renamed onionr dir and bugfixes/linting progress
This commit is contained in:
Kevin Froman
parent
2b996da17f
commit
720efe4fca
226 changed files with 179 additions and 142 deletions
252
src/onionrproofs/__init__.py
Executable file
252
src/onionrproofs/__init__.py
Executable file
|
|
@ -0,0 +1,252 @@
|
|||
'''
|
||||
Onionr - Private P2P Communication
|
||||
|
||||
Proof of work module
|
||||
'''
|
||||
'''
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
'''
|
||||
import multiprocessing, time, math, threading, binascii, sys, json
|
||||
import nacl.encoding, nacl.hash, nacl.utils
|
||||
|
||||
import config, logger
|
||||
from onionrblocks import onionrblockapi, storagecounter
|
||||
from onionrutils import bytesconverter
|
||||
from onionrcrypto import hashers
|
||||
config.reload()
|
||||
|
||||
def getDifficultyModifier():
|
||||
'''returns the difficulty modifier for block storage based
|
||||
on a variety of factors, currently only disk use.
|
||||
'''
|
||||
percentUse = storagecounter.StorageCounter().get_percent()
|
||||
difficultyIncrease = math.floor(4 * percentUse) # difficulty increase is a step function
|
||||
|
||||
return difficultyIncrease
|
||||
|
||||
def getDifficultyForNewBlock(data):
|
||||
'''
|
||||
Get difficulty for block. Accepts size in integer, Block instance, or str/bytes full block contents
|
||||
'''
|
||||
if isinstance(data, onionrblockapi.Block):
|
||||
dataSizeInBytes = len(bytesconverter.str_to_bytes(data.getRaw()))
|
||||
else:
|
||||
dataSizeInBytes = len(bytesconverter.str_to_bytes(data))
|
||||
|
||||
minDifficulty = config.get('general.minimum_send_pow', 4)
|
||||
totalDifficulty = max(minDifficulty, math.floor(dataSizeInBytes / 1000000.0)) + getDifficultyModifier()
|
||||
|
||||
return totalDifficulty
|
||||
|
||||
return retData
|
||||
|
||||
def getHashDifficulty(h: str):
|
||||
'''
|
||||
Return the amount of leading zeroes in a hex hash string (hexHash)
|
||||
'''
|
||||
return len(h) - len(h.lstrip('0'))
|
||||
|
||||
def hashMeetsDifficulty(hexHash):
|
||||
'''
|
||||
Return bool for a hash string to see if it meets pow difficulty defined in config
|
||||
'''
|
||||
hashDifficulty = getHashDifficulty(hexHash)
|
||||
|
||||
try:
|
||||
expected = int(config.get('general.minimum_block_pow'))
|
||||
except TypeError:
|
||||
raise ValueError('Missing general.minimum_block_pow config')
|
||||
|
||||
return hashDifficulty >= expected
|
||||
|
||||
class DataPOW:
|
||||
def __init__(self, data, minDifficulty = 0, threadCount = 1):
|
||||
self.data = data
|
||||
self.threadCount = threadCount
|
||||
self.difficulty = max(minDifficulty, getDifficultyForNewBlock(data))
|
||||
self.rounds = 0
|
||||
self.hashing = False
|
||||
self.foundHash = False
|
||||
|
||||
try:
|
||||
self.data = self.data.encode()
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
self.data = nacl.hash.blake2b(self.data)
|
||||
|
||||
logger.info('Computing POW (difficulty: %s)...' % self.difficulty)
|
||||
|
||||
self.mainHash = '0' * 70
|
||||
self.puzzle = self.mainHash[0:min(self.difficulty, len(self.mainHash))]
|
||||
|
||||
for i in range(max(1, threadCount)):
|
||||
t = threading.Thread(name = 'thread%s' % i, target = self.pow, args = (True,))
|
||||
t.start()
|
||||
|
||||
def pow(self, reporting = False):
|
||||
startTime = math.floor(time.time())
|
||||
self.hashing = True
|
||||
self.reporting = reporting
|
||||
iFound = False # if current thread is the one that found the answer
|
||||
|
||||
while self.hashing:
|
||||
rand = nacl.utils.random()
|
||||
token = nacl.hash.blake2b(rand + self.data).decode()
|
||||
self.rounds += 1
|
||||
#print(token)
|
||||
if self.puzzle == token[0:self.difficulty]:
|
||||
self.hashing = False
|
||||
iFound = True
|
||||
break
|
||||
|
||||
if iFound:
|
||||
endTime = math.floor(time.time())
|
||||
if self.reporting:
|
||||
logger.debug('Found token after %s seconds: %s' % (endTime - startTime, token), timestamp=True)
|
||||
logger.debug('Round count: %s' % (self.rounds,))
|
||||
self.result = (token, rand)
|
||||
|
||||
def shutdown(self):
|
||||
self.hashing = False
|
||||
self.puzzle = ''
|
||||
|
||||
def changeDifficulty(self, newDiff):
|
||||
self.difficulty = newDiff
|
||||
|
||||
def getResult(self):
|
||||
'''
|
||||
Returns the result then sets to false, useful to automatically clear the result
|
||||
'''
|
||||
|
||||
try:
|
||||
retVal = self.result
|
||||
except AttributeError:
|
||||
retVal = False
|
||||
|
||||
self.result = False
|
||||
return retVal
|
||||
|
||||
def waitForResult(self):
|
||||
'''
|
||||
Returns the result only when it has been found, False if not running and not found
|
||||
'''
|
||||
result = False
|
||||
try:
|
||||
while True:
|
||||
result = self.getResult()
|
||||
if not self.hashing:
|
||||
break
|
||||
else:
|
||||
time.sleep(1)
|
||||
except KeyboardInterrupt:
|
||||
self.shutdown()
|
||||
logger.warn('Got keyboard interrupt while waiting for POW result, stopping')
|
||||
return result
|
||||
|
||||
class POW:
|
||||
def __init__(self, metadata, data, threadCount = 1, minDifficulty=0):
|
||||
self.foundHash = False
|
||||
self.difficulty = 0
|
||||
self.data = data
|
||||
self.metadata = metadata
|
||||
self.threadCount = threadCount
|
||||
self.hashing = False
|
||||
|
||||
json_metadata = json.dumps(metadata).encode()
|
||||
|
||||
try:
|
||||
self.data = self.data.encode()
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
if minDifficulty > 0:
|
||||
self.difficulty = minDifficulty
|
||||
else:
|
||||
# Calculate difficulty. Dumb for now, may use good algorithm in the future.
|
||||
self.difficulty = getDifficultyForNewBlock(bytes(json_metadata + b'\n' + self.data))
|
||||
|
||||
logger.info('Computing POW (difficulty: %s)...' % (self.difficulty,))
|
||||
|
||||
self.mainHash = '0' * 64
|
||||
self.puzzle = self.mainHash[0:min(self.difficulty, len(self.mainHash))]
|
||||
|
||||
for i in range(max(1, threadCount)):
|
||||
t = threading.Thread(name = 'thread%s' % i, target = self.pow, args = (True,))
|
||||
t.start()
|
||||
|
||||
def pow(self, reporting = False):
|
||||
startTime = math.floor(time.time())
|
||||
self.hashing = True
|
||||
self.reporting = reporting
|
||||
iFound = False # if current thread is the one that found the answer
|
||||
nonce = int(binascii.hexlify(nacl.utils.random(64)), 16)
|
||||
while self.hashing:
|
||||
#token = nacl.hash.blake2b(rand + self.data).decode()
|
||||
self.metadata['pow'] = nonce
|
||||
payload = json.dumps(self.metadata).encode() + b'\n' + self.data
|
||||
token = hashers.sha3_hash(payload)
|
||||
try:
|
||||
# on some versions, token is bytes
|
||||
token = token.decode()
|
||||
except AttributeError:
|
||||
pass
|
||||
if self.puzzle == token[0:self.difficulty]:
|
||||
self.hashing = False
|
||||
iFound = True
|
||||
self.result = payload
|
||||
break
|
||||
nonce += 1
|
||||
|
||||
if iFound:
|
||||
endTime = math.floor(time.time())
|
||||
if self.reporting:
|
||||
logger.debug('Found token after %s seconds: %s' % (endTime - startTime, token), timestamp=True)
|
||||
|
||||
def shutdown(self):
|
||||
self.hashing = False
|
||||
self.puzzle = ''
|
||||
|
||||
def changeDifficulty(self, newDiff):
|
||||
self.difficulty = newDiff
|
||||
|
||||
def getResult(self):
|
||||
'''
|
||||
Returns the result then sets to false, useful to automatically clear the result
|
||||
'''
|
||||
|
||||
try:
|
||||
retVal = self.result
|
||||
except AttributeError:
|
||||
retVal = False
|
||||
|
||||
self.result = False
|
||||
return retVal
|
||||
|
||||
def waitForResult(self):
|
||||
'''
|
||||
Returns the result only when it has been found, False if not running and not found
|
||||
'''
|
||||
result = False
|
||||
try:
|
||||
while True:
|
||||
result = self.getResult()
|
||||
if not self.hashing:
|
||||
break
|
||||
else:
|
||||
time.sleep(1)
|
||||
except KeyboardInterrupt:
|
||||
self.shutdown()
|
||||
logger.warn('Got keyboard interrupt while waiting for POW result, stopping')
|
||||
return result
|
||||
132
src/onionrproofs/subprocesspow.py
Executable file
132
src/onionrproofs/subprocesspow.py
Executable file
|
|
@ -0,0 +1,132 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
Onionr - Private P2P Communication
|
||||
|
||||
Multiprocess proof of work
|
||||
"""
|
||||
|
||||
import os
|
||||
from multiprocessing import Pipe, Process
|
||||
import threading
|
||||
import time
|
||||
import json
|
||||
|
||||
import logger
|
||||
import onionrproofs
|
||||
import onionrcrypto as crypto
|
||||
from onionrutils import bytesconverter
|
||||
|
||||
"""
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
"""
|
||||
|
||||
|
||||
class SubprocessPOW:
|
||||
def __init__(self, data, metadata, subproc_count=None):
|
||||
"""
|
||||
Onionr proof of work using multiple processes
|
||||
Accepts block data, block metadata
|
||||
if subproc_count is not set,
|
||||
os.cpu_count() is used to determine the number of processes
|
||||
|
||||
Due to Python GIL multiprocessing/use of external libraries
|
||||
is necessary to accelerate CPU bound tasks
|
||||
"""
|
||||
# No known benefit to using more processes than there are cores.
|
||||
# Note: os.cpu_count perhaps not always accurate
|
||||
if subproc_count is None:
|
||||
subproc_count = os.cpu_count()
|
||||
self.subproc_count = subproc_count
|
||||
self.result = ''
|
||||
self.shutdown = False
|
||||
self.data = data
|
||||
self.metadata = metadata
|
||||
|
||||
"""dump dict to measure bytes of json metadata
|
||||
Cannot reuse later bc the pow token must be added
|
||||
"""
|
||||
json_metadata = json.dumps(metadata).encode()
|
||||
|
||||
self.data = bytesconverter.str_to_bytes(data)
|
||||
|
||||
compiled_data = bytes(json_metadata + b'\n' + self.data)
|
||||
|
||||
# Calculate difficulty. May use better algorithm in the future.
|
||||
self.difficulty = onionrproofs.getDifficultyForNewBlock(compiled_data)
|
||||
|
||||
logger.info('Computing POW (difficulty: %s)...' % (self.difficulty,))
|
||||
|
||||
self.main_hash = '0' * 64
|
||||
self.puzzle = self.main_hash[0:min(self.difficulty,
|
||||
len(self.main_hash))]
|
||||
self.shutdown = False
|
||||
self.payload = None
|
||||
|
||||
def start(self):
|
||||
"""spawn the multiproc handler threads"""
|
||||
# Create a new thread for each subprocess
|
||||
for _ in range(self.subproc_count): # noqa
|
||||
threading.Thread(target=self._spawn_proc).start()
|
||||
# Monitor the processes for a payload, shut them down when its found
|
||||
while True:
|
||||
if self.payload is None:
|
||||
time.sleep(0.1)
|
||||
else:
|
||||
self.shutdown = True
|
||||
return self.payload
|
||||
|
||||
def _spawn_proc(self):
|
||||
"""Create a child proof of work process
|
||||
wait for data and send shutdown signal when its found"""
|
||||
parent_conn, child_conn = Pipe()
|
||||
p = Process(target=self.do_pow, args=(child_conn,))
|
||||
p.start()
|
||||
p.join()
|
||||
payload = None
|
||||
try:
|
||||
while True:
|
||||
data = parent_conn.recv()
|
||||
if len(data) >= 1:
|
||||
payload = data
|
||||
break
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
parent_conn.send('shutdown')
|
||||
self.payload = payload
|
||||
|
||||
def do_pow(self, pipe):
|
||||
"""find partial hash colision generating nonce for a block"""
|
||||
nonce = -10000000
|
||||
data = self.data
|
||||
metadata = self.metadata
|
||||
puzzle = self.puzzle
|
||||
difficulty = self.difficulty
|
||||
while True:
|
||||
# Break if shutdown received
|
||||
if pipe.poll() and pipe.recv() == 'shutdown':
|
||||
break
|
||||
# Load nonce into block metadata
|
||||
metadata['pow'] = nonce
|
||||
# Serialize metadata, combine with block data
|
||||
payload = json.dumps(metadata).encode() + b'\n' + data
|
||||
# Check sha3_256 hash of block, compare to puzzle
|
||||
# Send payload if puzzle finished
|
||||
token = crypto.hashers.sha3_hash(payload)
|
||||
# ensure token is string
|
||||
token = bytesconverter.bytes_to_str(token)
|
||||
if puzzle == token[0:difficulty]:
|
||||
pipe.send(payload)
|
||||
break
|
||||
nonce += 1
|
||||
Loading…
Add table
Add a link
Reference in a new issue