def from_pubkey(cls, key: PublicKey) -> "ID": serialized_key = key.serialize() algo = multihash.Func.sha2_256 if ENABLE_INLINING and len(serialized_key) <= MAX_INLINE_KEY_LENGTH: algo = IDENTITY_MULTIHASH_CODE mh_digest = multihash.digest(serialized_key, algo) return cls(mh_digest.encode())
def ipfs_hash(content): """ Returns the SHA2-256 multihash of an object. Non-bytes objects are converted to strings and then encoded using utf-8 before being hashed. """ if not isinstance(content, bytes): content = str(content).encode() mh = multihash.digest(content, multihash.Func.sha2_256) return base58.b58encode(mh.encode()).decode()
def test_id_from_public_key(): bits_list = [1024, 1280, 1536, 1536, 2048] key = RSA.generate(random.choice(bits_list)) key_bin = key.exportKey("DER") algo = multihash.Func.sha2_256 mh_digest = multihash.digest(key_bin, algo) expected = ID(mh_digest.encode()) actual = id_from_public_key(key) assert actual == expected
def create(cls, data, links=None, hash_algorithm='sha2-256', serializer=json.dumps): links = [l for l in links if isinstance(l, Link)] if links is not None else [] serialized = ensure_bytes(serializer({'data': data, 'links': links})) mh = multihash.digest(serialized, hash_algorithm).encode('base58') return Node(data, links, serialized, mh)
def id_from_public_key(key): # export into binary format key_bin = key.exportKey("DER") algo = multihash.Func.sha2_256 # TODO: seems identity is not yet supported in pymultihash # if len(b) <= MAX_INLINE_KEY_LENGTH: # algo multihash.func.identity mh_digest = multihash.digest(key_bin, algo) return ID(mh_digest.encode())
def test_id_from_public_key(): key_pair = create_new_key_pair() public_key = key_pair.public_key key_bin = public_key.serialize() algo = multihash.Func.sha2_256 mh_digest = multihash.digest(key_bin, algo) expected = ID(mh_digest.encode()) actual = ID.from_pubkey(public_key) assert actual == expected
def multihash(data, fn_name='sha2_256'): """A utility function to make multihashing more convenient Args: data (bytes str): Any Python dict that is an output of the `marshal` function fn_name (str): Any of the following string values: 'sha1', 'sha2_256', 'sha2_512', 'sha3_512', 'sha3', 'sha3_384', 'sha3_256', 'sha3_224', 'shake_128', 'shake_256', 'blake2b', 'blake2s' Returns: A base58 encoded digest of a hash (encoded in ascii) """ return digest(data, fn_name).encode('base58').decode('ascii')
def compute_peerid(public_key: str) -> str: """ Compute the peer id from a public key. In particular, compute the base58 representation of libp2p PeerID from Bitcoin EC encoded Secp256k1 public key. :param public_key: the public key. :return: the peer id. """ key_protobuf = PublicKey( key_type=KeyType.Secp256k1, data=_hex_to_bytes(public_key) # type: ignore ) key_serialized = key_protobuf.SerializeToString() algo = multihash.Func.sha2_256 if ENABLE_INLINING and len(key_serialized) <= MAX_INLINE_KEY_LENGTH: algo = IDENTITY_MULTIHASH_CODE key_mh = multihash.digest(key_serialized, algo) return base58.b58encode(key_mh.encode()).decode()
async def test_dht_client_put_value(p2pds): peer_id_0, _ = await p2pds[0].control.identify() await connect_safe(p2pds[0], p2pds[1]) # test case: valid key pk0 = await p2pds[0].dht.get_public_key(peer_id_0) # make the `key` from pk0 algo = multihash.Func.sha2_256 value = pk0.Data mh_digest = multihash.digest(value, algo) mh_digest_bytes = mh_digest.encode() key = b"/pk/" + mh_digest_bytes await p2pds[0].dht.put_value(key, value) # test case: get_value await p2pds[1].dht.get_value(key) == value # test case: invalid key key_invalid = b"/123/456" with pytest.raises(ControlFailure): await p2pds[0].dht.put_value(key_invalid, key_invalid)
def multihash_sha256(data_in_bytes): return multihash.digest(data_in_bytes, "sha2_256").encode("hex").decode('utf-8')
def peer_id_from_pubkey(pubkey: datatypes.PublicKey) -> ID: algo = multihash.Func.sha2_256 mh_digest = multihash.digest(pubkey.to_bytes(), algo) return ID(mh_digest.encode())
def get_multihash(data): return multihash.digest(data, 'sha2_256').digest.hex()
def test_hash(): return multihash.digest(b'hello world', 'sha2-256').encode()
def _mk_multihash_sha256(data: bytes) -> bytes: return multihash.digest(data, "sha2-256")
def multihash(data): # NOTE: This is just a utility function to make the usage of this # library more convenient. # NOTE: Not sure why all IPLD implementations use sha2-256... return digest(data, 'sha2_256').encode('base58').decode('utf-8')