def stringReceived(self, string):
sign_message = SignMessage()
sign_message.ParseFromString(string)
valid = sign_message_verify(sign_message)
if not valid:
error = 'wrong signature'
return self.proxy_reply_error(error)
message = Message()
message.ParseFromString(sign_message.data)
valid = message_sanity_check(message)
if not valid or message.type == Message.PROXY_REPLY:
error = "wrong client request"
return self.proxy_reply_error(error)
public_key = sign_message.public_key
if message.type == Message.SELLER_DATA:
public_addr = message.seller_data.seller_addr
elif message.type == Message.BUYER_DATA:
public_addr = message.buyer_data.buyer_addr
if not is_address_from_key(public_addr, public_key):
error = "public key does not match with address"
return self.proxy_reply_error(error)
self.handle_message(message)
def send_request(self, order_id):
new_order_info = self.buyer.query_order(order_id)
message = Message()
buyer_data = message.buyer_data
message.type = Message.BUYER_DATA
buyer_data.order_id = order_id
buyer_data.seller_addr = to_bytes(hexstr=new_order_info[3])
buyer_data.buyer_addr = to_bytes(hexstr=new_order_info[2])
buyer_data.market_hash = new_order_info[0]
sign_message = SignMessage()
sign_message.public_key = Encoder.str_to_base64_byte(
self.market_client.pub_key)
sign_message.data = message.SerializeToString()
sign_message.signature = crypto.ECCipher.generate_signature(
Encoder.str_to_base64_byte(self.market_client.priv_key),
sign_message.data)
d = start_client(sign_message)
def update_buyer_db(file_uuid, file_path, new_order_id):
market_hash = Encoder.bytes_to_base64_str(
self.buyer.query_order(new_order_id)[0])
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()
return market_hash
def buyer_request_proxy_callback(message):
print("Inside buyer request callback.")
assert message.type == Message.PROXY_REPLY
proxy_reply = message.proxy_reply
if not proxy_reply.error:
print('file_uuid: %s' % proxy_reply.file_uuid)
print('AES_key: ')
print(len(proxy_reply.AES_key))
print(proxy_reply.AES_key)
file_dir = os.path.expanduser(config.wallet.download_dir)
file_path = os.path.join(file_dir, proxy_reply.file_uuid)
print(file_path)
decrypted_file = decrypt_file_aes(file_path,
proxy_reply.AES_key)
print('Decrypted file path ' + str(decrypted_file))
update_buyer_db(proxy_reply.file_uuid, decrypted_file,
order_id)
self.update_treasure_pane()
self.confirm_order(order_id)
self.order_id_list.remove(order_id)
else:
print(proxy_reply.error)
d.addBoth(buyer_request_proxy_callback)
def seller_send_request_stream(self, order_info):
logger.debug("seller send request to proxy ...")
order_id = list(order_info.keys())[0]
new_order_info = order_info[order_id]
market_hash = new_order_info[0]
seller_addr = eth_addr_to_string(new_order_info[3])
buyer_addr = eth_addr_to_string(new_order_info[2])
buyer_rsa_public_key = new_order_info[1]
proxy_id = eth_addr_to_string(new_order_info[4])
session = get_session()
raw_aes_key = session.query(FileInfo.aes_key) \
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash)) \
.all()[0][0]
logger.debug("start to encrypt aes key with buyer rsa public key")
logger.debug("raw aes key: %s", raw_aes_key)
logger.debug("buyer rsa public key: %s", buyer_rsa_public_key)
encrypted_aes_key = load_der_public_key(
buyer_rsa_public_key, backend=default_backend()).encrypt(
raw_aes_key,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None))
logger.debug("encrypted aes key: %s", encrypted_aes_key)
logger.debug("order info got generated")
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = order_id
seller_data.order_type = 'stream'
seller_data.seller_addr = seller_addr
seller_data.buyer_addr = buyer_addr
seller_data.market_hash = Encoder.bytes_to_base64_str(market_hash)
seller_data.AES_key = encrypted_aes_key
storage = seller_data.storage
storage_type = session.query(FileInfo.remote_type) \
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash)) \
.all()[0][0]
remote_uri = session.query(FileInfo.remote_uri) \
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash)) \
.all()[0][0]
storage.type = storage_type
storage.path = remote_uri
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)
try:
error, AES_key, urls = yield start_proxy_request(
sign_message, proxy_id)
if error:
logger.error(error)
else:
logger.debug(AES_key)
logger.debug(urls)
event.emit(events.SELLER_DELIVERY, order_id)
except Exception as e:
logger.error(e)
def proxy_reply_error(self, error):
message = Message()
message.type = Message.PROXY_REPLY
proxy_reply = message.proxy_reply
proxy_reply.error = error
string = message.SerializeToString()
self.sendString(string)
self.transport.loseConnection()
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 fake_buyer_message():
message = Message()
buyer_data = message.buyer_data
message.type = Message.BUYER_DATA
buyer_data.order_id = 1
buyer_data.seller_addr = seller_addr
buyer_data.buyer_addr = buyer_addr
buyer_data.market_hash = 'MARKET_HASH'
return message
def proxy_reply_success(self):
trade = self.trade
message = Message()
message.type = Message.PROXY_REPLY
proxy_reply = message.proxy_reply
proxy_reply.AES_key = trade.AES_key
proxy_reply.file_uuid = trade.file_uuid
string = message.SerializeToString()
self.sendString(string)
self.transport.loseConnection()
def stringReceived(self, string):
message = Message()
message.ParseFromString(string)
valid = message_sanity_check(message)
if not valid or message.type != Message.PROXY_REPLY:
# should never happen
proxy_reply = proxy_reply_error("wrong server response")
else:
proxy_reply = message.proxy_reply
self.proxy_reply = proxy_reply
self.transport.loseConnection()
def proxy_reply_success(self, trade):
message = Message()
message.type = Message.PROXY_REPLY
proxy_reply = message.proxy_reply
proxy_reply.AES_key = trade.AES_key
file_uri = "https://%s:%d/%s" % (
self.factory.ip,
self.factory.data_port,
trade.file_uuid)
proxy_reply.file_uri = file_uri
string = message.SerializeToString()
self.sendString(string)
self.transport.loseConnection()
def run(self, sign_message):
message = Message()
message.ParseFromString(sign_message.data)
valid = message_sanity_check(message)
if not valid:
logger.error("wrong message format")
return
self.factory.sign_message = sign_message
self.trans = reactor.connectSSL(self.host, self.port, self.factory,
ssl.ClientContextFactory())
return self.factory.d
def check_response(self, reply_error):
string = self.transport.value()
_, string = string.split(b':', 1)
message = Message()
message.ParseFromString(string)
assert message.type == Message.PROXY_REPLY
proxy_reply = message.proxy_reply
if not proxy_reply.error:
self.assertEqual(proxy_reply.AES_key, b'AES_key')
else:
self.assertEqual(reply_error, proxy_reply.error)
def fake_seller_message():
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = order_id
seller_data.order_type = order_type
seller_data.seller_addr = seller_addr
seller_data.buyer_addr = buyer_addr
seller_data.market_hash = 'MARKET_HASH'
seller_data.AES_key = b'AES_key'
storage = seller_data.storage
storage.type = 'template'
storage.path = 'fake_file_uri'
return message
def send_request(self):
new_order = self.query_new_order()
if len(new_order) != 0:
for new_order_id in new_order:
new_order_info = self.seller.query_order(new_order_id)
print('In seller send request: new oder infomation:')
market_hash = new_order_info[0]
buyer_rsa_pubkey = new_order_info[1]
raw_aes_key = session.query(FileInfo.aes_key)\
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash))\
.all()[0][0]
encrypted_aes_key = load_der_public_key(
buyer_rsa_pubkey, backend=default_backend()).encrypt(
raw_aes_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None))
print("Encrypted_aes_key length" + str(len(encrypted_aes_key)))
storage_type = Message.Storage.IPFS
ipfs_gateway = config.proxy.default_ipfs_gateway
file_hash = session.query(FileInfo.hashcode)\
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash))\
.all()[0][0]
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = new_order_id
seller_data.seller_addr = to_bytes(hexstr=new_order_info[3])
seller_data.buyer_addr = to_bytes(hexstr=new_order_info[2])
seller_data.market_hash = market_hash
seller_data.AES_key = encrypted_aes_key
storage = seller_data.storage
storage.type = storage_type
ipfs = storage.ipfs
ipfs.file_hash = file_hash.encode('utf-8')
ipfs.gateway = ipfs_gateway
sign_message = SignMessage()
sign_message.public_key = Encoder.str_to_base64_byte(
self.market_client.pub_key)
sign_message.data = message.SerializeToString()
sign_message.signature = crypto.ECCipher.generate_signature(
Encoder.str_to_base64_byte(self.market_client.priv_key),
sign_message.data)
d = start_client(sign_message)
d.addBoth(self.seller_deliver_proxy_callback)
def buyer_send_request_stream(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 = 'stream'
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(stream_id):
session = get_session()
session.query(BuyerFileInfo).filter(
BuyerFileInfo.order_id == order_id).update(
{
BuyerFileInfo.is_downloaded: True,
BuyerFileInfo.path: stream_id,
},
synchronize_session=False)
session.commit()
if error:
logger.error(error)
else:
update_buyer_db(json.dumps(urls))
logger.debug("Stream data has been geted")
event.emit(events.BUYER_RECEIVE, order_id)
def stringReceived(self, string):
message = Message()
message.ParseFromString(string)
valid = message_sanity_check(message)
if valid and message.type == Message.PROXY_REPLY:
proxy_reply = message.proxy_reply
if not proxy_reply.error and self.factory.need_download_file:
d = download_file(proxy_reply.file_uuid)
self.reply_message = message
d.addBoth(self.download_finish)
else:
self.factory.d.callback(message)
else:
# should never happen
message = proxy_reply_error("wrong server response")
self.factory.d.callback(message)
self.transport.loseConnection()
def start_client(sign_message, addr=None):
if addr:
host = str(addr[0])
port = int(addr[1])
else:
host = config.proxy.server_host
port = config.proxy.server_ctrl_port
message = Message()
message.ParseFromString(sign_message.data)
valid = message_sanity_check(message)
if not valid:
logger.error("wrong message format")
return
factory = SSLClientFactory(sign_message)
reactor.connectSSL(host, port, factory,
ssl.ClientContextFactory())
buyer_request = message.type == Message.BUYER_DATA
d = defer.Deferred()
def handle_proxy_response(proxy_reply):
if not proxy_reply.error:
logger.debug('file_uri: %s' % proxy_reply.file_uri)
logger.debug('AES_key: %s' % proxy_reply.AES_key)
if buyer_request:
return download_file(proxy_reply.file_uri).addCallback(
lambda _: d.callback(proxy_reply))
else:
logger.debug(proxy_reply.error)
d.callback(proxy_reply)
factory.d.addCallback(handle_proxy_response)
return d
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)
def send_seller_message(self, order):
global kad_port
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = order['order_id']
seller_data.order_type = order['order_type']
seller_data.seller_addr = order['seller']
seller_data.buyer_addr = order['buyer']
seller_data.market_hash = order['market_hash']
seller_data.AES_key = order['AES_key']
storage = seller_data.storage
storage.type = order['storage_type']
storage.path = order['storage_path']
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)
def start_client(sign_message):
log.startLogging(sys.stdout)
host = config.proxy.server_host
ctrl_port = config.proxy.server_ctrl_port
message = Message()
message.ParseFromString(sign_message.data)
valid = message_sanity_check(message)
if not valid:
print("wrong message format")
return
d = defer.Deferred()
factory = SSLClientFactory(sign_message)
factory.d = d
if message.type == Message.BUYER_DATA:
factory.need_download_file = True
reactor.connectSSL(host, ctrl_port, factory, ssl.ClientContextFactory())
return d
def fake_seller_message(storage_type):
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = 1
seller_data.seller_addr = seller_addr
seller_data.buyer_addr = buyer_addr
seller_data.market_hash = 'MARKET_HASH'
seller_data.AES_key = b'AES_key'
storage = seller_data.storage
if storage_type == 'ipfs':
storage.type = Message.Storage.IPFS
ipfs = storage.ipfs
ipfs.file_hash = 'fake_file_hash'
ipfs.gateway = "1.2.3.4:5001"
elif storage_type == 's3':
storage.type = Message.Storage.S3
s3 = storage.s3
s3.bucket = 'fake-bucket'
s3.key = 'fake-key'
return message
if __name__ == '__main__':
test_type = 'buyer_data'
buyer_private_key = None
buyer_private_key = b'\xa6\xf8_\xee\x1c\x85\xc5\x95\x8d@\x9e\xfa\x80\x7f\xb6\xe0\xb4u\x12\xb6\xdf\x00\xda4\x98\x8e\xaeR\x89~\xf6\xb5'
buyer_private_key, buyer_public_key = \
ECCipher.generate_key_pair(buyer_private_key)
seller_private_key = None
seller_private_key = b'\xa6\xf8_\xee\x1c\x85\xc5\x95\x8d@\x9e\xfa\x80\x7f\xb6\xe0\xb4u\x12\xb6\xdf\x00\xda4\x98\x8e\xaeR\x89~\xf6\xb5'
seller_private_key, seller_public_key = \
ECCipher.generate_key_pair(seller_private_key)
if test_type == 'seller_data':
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = 1
seller_data.seller_addr = seller_public_key
seller_data.buyer_addr = buyer_public_key
seller_data.market_hash = b'MARKET_HASH'
seller_data.AES_key = b'AES_key'
storage = seller_data.storage
storage.type = Message.Storage.IPFS
ipfs = storage.ipfs
ipfs.file_hash = b'QmT4kFS5gxzQZJwiDJQ66JLVGPpyTCF912bywYkpgyaPsD'
ipfs.gateway = "192.168.0.132:5001"
sign_message = SignMessage()
sign_message.public_key = seller_public_key
def proxy_reply_error(error):
message = Message()
message.type = Message.PROXY_REPLY
proxy_reply = message.proxy_reply
proxy_reply.error = error
return proxy_reply
def stringReceived(self, string):
sign_message = SignMessage()
sign_message.ParseFromString(string)
valid = sign_message_verify(sign_message)
if not valid:
error = 'wrong signature'
self.proxy_reply_error(error)
return
message = Message()
message.ParseFromString(sign_message.data)
valid = message_sanity_check(message)
if not valid or message.type == Message.PROXY_REPLY:
error = "wrong client request"
self.proxy_reply_error(error)
return
public_key = sign_message.public_key
proxy_db = self.proxy_db
self.trade = Trade()
trade = self.trade
error = None
if message.type == Message.SELLER_DATA:
data = message.seller_data
trade.order_id = data.order_id
trade.seller_addr = data.seller_addr
trade.buyer_addr = data.buyer_addr
trade.market_hash = data.market_hash
trade.AES_key = data.AES_key
if pub_key_der_to_addr(public_key) != data.seller_addr:
print("pubkey seller addr")
print(pub_key_der_to_addr(public_key))
print(data.seller_addr)
error = "not seller's signature"
self.proxy_reply_error(error)
return
storage = data.storage
if storage.type == Message.Storage.IPFS:
ipfs = storage.ipfs
trade.file_hash = ipfs.file_hash
if (proxy_db.count(trade)):
error = "trade record already in database"
self.proxy_reply_error(error)
return
else:
file_path = os.path.join(server_root,
trade.file_hash.decode())
# seller sold the same file to another buyer
if os.path.isfile(file_path):
mtime = time.time()
os.utime(file_path, (mtime, mtime))
proxy_db.insert(trade)
self.proxy_reply_success()
self.proxy_claim_relay()
return
else:
d = threads.deferToThread(self.get_ipfs_file,
ipfs.gateway,
trade.file_hash)
d.addBoth(self.ipfs_callback)
elif storage.type == Message.Storage.S3:
error = "not support S3 storage yet"
self.proxy_reply_error(error)
return
elif message.type == Message.BUYER_DATA:
data = message.buyer_data
trade.order_id = data.order_id
trade.seller_addr = data.seller_addr
trade.buyer_addr = data.buyer_addr
trade.market_hash = data.market_hash
if pub_key_der_to_addr(public_key) != data.buyer_addr:
error = "not buyer's signature"
self.proxy_reply_error(error)
return
if proxy_db.count(trade):
self.trade = proxy_db.query(trade)
self.proxy_reply_success()
return
else:
error = "trade record not found in database"
self.proxy_reply_error(error)
return
def seller_send_request(self, order_info):
logger.debug("seller send request to proxy ...")
order_id = list(order_info.keys())[0]
new_order_info = order_info[order_id]
market_hash = new_order_info[0]
seller_addr = eth_addr_to_string(new_order_info[3])
buyer_addr = eth_addr_to_string(new_order_info[2])
buyer_rsa_public_key = new_order_info[1]
proxy_id = eth_addr_to_string(new_order_info[4])
session = get_session()
raw_aes_key = session.query(FileInfo.aes_key) \
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash)) \
.all()[0][0]
logger.debug("start to encrypt aes key with buyer rsa public key")
logger.debug("raw aes key: %s", raw_aes_key)
logger.debug("buyer rsa public key: %s", buyer_rsa_public_key)
encrypted_aes_key = load_der_public_key(
buyer_rsa_public_key, backend=default_backend()).encrypt(
raw_aes_key,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None))
logger.debug("encrypted aes key: %s", encrypted_aes_key)
file_hash = session.query(FileInfo.hashcode) \
.filter(FileInfo.market_hash == Encoder.bytes_to_base64_str(market_hash)) \
.all()[0][0]
logger.debug("order info got generated")
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = order_id
seller_data.seller_addr = seller_addr
seller_data.buyer_addr = buyer_addr
seller_data.market_hash = 'market hash'
seller_data.AES_key = encrypted_aes_key
storage = seller_data.storage
# ipfs storage example
storage.type = Message.Storage.IPFS
ipfs = storage.ipfs
ipfs.file_hash = file_hash
ipfs.gateway = "192.168.0.132:5001"
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.accounts.default_account.private_key,
sign_message.data)
seller_sign_message = sign_message
logger.debug("message created")
d_proxy_reply = start_proxy_request(seller_sign_message,
proxy_id=proxy_id)
def seller_deliver_proxy_callback(proxy_reply):
logger.debug("in seller request callback.")
if not proxy_reply.error:
logger.debug("receive reply from proxy")
logger.debug('file_uri: %s', proxy_reply.file_uri)
else:
logger.debug(proxy_reply.error)
d_proxy_reply.addCallback(seller_deliver_proxy_callback)
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.seller_addr = seller_addr
buyer_data.buyer_addr = buyer_addr
buyer_data.market_hash = 'market hash'
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.accounts.default_account.private_key,
sign_message.data)
buyer_sign_message = sign_message
d_proxy_reply = start_proxy_request(buyer_sign_message,
proxy_id=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()
return market_hash
def buyer_request_proxy_callback(proxy_reply):
logger.debug("in buyer request callback.")
if not proxy_reply.error:
logger.debug('file_uri: %s', proxy_reply.file_uri)
file_dir = os.path.expanduser(config.wallet.download_dir)
file_name = proxy_reply.file_uri.split('/')[3]
file_path = os.path.join(file_dir, file_name)
logger.debug("downloaded file path: %s", file_path)
decrypted_file = decrypt_file_aes(file_path,
proxy_reply.AES_key)
logger.debug('Decrypted file path: %s', str(decrypted_file))
update_buyer_db(proxy_reply.file_uri, decrypted_file)
logger.debug("file has been downloaded")
logger.debug("put order into confirmed queue, order id: %s",
order_id)
self.confirmed_order_queue.put(order_id)
self.wallet.main_wnd.update_purchased_tab('downloaded')
else:
logger.debug(proxy_reply.error)
d_proxy_reply.addCallback(buyer_request_proxy_callback)
def seller_request():
# seller_request
message = Message()
seller_data = message.seller_data
message.type = Message.SELLER_DATA
seller_data.order_id = order_id
seller_data.order_type = order_type
seller_data.seller_addr = seller_addr
seller_data.buyer_addr = buyer_addr
seller_data.market_hash = 'MARKET_HASH'
seller_data.AES_key = b'AES_key'
storage = seller_data.storage
#stream test
storage.type = 'stream'
storage_plugin = "cpchain.storage_plugin."
module = importlib.import_module(storage_plugin + storage.type)
s = module.Storage()
param = yield s.user_input_param()
param['proxy_id'] = param['proxy_id'][
0] # should be selected by UI from proxy list
storage.path = yield s.upload_data(None, param)
# proxy storage
# storage.type = 'proxy'
# storage_plugin = "cpchain.storage_plugin."
# module = importlib.import_module(storage_plugin + storage.type)
# s = module.Storage()
# param = yield s.user_input_param()
# param['proxy_id'] = param['proxy_id'][0] # should be selected by UI from proxy list
# storage.path = yield s.upload_data('/bin/bash', param)
# ipfs storage
# storage.type = 'ipfs'
# storage_plugin = "cpchain.storage_plugin."
# module = importlib.import_module(storage_plugin + storage.type)
# s = module.Storage()
# param = yield s.user_input_param()
# storage.path = yield s.upload_data('/bin/bash', param)
# # S3 storage
# storage.type = 's3'
# storage_plugin = "cpchain.storage_plugin."
# module = importlib.import_module(storage_plugin + storage.type)
# s = module.Storage()
# param = yield s.user_input_param()
# storage.path = yield s.upload_data('/bin/bash', param)
sign_message = SignMessage()
sign_message.public_key = seller_public_key
sign_message.data = message.SerializeToString()
sign_message.signature = ECCipher.create_signature(seller_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)
