IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Insertion de mini cryptage pour un chat utilisant les Threads


Sujet :

Python

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut Insertion de mini cryptage pour un chat utilisant les Threads
    Bonjour à tous! Je vous remercie déjà de passer sur ce topic et de le lire.
    Je suis en dernière année de lycée en sciences informatiques à Saint Jean Berchmans (là ou à enseigné Gérard Swinnen).
    Et j'ai un TFE en programmation à réaliser, mon prof est au courant que je demande de l'aide sur les forums, car il ne saurait pas trop m'aider car les Threads il ne connait pas trop O_O, disons que je suis un peu mal pour mon tfe.

    J'ai pris le chat multi thread du livre Python de Gérard Swinnen et j'aimerais y insérer un mini cryptage, mais je n'arrive pas à transmettre la variable cryptée au thread de réception!

    Voilà le client du chat :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    #!/usr/bin/env python
    #-*-coding:Utf-8-*-
     
    # Définition d'un client réseau gérant en parallèle l'émission
    # et la réception des messages (utilisation de 2 THREADS).
    ip = raw_input("Entrez le numéro du pc serveur : ")
    HOST = "192.168.0.%s" % (ip)
    port = 40000
    import socket, sys, threading
    # Classe permettant la gestion du thread s'occupant de la réception du message.
    class ThreadReception(threading.Thread):
    	"""objet thread gérant la réception des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn            # réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_recu = self.connexion.recv(1024)
    			print "'" + message_recu + "'"
    			if message_recu =='' or message_recu.upper() == "FIN":
    				break
    		# Le thread <réception> se termine ici.
    		# On force la fermeture du thread <émission> :
    		th_E._Thread__stop()
    		print "Client arrêté. Connexion interrompue."
    		self.connexion.close()
    # Classe permettant la gestion du thread s'occupant de l'émission du message.
    class ThreadEmission(threading.Thread):
    	"""objet thread gérant l'émission des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn           
    		# réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_emis = raw_input()
    			self.connexion.send(message_emis)
    # Établissement de la connexion :
    connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
    	connexion.connect((host, port))
    except socket.error:
    	print "La connexion a échoué."
    	sys.exit()
    print "Connexion établie avec le serveur BlackWater."
    # Dialogue avec le serveur : on lance deux threads pour gérer
    # indépendamment l'émission et la réception des messages :
    th_E = ThreadEmission(connexion)
    th_R = ThreadReception(connexion)
    th_E.start()
    th_R.start()
    Et voici le mini cryptage :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
     
    chaine = raw_input("Donner la chaine à crypter : ")
    dec = 26
    crypt = ""
    decrypt = ""
     
    cpt = 0
    while cpt < len(chaine):
        crypt += chr(ord(chaine[cpt]) + dec)
        cpt += 1
     
    cpt2 = 0
    while cpt2 < len(crypt):
    	decrypt += chr(ord(crypt[cpt2]) - dec)
    	cpt2 +=1
     
    print "La chaine '%s' cryptée : '%s'." % (chaine, crypt)
    print "La chaine cryptée : '%s', une fois décryptée donne : '%s'." % (crypt, decrypt)
    Une personne m'avait conseillé d'utiliser code() et decode(), mais je n'ai pas compris comment l'utiliser (et on a regardé avec mon prof cela, ne fonctionnait pas.)

    Merci de votre aide!

  2. #2
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    Décembre 2007
    Messages
    758
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France

    Informations professionnelles :
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 758
    Points : 970
    Points
    970
    Par défaut
    bonjour,

    tu as besoin:

    - d'une fonction de cryptage (crypt par exemple)
    - d'une fonction de decryptage (decrypt par exemple)

    tu as déjà l'algo de cryptage alors ce devrait être très simple Chacune de ces fonctions doit prendre une chaine de caractères en argument et renvoyer une chaine de caractères.

    ensuite, dans les Threads ça vient tout seul:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    # à l'émission
    self.connexion.send(crypt(message_emis))
     
    # à la réception
    message_recu = decrypt(self.connexion.recv(1024))

  3. #3
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    Merci à toi je vais tester sa

  4. #4
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    Alors voilà le client modifié mais qui ne va pas, et je n'arrive pas à régler l'erreur.
    Le client :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    #!/usr/bin/env python
    #-*-coding:Utf-8-*-
    # ***********************************************************************
    # Définition d'un client réseau gérant en parallèle l'émission
    # et la réception des messages.
    # Ce sont les threads qui s'occupent de se travail là, un thread pour
    # la réception, et un pour l'émission des messages.
    # **********************************************************************
    ip = raw_input("Entrez le numéro du pc serveur : ")
    HOST = "192.168.0.%s" % (ip)
    PORT = 40000
    # **********************************************************************
    # Nous avons besoin des sockets car ils vont servir comme une sorte de
    # logiciel lié au port de communication (dans ce cas 40 000)
    # L'achange de donnée se fait aussi par une fonction des sockets le
    # stream socket, moins évolué que les packets mais plus simple et
    # demandant moins de ressources, c'est grâce au livre de M. Swinnen que 
    # j'ai pu utiliser ces technologies.
    # **********************************************************************
    import socket, sys, threading
    # Création de la fonction pour crypter le message message_emis sera donné dans le thread émission plus loin.
    def crypt(self, message_emis):
    	message_emis = chaine
    	cpt_crypt=0
    	dec = 26
    	crypt = ""
    	while cpt_crypt < len(chaine):
    		crypt += chr(ord(chaine[cpt_crypt]) + dec)
    		cpt_crypt += 1
     
    def decrypt(self):
    	message_recu = message_emis
    	cpt_decrypt = 0
    	decrypt = ""
    	while cpt_decrypt < len(message_recu):
    		decrypt += chr(ord(message_recu[cpt2]) - dec)
    		cpt_decrypt +=1
     
     
    # Classe permettant la gestion du thread s'occupant de l'émission du message.
    class ThreadEmission(threading.Thread):
    	"""objet thread gérant l'émission des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn           
    		# réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_emis = raw_input()
    			self.connexion.send(crypt(message_emis))
     
    # Classe permettant la gestion du thread s'occupant de la réception du message.
    class ThreadReception(threading.Thread):
    	"""objet thread gérant la réception des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn            # réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_recu = decrypt(self.connexion.recv(1024))
    			print "'" + message_recu + "'"
    			if message_recu =='' or message_recu.upper() == "FIN":
    				break
    # **********************************************************************
    # Fermeture par un break (le mal) du thread (classe) réception
    # On force la fermeture du thread émission (th_E) :
    # on ferme 
    # **********************************************************************
    		th_E._Thread__stop()
    		print "Client arrêté. Connexion interrompue."
    		self.connexion.close()
     
    # Établissement de la connexion :
    connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
    	connexion.connect((HOST, PORT))
    except socket.error:
    	print "La connexion a échoué."
    	sys.exit()
    print "Connexion établie avec le serveur BlackWater."
    # Dialogue avec le serveur : on lance deux threads pour gérer
    # indépendamment l'émission et la réception des messages :
    th_E = ThreadEmission(connexion)
    th_R = ThreadReception(connexion)
    th_E.start()
    th_R.start()

    L'erreur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    Exception in thread Thread-2:
    Traceback (most recent call last):
      File "/usr/lib/python2.6/threading.py", line 532, in __bootstrap_inner
        self.run()
      File "/media/dartagnan/classe6t/lefeale/programmation/lefeale_tfe/tfe_prog/client_test.py", line 60, in run
        message_recu = decrypt(self.connexion.recv(1024))
      File "/media/dartagnan/classe6t/lefeale/programmation/lefeale_tfe/tfe_prog/client_test.py", line 32, in decrypt
        message_recu = message_emis
    NameError: global name 'message_emis' is not defined
    Et j'ai essayé de régler le problème en mettant ligne 31 :
    def decrypt(self,message_recu):
    mais quand je fait sa sa m'affiche sa comme erreur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    Exception in thread Thread-2:
    Traceback (most recent call last):
      File "/usr/lib/python2.6/threading.py", line 532, in __bootstrap_inner
        self.run()
      File "/media/dartagnan/classe6t/lefeale/programmation/lefeale_tfe/tfe_prog/client_test.py", line 59, in run
        message_recu = decrypt(self.connexion.recv(1024))
    TypeError: decrypt() takes exactly 2 arguments (1 given)

  5. #5
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    Décembre 2007
    Messages
    758
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France

    Informations professionnelles :
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 758
    Points : 970
    Points
    970
    Par défaut
    il y a une erreur dans la fonction decrypt déjà:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    def decrypt(message_recu):
    	cpt_decrypt = 0
    	decrypt = ""
    	while cpt_decrypt < len(message_recu):
    		decrypt += chr(ord(message_recu[cpt2]) - dec)
    		cpt_decrypt +=1

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    J'ai fait comme tu as dis, après en testant il me mettait une erreur de concaténation, que message_recu n'avait pas de type (str en l'occurence) j'ai donc mis
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    message_recu =str(decrypt(self.connexion.recv(1024)))
    ce qui envois une valeur directement, sans rien marquer, cela met 'None'.

    et quand je tape quelque chose, sa met comme avant 2 arguments 1 given...

  7. #7
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    J'ai fait comme tu as dis, après en testant il me mettait une erreur de concaténation, que message_recu n'avait pas de type (str en l'occurence) j'ai donc mis [...]
    Remets comme c'était.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    def crypt(self, message_emis):
    	message_emis = chaine
    	cpt_crypt=0
    	dec = 26
    	crypt = ""
    	while cpt_crypt < len(chaine):
    		crypt += chr(ord(chaine[cpt_crypt]) + dec)
    		cpt_crypt += 1
    T'as modifié cette fonction ? cause normalement en l'état, elle fonctionne pas. Et puis comme cette fonction ne retourne rien, elle renvoie donc tout de même quelque chose... : None ! . C'est de là qu'elle vient ton erreur
    None est un type, qui représente... rien, mais un rien qui existe bien donc... heu... c'est clair ?

    fonction corrigée (et optimisée) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    def crypt(message):
    	crypted_message = ""
    	for char in message:
    		crypted_message += chr(ord(char)+26)
    	return crypted_message
    ou encore plus court, mais moins lisible:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    def crypt(message):
    	return ''.join( chr(ord(char)+26) for char in message )
    l'histoire du None par le code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> def foo(a,b):
    	a+b
     
     
    >>> foo(1,2)
    >>> type(foo(1,2))
    <type 'NoneType'>
    >>> print foo(1,2)
    None
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    >>> def foo(a,b):
    	return a+b
     
    >>> foo(1,2)
    3

  8. #8
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    J'ai fait +- comme tu avait dis (sur un autre forum on m'avait conseillé +- la même chose)
    et cela donne sa :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    #!/usr/bin/env python
    #-*-coding:Utf-8-*-
    # ***********************************************************************
    # Définition d'un client réseau gérant en parallèle l'émission
    # et la réception des messages.
    # Ce sont les threads qui s'occupent de se travail là, un thread pour
    # la réception, et un pour l'émission des messages.
    # **********************************************************************
    ip = raw_input("Entrez le numéro du pc serveur : ")
    HOST = "127.0.0.%s" % (ip)
    PORT = 40000
    # **********************************************************************
    # Nous avons besoin des sockets car ils vont servir comme une sorte de
    # logiciel lié au port de communication (dans ce cas 40 000)
    # L'achange de donnée se fait aussi par une fonction des sockets le
    # stream socket, moins évolué que les packets mais plus simple et
    # demandant moins de ressources, c'est grâce au livre de M. Swinnen que 
    # j'ai pu utiliser ces technologies.
    # **********************************************************************
    import socket, sys, threading
    # Création de la fonction pour crypter le message message_emis sera donné dans le thread émission plus loin.
    def crypt(message_emis):
    	cpt_crypt=0
    	dec = 26
    	crypt = ""
    	while cpt_crypt < len(message_emis):
    		crypt += chr(ord(message_emis[cpt_crypt]) + dec)
    		cpt_crypt += 1
    	return crypt
     
    def decrypt(message_recu):
    	cpt_decrypt = 0
    	decrypt = ""
    	dec = 26
    	while cpt_decrypt < len(message_recu):
    		decrypt += chr(ord(message_recu[cpt_decrypt]) - dec)
    		cpt_decrypt +=1
    	return decrypt
     
     
    # Classe permettant la gestion du thread s'occupant de l'émission du message.
    class ThreadEmission(threading.Thread):
    	"""objet thread gérant l'émission des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn           
    		# réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_emis = raw_input()
    			self.connexion.send(crypt(message_emis))
     
    # Classe permettant la gestion du thread s'occupant de la réception du message.
    class ThreadReception(threading.Thread):
    	"""objet thread gérant la réception des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn            # réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_recu = decrypt(self.connexion.recv(1024))
    			print "'" + message_recu + "'"
    			if message_recu =='' or message_recu.upper() == "FIN":
    				break
    # **********************************************************************
    # Fermeture par un break (le mal) du thread (classe) réception
    # On force la fermeture du thread émission (th_E) :
    # on ferme 
    # **********************************************************************
    		th_E._Thread__stop()
    		print "Client arrêté. Connexion interrompue."
    		self.connexion.close()
     
    # Établissement de la connexion :
    connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
    	connexion.connect((HOST, PORT))
    except socket.error:
    	print "La connexion a échoué."
    	sys.exit()
    print "Connexion établie avec le serveur BlackWater."
    # Dialogue avec le serveur : on lance deux threads pour gérer
    # indépendamment l'émission et la réception des messages :
    th_E = ThreadEmission(connexion)
    th_R = ThreadReception(connexion)
    th_E.start()
    th_R.start()

    Et sa marche!
    Ou presque...
    En effet, le client voit ce qu'il tape normalement, mais les autres ne peuvent voir que la chaine cryptée, ce qui n'est pas pratique...

  9. #9
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    En effet, heu... réponse de faignant : testes tes fonctions crypt et decrypt dans la console python, et vois si elle fonctionnent comme prévu... peut-être une erreur dans un des algorithmes.

  10. #10
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    Je pense qu'il faut que je mette un autre connexion send car c'est logique en faite, le programme en ce moment prends la chaine du client, l’envoi au serveur puis la retape cryptée aux autre.. je vais regarder sa

  11. #11
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    Il faut que le serveur reçoive bien la chaîne codée, sans la décoder, pour la renvoyer telle quelle au clients, cause si cette chaîne cryptée est sur-cryptée (ou renvoyée en clair)...

  12. #12
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    hmmm alors j'enleve le cryp au connexion send et je le rajoute au connexion recv comme cela le client recevra la chaine cryptée et la décryptée.. je regarderai sa ce soir ou demain

  13. #13
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    Ah mais non, chaque message Serveur <--> Client doivent être cryptés, sinon il y a faille !

    imaginons que l'on soit dans ton script serveur, tu peux te faire deux chaînes:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    #reception
    crypted_message = connexion.recv(1080)
    cleared_message = decrypt(crypted_message)
    comme ça plus tard, au moment de renvoyer le message vers les différents clients:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    #emission vers un des clients
    connexion.send(crypted_message)
    Ainsi entre-temps, tu as une version décryptée du message qui, n'étant pas la variable que tu renverras, est parfaitement sûre pour tout type de traitement, de log, etc...

  14. #14
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    En faite le must ce serait que le serveur voient la chaine cryptée et décryptée et le client aussi (cela n'as aucun interet mais mon prof m'as demandé cela)

  15. #15
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    Désolé du double post mais voila ce que mon prof aimerait

    Le client tape sa phrase
    La chaine se fait cryptée
    La chaine est envoyée au serveur
    Le serveur affiche la chaine cryptée
    Le serveur décrypte
    Le serveur affiche la chaine décryptée
    Le client recoit la chaine décryptée.

    Hmmm, je me met au boulot

  16. #16
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    Le serveur affiche la chaine décryptée
    Le client recoit la chaine décryptée.
    C'est clair que dans ce cas, on peut s'interroger sur l'interêt d'un cryptage à la base, si c'est pour qu'au final le message crypté finnisse par être relayé en clair par le serveur. Ton prof boit-il ?

  17. #17
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    Effectivement, remarque pertinente

    Ou alors comme cela :
    Le client écrit un message
    Le client crypte le message
    Le client envois le message
    Le serveur reçoit
    Le serveur affiche
    Le serveur décrypte la donnée
    le serveur renvois la donnée décryptée
    le client affiche

    Voilà sa c'est mieux je pense, comme cela sa fait comme si le serveur cryptait la donnée (voilà c'est simple mais bon j'y arrive pas)

    Voilà pour le moment le code client:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    #!/usr/bin/env python
    #-*-coding:Utf-8-*-
    # ***********************************************************************
    # Définition d'un client réseau gérant en parallèle l'émission
    # et la réception des messages.
    # Ce sont les threads qui s'occupent de se travail là, un thread pour
    # la réception, et un pour l'émission des messages.
    # **********************************************************************
    ip = raw_input("Entrez le numéro du pc serveur : ")
    HOST = "192.168.0.%s" % (ip)
    PORT = 40000
    # **********************************************************************
    # Nous avons besoin des sockets car ils vont servir comme une sorte de
    # logiciel lié au port de communication (dans ce cas 40 000)
    # L'achange de donnée se fait aussi par une fonction des sockets le
    # stream socket, moins évolué que les packets mais plus simple et
    # demandant moins de ressources, c'est grâce au livre de M. Swinnen que 
    # j'ai pu utiliser ces technologies.
    # **********************************************************************
    import socket, sys, threading
    # Création de la fonction pour crypter le message message_emis sera donné dans le thread émission plus loin.
    def crypt(message_emis):
    	cpt_crypt=0
    	dec = 26
    	crypt = ""
    	while cpt_crypt < len(message_emis):
    		crypt += chr(ord(message_emis[cpt_crypt]) + dec)
    		cpt_crypt += 1
    	return crypt
     
    def decrypt(message_recu):
    	cpt_decrypt = 0
    	decrypt = ""
    	dec = 26
    	while cpt_decrypt < len(message_recu):
    		decrypt += chr(ord(message_recu[cpt_decrypt]) - dec)
    		cpt_decrypt +=1
    	return decrypt
     
     
    # Classe permettant la gestion du thread s'occupant de l'émission du message.
    class ThreadEmission(threading.Thread):
    	"""objet thread gérant l'émission des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn           
    		# réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_emis = raw_input()
    			self.connexion.send(crypt(message_emis))
     
    # Classe permettant la gestion du thread s'occupant de la réception du message.
    class ThreadReception(threading.Thread):
    	"""objet thread gérant la réception des messages"""
    	def __init__(self, conn):
    		threading.Thread.__init__(self)
    		self.connexion = conn            # réf. du socket de connexion
    	def run(self):
    		while 1:
    			message_recu = decrypt(self.connexion.recv(1024))
    			print "'" + message_recu + "'"
    			if message_recu =='' or message_recu.upper() == "FIN":
    				break
    # **********************************************************************
    # Fermeture par un break (le mal) du thread (classe) réception
    # On force la fermeture du thread émission (th_E) :
    # on ferme 
    # **********************************************************************
    		th_E._Thread__stop()
    		print "Client arrêté. Connexion interrompue."
    		self.connexion.close()
     
    # Établissement de la connexion :
    connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
    	connexion.connect((HOST, PORT))
    except socket.error:
    	print "La connexion a échoué."
    	sys.exit()
    print "Connexion établie avec le serveur BlackWater."
    # Dialogue avec le serveur : on lance deux threads pour gérer
    # indépendamment l'émission et la réception des messages :
    th_E = ThreadEmission(connexion)
    th_R = ThreadReception(connexion)
    th_E.start()
    th_R.start()



    Sinon en image voilà ce que cela donne, c'est assez foireux pour le moment:
    Lancement du serveur, la il crypte le 'Bienvenue sur le serveur BlackWater' et je me prépare à envoyer ma première chaine.


    Là on voit ce que sa donne du coté de ceux qui réceptionnent le message, pas grand chose car il n'y a que le 'Thread numéro dit : ' qui est crypté et pas la chaine envoyée :


    La j'ai envoyé 'test 2' avec un autre client (sur la même machine comme vous voyez) et c'est pareil :


    Et la ce que le serveur affiche.. et c'est tout bon pour lui ... :

  18. #18
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    Le serveur reçoit
    Le serveur affiche
    Le serveur décrypte la donnée
    le serveur renvois la donnée décryptée
    C'est toujours pareil, le serveur relaye un message non codé, dans le contexte qui le tien, l'intérêt d'un cryptage réside dans le fait que les transmission entre le serveur et les clients (et vice versa) sont cryptées.

    C'est pourquoi je te suggérais que lorsque le serveur reçoit un message, il affiche une copie décryptée du message, mais renvoie vers les client le message original qu'il a reçu (qui est donc crypté). Et comme les clients s'attendent à recevoir un message crypté, ils peuvent donc le décrypter à leur tour afin de restituer le véritable message de l'auteur.

    Ainsi, tout le monde affiche le véritable message, mais chaque transmission est cryptée, et chacun s'y attend. Il n'y a donc pas de problème.

  19. #19
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2011
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2011
    Messages : 17
    Points : 2
    Points
    2
    Par défaut
    J'ai bien redemandé à mon prof, il veut que ce soit le serveur qui crypt et puis le client qui décrypt, donc en faite mon tfe est presque finis, question serveur c'est ok, mais le client lui crypt 'Thread 2 dit' assez embetant

  20. #20
    Membre éclairé
    Homme Profil pro
    heu...
    Inscrit en
    Octobre 2007
    Messages
    648
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : heu...

    Informations forums :
    Inscription : Octobre 2007
    Messages : 648
    Points : 773
    Points
    773
    Par défaut
    print est ton plus fidèle ami. Mais on ne connais toujours pas le code serveur...
    en attendant, essayes ce script client et regardes les messages DEBUG. le problème devrait toujours être là, mais au moins on pourra s'assurer que cela ne vient pas de ce script.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    #!/usr/bin/env python
    #-*-coding:Utf-8-*-
    # ***********************************************************************
    # Définition d'un client réseau gérant en parallèle l'émission
    # et la réception des messages.
    # Ce sont les threads qui s'occupent de se travail là, un thread pour
    # la réception, et un pour l'émission des messages.
    # **********************************************************************
    ip = raw_input("Entrez le numéro du pc serveur : ")
    HOST = "192.168.0.%s" % (ip)
    PORT = 40000
    # **********************************************************************
    # Nous avons besoin des sockets car ils vont servir comme une sorte de
    # logiciel lié au port de communication (dans ce cas 40 000)
    # L'achange de donnée se fait aussi par une fonction des sockets le
    # stream socket, moins évolué que les packets mais plus simple et
    # demandant moins de ressources, c'est grâce au livre de M. Swinnen que 
    # j'ai pu utiliser ces technologies.
    # **********************************************************************
    import socket, sys, threading
    # Création de la fonction pour crypter le message message_emis sera donné dans le thread émission plus loin.
    def crypt(message_emis):
        return ''.join(chr(ord(c)+26) for c in message_emis)
     
     
    def decrypt(message_recu):
        return  ''.join( chr(ord(c)-26) for c in message_recu) )
     
     
    # Classe permettant la gestion du thread s'occupant de l'émission du message.
    class ThreadEmission(threading.Thread):
        """objet thread gérant l'émission des messages"""
        def __init__(self, conn):
            threading.Thread.__init__(self)
            self.connexion = conn           
            # réf. du socket de connexion
        def run(self):
            while 1:
                message_emis = raw_input('> ')
                print 'DEBUG Emisson msg clear:','"',message_emis,'"'
                message_emis = crypt(message_emis)
                print 'DEBUG Emisson msg coded:','"',message_emis,'"'
                self.connexion.send(message_emis)
     
    # Classe permettant la gestion du thread s'occupant de la réception du message.
    class ThreadReception(threading.Thread):
        """objet thread gérant la réception des messages"""
        def __init__(self, conn):
            threading.Thread.__init__(self)
            self.connexion = conn            # réf. du socket de connexion
        def run(self):
            while 1:
                message_recu = self.connexion.recv(1024)
                print 'DEBUG Reception msg coded:','"',message_recu,'"'
                message_recu = decrypt(message_recu)
                print 'DEBUG Reception msg clear:','"',message_recu,'"'
                print "'" + message_recu + "'"
                if message_recu =='' or message_recu.upper() == "FIN":
                    break
    # **********************************************************************
    # Fermeture par un break (le mal) du thread (classe) réception
    # On force la fermeture du thread émission (th_E) :
    # on ferme 
    # **********************************************************************
            th_E._Thread__stop()
            print "Client arrêté. Connexion interrompue."
            self.connexion.close()
     
    # Établissement de la connexion :
    connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        connexion.connect((HOST, PORT))
    except socket.error:
        print "La connexion a échoué."
        sys.exit()
    print "Connexion établie avec le serveur BlackWater."
    # Dialogue avec le serveur : on lance deux threads pour gérer
    # indépendamment l'émission et la réception des messages :
    th_E = ThreadEmission(connexion)
    th_R = ThreadReception(connexion)
    th_E.start()
    th_R.start()

Discussions similaires

  1. Obligé d'utiliser les threads pour faire un timer ?
    Par theclem35 dans le forum Débuter
    Réponses: 5
    Dernier message: 31/03/2011, 21h25
  2. Réponses: 6
    Dernier message: 20/08/2010, 11h13
  3. Utiliser les threads pour les traitements long
    Par rach375 dans le forum Websphere
    Réponses: 3
    Dernier message: 14/11/2006, 13h08
  4. [VB]chat utilisant les mailslots
    Par Shypster dans le forum VB 6 et antérieur
    Réponses: 6
    Dernier message: 28/01/2006, 00h34

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo