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 sign_document(xml_string, private_key): if private_key is None: keypair = bbclib.KeyPair() keypair.generate() print('Keep this privately:') print('private key : {0}'.format( binascii.b2a_hex(keypair.private_key).decode())) print('') else: keypair = bbclib.KeyPair(privkey=binascii.a2b_hex(private_key)) if xml_string.endswith('.xml'): tree = ET.parse(xml_string) e = tree.getroot() else: s = xml_string.encode('utf-8') e = ET.fromstring(s) digest = hashlib.sha256(registry_lib.file(e)).digest() sig = keypair.sign(digest) print('Put the following as attributes of your XML document root:') print('algo="{0}"'.format('ecdsa-p256v1')) print('sig="{0}"'.format(binascii.b2a_hex(sig).decode())) print('pubkey="{0}"'.format(binascii.b2a_hex(keypair.public_key).decode()))
def create_user_id(self, num_pubkeys=1, public_keys=None, key_types=None, label=None): """Creates a user ID (and key pairs) and map public keys to it. Args: num_pubkeys (int): The number of new public keys to map to the ID. public_keys (list): The public keys to map. None by default. key_types (list): Types of the public keys. None by default. label (TransactionLabel): Label of transaction. None by default. Returns: user_id (bytes): The created user ID. initial_keypairs (list): The list of created key pairs. """ keypair = bbclib.KeyPair(curvetype=self.default_key_type) keypair.generate() 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(curvetype=self.default_key_type) new_keypair.generate() initial_keypairs.append(new_keypair) public_keys.append(new_keypair.public_key) directive = Directive(Directive.CMD_REPLACE, public_keys, key_types) tx = bbclib.make_transaction(event_num=1, witness=True) tx.events[0].asset_group_id = self.namespace_id tx.events[0].asset.add(user_id=user_id, asset_body=directive.serialize( self.default_key_type)) tx.events[0].add(mandatory_approver=user_id) if label is not None: tx.add(event=label.get_event()) tx.witness.add_witness(user_id) self.sign_and_insert(tx, user_id, keypair) return user_id, initial_keypairs
def read_keypair_file(): with open(PRIVATE_KEY, "rb") as fin: private_key = fin.read() with open(PUBLIC_KEY, "rb") as fin: public_key = fin.read() key_pair = bbclib.KeyPair(privkey=private_key, pubkey=public_key) return key_pair
def replace_keypair(): username = request.json.get('username') password_digest_str = request.json.get('password_digest_str') if username is None: return jsonify(message="user name is nothing."), 404 user = g.store.read_user(username, 'user_table') if user is None: return jsonify(message='user {0} is not found'.format(username)), 404 if user.password != password_digest_str: return jsonify(message='password is incorrect.'), 404 keypair_old = user.keypair keypair = bbclib.KeyPair() keypair.generate() g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id) g.idPubkeyMap.update(user.user_id, public_key_to_replace=[keypair.public_key], keypair=keypair_old) user.keypair = keypair g.store.update(user, 'user_table') return jsonify( pulic_key_str=bbclib.convert_id_to_string(keypair.public_key), private_key_str=bbclib.convert_id_to_string(keypair.private_key)), 200
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))
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 make_client(index, core_port_increment, callback=None, connect_to_core=True, domain_id=None): keypair = bbclib.KeyPair() keypair.generate() clients[index]['user_id'] = bbclib.get_new_id("user_%i" % index) clients[index]['keypair'] = keypair clients[index]['app'] = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT + core_port_increment, multiq=False, loglevel=loglv) if connect_to_core: if domain_id is None: global common_domain_id domain_id = common_domain_id clients[index]['app'].set_user_id(clients[index]['user_id']) clients[index]['app'].set_domain_id(domain_id) if callback is not None: clients[index]['app'].set_callback(callback) working_dir = ".bbc1-%i/" % (DEFAULT_CORE_PORT + core_port_increment) if os.path.exists(os.path.join(working_dir, "node_key.pem")): clients[index]['app'].set_node_key( os.path.join(working_dir, "node_key.pem")) time.sleep(1) print("[%i] user_id = %s" % (index, binascii.b2a_hex(clients[index]['user_id'])))
def test_keypair_generate(): """ """ keypair = bbclib.KeyPair() keypair.generate() assert (keypair.private_key_len.value == 32) assert (keypair.public_key_len.value == 65)
def generate_keypair(): keypair = bbclib.KeyPair() keypair.generate() print('private key : {0}'.format( binascii.b2a_hex(keypair.private_key).decode())) print('public key : {0}'.format( binascii.b2a_hex(keypair.public_key).decode())) return
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 get_keypair(): keypair = bbclib.KeyPair() keypair.generate() return jsonify({ 'pubkey': binascii.b2a_hex(keypair.public_key).decode(), 'privkey': binascii.b2a_hex(keypair.private_key).decode() })
def create_keypair(): if request.method == 'GET': keypair = bbclib.KeyPair() keypair.generate() save_keypair(keypair) return render_template('fileproof/message.html', message="Keypair was created successfully.")
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(curvetype=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 store_proc(asset_body, asset_file, asset_group_id, domain_id, key_pair, user_id, txid=None): bbc_app_client = setup_bbc_client(domain_id, user_id) store_transaction = bbclib.make_transaction(relation_num=1, witness=True) bbclib.add_relation_asset(store_transaction, relation_idx=0, asset_group_id=asset_group_id, user_id=user_id, asset_body=asset_body, asset_file=asset_file) store_transaction.witness.add_witness(user_id) if txid: bbc_app_client.search_transaction(txid) response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: return None, None, "ERROR: %s" % response_data[ KeyType.reason].decode() prev_tx, fmt_type = bbclib.deserialize( response_data[KeyType.transaction_data]) keypair = bbclib.KeyPair(privkey=key_pair.private_key, pubkey=key_pair.public_key) if not keypair.verify(prev_tx.transaction_id, prev_tx.signatures[0].signature): return None, None, "ERROR: Signature or keypair is invalid." bbclib.add_relation_pointer(transaction=store_transaction, relation_idx=0, ref_transaction_id=prev_tx.transaction_id) sig = store_transaction.sign(private_key=key_pair.private_key, public_key=key_pair.public_key) store_transaction.get_sig_index(user_id) store_transaction.add_signature_object(user_id=user_id, signature=sig) store_transaction.digest() print(store_transaction) ret = bbc_app_client.insert_transaction(store_transaction) assert ret response_data = bbc_app_client.callback.synchronize() if response_data[KeyType.status] < ESUCCESS: return None, None, "ERROR: %s" % response_data[KeyType.reason].decode() transaction_id = response_data[KeyType.transaction_id] asset_ids = store_transaction.relations[0].asset.asset_id return asset_ids, transaction_id, None
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 create_keypair(): if request.method == 'GET': keypair = bbclib.KeyPair() keypair.generate() return jsonify(private_key_str=bbclib.convert_id_to_string( keypair.private_key), public_key_str=bbclib.convert_id_to_string( keypair.public_key)), 200
def test_00_key_setup(self): print("\n-----", sys._getframe().f_code.co_name, "-----") try: os.mkdir(".bbc1-domainkeys") except: pass keypair = bbclib.KeyPair() keypair.generate() keyname = os.path.join(".bbc1-domainkeys", domain_id.hex() + ".pem") with open(keyname, "wb") as f: f.write(keypair.get_private_key_in_pem())
def test_keypair_pem(): keypair = bbclib.KeyPair(curvetype=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(pem.decode()) # 文字列化する。 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 set_node_key(self, pem_file=None): """Set node_key to this client Args: pem_file (str): path string for the pem file """ if pem_file is None: self.node_keypair = None try: self.node_keypair = bbclib.KeyPair() with open(pem_file, "r") as f: self.node_keypair.mk_keyobj_from_private_key_pem(f.read()) except: return
def test_keypair_der(): """ """ keypair = bbclib.KeyPair(curvetype=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 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 test_map_creation_with_pubkeys(default_domain_id): NUM_KEYPAIRS = 3 public_keys = [] for i in range(NUM_KEYPAIRS): keypair = bbclib.KeyPair() keypair.generate() 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 test_key_types(default_domain_id): idPubkeyMap = id_lib.BBcIdPublickeyMap( default_domain_id, default_key_type=bbclib.KeyType.ECDSA_SECP256k1) 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, key_types = idPubkeyMap.get_mapped_public_keys(user_id) assert len(key_types) == 1 assert key_types[0] == bbclib.KeyType.ECDSA_SECP256k1 public_keys = [] key_types = [] for i in range(3): if i == 1: key_type = bbclib.KeyType.ECDSA_SECP256k1 else: key_type = bbclib.KeyType.ECDSA_P256v1 keypair = bbclib.KeyPair(key_type) keypair.generate() public_keys.append(keypair.public_key) key_types.append(key_type) tx = idPubkeyMap.update(user_id, public_keys_to_replace=public_keys, key_types_to_replace=key_types, 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 public_keys, key_types = idPubkeyMap.get_mapped_public_keys(user_id) assert len(key_types) == 3 for i, key_type in enumerate(key_types): if i == 1: assert key_type == bbclib.KeyType.ECDSA_SECP256k1 else: assert key_type == bbclib.KeyType.ECDSA_P256v1
def sign_document(): document = get_document(request) privkey = request.json.get('privkey') if privkey is None: abort_by_missing_param('privkey') keypair = bbclib.KeyPair(privkey=binascii.a2b_hex(privkey)) digest = hashlib.sha256(registry_lib.file(document.root)).digest() sig = keypair.sign(digest) return jsonify({ 'algo': 'ecdsa-p256v1', 'sig': binascii.b2a_hex(sig).decode(), 'pubkey': binascii.b2a_hex(keypair.public_key).decode() })
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 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_keypair_sign_and_verify(): """ """ digest = binascii.a2b_hex( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") keypair = bbclib.KeyPair(curvetype=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 replace_keypair(hex_user_id=None): if hex_user_id is None: abort_by_missing_param('user_id') user = from_hex_to_user(g, hex_user_id, 'user_table') keypair_old = user.keypair keypair = bbclib.KeyPair() keypair.generate() g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id) g.idPubkeyMap.update(user.user_id, public_keys_to_replace=[keypair.public_key], keypair=keypair_old) user.keypair = keypair g.store.update_user(user, 'user_table') return jsonify({ 'old_pubkey': binascii.b2a_hex(keypair_old.public_key).decode(), 'new_pubkey': binascii.b2a_hex(keypair.public_key).decode() })