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': '******',
