def get_ssl_cert(): server_key = join_with_rc(config.proxy.server_key) server_crt = join_with_rc(config.proxy.server_crt) if not os.path.isfile(server_key): logger.info("SSL key/cert file not found, " + "run local self-test by default") server_key_sample = 'cpchain/assets/proxy/key/server.key' server_crt_sample = 'cpchain/assets/proxy/key/server.crt' server_key = join_with_root(server_key_sample) server_crt = join_with_root(server_crt_sample) return server_key, server_crt
def clean_up_old_data(self, ): global _clean_up_db # pylint: disable=global-statement if not _clean_up_db: _clean_up_db = True # init database db_path = join_with_rc(config.proxy.dbpath) if os.path.isfile(db_path): os.remove(db_path) # clean server_root server_root = join_with_rc(config.proxy.server_root) for root, dirs, files in os.walk(server_root, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name))
class FileServerResource(Resource): isLeaf = True server_root = join_with_rc(config.proxy.server_root) os.makedirs(server_root, exist_ok=True) proxy_db = ProxyDB() def render_GET(self, request): path = request.path.decode().strip('/') # don't expose the file list under root dir # for security consideration if path == '': return ForbiddenResource().render(request) file_path = os.path.join(self.server_root, path) return File(file_path).render(request) def render_POST(self, request): server_root = join_with_rc(config.proxy.server_root) file_name = str(uuid()) file_path = os.path.join(server_root, file_name) with open(file_path, 'wb') as f: f.write(request.content.read()) return file_name.encode('utf8')
def render_POST(self, request): server_root = join_with_rc(config.proxy.server_root) file_name = str(uuid()) file_path = os.path.join(server_root, file_name) with open(file_path, 'wb') as f: f.write(request.content.read()) return file_name.encode('utf8')
def buyer_send_request(self, order_info): logger.debug("buyer send request to proxy ...") order_id = list(order_info.keys())[0] new_order_info = order_info[order_id] seller_addr = eth_addr_to_string(new_order_info[3]) buyer_addr = eth_addr_to_string(new_order_info[2]) proxy_id = eth_addr_to_string(new_order_info[4]) message = Message() buyer_data = message.buyer_data message.type = Message.BUYER_DATA buyer_data.order_id = order_id buyer_data.order_type = 'file' buyer_data.seller_addr = seller_addr buyer_data.buyer_addr = buyer_addr buyer_data.market_hash = Encoder.bytes_to_base64_str(new_order_info[0]) sign_message = SignMessage() sign_message.public_key = self.wallet.market_client.public_key sign_message.data = message.SerializeToString() sign_message.signature = ECCipher.create_signature( self.wallet.market_client.account.private_key, sign_message.data) error, AES_key, urls = yield start_proxy_request( sign_message, proxy_id) def update_buyer_db(file_uri, file_path): market_hash = Encoder.bytes_to_base64_str(new_order_info[0]) file_uuid = file_uri.split('/')[3] session = get_session() session.query(BuyerFileInfo).filter( BuyerFileInfo.order_id == order_id).update( { BuyerFileInfo.market_hash: market_hash, BuyerFileInfo.is_downloaded: True, BuyerFileInfo.file_uuid: file_uuid, BuyerFileInfo.path: file_path, BuyerFileInfo.size: os.path.getsize(file_path) }, synchronize_session=False) session.commit() if error: logger.error(error) else: file_name = urls[0].split('/')[3] file_dir = join_with_rc(config.wallet.download_dir) # create if not exists os.makedirs(file_dir, exist_ok=True) file_path = os.path.join(file_dir, file_name) yield download_proxy_file(urls[0], file_path) logger.debug("downloaded file path: %s", file_path) decrypted_file = decrypt_file_aes(file_path, AES_key) logger.debug('Decrypted file path: %s', str(decrypted_file)) update_buyer_db(urls[0], decrypted_file) logger.debug("file has been downloaded") logger.debug("put order into confirmed queue, order id: %s", order_id) event.emit(events.BUYER_RECEIVE, order_id)
def start_service(self, ip=None, ctrl_port=None, data_port=None, account_id=0): self.ip = ip set_proxy_account(account_id) self.peer_id = get_proxy_id() server_key = os.path.expanduser(join_with_rc(config.proxy.server_key)) server_crt = os.path.expanduser(join_with_rc(config.proxy.server_crt)) if not os.path.isfile(server_key): logger.info("SSL key/cert file not found, " + "run local self-test by default") server_key_sample = 'cpchain/assets/proxy/key/server.key' server_crt_sample = 'cpchain/assets/proxy/key/server.crt' server_key = join_with_root(server_key_sample) server_crt = join_with_root(server_crt_sample) # data channel data_port = (data_port or config.proxy.server_data_port) file_factory = Site(FileServer()) reactor.listenSSL( data_port, file_factory, ssl.DefaultOpenSSLContextFactory(server_key, server_crt)) # ctrl channel ctrl_port = (ctrl_port or config.proxy.server_ctrl_port) ctrl_factory = SSLServerFactory(data_port=data_port) reactor.listenSSL( ctrl_port, ctrl_factory, ssl.DefaultOpenSSLContextFactory(server_key, server_crt)) self.service_port = ctrl_port def set_proxy_ip(): if self.ip is None: # waiting for node bootstrap finish return reactor.callLater(1, set_proxy_ip) ctrl_factory.set_external_ip(self.ip) set_proxy_ip()
def get_file_list(): """This returns a list of files. """ dbpath = join_with_rc(config.wallet.dbpath) engine = create_engine('sqlite:///{dbpath}'.format(dbpath=dbpath), echo=True) Session = sessionmaker(bind=engine) session = Session() return session.query(FileInfo).all()
class ProxyDB(object): db_path = join_with_rc(config.proxy.dbpath) db_path = os.path.expanduser(db_path) default_db = 'sqlite:///' + db_path def __init__(self, db=default_db): self.engine = create_engine(db, echo=False) Base.metadata.create_all(self.engine) self.session = None def session_create(self): Session = sessionmaker(bind=self.engine) self.session = Session() def count(self, trade): count = self.session.query(Trade).filter( Trade.order_id == trade.order_id).count() return count def query(self, trade): return self.session.query(Trade).filter( Trade.order_id == trade.order_id).first() def query_file_uuid(self, uuid): return self.session.query(Trade).filter( Trade.file_uuid == uuid).first() def insert(self, trade): trade.time_stamp = trade.time_stamp or datetime.now() trade.file_uuid = str(uuid()) trade.order_delivered = False self.session.add(trade) self.session.commit() def delete(self, trade): self.session.delete(trade) self.session.commit() def update(self): self.session.commit() def session_close(self): self.session.close() def reclaim(self): reclaim_period = datetime.now() - timedelta(days=7) for instance in self.session.query(Trade).filter( Trade.time_stamp < reclaim_period).all(): self.delete(instance) self.session.commit() self.session_close()
class ProxyDB(object): db_path = join_with_rc(config.proxy.dbpath) default_db = 'sqlite:///' + db_path def __init__(self, db=default_db): self.engine = create_engine(db, echo=False) Base.metadata.create_all(self.engine) Session = sessionmaker(bind=self.engine) self.session = Session() def query(self, trade): return self.session.query(Trade).filter( Trade.order_id == trade.order_id, Trade.order_type == trade.order_type, Trade.buyer_addr == trade.buyer_addr, Trade.seller_addr == trade.seller_addr, Trade.market_hash == trade.market_hash).first() def query_data_path(self, data_path): return self.session.query(Trade).filter( Trade.data_path == data_path).first() def insert(self, trade): trade.time_stamp = trade.time_stamp or datetime.now() self.session.add(trade) self.session.commit() def delete(self, trade): self.session.delete(trade) self.session.commit() def update(self): self.session.commit() def reclaim(self): reclaim_period = datetime.now() - timedelta(days=7) for instance in self.session.query(Trade).filter( Trade.time_stamp < reclaim_period).all(): self.delete(instance) self.session.commit()
def send_buyer_message(self, order): global kad_port message = Message() buyer_data = message.buyer_data message.type = Message.BUYER_DATA buyer_data.order_id = order['order_id'] buyer_data.order_type = order['order_type'] buyer_data.seller_addr = order['seller'] buyer_data.buyer_addr = order['buyer'] buyer_data.market_hash = order['market_hash'] sign_message = SignMessage() sign_message.public_key = self.public_key sign_message.data = message.SerializeToString() sign_message.signature = ECCipher.create_signature( self.private_key, sign_message.data ) kad_port += 1 proxy_id = order['proxy'] error, AES_key, urls = yield start_proxy_request(sign_message, proxy_id, kad_port) if error: print(error) else: print(urls) if order['order_type'] == 'file': file_name = urls[0].split('/')[3] file_dir = join_with_rc(config.wallet.download_dir) # create if not exists os.makedirs(file_dir, exist_ok=True) file_path = os.path.join(file_dir, file_name) yield download_proxy_file(urls[0], file_path)
def buyer_request(): message = Message() buyer_data = message.buyer_data message.type = Message.BUYER_DATA buyer_data.order_id = order_id buyer_data.order_type = order_type buyer_data.seller_addr = seller_addr buyer_data.buyer_addr = buyer_addr buyer_data.market_hash = 'MARKET_HASH' sign_message = SignMessage() sign_message.public_key = buyer_public_key sign_message.data = message.SerializeToString() sign_message.signature = ECCipher.create_signature(buyer_private_key, sign_message.data) proxy_list = yield pick_proxy() proxy_id = proxy_list[0] # should be selected by UI from proxy list if proxy_id: error, AES_key, urls = yield start_proxy_request( sign_message, proxy_id) if error: print(error) else: print(AES_key) print(urls) file_name = urls[0].split('/')[3] file_dir = join_with_rc(config.wallet.download_dir) # create if not exists os.makedirs(file_dir, exist_ok=True) file_path = os.path.join(file_dir, file_name) yield download_proxy_file(urls[0], file_path)
import os import time import glob import json from datetime import datetime from twisted.internet.defer import DeferredList, inlineCallbacks, Deferred from twisted.internet.threads import deferToThread from cpchain.utils import reactor, join_with_rc, config from cpchain.chain.utils import default_w3 as w3 _passphrase = 'cpc' _keystore_dir = join_with_rc(config.account.keystore_dir) os.makedirs(_keystore_dir, exist_ok=True) def create_eth_account(): return w3.eth.account.create() def backup_eth_account(eth_account, passphrase=_passphrase, keystore_dir=_keystore_dir): file_name = "UTC--%s--%s" % (datetime.utcnow().isoformat(), eth_account.address[2:].lower()) keystore = os.path.join(keystore_dir, file_name) encrypted_key = w3.eth.account.encrypt(eth_account.privateKey, passphrase) with open(keystore, 'w') as f: f.write(json.dumps(encrypted_key)) def get_keystore_list(keystore_dir=_keystore_dir):
import os import os.path as osp # https://qiita.com/zakuro9715/items/7e393ef1c80da8811027 from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import create_engine, Column, Integer, String, Boolean, TIMESTAMP from sqlalchemy.orm import sessionmaker from cpchain import config from cpchain.utils import join_with_rc dbpath = join_with_rc(config.wallet.dbpath) dirpath = osp.dirname(dbpath) os.makedirs(dirpath, exist_ok=True) engine = create_engine('sqlite:///{dbpath}'.format(dbpath=dbpath), echo=True, connect_args={"check_same_thread": False}) Base = declarative_base() def get_session(): Session = sessionmaker(bind=engine) session = Session() return session class FileInfo(Base): __tablename__ = 'fileinfo' id = Column(Integer, primary_key=True)
from twisted.web.static import File from cpchain import config from cpchain.proxy.msg.trade_msg_pb2 import Message, SignMessage from cpchain.proxy.message import message_sanity_check, \ sign_message_verify, is_address_from_key from cpchain.storage import IPFSStorage, S3Storage from cpchain.proxy.db import Trade, ProxyDB from cpchain.utils import join_with_rc from cpchain.proxy.chain import order_is_ready_on_chain, \ claim_data_delivered_to_chain, claim_data_fetched_to_chain logger = logging.getLogger(__name__) server_root = join_with_rc(config.proxy.server_root) server_root = os.path.expanduser(server_root) os.makedirs(server_root, exist_ok=True) class SSLServerProtocol(NetstringReceiver): def __init__(self, factory): self.factory = factory self.proxy_db = factory.proxy_db self.peer = None def connectionMade(self): self.factory.numConnections += 1 self.peer = str(self.transport.getPeer()) logger.debug("connect to client %s" % self.peer)
'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'market.wsgi.application' # Database # https://docs.djangoproject.com/en/2.0/ref/settings/#databases db_path = join_with_rc(config.market.dbpath) dir_name = os.path.dirname(db_path) if not os.path.exists(dir_name): os.makedirs(dir_name) DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': db_path, # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } # 'default': { # 'ENGINE': 'django.db.backends.postgresql', # 'NAME': 'dev', # 'USER': '******',