Chloryne - libsodium wrapper

$ pip install chloryne

from chloryne import Chloride
# lib sodium will be initialized automatically

server = Chloride()
client = Chloride()

server.importKey(client.exportKey())
client.importKey(server.exportKey())

assert server.compute() == client.compute()

sig = server.sign(b'data')
assert client.verify(b'data', sig)

ct = server.encrypt(b'data')
assert client.decrypt(ct) == b'data'

mac = server.unsafeMAC()
mac.update(b'data')
digest = mac.finalize()
mac = client.unsafeMAC()
mac.update(b'data')
assert mac.verify(digest)

eph, mac = server.safeMAC()
mac.update(b'data')
digest = mac.finalize()
mac = client.safeMAC(eph)
mac.update(b'data')
assert mac.verify(digest)

from chloryne.signers import Signer

signer = Signer()
signer.update(b'data')
sig = signer.sign(server.privateKey)
signer = Signer()
signer.update(b'data')
assert signer.verify(client.peerPublicKey, sig)

from chloryne.password import Password
import os

# password-based KDF
salt = os.urandom(32) # must be 32-bytes
Password.derive(b'password', salt)

# password storage
strhash = Password.stringify(b'password')
assert Password.verify(b'password', strhash)

from chloryne.ciphers import StreamCipher
import os

key = os.urandom(32)
sc = StreamCipher(key)
ct = sc.encrypt(b'data') + sc.nonce
# other side...
ct, nonce = ct[:-24], ct[-24:]
sc = StreamCipher(key, nonce)
assert sc.decrypt(ct) == b'data'

sk = server.privateKey.exportKey()
# sk is a bytes object that can be stored anywhere
server = Chloride(sk)