''' Onionr - P2P Anonymous Storage Network This file handles all incoming http requests to the client, using Flask ''' ''' 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 . ''' from gevent.pywsgi import WSGIServer, WSGIHandler from gevent import Timeout import flask, cgi from flask import request, Response, abort, send_from_directory import sys, random, threading, hmac, hashlib, base64, time, math, os, json, socket import core from onionrblockapi import Block import onionrutils, onionrexceptions, onionrcrypto, blockimporter, onionrevents as events, logger, config, onionr class FDSafeHandler(WSGIHandler): def handle(self): timeout = Timeout(60, exception=Exception) timeout.start() #timeout = gevent.Timeout.start_new(3) try: WSGIHandler.handle(self) except Timeout as ex: raise def guessMime(path): ''' Guesses the mime type of a file from the input filename ''' mimetypes = { 'html' : 'text/html', 'js' : 'application/javascript', 'css' : 'text/css', 'png' : 'image/png', 'jpg' : 'image/jpeg' } for mimetype in mimetypes: if path.endswith('.%s' % mimetype): return mimetypes[mimetype] return 'text/plain' def setBindIP(filePath): '''Set a random localhost IP to a specified file (intended for private or public API localhost IPs)''' hostOctets = [str(127), str(random.randint(0x02, 0xFF)), str(random.randint(0x02, 0xFF)), str(random.randint(0x02, 0xFF))] data = '.'.join(hostOctets) # Try to bind IP. Some platforms like Mac block non normal 127.x.x.x s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.bind((data, 0)) except OSError: logger.warn('Your platform appears to not support random local host addresses 127.x.x.x. Falling back to 127.0.0.1.') data = '127.0.0.1' s.close() with open(filePath, 'w') as bindFile: bindFile.write(data) return data class PublicAPI: ''' The new client api server, isolated from the public api ''' def __init__(self, clientAPI): assert isinstance(clientAPI, API) app = flask.Flask('PublicAPI') self.i2pEnabled = config.get('i2p.host', False) self.hideBlocks = [] # Blocks to be denied sharing self.host = setBindIP(clientAPI._core.publicApiHostFile) self.torAdder = clientAPI._core.hsAddress self.i2pAdder = clientAPI._core.i2pAddress self.bindPort = config.get('client.public.port') logger.info('Running public api on %s:%s' % (self.host, self.bindPort)) @app.before_request def validateRequest(): '''Validate request has the correct hostname''' # If high security level, deny requests to public if config.get('general.security_level', default=0) > 0: abort(403) if type(self.torAdder) is None and type(self.i2pAdder) is None: # abort if our hs addresses are not known abort(403) if request.host not in (self.i2pAdder, self.torAdder): abort(403) @app.after_request def sendHeaders(resp): '''Send api, access control headers''' resp.headers['Date'] = 'Thu, 1 Jan 1970 00:00:00 GMT' # Clock info is probably useful to attackers. Set to unix epoch. resp.headers["Content-Security-Policy"] = "default-src 'none'; script-src 'none'; object-src 'none'; style-src data: 'unsafe-inline'; img-src data:; media-src 'none'; frame-src 'none'; font-src 'none'; connect-src 'none'" resp.headers['X-Frame-Options'] = 'deny' resp.headers['X-Content-Type-Options'] = "nosniff" resp.headers['X-API'] = onionr.API_VERSION resp.headers['Connection'] = "close" return resp @app.route('/') def banner(): try: with open('static-data/index.html', 'r') as html: resp = Response(html.read(), mimetype='text/html') except FileNotFoundError: resp = Response("") return resp @app.route('/getblocklist') def getBlockList(): dateAdjust = request.args.get('date') bList = clientAPI._core.getBlockList(dateRec=dateAdjust) for b in self.hideBlocks: if b in bList: bList.remove(b) return Response('\n'.join(bList)) @app.route('/getdata/') def getBlockData(name): resp = '' data = name if clientAPI._utils.validateHash(data): if data not in self.hideBlocks: if data in clientAPI._core.getBlockList(): block = clientAPI.getBlockData(data, raw=True).encode() resp = base64.b64encode(block).decode() if len(resp) == 0: abort(404) resp = "" return Response(resp) @app.route('/www/') def wwwPublic(path): if not config.get("www.public.run", True): abort(403) return send_from_directory(config.get('www.public.path', 'static-data/www/public/'), path) @app.route('/ping') def ping(): return Response("pong!") @app.route('/getdbhash') def getDBHash(): return Response(clientAPI._utils.getBlockDBHash()) @app.route('/pex') def peerExchange(): response = ','.join(clientAPI._core.listAdders(recent=3600)) if len(response) == 0: response = '' return Response(response) @app.route('/announce', methods=['post']) def acceptAnnounce(): resp = 'failure' powHash = '' randomData = '' newNode = '' ourAdder = clientAPI._core.hsAddress.encode() try: newNode = request.form['node'].encode() except KeyError: logger.warn('No block specified for upload') pass else: try: randomData = request.form['random'] randomData = base64.b64decode(randomData) except KeyError: logger.warn('No random data specified for upload') else: nodes = newNode + clientAPI._core.hsAddress.encode() nodes = clientAPI._core._crypto.blake2bHash(nodes) powHash = clientAPI._core._crypto.blake2bHash(randomData + nodes) try: powHash = powHash.decode() except AttributeError: pass if powHash.startswith('0000'): try: newNode = newNode.decode() except AttributeError: pass if clientAPI._core.addAddress(newNode): resp = 'Success' else: logger.warn(newNode.decode() + ' failed to meet POW: ' + powHash) resp = Response(resp) return resp @app.route('/upload', methods=['post']) def upload(): resp = 'failure' try: data = request.form['block'] except KeyError: logger.warn('No block specified for upload') pass else: if sys.getsizeof(data) < 100000000: try: if blockimporter.importBlockFromData(data, clientAPI._core): resp = 'success' else: logger.warn('Error encountered importing uploaded block') except onionrexceptions.BlacklistedBlock: logger.debug('uploaded block is blacklisted') pass if resp == 'failure': abort(400) resp = Response(resp) return resp clientAPI.setPublicAPIInstance(self) while self.torAdder == '': clientAPI._core.refreshFirstStartVars() self.torAdder = clientAPI._core.hsAddress time.sleep(1) self.httpServer = WSGIServer((self.host, self.bindPort), app, log=None, handler_class=FDSafeHandler) self.httpServer.serve_forever() class API: ''' Client HTTP api ''' callbacks = {'public' : {}, 'private' : {}} def __init__(self, onionrInst, debug, API_VERSION): ''' Initialize the api server, preping variables for later use This initilization defines all of the API entry points and handlers for the endpoints and errors This also saves the used host (random localhost IP address) to the data folder in host.txt ''' # assert isinstance(onionrInst, onionr.Onionr) # configure logger and stuff onionr.Onionr.setupConfig('data/', self = self) self.debug = debug self._privateDelayTime = 3 self._core = onionrInst.onionrCore self.startTime = self._core._utils.getEpoch() self._crypto = onionrcrypto.OnionrCrypto(self._core) self._utils = onionrutils.OnionrUtils(self._core) app = flask.Flask(__name__) bindPort = int(config.get('client.client.port', 59496)) self.bindPort = bindPort # Be extremely mindful of this self.whitelistEndpoints = ('site', 'www', 'onionrhome', 'board', 'boardContent', 'sharedContent', 'mail', 'mailindex') self.clientToken = config.get('client.webpassword') self.timeBypassToken = base64.b16encode(os.urandom(32)).decode() self.publicAPI = None # gets set when the thread calls our setter... bad hack but kinda necessary with flask #threading.Thread(target=PublicAPI, args=(self,)).start() self.host = setBindIP(self._core.privateApiHostFile) logger.info('Running api on %s:%s' % (self.host, self.bindPort)) self.httpServer = '' self.queueResponse = {} onionrInst.setClientAPIInst(self) @app.before_request def validateRequest(): '''Validate request has set password and is the correct hostname''' if request.host != '%s:%s' % (self.host, self.bindPort): abort(403) if request.endpoint in self.whitelistEndpoints: return try: if not hmac.compare_digest(request.headers['token'], self.clientToken): abort(403) except KeyError: abort(403) @app.after_request def afterReq(resp): #resp.headers["Content-Security-Policy"] = "default-src 'none'; script-src 'none'; object-src 'none'; style-src data: 'unsafe-inline'; img-src data:; media-src 'none'; frame-src 'none'; font-src 'none'; connect-src 'none'" resp.headers['Content-Security-Policy'] = "default-src 'none'; script-src 'self'; object-src 'none'; style-src 'self'; img-src 'self'; media-src 'none'; frame-src 'none'; font-src 'none'; connect-src 'self'" resp.headers['X-Frame-Options'] = 'deny' resp.headers['X-Content-Type-Options'] = "nosniff" resp.headers['X-API'] = onionr.API_VERSION resp.headers['Server'] = '' resp.headers['Date'] = 'Thu, 1 Jan 1970 00:00:00 GMT' # Clock info is probably useful to attackers. Set to unix epoch. resp.headers['Connection'] = "close" return resp @app.route('/board/', endpoint='board') def loadBoard(): return send_from_directory('static-data/www/board/', "index.html") @app.route('/mail/', endpoint='mail') def loadMail(path): return send_from_directory('static-data/www/mail/', path) @app.route('/mail/', endpoint='mailindex') def loadMailIndex(): return send_from_directory('static-data/www/mail/', 'index.html') @app.route('/board/', endpoint='boardContent') def boardContent(path): return send_from_directory('static-data/www/board/', path) @app.route('/shared/', endpoint='sharedContent') def sharedContent(path): return send_from_directory('static-data/www/shared/', path) @app.route('/www/', endpoint='www') def wwwPublic(path): if not config.get("www.private.run", True): abort(403) return send_from_directory(config.get('www.private.path', 'static-data/www/private/'), path) @app.route('/queueResponseAdd/', methods=['post']) def queueResponseAdd(name): self.queueResponse[name] = request.form['data'] return Response('success') @app.route('/queueResponse/') def queueResponse(name): resp = 'failure' try: resp = self.queueResponse[name] except KeyError: pass else: del self.queueResponse[name] return Response(resp) @app.route('/ping') def ping(): return Response("pong!") @app.route('/', endpoint='onionrhome') def hello(): return send_from_directory('static-data/www/private/', 'index.html') @app.route('/getblocksbytype/') def getBlocksByType(name): blocks = self._core.getBlocksByType(name) return Response(','.join(blocks)) @app.route('/getblockbody/') def getBlockBodyData(name): resp = '' if self._core._utils.validateHash(name): try: resp = Block(name, decrypt=True).bcontent #resp = cgi.escape(Block(name, decrypt=True).bcontent, quote=True) except TypeError: pass else: abort(404) return Response(resp) @app.route('/getblockdata/') def getData(name): resp = "" if self._core._utils.validateHash(name): if name in self._core.getBlockList(): try: resp = self.getBlockData(name, decrypt=True) except ValueError: pass else: abort(404) else: abort(404) return Response(resp) @app.route('/getblockheader/') def getBlockHeader(name): resp = self.getBlockData(name, decrypt=True, headerOnly=True) return Response(resp) @app.route('/site/', endpoint='site') def site(name): bHash = name resp = 'Not Found' if self._core._utils.validateHash(bHash): try: resp = Block(bHash).bcontent except TypeError: pass try: resp = base64.b64decode(resp) except: pass if resp == 'Not Found': abourt(404) return Response(resp) @app.route('/waitforshare/', methods=['post']) def waitforshare(): assert name.isalnum() if name in self.publicAPI.hideBlocks: self.publicAPI.hideBlocks.remove(name) return Response("removed") else: self.publicAPI.hideBlocks.append(name) return Response("added") @app.route('/shutdown') def shutdown(): try: self.publicAPI.httpServer.stop() self.httpServer.stop() except AttributeError: pass return Response("bye") @app.route('/shutdownclean') def shutdownClean(): # good for calling from other clients self._core.daemonQueueAdd('shutdown') return Response("bye") @app.route('/getstats') def getStats(): #return Response("disabled") while True: try: return Response(self._core.serializer.getStats()) except AttributeError: pass @app.route('/getuptime') def showUptime(): return Response(str(self.getUptime())) @app.route('/getActivePubkey') def getActivePubkey(): return Response(self._core._crypto.pubKey) @app.route('/getHumanReadable/') def getHumanReadable(name): return Response(self._core._utils.getHumanReadableID(name)) self.httpServer = WSGIServer((self.host, bindPort), app, log=None, handler_class=FDSafeHandler) self.httpServer.serve_forever() def setPublicAPIInstance(self, inst): assert isinstance(inst, PublicAPI) self.publicAPI = inst def validateToken(self, token): ''' Validate that the client token matches the given token ''' if len(self.clientToken) == 0: logger.error("client password needs to be set") return False try: if not hmac.compare_digest(self.clientToken, token): return False else: return True except TypeError: return False def getUptime(self): while True: try: return self._utils.getEpoch - startTime except AttributeError: # Don't error on race condition with startup pass def getBlockData(self, bHash, decrypt=False, raw=False, headerOnly=False): assert self._core._utils.validateHash(bHash) bl = Block(bHash, core=self._core) if decrypt: bl.decrypt() if bl.isEncrypted and not bl.decrypted: raise ValueError if not raw: if not headerOnly: retData = {'meta':bl.bheader, 'metadata': bl.bmetadata, 'content': bl.bcontent} for x in list(retData.keys()): try: retData[x] = retData[x].decode() except AttributeError: pass else: bl.bheader['meta'] = '' retData = {'meta': bl.bheader, 'metadata': bl.bmetadata} return json.dumps(retData) else: return bl.raw