Looking for python Keywords? Try Ask4Keywords

Python LanguageSockets et cryptage / décryptage de messages entre le client et le serveur


Introduction

La cryptographie est utilisée à des fins de sécurité. Il n'y a pas beaucoup d'exemples de cryptage / décryptage en Python en utilisant le cryptage MODE CTR IDEA. But de cette documentation:

Étendre et implémenter le schéma de signature numérique RSA dans les communications entre stations. Utiliser Hashing pour l'intégrité du message, c'est SHA-1. Produire un protocole de transport de clé simple. Crypter la clé avec le cryptage IDEA. Le mode de chiffrement de bloc est le mode compteur

Remarques

Langue utilisée: Python 2.7 (lien de téléchargement: https://www.python.org/downloads/ )

Bibliothèque utilisée:

* PyCrypto (lien de téléchargement: https://pypi.python.org/pypi/pycrypto )

* PyCryptoPlus (lien de téléchargement: https://github.com/doegox/python-cryptoplus )

Installation de la bibliothèque:

PyCrypto: Décompressez le fichier. Allez dans le répertoire et ouvrez le terminal pour Linux (alt + ctrl + t) et CMD (shift + clic droit + sélection de l'invite de commande ouverte ici) pour Windows. Après cela, écrivez python setup.py install (Assurez-vous que Python Environment est correctement configuré dans Windows)

PyCryptoPlus: Identique à la dernière bibliothèque.

Tâches Implémentation: La tâche est séparée en deux parties. L'un est un processus de prise de contact et l'autre un processus de communication. Configuration du socket:

  • Comme la création de clés publiques et privées ainsi que le hachage de la clé publique, nous devons configurer le socket maintenant. Pour configurer le socket, nous devons importer un autre module avec «socket d'importation» et connecter (pour le client) ou lier (pour le serveur) l'adresse IP et le port avec le socket venant de l'utilisateur.

    ----------Côté client----------

      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      host = raw_input("Server Address To Be Connected -> ")
      port = int(input("Port of The Server -> "))
      server.connect((host, port))
    

    ----------Du côté serveur---------

      try:
      #setting up socket
      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)     
      server.bind((host,port))
      server.listen(5)
      except BaseException: print "-----Check Server Address or Port-----"
    

    "Socket.AF_INET, socket.SOCK_STREAM" nous permettra d'utiliser la fonction accept () et les fondamentaux de la messagerie. Au lieu de cela, nous pouvons utiliser «socket.AF_INET, socket.SOCK_DGRAM» également, mais cette fois, nous devrons utiliser setblocking (value).

Processus de poignée de main:

  • (CLIENT) La première tâche consiste à créer une clé publique et privée. Pour créer la clé privée et publique, nous devons importer certains modules. Ce sont: depuis l'importation Crypto Random et depuis l'importation Crypto.PublicKey RSA. Pour créer les clés, il faut écrire quelques lignes de codes simples:
random_generator = Random.new().read
        key = RSA.generate(1024,random_generator) 
        public = key.publickey().exportKey()

random_generator est dérivé du module " from Crypto import Random ". La clé est dérivée de «à partir de Crypto.PublicKey import RSA » qui créera une clé privée de 1024 en générant des caractères aléatoires. Public exporte la clé publique de la clé privée précédemment générée.

  • (CLIENT) Après avoir créé la clé publique et privée, nous devons hacher la clé publique pour envoyer au serveur en utilisant le hachage SHA-1. Pour utiliser le hachage SHA-1, nous devons importer un autre module en écrivant «import hashlib». Pour hacher la clé publique, nous avons écrit deux lignes de code:

      hash_object = hashlib.sha1(public) 
      hex_digest = hash_object.hexdigest()
    

Hash_object et hex_digest sont nos variables. Après cela, le client enverra hex_digest et public au serveur et le serveur les vérifiera en comparant le hash obtenu du client et le nouveau hachage de la clé publique. Si le nouveau hachage et le hachage du client correspondent, il passera à la procédure suivante. Comme le public envoyé par le client est sous forme de chaîne, il ne pourra pas être utilisé comme clé du côté serveur. Pour empêcher cela et convertir la clé publique de chaîne en clé publique rsa, nous devons écrire server_public_key = RSA.importKey(getpbk) , ici getpbk est la clé publique du client.

  • (SERVER) L'étape suivante consiste à créer une clé de session. Ici, j'ai utilisé le module "os" pour créer une clé aléatoire "key = os.urandom (16)" qui nous donnera une clé de 16 bits et après cela, j'ai chiffré cette clé dans "AES.MODE_CTR" avec SHA-1:

     #encrypt CTR MODE session key
     en = AES.new(key_128,AES.MODE_CTR,counter = lambda:key_128) encrypto = en.encrypt(key_128)
     #hashing sha1
     en_object = hashlib.sha1(encrypto)
     en_digest = en_object.hexdigest()
    

Donc, le en_digest sera notre clé de session.

  • (SERVER) La dernière partie du processus de prise de contact consiste à chiffrer la clé publique obtenue à partir du client et la clé de session créée côté serveur.

     #encrypting session key and public key
     E = server_public_key.encrypt(encrypto,16)
    

Après le cryptage, le serveur enverra la clé au client sous forme de chaîne.

  • (CLIENT) Après avoir obtenu la chaîne chiffrée de (clé publique et de session) du serveur, le client les déchiffrera à l'aide de la clé privée créée précédemment avec la clé publique. Comme le crypté (clé publique et clé de session) était sous forme de chaîne, nous devons maintenant le récupérer en tant que clé en utilisant eval (). Si le déchiffrement est effectué, le processus de prise de contact est également terminé, les deux parties confirmant qu'elles utilisent les mêmes clés. Déchiffrer:

     en = eval(msg)
     decrypt = key.decrypt(en)
     # hashing sha1
     en_object = hashlib.sha1(decrypt) en_digest = en_object.hexdigest()
    

J'ai utilisé le SHA-1 ici pour qu'il soit lisible dans la sortie.

Processus de communication:

Pour le processus de communication, nous devons utiliser la clé de session des deux côtés comme clé pour le cryptage MODE_CTR. Les deux parties vont chiffrer et déchiffrer les messages avec IDEA.MODE_CTR en utilisant la clé de session.

  • (Cryptage) Pour le cryptage IDEA, nous avons besoin d'une clé de 16 bits et d'un compteur tel que pouvant être appelé. Le compteur est obligatoire dans MODE_CTR. La clé de session que nous avons chiffrée et hachée est désormais de 40, ce qui dépassera la clé de limite du chiffrement IDEA. Par conséquent, nous devons réduire la taille de la clé de session. Pour réduire, nous pouvons utiliser la chaîne de fonctions normale de python intégrée [valeur: valeur]. Où la valeur peut être n'importe quelle valeur en fonction du choix de l'utilisateur. Dans notre cas, j'ai fait “key [: 16]” où il faudra de 0 à 16 valeurs de la clé. Cette conversion pourrait être faite de plusieurs manières comme la clé [1:17] ou la clé [16:]. La prochaine partie consiste à créer une nouvelle fonction de chiffrement IDEA en écrivant IDEA.new () qui prendra trois arguments pour le traitement. Le premier argument sera KEY, le deuxième argument sera le mode de cryptage IDEA (dans notre cas, IDEA.MODE_CTR) et le troisième argument sera le compteur = qui est une fonction appelable. Le compteur = contiendra une taille de chaîne qui sera retournée par la fonction. Pour définir le compteur =, il faut utiliser des valeurs raisonnables. Dans ce cas, j'ai utilisé la taille de la clé en définissant lambda. Au lieu d'utiliser lambda, nous pourrions utiliser Counter.Util qui génère une valeur aléatoire pour le compteur =. Pour utiliser Counter.Util, nous devons importer un module de compteur à partir de crypto. Par conséquent, le code sera:

      ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
    

Une fois que vous avez défini «ideaEncrypt» comme variable de chiffrement IDEA, vous pouvez utiliser la fonction de chiffrement intégrée pour chiffrer n'importe quel message.

eMsg = ideaEncrypt.encrypt(whole)
#converting the encrypted message to HEXADECIMAL to readable eMsg =         
eMsg.encode("hex").upper()

Dans ce segment de code, tout est le message à chiffrer et eMsg est le message chiffré. Après avoir chiffré le message, je l'ai converti en HEXADECIMAL pour le rendre lisible et upper () est la fonction intégrée pour rendre les caractères en majuscule. Après cela, ce message crypté sera envoyé à la station opposée pour décryptage.

  • (Décryptage)

Pour déchiffrer les messages chiffrés, nous devrons créer une autre variable de chiffrement en utilisant les mêmes arguments et la même clé, mais cette fois-ci, la variable déchiffrera les messages chiffrés. Le code pour le même que la dernière fois. Cependant, avant de déchiffrer les messages, nous devons décoder le message en hexadécimal car, dans notre partie chiffrement, nous avons encodé le message chiffré en hexadécimal pour le rendre lisible. Par conséquent, le code entier sera:

decoded = newmess.decode("hex")
ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key) 
dMsg = ideaDecrypt.decrypt(decoded)

Ces processus seront effectués côté serveur et côté client pour le cryptage et le décryptage.

Sockets et cryptage / décryptage de messages entre le client et le serveur Exemples Liés