2017-07-05 5 views
1

J'ai moi-même travaillé sur un projet et j'utilise comme guide les codes website. Est-il possible, je peux mettre la génération de clés dans 1 fichier et le cryptage/décryptage dans un autre. Comment définir bob_box sans avoir à générer une autre paire de clés?Comment effectuer un chiffrement/déchiffrement sans générer de paires de clés?

GEN.PY:

import libnacl.public 

def genkeys(): 

    bob = libnacl.public.SecretKey() 
    alice = libnacl.public.SecretKey() 

    bob_box = libnacl.public.Box(bob.sk, alice.pk) 
    alice_box = libnacl.public.Box(alice.sk, bob.pk) 

genkeys() 

Endecrypt:

import libnacl.public 
from GEN import genkeys 

msg = '1234' 

# Bob's box encrypts messages for Alice 
bob_ctxt = bob_box.encrypt(msg) 

# Alice's box decrypts messages from Bob 
bclear = alice_box.decrypt(bob_ctxt) 

# Alice can send encrypted messages which only Bob can decrypt 
alice_ctxt = alice_box.encrypt(msg) 
aclear = bob_box.decrypt(alice_ctxt) 

sortie quand je lance Endecrypt:

Traceback (most recent call last): 
File "/home/pi/Desktop/BOBALICE/endecrypt.py", line 7, in <module> 
bob_ctxt = bob_box.encrypt(msg) 
NameError: name 'bob_box' is not defined 
+0

@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

+0

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. –

+0

@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

Répondre

2

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 
+0

Tout ce qui n'est pas divisé par un commentaire de code peut être combiné à une fonction dans l'exemple de code ci-dessus. –

+0

Merci pour l'explication détaillée !! J'ai une question. Y at-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? Parce que c'était ma question principale. Mais je vais changer les codes dans mon projet en fonction de votre réponse. Cependant, le problème que j'ai en ce moment c'est que je dois les séparer en deux fichiers. Des idées? @Artjom B. – meh

+0

J'ai prolongé ma réponse –