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)