def buyer_place_order(self, product, proxy):
buyer_rsa_pubkey = self.rsa_public_key
desc_hash = Encoder.str_to_base64_byte(product['msg_hash'])
public_key = ECCipher.create_public_key(
Encoder.hex_to_bytes(product['owner_address']))
seller_addr = w3.toChecksumAddress(
ECCipher.get_address_from_public_key(public_key))
proxy = w3.toChecksumAddress(proxy)
product = OrderInfo(desc_hash=desc_hash,
buyer_rsa_pubkey=buyer_rsa_pubkey,
seller=seller_addr,
proxy=proxy,
secondary_proxy=proxy,
proxy_value=100,
value=product['price'],
time_allowed=3600 * 24)
w3.personal.unlockAccount(self.account.address, _passphrase)
order_id = self.buyer_agent.place_order(product)
# w3.personal.lockAccount(self.account.address)
# return -1 if failure
return order_id
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 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 callback(path):
try:
# Save
proxy = self.proxy.current
self.aes_key = AESCipher.generate_key()
remote_uri = str(path)
new_file_info = FileInfo(
name=self.data_name.value,
data_type='stream',
proxy=proxy,
remote_type='stream',
remote_uri=remote_uri,
public_key=wallet.market_client.public_key,
is_published=False,
created=func.current_timestamp(),
aes_key=self.aes_key)
fs.add_file(new_file_info)
self._id = new_file_info.id
encrypted_key = RSACipher.encrypt(self.aes_key)
encrypted_key = Encoder.bytes_to_base64_str(encrypted_key)
wallet.market_client.upload_file_info(None, None, 0, self._id,
'stream',
json.dumps(remote_uri),
self.data_name.value,
encrypted_key)
path = json.loads(path)
self.uploaded.emit(path)
except Exception as err:
logger.error(err)
def buy_product(self, msg_hash, file_title, proxy, seller, value):
logger.debug("start to buy product")
seller_addr = get_address_from_public_key_object(seller)
desc_hash = Encoder.str_to_base64_byte(msg_hash)
rsa_key = RSACipher.load_public_key()
# rsa_key = self.broker.wallet.market_client.public_key
logger.debug("desc hash: %s", desc_hash)
logger.info('Value: %s', value)
product = OrderInfo(
desc_hash=desc_hash,
buyer_rsa_pubkey=rsa_key,
seller=self.broker.buyer.web3.toChecksumAddress(seller_addr),
proxy=self.broker.buyer.web3.toChecksumAddress(proxy),
secondary_proxy=self.broker.buyer.web3.toChecksumAddress(proxy),
proxy_value=10,
value=value,
time_allowed=3600 * 24
)
logger.debug("product info has been created")
logger.debug("product info: %s", product)
logger.debug("seller address: %s", product.seller)
d_placed_order = deferToThread(self.broker.buyer.place_order, product)
def add_bought_order(order_id):
logger.debug("start to update local database")
new_buyer_file_info = BuyerFileInfo(order_id=order_id,
market_hash=Encoder.bytes_to_base64_str(desc_hash),
file_title=file_title, is_downloaded=False)
add_file(new_buyer_file_info)
logger.debug("update local db completed")
event.emit(events.PAY, (order_id, msg_hash))
# Update the purchased downloaded tab in the main window of wallet
d_placed_order.addCallback(add_bought_order)
def add_bought_order(order_id):
logger.debug("start to update local database")
new_buyer_file_info = BuyerFileInfo(order_id=order_id,
market_hash=Encoder.bytes_to_base64_str(desc_hash),
file_title=file_title, is_downloaded=False)
add_file(new_buyer_file_info)
logger.debug("update local db completed")
event.emit(events.PAY, (order_id, msg_hash))
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(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 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()
def cb(order_id):
self.order_id_list.append(order_id)
print("Before new buyer file info. ")
new_buyer_file_info = BuyerFileInfo(
order_id=order_id,
market_hash=Encoder.bytes_to_base64_str(desc_hash),
file_title=file_title,
is_downloaded=False)
add_file(new_buyer_file_info)
self.update_treasure_pane()
print('In place order callback order id: ', self.order_id_list)
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 add_bought_order(order_id):
logger.debug("order has been placed to chain")
self.broker.bought_order_queue.put(order_id)
logger.debug("new order has been put into bought order queue")
logger.debug("bought order queue size: %s",
self.broker.bought_order_queue.qsize())
logger.debug("start to update local database")
new_buyer_file_info = BuyerFileInfo(
order_id=order_id,
market_hash=Encoder.bytes_to_base64_str(desc_hash),
file_title=file_title,
is_downloaded=False)
add_file(new_buyer_file_info)
logger.debug("update local db completed")
# Update the purchased downloaded tab in the main window of wallet
self.broker.wallet.main_wnd.update_purchased_tab('downloading')
def proxy_claim_relay(self):
proxy_trans = ProxyTrans(default_web3, config.chain.core_contract)
private_key_file_path = join_with_root(config.wallet.private_key_file)
password_path = join_with_root(config.wallet.private_key_password_file)
with open(password_path) as f:
password = f.read()
priv_key, pub_key = ECCipher.geth_load_key_pair_from_private_key(
private_key_file_path, password)
priv_key_bytes = Encoder.str_to_base64_byte(priv_key)
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(
ECCipher.generate_signature(priv_key_bytes,
to_bytes(self.trade.order_id),
password))
deliver_hash = digest.finalize()
tx_hash = proxy_trans.claim_relay(self.trade.order_id, deliver_hash)
return tx_hash
def buy_product(self, msg_hash, file_title, proxy, seller):
logger.debug("start to buy product")
seller_addr = get_address_from_public_key_object(seller)
desc_hash = Encoder.str_to_base64_byte(msg_hash)
rsa_key = RSACipher.load_public_key()
logger.debug("desc hash: %s", desc_hash)
product = OrderInfo(
desc_hash=desc_hash,
buyer_rsa_pubkey=rsa_key,
seller=self.broker.buyer.web3.toChecksumAddress(seller_addr),
proxy=self.broker.buyer.web3.toChecksumAddress(proxy),
secondary_proxy=self.broker.buyer.web3.toChecksumAddress(proxy),
proxy_value=10,
value=20,
time_allowed=1000)
logger.debug("product info has been created")
logger.debug("product info: %s", product)
logger.debug("seller address: %s", product.seller)
logger.debug("bought order queue size: %s",
self.broker.bought_order_queue.qsize())
d_placed_order = deferToThread(self.broker.buyer.place_order, product)
def add_bought_order(order_id):
logger.debug("order has been placed to chain")
self.broker.bought_order_queue.put(order_id)
logger.debug("new order has been put into bought order queue")
logger.debug("bought order queue size: %s",
self.broker.bought_order_queue.qsize())
logger.debug("start to update local database")
new_buyer_file_info = BuyerFileInfo(
order_id=order_id,
market_hash=Encoder.bytes_to_base64_str(desc_hash),
file_title=file_title,
is_downloaded=False)
add_file(new_buyer_file_info)
logger.debug("update local db completed")
# Update the purchased downloaded tab in the main window of wallet
self.broker.wallet.main_wnd.update_purchased_tab('downloading')
d_placed_order.addCallback(add_bought_order)
return self.broker.bought_order_queue
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 handle_ok_callback(self, file_id):
file_info = fs.get_file_by_id(file_id)
hashcode = file_info.hashcode
path = file_info.path
size = file_info.size
product_id = file_info.id
remote_type = file_info.remote_type
remote_uri = file_info.remote_uri
name = file_info.name
encrypted_key = RSACipher.encrypt(file_info.aes_key)
encrypted_key = Encoder.bytes_to_base64_str(encrypted_key)
d = wallet.market_client.upload_file_info(hashcode, path, size,
product_id, remote_type,
remote_uri, name,
encrypted_key)
def cb(status):
self.okSignal.emit(status)
d.addCallbacks(cb)
def get_public_key(public_key_string):
pub_key_bytes = Encoder.hex_to_bytes(public_key_string)
return ECCipher.create_public_key(pub_key_bytes)
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)
