def remove_peer_tx():
peer_key = IrohaCrypto.private_key()
tx = iroha.transaction(
[iroha.command('RemovePeer', public_key=peer.peer_key)],
creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def __init__(self, source_public, user, peer_address):
assert (user or peer_address)
self.source_public_key = source_public
self.private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.private_key)
self.user = user
self.peer_address = peer_address
def __init__(self, account_name, domain):
self.account_name = account_name
self.domain = domain
self.full_name = f"{self.account_name}@{self.domain}"
self.__private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.__private_key)
self.iroha = Iroha(self.full_name)
def save_keys_to_file(account_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = account_id + '.priv'
public_key_file = account_id + '.pub'
open(private_key_file, 'wb+').write(private_key)
open(public_key_file, 'wb+').write(public_key)
def create_agent(self, company_name, agent_name):
user_private_key = IrohaCrypto.private_key()
user_public_key = IrohaCrypto.derive_public_key(user_private_key)
commands = [
self.iroha.command('CreateAccount',
account_name=agent_name,
domain_id=company_name,
public_key=user_public_key),
self.iroha.command(
'GrantPermission',
account_id=get_full_acc(agent_name, company_name),
permission=primitive_pb2.can_set_my_account_detail),
self.iroha.command('AddSignatory',
account_id=self.admin_account,
public_key=user_public_key)
]
transaction = self.iroha.transaction(commands)
IrohaCrypto.sign_transaction(transaction, self.admin_private_key)
self.__send_transaction_and_print_status(transaction)
if self.__send_transaction_and_print_status(
transaction) == "COMMITTED":
return "Your private key: " + str(
user_private_key) + " Your public key: " + str(
user_public_key), 201
else:
return 'Internal Error', 500
def save_to_wallet_db(account_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = account_id + ".priv"
public_key_file = account_id + ".pub"
open(private_key_file, "wb+").write(private_key)
open(public_key_file, "wb+").write(public_key)
def generate_new_node_keys(node_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = node_id + '.priv'
public_key_file = node_id + '.pub'
open(private_key_file, 'wb+').write(private_key)
open(public_key_file, 'wb+').write(public_key)
return public_key
def generate_new_node_keys(node_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = node_id + ".priv"
public_key_file = node_id + ".pub"
open(private_key_file, "wb+").write(private_key)
open(public_key_file, "wb+").write(public_key)
return public_key
def add_peer_tx():
peer_key = IrohaCrypto.private_key()
peer = primitive_pb2.Peer()
peer.address = '192.168.10.10:50541'
peer.peer_key = IrohaCrypto.derive_public_key(peer_key)
tx = iroha.transaction([
iroha.command('AddPeer', peer=peer)
], creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def add_signatory_tx():
extra_key = IrohaCrypto.private_key()
tx = iroha.transaction([
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key))
],
creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def genesis_tx():
test_permissions = [primitive_pb2.can_set_quorum]
extra_key = IrohaCrypto.private_key()
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.append(
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key)))
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
def CreateAccount(self, accName):
user = User()
user.Name = accName + "@" + "domain"
user.PrivKey = IrohaCrypto.private_key()
user.PubKey = IrohaCrypto.derive_public_key(user.PrivKey)
tx = self.iroha.transaction([
self.iroha.command('CreateAccount', account_name=accName, domain_id='domain',
public_key=user.PubKey)
])
IrohaCrypto.sign_transaction(tx, self.admin_private_key)
self.SendTxAndPrintstatus(tx)
users.append(user)
def __init__(self, source_public, user, peer_address, source_private=None):
assert (user or peer_address)
self.used = False
self.source_public_key = source_public
if None == source_private:
self.private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.private_key)
else:
self.private_key = source_private
self.public_key = IrohaCrypto.derive_public_key(source_private)
assert (source_public == self.public_key.decode('utf-8'))
self.user = user
self.peer_address = peer_address
def send_tx():
rand_name = uuid.uuid4().hex
rand_key = IrohaCrypto.private_key()
domain = ADMIN_ACCOUNT_ID.split('@')[1]
tx = iroha.transaction([
iroha.command('CreateAccount',
account_name=rand_name,
domain_id=domain,
public_key=rand_key)
])
IrohaCrypto.sign_transaction(tx, ADMIN_PRIVATE_KEY)
net.send_tx(tx)
print('tx is sent')
async def create_accounts(i):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
user_name = str(i)
init_cmds = [
iroha.command('CreateAccount',
account_name=user_name,
domain_id='test',
public_key=public_key)
]
init_tx = iroha.transaction(init_cmds, creator_account='admin@test')
ic.sign_transaction(init_tx, admin_private_key)
await send_transaction(init_tx)
def grant_can_set_my_quorum_tx():
extra_key = IrohaCrypto.private_key()
tx = iroha.transaction([
iroha.command('GrantPermission',
account_id=bob['id'],
permission=primitive_pb2.can_set_my_quorum),
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key))
],
creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def add_user_to_db(userid,
guid,
conn,
tb_name=dbcfg['LEDGER_USER_TABLE_NAME']):
'''
Add a user to the Iroha ledger and the shared database.
N.B. userid should be in proper Iroha format, e.g. "user@domain".
The guid value (global platform-level user ID) should be passed from
the shared API, which will generate it.
'''
# check correct userid format
assert re.match(UID_PAT, userid) is not None, 'invalid userid format'
# empty placeholders for privkey / pubkey
privkey, pubkey = None, None
# check if userid already exists in SQL (for this ledger)
# this assumes that it is impossible to have user in SQL but not in Iroha...
if userid in get_user_data(conn)['LedgerUserID']:
warnings.warn('User already exists - nothing to add')
return
# check if userid already exists in Iroha (but not SQL yet)
if get_iroha_user_info(
userid).account_response.account.account_id != userid:
# we need to create a new account entirely
privkey = IrohaCrypto.private_key()
pubkey = IrohaCrypto.derive_public_key(privkey)
status = create_iroha_user_account(userid, pubkey)
# check status for correctness, throw if bad status
if status[0][0] == 'STATELESS_VALIDATION_FAILED':
warnings.warn('User create transaction failed - check tx format')
return
if status[0][0] == 'COMMITTED':
print('Successfully created user {} in Iroha'.format(userid))
# once we know that the account exists in Iroha, add it to SQL as well
ledgerid = get_ledgerids(conn, lname='Iroha')
if privkey is None:
privkey = ''
else:
privkey = str(privkey)[2:-1] # string representation of hex bytes
if pubkey is None:
pubkey = ''
else:
pubkey = str(pubkey)[2:-1] # string representation of hex bytes
user_info = (guid, ledgerid, userid, privkey, pubkey)
sql_qry = 'INSERT INTO {} VALUES (?,?,?,?,?)'.format(tb_name)
c = conn.cursor()
c.execute(sql_qry, user_info)
conn.commit()
print('Added user information for userid {} to SQL'.format(userid))
def create_client(self, client_name):
user_private_key = IrohaCrypto.private_key()
user_public_key = IrohaCrypto.derive_public_key(user_private_key)
commands = [
self.iroha.command('CreateAccount', account_name=client_name, domain_id="test",
public_key=user_public_key),
]
transaction = self.iroha.transaction(commands)
IrohaCrypto.sign_transaction(transaction, self.admin_private_key)
self.__send_transaction_and_print_status(transaction)
tx = self.iroha.transaction([
self.iroha.command('GrantPermission', account_id='admin@test',
permission=primitive_pb2.can_set_my_account_detail)
])
IrohaCrypto.sign_transaction(tx, user_private_key)
if self.__send_transaction_and_print_status(transaction) == "COMMITTED":
return "Your key: " + user_private_key, 201
else:
return 'Internal Error', 500
def register(self, request: Request, response: Response, auth: Auth,
validate: Validator):
errors = request.validate(
validate.required("name"),
validate.required("email"),
validate.required("type"),
validate.required("gov_id"),
validate.required("phone_number"),
)
if errors:
return errors
priv_key = IrohaCrypto.private_key()
pub_key = IrohaCrypto.derive_public_key(priv_key)
user = User()
user.name = request.input("name")
user.email = request.input("email")
user.type = request.input("type")
user.gov_id = request.input("gov_id")
user.phone_number = request.input("phone_number")
user.private_key = priv_key.decode("utf-8")
user.public_key = pub_key.decode("utf-8")
if user.type == "user":
user.password = str(random.randrange(1000, 9999))
else:
user.password = request.input("password")
blockchain_status = self.ibc.create_account(user)
iroha_message = iroha_messages.create_account_failed(blockchain_status)
if iroha_message != None:
return response.json(iroha_message)
blockchain_status = self.ibc.grant_set_account_detail_perms(user)
iroha_message = iroha_messages.grant_set_account_detail_perms_failed(
blockchain_status)
if iroha_message != None:
return response.json(iroha_message)
blockchain_status = self.ibc.set_account_details(user)
iroha_message = iroha_messages.set_account_details_failed(
blockchain_status)
if iroha_message != None:
return response.json(iroha_message)
if user.type != "user":
blockchain_status = self.ibc.append_role(user)
iroha_message = iroha_messages.append_role_failed(
blockchain_status)
if iroha_message != None:
return response.json(iroha_message)
if user.type == "user":
blockchain_status = self.ibc.revoke_set_account_detail_perms(user)
iroha_message = iroha_messages.revoke_set_account_detail_perms_failed(
blockchain_status)
if iroha_message != None:
return response.json(iroha_message)
res = auth.register({
"name": user.name,
"email": user.email,
"password": user.password,
"type": user.type,
"private_key": user.private_key,
"public_key": user.public_key,
"gov_id": user.gov_id,
"phone_number": user.phone_number,
})
if res is None and user.type == "user":
message = Mail(
from_email=env("MAIL_FROM_ADDRESS"),
to_emails=user.email,
subject="Afya Mkononi Auth Details",
html_content=
f"<div> <p>Welcome to this cool health service</p> <p>Your email: { user.email }</p> <p>Your Password: { user.password }</p>",
)
sg = SendGridAPIClient(env("SENDGRID_KEY"))
sg.send(message)
return response.json(
{"success": "Check your email for your credentials"})
elif res is None:
return response.json({"success": "Account has been added"})
return response.json({"error": "Failed to add account"})
def generate_keypair():
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
return public_key, private_key
IROHA_PORT = os.getenv('IROHA_PORT', '50051')
ADMIN_ACCOUNT_ID = os.getenv('ADMIN_ACCOUNT_ID', 'admin@test')
admin_private_key_path = IROHA_CONFIG_KEY_PATH + ADMIN_ACCOUNT_ID + '.priv'
with open(admin_private_key_path, "r") as key_file:
ADMIN_PRIVATE_KEY = ''.join(key_file.readlines())
account_id = uuid.uuid1().hex # because Iroha doesn't like "-" in its ids
account_private_key = None
account_public_key = None
account_private_key_path = f'{IROHA_KEY_PATH}{account_id}@test.priv'
if os.path.exists(account_private_key_path):
with open(account_private_key_path, "w") as key_file:
account_private_key = ''.join(key_file.readlines())
else:
account_private_key = IrohaCrypto.private_key()
with open(account_private_key_path, "w") as key_file:
key_file.write(account_private_key.decode("ASCII"))
account_public_key_path = f'{IROHA_KEY_PATH}{account_id}@test.pub'
if os.path.exists(account_public_key_path):
with open(account_public_key_path, "w") as key_file:
account_public_key = ''.join(key_file.readlines())
else:
account_public_key = IrohaCrypto.derive_public_key(account_private_key)
with open(account_public_key_path, "w") as key_file:
key_file.write(account_public_key.decode("ASCII"))
iroha = Iroha(ADMIN_ACCOUNT_ID)
net = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR, IROHA_PORT))
# IrohaGrpc net for peer 1, 2, 3
net_1 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_1, IROHA_PORT_1))
net_2 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_2, IROHA_PORT_2))
net_3 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_3, IROHA_PORT_3))
# Admin Account loading with Admin's private key
ADMIN_PRIVATE_KEY = os.getenv(
'ADMIN_PRIVATE_KEY',
'f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70')
# Admin's account
ADMIN_ACCOUNT_ID = os.getenv('ADMIN_ACCOUNT_ID', 'admin@test')
iroha_admin = Iroha(ADMIN_ACCOUNT_ID)
# Satoshi's crypto material generation
satoshi_private_key = IrohaCrypto.private_key()
satoshi_public_key = IrohaCrypto.derive_public_key(satoshi_private_key)
# Satoshi's account
SATOSHI_ACCOUNT_ID = os.getenv('SATOSHI_ACCOUNT_ID', 'satoshi@test')
iroha_satoshi = Iroha(SATOSHI_ACCOUNT_ID)
# Nakamoto's crypto material generation
nakamoto_private_key = IrohaCrypto.private_key()
nakamoto_public_key = IrohaCrypto.derive_public_key(nakamoto_private_key)
# Nakamoto's account
NAKAMOTO_ACCOUNT_ID = os.getenv('NAKAMOTO_ACCOUNT_ID', 'nakamoto@test')
iroha_nakamoto = Iroha(NAKAMOTO_ACCOUNT_ID)
print("""
Please ensure about MST in iroha config file.
""")
def new_user(user_id):
private_key = IrohaCrypto.private_key()
if user_id.lower().startswith('admin'):
print('K{}'.format(private_key.decode('utf-8')))
return {'id': user_id, 'key': private_key}
def generate_kp():
global iroha
pk = ic.private_key()
user_private_key = pk
user_public_key = ic.derive_public_key(user_private_key)
return user_private_key, user_public_key
if sys.version_info[0] < 3:
raise Exception("Python 3 or a more recent version is required.")
# Here is the information about the environment and admin account information:
IROHA_HOST_ADDR = os.getenv("IROHA_HOST_ADDR", "127.0.0.1")
IROHA_PORT = os.getenv("IROHA_PORT", "50051")
ADMIN_ACCOUNT_ID = os.getenv("ADMIN_ACCOUNT_ID", "admin@test")
ADMIN_PRIVATE_KEY = os.getenv(
"ADMIN_PRIVATE_KEY",
"f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70",
)
iroha = Iroha(ADMIN_ACCOUNT_ID)
net = IrohaGrpc("{}:{}".format(IROHA_HOST_ADDR, IROHA_PORT))
test_private_key = IrohaCrypto.private_key()
test_public_key = IrohaCrypto.derive_public_key(test_private_key).decode(
"utf-8")
@integration_helpers.trace
def create_contract():
bytecode = "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"
"""Bytecode was generated using remix editor https://remix.ethereum.org/ from file role.sol. """
tx = iroha.transaction(
[iroha.command("CallEngine", caller=ADMIN_ACCOUNT_ID, input=bytecode)])
IrohaCrypto.sign_transaction(tx, ADMIN_PRIVATE_KEY)
net.send_tx(tx)
hex_hash = binascii.hexlify(IrohaCrypto.hash(tx))
for status in net.tx_status_stream(tx):
print(status)
worker8_private_key = '3c08c360f0d69eff638c50609d11c57cd9aeaaca9f55e6808f5e008fdcd3788e'
worker8_public_key = IrohaCrypto.derive_public_key(worker8_private_key)
worker8_name = 'worker8'
worker8_account_id = worker8_name + '@' + domain_id
iroha_worker8 = Iroha('worker8@federated')
# worker9 node
######################
worker9_private_key = '3587faf346d017b6e103332f681a9a109bb599ed7ee52c6441e2afe78b2fab40'
worker9_public_key = IrohaCrypto.derive_public_key(worker9_private_key)
worker9_name = 'worker9'
worker9_account_id = worker9_name + '@' + domain_id
iroha_worker9 = Iroha('worker9@federated')
# worker10 node
######################
worker10_private_key = '8dfeda110938efb253fe5fe8804234a8bc6d4b1e366e68c4d7a93840e305a159'
worker10_public_key = IrohaCrypto.derive_public_key(worker10_private_key)
worker10_name = 'worker10'
worker10_account_id = worker10_name + '@' + domain_id
iroha_worker10 = Iroha('worker10@federated')
# # To create private and public keys for nodes use
user_p_key = IrohaCrypto.private_key()
print('private: ', user_p_key)
# print('public: ', IrohaCrypto.derive_public_key('f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70'))
def create(acc_name, domain_name):
"""
This route creates a new private key, derives the public key and then sends it
back to the requester in a json form.
Parameters
----------
acc_name : str
The name of the account to be created. Must be unique.
domain_name : str
The name of the domain where the account should be register.
Returns
-------
response : json
A response containing the created keys.
"""
private_key = IrohaCrypto.private_key().decode('utf-8')
public_key = IrohaCrypto.derive_public_key(private_key).decode('utf-8')
iroha_network = IrohaGrpc(constants.iroha_network)
iroha_client = constants.iroha_client
# Defining the account creation transaction
new_account_tx = iroha_client.transaction([
iroha_client.command(
'CreateAccount',
account_name=acc_name,
domain_id=domain_name,
public_key=public_key
)
])
# Signing the transaction with the instrumentality private key
IrohaCrypto.sign_transaction(new_account_tx, constants.private_key)
# Sending the transaction to be validated by the peers
iroha_network.send_tx(new_account_tx)
encoder = json.encoder.JSONEncoder()
response = {}
for status in iroha_network.tx_status_stream(new_account_tx):
if status[0] == "STATEFUL_VALIDATION_FAILED":
response['status'] = 'error'
# Checking which error we got
# First error: Couldn't create account. Internal error.
if status[2] == 1:
response['msg'] = "Couldn't create account. Internal error."
response['code'] = "500"
return encoder.encode(response), 500
# Second error: No such permissions
elif status[2] == 2:
response['msg'] = "The node doesn't have permission to create accounts."
response['code'] = "403"
return encoder.encode(response), 403
# Third error: No such domain
elif status[2] == 3:
response['msg'] = "There is no such domain."
response['code'] = "404"
return encoder.encode(response), 404
# Fourth error: Account already exists
elif status[2] == 4:
response['msg'] = "Account with this name already exists."
response['code'] = "403"
return encoder.encode(response), 403
elif status[0] == "COMMITTED":
response['status'] = "success"
response['private_key'] = private_key
response['public_key'] = public_key
response['msg'] = "Transaction written in ledger."
response['code'] = 200
return encoder.encode(response), 200
def user_pub_priv_key(self):
user_private_key = IrohaCrypto.private_key()
user_public_key = IrohaCrypto.derive_public_key(user_private_key)
return user_private_key, user_public_key
#
# Copyright Soramitsu Co., Ltd. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
#
from iroha import Iroha, IrohaCrypto
from iroha import primitive_pb2
import commons
admin = commons.new_user('admin@test')
alice = commons.new_user('alice@test')
iroha = Iroha(admin['id'])
peer_key = IrohaCrypto.private_key()
peer = primitive_pb2.Peer()
peer.address = '192.168.10.10:50541'
peer.peer_key = IrohaCrypto.derive_public_key(peer_key)
@commons.hex
def genesis_tx():
test_permissions = [primitive_pb2.can_remove_peer]
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.append(Iroha.command('AddPeer', peer=peer))
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
@commons.hex
def remove_peer_tx():
from iroha import IrohaCrypto
node1_private_key = IrohaCrypto.private_key()
node1_public_key = IrohaCrypto.derive_public_key(node1_private_key)
print('node 1 private key: ', node1_private_key)
print('node 1 public key: ', node1_public_key)
# node2_private_key = IrohaCrypto.private_key()
# node2_public_key = IrohaCrypto.derive_public_key(node2_private_key)
