Onionr/src/onionrblocks/onionrblockapi.py

496 lines
16 KiB
Python
Raw Normal View History

"""Onionr - P2P Anonymous Storage Network.
2018-05-15 06:43:29 +00:00
OnionrBlocks class for abstraction of blocks
"""
import binascii
import os
import datetime
import onionrstorage
import unpaddedbase32
import ujson as json
import nacl.exceptions
import logger
import onionrexceptions
from onionrusers import onionrusers
from onionrutils import stringvalidators, epoch
from coredb import blockmetadb
from onionrutils import bytesconverter
from onionrstorage import removeblock
import onionrblocks
from onionrcrypto import encryption, cryptoutils as cryptoutils, signing
"""
2018-05-15 06:43:29 +00:00
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/>.
"""
2018-05-15 06:43:29 +00:00
class Block:
2018-06-14 04:17:58 +00:00
blockCacheOrder = list() # NEVER write your own code that writes to this!
blockCache = dict() # should never be accessed directly, look at Block.getCache()
2019-07-19 19:49:56 +00:00
def __init__(self, hash = None, type = None, content = None, expire=None, decrypt=False, bypassReplayCheck=False):
2018-06-20 04:36:07 +00:00
# take from arguments
# sometimes people input a bytes object instead of str in `hash`
2018-08-04 03:47:56 +00:00
if (not hash is None) and isinstance(hash, bytes):
hash = hash.decode()
2018-06-20 04:36:07 +00:00
self.hash = hash
self.btype = type
self.bcontent = content
2018-09-30 16:53:39 +00:00
self.expire = expire
self.bypassReplayCheck = bypassReplayCheck
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
# initialize variables
self.valid = True
self.raw = None
self.signed = False
self.signature = None
self.signedData = None
2018-05-16 03:08:42 +00:00
self.blockFile = None
2018-05-16 01:47:58 +00:00
self.bheader = {}
self.bmetadata = {}
self.isEncrypted = False
self.decrypted = False
self.signer = None
self.validSig = False
self.autoDecrypt = decrypt
2018-05-16 01:47:58 +00:00
self.update()
2018-05-15 06:43:29 +00:00
2019-02-17 20:21:03 +00:00
def decrypt(self, encodedData = True):
"""
2018-07-30 00:37:12 +00:00
Decrypt a block, loading decrypted data into their vars
"""
if self.decrypted:
return True
retData = False
2018-07-17 07:18:17 +00:00
# decrypt data
if self.getHeader('encryptType') == 'asym':
try:
try:
self.bcontent = encryption.pub_key_decrypt(self.bcontent, encodedData=encodedData)
2019-09-12 06:28:20 +00:00
except (binascii.Error, ValueError) as e:
self.bcontent = encryption.pub_key_decrypt(self.bcontent, encodedData=False)
2019-07-20 00:01:16 +00:00
bmeta = encryption.pub_key_decrypt(self.bmetadata, encodedData=encodedData)
try:
bmeta = bmeta.decode()
except AttributeError:
# yet another bytes fix
pass
self.bmetadata = json.loads(bmeta)
2019-07-20 00:01:16 +00:00
self.signature = encryption.pub_key_decrypt(self.signature, encodedData=encodedData)
self.signer = encryption.pub_key_decrypt(self.signer, encodedData=encodedData)
self.bheader['signer'] = self.signer.decode()
self.signedData = json.dumps(self.bmetadata).encode() + self.bcontent
if not self.signer is None:
if not self.verifySig():
raise onionrexceptions.SignatureError("Block has invalid signature")
# Check for replay attacks
try:
if epoch.get_epoch() - blockmetadb.get_block_date(self.hash) > 60:
if not cryptoutils.replay_validator(self.bmetadata['rply']): raise onionrexceptions.ReplayAttack
except (AssertionError, KeyError, TypeError, onionrexceptions.ReplayAttack) as e:
if not self.bypassReplayCheck:
# Zero out variables to prevent reading of replays
self.bmetadata = {}
self.signer = ''
self.bheader['signer'] = ''
self.signedData = ''
self.signature = ''
raise onionrexceptions.ReplayAttack('Signature is too old. possible replay attack')
2018-10-08 02:25:59 +00:00
try:
if not self.bmetadata['forwardEnc']: raise KeyError
2018-10-08 02:25:59 +00:00
except (AssertionError, KeyError) as e:
pass
else:
2018-10-08 05:11:46 +00:00
try:
2019-07-19 19:49:56 +00:00
self.bcontent = onionrusers.OnionrUser(self.signer).forwardDecrypt(self.bcontent)
2018-10-09 23:36:52 +00:00
except (onionrexceptions.DecryptionError, nacl.exceptions.CryptoError) as e:
2019-08-06 03:10:21 +00:00
#logger.error(str(e))
2018-10-08 05:11:46 +00:00
pass
except nacl.exceptions.CryptoError:
pass
#logger.debug('Could not decrypt block. Either invalid key or corrupted data')
except onionrexceptions.ReplayAttack:
logger.warn('%s is possibly a replay attack' % (self.hash,))
else:
retData = True
self.decrypted = True
return retData
2018-07-30 00:37:12 +00:00
def verifySig(self):
"""
2018-07-30 00:37:12 +00:00
Verify if a block's signature is signed by its claimed signer
"""
if self.signer is None:
return False
if signing.ed_verify(data=self.signedData, key=self.signer, sig=self.signature, encodedData=True):
self.validSig = True
else:
self.validSig = False
return self.validSig
2018-07-17 07:18:17 +00:00
2018-05-15 06:43:29 +00:00
def update(self, data = None, file = None):
"""
2018-05-15 06:43:29 +00:00
Loads data from a block in to the current object.
Inputs:
- data (str):
- if None: will load from file by hash
- else: will load from `data` string
- file (str):
- if None: will load from file specified in this parameter
- else: will load from wherever block is stored by hash
Outputs:
- (bool): indicates whether or not the operation was successful
"""
2018-05-16 01:47:58 +00:00
try:
# import from string
blockdata = data
# import from file
if blockdata is None:
2019-02-22 21:04:03 +00:00
try:
blockdata = onionrstorage.getData(self.getHash())#.decode()
2019-02-22 21:04:03 +00:00
except AttributeError:
raise onionrexceptions.NoDataAvailable('Block does not exist')
2018-05-16 01:47:58 +00:00
else:
self.blockFile = None
# parse block
self.raw = blockdata
self.bheader = json.loads(self.getRaw()[:self.getRaw().index(b'\n')])
self.bcontent = self.getRaw()[self.getRaw().index(b'\n') + 1:]
2018-09-27 00:40:02 +00:00
if ('encryptType' in self.bheader) and (self.bheader['encryptType'] in ('asym', 'sym')):
self.bmetadata = self.getHeader('meta', None)
self.isEncrypted = True
else:
self.bmetadata = json.loads(self.getHeader('meta', None))
2018-06-20 04:36:07 +00:00
self.btype = self.getMetadata('type', None)
2018-05-16 01:47:58 +00:00
self.signed = ('sig' in self.getHeader() and self.getHeader('sig') != '')
# TODO: detect if signer is hash of pubkey or not
self.signer = self.getHeader('signer', None)
2018-06-20 04:36:07 +00:00
self.signature = self.getHeader('sig', None)
# signed data is jsonMeta + block content (no linebreak)
self.signedData = (None if not self.isSigned() else self.getHeader('meta').encode() + self.getContent())
self.date = blockmetadb.get_block_date(self.getHash())
self.claimedTime = self.getHeader('time', None)
2018-05-16 01:47:58 +00:00
if not self.getDate() is None:
self.date = datetime.datetime.fromtimestamp(self.getDate())
self.valid = True
if self.autoDecrypt:
self.decrypt()
2018-06-14 04:17:58 +00:00
2018-05-16 01:47:58 +00:00
return True
except Exception as e:
2019-09-04 06:20:11 +00:00
logger.warn('Failed to parse block %s' % self.getHash(), error = e, timestamp = False)
2018-09-25 04:16:51 +00:00
# if block can't be parsed, it's a waste of precious space. Throw it away.
if not self.delete():
2019-02-22 21:04:03 +00:00
logger.warn('Failed to delete invalid block %s.' % self.getHash(), error = e)
2018-09-27 00:40:02 +00:00
else:
logger.debug('Deleted invalid block %s.' % self.getHash(), timestamp = False)
2018-05-16 01:47:58 +00:00
self.valid = False
2018-05-15 06:43:29 +00:00
return False
def delete(self):
"""
2018-05-16 02:12:23 +00:00
Deletes the block's file and records, if they exist
Outputs:
- (bool): whether or not the operation was successful
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
if self.exists():
try:
os.remove(self.getBlockFile())
except TypeError:
pass
2019-09-04 06:20:11 +00:00
b_hash = self.getHash()
onionrstorage.deleteBlock(b_hash)
removeblock.remove_block(b_hash)
2018-05-16 01:47:58 +00:00
return True
2018-05-15 06:43:29 +00:00
return False
2018-05-16 02:12:23 +00:00
def save(self, sign = False, recreate = True):
"""
2018-05-16 02:12:23 +00:00
Saves a block to file and imports it into Onionr
Inputs:
- sign (bool): whether or not to sign the block before saving
- recreate (bool): if the block already exists, whether or not to recreate the block and save under a new hash
Outputs:
- (bool): whether or not the operation was successful
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
try:
if self.isValid() is True:
2019-07-19 19:49:56 +00:00
self.hash = onionrblocks.insert(self.getRaw(), header = self.getType(), sign = sign, meta = self.getMetadata(), expire = self.getExpire())
2018-12-24 06:12:46 +00:00
if self.hash != False:
self.update()
2018-07-30 00:37:12 +00:00
2018-05-19 22:21:35 +00:00
return self.getHash()
2018-05-16 01:47:58 +00:00
else:
logger.warn('Not writing block; it is invalid.')
except Exception as e:
logger.error('Failed to save block.', error = e, timestamp = False)
2018-07-30 00:37:12 +00:00
return False
2018-05-15 06:43:29 +00:00
# getters
2018-10-02 05:02:05 +00:00
def getExpire(self):
"""
2018-10-02 05:02:05 +00:00
Returns the expire time for a block
Outputs:
- (int): the expire time for a block, or None
"""
2018-10-02 05:02:05 +00:00
return self.expire
2018-05-15 06:43:29 +00:00
def getHash(self):
"""
2018-05-16 02:12:23 +00:00
Returns the hash of the block if saved to file
Outputs:
- (str): the hash of the block, or None
"""
2018-05-16 02:12:23 +00:00
2018-05-15 06:43:29 +00:00
return self.hash
def getType(self):
"""
2018-05-16 02:12:23 +00:00
Returns the type of the block
Outputs:
- (str): the type of the block
"""
2018-05-15 06:43:29 +00:00
return self.btype
2018-05-16 01:47:58 +00:00
def getRaw(self):
"""
2018-05-16 02:12:23 +00:00
Returns the raw contents of the block, if saved to file
Outputs:
- (bytes): the raw contents of the block, or None
"""
2018-05-16 02:12:23 +00:00
return self.raw
2018-05-16 01:47:58 +00:00
2018-06-20 04:36:07 +00:00
def getHeader(self, key = None, default = None):
"""
2018-05-16 02:12:23 +00:00
Returns the header information
Inputs:
- key (str): only returns the value of the key in the header
Outputs:
- (dict/str): either the whole header as a dict, or one value
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
if not key is None:
2018-06-20 04:36:07 +00:00
if key in self.getHeader():
return self.getHeader()[key]
return default
return self.bheader
2018-05-16 01:47:58 +00:00
2018-06-20 04:36:07 +00:00
def getMetadata(self, key = None, default = None):
"""
2018-05-16 02:12:23 +00:00
Returns the metadata information
Inputs:
- key (str): only returns the value of the key in the metadata
Outputs:
- (dict/str): either the whole metadata as a dict, or one value
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
if not key is None:
2018-06-20 04:36:07 +00:00
if key in self.getMetadata():
return self.getMetadata()[key]
return default
return self.bmetadata
2018-05-15 06:43:29 +00:00
def getContent(self):
"""
2018-05-16 02:12:23 +00:00
Returns the contents of the block
Outputs:
- (str): the contents of the block
"""
2018-05-16 02:12:23 +00:00
return self.bcontent
2018-06-05 02:26:04 +00:00
2018-05-15 06:43:29 +00:00
def getDate(self):
"""
2018-05-16 02:12:23 +00:00
Returns the date that the block was received, if loaded from file
Outputs:
- (datetime): the date that the block was received
"""
2018-05-16 02:12:23 +00:00
2018-05-15 06:43:29 +00:00
return self.date
2018-05-16 01:47:58 +00:00
def getBlockFile(self):
"""
2018-05-16 02:12:23 +00:00
Returns the location of the block file if it is saved
Outputs:
- (str): the location of the block file, or None
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
return self.blockFile
2018-05-15 06:43:29 +00:00
def isValid(self):
"""
2018-05-16 02:12:23 +00:00
Checks if the block is valid
Outputs:
- (bool): whether or not the block is valid
"""
2018-05-16 02:12:23 +00:00
2018-05-15 06:43:29 +00:00
return self.valid
def isSigned(self):
"""
2018-05-16 02:12:23 +00:00
Checks if the block was signed
Outputs:
- (bool): whether or not the block is signed
"""
2018-05-16 02:12:23 +00:00
2018-05-15 06:43:29 +00:00
return self.signed
2018-05-16 01:47:58 +00:00
def getSignature(self):
"""
2018-05-16 02:12:23 +00:00
Returns the base64-encoded signature
Outputs:
- (str): the signature, or None
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
return self.signature
def getSignedData(self):
"""
2018-05-16 02:12:23 +00:00
Returns the data that was signed
Outputs:
- (str): the data that was signed, or None
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
return self.signedData
def isSigner(self, signer, encodedData = True):
"""
2018-05-16 02:12:23 +00:00
Checks if the block was signed by the signer inputted
Inputs:
- signer (str): the public key of the signer to check against
- encodedData (bool): whether or not the `signer` argument is base64 encoded
Outputs:
- (bool): whether or not the signer of the block is the signer inputted
"""
signer = unpaddedbase32.repad(bytesconverter.str_to_bytes(signer))
2018-05-16 01:47:58 +00:00
try:
if (not self.isSigned()) or (not stringvalidators.validate_pub_key(signer)):
2018-05-16 01:47:58 +00:00
return False
2019-07-20 00:01:16 +00:00
return bool(signing.ed_verify(self.getSignedData(), signer, self.getSignature(), encodedData = encodedData))
2018-05-16 01:47:58 +00:00
except:
return False
2018-05-15 06:43:29 +00:00
# setters
def setType(self, btype):
"""
2018-05-16 02:12:23 +00:00
Sets the type of the block
Inputs:
- btype (str): the type of block to be set to
Outputs:
- (Block): the Block instance
"""
2018-05-16 02:12:23 +00:00
2018-05-15 06:43:29 +00:00
self.btype = btype
return self
2018-06-05 02:26:04 +00:00
def setMetadata(self, key, val):
"""
Sets a custom metadata value
2018-06-05 02:26:04 +00:00
Metadata should not store block-specific data structures.
2018-06-05 02:26:04 +00:00
Inputs:
- key (str): the key
- val: the value (type is irrelevant)
2018-06-05 02:26:04 +00:00
Outputs:
- (Block): the Block instance
"""
2018-06-05 02:26:04 +00:00
self.bmetadata[key] = val
return self
2018-05-15 06:43:29 +00:00
def setContent(self, bcontent):
"""
2018-05-16 02:12:23 +00:00
Sets the contents of the block
Inputs:
- bcontent (str): the contents to be set to
Outputs:
- (Block): the Block instance
"""
2018-05-16 02:12:23 +00:00
2018-05-16 01:47:58 +00:00
self.bcontent = str(bcontent)
2018-05-15 06:43:29 +00:00
return self
2018-06-05 02:26:04 +00:00
# static functions
def exists(bHash):
"""
2018-05-16 02:12:23 +00:00
Checks if a block is saved to file or not
Inputs:
- hash (str/Block):
- if (Block): check if this block is saved to file
- if (str): check if a block by this hash is in file
Outputs:
- (bool): whether or not the block file exists
"""
2018-05-16 02:12:23 +00:00
2018-06-14 04:17:58 +00:00
# no input data? scrap it.
if bHash is None:
2018-05-16 01:47:58 +00:00
return False
2019-07-19 19:49:56 +00:00
if isinstance(bHash, Block):
bHash = bHash.getHash()
2019-07-19 19:49:56 +00:00
ret = isinstance(onionrstorage.getData(bHash), type(None))
2018-05-16 01:47:58 +00:00
return not ret