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 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 setUp(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() self.private_key_file_path = private_key_file_path self.password = password
def main(): if len(sys.argv) != 3: src_path = join_with_root(config.chain.contract_src_path) abi_path = join_with_root(config.chain.contract_bin_path) else: src_path = sys.argv[1] abi_path = sys.argv[2] compile_contract(src_path, abi_path)
def main(): bin_path = join_with_root(config.chain.contract_bin_path) contract_name = config.chain.contract_name contract = deploy_contract(bin_path, contract_name) registrar_path = join_with_root(config.chain.registrar_json) with open(registrar_path, 'w') as f: f.write(json.dumps(dict({contract_name: contract.address}))) print("contract address: %s" % contract.address)
def load_private_key(): with open(join_with_root(config.wallet.rsa_private_key_password_file), "rb") as f: buyer_rsa_private_key_password = f.read() with open(join_with_root(config.wallet.rsa_private_key_file), "rb") as key_file: buyer_private_key = serialization.load_pem_private_key( key_file.read(), password=buyer_rsa_private_key_password, backend=default_backend() ) return buyer_private_key
def get_ssl_cert(): server_key = join_with_rc(config.proxy.server_key) server_crt = join_with_rc(config.proxy.server_crt) if not os.path.isfile(server_key): logger.info("SSL key/cert file not found, " + "run local self-test by default") server_key_sample = 'cpchain/assets/proxy/key/server.key' server_crt_sample = 'cpchain/assets/proxy/key/server.crt' server_key = join_with_root(server_key_sample) server_crt = join_with_root(server_crt_sample) return server_key, server_crt
def __init__(self, main_wnd): self.main_wnd = main_wnd self.url = config.market.market_url 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() self.priv_key, self.pub_key = crypto.ECCipher.geth_load_key_pair_from_private_key( private_key_file_path, password) self.token = '' self.nonce = '' self.message_hash = ''
def setUp(self): private_key_file_path1 = join_with_root(private_key_file1) private_key_file_path2 = join_with_root(private_key_file2) password_path = join_with_root(private_key_password_file) with open(password_path) as f: password = f.read() self.pri_key, self.pub_key = ECCipher.load_key_pair(private_key_file_path1, password) self.pri_key_2, self.pub_key_2 = ECCipher.load_key_pair(private_key_file_path2, password) self.pub_key_string = ECCipher.serialize_public_key(self.pub_key) self.pub_key_string2 = ECCipher.serialize_public_key(self.pub_key_2) self.address = ECCipher.get_address_from_public_key(self.pub_key) self.address_2 = ECCipher.get_address_from_public_key(self.pub_key_2)
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 start_service(self, ip=None, ctrl_port=None, data_port=None, account_id=0): self.ip = ip set_proxy_account(account_id) self.peer_id = get_proxy_id() server_key = os.path.expanduser(join_with_rc(config.proxy.server_key)) server_crt = os.path.expanduser(join_with_rc(config.proxy.server_crt)) if not os.path.isfile(server_key): logger.info("SSL key/cert file not found, " + "run local self-test by default") server_key_sample = 'cpchain/assets/proxy/key/server.key' server_crt_sample = 'cpchain/assets/proxy/key/server.crt' server_key = join_with_root(server_key_sample) server_crt = join_with_root(server_crt_sample) # data channel data_port = (data_port or config.proxy.server_data_port) file_factory = Site(FileServer()) reactor.listenSSL( data_port, file_factory, ssl.DefaultOpenSSLContextFactory(server_key, server_crt)) # ctrl channel ctrl_port = (ctrl_port or config.proxy.server_ctrl_port) ctrl_factory = SSLServerFactory(data_port=data_port) reactor.listenSSL( ctrl_port, ctrl_factory, ssl.DefaultOpenSSLContextFactory(server_key, server_crt)) self.service_port = ctrl_port def set_proxy_ip(): if self.ip is None: # waiting for node bootstrap finish return reactor.callLater(1, set_proxy_ip) ctrl_factory.set_external_ip(self.ip) set_proxy_ip()
def download_data(self, src, dst): stream_channel = json.loads(src) ws_url = stream_channel['ws_url'] dest_stream_id = dst cmd_path = join_with_root( 'cpchain/storage_plugin/bin/replicate-stream') args = ['nohup', cmd_path, ws_url, dest_stream_id] log = open('/tmp/' + dest_stream_id, 'w') subprocess.Popen(args, stdout=log, stderr=log)
def generate_private_key(password=b'cpchainisawesome') -> "returns key bytes": # Generate our key key = rsa.generate_private_key( public_exponent=65537, key_size=4096, backend=default_backend() ) # Write our key to disk for safe keeping with open(join_with_root(config.wallet.rsa_private_key_file), "wb") as f: f.write(key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.BestAvailableEncryption(password), )) with open(join_with_root(config.wallet.rsa_private_key_password_file), "wb") as f: f.write(password) return key
def test_server_chain(): os.chdir(root_dir) server_web3 = chain.default_web3 # chain.utils.deploy_contract(config.chain.core_contract) buyertrans = BuyerAgent(server_web3, config.chain.core_contract) print(server_web3.eth.defaultAccount) # desc_hash_base64 = 'AQkKqDxtNIRJ+1V82J5lP2/fRj/zbJ+2n0GzUF52Wsc=' # desc_hash = Encoder.str_to_base64_byte(desc_hash_base64) # public_key = RSACipher.load_public_key() # print('pubkey ' + str(len(public_key))) # order_info = OrderInfo( # desc_hash=desc_hash, # buyer_rsa_pubkey=public_key, # seller=buyertrans.web3.eth.defaultAccount, # proxy=buyertrans.web3.eth.defaultAccount, # secondary_proxy=buyertrans.web3.eth.defaultAccount, # proxy_value=10, # value=20, # time_allowed=100 # ) # test_server_id = buyertrans.place_order(order_info) # print(test_server_id) # buyertrans.withdraw_order(test_server_id) # print(buyertrans.query_order(test_server_id)) order_num = buyertrans.get_order_num() print(order_num) latest_order_info = buyertrans.query_order(order_num - 1) 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.load_key_pair_from_private_key( private_key_file_path, password) pub_key_bytes = Encoder.str_to_base64_byte(pub_key) pub_key_loaded = load_der_public_key(pub_key_bytes, backend=default_backend()) # print(Encoder.str_to_base64_byte(pub_key)) # print(len(Encoder.str_to_base64_byte(pub_key))) # print(pub_key_bytes_to_addr(Encoder.str_to_base64_byte(pub_key))) # print(len(pub_key_bytes_to_addr(Encoder.str_to_base64_byte(pub_key)))) print(get_addr_from_public_key(pub_key_loaded)) print(to_bytes(hexstr=latest_order_info[2])) print(len(to_bytes(hexstr=latest_order_info[2])))
def generate_private_key( password=b'cpchainisawesome') -> "returns key bytes": """ generate private key with RSA. we can use it like this : priv_key = RSACipher.generate_private_key(password=b'cpchainisawesome') pub_key = priv_key.public_key() pub_bytes = pub_key.public_bytes(encoding=serialization.Encoding.DER, format=serialization.PublicFormat.SubjectPublicKeyInfo) print(len(pub_bytes)) Args: password:password bytes Returns: private key object """ key = rsa.generate_private_key(public_exponent=65537, key_size=4096, backend=default_backend()) # Write our key to disk for safe keeping with open(join_with_root(config.wallet.rsa_private_key_file), "wb") as f: f.write( key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.BestAvailableEncryption( password), )) with open(join_with_root(config.wallet.rsa_private_key_password_file), "wb") as f: f.write(password) return key
def load_private_key(): """ load private key with key file and password file in cpchain.toml, key file path item: config.wallet.rsa_private_key_password_file password file path item: config.wallet.rsa_private_key_password_file Returns: private key object """ with open(join_with_root(config.wallet.rsa_private_key_password_file), "rb") as f: buyer_rsa_private_key_password = f.read() with open(join_with_root(config.wallet.rsa_private_key_file), "rb") as key_file: buyer_private_key = serialization.load_pem_private_key( key_file.read(), password=buyer_rsa_private_key_password, backend=default_backend()) return buyer_private_key
def __init__(self, wallet): self.wallet = wallet bin_path = join_with_root(config.chain.contract_bin_path) # deploy_contract(bin_path, config.chain.contract_name, default_w3) account = get_address_from_public_key_object(self.wallet.market_client.public_key) if default_w3: account = default_w3.toChecksumAddress(account) self.buyer = BuyerAgent(default_w3, bin_path, config.chain.contract_name, account) self.seller = SellerAgent(default_w3, bin_path, config.chain.contract_name, account) self.handler = Handler(self) self.monitor = Monitor(self)
def _set_web3(self): if self.web3 is None: mode = config.chain.mode if mode == "test": provider = TestRPCProvider() elif mode == "falcon": provider = HTTPProvider(config.chain.falcon_provider_addr) else: provider = IPCProvider( join_with_root(config.chain.ipc_provider_addr)) self.web3 = Web3(provider) self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
def _populate_accounts(self): key_dir = join_with_root(config.account.keystore_dir) ptn = osp.join(key_dir, 'UTC-*') # TODO for now, we use the password stored in the file key_passphrase = open(osp.join(key_dir, 'password')).read() for key_path in glob.glob(ptn): account = Account(key_path, key_passphrase) self.append(account) if len(self): self.default_account = self[0]
def publish_product(self, title, ptype=None): if not ptype: type_list = ['file', 'stream'] ptype = type_list[randint(0, 1)] description = 'stress testing description' price = randint(1, 10000) * 0.01 # could not be zero now. tags = 'stress testing tags' now = datetime.now() start_date = now.isoformat() end_date = (now + timedelta(days=7)).isoformat() category = 'stress testing category' cover_image = join_with_root('cpchain/assets/wallet/icons/[email protected]') self.selected_id += 1 return super().publish_product(self.selected_id, title, ptype, description, str(price), tags, start_date, end_date, category, cover_image)
def read_contract_address(contract_name): with open(join_with_root(config.chain.registrar_json)) as f: contracts = json.load(f) return contracts[contract_name]
def read_contract_interface(contract_name): with open(join_with_root(config.chain.contract_json)) as f: all_contracts = json.load(f) contract_interface = all_contracts['<stdin>:' + contract_name] return contract_interface
from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import rsa from cpchain.utils import join_with_root from cpchain import config # Generate our key key = rsa.generate_private_key( public_exponent=65537, key_size=4096, backend=default_backend() ) # Write our key to disk for safe keeping with open(join_with_root(config.wallet.rsa_private_key_file), "wb") as f: f.write(key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.BestAvailableEncryption(b"cpchainisawesome"), )) with open(join_with_root(config.wallet.rsa_private_key_password_file), "wb") as f: f.write(b"cpchainisawesome")
class Player: contract_path = join_with_root(config.chain.contract_bin_path) contract_name = config.chain.contract_name def __init__(self, account): self.address = account.address self.account = account self.buyer_agent = BuyerAgent(w3, self.contract_path, self.contract_name, self.address) self.seller_agent = SellerAgent(w3, self.contract_path, self.contract_name, self.address) self.proxy_agent = ProxyAgent(w3, self.contract_path, self.contract_name, self.address) self.rsa_public_key = generate_rsa_public_key() def query_order(self, order_id): return self.seller_agent.query_order(order_id) def mockup_product(self): private_key = ECCipher.create_private_key(self.account.privateKey) public_key = ECCipher.create_public_key_from_private_key(private_key) public_key = ECCipher.serialize_public_key(public_key) price = randint(1, 10000) * 0.01 return { 'description': 'stress testing description', 'signature': '304502201b31544ff65ebbfff3743a0b2536388e1f6cf2533de4bbf0ffab57d762f54d50022100a8101face8c6a6d2f0e01a9a01ea49d80598c880872db9e3c1e9eb27a23a2554', 'cover_image': 'upload_images/20181127072441_13.png', 'end_date': '2018-12-04T15:24:41.664517Z', 'msg_hash': 'dRFWYcWC9TKujDo7mLiUCq00MthHezzkyncAGIdaEos=', 'id': 53, 'start_date': '2018-11-27T15:24:41.664517Z', 'ptype': 'file', 'seq': 0, 'owner_address': public_key, 'tags': 'stress testing tags', 'price': price, 'title': 'stress testing product', 'category': 'stress testing category', 'status': 0, 'created': '2018-11-27T07:24:41.715315Z' } 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_confirm_order(self, order_id): w3.personal.unlockAccount(self.account.address, _passphrase) status = self.seller_agent.confirm_order(order_id) # w3.personal.lockAccount(self.account.address) return status def proxy_claim_fetched(self, order_id): w3.personal.unlockAccount(self.account.address, _passphrase) status = self.proxy_agent.claim_fetched(order_id) # w3.personal.lockAccount(self.account.address) return status def proxy_claim_delivered(self, order_id): w3.personal.unlockAccount(self.account.address, _passphrase) status = self.proxy_agent.claim_delivered(order_id, b'dummy') # w3.personal.lockAccount(self.account.address) return status def buyer_confirm_order(self, order_id): w3.personal.unlockAccount(self.account.address, _passphrase) status = self.buyer_agent.confirm_order(order_id) # w3.personal.lockAccount(self.account.address) return status
from eth_keys import keys from eth_keyfile import extract_key_from_keyfile from cpchain import config from cpchain.utils import join_with_root priv_bytes = extract_key_from_keyfile( join_with_root(config.wallet.private_key_file), open(join_with_root(config.wallet.private_key_password_file)).read()) print(priv_bytes) priv_key = keys.PrivateKey(priv_bytes) pub_key = priv_key.public_key addr = pub_key.to_address() print(addr)