Partage
  • Partager sur Facebook
  • Partager sur Twitter

[WebSocket] Validation du handshake

    22 octobre 2010 à 22:24:38

    Bonjour,

    Je ne savais pas trop ou poster. Je suis actuellement entrain de créer un serveur websocket en python cependant je n'arrive pas a faire la validation du handshake je m'explique.

    Tout d'abord je me sert du draft du protocole websocket

    http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-03

    Ensuite la poignet de mains commence par le handshake du client puis je doit renvoyer celui du serveur suivant ce qu'envoie le client.

    Dans celui du clients 3 info nous interesse pour valider le handshake la Key1, Key2 et le code qui est à la fin du hanshake.

    Moi au niveau du serveur je doit, si j'ai bien compris le protocole ,effectuer une opération au niveau de chaque clé.
    cet operation consiste à concatener tous les chiffres d'une clé puis de divisé ce nombre par le nombre d'espace puis de faire un pack en unsigned long interger big endian du résultat. je fais la même chose avec la clé 2.

    Ensuite j'additionne la clé 1, 2 et le code de fin handshake et j'applique un md5 la dessus

    Citation : Exemple de handshake client


    GET /demo HTTP/1.1
    Host: example.com
    Connection: Upgrade
    Sec-WebSocket-Key2: 12998 5 Y3 1 .P00
    Sec-WebSocket-Protocol: sample
    Upgrade: WebSocket
    Sec-WebSocket-Key1: 18x 6]8vM;54 *(5: { U1]8 z [ 8
    Sec-WebSocket-Key2: 1_ tx7X d < nw 334J702) 7]o}` 0
    Origin: http://example.com

    Tm[K T2u



    Citation : Exemple de handshake Serveur


    HTTP/1.1 101 WebSocket Protocol Handshake
    Upgrade: WebSocket
    Connection: Upgrade
    Sec-WebSocket-Origin: http://example.com
    Sec-WebSocket-Location: ws://example.com/demo
    Sec-WebSocket-Protocol: sample

    fQJ,fN/4F4!~K~MH



    Voilà pour l'introduction. Malheureusement je n'arrive pas à produire la code pour signer le handshake serveur en tout cas à chaque fois j'ai une déconnection du clients car la clé est mauvaise...

    Voici mon code pour générer le handshake à partir de celui du clients

    # -*- coding:utf8 -*-
    import re
    import struct
    import hashlib
    class Handshake:
    	def __init__(self,handshakeClient):
    	
    		getHost = re.compile("Host: (.*)\r\n")
    		getOrigin = re.compile("Origin: (.*)\r\n")
    		getRessource = re.compile("GET (.*) HTTP")
    		getKey1 = re.compile("Sec-WebSocket-Key1: (.*)\r\n")
    		getKey2 = re.compile("Sec-WebSocket-Key2: (.*)\r\n") 
    		getCode = re.compile("\r\n(.*)$") 
    		
    		self.host = (getHost.search(handshakeClient)).group(1)
    		self.origin = (getOrigin.search(handshakeClient)).group(1)
    		self.ressource = (getRessource.search(handshakeClient)).group(1)
    		self.key1 = (getKey1.search(handshakeClient)).group(1)
    		self.key2 = (getKey2.search(handshakeClient)).group(1)
    		self.code= (getCode.search(handshakeClient)).group(1)
    	
    	def parseKey(self,key):
    		valeur = ""
    		space = 0
    		for caractere in key:
    			if ord(caractere) >=48 and ord(caractere)<=57:
    				valeur+=caractere
    			elif ord(caractere) == ord(" "):
    				space+=1
    		return struct.pack('!L',(int(valeur)/space)) # ordre big endian Unsigned Long Interger
    	
    	def createKey(self): # to sign the handshake of the server
    		return hashlib.md5(self.parseKey(self.key1)+self.parseKey(self.key2)+self.code).digest() # md5 of the concatenation of key1,key2,code
    		
    	def createHandshakeServer(self):
    		return "HTTP/1.1 101 Web Socket Protocol Handshake\r\nUpgrade: WebSocket\r\nConnection: Upgrade\r\nSec-WebSocket-Origin: http://%s\r\nSec-WebSocket-Location: ws://%s%s\r\nSec-WebSocket-Protocol: sample\r\n\r\n%s" % (self.host, self.origin,self.ressource,self.createKey())
    



    J'espère que vous pourrez m'aider.

    Blister
    • Partager sur Facebook
    • Partager sur Twitter
      29 janvier 2011 à 15:31:39

      Bonjour,

      Je n'arrive pas non plus à créer une connexion entre le client et le serveur ! Je travaille également sous Python. Mon serveur reçoit le handshake du client, mais cela s'arrête là !

      Ce qui est curieux, c'est que tu cherches une clef dans le handshake du client, non ? Cela m'étonne car j'ai trouvé des serveurs Python sur internet qui envoient la même chose au client quel que soit le handshake du client.

      A titre d'exemple, le code d'Adrian Gaudebert.

      Pourrais-tu me renseigner sur ce point ?

      Merci par avance
      • Partager sur Facebook
      • Partager sur Twitter
      Anonyme
        29 janvier 2011 à 22:22:12

        Bon j'y connais rien là dedans, mais je retiens ceci

        Citation

        cet operation consiste à concatener tous les chiffres d'une clé puis de divisé ce nombre par le nombre d'espace



        Vite fait je ferais ceci

        >>> def valeur(key):
        ...     nombre = ""
        ...     for i in key:
        ...         if i.isdigit():
        ...             nombre += i
        ...     return nombre
        ... 
        >>> 
        >>> def espace(key):
        ...     return key.count(" ")
        ... 
        >>> cle = "18x 6]8vM;54 *(5: { U1]8 z [ 8"
        >>> valeur(cle)
        '1868545188'
        >>> espace(cle)
        7 # nombre d'espacement
        


        Citation

        puis de faire un pack en unsigned long interger big endian du résultat



        Là j'ai rien capté!

        • Partager sur Facebook
        • Partager sur Twitter
          30 janvier 2011 à 14:50:08

          Comme j'ai le beau code, j'aurais plutôt fait ca:

          Citation : fred1599

          def valeur(key):
              return ''.join([i for i in key if i.isdigit()])
          

          Mais ensuite c'est personnel, et ca n'aide pas beaucoup l'OP.
          • Partager sur Facebook
          • Partager sur Twitter
          yjltg.
            1 février 2011 à 18:37:27

            Si ça peut aider :
            >>> import struct
            >>> def valeur(key):
            	return int(''.join([i for i in key if i.isdigit()])) / key.count(" ")
            
            >>> clef = "18x 6]8vM;54 *(5: { U1]8 z [ 8"
            >>> struct.pack("L", valeur(clef)) # retourne un unsigned long integer
            '\xf2\x1a\xe9\x0f'
            
            • Partager sur Facebook
            • Partager sur Twitter

            [WebSocket] Validation du handshake

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
            • Editeur
            • Markdown