Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_sign(self):
msg = (b'Well, that\'s no ordinary rabbit. That\'s the most foul, '
b'cruel, and bad-tempered rodent you ever set eyes on.')
signer = libnacl.dual.DualSecret()
signed = signer.sign(msg)
signature = signer.signature(msg)
self.assertNotEqual(msg, signed)
veri = libnacl.sign.Verifier(signer.hex_vk())
verified = veri.verify(signed)
verified2 = veri.verify(signature + msg)
self.assertEqual(verified, msg)
self.assertEqual(verified2, msg)
def test_sign(self):
msg = (b'Well, that\'s no ordinary rabbit. That\'s the most foul, '
b'cruel, and bad-tempered rodent you ever set eyes on.')
signer = libnacl.sign.Signer()
signed = signer.sign(msg)
signature = signer.signature(msg)
self.assertNotEqual(msg, signed)
veri = libnacl.sign.Verifier(signer.hex_vk())
verified = veri.verify(signed)
verified2 = veri.verify(signature + msg)
self.assertEqual(verified, msg)
self.assertEqual(verified2, msg)
aserver, server, db = set_api_security(settings)
config.registry.couchdb_server = server
if aserver:
config.registry.admin_couchdb_server = aserver
config.registry.db = db
# Document Service key
config.registry.docservice_url = settings.get('docservice_url')
config.registry.docservice_username = settings.get('docservice_username')
config.registry.docservice_password = settings.get('docservice_password')
config.registry.docservice_upload_url = settings.get('docservice_upload_url')
config.registry.docservice_key = dockey = Signer(settings.get('dockey', '').decode('hex'))
config.registry.keyring = keyring = {}
dockeys = settings.get('dockeys') if 'dockeys' in settings else dockey.hex_vk()
for key in dockeys.split('\0'):
keyring[key[:8]] = Verifier(key)
# Archive keys
arch_pubkey = settings.get('arch_pubkey', None)
config.registry.arch_pubkey = PublicKey(arch_pubkey.decode('hex') if arch_pubkey else SecretKey().pk)
# migrate data
if not os.environ.get('MIGRATION_SKIP'):
for entry_point in iter_entry_points('openprocurement.api.migrations'):
plugin = entry_point.load()
plugin(config.registry)
config.registry.server_id = settings.get('id', '')
# search subscribers
subscribers_keys = [k for k in settings if k.startswith('subscribers.')]
for k in subscribers_keys:
"""
Create a new LibNaCL secret key. Optionally load it from a string representation.
Otherwise generate it from the 25519 curve.
:param binarykey: load the sk from this string (see key_to_bin())
"""
# Load the key, if specified
if binarykey:
crypt, seed = (binarykey[:libnacl.crypto_box_SECRETKEYBYTES],
binarykey[libnacl.crypto_box_SECRETKEYBYTES: libnacl.crypto_box_SECRETKEYBYTES
+ libnacl.crypto_sign_SEEDBYTES])
self.key = libnacl.dual.DualSecret(crypt, seed)
else:
self.key = libnacl.dual.DualSecret()
# Immediately create a verifier
self.veri = libnacl.sign.Verifier(self.key.hex_vk())
password = getpass.getpass("Enter your password: ")
# Create key object
key = SigningKey.from_credentials(salt, password)
# Display your public key
print("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)
# save signed message in a file
with open(SIGNED_MESSAGE_FILENAME, "wb") as file_handler:
file_handler.write(signed_message)
print("Signed message saved in file ./{0}".format(SIGNED_MESSAGE_FILENAME))
if 'priv' in key_data and 'sign' in key_data and 'pub' in key_data:
return libnacl.dual.DualSecret(
libnacl.encode.hex_decode(key_data['priv']),
libnacl.encode.hex_decode(key_data['sign']))
elif 'priv' in key_data and 'pub' in key_data:
return libnacl.public.SecretKey(
libnacl.encode.hex_decode(key_data['priv']))
elif 'sign' in key_data:
return libnacl.sign.Signer(
libnacl.encode.hex_decode(key_data['sign']))
elif 'pub' in key_data:
return libnacl.public.PublicKey(
libnacl.encode.hex_decode(key_data['pub']))
elif 'verify' in key_data:
return libnacl.sign.Verifier(key_data['verify'])
elif 'priv' in key_data:
return libnacl.secret.SecretBox(
libnacl.encode.hex_decode(key_data['priv']))
raise ValueError('Found no key data')
def __init__(self, binarykey=""):
if binarykey:
crypt, seed = binarykey[:libnacl.crypto_box_SECRETKEYBYTES], binarykey[libnacl.crypto_box_SECRETKEYBYTES : libnacl.crypto_box_SECRETKEYBYTES + libnacl.crypto_sign_SEEDBYTES]
self.key = libnacl.dual.DualSecret(crypt, seed)
else:
self.key = libnacl.dual.DualSecret()
self.veri = libnacl.sign.Verifier(self.key.hex_vk())
Create a new LibNaCL public key. Optionally load it from a string representation or
using a public key and verification key.
:param binarykey: load the pk from this string (see key_to_bin())
:param pk: the libnacl public key to use in byte format
:param hex_vk: a verification key in hex format
"""
# Load the key, if specified
if binarykey:
pk, vk = (binarykey[:libnacl.crypto_box_SECRETKEYBYTES],
binarykey[libnacl.crypto_box_SECRETKEYBYTES: libnacl.crypto_box_SECRETKEYBYTES
+ libnacl.crypto_sign_SEEDBYTES])
hex_vk = libnacl.encode.hex_encode(vk)
# Construct the public key and verifier objects
self.key = libnacl.public.PublicKey(pk)
self.veri = libnacl.sign.Verifier(hex_vk)