Mi Python seguro websocket código de cliente darme excepción de la siguiente manera:

[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:748)

He creado mi certificado y firmar el certificado, pero no soy capaz de conectarse a él mediante secuencia de comandos de Python como sigue:

import json
from websocket import create_connection


class subscriber:
   def listenForever(self):
   try:
      # ws = create_connection("wss://localhost:9080/websocket")
      ws = create_connection("wss://nbtstaging.westeurope.cloudapp.azure.com:9090/websocket")
      ws.send("test message")
      while True:
          result = ws.recv()
          result = json.loads(result)
          print("Received '%s'" % result)

      ws.close()
  except Exception as ex:
      print("exception: ", format(ex))


try:
    subscriber().listenForever()
except:
    print("Exception occured: ")

Mi https/servidor wss script en python con el tornado de la siguiente manera:

import tornado.web
import tornado.websocket
import tornado.httpserver
import tornado.ioloop
import os
import ssl

ssl_root = os.path.join(os.path.dirname(__file__), 'ssl1_1020')


class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def check_origin(self, origin):
        return True

    def open(self):
        pass

    def on_message(self, message):
        self.write_message("Your message was: " + message)
        print("message received: ", format(message))

    def on_close(self):
        pass


class IndexPageHandler(tornado.web.RequestHandler):
    def get(self):
        self.render("index.html")


class Application(tornado.web.Application):
    def __init__(self):
        handlers = [
           (r'/', IndexPageHandler),
           (r'/websocket', WebSocketHandler),
        ]

        settings = {
            'template_path': 'templates'
        }
        tornado.web.Application.__init__(self, handlers, **settings)


ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.load_cert_chain(ssl_root+"/server.crt",
                    ssl_root + "/server.pem")


if __name__ == '__main__':
    ws_app = Application()
    server = tornado.httpserver.HTTPServer(ws_app, ssl_options=ssl_ctx,)
    server.listen(9081, "0.0.0.0")
    print("server started...")
    tornado.ioloop.IOLoop.instance().start()

pasos que se usan para crear SSL certificados de firma:

openssl genrsa -des3 -out server.key 1024
openssl rsa -in server.key -out server.pem
openssl req -new -nodes -key server.pem -out server.csr
openssl x509 -req -days 365 -in server.csr -signkey server.pem -out server.crt
InformationsquelleAutor Ravi Anand | 2017-10-20

4 Comentarios

  1. 6

    Finalmente encontré la solución, he actualizado python script de cliente mientras que la toma de conexión a la web segura de socket url ignorar cert solicitud de la siguiente manera:

     ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
          ws.connect("wss://xxx.com:9090/websocket")
  2. 2

    Si alguien tiene curiosidad en el futuro ¿por qué wss python server no es a causa de este derecho aquí, en el tornado documentación:

    Cuando se utiliza una segura conexión websocket (wss://) con un certificado auto-firmado, la conexión desde un navegador puede fallar porque se quiere mostrar la «aceptar este certificado de diálogo», pero tiene nada que mostrar. Debe la primera visita regular de la página HTML utilizando el mismo certificado para aceptarlo antes de la conexión websocket tendrá éxito.

  3. 0

    Para mí, ignorando los errores no es una opción, tuve que utilizar mi certificado autofirmado:

    import asyncio
    import pathlib
    import ssl
    import websockets
    
    ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
    localhost_pem = pathlib.Path(__file__).with_name("localhost.pem")
    ssl_context.load_verify_locations(localhost_pem)
    
    async def hello():
        uri = "wss://localhost:8765"
        async with websockets.connect(
            uri, ssl=ssl_context
        ) as websocket:
            name = input("What's your name? ")
    
            await websocket.send(name)
            print(f"> {name}")
    
            greeting = await websocket.recv()
            print(f"< {greeting}")
    
    asyncio.get_event_loop().run_until_complete(hello())

    Encontrado aquí en el websocket repo de la carpeta de ejemplos.

    P. S

    He cambiado de SSLContext(ssl.PROTOCOL_TLS_CLIENT) a SSLContext(ssl.PROTOCOL_TLSv1_2) para hacer que funcione

  4. 0

    Sólo se trate de la continuación para propósitos de prueba solamente. El siguiente es un muy insegura kluge:

    import asyncio, ssl, websockets
    
    #todo kluge
    #HIGHLY INSECURE
    ssl_context = ssl.SSLContext()
    ssl_context.check_hostname = False
    ssl_context.verify_mode = ssl.CERT_NONE
    #HIGHLY INSECURE
    #todo kluge
    
    uri = "wss://myAwesomeSSL.wss.kluge"
    
    async with websockets.connect(uri, ssl=ssl_context) as websocket:
            greeting = await websocket.recv()
            print(f"< {greeting}")

Dejar respuesta

Please enter your comment!
Please enter your name here