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)
