def test_load_key(self): pri_k, pub_k = ECCipher.load_key_pair(self.private_key_file_path, self.password) self.assertIsNotNone(pri_k) self.assertIsNotNone(pub_k) pri_key = ECCipher.load_private_key(self.private_key_file_path, self.password) self.assertIsNotNone(pri_key) msg = 'test123' sig = ECCipher.create_signature(pri_key, msg) print('sig:', sig) self.assertIsNotNone(sig) create_pub_key = ECCipher.create_public_key_from_private_key(pri_key) self.assertIsNotNone(create_pub_key) load_pub_key = ECCipher.load_public_key(self.private_key_file_path, self.password) self.assertIsNotNone(load_pub_key) v1 = ECCipher.verify_sign(load_pub_key, sig, msg) self.assertTrue(v1) v2 = ECCipher.verify_sign(create_pub_key, sig, msg) self.assertTrue(v2) addr = ECCipher.get_address_from_public_key(load_pub_key) print(addr) self.assertIsNotNone(addr)
def test_generate_key_pair_signature_and_verify(self): private_key_file_path = join_with_root(private_key_file) password_path = join_with_root(private_key_password_file) with open(password_path) as f: password = f.read() print(password) new_pri_key, pub_key = ECCipher.load_key_pair(private_key_file_path, password) sample = b"qZaQ6S" print("gen prikey:", new_pri_key) self.assertIsNotNone(new_pri_key) new_signature = ECCipher.create_signature(new_pri_key, sample) print("new_signature is:", new_signature) self.assertIsNotNone(new_signature) # pub_key = ECCipher.create_public_key(new_pub_key) is_valid_sign = ECCipher.verify_sign(pub_key, new_signature, sample) print("is valid new_signature:", is_valid_sign) self.assertTrue(is_valid_sign)
def login(self, username=None): header = {'Content-Type': 'application/json'} data = {'public_key': self.public_key, 'username': username} resp = yield treq.post(url=self.url + 'account/v1/login/', headers=header, json=data, persistent=False) confirm_info = yield treq.json_content(resp) logger.debug("login response: %s", confirm_info) self.nonce = confirm_info['message'] logger.debug('nonce: %s', self.nonce) signature = ECCipher.create_signature(self.account.private_key, self.nonce) header_confirm = {'Content-Type': 'application/json'} data_confirm = { 'public_key': self.public_key, 'code': Encoder.bytes_to_hex(signature) } resp = yield treq.post(self.url + 'account/v1/confirm/', headers=header_confirm, json=data_confirm, persistent=False) confirm_info = yield treq.json_content(resp) self.token = confirm_info['message'] return confirm_info['status']
def test_load_key_pair_from_private_key_and_verify_signature(self): private_key_file_path = join_with_root(private_key_file) password_path = join_with_root(private_key_password_file) with open(password_path) as f: password = f.read() print(password) pri_key, pub_key = ECCipher.load_key_pair(private_key_file_path, password) # ---------- sign and verify ------------ data = "testdata" new_signature = ECCipher.create_signature(pri_key, data) print("new_signature is:" + new_signature.hex()) is_valid_sign = verify_geth_signature(pub_key, new_signature, data) print("is valid new_signature:" + str(is_valid_sign)) self.assertTrue(is_valid_sign, "should be success") is_valid_sign = verify_geth_signature(pub_key, new_signature, data + "error") print("is valid new_signature:" + str(is_valid_sign)) self.assertFalse(is_valid_sign, "should be failed")
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 sign_buyer_message(message): 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) return sign_message
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 publish_product(self, selected_id, title, ptype, description, price, tags, start_date, end_date, category=None, cover_image=None): logger.debug("start publish product") header = {'Content-Type': 'multipart/form-data'} # 'application/json'} header['MARKET-KEY'] = self.public_key header['MARKET-TOKEN'] = self.token logger.debug('header token: %s', self.token) data = { 'owner_address': self.public_key, 'title': title, 'ptype': ptype, 'description': description, 'price': price, 'tags': tags, 'start_date': start_date, 'end_date': end_date, 'category': category } signature_source = str( self.public_key) + str(title) + str(ptype) + str( description) + str(price) + MarketClient.str_to_timestamp( start_date) + MarketClient.str_to_timestamp(end_date) signature = ECCipher.create_signature(self.account.private_key, signature_source) data['signature'] = Encoder.bytes_to_hex(signature) logger.debug("signature: %s", data['signature']) try: url = self.url + 'product/v1/allproducts/' resp = yield treq.post( url, files=dict(cover_image=open(cover_image, 'rb')), headers=header, data=data, persistent=False) confirm_info = yield treq.json_content(resp) logger.debug('market_hash: %s', confirm_info['data']['market_hash']) market_hash = confirm_info['data']['market_hash'] except Exception as e: logger.exception(e) if ptype == 'file' or ptype == 'stream': publish_file_update(market_hash, selected_id) return market_hash
def sign_proxy_data(data): public_key = _proxy_account.public_key private_key = _proxy_account.private_key signature = ECCipher.create_signature(private_key, data) msg = { 'data': data, 'public_key': ECCipher.serialize_public_key(public_key), 'signature': signature } return packb(msg, use_bin_type=True)
def __generate_nonce_signature_and_get_token(self, header, nonce, pub_key_str, pri_key): url = '%s/account/v1/confirm/' % HOST print("nonce:%s" % nonce) nonce_signature = ECCipher.create_signature(pri_key, nonce) payload = {"public_key": pub_key_str, "code": Encoder.bytes_to_hex(nonce_signature)} confirm_resp = requests.post(url, headers=header, json=payload) print("response:%s" , confirm_resp.text) self.assertEqual(confirm_resp.status_code, 200) parsed_json = json.loads(confirm_resp.text) self.assertEqual(parsed_json['status'], 1) token = parsed_json['message'] print("token:%s" % token) return token
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 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 __generate_nonce_signature_and_get_token(self, header, nonce, pub_key_str, pri_key): url = reverse('confirm') print("nonce:%s" % nonce) nonce_signature = ECCipher.create_signature(pri_key, nonce) payload = { "public_key": pub_key_str, "code": Encoder.bytes_to_hex(nonce_signature) } # self.client.head(header) confirm_resp = self.client.post(url, data=payload, format='json', **header) self.assertEqual(confirm_resp.status_code, 200) resp = confirm_resp.content.decode("utf-8") print("response:%s" % resp) parsed_json = json.loads(resp) self.assertEqual(parsed_json['status'], 1) token = parsed_json['message'] print("token:%s" % token) return token
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 publish_product(self, selected_id, title, description, price, tags, start_date, end_date, file_md5, size): logger.debug("start publish product") header = {'Content-Type': 'application/json'} header['MARKET-KEY'] = self.public_key header['MARKET-TOKEN'] = self.token logger.debug('header token: %s', self.token) data = {'owner_address': self.public_key, 'title': title, 'description': description, 'price': price, 'tags': tags, 'start_date': start_date, 'end_date': end_date, 'file_md5': file_md5, 'size': size} signature_source = str(self.public_key) + str(title) + str(description) + str( price) + MarketClient.str_to_timestamp(start_date) + MarketClient.str_to_timestamp(end_date) + str(file_md5) signature = ECCipher.create_signature(self.account.private_key, signature_source) data['signature'] = Encoder.bytes_to_hex(signature) logger.debug("signature: %s", data['signature']) resp = yield treq.post(self.url + 'product/v1/product/publish/', headers=header, json=data, persistent=False) confirm_info = yield treq.json_content(resp) print(confirm_info) logger.debug('market_hash: %s', confirm_info['data']['market_hash']) market_hash = confirm_info['data']['market_hash'] publish_file_update(market_hash, selected_id) return market_hash
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 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)
def sign(private_key, message): return ECCipher.create_signature(private_key=private_key, message=message)
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)