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)