def test_create_encrypted(self):
# pubkey of recipient
alice_signing_key = SigningKey.from_credentials("alice", "password")
# message
message = """
Hello world !
Héhé ;-)
This is a utf-8 message...
"""
# create encrypted and signed ascii armor message
encrypted_aa_message = AsciiArmor.create(message, alice_signing_key.pubkey)
# split in lines for check up
aa_message_lines = encrypted_aa_message.splitlines()
# check before message
self.assertEqual(aa_message_lines[0], BEGIN_MESSAGE_HEADER)
self.assertTrue(aa_message_lines[1].startswith("Version:"))
self.assertEqual("", aa_message_lines[2].strip())
# check after message
self.assertEqual(aa_message_lines[4], END_MESSAGE_HEADER)
# parse ascii armor message
result = AsciiArmor.parse(encrypted_aa_message, alice_signing_key)
# check result
self.assertEqual(message + "\n", result['message']['content'])
def test_create_encrypted(self):
# pubkey of recipient
alice_signing_key = SigningKey.from_credentials("alice", "password")
# message
message = """
Hello world !
Héhé ;-)
This is a utf-8 message...
"""
# create encrypted and signed ascii armor message
encrypted_aa_message = AsciiArmor.create(message,
alice_signing_key.pubkey)
# split in lines for check up
aa_message_lines = encrypted_aa_message.splitlines()
# check before message
self.assertEqual(aa_message_lines[0], BEGIN_MESSAGE_HEADER)
self.assertTrue(aa_message_lines[1].startswith("Version:"))
self.assertEqual("", aa_message_lines[2].strip())
# check after message
self.assertEqual(aa_message_lines[4], END_MESSAGE_HEADER)
# parse ascii armor message
result = AsciiArmor.parse(encrypted_aa_message, alice_signing_key)
# check result
self.assertEqual(message + "\n", result["message"]["content"])
def get_identity_document(current_block: dict, uid: str, salt: str,
password: str) -> Identity:
"""
Get an Identity document
:param current_block: Current block data
:param uid: Unique IDentifier
:param salt: Passphrase of the account
:param password: Password of the account
:rtype: Identity
"""
# get current block BlockStamp
timestamp = BlockUID(current_block['number'], current_block['hash'])
# create keys from credentials
key = SigningKey.from_credentials(salt, password)
# create identity document
identity = Identity(version=10,
currency=current_block['currency'],
pubkey=key.pubkey,
uid=uid,
ts=timestamp,
signature=None)
# sign document
identity.sign([key])
return identity
def test_create_signed_cleartext(self):
# signing key of issuer
bob_signing_key = SigningKey.from_credentials("bob", "password")
# message
message = """
Hello world !
Héhé ;-)
This is a utf-8 message...
"""
# create encrypted and signed ascii armor message
signed_cleartext_aa_message = AsciiArmor.create(message, None, [bob_signing_key])
# split in lines for check up
aa_message_lines = signed_cleartext_aa_message.splitlines()
# check before message
self.assertEqual(aa_message_lines[0], BEGIN_MESSAGE_HEADER)
self.assertEqual("", aa_message_lines[1].strip())
# check after message
self.assertEqual(aa_message_lines[10], BEGIN_SIGNATURE_HEADER)
self.assertTrue(aa_message_lines[11].startswith("Version:"))
self.assertEqual("", aa_message_lines[12].strip())
self.assertEqual(aa_message_lines[14], END_SIGNATURE_HEADER)
# parse ascii armor message
result = AsciiArmor.parse(signed_cleartext_aa_message, None, [bob_signing_key.pubkey])
# check result
self.assertEqual(message + "\n", result['message']['content'])
self.assertTrue(message + "\n", result['signatures'][0]['valid'])
def test_save_wif_and_load_from_ewif_or_wif_file(self):
sign_key_save = SigningKey.from_credentials("alice", "password",
ScryptParams())
sign_key_save.save_wif_file(TEST_FILE_PATH)
sign_key_load = SigningKey.from_wif_or_ewif_file(TEST_FILE_PATH)
self.assertEqual(sign_key_save.sk, sign_key_load.sk)
def get_identity_document(current_block: dict, uid: str, salt: str, password: str) -> Identity:
"""
Get an Identity document
:param current_block: Current block data
:param uid: Unique Identifier
:param salt: Passphrase of the account
:param password: Password of the account
:rtype: Identity
"""
# get current block BlockStamp
timestamp = BlockUID(current_block['number'], current_block['hash'])
# create keys from credentials
key = SigningKey.from_credentials(salt, password)
# create identity document
identity = Identity(
version=10,
currency=current_block['currency'],
pubkey=key.pubkey,
uid=uid,
ts=timestamp,
signature=None
)
# sign document
identity.sign([key])
return identity
def test_decrypt_seal(self):
sign_key = SigningKey.from_credentials("alice", "password", ScryptParams())
public_key = PublicKey(sign_key.pubkey)
message = "Hello world with utf-8 chars like éàè !"
encrypted_message = public_key.encrypt_seal(bytes(message, 'utf-8'))
decrypted_message = sign_key.decrypt_seal(encrypted_message)
self.assertEqual(message, decrypted_message.decode('utf-8'))
def test_encrypt_seal(self):
sign_key = SigningKey.from_credentials("alice", "password",
ScryptParams())
public_key = PublicKey(sign_key.pubkey)
message = "Hello world with utf-8 chars like éàè !"
encrypted_message = public_key.encrypt_seal(bytes(message, 'utf-8'))
decrypted_message = sign_key.decrypt_seal(encrypted_message)
self.assertEqual(message, decrypted_message.decode('utf-8'))
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter recipient pubkey: ")
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# capture sources of account
response = await client(bma.tx.sources, pubkey_from)
if len(response["sources"]) == 0:
print("no sources found for account %s" % pubkey_to)
sys.exit(1)
# get the first source
source = response["sources"][0]
# create the transaction document
transaction = get_transaction_document(current_block, source, pubkey_from,
pubkey_to)
# sign document
transaction.sign([key])
# send the Transaction document to the node
response = await client(bma.tx.process, transaction.signed_raw())
if response.status == 200:
print(await response.text())
else:
print("Error while publishing transaction: {0}".format(
await response.text()))
# Close client aiohttp session
await client.close()
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter your public key: ")
# init signer instance
signer = SigningKey.from_credentials(salt, password)
# check public key
if signer.pubkey != pubkey:
print("Bad credentials!")
sys.exit(0)
# capture current block to get currency name
current_block = await client(bma.blockchain.current)
# create our Identity document to sign the Certification document
identity = await get_identity_document(client, current_block, pubkey)
if identity is None:
print("Identity not found for pubkey {0}".format(pubkey))
# Close client aiohttp session
await client.close()
sys.exit(1)
# get the revoke document
revocation_signed_raw_document = get_signed_raw_revocation_document(
identity, salt, password)
# save revoke document in a file
fp = open(REVOCATION_DOCUMENT_FILE_PATH, "w")
fp.write(revocation_signed_raw_document)
fp.close()
# document saved
print("Revocation document saved in %s" % REVOCATION_DOCUMENT_FILE_PATH)
# Close client aiohttp session
await client.close()
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter recipient pubkey: ")
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# capture sources of account
response = await client(bma.tx.sources, pubkey_from)
if len(response['sources']) == 0:
print("no sources found for account %s" % pubkey_to)
exit(1)
# get the first source
source = response['sources'][0]
# create the transaction document
transaction = get_transaction_document(current_block, source, pubkey_from, pubkey_to)
# sign document
transaction.sign([key])
# send the Transaction document to the node
response = await client(bma.tx.process, transaction.signed_raw())
if response.status == 200:
print(await response.text())
else:
print("Error while publishing transaction: {0}".format(await response.text()))
# Close client aiohttp session
await client.close()
def test_get_verified_data(self):
sign_key = SigningKey.from_credentials("alice", "password", ScryptParams())
message = "Hello world with utf-8 chars like éàè !"
# Sign the message, the signed string is the message itself plus the
# signature
signed_message = sign_key.sign(bytes(message, 'utf-8')) # type: bytes
# Verify the message!
verifier = VerifyingKey(sign_key.pubkey)
verified_message = verifier.get_verified_data(signed_message)
self.assertEqual(message, verified_message.decode('utf-8'))
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter certified pubkey: ")
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# create our Identity document to sign the Certification document
identity = await get_identity_document(client, current_block, pubkey_to)
if identity is None:
print("Identity not found for pubkey {0}".format(pubkey_to))
# Close client aiohttp session
await client.close()
sys.exit(1)
# send the Certification document to the node
certification = get_certification_document(current_block, identity,
pubkey_from)
# sign document
certification.sign([key])
# Here we request for the path wot/certify
response = await client(bma.wot.certify, certification.signed_raw())
if response.status == 200:
print(await response.text())
else:
print("Error while publishing certification: {0}".format(
await response.text()))
# Close client aiohttp session
await client.close()
def get_signed_raw_revocation_document(identity: Identity, salt: str, password: str) -> str:
"""
Generate account revocation document for given identity
:param identity: Self Certification of the identity
:param salt: Salt
:param password: Password
:rtype: str
"""
revocation = Revocation(PROTOCOL_VERSION, identity.currency, identity, "")
key = SigningKey.from_credentials(salt, password)
revocation.sign([key])
return revocation.signed_raw()
def test_load_credentials_file(self):
salt = password = "******"
# create a dummy credentials file
with open(TEST_FILE_PATH, "w") as fh:
fh.write("{}\n{}\n".format(salt, password))
# same key from credentials
sign_key_test = SigningKey.from_credentials(salt, password)
# test load file
sign_key_load = SigningKey.from_credentials_file(TEST_FILE_PATH)
self.assertEqual(sign_key_test.sk, sign_key_load.sk)
self.assertEqual(sign_key_test.pubkey, sign_key_load.pubkey)
self.assertEqual(sign_key_test.vk, sign_key_load.vk)
def get_signed_raw_revocation_document(identity: Identity, salt: str,
password: str) -> str:
"""
Generate account revocation document for given identity
:param identity: Self Certification of the identity
:param salt: Salt
:param password: Password
:rtype: str
"""
revocation = Revocation(PROTOCOL_VERSION, identity.currency, identity, "")
key = SigningKey.from_credentials(salt, password)
revocation.sign([key])
return revocation.signed_raw()
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter your public key: ")
# init signer instance
signer = SigningKey.from_credentials(salt, password)
# check public key
if signer.pubkey != pubkey:
print("Bad credentials!")
exit(0)
# capture current block to get currency name
current_block = await client(bma.blockchain.current)
# create our Identity document to sign the revoke document
identity_document = await get_identity_document(client, current_block['currency'], pubkey)
# get the revoke document
revocation_signed_raw_document = get_signed_raw_revocation_document(identity_document, salt, password)
# save revoke document in a file
fp = open(REVOCATION_DOCUMENT_FILE_PATH, 'w')
fp.write(revocation_signed_raw_document)
fp.close()
# document saved
print("Revocation document saved in %s" % REVOCATION_DOCUMENT_FILE_PATH)
# Close client aiohttp session
await client.close()
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter certified pubkey: ")
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# create our Identity document to sign the Certification document
identity = await get_identity_document(client, current_block, pubkey_to)
# send the Certification document to the node
certification = get_certification_document(current_block, identity, pubkey_from)
# sign document
certification.sign([key])
# Here we request for the path wot/certify
response = await client(bma.wot.certify, certification.signed_raw())
if response.status == 200:
print(await response.text())
else:
print("Error while publishing certification: {0}".format(await response.text()))
# Close client aiohttp session
await client.close()
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos by dedicated method (with json schema validation)
response = await client(bma.node.summary)
print(response)
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"results"][0]
# create a membership demand document
membership = get_membership_document("IN", current_block, identity, key)
# send the membership signed raw document to the node
response = await client(bma.blockchain.membership, membership.signed_raw())
if response.status == 200:
print(await response.text())
else:
print("Error while publishing membership : {0}".format(
await response.text()))
# Close client aiohttp session
await client.close()
def auth_by_scrypt(ctx):
salt = getpass("Please enter your Scrypt Salt (Secret identifier): ")
password = getpass("Please enter your Scrypt password (masked): ")
if ctx.obj["AUTH_SCRYPT_PARAMS"]:
n, r, p = ctx.obj["AUTH_SCRYPT_PARAMS"].split(",")
if n.isnumeric() and r.isnumeric() and p.isnumeric():
n, r, p = int(n), int(r), int(p)
if n <= 0 or n > 65536 or r <= 0 or r > 512 or p <= 0 or p > 32:
message_exit(
"Error: the values of Scrypt parameters are not good")
scrypt_params = ScryptParams(n, r, p)
else:
message_exit("one of n, r or p is not a number")
else:
scrypt_params = None
try:
return SigningKey.from_credentials(salt, password, scrypt_params)
except ValueError as error:
message_exit(error)
async def main():
"""
Main code
"""
# Create Client from endpoint string in Duniter format
client = Client(BMAS_ENDPOINT)
# Get the node summary infos to test the connection
response = await client(bma.node.summary)
print(response)
# capture current block to get version and currency and blockstamp
current_block = await client(bma.blockchain.current)
# prompt entry
uid = input("Enter your Unique IDentifier (pseudonym): ")
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Error while publishing identity : {0}".format(await response.text()))
# Close client aiohttp session
await client.close()
def test_create_signed_cleartext(self):
# signing key of issuer
bob_signing_key = SigningKey.from_credentials("bob", "password")
# message
message = """
Hello world !
Héhé ;-)
This is a utf-8 message...
"""
# create encrypted and signed ascii armor message
signed_cleartext_aa_message = AsciiArmor.create(
message, None, [bob_signing_key])
# split in lines for check up
aa_message_lines = signed_cleartext_aa_message.splitlines()
# check before message
self.assertEqual(aa_message_lines[0], BEGIN_MESSAGE_HEADER)
self.assertEqual("", aa_message_lines[1].strip())
# check after message
self.assertEqual(aa_message_lines[10], BEGIN_SIGNATURE_HEADER)
self.assertTrue(aa_message_lines[11].startswith("Version:"))
self.assertEqual("", aa_message_lines[12].strip())
self.assertEqual(aa_message_lines[14], END_SIGNATURE_HEADER)
# parse ascii armor message
result = AsciiArmor.parse(signed_cleartext_aa_message, None,
[bob_signing_key.pubkey])
# check result
self.assertEqual(message + "\n", result["message"]["content"])
self.assertTrue(message + "\n", result["signatures"][0]["valid"])
def get_membership_document(membership_type: str, current_block: dict, identity: Identity, salt: str,
password: str) -> Membership:
"""
Get a Membership document
:param membership_type: "IN" to ask for membership or "OUT" to cancel membership
:param current_block: Current block data
:param identity: Identity document
:param salt: Passphrase of the account
:param password: Password of the account
:rtype: Membership
"""
# get current block BlockStamp
timestamp = BlockUID(current_block['number'], current_block['hash'])
# create keys from credentials
key = SigningKey.from_credentials(salt, password)
# create identity document
membership = Membership(
version=10,
currency=current_block['currency'],
issuer=key.pubkey,
membership_ts=timestamp,
membership_type=membership_type,
uid=identity.uid,
identity_ts=identity.timestamp,
signature=None
)
# sign document
membership.sign([key])
return membership
async def main():
"""
Main code
"""
# Arbitrary credentials to create the node key pair to sign ws2p documents
salt = password = "******"
# You can connect with member credentials in case there is not much slots available on the endpoint
#
# # Prompt hidden user entry
# import getpass
# salt = getpass.getpass("Enter your passphrase (salt): ")
#
# # Prompt hidden user entry
# password = getpass.getpass("Enter your password: "******"Successfully connected to the web socket endpoint")
# HANDSHAKE #######################################################
try:
# Resolve handshake
print("Handshake...")
await handshake(ws, signing_key, CURRENCY)
except ValidationError as exception:
print(exception.message)
print("HANDSHAKE FAILED !")
sys.exit(1)
print("Handshake ok")
loop = True
# Iterate on each message received...
while loop:
print("Waiting message...")
# Wait and capture next message
data = await ws.receive_json()
print("Message received:")
print(json.dumps(data, indent=2))
# Close session
await client.close()
except (aiohttp.WSServerHandshakeError, ValueError) as e:
print("Websocket handshake {0} : {1}".format(type(e).__name__, str(e)))
except (aiohttp.ClientError, gaierror, TimeoutError) as e:
print("{0} : {1}".format(str(e), ws2p_endpoint.inline()))
except jsonschema.ValidationError as e:
print("{:}:{:}".format(str(e.__class__.__name__), str(e)))
await client.close()
# CONFIG #######################################
SIGNED_MESSAGE_FILENAME = '/tmp/duniter_signed_message.bin'
################################################
if __name__ == '__main__':
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Public key for your credentials: %s" % key.pubkey)
message = input("Enter your message: ")
# Sign the message, the signed string is the message itself plus the
# signature
signed_message = key.sign(bytes(message, 'utf-8')) # type: bytes
# To create a verifier pass in the verify key:
veri = libnacl.sign.Verifier(key.hex_vk())
# Verify the message!
verified = veri.verify(signed_message)
# CONFIG #######################################
CLEARTEXT_AA_MESSAGE_PATH = "/tmp/duniter_cleartext_aa_message.txt"
################################################
if __name__ == "__main__":
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Enter your message (Ctrl-D below last line to end):")
message = sys.stdin.read()
print("Message signed by puplic key : {pubkey}".format(pubkey=signing_key.pubkey))
comment = "generated by Duniterpy {0}".format(__version__)
# Dash escape the message and sign it
aa_cleartext_message = AsciiArmor.create(
message, None, [signing_key], None, signatures_comment=comment
)
# Save cleartext ascii armor message in a file
with open(CLEARTEXT_AA_MESSAGE_PATH, "w") as file_handler:
if len(sys.argv) < 2:
print("""
Usage:
python decrypt_message.py ENCRYPTED_MESSAGE_FILEPATH
""")
# capture encrypted message filepath argument
signed_message_path = sys.argv[1]
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Decrypted message:")
except ValueError as error:
message = str(error)
print(message)
print("""
Usage:
python decrypt_message.py ENCRYPTED_MESSAGE_FILEPATH
""")
# capture encrypted message filepath argument
signed_message_path = sys.argv[1]
# prompt hidden user entry
salt = getpass.getpass("Enter your passphrase (salt): ")
# prompt hidden user entry
password = getpass.getpass("Enter your password: "******"Decrypted message:")
except ValueError as error:
message = str(error)
print(message)
def patched_auth_method():
return SigningKey.from_credentials(identity_uid, identity_uid)
def test_save_wif_and_load_from_ewif_or_wif_file(self):
sign_key_save = SigningKey.from_credentials("alice", "password", ScryptParams())
sign_key_save.save_wif_file(TEST_FILE_PATH)
sign_key_load = SigningKey.from_wif_or_ewif_file(TEST_FILE_PATH)
self.assertEqual(sign_key_save.sk, sign_key_load.sk)
def test_from_credentials(self):
sign_key = SigningKey.from_credentials("alice", "password",
ScryptParams())
verify_key = VerifyingKey(sign_key.pubkey)
self.assertEqual(verify_key.vk, sign_key.vk)
def test_from_credentials(self):
sign_key = SigningKey.from_credentials("alice", "password", ScryptParams())
verify_key = VerifyingKey(sign_key.pubkey)
self.assertEqual(verify_key.vk, sign_key.vk)
async def main():
"""
Main code
"""
# dummy credentials
salt = password = "******"
# You can connect with member credentials in case there is not much slots available on the endpoint
#
# # Prompt hidden user entry
# import getpass
# salt = getpass.getpass("Enter your passphrase (salt): ")
#
# # Prompt hidden user entry
# password = getpass.getpass("Enter your password: "******"Successfully connected to the web socket endpoint")
# HANDSHAKE #######################################################
try:
await handshake(ws, signing_key, CURRENCY)
except ValidationError as exception:
print(exception.message)
print("HANDSHAKE FAILED !")
sys.exit(1)
# Send ws2p request
print("Send getCurrent() request")
request_id = get_ws2p_challenge()[:8]
response = await send(
ws,
requests.get_current(request_id),
request_id,
requests.BLOCK_RESPONSE_SCHEMA,
)
print("Response: " + json.dumps(response, indent=2))
# Send ws2p request
print("Send getBlock(30000) request")
request_id = get_ws2p_challenge()[:8]
response = await send(
ws,
requests.get_block(request_id, 30000),
request_id,
requests.BLOCK_RESPONSE_SCHEMA,
)
print("Response: " + json.dumps(response, indent=2))
# Send ws2p request
print("Send getBlocks(30000, 2) request")
request_id = get_ws2p_challenge()[:8]
response = await send(
ws,
requests.get_blocks(request_id, 30000, 2),
request_id,
requests.BLOCKS_RESPONSE_SCHEMA,
)
print("Response: " + json.dumps(response, indent=2))
# Send ws2p request
print("Send getRequirementsPending(3) request")
request_id = get_ws2p_challenge()[:8]
response = await send(
ws,
requests.get_requirements_pending(request_id, 3),
request_id,
requests.REQUIREMENTS_RESPONSE_SCHEMA,
)
print("Response: " + json.dumps(response, indent=2))
# Close session
await client.close()
except (aiohttp.WSServerHandshakeError, ValueError) as e:
print("Websocket handshake {0} : {1}".format(type(e).__name__, str(e)))
except (aiohttp.ClientError, gaierror, TimeoutError) as e:
print("{0} : {1}".format(str(e), ws2p_endpoint.inline()))
except jsonschema.ValidationError as e:
print("{:}:{:}".format(str(e.__class__.__name__), str(e)))
await client.close()