def create_user_id(self, num_pubkeys=1, public_keys=None):
keypair = bbclib.KeyPair()
user_id = hashlib.sha256(bytes(keypair.public_key)).digest()
# FIXME: detect collision
initial_keypairs = []
if public_keys is None:
public_keys = []
for i in range(num_pubkeys):
new_keypair = bbclib.KeyPair()
initial_keypairs.append(new_keypair)
public_keys.append(new_keypair.public_key)
directive = Directive(Directive.CMD_REPLACE, public_keys)
tx = bbclib.make_transaction_for_base_asset(
asset_group_id=self.namespace_id, event_num=1)
tx.events[0].asset.add(user_id=user_id,
asset_body=directive.serialize())
tx.events[0].add(mandatory_approver=user_id)
tx.add(witness=bbclib.BBcWitness())
tx.witness.add_witness(user_id)
self.sign_and_insert(tx, user_id, keypair)
return (user_id, initial_keypairs)
def test_00_setup(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
print("domain_id =", binascii.b2a_hex(domain_id))
keypair = bbclib.KeyPair()
keypair.generate()
keyname = domain_id.hex() + ".pem"
try:
os.mkdir(".bbc1")
except:
pass
with open(os.path.join(".bbc1", keyname), "wb") as f:
f.write(keypair.get_private_key_in_pem())
global msg_processor
prepare(core_num=core_num, client_num=client_num, loglevel=LOGLEVEL)
for i in range(core_num):
start_core_thread(index=i,
core_port_increment=i,
p2p_port_increment=i)
time.sleep(0.1)
domain_setup_utility(i, domain_id) # system administrator
time.sleep(1)
for i in range(client_num):
msg_processor[i] = MessageProcessor(index=i)
make_client(index=i,
core_port_increment=i,
callback=msg_processor[i])
time.sleep(1)
global cores, clients
cores, clients = get_core_client()
def test_keypair_generate():
"""
"""
keypair = bbclib.KeyPair()
keypair.generate()
assert (keypair.private_key_len.value == 32)
assert (keypair.public_key_len.value == 65)
def test_00_key_setup(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
keypair = bbclib.KeyPair()
keypair.generate()
keyname = domain_id.hex() + ".pem"
with open(keyname, "wb") as f:
f.write(keypair.get_private_key_in_pem())
def create_keypair():
keypair = bbclib.KeyPair()
keypair.generate()
with open(PRIVATE_KEY, "wb") as fout:
fout.write(keypair.private_key)
with open(PUBLIC_KEY, "wb") as fout:
fout.write(keypair.public_key)
print("created private_key and public_key : %s, %s" % (PRIVATE_KEY, PUBLIC_KEY))
def from_dict(dic):
user_id = bytes(binascii.a2b_hex(dic['user_id']))
public_key = bytes(binascii.a2b_hex(dic['public_key']))
private_key = bytes(binascii.a2b_hex(dic['private_key']))
return User(user_id,
bbclib.KeyPair(privkey=private_key, pubkey=public_key),
dic['is_selected'])
def make_user(index):
global users
keypair = bbclib.KeyPair()
keypair.generate()
user_info = {
'user_id': bbclib.get_new_id("user_%i" % index),
'keypair': keypair,
}
users.append(user_info)
def test_keypair_pubkey():
"""
"""
keypair = bbclib.KeyPair(type=bbclib.KeyType.ECDSA_SECP256k1,
privkey=in_privkey)
keypair.mk_keyobj_from_private_key()
assert (keypair.public_key_len.value == 65)
assert (bytes(
keypair.public_key)[:keypair.public_key_len.value] == in_pubkey)
def test_00_setup(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
print("domain_id =", binascii.b2a_hex(domain_id))
global keyname
keypair = bbclib.KeyPair()
keypair.generate()
keyname = os.path.join(".bbc1", domain_id.hex() + ".pem")
try:
os.mkdir(".bbc1")
except:
pass
with open(keyname, "wb") as f:
f.write(keypair.get_private_key_in_pem())
keypair_dummy = bbclib.KeyPair()
keypair_dummy.generate()
with open(os.path.join(".bbc1", "dummy.pem"), "wb") as f:
f.write(keypair_dummy.get_private_key_in_pem())
with open(os.path.join(".bbc1", "testconf.json"), "wb") as f:
f.write(json.dumps(config_file_content).encode())
global msg_processor
prepare(core_num=core_num,
client_num=client_num,
conf_file=os.path.join(".bbc1", "testconf.json"),
loglevel=LOGLEVEL)
for i in range(core_num):
start_core_thread(index=i,
core_port_increment=i,
p2p_port_increment=i,
use_nodekey=True)
time.sleep(0.1)
time.sleep(1)
for i in range(client_num):
msg_processor[i] = MessageProcessor(index=i)
make_client(index=i,
core_port_increment=i,
callback=msg_processor[i])
time.sleep(1)
global cores, clients
cores, clients = get_core_client()
def test_06_domain_key_change(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
keypair = bbclib.KeyPair()
keypair.generate()
keyname = domain_id.hex() + ".pem"
with open(keyname, "wb") as f:
f.write(keypair.get_private_key_in_pem())
for i, nw in enumerate(networkings):
nw.get_domain_keypair(domain_id)
keypair = bbclib.KeyPair()
keypair.generate()
keyname = domain_id.hex() + ".pem"
with open(keyname, "wb") as f:
f.write(keypair.get_private_key_in_pem())
for i, nw in enumerate(networkings):
nw.get_domain_keypair(domain_id)
def set_domain_key(self, pem_file=None):
"""
Set domain_auth_key to this client
:param pem_file:
:return:
"""
if pem_file is None:
self.domain_keypair = None
try:
self.domain_keypair = bbclib.KeyPair()
with open(pem_file, "r") as f:
self.domain_keypair.mk_keyobj_from_private_key_pem(f.read())
except:
return
def test_keypair_pem():
"""
"""
keypair = bbclib.KeyPair(type=bbclib.KeyType.ECDSA_SECP256k1,
privkey=in_privkey,
pubkey=in_pubkey)
pem = keypair.get_private_key_in_pem()
assert (bytes(pem) == in_pem[:(len(in_pem) - 1)]) # ヌル終端を取り除いて比較する。
keypair.mk_keyobj_from_private_key_pem(str(pem)) # 文字列化する。
assert (bytes(
keypair.private_key)[:keypair.private_key_len.value] == in_privkey)
assert (bytes(
keypair.public_key)[:keypair.public_key_len.value] == in_pubkey)
def test_keypair_der():
"""
"""
keypair = bbclib.KeyPair(type=bbclib.KeyType.ECDSA_SECP256k1,
privkey=in_privkey,
pubkey=in_pubkey)
der = keypair.get_private_key_in_der()
assert (der == in_der)
keypair.mk_keyobj_from_private_key_der(der)
assert (bytes(
keypair.private_key)[:keypair.private_key_len.value] == in_privkey)
assert (bytes(
keypair.public_key)[:keypair.public_key_len.value] == in_pubkey)
def test_map_creation_with_pubkeys(default_domain_id):
NUM_KEYPAIRS = 3
public_keys = []
for i in range(NUM_KEYPAIRS):
keypair = bbclib.KeyPair()
public_keys.append(keypair.public_key)
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
(user_id, keypairs) = idPubkeyMap.create_user_id(public_keys=public_keys)
assert len(keypairs) == 0
for i in range(NUM_KEYPAIRS):
assert idPubkeyMap.is_mapped(user_id, public_keys[i]) == True
def replace_keypair(name, dic, file_name):
for name0, user in dic.items():
if name0 == name:
keypair_old = user.keypair
keypair = bbclib.KeyPair()
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
idPubkeyMap.update(user.user_id,
public_keys_to_replace=[keypair.public_key],
keypair=keypair_old)
user.keypair = keypair
break
write_dic(file_name, dic)
print("public key for %s is renewed:" % (name))
print("old:", binascii.b2a_hex(keypair_old.public_key).decode())
print("new:", binascii.b2a_hex(keypair.public_key).decode())
def make_client(index,
core_port_increment,
callback=None,
connect_to_core=True,
asset_group_id=None):
keypair = bbclib.KeyPair()
keypair.generate()
clients[index]['user_id'] = bbclib.get_new_id("user_%i" % index)
clients[index]['keypair'] = keypair
if connect_to_core:
clients[index]['app'] = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT +
core_port_increment,
loglevel=loglv)
clients[index]['app'].set_user_id(clients[index]['user_id'])
clients[index]['app'].set_asset_group_id(asset_group_id)
if callback is not None:
clients[index]['app'].set_callback(callback)
print("[%i] user_id = %s" %
(index, binascii.b2a_hex(clients[index]['user_id'])))
def sys_check(args):
if args.command_type in ("store", "update", "verify") and \
not os.path.exists(args.target_file):
raise Exception("file not found : %s" % args.target_file)
# TODO consider whether to check core accessibility
if args.command_type != "keypair":
if not os.path.exists(PRIVATE_KEY):
message = "not exist private key\n"
message += "create a key pair with keypair option"
raise Exception(message)
if not os.path.exists(PUBLIC_KEY):
message = "not exist public key\n"
message += "create a key pair with keypair option"
raise Exception(message)
with open(PRIVATE_KEY, "rb") as fin:
private_key = fin.read()
with open(PUBLIC_KEY, "rb") as fin:
public_key = fin.read()
global key_pair
key_pair = bbclib.KeyPair(privkey=private_key, pubkey=public_key)
def test_map_update(default_domain_id):
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
(user_id, keypairs) = idPubkeyMap.create_user_id(num_pubkeys=1)
assert len(keypairs) == 1
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == True
public_keys = []
for i in range(3):
keypair = bbclib.KeyPair()
public_keys.append(keypair.public_key)
tx = idPubkeyMap.update(user_id,
public_keys_to_replace=public_keys,
keypair=keypairs[0])
assert idPubkeyMap.is_mapped(user_id, keypairs[0].public_key) == False
for i in range(3):
assert idPubkeyMap.is_mapped(user_id, public_keys[i]) == True
def test_00_setup(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
print("domain_id =", binascii.b2a_hex(domain_id))
prepare(core_num=core_num, client_num=client_num, loglevel=LOGLEVEL)
for i in range(core_num):
start_core_thread(index=i,
core_port_increment=i,
p2p_port_increment=i)
time.sleep(1)
global cores
cores = testutils.cores
for i in range(client_num):
clients[i] = setup_bbc_client(i, user_ids[i])
ret = clients[i].register_to_core()
assert ret
keypairs[i] = bbclib.KeyPair()
keypairs[i].generate()
time.sleep(1)
def test_keypair_sign_and_verify():
"""
"""
digest = binascii.a2b_hex(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
keypair = bbclib.KeyPair(type=bbclib.KeyType.ECDSA_SECP256k1,
privkey=in_privkey,
pubkey=in_pubkey)
signature = keypair.sign(digest)
print("signature = {}".format(signature))
ret = keypair.verify(digest, signature)
# print("ret = {}".format(ret))
assert (ret == 1)
not_digest = binascii.a2b_hex("bbbbbb")
ret = keypair.verify(not_digest, signature)
# print("ret = {}".format(ret))
assert (ret == 0)
def get_domain_keypair(self, domain_id):
"""
(internal use) Get domain_keys (private key and public key)
:param domain_id:
:return:
"""
keyconfig = self.config.get_config().get('domain_auth_key', None)
if keyconfig is None:
self.domains[domain_id]['keypair'] = None
return
if 'use' not in keyconfig or not keyconfig['use']:
return
if 'directory' not in keyconfig or not os.path.exists(
keyconfig['directory']):
self.domains[domain_id]['keypair'] = None
return
domain_id_str = domain_id.hex()
keypair = bbclib.KeyPair()
try:
with open(
os.path.join(keyconfig['directory'],
domain_id_str + ".pem"), "r") as f:
keypair.mk_keyobj_from_private_key_pem(f.read())
except:
self.domains[domain_id]['keypair'] = None
return
self.domains[domain_id].setdefault('keypair', dict())
self.domains[domain_id]['keypair'].setdefault('keys', list())
self.domains[domain_id]['keypair']['keys'].insert(0, keypair)
timer = self.domains[domain_id]['keypair'].setdefault('timer', None)
if timer is None or not timer.active:
self.domains[domain_id]['keypair'][
'timer'] = query_management.QueryEntry(
expire_after=keyconfig['obsolete_timeout'],
data={KeyType.domain_id: domain_id},
callback_expire=self.delete_obsoleted_domain_keys)
else:
timer.update_expiration_time(keyconfig['obsolete_timeout'])
self.domains[domain_id]['keypair']['keys'].insert(0, keypair)
LOGLEVEL = 'debug'
LOGLEVEL = 'info'
core_num = 3
client_num = 3
cores = None
clients = None
domain_id = bbclib.get_new_id("testdomain")
asset_group_id = bbclib.get_new_id("asset_group_1")
transaction = None
txid = None
user_id1 = bbclib.get_new_id("destination_id_test1")
txid1 = bbclib.get_new_id("dummy_txid_1")
keypair = bbclib.KeyPair()
keypair.generate()
result_queue = queue.Queue()
def make_user(index):
global users
keypair = bbclib.KeyPair()
keypair.generate()
user_info = {
'user_id': bbclib.get_new_id("user_%i" % index),
'keypair': keypair,
}
users.append(user_info)
def test_map_eval(default_domain_id):
idPubkeyMap = id_lib.BBcIdPublickeyMap(default_domain_id)
(user_id, keypairs0) = idPubkeyMap.create_user_id()
time0 = int(time.time())
print("\n2-second interval.")
time.sleep(2)
keypairs1 = []
public_keys = []
for i in range(3):
keypairs1.append(bbclib.KeyPair())
public_keys.append(keypairs1[i].public_key)
tx = idPubkeyMap.update(user_id,
public_keys_to_add=public_keys,
keypair=keypairs0[0])
time1 = int(time.time())
print("2-second interval.")
time.sleep(2)
tx = idPubkeyMap.update(user_id,
public_keys_to_remove=public_keys,
keypair=keypairs0[0])
time2 = int(time.time())
print("2-second interval.")
time.sleep(2)
tx = idPubkeyMap.update(user_id,
public_keys_to_replace=public_keys,
keypair=keypairs0[0])
time3 = int(time.time())
public_keys = idPubkeyMap.get_mapped_public_keys(user_id, time3)
assert len(public_keys) == 3
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time3) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time3) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time3) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time3) == True
public_keys = idPubkeyMap.get_mapped_public_keys(user_id, time2)
assert len(public_keys) == 1
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time2) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time2) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time2) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time2) == False
public_keys = idPubkeyMap.get_mapped_public_keys(user_id, time1)
assert len(public_keys) == 4
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time1) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time1) == True
public_keys = idPubkeyMap.get_mapped_public_keys(user_id, time0)
assert len(public_keys) == 1
for keypair in keypairs0:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key,
time0) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key,
time0) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key,
time0) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key,
time0) == False
idPubkeyMap._BBcIdPublickeyMap__clear_local_database(user_id)
print("cleared local database entries for the user for reconstruction.")
public_keys = idPubkeyMap.get_mapped_public_keys(user_id)
assert len(public_keys) == 3
for keypair in keypairs1:
assert bytes(keypair.public_key) in public_keys
assert idPubkeyMap.is_mapped(user_id, keypairs0[0].public_key) == False
assert idPubkeyMap.is_mapped(user_id, keypairs1[0].public_key) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[1].public_key) == True
assert idPubkeyMap.is_mapped(user_id, keypairs1[2].public_key) == True
transaction_id = get_transaction.transaction_id
transaction_info = store_proc(data, approver_id=binascii.unhexlify(new_owner),txid=transaction_id)
bbc_app_client.send_message(transaction_info, asset_group_id, binascii.unhexlify(new_owner))
print("Transfer is done.....")
if __name__ == '__main__':
if(not os.path.exists(PRIVATE_KEY) and not os.path.exists(PUBLIC_KEY)):
create_keypair()
with open(PRIVATE_KEY, "rb") as fin:
private_key = fin.read()
with open(PUBLIC_KEY, "rb") as fin:
public_key = fin.read()
asset_group_setup()
key_pair = bbclib.KeyPair(privkey=private_key, pubkey=public_key)
user_id = bbclib.get_new_id(str(binascii.b2a_hex(key_pair.public_key)), include_timestamp=False)
print("welcome to sample coin manage!")
print("Your id: %s" % binascii.b2a_hex(user_id))
print("Type command(help to see command list)")
while(True):
command = input('>> ')
if command == "help":
print("generate - generate coin")
print("get - get coin info")
print("send - send coin")
print("recieve - wait for recieve coin")
print("exit - exit coin manage")
elif command == "generate":
print("Type price generate coin")
address = input('>> ')
import pprint
import sys
sys.path.extend(["../"])
from bbc1.common import bbclib
from bbc1.core import bbc_stats
from bbc1.core.data_handler import DataHandler
user_id1 = bbclib.get_new_id("destination_id_test1")
user_id2 = bbclib.get_new_id("destination_id_test2")
domain_id = bbclib.get_new_id("test_domain")
asset_group_id1 = bbclib.get_new_id("asset_group_1")
asset_group_id2 = bbclib.get_new_id("asset_group_2")
txid1 = bbclib.get_new_id("dummy_txid_1")
txid2 = bbclib.get_new_id("dummy_txid_2")
keypair1 = bbclib.KeyPair()
keypair1.generate()
transactions = list()
data_handler = None
config = {
"domains": {
bbclib.convert_id_to_string(domain_id): {
"storage": {
"type": "internal",
},
"db": {
"db_type":
"mysql",
"db_name":
