ssl —Empaquetador o wrapper TLS/SSL para objetos de tipo socket

Código fuente:Lib/ssl.py


This module provides access to Transport Layer Security (often known as «Secure Sockets Layer») encryption and peer authentication facilities for network sockets, both client-side and server-side. This module uses the OpenSSL library. It is available on all modern Unix systems, Windows, macOS, and probably additional platforms, as long as OpenSSL is installed on that platform.

Nota

Some behavior may be platform dependent, since calls are made to the operating system socket APIs. The installed version of OpenSSL may also cause variations in behavior. For example, TLSv1.1 and TLSv1.2 come with openssl version 1.0.1.

Advertencia

No use este módulo sin leer Consideraciones de seguridad. Hacerlo puede generar una falsa sensación de seguridad, ya que la configuración predeterminada del módulo ssl no es necesariamente la adecuada para su aplicación.

Esta sección documenta los objetos y funciones en el módulo ssl; para más información general sobre TLS,SSL, y certificados, se recomienda que el lector acuda a la sección «Ver también» al final de la página.

Este módulo proporciona una clase, ssl.SSLSocket, que se deriva del tipo socket.socket, y proporciona una envoltura similar a un socket que también encripta y desencripta los datos que pasan por el socket con SSL . Admite métodos adicionales como getpeercert(), que recupera el certificado del otro lado de la conexión, y cipher(), que recupera el cifrado que se utiliza para la conexión segura.

Para aplicaciones más sofisticadas, la clase ssl.SSLContext ayuda a administrar la configuración y los certificados, que luego pueden ser heredados por sockets SSL creados a través del método SSLContext.wrap_socket().

Distinto en la versión 3.5.3: Actualizado para admitir la vinculación con OpenSSL 1.1.0

Distinto en la versión 3.6: OpenSSL 0.9.8, 1.0.0 y 1.0.1 son obsoletos y no son compatibles. En el futuro, el módulo ssl requerirá al menos OpenSSL 1.0.2 o 1.1.0.

Funciones, constantes y excepciones

Creación de sockets

Desde Python 3.2 y 2.7.9, se recomienda utilizar SSLContext.wrap_socket() de una instancia de SSLContext para envolver sockets como objetos SSLSocket. La función utilitaria create_default_context() retorna un nuevo contexto con ajustes por defecto seguros. La vieja función wrap_socket() es obsoleta debido a que es ineficiente y que no tiene soporte para la indicación de nombre de servidor (SNI) ni hostname matching.

Ejemplo de socket cliente con contexto por defecto y doble pila IPv4/IPv6:

import socket
import ssl

hostname = 'www.python.org'
context = ssl.create_default_context()

with socket.create_connection((hostname, 443)) as sock:
    with context.wrap_socket(sock, server_hostname=hostname) as ssock:
        print(ssock.version())

Ejemplo de socket cliente con contexto personalizado y IPv4:

hostname = 'www.python.org'
# PROTOCOL_TLS_CLIENT requires valid cert chain and hostname
context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
context.load_verify_locations('path/to/cabundle.pem')

with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
    with context.wrap_socket(sock, server_hostname=hostname) as ssock:
        print(ssock.version())

Ejemplo de socket servidor escuchando en localhost IPv4:

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain('/path/to/certchain.pem', '/path/to/private.key')

with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
    sock.bind(('127.0.0.1', 8443))
    sock.listen(5)
    with context.wrap_socket(sock, server_side=True) as ssock:
        conn, addr = ssock.accept()
        ...

Creación de contexto

Una función conveniente ayuda a crear objetos SSLContext para propósitos comunes.

ssl.create_default_context(purpose=Purpose.SERVER_AUTH, cafile=None, capath=None, cadata=None)

Retorna un nuevo objeto SSLContext con ajustes por defecto para el purpose dado. Los ajustes son elegidos por el módulo ssl y generalmente representan un nivel de seguridad mas alto que invocando directamente el constructor de SSLContext.

cafile, capath, cadata representan certificados CA opcionales para confiar en la verificación de certificados, como en SSLContext.load_verify_locations(). Si los tres son None al mismo tiempo, esta función puede optar por confiar en su lugar en los certificados CA por defecto del sistema.

Los ajustes son: PROTOCOL_TLS, OP_NO_SSLv2 y OP_NO_SSLv3 con suites de cifrado de alto nivel sin RC4 y sin suites de cifrado sin autentificar. Pasar SERVER_AUTH como purpose establece verify_mode a CERT_REQUIRED y carga los certificados CA (si al menos uno de cafile, capath o cadata es dado) o usa SSLContext.load_default_certs() para cargar los certificados CA por defecto.

Cuando keylog_filename es soportado y la variable de entorno SSLKEYLOGFILE está establecida, create_default_context() activa el registro de claves.

Nota

El protocolo, las opciones, el cifrado y otros ajustes pueden cambiar a valores mas restrictivos en cualquier momento sin previa obsolescencia. Los valores representan un equilibrio justo entre compatibilidad y seguridad.

Si su aplicación necesita ajustes específicos, debe crear un SSLContext y aplicar los ajustes usted mismo.

Nota

Si encuentra que cuando ciertos clientes o servidores antiguos intentan conectarse con un SSLContext creado con esta función obtienen un error indicando Protocol or cipher suite mismatch, puede ser que estos sólo soportan SSL3.0 el cual esta función excluye utilizando OP_NO_SSLv3. SSL3.0 está ampliamente considerado como completamente roto. Si todavía desea seguir utilizando esta función pero permitir conexiones SSL 3.0, puede volver a activarlas mediante:

ctx = ssl.create_default_context(Purpose.CLIENT_AUTH)
ctx.options &= ~ssl.OP_NO_SSLv3

Nuevo en la versión 3.4.

Distinto en la versión 3.4.4: RC4 ha sido abandonado de la cadena de cifrado por defecto.

Distinto en la versión 3.6: ChaCha20/Poly1305 ha sido agregado a la cadena de caracteres de cifrado por defecto.

3DES ha sido abandonado de la cadena de caracteres de cifrado por defecto.

Distinto en la versión 3.8: Soporte del registro de claves en SSLKEYLOGFILE ha sido agregado.

Excepciones

exception ssl.SSLError

Se lanza para señalar un error de la implementación de SSL subyacente (actualmente proporcionada por la biblioteca OpenSSL). Esto indica algún problema en la capa de cifrado y autenticación de alto nivel que se superpone a la conexión de red subyacente. Este error es un subtipo de OSError. El código de error y el mensaje de las instancias de SSLError son proporcionados por la biblioteca OpenSSL.

Distinto en la versión 3.3: SSLError era un subtipo de socket.error.

library

Una cadena de caracteres mnemotécnica que designa el submódulo de OpenSSL en el que se ha producido el error, como SSL, PEM o X509. El rango de valores posibles depende de la versión de OpenSSL.

Nuevo en la versión 3.3.

reason

Una cadena de caracteres mnemotécnica que designa la razón por la que se produjo el error, por ejemplo CERTIFICATE_VERIFY_FAILED. El rango de valores posibles depende de la versión de OpenSSL.

Nuevo en la versión 3.3.

exception ssl.SSLZeroReturnError

Una subclase de SSLError lanzada cuando se intenta leer o escribir y la conexión SSL ha sido cerrada limpiamente. Tenga en cuenta que esto no significa que el transporte subyacente (lectura TCP) haya sido cerrado.

Nuevo en la versión 3.3.

exception ssl.SSLWantReadError

Una subclase de SSLError lanzada por un socket SSL no bloqueante cuando se intenta leer o escribir datos, pero mas datos necesitan ser recibidos en el transporte TCP subyacente antes de que la solicitud pueda ser completada.

Nuevo en la versión 3.3.

exception ssl.SSLWantWriteError

Una subclase de SSLError lanzada por un socket SSL no bloqueante cuando se intenta leer o escribir datos, pero mas datos necesitan ser enviados en el transporte TCP subyacente antes de que la solicitud pueda ser completada.

Nuevo en la versión 3.3.

exception ssl.SSLSyscallError

Una subclase de SSLError lanzada cuando se encuentra un error del sistema mientras se intenta completar una operación en un socket SSL. Por desgracia, no hay una manera fácil de inspeccionar el número errno original.

Nuevo en la versión 3.3.

exception ssl.SSLEOFError

Una subclase de SSLError lanzada cuando la conexión SSL ha sido cancelada abruptamente. Generalmente, no debería intentar reutilizar el transporte subyacente cuando este error se produce.

Nuevo en la versión 3.3.

exception ssl.SSLCertVerificationError

Una subclase de SSLError lanzada cuando la validación del certificado ha fallado.

Nuevo en la versión 3.7.

verify_code

Un número de error numérico que indica el error de verificación.

verify_message

Una cadena de caracteres legible del error de verificación.

exception ssl.CertificateError

Un alias para SSLCertVerificationError.

Distinto en la versión 3.7: La excepción es ahora un alias para SSLCertVerificationError.

Generación aleatoria

ssl.RAND_bytes(num)

Retorna num bytes pseudoaleatorios criptográficamente fuertes. Lanza un SSLError si el PRNG no a sido sembrado con suficiente datos o si la operación no es soportada por el método RAND actual. RAND_status() puede ser usada para verificar el estado de PRNG y RAND_add() puede ser usada para sembrar el PRNG.

Para casi todas las aplicaciones os.urandom() es preferible.

Léase el artículo Wikipedia, Generador de números pseudoaleatorios criptográficamente seguro (CSPRNG), para obtener los requisitos para un generador criptográficamente seguro.

Nuevo en la versión 3.3.

ssl.RAND_pseudo_bytes(num)

Retorna (bytes, is_cryptographic): bytes es num bytes pseudoaleatorios, is_cryptographic es True si los bytes generados son criptográficamente fuertes. Lanza un SSLError si la operación no es soportada por el método RAND actual.

Las secuencias de bytes pseudoaleatorios generadas serán únicas si tienen una longitud suficiente, pero no son necesariamente impredecibles. Pueden utilizarse para fines no criptográficos y para ciertos fines en protocolos criptográficos, pero normalmente no para la generación de claves, etc.

Para casi todas las aplicaciones os.urandom() es preferible.

Nuevo en la versión 3.3.

Obsoleto desde la versión 3.6: OpenSSL a dejado obsoleta ssl.RAND_pseudo_bytes(), utilice ssl.RAND_bytes() en su lugar.

ssl.RAND_status()

Retorna True si el generador de números pseudoaleatorios SSL a sido sembrado con “suficiente” aleatoriedad, y False de lo contrario. Puede utilizarse ssl.RAND_egd() y ssl.RAND_add() para aumentar la aleatoriedad del generador de números pseudoaleatorios.

ssl.RAND_egd(path)

Si está ejecutando un daemon de recolección de entropía (EGD) en algún lugar, y path es la ruta de una conexión de socket abierta a él, esto leerá 256 bytes de aleatoriedad del socket, y lo añadirá al generador de números pseudoaleatorios de SSL para aumentar la seguridad de las claves secretas generadas. Esto suele ser necesario sólo en sistemas sin mejores fuentes de aleatoriedad.

Véase http://egd.sourceforge.net/ o http://prngd.sourceforge.net/ para fuentes de daemons de recolección de entropía (EGD).

Disponibilidad: no disponible con LibreSSL y OpenSSL > 1.1.0.

ssl.RAND_add(bytes, entropy)

Mezcla los bytes dados en el generador de números pseudoaleatorios de SSL. El parámetro entropy (un flotante) es un límite inferior de la entropía contenida en la cadena de caracteres (por lo que siempre se puede utilizar 0.0). Véase RFC 1750 para mas información sobre las fuentes de entropía.

Distinto en la versión 3.5: Ahora se acepta bytes-like object modificable.

Gestión de certificados

ssl.match_hostname(cert, hostname)

Verifica que cert (en formato decodificado tal y como es retornado por SSLSocket.getpeercert()) coincide con el hostname dado. Las reglas aplicadas son las de comprobación de la identidad de los servidores HTTPS, como se indica en RFC 2818, RFC 5280 y RFC 6125. Además de HTTPS, esta función debería ser adecuada para comprobar la identidad de servidores en varios protocolos basados en SSL como FTPS, IMAPS, POPS y otros.

CertificateError es lanzado en caso de error. En caso de éxito, la función no retorna nada:

>>> cert = {'subject': ((('commonName', 'example.com'),),)}
>>> ssl.match_hostname(cert, "example.com")
>>> ssl.match_hostname(cert, "example.org")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/py3k/Lib/ssl.py", line 130, in match_hostname
ssl.CertificateError: hostname 'example.org' doesn't match 'example.com'

Nuevo en la versión 3.2.

Distinto en la versión 3.3.3: La función ahora sigue RFC 6125 sección 6.4.3 y no soporta múltiples caracteres comodín (por ejemplo *.*.com o *a*.example.org) ni tampoco un carácter comodín dentro de un fragmento de un nombre de dominio internacionalizado (IDN). Etiquetas A de IDN tales como www*.xn--pthon-kva.org son todavía soportadas, pero x*.python.org ya no corresponde con xn--tda.python.org.

Distinto en la versión 3.5: Ahora se admite la coincidencia de direcciones IP cuando están presentes en el campo subjectAltName del certificado.

Distinto en la versión 3.7: La función ya no se utiliza para las conexiones TLS. La coincidencia de hostname es ahora realizada por OpenSSL.

Se permite el carácter comodín cuando es el carácter más a la izquierda y el único en ese segmento. Ya no se admiten comodines parciales como www*.example.com .

Obsoleto desde la versión 3.7.

ssl.cert_time_to_seconds(cert_time)

Retorna el tiempo en segundos desde la Época, dada la cadena de caracteres cert_time que representa la fecha notBefore o notAfter de un certificado en formato strptime "%b %d %H:%M:%S %Y %Z" (C locale).

He aquí un ejemplo:

>>> import ssl
>>> timestamp = ssl.cert_time_to_seconds("Jan  5 09:34:43 2018 GMT")
>>> timestamp  
1515144883
>>> from datetime import datetime
>>> print(datetime.utcfromtimestamp(timestamp))  
2018-01-05 09:34:43

Las fechas notBefore o notAfter deben utilizar GMT (RFC 5280).

Distinto en la versión 3.5: Interpreta la hora de entrada como una hora en UTC según lo especificado por la zona horaria “GMT” en la cadena de caracteres de entrada. Anteriormente se utilizaba la zona horaria local. Devuelve un número entero (sin fracciones de segundo en el formato de entrada)

ssl.get_server_certificate(addr, ssl_version=PROTOCOL_TLS, ca_certs=None)

Dada la dirección addr de un servidor protegido con SSL, como un par (hostname, port-number), obtiene el certificado del servidor, y lo retorna como una cadena de caracteres codificada en PEM. Si se especifica ssl_version, utiliza esta versión del protocolo SSL para intentar conectarse al servidor. Si se especifica ca_certs, debe ser un archivo que contenga una lista de certificados raíz, con el mismo formato que se utiliza para el mismo parámetro en SSLContext.wrap_socket(). La llamada intentará validar el certificado del servidor contra ese conjunto de certificados raíz, y fallará si el intento de validación falla.

Distinto en la versión 3.3: Esta función es ahora compatible IPv6.

Distinto en la versión 3.5: La ssl_version por defecto se cambia de PROTOCOL_SSLv3 a PROTOCOL_TLS para una máxima compatibilidad con los servidores modernos.

ssl.DER_cert_to_PEM_cert(DER_cert_bytes)

Dado un certificado como blob de bytes codificado en DER, devuelve una versión de cadena de caracteres codificada en PEM del mismo certificado.

ssl.PEM_cert_to_DER_cert(PEM_cert_string)

Dado un certificado como cadena de caracteres ASCII PEM, devuelve una secuencia de bytes codificada con DER para ese mismo certificado.

ssl.get_default_verify_paths()

Retorna una tupla con nombre con las rutas por defecto de cafile y capath de OpenSSL. Las rutas son las mismas que las usadas por SSLContext.set_default_verify_paths(). El valor de retorno es una named tuple DefaultVerifyPaths:

  • cafile - ruta resuelta a cafile o None si el archivo no existe,

  • capath - ruta resuelta a capath o None si el directorio no existe,

  • openssl_cafile_env - clave de entorno de OpenSSL que apunta a un cafile,

  • openssl_cafile - camino codificado de forma rígida a un cafile,

  • openssl_capath_env - clave de entorno de OpenSSL que apunta a un capath,

  • openssl_capath - camino codificado de forma rígida a un directorio capath

Disponibilidad: LibreSSL ignora las variables de entorno openssl_cafile_env y openssl_capath_env.

Nuevo en la versión 3.4.

ssl.enum_certificates(store_name)

Recupera los certificados del almacén de certificados del sistema de Windows. store_name puede ser uno de los siguientes: CA, ROOT o MY. Windows también puede proporcionar almacenes de certificados adicionales.

La función devuelve una lista de tuplas (cert_bytes, encoding_type, trust). El encoding_type especifica la codificación de cert_bytes. Es x509_asn para datos X.509 ASN.1 o pkcs_7_asn para datos PKCS#7 ASN.1. Trust especifica el propósito del certificado como un conjunto de OIDS o exactamente True si el certificado es de confianza para todos los propósitos.

Ejemplo:

>>> ssl.enum_certificates("CA")
[(b'data...', 'x509_asn', {'1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2'}),
 (b'data...', 'x509_asn', True)]

Disponibilidad: Windows.

Nuevo en la versión 3.4.

ssl.enum_crls(store_name)

Obtiene CRLs del almacén de certificados del sistema de Windows. store_name puede ser uno de los siguientes: CA, ROOT o MY. Windows también puede proporcionar almacenes de certificados adicionales.

La función devuelve una lista de tuplas (cert_bytes, encoding_type, trust). El encoding_type especifica la codificación de cert_bytes. Es x509_asn para datos X.509 ASN.1 o pkcs_7_asn para datos PKCS#7 ASN.1.

Disponibilidad: Windows.

Nuevo en la versión 3.4.

ssl.wrap_socket(sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_TLS, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None)

Toma una instancia sock de socket.socket, y devuelve una instancia de ssl.SSLSocket, un subtipo de socket.socket, que envuelve el socket de base en un contexto SSL. sock debe ser un socket SOCK_STREAM; otros tipos de socket no son compatibles.

Internamente, la función crea un SSLContext con un protocolo ssl_version y SSLContext.options establecido a cert_reqs. Si los parámetros keyfile, certfile, ca_certs o ciphers son establecidos, entonces los valores son pasados a SSLContext.load_cert_chain(), SSLContext.load_verify_locations(), y SSLContext.set_ciphers().

Los argumentos server_side, do_handshake_on_connect, y supress_ragged_eofs tienen el mismo significado que SSLContext.wrap_socket().

Obsoleto desde la versión 3.7: Desde Python 3.2 y 2.7.9, se recomienda usar SSLContext.wrap_socket() en lugar de wrap_socket(). La función de alto nivel tiene limitaciones y crea un socket cliente no seguro sin indicación de nombre de servidor ni hostname matching.

Constantes

Todas las constantes son ahora colecciones enum.IntEnum o enum.IntFlag.

Nuevo en la versión 3.6.

ssl.CERT_NONE

Valor posible para SSLContext.verify_mode, o el parámetro cert_reqs de wrap_socket(). A excepción de PROTOCOL_TLS_CLIENT, es el modo por defecto. Con sockets del lado del cliente, se acepta casi cualquier certificado. Errores de validación, como certificado no confiable o caducado, son ignorados y no abortan el handshake TLS/SSL.

En modo servidor, no se solicita ningún certificado al cliente, por lo que el cliente no envía ninguno para la autenticación del certificado del cliente.

Vea la discusión sobre Consideraciones de seguridad más abajo.

ssl.CERT_OPTIONAL

Valor posible para SSLContext.verify_mode, o el parámetro cert_reqs de wrap_socket(). En modo cliente, CERT_OPTIONAL tiene el mismo significado que CERT_REQUIRED. Se recomienda usar en su lugar CERT_REQUIRED para sockets del lado del cliente.

En el modo servidor, se envía una solicitud de certificado de cliente al cliente. El cliente puede ignorar la solicitud o enviar un certificado para realizar la autenticación de certificado de cliente TLS. Si el cliente opta por enviar un certificado, éste se verifica. Cualquier error de verificación aborta inmediatamente el handshake TLS.

El uso de esta configuración requiere que se pase un conjunto válido de certificados de CA, ya sea a SSLContext.load_verify_locations() o como valor del parámetro ca_certs de wrap_socket().

ssl.CERT_REQUIRED

Valor posible para SSLContext.verify_mode, o el parámetro cert_reqs de wrap_socket(). En este modo, se requieren certificados del otro lado de la conexión del socket; se lanzará un SSLError si no se proporciona ningún certificado, o si su validación falla. Este modo no es suficiente para verificar un certificado en modo cliente, ya que no coincide con los hostnames. check_hostname debe estar activado también para verificar la autenticidad de un certificado. PROTOCOL_TLS_CLIENT utiliza CERT_REQUIRED y activa check_hostname por defecto.

Con socket servidor, este modo proporciona una autenticación obligatoria de certificado de cliente TLS. Se envía una solicitud de certificado de cliente al cliente y el cliente debe proporcionar un certificado válido y de confianza.

El uso de esta configuración requiere que se pase un conjunto válido de certificados de CA, ya sea a SSLContext.load_verify_locations() o como valor del parámetro ca_certs de wrap_socket().

class ssl.VerifyMode

Colección enum.IntEnum de constantes CERT_*.

Nuevo en la versión 3.6.

ssl.VERIFY_DEFAULT

Valor posible para SSLContext.verify_flags. En este modo, las listas de revocación de certificado (CRLs) no son verificadas. Por defecto OpenSSL no requiere ni verifica CRLs.

Nuevo en la versión 3.4.

ssl.VERIFY_CRL_CHECK_LEAF

Valor posible para SSLContext.verify_flags. En este modo, sólo el certificado de pares es verificado pero ninguno de los certificados CA intermedios. El modo requiere una CRL válida que esté firmada por el emisor del certificado de pares (su CA antecesora directa). Si no se ha cargado una CRL adecuada con SSLContext.load_verify_locations, la validación fallará.

Nuevo en la versión 3.4.

ssl.VERIFY_CRL_CHECK_CHAIN

Valor posible para SSLContext.verify_flags. En este modo, las CRLs de todos los certificados en la cadena de certificado de pares son verificadas.

Nuevo en la versión 3.4.

ssl.VERIFY_X509_STRICT

Valor posible para SSLContext.verify_flags para desactivar soluciones alternativas para certificados X.509 rotos.

Nuevo en la versión 3.4.

ssl.VERIFY_X509_TRUSTED_FIRST

Valor posible para SSLContext.verify_flags. Indica a OpenSSL de preferir certificados de confianza al construir la cadena de confianza para validar un certificado. Esta opción está activada por defecto.

Nuevo en la versión 3.4.4.

class ssl.VerifyFlags

Colección enum.IntFlag de constantes VERIFY_*.

Nuevo en la versión 3.6.

ssl.PROTOCOL_TLS

Selecciona la versión mas alta del protocolo soportada tanto por el cliente como por el servidor. A pesar de su nombre, esta opción puede seleccionar ambos protocolos «SSL» y «TLS».

Nuevo en la versión 3.6.

ssl.PROTOCOL_TLS_CLIENT

Negocia automáticamente la versión más alta del protocolo como PROTOCOL_TLS, pero sólo soporta conexiones SSLSocket del lado del cliente. El protocolo activa CERT_REQUIRED y check_hostname por defecto.

Nuevo en la versión 3.6.

ssl.PROTOCOL_TLS_SERVER

Negocia automáticamente la versión más alta del protocolo como PROTOCOL_TLS, pero sólo soporta conexiones SSLSocket del lado del servidor.

Nuevo en la versión 3.6.

ssl.PROTOCOL_SSLv23

Alias para PROTOCOL_TLS.

Obsoleto desde la versión 3.6: Utilice en su lugar PROTOCOL_TLS.

ssl.PROTOCOL_SSLv2

Selecciona la versión 2 de SSL como protocolo de cifrado del canal.

Este protocolo no está disponible si OpenSSL fue compilada con la opción OPENSSL_NO_SSL2.

Advertencia

La versión 2 de SSL es insegura. Su uso es muy desaconsejado.

Obsoleto desde la versión 3.6: OpenSSL a eliminado el soporte para SSLv2.

ssl.PROTOCOL_SSLv3

Selecciona la versión 3 de SSL como protocolo de cifrado del canal.

Este protocolo no está disponible si OpenSSL fue compilada con la opción OPENSSL_NO_SSLv3.

Advertencia

La versión 3 de SSL es insegura. Su uso es muy desaconsejado.

Obsoleto desde la versión 3.6: OpenSSL a dejado obsoletas todos los protocolos de versiones específicas. Utilice en su lugar el protocolo por defecto PROTOCOL_TLS con opciones como OP_NO_SSLv3.

ssl.PROTOCOL_TLSv1

Selecciona la versión 1.0 de TLS como protocolo de cifrado del canal.

Obsoleto desde la versión 3.6: OpenSSL a dejado obsoletas todos los protocolos de versiones específicas. Utilice en su lugar el protocolo por defecto PROTOCOL_TLS con opciones como OP_NO_SSLv3.

ssl.PROTOCOL_TLSv1_1

Selecciona la versión 1.1 de TLS como protocolo de cifrado del canal. Disponible sólo con openssl en versión 1.0.1+.

Nuevo en la versión 3.4.

Obsoleto desde la versión 3.6: OpenSSL a dejado obsoletas todos los protocolos de versiones específicas. Utilice en su lugar el protocolo por defecto PROTOCOL_TLS con opciones como OP_NO_SSLv3.

ssl.PROTOCOL_TLSv1_2

Selecciona la versión 1.2 de TLS como protocolo de cifrado del canal. Esta es la versión mas moderna, y probablemente la mejor alternativa para máxima protección, si ambos lados pueden utilizarla. Disponible sólo con openssl en versión 1.0.1+.

Nuevo en la versión 3.4.

Obsoleto desde la versión 3.6: OpenSSL a dejado obsoletas todos los protocolos de versiones específicas. Utilice en su lugar el protocolo por defecto PROTOCOL_TLS con opciones como OP_NO_SSLv3.

ssl.OP_ALL

Activa soluciones alternativas para varios errores presentes en otras implementaciones SSL. Esta opción esta activada por defecto. No necesariamente activa las mismas opciones como la constante SSL_OP_ALL de OpenSSL.

Nuevo en la versión 3.2.

ssl.OP_NO_SSLv2

Evita una conexión SSLv2. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan SSLv2 como versión del protocolo.

Nuevo en la versión 3.2.

Obsoleto desde la versión 3.6: SSLv2 es obsoleto

ssl.OP_NO_SSLv3

Evita una conexión SSLv3. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan SSLv3 como versión del protocolo.

Nuevo en la versión 3.2.

Obsoleto desde la versión 3.6: SSLv3 es obsoleto

ssl.OP_NO_TLSv1

Evita una conexión TLSv1. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan TLSv1 como versión del protocolo.

Nuevo en la versión 3.2.

Obsoleto desde la versión 3.7: Esta opción es obsoleta desde OpenSSL 1.1.0, utilice en su lugar los nuevos SSLContext.minimum_version y SSLContext.maximum_version.

ssl.OP_NO_TLSv1_1

Evita una conexión TLSv1.1. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan TLSv1.1 como versión del protocolo. Disponible sólo con openssl en versión 1.0.1+.

Nuevo en la versión 3.4.

Obsoleto desde la versión 3.7: Esta opción es obsoleta desde OpenSSL 1.1.0.

ssl.OP_NO_TLSv1_2

Evita una conexión TLSv1.2. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan TLSv1.2 como versión del protocolo. Disponible sólo con openssl en versión 1.0.1+.

Nuevo en la versión 3.4.

Obsoleto desde la versión 3.7: Esta opción es obsoleta desde OpenSSL 1.1.0.

ssl.OP_NO_TLSv1_3

Evita una conexión TLSv1.3. Esta opción sólo es aplicable junto con PROTOCOL_TLS. Evita que los pares elijan TLSv1.3 como versión del protocolo. TLS 1.3 está disponible con OpenSSL 1.1.1 o superior. Cuando Python es compilado contra una versión mas antigua de OpenSSL, la opción vale 0 por defecto.

Nuevo en la versión 3.7.

Obsoleto desde la versión 3.7: Esta opción es obsoleta desde OpenSSL 1.1.0. Ha sido agregada a 2.7.15, 3.6.3 y 3.7.0 por retro-compatibilidad con OpenSSL 1.0.2.

ssl.OP_NO_RENEGOTIATION

Desactiva toda re-negociación en TLSv1.2 y anteriores. No envía mensajes HelloRequest e ignora solicitudes de re-negociación vía ClientHello.

Esta opción sólo está disponible con OpenSSL 1.1.0h y posteriores.

Nuevo en la versión 3.7.

ssl.OP_CIPHER_SERVER_PREFERENCE

Utiliza la preferencia de ordenación de cifrado del servidor, en lugar de la del cliente. Esta opción no tiene efecto en los sockets del cliente ni en los sockets del servidor SSLv2.

Nuevo en la versión 3.3.

ssl.OP_SINGLE_DH_USE

Evita la reutilización de la misma clave DH para distintas sesiones SSL. Esto mejora el secreto hacia adelante pero requiere más recursos computacionales. Esta opción sólo se aplica a los sockets del servidor.

Nuevo en la versión 3.3.

ssl.OP_SINGLE_ECDH_USE

Evita la reutilización de la misma clave ECDH para distintas sesiones SSL. Esto mejora el secreto hacia adelante pero requiere más recursos computacionales. Esta opción sólo se aplica a los sockets del servidor.

Nuevo en la versión 3.3.

ssl.OP_ENABLE_MIDDLEBOX_COMPAT

Enviar mensajes Change Cipher Spec (CCS) ficticios en el handshake de TLS 1.3 para que una conexión TLS 1.3 se parezca más a una conexión TLS 1.2.

Esta opción sólo está disponible con OpenSSL 1.1.1 y posteriores.

Nuevo en la versión 3.8.

ssl.OP_NO_COMPRESSION

Desactivar la compresión en el canal SSL. Esto es útil si el protocolo de la aplicación soporta su propio esquema de compresión.

Esta opción sólo está disponible con OpenSSL 1.0.0 y posteriores.

Nuevo en la versión 3.3.

class ssl.Options

Colección enum.IntFlag de constantes OP_*.

ssl.OP_NO_TICKET

Evita que el lado del cliente solicite un ticket de sesión.

Nuevo en la versión 3.6.

ssl.OP_IGNORE_UNEXPECTED_EOF

Ignore unexpected shutdown of TLS connections.

This option is only available with OpenSSL 3.0.0 and later.

Nuevo en la versión 3.10.

ssl.HAS_ALPN

Si la biblioteca OpenSSL tiene soporte incorporado para la extensión TLS Application-Layer Protocol Negotiation como se describe en RFC 7301.

Nuevo en la versión 3.5.

ssl.HAS_NEVER_CHECK_COMMON_NAME

Si la biblioteca OpenSSL tiene soporte incorporado para no comprobar el nombre común del sujeto y SSLContext.hostname_checks_common_name es modificable.

Nuevo en la versión 3.7.

ssl.HAS_ECDH

Si la biblioteca OpenSSL tiene soporte incorporado para el intercambio de claves Diffie-Hellman basado en Elliptic Curve. Esto debería ser cierto a menos que la función haya sido desactivada explícitamente por el distribuidor.

Nuevo en la versión 3.3.

ssl.HAS_SNI

Si la biblioteca OpenSSL tiene soporte incorporado para la extensión Server Name Indication (como se define en RFC 6066).

Nuevo en la versión 3.2.

ssl.HAS_NPN

Si la biblioteca OpenSSL tiene soporte incorporado para Next Protocol Negotiation como se describe en Application Layer Protocol Negotiation. Cuando es verdadero, puede utilizar el método SSLContext.set_npn_protocols() para anunciar los protocolos que desea soportar.

Nuevo en la versión 3.3.

ssl.HAS_SSLv2

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo SSL 2.0.

Nuevo en la versión 3.7.

ssl.HAS_SSLv3

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo SSL 3.0.

Nuevo en la versión 3.7.

ssl.HAS_TLSv1

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo TLS 1.0.

Nuevo en la versión 3.7.

ssl.HAS_TLSv1_1

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo TLS 1.1.

Nuevo en la versión 3.7.

ssl.HAS_TLSv1_2

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo TLS 1.2.

Nuevo en la versión 3.7.

ssl.HAS_TLSv1_3

Si la biblioteca OpenSSL tiene soporte incorporado para el protocolo TLS 1.3.

Nuevo en la versión 3.7.

ssl.CHANNEL_BINDING_TYPES

Lista de tipos de enlace de canales TLS admitidos. Las cadenas de caracteres en esta lista pueden ser usadas como argumentos para SSLSocket.get_channel_binding().

Nuevo en la versión 3.3.

ssl.OPENSSL_VERSION

La cadena de versión de la biblioteca OpenSSL cargada por el intérprete:

>>> ssl.OPENSSL_VERSION
'OpenSSL 1.0.2k  26 Jan 2017'

Nuevo en la versión 3.2.

ssl.OPENSSL_VERSION_INFO

Una tupla de cinco números enteros representando la información de versión de la biblioteca OpenSSL:

>>> ssl.OPENSSL_VERSION_INFO
(1, 0, 2, 11, 15)

Nuevo en la versión 3.2.

ssl.OPENSSL_VERSION_NUMBER

El número de versión en bruto de la biblioteca OpenSSL, como un único número entero:

>>> ssl.OPENSSL_VERSION_NUMBER
268443839
>>> hex(ssl.OPENSSL_VERSION_NUMBER)
'0x100020bf'

Nuevo en la versión 3.2.

ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE
ssl.ALERT_DESCRIPTION_INTERNAL_ERROR
ALERT_DESCRIPTION_*

Descripciones de alertas de RFC 5246 y otras. El IANA TLS Alert Registry contiene esta lista y las referencias a las RFC donde se define su significado.

Se utiliza como valor de retorno de la función callback en SSLContext.set_servername_callback().

Nuevo en la versión 3.4.

class ssl.AlertDescription

Colección enum.IntEnum de constantes ALERT_DESCRIPTION_*.

Nuevo en la versión 3.6.

Purpose.SERVER_AUTH

Opción para create_default_context() y SSLContext.load_default_certs(). Este valor indica que el contexto puede utilizarse para autenticar servidores web (por lo tanto, se utilizará para crear sockets del lado del cliente).

Nuevo en la versión 3.4.

Purpose.CLIENT_AUTH

Opción para create_default_context() y SSLContext.load_default_certs(). Este valor indica que el contexto puede utilizarse para autenticar clientes web (por lo tanto, se utilizará para crear sockets del lado del servidor).

Nuevo en la versión 3.4.

class ssl.SSLErrorNumber

Colección enum.IntEnum de constantes SSL_ERROR_*.

Nuevo en la versión 3.6.

class ssl.TLSVersion

Colección enum.IntEnum de versiones SSL y TLS para SSLContext.maximum_version y SSLContext.minimum_version.

Nuevo en la versión 3.7.

TLSVersion.MINIMUM_SUPPORTED
TLSVersion.MAXIMUM_SUPPORTED

La mínima o máxima versión soportada de SSL o TLS. Estas son constantes mágicas. Sus valores no reflejan la mas baja o mas alta versión TLS/SSL disponible.

TLSVersion.SSLv3
TLSVersion.TLSv1
TLSVersion.TLSv1_1
TLSVersion.TLSv1_2
TLSVersion.TLSv1_3

SSL 3.0 a TLS 1.3.

Sockets SSL

class ssl.SSLSocket(socket.socket)

Los sockets SSL proporcionan los siguientes métodos de Objetos Socket:

Sin embargo, dado que el protocolo SSL (y TLS) tiene su propia estructura encima de TCP, la abstracción de los sockets SSL puede, en ciertos aspectos, divergir de la especificación de los sockets normales a nivel de SO. Ver especialmente las notas sobre sockets no bloqueantes.

Instancias de SSLSocket deben ser creadas usando el método SSLContext.wrap_socket().

Distinto en la versión 3.5: El método sendfile() ha sido agregado.

Distinto en la versión 3.5: El método shutdown() no reinicia el tiempo de espera del socket cada vez que se reciben o envían bytes. El tiempo de espera del socket es ahora la máxima duración del cierre.

Obsoleto desde la versión 3.6: Crear una instancia de SSLSocket directamente es obsoleto, utilice SSLContext.wrap_socket() para envolver un socket.

Distinto en la versión 3.7: Las instancias de SSLSocket deben crearse con wrap_socket(). En versiones anteriores, era posible crear instancias directamente. Esto nunca fue documentado ni soportado oficialmente.

Los sockets SSL tienen también los siguientes métodos y atributos adicionales:

SSLSocket.read(len=1024, buffer=None)

Lee hasta len bytes de datos del socket SSL y retorna el resultado como una instancia bytes. Si buffer es especificado, entonces se lee hacia el búfer en su lugar, y retorna el número de bytes leídos.

Lanza SSLWantReadError o SSLWantWriteError si el socket es no-bloqueante y la lectura se bloquearía.

Como en cualquier momento es posible una re-negociación, una llamada a read() también puede provocar operaciones de escritura.

Distinto en la versión 3.5: El tiempo de espera del socket ya no se reinicia cada vez que se reciben o envían bytes. El tiempo de espera del socket es ahora la duración total máxima para leer hasta len bytes.

Obsoleto desde la versión 3.6: Utilice recv() en lugar de read().

SSLSocket.write(buf)

Escribe buf en el socket SSL y retorna el número de bytes escritos. El argumento buf debe ser un objeto que soporte la interfaz búfer.

Lanza SSLWantReadError o SSLWantWriteError si el socket es no-bloqueante y la escritura se bloquearía.

Como en cualquier momento es posible una re-negociación, una llamada a write() también puede provocar operaciones de lectura.

Distinto en la versión 3.5: El tiempo de espera del socket ya no se reinicia cada vez que se reciben o envían bytes. El tiempo de espera del socket es ahora la duración total máxima para escribir buf.

Obsoleto desde la versión 3.6: Utilice send() en lugar de write().

Nota

Los métodos read() y write() son los métodos de bajo nivel que leen y escriben datos no cifrados a nivel de aplicación y los descifran/cifran a datos cifrados a nivel de cable. Estos métodos requieren una conexión SSL activa, es decir, que se haya completado el handshake y no se haya llamado a SSLSocket.unwrap().

Normalmente se deberían utilizar los métodos de la API de sockets como recv() y send() en lugar de estos métodos.

SSLSocket.do_handshake()

Realiza el handshake de configuración SSL.

Distinto en la versión 3.4: El método handshake también realiza match_hostname() cuando el atributo check_hostname del context del socket es verdadero.

Distinto en la versión 3.5: El tiempo de espera del socket ya no se reinicia cada vez que se reciben o envían bytes. El tiempo de espera del socket es ahora la duración total máxima del handshake.

Distinto en la versión 3.7: El hostname o la dirección IP son comparados por OpenSSL durante el handshake. La función match_hostname() ya no se utiliza. En caso de que OpenSSL rechace un hostname o dirección IP, el handshake se aborta antes de tiempo y se envía un mensaje de alerta TLS al peer.

SSLSocket.getpeercert(binary_form=False)

Si no hay un certificado para el peer en el otro extremo de la conexión, devuelve None. Si el handshake SSL no se ha realizado todavía, lanza ValueError.

Si el parámetro binary_form es False, y se ha recibido un certificado del peer, este método devuelve una instancia dict. Si el certificado no fue validado, el dict está vacío. Si el certificado fue validado, devuelve un dict con varias claves, entre ellas subject (la entidad para la que se emitió el certificado) y issuer (la entidad que emite el certificado). Si un certificado contiene una instancia de la extensión Subject Alternative Name (véase RFC 3280), también habrá una clave subjectAltName en el diccionario.

Los campos subject y issuer son tuplas que contienen la secuencia de nombres distinguidos relativos (RDNs) indicados en la estructura de datos del certificado para los campos respectivos, y cada RDN es una secuencia de pares nombre-valor. Este es un ejemplo del mundo real:

{'issuer': ((('countryName', 'IL'),),
            (('organizationName', 'StartCom Ltd.'),),
            (('organizationalUnitName',
              'Secure Digital Certificate Signing'),),
            (('commonName',
              'StartCom Class 2 Primary Intermediate Server CA'),)),
 'notAfter': 'Nov 22 08:15:19 2013 GMT',
 'notBefore': 'Nov 21 03:09:52 2011 GMT',
 'serialNumber': '95F0',
 'subject': ((('description', '571208-SLe257oHY9fVQ07Z'),),
             (('countryName', 'US'),),
             (('stateOrProvinceName', 'California'),),
             (('localityName', 'San Francisco'),),
             (('organizationName', 'Electronic Frontier Foundation, Inc.'),),
             (('commonName', '*.eff.org'),),
             (('emailAddress', 'hostmaster@eff.org'),)),
 'subjectAltName': (('DNS', '*.eff.org'), ('DNS', 'eff.org')),
 'version': 3}

Nota

Para validar un certificado para un servicio concreto, puede utilizar la función match_hostname().

Si el parámetro binary_form es True, y se proporcionó un certificado, este método devuelve la forma codificada en DER del certificado completo como una secuencia de bytes, o None si el par no proporcionó un certificado. El hecho de que el par proporcione un certificado depende del rol del socket SSL:

  • para un socket SSL cliente, el servidor siempre proporcionará un certificado, independientemente de si se requirió la validación;

  • para un socket SSL servidor, el cliente sólo proporcionará un certificado cuando lo solicite el servidor; por lo tanto getpeercert() devolverá None si ha utilizado CERT_NONE (en lugar de CERT_OPTIONAL o CERT REQUIRED).

Distinto en la versión 3.2: El diccionario devuelto incluye elementos adicionales tales como issuer y notBefore.

Distinto en la versión 3.4: ValueError se lanza cuando no se realiza el handshake. El diccionario retornado incluye elementos de extensión X509v3 adicionales como crlDistributionPoints, caIssuers y OCSP URIs.

Distinto en la versión 3.9: Las cadenas de direcciones IPv6 ya no tienen una nueva línea al final.

SSLSocket.cipher()

Retorna una tupla de tres valores que contiene el nombre del cifrado que se está utilizando, la versión del protocolo SSL que define su uso y el número de bits secretos que se están utilizando. Si no se ha establecido ninguna conexión, retorna None.

SSLSocket.shared_ciphers()

Retorna la lista de cifrados compartidos por el cliente durante el handshake. Cada entrada de la lista devuelta es una tupla de tres valores que contiene el nombre del cifrado, la versión del protocolo SSL que define su uso y el número de bits secretos que utiliza el cifrado. shared_ciphers`() retorna None si no se ha establecido ninguna conexión o el socket es un socket cliente.

Nuevo en la versión 3.5.

SSLSocket.compression()

Retorna el algoritmo de compresión utilizado como una cadena de caracteres, o None si la conexión no está comprimida.

Si el protocolo de nivel superior soporta su propio mecanismo de compresión, puede utilizar OP_NO_COMPRESSION para desactivar la compresión a nivel de SSL.

Nuevo en la versión 3.3.

SSLSocket.get_channel_binding(cb_type="tls-unique")

Obtiene los datos de enlace del canal para la conexión actual, como un objeto bytes. Retorna None si no está conectado o no se ha completado el handshake.

El parámetro cb_type permite seleccionar el tipo de enlace de canal deseado. Los tipos de enlace de canal válidos se enumeran en la lista CHANNEL_BINDING_TYPES. Actualmente, sólo se admite la vinculación de canal “tls-unique”, definida por RFC 5929. ValueError se lanzará si se solicita un tipo de vinculación de canal no admitido.

Nuevo en la versión 3.3.

SSLSocket.selected_alpn_protocol()

Retorna el protocolo que fue seleccionado durante el handshake TLS. Si no se ha llamado a SSLContext.set_alpn_protocols(), si la otra parte no soporta ALPN, si este socket no soporta ninguno de los protocolos propuestos por el cliente, o si el handshake no ha ocurrido todavía, se devuelve None.

Nuevo en la versión 3.5.

SSLSocket.selected_npn_protocol()

Devuelve el protocolo de nivel superior que se seleccionó durante el handshake TLS/SSL. Si no se llamó a SSLContext.set_npn_protocols(), o si la otra parte no soporta NPN, o si el handshake aún no ha ocurrido, esto devolverá None.

Nuevo en la versión 3.3.

SSLSocket.unwrap()

Realiza el handshake de cierre de SSL, que elimina la capa TLS del socket subyacente, y devuelve el objeto socket subyacente. Esto puede utilizarse para pasar de una operación encriptada sobre una conexión a una sin encriptar. El socket devuelto debe utilizarse siempre para la comunicación posterior con el otro lado de la conexión, en lugar del socket original.

SSLSocket.verify_client_post_handshake()

Solicita la autenticación post-handshake (PHA) de un cliente TLS 1.3. PHA sólo puede iniciarse para una conexión TLS 1.3 desde un socket del lado del servidor, después del handshake TLS inicial y con PHA habilitado en ambos lados, ver SSLContext.post_handshake_auth.

El método no realiza un intercambio de certificados inmediatamente. El lado del servidor envía una CertificateRequest durante el siguiente evento de escritura y espera que el cliente responda con un certificado en el siguiente evento de lectura.

Si alguna precondición no se cumple (por ejemplo, no es TLS 1.3, PHA no está habilitado), se genera un SSLError.

Nota

Sólo está disponible con OpenSSL 1.1.1 y TLS 1.3 habilitados. Sin el soporte de TLS 1.3, el método lanza NotImplementedError.

Nuevo en la versión 3.8.

SSLSocket.version()

Return the actual SSL protocol version negotiated by the connection as a string, or None if no secure connection is established. As of this writing, possible return values include "SSLv2", "SSLv3", "TLSv1", "TLSv1.1" and "TLSv1.2". Recent OpenSSL versions may define more return values.

Nuevo en la versión 3.5.

SSLSocket.pending()

Retorna el número de bytes ya descifrados disponibles para leer, pendientes de la conexión.

SSLSocket.context

El objeto SSLContext al que está vinculado este socket SSL. Si el socket SSL fue creado usando la función obsoleta wrap_socket() (en lugar de SSLContext.wrap_socket()), este es un objeto de contexto personalizado creado para este socket SSL.

Nuevo en la versión 3.2.

SSLSocket.server_side

Un booleano que es True para los sockets del lado del servidor y False para los sockets del lado del cliente.

Nuevo en la versión 3.2.

SSLSocket.server_hostname

Hostname del servidor: tipo str, o None para el socket del lado del servidor o si el hostname no fue especificado en el constructor.

Nuevo en la versión 3.2.

Distinto en la versión 3.7: El atributo es ahora siempre texto ASCII. Cuando server_hostname es un nombre de dominio internacionalizado (IDN), este atributo almacena ahora la forma de etiqueta A ("xn--pythn-mua.org"), en lugar de la forma de etiqueta U ("pythön.org").

SSLSocket.session

La SSLSession para esta conexión SSL. La sesión está disponible para los sockets del lado del cliente y del servidor después de que se haya realizado el handshake TLS. Para los sockets del cliente la sesión puede ser establecida antes de que do_handshake() haya sido llamado para reutilizar una sesión.

Nuevo en la versión 3.6.

SSLSocket.session_reused

Nuevo en la versión 3.6.

Contextos SSL

Nuevo en la versión 3.2.

Un contexto SSL contiene varios datos más duraderos que las conexiones SSL individuales, como opciones de configuración SSL, certificado(s) y clave(s) privada(s). También gestiona un cache de sesiones SSL para sockets del lado del servidor, para acelerar conexiones repetidas de los mismos clientes.

class ssl.SSLContext(protocol=PROTOCOL_TLS)

Crea un nuevo contexto SSL. Puede pasar protocolo que debe ser una de las constantes PROTOCOL_* definidas en este módulo. El parámetro especifica la versión del protocolo SSL a utilizar. Típicamente, el servidor elige una versión particular del protocolo, y el cliente debe adaptarse a la elección del servidor. La mayoría de las versiones no son interoperables con las demás. Si no se especifica, el valor por defecto es PROTOCOL_TLS; proporciona la mayor compatibilidad con otras versiones.

Esta es una tabla que muestra qué versiones de un cliente (en la parte inferior) pueden conectarse a qué versiones de un servidor (en la parte superior):

cliente / servidor

SSLv2

SSLv3

TLS 3

TLSv1

TLSv1.1

TLSv1.2

SSLv2

si

no

no 1

no

no

no

SSLv3

no

si

no 2

no

no

no

TLS (SSLv23) 3

no 1

no 2

si

si

si

si

TLSv1

no

no

si

si

no

no

TLSv1.1

no

no

si

no

si

no

TLSv1.2

no

no

si

no

no

si

Notas a pie de página

1(1,2)

SSLContext desactiva SSLv2 con OP_NO_SSLv2 por defecto.

2(1,2)

SSLContext desactiva SSLv3 con OP_NO_SSLv3 por defecto.

3(1,2)

El protocolo TLS 1.3 estará disponible con PROTOCOL_TLS en OpenSSL >= 1.1.1. No existe una constante PROTOCOL dedicada sólo a TLS 1.3.

Ver también

create_default_context() permite al módulo ssl elegir la configuración de seguridad para un propósito determinado.

Distinto en la versión 3.6: El contexto se crea con valores seguros por defecto. Las opciones OP_NO_COMPRESSION, OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE, OP_SINGLE_ECDH_USE, OP_NO_SSLv2 (excepto para PROTOCOL_SSLv2), y OP_NO_SSLv3 (excepto para PROTOCOL_SSLv3) están establecidas por defecto. La lista inicial de conjuntos de cifrado sólo contiene cifrados HIGH, ningún cifrado NULL y ningún cifrado MD5 (excepto para PROTOCOL_SSLv2).

Los objetos SSLContext tienen los siguientes métodos y atributos:

SSLContext.cert_store_stats()

Obtiene estadísticas sobre las cantidades de certificados X.509 cargados, la cantidad de certificados X.509 marcados como certificados CA y las listas de revocación de certificados como diccionario.

Ejemplo para un contexto con un certificado CA y otro certificado:

>>> context.cert_store_stats()
{'crl': 0, 'x509_ca': 1, 'x509': 2}

Nuevo en la versión 3.4.

SSLContext.load_cert_chain(certfile, keyfile=None, password=None)

Load a private key and the corresponding certificate. The certfile string must be the path to a single file in PEM format containing the certificate as well as any number of CA certificates needed to establish the certificate’s authenticity. The keyfile string, if present, must point to a file containing the private key. Otherwise the private key will be taken from certfile as well. See the discussion of Certificados for more information on how the certificate is stored in the certfile.

El argumento password puede ser una función a la que llamar para obtener la contraseña para descifrar la clave privada. Sólo se llamará si la clave privada está encriptada y se necesita una contraseña. Se llamará sin argumentos, y deberá devolver una cadena de caracteres, bytes o bytearray. Si el valor devuelto es una cadena de caracteres, se codificará como UTF-8 antes de utilizarlo para descifrar la clave. Alternativamente, se puede suministrar un valor de cadena de caracteres, bytes o bytearray directamente como argumento password. Se ignorará si la clave privada no está cifrada y no se necesita una contraseña.

Si el argumento password no es especificado y una contraseña es requerida, el mecanismo de solicitud de contraseña incorporado de OpenSSL se usará para solicitarle una contraseña al usuario de forma interactiva.

Un SSLError es lanzado si la clave privada no coincide con el certificado.

Distinto en la versión 3.3: Nuevo argumento opcional password.

SSLContext.load_default_certs(purpose=Purpose.SERVER_AUTH)

Load a set of default «certification authority» (CA) certificates from default locations. On Windows it loads CA certs from the CA and ROOT system stores. On all systems it calls SSLContext.set_default_verify_paths(). In the future the method may load CA certificates from other locations, too.

La opción purpose especifica qué tipo de certificados CA se cargan. La configuración por defecto Purpose.SERVER_AUTH carga certificados, que están marcados y son de confianza para la autenticación del servidor web TLS (sockets del lado del cliente). Purpose.CLIENT_AUTH carga certificados CA para la verificación de certificados de cliente en el lado del servidor.

Nuevo en la versión 3.4.

SSLContext.load_verify_locations(cafile=None, capath=None, cadata=None)

Carga un conjunto de certificados de «autoridad de certificación» (CA) usados para validar certificados de otros pares cuando verify_mode es distinto de CERT_NONE. Debe especificarse al menos uno de cafile o capath.

Este método puede cargar también listas de revocación de certificados (CRLs) en formato PEM o DER. Para poder usar CRLs, SSLContext.verify_flags debe ser configurado correctamente.

La cadena de caracteres cafile, si está presente, es la ruta a un archivo de certificados CA concatenados en formato PEM. Vea la discusión de Certificados para más información acerca de como organizar los certificados en este archivo.

La cadena de caracteres capath, si está presente, es la ruta a un directorio que contiene varios certificados CA en formato PEM, siguiendo la disposición específica de OpenSSL.

El objeto cadata, si está presente, es una cadena de caracteres ASCII de uno o más certificados codificados en PEM o un bytes-like object de certificados codificados en DER. Al igual que con capath, las líneas adicionales alrededor de los certificados codificados en PEM se ignoran, pero debe haber al menos un certificado.

Distinto en la versión 3.4: Nuevo argumento opcional cadata

SSLContext.get_ca_certs(binary_form=False)

Obtiene una lista de certificados de «autoridad de certificación» (CA) cargados. Si el parámetro binary_form es False cada entrada de la lista es un diccionario como la salida de SSLSocket.getpeercert(). En caso contrario, el método devuelve una lista de certificados codificados con DER. La lista devuelta no contiene certificados de capath a menos que un certificado haya sido solicitado y cargado por una conexión SSL.

Nota

Los certificados de un directorio capath no se cargan a menos que se hayan utilizado al menos una vez.

Nuevo en la versión 3.4.

SSLContext.get_ciphers()

Obtiene una lista de cifrados habilitados. La lista está en orden de prioridad de cifrado. Véase SSLContext.set_ciphers().

Ejemplo:

>>> ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
>>> ctx.set_ciphers('ECDHE+AESGCM:!ECDSA')
>>> ctx.get_ciphers()  # OpenSSL 1.0.x
[{'alg_bits': 256,
  'description': 'ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  '
                 'Enc=AESGCM(256) Mac=AEAD',
  'id': 50380848,
  'name': 'ECDHE-RSA-AES256-GCM-SHA384',
  'protocol': 'TLSv1/SSLv3',
  'strength_bits': 256},
 {'alg_bits': 128,
  'description': 'ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  '
                 'Enc=AESGCM(128) Mac=AEAD',
  'id': 50380847,
  'name': 'ECDHE-RSA-AES128-GCM-SHA256',
  'protocol': 'TLSv1/SSLv3',
  'strength_bits': 128}]

En OpenSSL 1.1 y posterior el diccionario de cifrado contiene campos adicionales:

>>> ctx.get_ciphers()  # OpenSSL 1.1+
[{'aead': True,
  'alg_bits': 256,
  'auth': 'auth-rsa',
  'description': 'ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  '
                 'Enc=AESGCM(256) Mac=AEAD',
  'digest': None,
  'id': 50380848,
  'kea': 'kx-ecdhe',
  'name': 'ECDHE-RSA-AES256-GCM-SHA384',
  'protocol': 'TLSv1.2',
  'strength_bits': 256,
  'symmetric': 'aes-256-gcm'},
 {'aead': True,
  'alg_bits': 128,
  'auth': 'auth-rsa',
  'description': 'ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  '
                 'Enc=AESGCM(128) Mac=AEAD',
  'digest': None,
  'id': 50380847,
  'kea': 'kx-ecdhe',
  'name': 'ECDHE-RSA-AES128-GCM-SHA256',
  'protocol': 'TLSv1.2',
  'strength_bits': 128,
  'symmetric': 'aes-128-gcm'}]

Availability: OpenSSL 1.0.2+.

Nuevo en la versión 3.6.

SSLContext.set_default_verify_paths()

Carga un conjunto de certificados de «autoridad de certificación» (CA) por defecto desde una ruta del sistema de archivos definida al construir la biblioteca OpenSSL. Desafortunadamente, no hay una manera fácil de saber si este método tiene éxito: no se devuelve ningún error si no se encuentran certificados. Sin embargo, cuando la biblioteca OpenSSL se proporciona como parte del sistema operativo, es probable que esté configurada correctamente.

SSLContext.set_ciphers(ciphers)

Establece los cifrados disponibles para los sockets creados con este contexto. Debe ser una cadena de caracteres con el formato de la lista de cifrado de OpenSSL. Si no se puede seleccionar ningún cifrado (porque las opciones en tiempo de compilación u otra configuración prohíben el uso de todos los cifrados especificados), se lanzará un SSLError.

Nota

cuando se conecta, el método SSLSocket.cipher() de los sockets SSL dará el cifrado actualmente seleccionado.

OpenSSL 1.1.1 tiene suites de cifrado TLS 1.3 habilitadas por defecto. Las suites no se pueden desactivar con set_ciphers().

SSLContext.set_alpn_protocols(protocols)

Especifica qué protocolos debe anunciar el socket durante el handshake SSL/TLS. Debe ser una lista de cadenas de caracteres ASCII, como ['http/1.1', 'spdy/2'], ordenadas por preferencia. La selección de un protocolo ocurrirá durante el handshake, y se desarrollará de acuerdo con RFC 7301. Después de un handshake exitoso, el método SSLSocket.selected_alpn_protocol() devolverá el protocolo acordado.

Este método lanzará NotImplementedError si HAS_ALPN es False.

OpenSSL 1.1.0 a 1.1.0e abortará el handshake y lanzará SSLError cuando ambos lados soporten ALPN pero no puedan acordar un protocolo. 1.1.0f+ se comporta como 1.0.2, SSLSocket.selected_alpn_protocol() devuelve None.

Nuevo en la versión 3.5.

SSLContext.set_npn_protocols(protocols)

Especifica qué protocolos debe anunciar el socket durante el handshake SSL/TLS. Debe ser una lista de cadenas, como ['http/1.1', 'spdy/2'], ordenadas por preferencia. La selección de un protocolo ocurrirá durante el handshake, y se desarrollará de acuerdo a la Negociación del Protocolo de la Capa de Aplicación. Después de un handshake exitoso, el método SSLSocket.selected_npn_protocol() devolverá el protocolo acordado.

Este método lanzará NotImplementedError si HAS_NPN es False.

Nuevo en la versión 3.3.

SSLContext.sni_callback

Registra una función callback que se llamará después de que el servidor SSL/TLS haya recibido el mensaje de diálogo TLS Client Hello cuando el cliente TLS especifique una indicación de nombre de servidor. El mecanismo de indicación de nombre de servidor se especifica en RFC 6066 sección 3 - Server Name Indication.

Sólo se puede establecer una función callback por SSLContext. Si sni_callback se establece como None, la función callback se desactiva. Si se llama a esta función una vez más, se desactivará la función callback registrada anteriormente.

La función callback será llamada con tres argumentos; el primero es el ssl.SSLSocket, el segundo es una cadena que representa el nombre del servidor con el que el cliente pretende comunicarse (o None si el TLS Client Hello no contiene un nombre de servidor) y el tercer argumento es el SSLContext original. El argumento del nombre del servidor es un texto. En el caso de los nombres de dominio internacionalizados, el nombre del servidor es un IDN etiqueta A ("xn--pythn-mua.org").

Un uso típico de esta función callback es cambiar el atributo SSLSocket.context de ssl.SSLSocket por un nuevo objeto de tipo SSLContext que representa una cadena de certificados que coincide con el nombre del servidor.

Due to the early negotiation phase of the TLS connection, only limited methods and attributes are usable like SSLSocket.selected_alpn_protocol() and SSLSocket.context. The SSLSocket.getpeercert(), SSLSocket.cipher() and SSLSocket.compression() methods require that the TLS connection has progressed beyond the TLS Client Hello and therefore will not return meaningful values nor can they be called safely.

La función sni_callback debe devolver None para permitir que la negociación TLS continúe. Si se requiere un fallo TLS, se puede devolver una constante ALERT_DESCRIPTION_*. Otros valores de retorno resultarán en un error fatal TLS con ALERT_DESCRIPTION_INTERNAL_ERROR.

Si se lanza una excepción desde la función sni_callback la conexión TLS terminará con un mensaje de alerta TLS fatal ALERT_DESCRIPTION_HANDSHAKE_FAILURE.

Este método lanzará NotImplementedError si la biblioteca OpenSSL tenía definido OPENSSL_NO_TLSEXT cuando se construyó.

Nuevo en la versión 3.7.

SSLContext.set_servername_callback(server_name_callback)

Se trata de una API heredada que se mantiene por compatibilidad con versiones anteriores. Cuando sea posible, debería utilizar sni_callback en su lugar. El server_name_callback dado es similar a sni_callback, excepto que cuando el nombre del servidor es un nombre de dominio internacionalizado codificado con IDN, el server_name_callback recibe una etiqueta U decodificada ("pythön.org").

Si hay un error de decodificación en el nombre del servidor, la conexión TLS terminará con un mensaje fatal de alerta TLS ALERT_DESCRIPTION_INTERNAL_ERROR al cliente.

Nuevo en la versión 3.4.

SSLContext.load_dh_params(dhfile)

Carga los parámetros de generación de claves para el intercambio de claves Diffie-Hellman (DH). El uso del intercambio de claves DH mejora el secreto hacia adelante a expensas de recursos computacionales (tanto en el servidor como en el cliente). El parámetro dhfile debe ser la ruta de un archivo que contenga los parámetros DH en formato PEM.

Esta configuración no se aplica a los sockets de los clientes. También puede utilizar la opción OP_SINGLE_DH_USE para mejorar aún más la seguridad.

Nuevo en la versión 3.3.

SSLContext.set_ecdh_curve(curve_name)

Establece el nombre de la curva para el intercambio de claves Diffie-Hellman basado en la curva elíptica (ECDH). ECDH es significativamente más rápido que el DH normal, aunque podría decirse que es igual de seguro. El parámetro curve_name debe ser una cadena que describa una curva elíptica conocida, por ejemplo prime256v1 para una curva ampliamente soportada.

Esta configuración no se aplica a los sockets de los clientes. También puede utilizar la opción OP_SINGLE_ECDH_USE para mejorar aún más la seguridad.

Este método no está disponible si HAS_ECDH es False.

Nuevo en la versión 3.3.

Ver también

SSL/TLS & Perfect Forward Secrecy

Vincent Bernat.

SSLContext.wrap_socket(sock, server_side=False, do_handshake_on_connect=True, suppress_ragged_eofs=True, server_hostname=None, session=None)

Envuelve un socket Python existente sock y devuelve una instancia de SSLContext.sslsocket_class (por defecto SSLSocket). El socket SSL devuelto está ligado al contexto, su configuración y certificados. sock debe ser un socket SOCK_STREAM; otros tipos de socket no son soportados.

El parámetro server_side es un booleano que identifica si se desea un comportamiento del lado del servidor o del lado del cliente en este socket.

Para los sockets del lado del cliente, la construcción del contexto es perezosa; si el socket subyacente no está conectado todavía, la construcción del contexto se realizará después de llamar a connect() en el socket. Para los sockets del lado del servidor, si el socket no tiene un par remoto, se asume que es un socket a la escucha, y la envoltura SSL del lado del servidor se realiza automáticamente en las conexiones del cliente aceptadas a través del método accept(). El método puede lanzar SSLError.

En las conexiones de cliente, el parámetro opcional server_hostname especifica el nombre del servicio al que nos estamos conectando. Esto permite que un único servidor aloje varios servicios basados en SSL con certificados distintos, de forma similar a los hosts virtuales HTTP. Al especificar server_hostname se producirá un ValueError si server_side es verdadero.

El parámetro do_handshake_on_connect especifica si se hace el handshake SSL automáticamente después de hacer un socket.connect(), o si el programa de aplicación lo llamará explícitamente, invocando el método SSLSocket.do_handshake(). Llamar explícitamente a SSLSocket.do_handshake() da al programa el control sobre el comportamiento de bloqueo de la E/S del socket involucrada en el handshake.

El parámetro suppress_ragged_eofs especifica cómo el método SSLSocket.recv() debe señalar los EOF inesperados desde el otro extremo de la conexión. Si se especifica como True (el valor por defecto), devuelve un EOF normal (un objeto bytes vacío) en respuesta a los errores EOF inesperados que se produzcan desde el socket subyacente; si False, lanzará las excepciones al llamador.

session, véase session.

Distinto en la versión 3.5: Siempre permite pasar un server_hostname, incluso si OpenSSL no tiene SNI.

Distinto en la versión 3.6: Se agregó el argumento session.

Distinto en la versión 3.7: El método retorna una instancia de SSLContext.sslsocket_class en lugar de un SSLSocket rígidamente programado.

SSLContext.sslsocket_class

El tipo de retorno de SSLContext.wrap_socket(), por defecto es SSLSocket. El atributo puede anularse en la instancia de la clase para devolver una subclase personalizada de SSLSocket.

Nuevo en la versión 3.7.

SSLContext.wrap_bio(incoming, outgoing, server_side=False, server_hostname=None, session=None)

Envuelve los objetos BIO incoming y outgoing y devuelve una instancia de SSLContext.sslobject_class (por defecto SSLObject). Las rutinas SSL leerán los datos de entrada de la BIO entrante y escribirán los datos en la BIO saliente.

Los parámetros server_side, server_hostname y session tienen el mismo significado que en SSLContext.wrap_socket().

Distinto en la versión 3.6: Se agregó el argumento session.

Distinto en la versión 3.7: El método retorna una instancia de SSLContext.sslobject_class en lugar de un SSLObject rígidamente programado.

SSLContext.sslobject_class

El tipo de retorno de SSLContext.wrap_bio(), por defecto es SSLObject. El atributo puede anularse en la instancia de la clase para devolver una subclase personalizada de SSLObject.

Nuevo en la versión 3.7.

SSLContext.session_stats()

Obtiene estadísticas sobre las sesiones SSL creadas o gestionadas por este contexto. Se devuelve un diccionario que asigna los nombres de cada pieza de información a sus valores numéricos. Por ejemplo, aquí está el número total de aciertos y errores en la caché de sesión desde que se creó el contexto:

>>> stats = context.session_stats()
>>> stats['hits'], stats['misses']
(0, 0)
SSLContext.check_hostname

Whether to match the peer cert’s hostname in SSLSocket.do_handshake(). The context’s verify_mode must be set to CERT_OPTIONAL or CERT_REQUIRED, and you must pass server_hostname to wrap_socket() in order to match the hostname. Enabling hostname checking automatically sets verify_mode from CERT_NONE to CERT_REQUIRED. It cannot be set back to CERT_NONE as long as hostname checking is enabled. The PROTOCOL_TLS_CLIENT protocol enables hostname checking by default. With other protocols, hostname checking must be enabled explicitly.

Ejemplo:

import socket, ssl

context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
context.verify_mode = ssl.CERT_REQUIRED
context.check_hostname = True
context.load_default_certs()

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_sock = context.wrap_socket(s, server_hostname='www.verisign.com')
ssl_sock.connect(('www.verisign.com', 443))

Nuevo en la versión 3.4.

Distinto en la versión 3.7: verify_mode ahora se cambia automáticamente a CERT_REQUIRED cuando la comprobación del hostname está activada y verify_mode es CERT_NONE. Anteriormente la misma operación habría fallado con un ValueError.

Nota

Esta funcionalidad requiere OpenSSL 0.9.8f o posterior.

SSLContext.keylog_filename

Escribe las claves TLS en un archivo keylog, siempre que se genere o reciba material de claves. El archivo keylog está diseñado únicamente para fines de depuración. El formato del archivo está especificado por NSS y es utilizado por muchos analizadores de tráfico como Wireshark. El archivo de registro se abre en modo sólo añadir. Las escrituras se sincronizan entre hilos, pero no entre procesos.

Nuevo en la versión 3.8.

Nota

Esta funcionalidad requiere OpenSSL 1.1.1 o posterior.

SSLContext.maximum_version

Un miembro enumeración de TLSVersion que representa la versión más alta de TLS soportada. El valor por defecto es TLSVersion.MAXIMUM_SUPPORTED. El atributo es de sólo lectura para protocolos distintos de PROTOCOL_TLS, PROTOCOL_TLS_CLIENT y PROTOCOL_TLS_SERVER.

Los atributos maximum_version, minimum_version y SSLContext.options afectan a las versiones SSL y TLS soportadas del contexto. La implementación no evita la combinación inválida. Por ejemplo, un contexto con OP_NO_TLSv1_2 en options y maximum_version establecido en TLSVersion.TLSv1_2 no podrá establecer una conexión TLS 1.2.

Nota

Este atributo no está disponible a menos que el módulo ssl haya sido compilado con OpenSSL 1.1.0g o posterior.

Nuevo en la versión 3.7.

SSLContext.minimum_version

Igual que SSLContext.maximum_version excepto que es la versión más baja soportada o TLSVersion.MINIMUM_SUPPORTED.

Nota

Este atributo no está disponible a menos que el módulo ssl haya sido compilado con OpenSSL 1.1.0g o posterior.

Nuevo en la versión 3.7.

SSLContext.num_tickets

Controla el número de tickets de sesión TLS 1.3 de un contexto TLS_PROTOCOL_SERVER. El ajuste no tiene impacto en las conexiones TLS 1.0 a 1.2.

Nota

Este atributo no está disponible a menos que el módulo ssl haya sido compilado con OpenSSL 1.1.1 o posterior.

Nuevo en la versión 3.8.

SSLContext.options

Un número entero que representa el conjunto de opciones SSL habilitadas en este contexto. El valor por defecto es OP_ALL, pero se pueden especificar otras opciones como OP_NO_SSLv2 mediante la combinación OR.

Nota

Con versiones de OpenSSL anteriores a la 0.9.8m, sólo es posible establecer opciones, no borrarlas. Si se intenta borrar una opción (restableciendo los bits correspondientes) se producirá un ValueError.

Distinto en la versión 3.6: SSLContext.options retorna opciones Options:

>>> ssl.create_default_context().options  
<Options.OP_ALL|OP_NO_SSLv3|OP_NO_SSLv2|OP_NO_COMPRESSION: 2197947391>
SSLContext.post_handshake_auth

Habilita la autenticación del cliente TLS 1.3 post-handshake. La autenticación post-handshake está deshabilitada por defecto y un servidor sólo puede solicitar un certificado de cliente TLS durante el handshake inicial. Cuando se habilita, un servidor puede solicitar un certificado de cliente TLS en cualquier momento después del handshake.

Cuando se activa en los sockets del lado del cliente, el cliente indica al servidor que soporta la autenticación post-handshake.

Cuando se activa en los sockets del lado del servidor, SSLContext.verify_mode debe establecerse también como CERT_OPTIONAL o CERT_REQUIRED. El intercambio real de certificados del cliente se retrasa hasta que se llama a SSLSocket.verify_client_post_handshake() y se realiza alguna E/S.

Nota

Sólo está disponible con OpenSSL 1.1.1 y TLS 1.3 habilitados. Sin soporte de TLS 1.3, el valor de la propiedad es None y no puede ser modificado

Nuevo en la versión 3.8.

SSLContext.protocol

La versión del protocolo elegida cuando se construyó el contexto. Este atributo es de sólo lectura.

SSLContext.hostname_checks_common_name

Si check_hostname vuelve a verificar el nombre común del sujeto del certificado en ausencia de una extensión de nombre alternativo del sujeto (por defecto: true).

Nota

Solo modificable con OpenSSL 1.1.0 o posterior.

Nuevo en la versión 3.7.

Distinto en la versión 3.9.3: The flag had no effect with OpenSSL before version 1.1.1k. Python 3.8.9, 3.9.3, and 3.10 include workarounds for previous versions.

SSLContext.verify_flags

Los indicadores para las operaciones de verificación de certificados. Se pueden establecer indicadores como VERIFY_CRL_CHECK_LEAF mediante la combinación OR. Por defecto, OpenSSL no requiere ni verifica las listas de revocación de certificados (CRL). Disponible sólo con la versión 0.9.8+ de openssl.

Nuevo en la versión 3.4.

Distinto en la versión 3.6: SSLContext.verify_flags retorna opciones VerifyFlags:

>>> ssl.create_default_context().verify_flags  
<VerifyFlags.VERIFY_X509_TRUSTED_FIRST: 32768>
SSLContext.verify_mode

Si se intenta verificar los certificados de otros pares y cómo comportarse si la verificación falla. Este atributo debe ser uno de los siguientes: CERT_NONE, CERT_OPTIONAL o CERT_REQUIRED.

Distinto en la versión 3.6: SSLContext.verify_mode retorna VerifyMode enum:

>>> ssl.create_default_context().verify_mode
<VerifyMode.CERT_REQUIRED: 2>

Certificados

En general, los certificados forman parte de un sistema de clave pública/clave privada. En este sistema, a cada principal (que puede ser una máquina, una persona o una organización) se le asigna una clave de cifrado única de dos partes. Una parte de la clave es pública y se llama clave pública; la otra parte se mantiene en secreto y se llama clave privada. Las dos partes están relacionadas, en el sentido de que si se cifra un mensaje con una de las partes, se puede descifrar con la otra parte, y sólo con la otra parte.

Un certificado contiene información sobre dos sujetos. Contiene el nombre de un sujeto, y la clave pública del sujeto. También contiene una declaración de un segundo titular, el emisor, de que el sujeto es quien dice ser, y de que ésta es efectivamente la clave pública del sujeto. La declaración del emisor está firmada con su clave privada, que sólo el emisor conoce. Sin embargo, cualquiera puede verificar la declaración del emisor encontrando la clave pública del emisor, descifrando la declaración con ella y comparándola con el resto de la información del certificado. El certificado también contiene información sobre el periodo de tiempo en el que es válido. Esto se expresa en dos campos, llamados notBefore y notAfter.

En el uso de certificados en Python, un cliente o servidor puede utilizar un certificado para demostrar quién es. El otro lado de una conexión de red también puede ser requerido para producir un certificado, y ese certificado puede ser validado a la satisfacción del cliente o servidor que requiere dicha validación. El intento de conexión puede configurarse para que lance una excepción si la validación falla. La validación se realiza automáticamente, por el subyacente framework OpenSSL; la aplicación no necesita preocuparse de su mecánica. Sin embargo, la aplicación normalmente necesita proporcionar conjuntos de certificados para permitir que este proceso tenga lugar.

Python utiliza archivos para contener certificados. Deben ser formateados como «PEM» (ver RFC 1422), que es una forma codificada en base-64 envuelta con una línea de cabecera y una línea de pie de página:

-----BEGIN CERTIFICATE-----
... (certificate in base64 PEM encoding) ...
-----END CERTIFICATE-----

Cadenas de certificados

Los archivos de Python que contienen certificados pueden contener una secuencia de certificados, a veces llamada cadena de certificados. Esta cadena debería empezar con el certificado específico para el principal que «es» el cliente o servidor, y luego el certificado para el emisor de ese certificado, y luego el certificado para el emisor de ese certificado, y así sucesivamente hasta llegar a un certificado que es auto-firmado, es decir, un certificado que tiene el mismo sujeto y emisor, a veces llamado certificado raíz. Los certificados sólo deben concatenarse en el archivo de certificados. Por ejemplo, supongamos que tenemos una cadena de tres certificados, desde el certificado de nuestro servidor al certificado de la autoridad de certificación que firmó nuestro certificado del servidor, hasta el certificado raíz de la agencia que emitió el certificado de la autoridad de certificación:

-----BEGIN CERTIFICATE-----
... (certificate for your server)...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
... (the certificate for the CA)...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
... (the root certificate for the CA's issuer)...
-----END CERTIFICATE-----

Certificados CA

Si se requiere la validación del certificado del otro lado de la conexión, se necesita proporcionar un archivo «CA certs», con las cadenas de certificados para cada emisor en el que se está dispuesto a confiar. De nuevo, este archivo sólo contiene estas cadenas concatenadas. Para la validación, Python utilizará la primera cadena que encuentre en el archivo que coincida. El archivo de certificados de la plataforma se puede utilizar llamando a SSLContext.load_default_certs(), esto se hace automáticamente con create_default_context().

Clave y certificado combinados

A menudo la clave privada se almacena en el mismo archivo que el certificado; en este caso, sólo es necesario pasar el parámetro certfile a SSLContext.load_cert_chain() y wrap_socket(). Si la clave privada se almacena con el certificado, debe ir antes del primer certificado de la cadena de certificados:

-----BEGIN RSA PRIVATE KEY-----
... (private key in base64 encoding) ...
-----END RSA PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
... (certificate in base64 PEM encoding) ...
-----END CERTIFICATE-----

Certificados auto-firmados

Si va a crear un servidor que proporcione servicios de conexión encriptada SSL, necesitará adquirir un certificado para ese servicio. Hay muchas formas de adquirir los certificados adecuados, como comprar uno a una autoridad de certificación. Otra práctica común es generar un certificado auto-firmado. La forma más sencilla de hacerlo es con el paquete OpenSSL, utilizando algo como lo siguiente:

% openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem
Generating a 1024 bit RSA private key
.......++++++
.............................++++++
writing new private key to 'cert.pem'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:MyState
Locality Name (eg, city) []:Some City
Organization Name (eg, company) [Internet Widgits Pty Ltd]:My Organization, Inc.
Organizational Unit Name (eg, section) []:My Group
Common Name (eg, YOUR name) []:myserver.mygroup.myorganization.com
Email Address []:ops@myserver.mygroup.myorganization.com
%

La desventaja de un certificado auto-firmado es que es su propio certificado raíz, y nadie más lo tendrá en su caché de certificados raíz conocidos (y de confianza).

Ejemplos

Pruebas de compatibilidad con SSL

Para comprobar la presencia de soporte SSL en una instalación de Python, el código del usuario debe utilizar el siguiente modismo:

try:
    import ssl
except ImportError:
    pass
else:
    ...  # do something that requires SSL support

Operación del lado del cliente

Este ejemplo crea un contexto SSL con la configuración de seguridad recomendada para los sockets del cliente, incluyendo la verificación automática de certificados:

>>> context = ssl.create_default_context()

Si prefieres ajustar la configuración de seguridad tú mismo, puedes crear un contexto desde cero (pero ten en cuenta que podrías no acertar con la configuración):

>>> context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
>>> context.load_verify_locations("/etc/ssl/certs/ca-bundle.crt")

(este fragmento asume que tu sistema operativo coloca un paquete de todos los certificados CA en /etc/ssl/certs/ca-bundle.crt; si no es así, obtendrá un error y tendrá que ajustar la ubicación)

El protocolo PROTOCOL_TLS_CLIENT configura el contexto para la validación de certificados y la verificación del hostname. verify_mode se establece en CERT_REQUIRED y check_hostname se establece en True. Todos los demás protocolos crean contextos SSL con valores predeterminados inseguros.

Cuando se utiliza el contexto para conectarse a un servidor, CERT_REQUIRED y check_hostname validan el certificado del servidor: se asegura de que el certificado del servidor se ha firmado con uno de los certificados de la CA, se comprueba que la firma es correcta y se verifican otras propiedades como la validez y la identidad del hostname:

>>> conn = context.wrap_socket(socket.socket(socket.AF_INET),
...                            server_hostname="www.python.org")
>>> conn.connect(("www.python.org", 443))

A continuación, puede obtener el certificado:

>>> cert = conn.getpeercert()

La inspección visual muestra que el certificado sí identifica el servicio deseado (es decir, el host HTTPS www.python.org):

>>> pprint.pprint(cert)
{'OCSP': ('http://ocsp.digicert.com',),
 'caIssuers': ('http://cacerts.digicert.com/DigiCertSHA2ExtendedValidationServerCA.crt',),
 'crlDistributionPoints': ('http://crl3.digicert.com/sha2-ev-server-g1.crl',
                           'http://crl4.digicert.com/sha2-ev-server-g1.crl'),
 'issuer': ((('countryName', 'US'),),
            (('organizationName', 'DigiCert Inc'),),
            (('organizationalUnitName', 'www.digicert.com'),),
            (('commonName', 'DigiCert SHA2 Extended Validation Server CA'),)),
 'notAfter': 'Sep  9 12:00:00 2016 GMT',
 'notBefore': 'Sep  5 00:00:00 2014 GMT',
 'serialNumber': '01BB6F00122B177F36CAB49CEA8B6B26',
 'subject': ((('businessCategory', 'Private Organization'),),
             (('1.3.6.1.4.1.311.60.2.1.3', 'US'),),
             (('1.3.6.1.4.1.311.60.2.1.2', 'Delaware'),),
             (('serialNumber', '3359300'),),
             (('streetAddress', '16 Allen Rd'),),
             (('postalCode', '03894-4801'),),
             (('countryName', 'US'),),
             (('stateOrProvinceName', 'NH'),),
             (('localityName', 'Wolfeboro'),),
             (('organizationName', 'Python Software Foundation'),),
             (('commonName', 'www.python.org'),)),
 'subjectAltName': (('DNS', 'www.python.org'),
                    ('DNS', 'python.org'),
                    ('DNS', 'pypi.org'),
                    ('DNS', 'docs.python.org'),
                    ('DNS', 'testpypi.org'),
                    ('DNS', 'bugs.python.org'),
                    ('DNS', 'wiki.python.org'),
                    ('DNS', 'hg.python.org'),
                    ('DNS', 'mail.python.org'),
                    ('DNS', 'packaging.python.org'),
                    ('DNS', 'pythonhosted.org'),
                    ('DNS', 'www.pythonhosted.org'),
                    ('DNS', 'test.pythonhosted.org'),
                    ('DNS', 'us.pycon.org'),
                    ('DNS', 'id.python.org')),
 'version': 3}

Ahora que se ha establecido el canal SSL y se ha verificado el certificado, se puede proceder a hablar con el servidor:

>>> conn.sendall(b"HEAD / HTTP/1.0\r\nHost: linuxfr.org\r\n\r\n")
>>> pprint.pprint(conn.recv(1024).split(b"\r\n"))
[b'HTTP/1.1 200 OK',
 b'Date: Sat, 18 Oct 2014 18:27:20 GMT',
 b'Server: nginx',
 b'Content-Type: text/html; charset=utf-8',
 b'X-Frame-Options: SAMEORIGIN',
 b'Content-Length: 45679',
 b'Accept-Ranges: bytes',
 b'Via: 1.1 varnish',
 b'Age: 2188',
 b'X-Served-By: cache-lcy1134-LCY',
 b'X-Cache: HIT',
 b'X-Cache-Hits: 11',
 b'Vary: Cookie',
 b'Strict-Transport-Security: max-age=63072000; includeSubDomains',
 b'Connection: close',
 b'',
 b'']

Vea la discusión sobre Consideraciones de seguridad más abajo.

Operación del lado del servidor

Para el funcionamiento del servidor, normalmente necesitarás tener un certificado de servidor y una clave privada, cada uno en un archivo. Primero crearás un contexto que contenga la clave y el certificado, para que los clientes puedan comprobar tu autenticidad. Entonces abrirás un socket, lo enlazarás a un puerto, llamarás a listen() en él, y empezarás a esperar a que los clientes se conecten:

import socket, ssl

context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(certfile="mycertfile", keyfile="mykeyfile")

bindsocket = socket.socket()
bindsocket.bind(('myaddr.example.com', 10023))
bindsocket.listen(5)

Cuando un cliente se conecta, llamarás a accept() en el socket para obtener el nuevo socket del otro extremo, y utilizarás el método SSLContext.wrap_socket() del contexto para crear un socket SSL del lado del servidor para la conexión:

while True:
    newsocket, fromaddr = bindsocket.accept()
    connstream = context.wrap_socket(newsocket, server_side=True)
    try:
        deal_with_client(connstream)
    finally:
        connstream.shutdown(socket.SHUT_RDWR)
        connstream.close()

Entonces leerás los datos del connstream y harás algo con ellos hasta que hayas terminado con el cliente (o el cliente haya terminado contigo):

def deal_with_client(connstream):
    data = connstream.recv(1024)
    # empty data means the client is finished with us
    while data:
        if not do_something(connstream, data):
            # we'll assume do_something returns False
            # when we're finished with client
            break
        data = connstream.recv(1024)
    # finished with client

Y volver a escuchar nuevas conexiones de clientes (por supuesto, un servidor real probablemente manejaría cada conexión de cliente en un hilo separado, o pondría los sockets en modo no-bloqueo y usaría un bucle de eventos).

Notas sobre los sockets no bloqueantes

Los sockets SSL se comportan de forma ligeramente diferente a los sockets normales en modo no bloqueante. Cuando se trabaja con sockets no bloqueantes, hay varias cosas que hay que tener en cuenta:

  • La mayoría de los métodos de SSLSocket lanzarán SSLWantWriteError o SSLWantReadError en lugar de BlockingIOError si una operación de E/S se bloquea. SSLWantReadError se lanzará si es necesaria una operación de lectura en el socket subyacente, y SSLWantWriteError para una operación de escritura en el socket subyacente. Tenga en cuenta que los intentos de escribir en un socket SSL pueden requerir leer del socket subyacente primero, y los intentos de leer del socket SSL pueden requerir una escritura previa en el socket subyacente.

    Distinto en la versión 3.5: En versiones anteriores de Python, el método SSLSocket.send() devolvía cero en lugar de lanzar SSLWantWriteError o SSLWantReadError.

  • Llamar a select() le indica que se puede leer (o escribir) en el socket a nivel del SO, pero no implica que haya suficientes datos en la capa superior SSL. Por ejemplo, puede que sólo haya llegado una parte de una trama SSL. Por lo tanto, debe estar preparado para manejar los fallos de SSLSocket.recv() y SSLSocket.send(), y re-intentar después de otra llamada a select().

  • Por el contrario, dado que la capa SSL tiene su propia estructura, un socket SSL puede tener datos disponibles para leer sin que select() lo sepa. Por lo tanto, debería llamar primero a SSLSocket.recv() para drenar cualquier dato potencialmente disponible, y luego sólo bloquear en una llamada a select() si todavía es necesario.

    (por supuesto, se aplican disposiciones similares cuando se utilizan otras primitivas como poll(), o las del módulo selectors)

  • El handshake SSL en sí mismo será no bloqueante: el método SSLSocket.do_handshake() tiene que ser re-intentado hasta que regrese con éxito. Aquí hay una sinopsis usando select() para esperar la disponibilidad del socket:

    while True:
        try:
            sock.do_handshake()
            break
        except ssl.SSLWantReadError:
            select.select([sock], [], [])
        except ssl.SSLWantWriteError:
            select.select([], [sock], [])
    

Ver también

El módulo asyncio soporta sockets SSL no bloqueantes y proporciona una API de alto nivel. Busca eventos usando el módulo selectors y maneja las excepciones SSLWantWriteError, SSLWantReadError y BlockingIOError. También ejecuta el handshake SSL de forma asíncrona.

Soporte de memoria BIO

Nuevo en la versión 3.5.

Desde que se introdujo el módulo SSL en Python 2.6, la clase SSLSocket ha proporcionado dos áreas de funcionalidad relacionadas pero distintas:

  • Manejo del protocolo SSL

  • E/S de red

La API de E/S de red es idéntica a la proporcionada por socket.socket, de la que también hereda SSLSocket. Esto permite que un socket SSL sea utilizado como un reemplazo de un socket normal, haciendo que sea muy fácil añadir soporte SSL a una aplicación existente.

La combinación del manejo del protocolo SSL y la E/S de red suele funcionar bien, pero hay algunos casos en los que no es así. Un ejemplo son los frameworks de E/S asíncronos que quieren utilizar un modelo de multiplexación de E/S diferente al modelo «selección/consulta de un descriptor de archivo» (basado en la preparación) que es asumido por socket.socket y por las rutinas internas de E/S de socket de OpenSSL. Esto es principalmente relevante para plataformas como Windows donde este modelo no es eficiente. Para este propósito, se proporciona una variante de ámbito reducido de SSLSocket llamada SSLObject.

class ssl.SSLObject

Una variante de alcance reducido de SSLSocket que representa una instancia del protocolo SSL que no contiene ningún método de E/S de red. Esta clase suele ser utilizada por los autores de frameworks que quieren implementar E/S asíncrona para SSL a través de búfers de memoria.

Esta clase implementa una interfaz sobre un objeto SSL de bajo nivel como el implementado por OpenSSL. Este objeto captura el estado de una conexión SSL pero no proporciona ninguna E/S de red en sí misma. La E/S debe realizarse a través de objetos «BIO» separados que son la capa de abstracción de E/S de OpenSSL.

Esta clase no tiene un constructor público. Se debe crear una instancia SSLObject utilizando el método wrap_bio(). Este método creará la instancia SSLObject y la vinculará a un par de BIOs. El BIO de entrada se utiliza para pasar los datos de Python a la instancia del protocolo SSL, mientras que el BIO de salida se utiliza para pasar los datos a la inversa.

Los siguientes métodos son disponibles:

En comparación con SSLSocket, este objeto carece de las siguientes características:

  • Cualquier forma de E/S de red; recv() y send() leen y escriben sólo en los búfers subyacentes de MemoryBIO.

  • No existe la maquinaria do_handshake_on_connect. Siempre hay que llamar manualmente a do_handshake() para iniciar el handshake.

  • No hay manejo de suppress_ragged_eofs. Todas las condiciones de fin de archivo que violan el protocolo se reportan a través de la excepción SSLEOFError.

  • La llamada al método unwrap() no devuelve nada, a diferencia de lo que ocurre con un socket SSL, que devuelve el socket subyacente.

  • La función callback server_name_callback pasada a SSLContext.set_servername_callback() obtendrá una instancia de SSLObject en lugar de una instancia de SSLSocket como primer parámetro.

Algunas notas relacionadas con el uso de SSLObject:

Distinto en la versión 3.7: Las instancias SSLObject deben crearse con wrap_bio(). En versiones anteriores, era posible crear instancias directamente. Esto nunca fue documentado ni soportado oficialmente.

Un SSLObject se comunica con el mundo exterior utilizando búfers de memoria. La clase MemoryBIO proporciona un búfer de memoria que puede ser utilizado para este propósito. Envuelve un objeto BIO (Basic IO) de memoria de OpenSSL:

class ssl.MemoryBIO

Un búfer de memoria que se puede utilizar para pasar datos entre Python y una instancia del protocolo SSL.

pending

Retorna el número de bytes que se encuentran actualmente en la memoria búfer.

eof

Un booleano que indica si la memoria BIO es actual en la posición de fin de archivo.

read(n=-1)

Lee hasta n bytes del búfer de memoria. Si n no se especifica o es negativo, se devuelven todos los bytes.

write(buf)

Escribe los bytes de buf en la memoria BIO. El argumento buf debe ser un objeto que soporte el protocolo de búfer.

El valor de retorno es el número de bytes escritos, que siempre es igual a la longitud de buf.

write_eof()

Escribe un marcador EOF en la memoria BIO. Después de llamar a este método, es ilegal llamar a write(). El atributo eof se convertirá en verdadero después de que se hayan leído todos los datos que hay actualmente en el búfer.

Sesión SSL

Nuevo en la versión 3.6.

class ssl.SSLSession

Objeto sesión usado por session.

id
time
timeout
ticket_lifetime_hint
has_ticket

Consideraciones de seguridad

Los mejores valores por defecto

Para el uso en el cliente, si no tiene ningún requisito especial para su política de seguridad, es muy recomendable que utilice la función create_default_context() para crear su contexto SSL. Cargará los certificados CA de confianza del sistema, habilitará la validación de certificados y la comprobación del hostname, e intentará elegir una configuración de protocolo y cifrado razonablemente segura.

Por ejemplo, así es como se utiliza la clase smtplib.SMTP para crear una conexión segura y de confianza con un servidor SMTP:

>>> import ssl, smtplib
>>> smtp = smtplib.SMTP("mail.python.org", port=587)
>>> context = ssl.create_default_context()
>>> smtp.starttls(context=context)
(220, b'2.0.0 Ready to start TLS')

Si se necesita un certificado de cliente para la conexión, se puede añadir con SSLContext.load_cert_chain().

Por el contrario, si crea el contexto SSL llamando usted mismo al constructor SSLContext, no tendrá activada por defecto la validación de certificados ni la comprobación de hostname. Si lo hace, lea los párrafos siguientes para conseguir un buen nivel de seguridad.

Ajustes manuales

Verificación de certificados

Cuando se llama al constructor de SSLContext directamente, CERT_NONE es el valor por defecto. Dado que no autentifica al otro peer, puede ser inseguro, especialmente en modo cliente, donde la mayoría de las veces se quiere asegurar la autenticidad del servidor con el que se está hablando. Por lo tanto, cuando se está en modo cliente, es muy recomendable utilizar CERT_REQUIRED. Sin embargo, no es suficiente por sí mismo; también hay que comprobar que el certificado del servidor, que se puede obtener llamando a SSLSocket.getpeercert(), coincide con el servicio deseado. Para muchos protocolos y aplicaciones, el servicio puede ser identificado por el hostname; en este caso, se puede utilizar la función match_hostname(). Esta comprobación común se realiza automáticamente cuando SSLContext.check_hostname está activado.

Distinto en la versión 3.7: Las hostname matchings son ahora realizadas por OpenSSL. Python ya no utiliza match_hostname().

En el modo servidor, si quiere autenticar a sus clientes utilizando la capa SSL (en lugar de utilizar un mecanismo de autenticación de nivel superior), también tendrá que especificar CERT_REQUIRED y comprobar de forma similar el certificado del cliente.

Versiones del protocolo

Las versiones 2 y 3 de SSL se consideran inseguras y, por lo tanto, su uso es peligroso. Si desea la máxima compatibilidad entre clientes y servidores, se recomienda utilizar PROTOCOL_TLS_CLIENT o PROTOCOL_TLS_SERVER como versión del protocolo. SSLv2 y SSLv3 están desactivados por defecto.

>>> client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
>>> client_context.options |= ssl.OP_NO_TLSv1
>>> client_context.options |= ssl.OP_NO_TLSv1_1

El contexto SSL creado anteriormente sólo permitirá conexiones TLSv1.2 y posteriores (si su sistema lo soporta) a un servidor. PROTOCOL_TLS_CLIENT implica la validación del certificado y la comprobación del nombre de host por defecto. Tiene que cargar los certificados en el contexto.

Selección de cifrado

Si tienes requisitos de seguridad avanzados, es posible ajustar los cifrados habilitados al negociar una sesión SSL mediante el método SSLContext.set_ciphers(). A partir de Python 3.2.3, el módulo ssl deshabilita ciertos cifrados débiles por defecto, pero es posible que quieras restringir más la elección del cifrado. Asegúrese de leer la documentación de OpenSSL sobre el formato de la lista de cifrado. Si quiere comprobar qué cifrados están habilitados por una determinada lista de cifrado, utilice SSLContext.get_ciphers() o el comando openssl ciphers en su sistema.

Multiprocesamiento

Si utiliza este módulo como parte de una aplicación multiproceso (utilizando, por ejemplo, los módulos multiprocessing o concurrent.futures), tenga en cuenta que el generador de números aleatorios interno de OpenSSL no maneja adecuadamente los procesos bifurcados. Las aplicaciones deben cambiar el estado del PRNG del proceso padre si utilizan cualquier función de SSL con os.fork(). Cualquier llamada exitosa de RAND_add(), RAND_bytes() o RAND_pseudo_bytes() es suficiente.

TLS 1.3

Nuevo en la versión 3.7.

Python tiene soporte provisional y experimental para TLS 1.3 con OpenSSL 1.1.1. El nuevo protocolo se comporta de forma ligeramente diferente a la versión anterior de TLS/SSL. Algunas de las nuevas características de TLS 1.3 aún no están disponibles.

  • TLS 1.3 utiliza un conjunto disjunto de suites de cifrado. Todas las suites de cifrado AES-GCM y ChaCha20 están habilitadas por defecto. El método SSLContext.set_ciphers() aún no puede habilitar o deshabilitar ningún cifrado de TLS 1.3, pero SSLContext.get_ciphers() los devuelve.

  • Los tickets de sesión ya no se envían como parte del handshake inicial y se manejan de forma diferente. SSLSocket.session y SSLSession no son compatibles con TLS 1.3.

  • Los certificados del lado del cliente ya no se verifican durante el handshake inicial. Un servidor puede solicitar un certificado en cualquier momento. Los clientes procesan las solicitudes de certificados mientras envían o reciben datos de la aplicación desde el servidor.

  • Las funciones de TLS 1.3, como los datos anticipados, la solicitud de certificado de cliente TLS diferida, la configuración del algoritmo de firma y la repetición de claves, aún no son compatibles.

Soporte LibreSSL

LibreSSL es un fork de OpenSSL 1.0.1. El módulo ssl tiene un soporte limitado para LibreSSL. Algunas características no están disponibles cuando el módulo ssl se compila con LibreSSL.