L'API de libnacl est conçu de telle sorte que deux partis qui veulent communiquer en toute sécurité doit en quelque sorte échanger leur publ touches ic. Disons qu'Alice veut envoyer un message à Bob.
# Alice's computer: Bob's computer:
alice_sign = libnacl.public.SecretKey() bob_enc = libnacl.public.SecretKey()
alice_spk_h = alice_sign.hex_pk() bob_epk_h = bob_enc.hex_pk()
# magic happens where alice_spk_h goes to Bob and bob_epk_h goes to alice (i.e. by phone)
bob_epk = libnacl.public.PublicKey(bob_epk_h) alice_spk = libnacl.public.PublicKey(
alice_spk_h)
alice_box = libnacl.public.Box( bob_box = libnacl.public.Box(
alice_sign.sk, bob_epk) bob_enc.sk, alice_spk)
# preparation is done, let's start encrypting...
ct = alice_box.encrypt(msg)
# send ct to Bob (the message is protected)
msg = bob_box.decrypt(ct)
Comme vous pouvez le voir, vous devez traiter les clés publiques et secrètes séparément pour les envoyer entre la machine des parties communicantes. Vous ne pouvez pas les combiner en une seule méthode, car cela contredirait le scénario d'utilisation du chiffrement à clé publique de libnacl. Gardez à l'esprit qu'avec une paire de clés unique par partie, il est seulement permis d'envoyer les messages cryptés dans une seule direction. Si vous avez besoin de renvoyer des messages, chaque partie doit avoir deux clés (une pour la signature et une pour le cryptage, notez que j'ai nommé les clés d'Alice et de Bob d'une certaine manière pour que cela soit clair).
est-il un moyen de faire la génération de clés dans un fichier et le stockage des clés dans une boîte + chiffrement/déchiffrement dans un autre fichier?
Oui, mais ici vous devez penser à ce que font ces fichiers. Un fichier Python est du code. Si vous exécutez le code qui génère la clé secrète à partir d'une ligne de commande, vous devez la stocker d'une manière ou d'une autre, car l'exécution du code à nouveau modifierait la clé.
gen.py
import libnacl.public
def genkey():
return libnacl.public.SecretKey()
def gen_keys_and_save():
# Generate two key pairs and store them for later use
enc = genkey()
enc.save('myencsecret.key')
with open('myencpublic.key', 'w') as pkf:
pkf.write(enc.hex_pk())
sign = genkey()
sign.save('mysignsecret.key')
with open('mysignpublic.key', 'w') as pkf:
pkf.write(sign.hex_pk())
if __name__ == "__main__":
# this code only runs when executed directly (i.e. from command line)
gen_keys_and_save()
enc.py
import libnacl.public
import libnacl.utils
def encrypt(mysignsecret, theirencpublic, data):
box = libnacl.public.Box(mysignsecret, theirencpublic)
return box.encrypt(data)
def parse_and_encrypt(mysignsecretfile, theirencpublicfile, data):
sk = libnacl.utils.load_key(mysignsecretfile)
with open(theirencpublicfile, 'r') as pkf:
pk = libnacl.public.PublicKey(pkf.read())
return encrypt(sk, pk, data)
if __name__ == "__main__":
parse_and_encrypt('mysignsecret.key', 'theirencpublic.key', 'some kind of msg')
dec.py
import libnacl.public
def decrypt(myencsecret, theirsignpublic, ciphertext):
box = libnacl.public.Box(myencsecret, theirsignpublic)
return box.decrypt(ciphertext)
# similar to enc.py ...
Maintenant, vous pouvez l'exécuter comme ceci:
$ python gen.py
Vous devez maintenant recevoir leur clé publique et envoyer le fichier mysignpublic.key. Lorsque vous avez fait cela, vous pouvez le faire:
$ python enc.py
@ArtjomB. Oops! mon mauvais, j'ai fait une erreur quand j'ai ajouté les clés dans la boîte. Ive mis à jour mes codes – meh
Passer la clé publique et privée de Bob à 'libnacl.public.Box' n'a pas de sens. La clé publique doit provenir de la personne avec laquelle Bob veut communiquer. Ici, Bob veut communiquer avec lui-même. –
@ArtjomB.mais disons que je n'ai besoin que d'une paire de clés (publique et privée), si je suivais les codes du site, cela ne me donnerait-il pas 2 paires de clés? – meh