ssl.md
1> **Источник:** https://python-all.ru/3.13/library/ssl.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `ssl` – обёртка TLS/SSL для сокетов89**Исходный код:** [Lib/ssl.py](https://python-all.ru/src/3.13/Lib/ssl.py)1011---1213Этот модуль предоставляет доступ к шифрованию по протоколу безопасности транспортного уровня (часто называемому "Secure Sockets Layer") и средствам проверки подлинности одноранговых узлов для сетевых сокетов как на стороне клиента, так и на стороне сервера. Модуль использует библиотеку OpenSSL. Он доступен на всех современных системах Unix, Windows, macOS и, вероятно, на других платформах, при условии, что на них установлена OpenSSL.1415> **Примечание**16>17> Некоторые особенности поведения могут зависеть от платформы, поскольку используются системные API сокетов. Установленная версия OpenSSL также может влиять на поведение. Например, TLSv1.3 доступен в OpenSSL версии 1.1.1.1819> **Предупреждение**20>21> Не следует использовать этот модуль без ознакомления с [рекомендациями по безопасности](https://python-all.ru/3.13/library/ssl.html#ssl-security). В противном случае может возникнуть ложное ощущение безопасности, поскольку настройки по умолчанию модуля ssl не обязательно подходят для конкретного приложения.2223[Доступность](https://python-all.ru/3.13/library/intro.html#availability): не WASI.2425Этот модуль не работает или недоступен на WebAssembly. Подробнее см. [платформы WebAssembly](https://python-all.ru/3.13/library/intro.html#wasm-availability).2627В этом разделе описываются объекты и функции модуля `ssl`; более общую информацию о TLS, SSL и сертификатах можно найти в документах, перечисленных в разделе «См. также» внизу.2829Этот модуль предоставляет класс [`ssl.SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket), производный от типа [`socket.socket`](https://python-all.ru/3.13/library/socket.html#socket.socket) и представляющий собой сокетоподобную обёртку, которая также шифрует и дешифрует передаваемые через сокет данные с помощью SSL. Он поддерживает дополнительные методы, такие как `getpeercert()` (получает сертификат другой стороны соединения), `cipher()` (получает используемый шифр защищённого соединения), `get_verified_chain()` и `get_unverified_chain()` (получает цепочку сертификатов).3031Для более сложных приложений класс [`ssl.SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) помогает управлять настройками и сертификатами, которые затем могут наследоваться SSL-сокетами, созданными через метод [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket).3233Изменено в версии 3.5.3: Обновлено для поддержки связывания с OpenSSL 1.1.03435Изменено в версии 3.6: OpenSSL 0.9.8, 1.0.0 и 1.0.1 устарели и больше не поддерживаются. В будущем модуль ssl потребует как минимум OpenSSL 1.0.2 или 1.1.0.3637Изменено в версии 3.10: [**PEP 644**](https://python-all.ru/3.13/library/ssl.html) реализован. Модуль ssl требует OpenSSL 1.1.1 или новее.3839Использование устаревших констант и функций приводит к предупреждениям об устаревании.4041## Функции, константы и исключения4243### Создание сокетов4445Экземпляры [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) должны создаваться с помощью метода [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket). Вспомогательная функция [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context) возвращает новый контекст с безопасными настройками по умолчанию.4647Пример клиентского сокета с контекстом по умолчанию и двойным стеком IPv4/IPv6:4849```python50import socket51import ssl5253hostname = 'www.python.org'54context = ssl.create_default_context()5556with socket.create_connection((hostname, 443)) as sock:57 with context.wrap_socket(sock, server_hostname=hostname) as ssock:58 print(ssock.version())59```6061Пример клиентского сокета с пользовательским контекстом и IPv4:6263```python64hostname = 'www.python.org'65# PROTOCOL_TLS_CLIENT требует правильной цепочки сертификатов и имени хоста66context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)67context.load_verify_locations('path/to/cabundle.pem')6869with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:70 with context.wrap_socket(sock, server_hostname=hostname) as ssock:71 print(ssock.version())72```7374Пример серверного сокета, прослушивающего localhost IPv4:7576```python77context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)78context.load_cert_chain('/path/to/certchain.pem', '/path/to/private.key')7980with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:81 sock.bind(('127.0.0.1', 8443))82 sock.listen(5)83 with context.wrap_socket(sock, server_side=True) as ssock:84 conn, addr = ssock.accept()85 ...86```8788### Создание контекста8990Вспомогательная функция помогает создавать объекты [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) для распространённых целей.9192#### `ssl.create_default_context(purpose=Purpose.SERVER_AUTH, *, cafile=None, capath=None, cadata=None)`9394Возвращает новый объект [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) с настройками по умолчанию для указанного *назначения*. Настройки выбираются модулем `ssl` и обычно представляют более высокий уровень безопасности, чем при непосредственном вызове конструктора `SSLContext`.9596*cafile*, *capath*, *cadata* представляют необязательные сертификаты ЦС, которым следует доверять при проверке сертификатов, как в [`SSLContext.load_verify_locations()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_verify_locations). Если все три равны [`None`](https://python-all.ru/3.13/library/constants.html#None), эта функция может вместо этого доверять системным сертификатам ЦС по умолчанию.9798Настройки: [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) или [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER), [`OP_NO_SSLv2`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv2) и [`OP_NO_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv3) с наборами шифров высокой стойкости без RC4 и без неаутентифицированных наборов шифров. Передача [`SERVER_AUTH`](https://python-all.ru/3.13/library/ssl.html#ssl.Purpose.SERVER_AUTH) в качестве *назначения* устанавливает [`verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) в [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED) и либо загружает сертификаты ЦС (если указан хотя бы один из *cafile*, *capath* или *cadata*), либо использует [`SSLContext.load_default_certs()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_default_certs) для загрузки сертификатов ЦС по умолчанию.99100Если [`keylog_filename`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.keylog_filename) поддерживается и установлена переменная окружения `SSLKEYLOGFILE`, `create_default_context()` включает запись ключей.101102Настройки по умолчанию для этого контекста включают [`VERIFY_X509_PARTIAL_CHAIN`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_X509_PARTIAL_CHAIN) и [`VERIFY_X509_STRICT`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_X509_STRICT). Они заставляют базовую реализацию OpenSSL вести себя как реализация, соответствующая [**RFC 5280**](https://python-all.ru/3.13/library/ssl.html), ценой небольшой несовместимости со старыми сертификатами X.509.103104> **Примечание**105>106> Протокол, параметры, шифр и другие настройки могут в любой момент измениться на более строгие значения без предварительного уведомления об устаревании. Эти значения представляют собой разумный баланс между совместимостью и безопасностью.107>108> Если приложению требуются особые настройки, нужно создать [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) и применить их самостоятельно.109110> **Примечание**111>112> Если при попытке некоторых старых клиентов или серверов подключиться с помощью [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext), созданного этой функцией, возникает ошибка «Несовпадение протокола или набора шифров», возможно, они поддерживают только SSL 3.0, который эта функция исключает с помощью [`OP_NO_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv3). SSL 3.0 общепризнанно [полностью скомпрометирован](https://python-all.ru/3.13/library/ssl.html). Если всё же необходимо продолжить использование этой функции, но при этом разрешить подключения SSL 3.0, можно снова включить их с помощью:113>114> ```python115> ctx = ssl.create_default_context(Purpose.CLIENT_AUTH)116> ctx.options &= ~ssl.OP_NO_SSLv3117> ```118119> **Примечание**120>121> Этот контекст по умолчанию включает [`VERIFY_X509_STRICT`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_X509_STRICT), что может отклонять сертификаты, выпущенные до [**RFC 5280**](https://python-all.ru/3.13/library/ssl.html), или некорректные сертификаты, которые базовая реализация OpenSSL в противном случае приняла бы. Хотя отключать это не рекомендуется, можно сделать это с помощью:122>123> ```python124> ctx = ssl.create_default_context()125> ctx.verify_flags &= ~ssl.VERIFY_X509_STRICT126> ```127128Добавлено в версии 3.4.129130Изменено в версии 3.4.4: RC4 был удалён из строки шифров по умолчанию.131132Изменено в версии 3.6: ChaCha20/Poly1305 был добавлен в строку шифров по умолчанию.1331343DES был удалён из строки шифров по умолчанию.135136Изменено в версии 3.8: Добавлена поддержка логирования ключей в `SSLKEYLOGFILE`.137138Изменено в версии 3.10: Контекст теперь использует протокол [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) или [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER) вместо общего [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS).139140Изменено в версии 3.13: Контекст теперь использует [`VERIFY_X509_PARTIAL_CHAIN`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_X509_PARTIAL_CHAIN) и [`VERIFY_X509_STRICT`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_X509_STRICT) в своих флагах проверки по умолчанию.141142### Исключения143144#### `exception ssl.SSLError`145146Возникает при ошибке в базовой реализации SSL (в настоящее время предоставляемой библиотекой OpenSSL). Это указывает на проблемы в высокоуровневом уровне шифрования и аутентификации, наложенном на нижележащее сетевое соединение. Эта ошибка является подтипом [`OSError`](https://python-all.ru/3.13/library/exceptions.html#OSError). Код ошибки и сообщение экземпляров `SSLError` предоставляются библиотекой OpenSSL.147148Изменено в версии 3.3: `SSLError` ранее был подтипом [`socket.error`](https://python-all.ru/3.13/library/socket.html#socket.error).149150#### `library`151152Строковый мнемонический код, обозначающий подмодуль OpenSSL, в котором произошла ошибка, например `SSL`, `PEM` или `X509`. Набор возможных значений зависит от версии OpenSSL.153154Добавлено в версии 3.3.155156#### `reason`157158Строковый мнемонический код, обозначающий причину этой ошибки, например `CERTIFICATE_VERIFY_FAILED`. Набор возможных значений зависит от версии OpenSSL.159160Добавлено в версии 3.3.161162#### `exception ssl.SSLZeroReturnError`163164Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый при попытке чтения или записи, когда SSL-соединение было корректно закрыто. Обратите внимание, что это не означает, что нижележащий транспорт (например, TCP) был закрыт.165166Добавлено в версии 3.3.167168#### `exception ssl.SSLWantReadError`169170Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый [неблокирующим SSL-сокетом](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) при попытке чтения или записи данных, но для выполнения запроса необходимо получить больше данных по нижележащему TCP-транспорту.171172Добавлено в версии 3.3.173174#### `exception ssl.SSLWantWriteError`175176Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый [неблокирующим SSL-сокетом](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) при попытке чтения или записи данных, но для выполнения запроса необходимо отправить больше данных по нижележащему TCP-транспорту.177178Добавлено в версии 3.3.179180#### `exception ssl.SSLSyscallError`181182Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый при возникновении системной ошибки во время выполнения операции с SSL-сокетом. К сожалению, нет простого способа узнать исходный номер errno.183184Добавлено в версии 3.3.185186#### `exception ssl.SSLEOFError`187188Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый при внезапном завершении SSL-соединения. Обычно не следует пытаться повторно использовать нижележащий транспорт при возникновении этой ошибки.189190Добавлено в версии 3.3.191192#### `exception ssl.SSLCertVerificationError`193194Подкласс [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), возбуждаемый при неудачной проверке сертификата.195196Добавлено в версии 3.7.197198#### `verify_code`199200Числовой код ошибки, обозначающий ошибку проверки.201202#### `verify_message`203204Человекочитаемая строка с описанием ошибки проверки.205206#### `exception ssl.CertificateError`207208Псевдоним для [`SSLCertVerificationError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLCertVerificationError).209210Изменено в версии 3.7: Это исключение теперь является псевдонимом для [`SSLCertVerificationError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLCertVerificationError).211212### Генерация случайных чисел213214#### `ssl.RAND_bytes(num, /)`215216Возвращает *num* криптостойких псевдослучайных байт. Вызывает исключение [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), если ГПСЧ (PRNG) не был инициализирован достаточным количеством данных или если операция не поддерживается текущим методом RAND. [`RAND_status()`](https://python-all.ru/3.13/library/ssl.html#ssl.RAND_status) можно использовать для проверки состояния ГПСЧ, а [`RAND_add()`](https://python-all.ru/3.13/library/ssl.html#ssl.RAND_add) – для его инициализации.217218Для практически всех приложений предпочтительнее использовать [`os.urandom()`](https://python-all.ru/3.13/library/os.html#os.urandom).219220Прочитайте статью в Википедии [Криптостойкий генератор псевдослучайных чисел (CSPRNG)](https://python-all.ru/3.13/library/ssl.html), чтобы узнать требования к криптостойкому генератору.221222Добавлено в версии 3.3.223224#### `ssl.RAND_status()`225226Возвращает `True`, если ГПСЧ (псевдослучайный генератор чисел) SSL был инициализирован достаточным количеством случайных данных, и `False` в противном случае. Можно использовать `ssl.RAND_egd()` и [`ssl.RAND_add()`](https://python-all.ru/3.13/library/ssl.html#ssl.RAND_add) для увеличения случайности генератора псевдослучайных чисел.227228#### `ssl.RAND_add(bytes, entropy, /)`229230Смешивает заданные *bytes* (байты) с генератором псевдослучайных чисел SSL. Параметр *entropy* (число с плавающей точкой) задаёт нижнюю границу энтропии, содержащейся в строке (поэтому всегда можно использовать `0.0`). См. [**RFC 1750**](https://python-all.ru/3.13/library/ssl.html) для получения дополнительной информации об источниках энтропии.231232Изменено в версии 3.5: Теперь принимается записываемый [байтоподобный объект](https://python-all.ru/3.13/glossary.html#term-bytes-like-object).233234### Обработка сертификатов235236#### `ssl.cert_time_to_seconds(cert_time)`237238Возвращает время в секундах с начала эпохи (epoch), принимая строку `cert_time`, представляющую дату “notBefore” или “notAfter” из сертификата, в формате `"%b %d %H:%M:%S %Y %Z"` strptime (локаль C).239240Вот пример:241242```pycon243>>> import ssl244>>> import datetime as dt245>>> timestamp = ssl.cert_time_to_seconds("Jan 5 09:34:43 2018 GMT")246>>> timestamp2471515144883248>>> print(dt.datetime.fromtimestamp(timestamp, dt.UTC))2492018-01-05 09:34:43+00:00250```251252Даты “notBefore” or “notAfter” должны использовать GMT ([**RFC 5280**](https://python-all.ru/3.13/library/ssl.html)).253254Изменено в версии 3.5: Входное время теперь интерпретируется как время в UTC, как указано часовым поясом 'GMT' во входной строке. Ранее использовался местный часовой пояс. Возвращает целое число (во входном формате нет долей секунды).255256#### `ssl.get_server_certificate(addr, ssl_version=PROTOCOL_TLS_CLIENT, ca_certs=None[, timeout])`257258По адресу `addr` SSL-защищённого сервера, заданному в виде пары (*имя\_хоста*, *номер\_порта*), получает сертификат сервера и возвращает его в виде строки в кодировке PEM. Если указан `ssl_version`, используется соответствующая версия протокола SSL для попытки подключения к серверу. Если указан *ca\_certs*, это должен быть файл, содержащий список корневых сертификатов, в том же формате, что используется для параметра *cafile* в [`SSLContext.load_verify_locations()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_verify_locations). Вызов попытается проверить сертификат сервера относительно этого набора корневых сертификатов и завершится ошибкой, если проверка не удастся. Можно указать тайм-аут с помощью параметра `timeout`.259260Изменено в версии 3.3: Эта функция теперь совместима с IPv6.261262Изменено в версии 3.5: Значение по умолчанию *ssl\_version* изменено с [`PROTOCOL_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_SSLv3) на [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS) для максимальной совместимости с современными серверами.263264Изменено в версии 3.10: Добавлен параметр *timeout*.265266#### `ssl.DER_cert_to_PEM_cert(der_cert_bytes)`267268Принимая сертификат в виде набора байтов в кодировке DER, возвращает версию того же сертификата в виде строки в кодировке PEM.269270#### `ssl.PEM_cert_to_DER_cert(pem_cert_string)`271272Принимая сертификат в виде строки ASCII в формате PEM, возвращает последовательность байтов в кодировке DER для того же сертификата.273274#### `ssl.get_default_verify_paths()`275276Возвращает именованный кортеж с путями к файлу cafile и каталогу capath OpenSSL по умолчанию. Эти пути совпадают с используемыми в [`SSLContext.set_default_verify_paths()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_default_verify_paths). Возвращаемое значение – это [именованный кортеж](https://python-all.ru/3.13/glossary.html#term-named-tuple) `DefaultVerifyPaths`:277278- `cafile` – разрешённый (абсолютный) путь к cafile или `None`, если файл не существует,279- `capath` – разрешённый путь к capath или `None`, если каталог не существует,280- `openssl_cafile_env` – переменная окружения OpenSSL, указывающая на cafile,281- `openssl_cafile` – жёстко заданный путь к cafile,282- `openssl_capath_env` – переменная окружения OpenSSL, указывающая на capath,283- `openssl_capath` – жёстко заданный путь к каталогу capath284285Добавлено в версии 3.4.286287#### `ssl.enum_certificates(store_name)`288289Извлекает сертификаты из системного хранилища сертификатов Windows. *store\_name* может быть одним из `CA`, `ROOT` или `MY`. Windows также может предоставлять дополнительные хранилища сертификатов.290291Функция возвращает список кортежей (cert\_bytes, encoding\_type, trust). Параметр encoding\_type задаёт кодировку cert\_bytes. Это может быть `x509_asn` для данных X.509 ASN.1 или `pkcs_7_asn` для данных PKCS#7 ASN.1. Параметр trust определяет назначение сертификата в виде набора OID или точно `True`, если сертификат считается надёжным для всех целей.292293Пример:294295```python296>>> ssl.enum_certificates("CA")297[(b'data...', 'x509_asn', {'1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2'}),298 (b'data...', 'x509_asn', True)]299```300301[Доступность](https://python-all.ru/3.13/library/intro.html#availability): Windows.302303Добавлено в версии 3.4.304305#### `ssl.enum_crls(store_name)`306307Извлекает CRL из системного хранилища сертификатов Windows. *store\_name* может быть одним из `CA`, `ROOT` или `MY`. Windows также может предоставлять дополнительные хранилища сертификатов.308309Функция возвращает список кортежей (cert\_bytes, encoding\_type, trust). Параметр encoding\_type задаёт кодировку cert\_bytes. Это может быть `x509_asn` для данных X.509 ASN.1 или `pkcs_7_asn` для данных PKCS#7 ASN.1.310311[Доступность](https://python-all.ru/3.13/library/intro.html#availability): Windows.312313Добавлено в версии 3.4.314315### Константы316317> Все константы теперь являются коллекциями [`enum.IntEnum`](https://python-all.ru/3.13/library/enum.html#enum.IntEnum) или [`enum.IntFlag`](https://python-all.ru/3.13/library/enum.html#enum.IntFlag).318>319> Добавлено в версии 3.6.320321#### `ssl.CERT_NONE`322323Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode). За исключением [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT), это режим по умолчанию. В клиентских сокетах принимается практически любой сертификат. Ошибки проверки, такие как ненадёжный или просроченный сертификат, игнорируются и не прерывают рукопожатие TLS/SSL.324325В серверном режиме сертификат у клиента не запрашивается, поэтому клиент не отправляет его для аутентификации по клиентскому сертификату.326327См. обсуждение [соображений безопасности](https://python-all.ru/3.13/library/ssl.html#ssl-security) ниже.328329#### `ssl.CERT_OPTIONAL`330331Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode). В клиентском режиме [`CERT_OPTIONAL`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_OPTIONAL) имеет то же значение, что и [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED). Рекомендуется вместо него использовать `CERT_REQUIRED` для клиентских сокетов.332333В серверном режиме клиенту отправляется запрос клиентского сертификата. Клиент может либо проигнорировать запрос, либо отправить сертификат для выполнения аутентификации по клиентскому сертификату TLS. Если клиент решает отправить сертификат, он проверяется. Любая ошибка проверки немедленно прерывает рукопожатие TLS.334335Использование этого параметра требует передачи допустимого набора сертификатов ЦС в [`SSLContext.load_verify_locations()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_verify_locations).336337#### `ssl.CERT_REQUIRED`338339Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode). В этом режиме сертификаты требуются от другой стороны сокетного соединения; если сертификат не предоставлен или его проверка не удалась, будет возбуждено исключение [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError). Этот режим **не** достаточен для проверки сертификата в клиентском режиме, поскольку он не сопоставляет имена хостов. Для проверки подлинности сертификата также необходимо включить [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname). [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) использует [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED) и по умолчанию включает `check_hostname`.340341В серверном сокете этот режим обеспечивает обязательную аутентификацию по клиентскому сертификату TLS. Клиенту отправляется запрос клиентского сертификата, и клиент должен предоставить действительный и надёжный сертификат.342343Использование этого параметра требует передачи допустимого набора сертификатов ЦС в [`SSLContext.load_verify_locations()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_verify_locations).344345#### `class ssl.VerifyMode`346347Коллекция [`enum.IntEnum`](https://python-all.ru/3.13/library/enum.html#enum.IntEnum) констант CERT\_\*.348349Добавлено в версии 3.6.350351#### `ssl.VERIFY_DEFAULT`352353Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме списки отзыва сертификатов (CRL) не проверяются. По умолчанию OpenSSL не требует и не проверяет CRL.354355Добавлено в версии 3.4.356357#### `ssl.VERIFY_CRL_CHECK_LEAF`358359Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме проверяется только сертификат однорангового узла, но ни один из промежуточных сертификатов ЦС. Режим требует действительного CRL, подписанного эмитентом сертификата однорангового узла (его прямым вышестоящим ЦС). Если подходящий CRL не был загружен с помощью [`SSLContext.load_verify_locations`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_verify_locations), проверка не удастся.360361Добавлено в версии 3.4.362363#### `ssl.VERIFY_CRL_CHECK_CHAIN`364365Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме проверяются CRL всех сертификатов в цепочке сертификата однорангового узла.366367Добавлено в версии 3.4.368369#### `ssl.VERIFY_X509_STRICT`370371Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags) для отключения обходных путей для повреждённых сертификатов X.509.372373Добавлено в версии 3.4.374375#### `ssl.VERIFY_ALLOW_PROXY_CERTS`376377Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags) для включения проверки прокси-сертификатов.378379Добавлено в версии 3.10.380381#### `ssl.VERIFY_X509_TRUSTED_FIRST`382383Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags). Оно указывает OpenSSL отдавать предпочтение доверенным сертификатам при построении цепочки доверия для проверки сертификата. Этот флаг включён по умолчанию.384385Добавлено в версии 3.4.4.386387#### `ssl.VERIFY_X509_PARTIAL_CHAIN`388389Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags). Оно указывает OpenSSL принимать промежуточные УЦ в хранилище доверенных сертификатов как доверенные якоря, так же как и самоподписанные корневые сертификаты УЦ. Это позволяет доверять сертификатам, выпущенным промежуточным УЦ, без необходимости доверять его вышестоящему корневому УЦ.390391Добавлено в версии 3.10.392393#### `class ssl.VerifyFlags`394395[`enum.IntFlag`](https://python-all.ru/3.13/library/enum.html#enum.IntFlag) набор констант VERIFY\_\*.396397Добавлено в версии 3.6.398399#### `ssl.PROTOCOL_TLS`400401Выбирает самую высокую версию протокола, поддерживаемую как клиентом, так и сервером. Несмотря на название, эта опция может выбирать как протокол «SSL», так и «TLS».402403Добавлено в версии 3.6.404405Устарело с версии 3.10: TLS-клиенты и серверы требуют разных настроек по умолчанию для безопасной связи. Общая константа протокола TLS устарела в пользу [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) и [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER).406407#### `ssl.PROTOCOL_TLS_CLIENT`408409Автоматически согласовывает самую высокую версию протокола, поддерживаемую как клиентом, так и сервером, и настраивает контекст для соединений на стороне клиента. Данный протокол по умолчанию включает [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED) и [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname).410411Добавлено в версии 3.6.412413#### `ssl.PROTOCOL_TLS_SERVER`414415Автоматически согласовывает самую высокую версию протокола, поддерживаемую как клиентом, так и сервером, и настраивает контекст для соединений на стороне сервера.416417Добавлено в версии 3.6.418419#### `ssl.PROTOCOL_SSLv23`420421Псевдоним для [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS).422423Устарело с версии 3.6: Используйте [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS) вместо.424425#### `ssl.PROTOCOL_SSLv3`426427Выбирает SSL версии 3 в качестве протокола шифрования канала.428429Этот протокол недоступен, если OpenSSL скомпилирован с опцией `no-ssl3`.430431> **Предупреждение**432>433> SSL версии 3 небезопасен. Его использование крайне не рекомендуется.434435Устарело с версии 3.6: OpenSSL объявил устаревшими все версионно-зависимые протоколы. Используйте протокол по умолчанию [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER) или [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) с [`SSLContext.minimum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.minimum_version) и [`SSLContext.maximum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.maximum_version) вместо.436437#### `ssl.PROTOCOL_TLSv1`438439Выбирает TLS версии 1.0 в качестве протокола шифрования канала.440441Устарело с версии 3.6: OpenSSL объявил устаревшими все версионно-зависимые протоколы.442443#### `ssl.PROTOCOL_TLSv1_1`444445Выбирает TLS версии 1.1 в качестве протокола шифрования канала. Доступно только в openssl версии 1.0.1+.446447Добавлено в версии 3.4.448449Устарело с версии 3.6: OpenSSL объявил устаревшими все версионно-зависимые протоколы.450451#### `ssl.PROTOCOL_TLSv1_2`452453Выбирает TLS версии 1.2 в качестве протокола шифрования канала. Доступно только в openssl версии 1.0.1+.454455Добавлено в версии 3.4.456457Устарело с версии 3.6: OpenSSL объявил устаревшими все версионно-зависимые протоколы.458459#### `ssl.OP_ALL`460461Включает обходные пути для различных ошибок, присутствующих в других реализациях SSL. Эта опция включена по умолчанию. Она не обязательно устанавливает те же флаги, что и константа `SSL_OP_ALL` от OpenSSL.462463Добавлено в версии 3.2.464465#### `ssl.OP_NO_SSLv2`466467Предотвращает подключение по SSLv2. Эта опция применима только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Она не позволяет сторонам выбирать SSLv2 в качестве версии протокола.468469Добавлено в версии 3.2.470471Устарело с версии 3.6: SSLv2 устарел472473#### `ssl.OP_NO_SSLv3`474475Предотвращает подключение по SSLv3. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать SSLv3 в качестве версии протокола.476477Добавлено в версии 3.2.478479Устарело с версии 3.6: SSLv3 устарел480481#### `ssl.OP_NO_TLSv1`482483Предотвращает подключение по TLSv1. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать TLSv1 в качестве версии протокола.484485Добавлено в версии 3.2.486487Устарело с версии 3.7: Этот параметр устарел начиная с OpenSSL 1.1.0, используйте новые [`SSLContext.minimum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.minimum_version) и [`SSLContext.maximum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.maximum_version) вместо них.488489#### `ssl.OP_NO_TLSv1_1`490491Предотвращает подключение по TLSv1.1. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать TLSv1.1 в качестве версии протокола. Доступно только для OpenSSL версии 1.0.1 и выше.492493Добавлено в версии 3.4.494495Устарело с версии 3.7: Этот параметр устарел начиная с OpenSSL 1.1.0.496497#### `ssl.OP_NO_TLSv1_2`498499Предотвращает подключение по TLSv1.2. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать TLSv1.2 в качестве версии протокола. Доступно только для OpenSSL версии 1.0.1 и выше.500501Добавлено в версии 3.4.502503Устарело с версии 3.7: Этот параметр устарел начиная с OpenSSL 1.1.0.504505#### `ssl.OP_NO_TLSv1_3`506507Предотвращает подключение по TLSv1.3. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать TLSv1.3 в качестве версии протокола. TLS 1.3 доступен начиная с OpenSSL 1.1.1. Если Python был собран с более старой версией OpenSSL, этот флаг по умолчанию равен *0*.508509Добавлено в версии 3.6.3.510511Устарело с версии 3.7: Этот параметр устарел начиная с OpenSSL 1.1.0. Он был добавлен в версии 2.7.15 и 3.6.3 для обратной совместимости с OpenSSL 1.0.2.512513#### `ssl.OP_NO_RENEGOTIATION`514515Отключает любое пересогласование в TLSv1.2 и более ранних версиях. Не отправляет сообщения HelloRequest и игнорирует запросы на пересогласование через ClientHello.516517Этот параметр доступен только в OpenSSL 1.1.0h и выше.518519Добавлено в версии 3.7.520521#### `ssl.OP_CIPHER_SERVER_PREFERENCE`522523Использовать порядок шифров, заданный на сервере, а не на клиенте. Этот параметр не влияет на клиентские сокеты и сокеты сервера SSLv2.524525Добавлено в версии 3.3.526527#### `ssl.OP_SINGLE_DH_USE`528529Предотвращает повторное использование одного и того же DH-ключа для разных SSL-сеансов. Это улучшает прямую секретность (forward secrecy), но требует больше вычислительных ресурсов. Этот параметр применяется только к серверным сокетам.530531Добавлено в версии 3.3.532533#### `ssl.OP_SINGLE_ECDH_USE`534535Предотвращает повторное использование одного и того же ECDH-ключа для разных SSL-сеансов. Это улучшает прямую секретность (forward secrecy), но требует больше вычислительных ресурсов. Этот параметр применяется только к серверным сокетам.536537Добавлено в версии 3.3.538539#### `ssl.OP_ENABLE_MIDDLEBOX_COMPAT`540541Отправляет фиктивные сообщения Change Cipher Spec (CCS) в процессе рукопожатия TLS 1.3, чтобы подключение TLS 1.3 выглядело больше как подключение TLS 1.2.542543Этот параметр доступен только в OpenSSL 1.1.1 и выше.544545Добавлено в версии 3.8.546547#### `ssl.OP_NO_COMPRESSION`548549Отключает сжатие в SSL-канале. Это полезно, если прикладной протокол поддерживает собственный механизм сжатия.550551Добавлено в версии 3.3.552553#### `class ssl.Options`554555[`enum.IntFlag`](https://python-all.ru/3.13/library/enum.html#enum.IntFlag) коллекция констант OP\_\*.556557#### `ssl.OP_NO_TICKET`558559Предотвращает запрос сессионного билета со стороны клиента.560561Добавлено в версии 3.6.562563#### `ssl.OP_IGNORE_UNEXPECTED_EOF`564565Игнорирует неожиданное завершение TLS-соединений.566567Эта опция доступна только в OpenSSL 3.0.0 и новее.568569Добавлено в версии 3.10.570571#### `ssl.OP_ENABLE_KTLS`572573Включает использование TLS на уровне ядра. Чтобы воспользоваться этой возможностью, OpenSSL должен быть собран с поддержкой этой функции, а согласованные наборы шифров и расширения должны ей поддерживаться (список поддерживаемых может различаться в зависимости от платформы и версии ядра).574575Обратите внимание, что при включенном TLS ядра некоторые криптографические операции выполняются ядром напрямую, а не через доступные провайдеры OpenSSL. Это может быть нежелательно, если, например, приложение требует выполнения всех криптографических операций провайдером FIPS.576577Эта опция доступна только в OpenSSL 3.0.0 и новее.578579Добавлено в версии 3.12.580581#### `ssl.OP_LEGACY_SERVER_CONNECT`582583Разрешает устаревшее небезопасное пересогласование между OpenSSL и незапатченными серверами только.584585Добавлено в версии 3.12.586587#### `ssl.HAS_ALPN`588589Указывает, имеет ли библиотека OpenSSL встроенную поддержку расширения TLS *Согласование протокола прикладного уровня*, как описано в [**RFC 7301**](https://python-all.ru/3.13/library/ssl.html).590591Добавлено в версии 3.5.592593#### `ssl.HAS_NEVER_CHECK_COMMON_NAME`594595Указывает, имеет ли библиотека OpenSSL встроенную поддержку отключения проверки общего имени субъекта и [`SSLContext.hostname_checks_common_name`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.hostname_checks_common_name) является доступным для записи.596597Добавлено в версии 3.7.598599#### `ssl.HAS_ECDH`600601Указывает, имеет ли библиотека OpenSSL встроенную поддержку обмена ключами Диффи-Хеллмана на основе эллиптических кривых. Это должно быть истиной (true), если только эта возможность не была явно отключена распространителем.602603Добавлено в версии 3.3.604605#### `ssl.HAS_SNI`606607Указывает, имеет ли библиотека OpenSSL встроенную поддержку расширения *Указание имени сервера (Server Name Indication)* (как определено в [**RFC 6066**](https://python-all.ru/3.13/library/ssl.html)).608609Добавлено в версии 3.2.610611#### `ssl.HAS_NPN`612613Указывает, имеет ли библиотека OpenSSL встроенную поддержку *Согласования следующего протокола*, как описано в [Согласовании протокола прикладного уровня](https://python-all.ru/3.13/library/ssl.html). Если истина (true), вы можете использовать метод [`SSLContext.set_npn_protocols()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_npn_protocols) для объявления поддерживаемых протоколов.614615Добавлено в версии 3.3.616617#### `ssl.HAS_SSLv2`618619Указывает, имеет ли библиотека OpenSSL встроенную поддержку протокола SSL 2.0.620621Добавлено в версии 3.7.622623#### `ssl.HAS_SSLv3`624625Указывает, имеет ли библиотека OpenSSL встроенную поддержку протокола SSL 3.0.626627Добавлено в версии 3.7.628629#### `ssl.HAS_TLSv1`630631Указывает, имеет ли библиотека OpenSSL встроенную поддержку протокола TLS 1.0.632633Добавлено в версии 3.7.634635#### `ssl.HAS_TLSv1_1`636637Указывает, имеет ли библиотека OpenSSL встроенную поддержку протокола TLS 1.1.638639Добавлено в версии 3.7.640641#### `ssl.HAS_TLSv1_2`642643Указывает, имеет ли библиотека OpenSSL встроенную поддержку протокола TLS 1.2.644645Добавлено в версии 3.7.646647#### `ssl.HAS_TLSv1_3`648649Определяет, поддерживает ли библиотека OpenSSL протокол TLS 1.3 на встроенном уровне.650651Добавлено в версии 3.7.652653#### `ssl.HAS_PSK`654655Определяет, поддерживает ли библиотека OpenSSL TLS-PSK встроенными средствами.656657Добавлено в версии 3.13.658659#### `ssl.CHANNEL_BINDING_TYPES`660661Список поддерживаемых типов привязки каналов TLS. Строки из этого списка можно использовать в качестве аргументов для [`SSLSocket.get_channel_binding()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_channel_binding).662663Добавлено в версии 3.3.664665#### `ssl.OPENSSL_VERSION`666667Строка с версией библиотеки OpenSSL, загруженной интерпретатором:668669```python670>>> ssl.OPENSSL_VERSION671'OpenSSL 1.0.2k 26 Jan 2017'672```673674Добавлено в версии 3.2.675676#### `ssl.OPENSSL_VERSION_INFO`677678Кортеж из пяти целых чисел, содержащий информацию о версии библиотеки OpenSSL:679680```python681>>> ssl.OPENSSL_VERSION_INFO682(1, 0, 2, 11, 15)683```684685Добавлено в версии 3.2.686687#### `ssl.OPENSSL_VERSION_NUMBER`688689Сырой номер версии библиотеки OpenSSL в виде целого числа:690691```python692>>> ssl.OPENSSL_VERSION_NUMBER693268443839694>>> hex(ssl.OPENSSL_VERSION_NUMBER)695'0x100020bf'696```697698Добавлено в версии 3.2.699700#### `ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE`701702#### `ssl.ALERT_DESCRIPTION_INTERNAL_ERROR`703704#### `ALERT_DESCRIPTION_*`705706Описания предупреждений из [**RFC 5246**](https://python-all.ru/3.13/library/ssl.html) и других источников. [Реестр предупреждений TLS IANA](https://python-all.ru/3.13/library/ssl.html) содержит этот список и ссылки на RFC, где определено их значение.707708Используется как возвращаемое значение колбэка в [`SSLContext.set_servername_callback()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_servername_callback).709710Добавлено в версии 3.4.711712#### `class ssl.AlertDescription`713714[`enum.IntEnum`](https://python-all.ru/3.13/library/enum.html#enum.IntEnum) набор констант ALERT\_DESCRIPTION\_\*.715716Добавлено в версии 3.6.717718#### `Purpose.SERVER_AUTH`719720Параметр для [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context) и [`SSLContext.load_default_certs()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_default_certs). Это значение указывает, что контекст может использоваться для аутентификации веб-серверов (поэтому он будет использоваться для создания клиентских сокетов).721722Добавлено в версии 3.4.723724#### `Purpose.CLIENT_AUTH`725726Параметр для [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context) и [`SSLContext.load_default_certs()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_default_certs). Это значение указывает, что контекст может использоваться для аутентификации веб-клиентов (поэтому он будет использоваться для создания серверных сокетов).727728Добавлено в версии 3.4.729730#### `class ssl.SSLErrorNumber`731732[`enum.IntEnum`](https://python-all.ru/3.13/library/enum.html#enum.IntEnum) набор констант SSL\_ERROR\_\*.733734Добавлено в версии 3.6.735736#### `class ssl.TLSVersion`737738[`enum.IntEnum`](https://python-all.ru/3.13/library/enum.html#enum.IntEnum) набор версий SSL и TLS для [`SSLContext.maximum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.maximum_version) и [`SSLContext.minimum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.minimum_version).739740Добавлено в версии 3.7.741742#### `TLSVersion.MINIMUM_SUPPORTED`743744#### `TLSVersion.MAXIMUM_SUPPORTED`745746Минимальная или максимальная поддерживаемая версия SSL или TLS. Это магические константы. Их значения не соответствуют наименьшей и наибольшей доступным версиям TLS/SSL.747748#### `TLSVersion.SSLv3`749750#### `TLSVersion.TLSv1`751752#### `TLSVersion.TLSv1_1`753754#### `TLSVersion.TLSv1_2`755756#### `TLSVersion.TLSv1_3`757758от SSL 3.0 до TLS 1.3.759760Устарело с версии 3.10: Все члены [`TLSVersion`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion), кроме [`TLSVersion.TLSv1_2`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion.TLSv1_2) и `TLSVersion.TLSv1_3`, устарели.761762## SSL-сокеты763764#### `class ssl.SSLSocket(socket.socket)`765766SSL-сокеты предоставляют следующие методы [объектов сокетов](https://python-all.ru/3.13/library/socket.html#socket-objects):767768- [`accept()`](https://python-all.ru/3.13/library/socket.html#socket.socket.accept)769- [`bind()`](https://python-all.ru/3.13/library/socket.html#socket.socket.bind)770- [`close()`](https://python-all.ru/3.13/library/socket.html#socket.socket.close)771- [`connect()`](https://python-all.ru/3.13/library/socket.html#socket.socket.connect)772- [`detach()`](https://python-all.ru/3.13/library/socket.html#socket.socket.detach)773- [`fileno()`](https://python-all.ru/3.13/library/socket.html#socket.socket.fileno)774- [`getpeername()`](https://python-all.ru/3.13/library/socket.html#socket.socket.getpeername), [`getsockname()`](https://python-all.ru/3.13/library/socket.html#socket.socket.getsockname)775- [`getsockopt()`](https://python-all.ru/3.13/library/socket.html#socket.socket.getsockopt), [`setsockopt()`](https://python-all.ru/3.13/library/socket.html#socket.socket.setsockopt)776- [`gettimeout()`](https://python-all.ru/3.13/library/socket.html#socket.socket.gettimeout), [`settimeout()`](https://python-all.ru/3.13/library/socket.html#socket.socket.settimeout), [`setblocking()`](https://python-all.ru/3.13/library/socket.html#socket.socket.setblocking)777- [`listen()`](https://python-all.ru/3.13/library/socket.html#socket.socket.listen)778- [`makefile()`](https://python-all.ru/3.13/library/socket.html#socket.socket.makefile)779- [`recv()`](https://python-all.ru/3.13/library/socket.html#socket.socket.recv), [`recv_into()`](https://python-all.ru/3.13/library/socket.html#socket.socket.recv_into) (однако передача ненулевого аргумента `flags` не разрешена)780- [`send()`](https://python-all.ru/3.13/library/socket.html#socket.socket.send), [`sendall()`](https://python-all.ru/3.13/library/socket.html#socket.socket.sendall) (с тем же ограничением)781- [`sendfile()`](https://python-all.ru/3.13/library/socket.html#socket.socket.sendfile) (но [`os.sendfile`](https://python-all.ru/3.13/library/os.html#os.sendfile) будет использоваться только для сокетов с незашифрованным текстом, иначе будет использоваться [`send()`](https://python-all.ru/3.13/library/socket.html#socket.socket.send))782- [`shutdown()`](https://python-all.ru/3.13/library/socket.html#socket.socket.shutdown)783784Однако, поскольку протокол SSL (и TLS) имеет собственную структуру поверх TCP, абстракция SSL-сокетов может в некоторых аспектах отличаться от спецификации обычных сокетов на уровне ОС. Особенно см. [примечания о неблокирующих сокетах](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking).785786Экземпляры `SSLSocket` должны создаваться с помощью метода [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket).787788Изменено в версии 3.5: Был добавлен метод `sendfile()`.789790Изменено в версии 3.5: Метод `shutdown()` не сбрасывает тайм-аут сокета каждый раз, когда принимаются или отправляются байты. Теперь тайм-аут сокета – это максимальная общая продолжительность завершения работы.791792Устарело с версии 3.6: Создавать экземпляр `SSLSocket` напрямую устарело; используйте [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket) для обёртывания сокета.793794Изменено в версии 3.7: Экземпляры `SSLSocket` должны создаваться с помощью [`wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket). В более ранних версиях можно было создавать экземпляры напрямую. Это никогда не документировалось и официально не поддерживалось.795796Изменено в версии 3.10: Python теперь использует `SSL_read_ex` и `SSL_write_ex` внутренне. Функции поддерживают чтение и запись данных размером более 2 ГБ. Запись данных нулевой длины больше не вызывает ошибку нарушения протокола.797798SSL-сокеты также имеют следующие дополнительные методы и атрибуты:799800#### `SSLSocket.read(len=1024, buffer=None)`801802Считывает до *len* байт данных из SSL-сокета и возвращает результат в виде экземпляра `bytes`. Если указан *buffer*, то считывает в этот буфер и возвращает количество прочитанных байт.803804Возбуждает [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError) или [`SSLWantWriteError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantWriteError), если сокет является [неблокирующим](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) и чтение заблокируется.805806Поскольку в любой момент возможна повторная переговорка, вызов `read()` также может вызвать операции записи.807808Изменено в версии 3.5: Тайм-аут сокета больше не сбрасывается каждый раз при получении или отправке байт. Теперь тайм-аут сокета – это максимальная общая продолжительность чтения до *len* байт.809810Устарело с версии 3.6: Используйте `recv()` вместо `read()`.811812#### `SSLSocket.write(data)`813814Записывает *data* в SSL-сокет и возвращает количество записанных байт. Аргумент *data* должен быть объектом, поддерживающим интерфейс буфера.815816Возбуждает [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError) или [`SSLWantWriteError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantWriteError), если сокет является [неблокирующим](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) и запись заблокируется.817818Поскольку в любой момент возможна повторная переговорка, вызов `write()` также может вызвать операции чтения.819820Изменено в версии 3.5: Тайм-аут сокета больше не сбрасывается каждый раз при получении или отправке байт. Теперь тайм-аут сокета – это максимальная общая продолжительность записи *data*.821822Устарело с версии 3.6: Используйте `send()` вместо `write()`.823824> **Примечание**825>826> Методы [`read()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.read) и [`write()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.write) – это низкоуровневые методы для чтения и записи незашифрованных данных уровня приложения и их расшифровки/зашифровки в зашифрованные данные уровня передачи. Для использования этих методов требуется активное SSL-соединение, то есть рукопожатие должно быть завершено, а [`SSLSocket.unwrap()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.unwrap) не вызывался.827>828> Обычно вместо этих методов следует использовать методы сокетного API, такие как [`recv()`](https://python-all.ru/3.13/library/socket.html#socket.socket.recv) и [`send()`](https://python-all.ru/3.13/library/socket.html#socket.socket.send).829830#### `SSLSocket.do_handshake(block=False)`831832Выполняет рукопожатие для настройки SSL.833834Если *block* равен true, а тайм-аут, полученный с помощью [`gettimeout()`](https://python-all.ru/3.13/library/socket.html#socket.socket.gettimeout), равен нулю, сокет переводится в блокирующий режим до выполнения рукопожатия.835836Изменено в версии 3.4: Метод рукопожатия также выполняет `match_hostname()`, если атрибут [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname) объекта [`context`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.context) сокета равен true.837838Изменено в версии 3.5: Тайм-аут сокета больше не сбрасывается при каждом получении или отправке байтов. Теперь тайм-аут сокета – это максимальная общая продолжительность рукопожатия.839840Изменено в версии 3.7: Имя хоста или IP-адрес теперь сопоставляется OpenSSL во время рукопожатия. Функция `match_hostname()` больше не используется. Если OpenSSL отклоняет имя хоста или IP-адрес, рукопожатие прерывается досрочно, и одноранговому узлу отправляется сообщение TLS-оповещения.841842#### `SSLSocket.getpeercert(binary_form=False)`843844Если для однорангового узла на другом конце соединения нет сертификата, возвращается `None`. Если рукопожатие SSL еще не выполнено, вызывается исключение [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError).845846Если параметр `binary_form` равен [`False`](https://python-all.ru/3.13/library/constants.html#False) и от однорангового узла получен сертификат, этот метод возвращает экземпляр [`dict`](https://python-all.ru/3.13/library/stdtypes.html#dict). Если сертификат не был проверен, словарь пуст. Если сертификат был проверен, возвращается словарь с несколькими ключами, среди которых `subject` (субъект, для которого выдан сертификат) и `issuer` (субъект, выдавший сертификат). Если сертификат содержит экземпляр расширения *Subject Alternative Name* (см. [**RFC 3280**](https://python-all.ru/3.13/library/ssl.html)), в словаре также будет ключ `subjectAltName`.847848Поля `subject` и `issuer` – это кортежи, содержащие последовательность относительных отличительных имен (RDN) в структуре данных сертификата для соответствующих полей, причем каждый RDN является последовательностью пар имя-значение. Вот реальный пример:849850```python851{'issuer': ((('countryName', 'IL'),),852 (('organizationName', 'StartCom Ltd.'),),853 (('organizationalUnitName',854 'Secure Digital Certificate Signing'),),855 (('commonName',856 'StartCom Class 2 Primary Intermediate Server CA'),)),857 'notAfter': 'Nov 22 08:15:19 2013 GMT',858 'notBefore': 'Nov 21 03:09:52 2011 GMT',859 'serialNumber': '95F0',860 'subject': ((('description', '571208-SLe257oHY9fVQ07Z'),),861 (('countryName', 'US'),),862 (('stateOrProvinceName', 'California'),),863 (('localityName', 'San Francisco'),),864 (('organizationName', 'Electronic Frontier Foundation, Inc.'),),865 (('commonName', '*.eff.org'),),866 (('emailAddress', 'hostmaster@eff.org'),)),867 'subjectAltName': (('DNS', '*.eff.org'), ('DNS', 'eff.org')),868 'version': 3}869```870871Если параметр `binary_form` равен [`True`](https://python-all.ru/3.13/library/constants.html#True) и сертификат был предоставлен, этот метод возвращает DER-кодированную форму всего сертификата в виде последовательности байтов или [`None`](https://python-all.ru/3.13/library/constants.html#None), если одноранговый узел не предоставил сертификат. Предоставляет ли одноранговый узел сертификат, зависит от роли SSL-сокета:872873- для клиентского SSL-сокета сервер всегда предоставляет сертификат, независимо от того, требовалась ли проверка;874- для серверного SSL-сокета клиент предоставляет сертификат только по запросу сервера; поэтому `getpeercert()` вернет [`None`](https://python-all.ru/3.13/library/constants.html#None), если использовался [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE) (а не [`CERT_OPTIONAL`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED)).875876См. также [`SSLContext.check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname).877878Изменено в версии 3.2: Возвращаемый словарь включает дополнительные элементы, такие как `issuer` и `notBefore`.879880Изменено в версии 3.4: Вызывается [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError), если рукопожатие не выполнено. Возвращаемый словарь включает дополнительные элементы расширений X509v3, такие как `crlDistributionPoints`, `caIssuers` и `OCSP` URI.881882Изменено в версии 3.9: Строки IPv6-адресов больше не содержат завершающего перевода строки.883884#### `SSLSocket.get_verified_chain()`885886Возвращает проверенную цепочку сертификатов, предоставленную другим концом SSL-канала, в виде списка байтов в DER-кодировке. Если проверка сертификата была отключена, метод действует так же, как [`get_unverified_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_unverified_chain).887888Добавлено в версии 3.13.889890#### `SSLSocket.get_unverified_chain()`891892Возвращает необработанную цепочку сертификатов, предоставленную другим концом SSL-канала, в виде списка байтов в DER-кодировке.893894Добавлено в версии 3.13.895896#### `SSLSocket.cipher()`897898Возвращает кортеж из трех значений: название используемого шифра, версию протокола SSL, определяющую его использование, и количество используемых секретных бит. Если соединение не установлено, возвращает `None`.899900#### `SSLSocket.shared_ciphers()`901902Возвращает список шифров, доступных как на клиенте, так и на сервере. Каждый элемент возвращаемого списка – это кортеж из трех значений: название шифра, версия протокола SSL, определяющая его использование, и количество секретных бит, используемых шифром. `shared_ciphers()` возвращает `None`, если соединение не установлено или сокет является клиентским.903904Добавлено в версии 3.5.905906#### `SSLSocket.compression()`907908Возвращает используемый алгоритм сжатия в виде строки или `None`, если соединение не сжато.909910Если протокол более высокого уровня поддерживает собственный механизм сжатия, можно использовать [`OP_NO_COMPRESSION`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_COMPRESSION) для отключения сжатия на уровне SSL.911912Добавлено в версии 3.3.913914#### `SSLSocket.get_channel_binding(cb_type='tls-unique')`915916Получает данные привязки канала для текущего соединения в виде объекта bytes. Возвращает `None`, если нет соединения или рукопожатие не завершено.917918Параметр *cb\_type* позволяет выбрать желаемый тип привязки канала. Допустимые типы привязки канала перечислены в списке [`CHANNEL_BINDING_TYPES`](https://python-all.ru/3.13/library/ssl.html#ssl.CHANNEL_BINDING_TYPES). В настоящее время поддерживается только привязка канала 'tls-unique', определяемая [**RFC 5929**](https://python-all.ru/3.13/library/ssl.html). Если запрошен неподдерживаемый тип привязки канала, будет вызвано [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError).919920Добавлено в версии 3.3.921922#### `SSLSocket.selected_alpn_protocol()`923924Возвращает протокол, выбранный во время рукопожатия TLS. Если [`SSLContext.set_alpn_protocols()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_alpn_protocols) не был вызван, другая сторона не поддерживает ALPN, этот сокет не поддерживает ни один из предложенных клиентом протоколов, или рукопожатие ещё не произошло, возвращается `None`.925926Добавлено в версии 3.5.927928#### `SSLSocket.selected_npn_protocol()`929930Возвращает протокол более высокого уровня, выбранный во время рукопожатия TLS/SSL. Если [`SSLContext.set_npn_protocols()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_npn_protocols) не был вызван, или другая сторона не поддерживает NPN, или рукопожатие ещё не произошло, возвращается `None`.931932Добавлено в версии 3.3.933934Устарело с версии 3.10: NPN заменён на ALPN935936#### `SSLSocket.unwrap()`937938Выполняет рукопожатие завершения SSL, которое удаляет слой TLS из базового сокета и возвращает объект базового сокета. Это можно использовать для перехода от зашифрованной работы по соединению к незашифрованной. Возвращённый сокет всегда следует использовать для дальнейшего обмена данными с другой стороной соединения, а не исходный сокет.939940#### `SSLSocket.verify_client_post_handshake()`941942Запрашивает аутентификацию после рукопожатия (PHA) у клиента TLS 1.3. PHA может быть инициирована только для соединения TLS 1.3 на стороне серверного сокета, после начального рукопожатия TLS и при включённой PHA на обеих сторонах; см. [`SSLContext.post_handshake_auth`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.post_handshake_auth).943944Метод не выполняет обмен сертификатами немедленно. Серверная сторона отправляет CertificateRequest во время следующего события записи и ожидает, что клиент ответит сертификатом во время следующего события чтения.945946Если какое-либо предусловие не выполнено (например, не TLS 1.3, PHA не включена), вызывается [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError).947948> **Примечание**949>950> Доступно только при наличии OpenSSL 1.1.1 и включённом TLS 1.3. Без поддержки TLS 1.3 метод вызывает [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError).951952Добавлено в версии 3.8.953954#### `SSLSocket.version()`955956Возвращает фактическую версию протокола SSL, согласованную соединением, в виде строки, или `None`, если безопасное соединение не установлено. На момент написания документации возможные возвращаемые значения включают `"SSLv2"`, `"SSLv3"`, `"TLSv1"`, `"TLSv1.1"` и `"TLSv1.2"`. Последние версии OpenSSL могут определять дополнительные возвращаемые значения.957958Добавлено в версии 3.5.959960#### `SSLSocket.pending()`961962Возвращает количество уже расшифрованных байтов, доступных для чтения, ожидающих на соединении.963964#### `SSLSocket.context`965966Объект [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext), к которому привязан этот SSL-сокет.967968Добавлено в версии 3.2.969970#### `SSLSocket.server_side`971972Логическое значение, равное `True` для серверных сокетов и `False` для клиентских сокетов.973974Добавлено в версии 3.2.975976#### `SSLSocket.server_hostname`977978Имя хоста сервера: тип [`str`](https://python-all.ru/3.13/library/stdtypes.html#str), или `None` для серверного сокета, или если имя хоста не было указано в конструкторе.979980Добавлено в версии 3.2.981982Изменено в версии 3.7: Атрибут теперь всегда является текстом ASCII. Если `server_hostname` является интернационализированным доменным именем (IDN), этот атрибут теперь хранит форму A-label (`"xn--pythn-mua.org"`), а не форму U-label (`"pythön.org"`).983984#### `SSLSocket.session`985986[`SSLSession`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSession) для этого SSL-соединения. Сессия доступна для клиентских и серверных сокетов после выполнения рукопожатия TLS. Для клиентских сокетов сессия может быть установлена до вызова [`do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake), чтобы повторно использовать сессию.987988Добавлено в версии 3.6.989990#### `SSLSocket.session_reused`991992Добавлено в версии 3.6.993994## Контексты SSL995996Добавлено в версии 3.2.997998Контекст SSL хранит различные данные, которые живут дольше, чем отдельные SSL-соединения, такие как параметры конфигурации SSL, сертификат(ы) и закрытый(е) ключ(и). Он также управляет кешем SSL-сессий для серверных сокетов, чтобы ускорить повторные подключения от одних и тех же клиентов.9991000#### `class ssl.SSLContext(protocol=None)`10011002Создаёт новый контекст SSL. Можно передать *протокол*, который должен быть одной из констант `PROTOCOL_*`, определённых в этом модуле. Параметр указывает, какую версию протокола SSL использовать. Обычно сервер выбирает конкретную версию протокола, а клиент должен подстраиваться под выбор сервера. Большинство версий несовместимы с другими версиями. Если параметр не указан, по умолчанию используется [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS); он обеспечивает наибольшую совместимость с другими версиями.10031004Ниже приведена таблица, показывающая, какие версии на стороне клиента (по вертикали) могут подключаться к каким версиям на стороне сервера (по горизонтали):10051006| *клиент* / **сервер** | **SSLv2** | **SSLv3** | **TLS** [\[3\]](https://python-all.ru/3.13/library/ssl.html#id9) | **TLSv1** | **TLSv1.1** | **TLSv1.2** |1007| --- | --- | --- | --- | --- | --- | --- |1008| *SSLv2* | да | нет | нет [\[1\]](https://python-all.ru/3.13/library/ssl.html#id7) | нет | нет | нет |1009| *SSLv3* | нет | да | нет [\[2\]](https://python-all.ru/3.13/library/ssl.html#id8) | нет | нет | нет |1010| *TLS* (*SSLv23*) [\[3\]](https://python-all.ru/3.13/library/ssl.html#id9) | нет [\[1\]](https://python-all.ru/3.13/library/ssl.html#id7) | нет [\[2\]](https://python-all.ru/3.13/library/ssl.html#id8) | да | да | да | да |1011| *TLSv1* | нет | нет | да | да | нет | нет |1012| *TLSv1.1* | нет | нет | да | нет | да | нет |1013| *TLSv1.2* | нет | нет | да | нет | нет | да |10141015Сноски10161017\[1\]10181019([1](https://python-all.ru/3.13/library/ssl.html#id2),[2](https://python-all.ru/3.13/library/ssl.html#id5))10201021`SSLContext` по умолчанию отключает SSLv2 с помощью [`OP_NO_SSLv2`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv2).10221023\[2\]10241025([1](https://python-all.ru/3.13/library/ssl.html#id3),[2](https://python-all.ru/3.13/library/ssl.html#id6))10261027`SSLContext` по умолчанию отключает SSLv3 с помощью [`OP_NO_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv3).10281029\[3\]10301031([1](https://python-all.ru/3.13/library/ssl.html#id1),[2](https://python-all.ru/3.13/library/ssl.html#id4))10321033Протокол TLS 1.3 будет доступен с [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS) в OpenSSL \>= 1.1.1. Для одного только TLS 1.3 не существует отдельной константы PROTOCOL.10341035> **См. также**1036>1037> [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context) позволяет модулю `ssl` выбирать настройки безопасности для заданной цели.10381039Изменено в версии 3.6: Контекст создаётся с безопасными значениями по умолчанию. По умолчанию устанавливаются опции [`OP_NO_COMPRESSION`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_COMPRESSION), [`OP_CIPHER_SERVER_PREFERENCE`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_CIPHER_SERVER_PREFERENCE), [`OP_SINGLE_DH_USE`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_SINGLE_DH_USE), [`OP_SINGLE_ECDH_USE`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_SINGLE_ECDH_USE), [`OP_NO_SSLv2`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv2), и [`OP_NO_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv3) (за исключением [`PROTOCOL_SSLv3`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_SSLv3)). Исходный список наборов шифров содержит только шифры `HIGH`, не содержит шифров `NULL` и `MD5`.10401041Устарело с версии 3.10: Вызов `SSLContext` без аргумента protocol устарел. В будущем класс контекста будет требовать протокол [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) или [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER).10421043Изменено в версии 3.10: Наборы шифров по умолчанию теперь включают только безопасные шифры AES и ChaCha20 с прямой секретностью и уровнем безопасности 2. Ключи RSA и DH с длиной менее 2048 бит и ключи ECC с длиной менее 224 бит запрещены. [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS), [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) и [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER) используют TLS 1.2 как минимальную версию TLS.10441045> **Примечание**1046>1047> `SSLContext` поддерживает только ограниченную модификацию после того, как был использован соединением. Добавление новых сертификатов во внутреннее хранилище доверенных сертификатов разрешено, но изменение шифров, параметров проверки или сертификатов mTLS может привести к неожиданному поведению.10481049> **Примечание**1050>1051> `SSLContext` предназначен для совместного использования несколькими соединениями. Таким образом, он потокобезопасен, если не перенастраивается после того, как был использован соединением.10521053Объекты [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) имеют следующие методы и атрибуты:10541055#### `SSLContext.cert_store_stats()`10561057Возвращает словарь со статистикой о количестве загруженных X.509 сертификатов, количестве сертификатов X.509, помеченных как сертификаты CA, и списках отзыва сертификатов.10581059Пример для контекста с одним сертификатом CA и одним другим сертификатом:10601061```python1062>>> context.cert_store_stats()1063{'crl': 0, 'x509_ca': 1, 'x509': 2}1064```10651066Добавлено в версии 3.4.10671068#### `SSLContext.load_cert_chain(certfile, keyfile=None, password=None)`10691070Загружает закрытый ключ и соответствующий сертификат. Строка *certfile* должна быть путём к одному файлу в формате PEM, содержащему сертификат, а также любое количество сертификатов CA, необходимых для установления подлинности сертификата. Строка *keyfile*, если присутствует, должна указывать на файл, содержащий закрытый ключ. В противном случае закрытый ключ также будет взят из *certfile*. См. обсуждение [Сертификаты](https://python-all.ru/3.13/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как сертификат хранится в *certfile*.10711072Аргумент *password* может быть функцией, вызываемой для получения пароля для расшифровки закрытого ключа. Она будет вызвана только в том случае, если закрытый ключ зашифрован и требуется пароль. Она будет вызвана без аргументов, и должна возвращать строку, bytes или bytearray. Если возвращаемое значение – строка, она будет закодирована в UTF-8 перед использованием для расшифровки ключа. В качестве альтернативы, строка, bytes или bytearray могут быть переданы напрямую в качестве аргумента *password*. Этот аргумент будет проигнорирован, если закрытый ключ не зашифрован и пароль не требуется.10731074Если аргумент *password* не указан и требуется пароль, будет использован встроенный механизм запроса пароля OpenSSL для интерактивного запроса пароля у пользователя.10751076Вызывается исключение [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError), если закрытый ключ не соответствует сертификату.10771078Изменено в версии 3.3: Новый необязательный аргумент *password*.10791080#### `SSLContext.load_default_certs(purpose=Purpose.SERVER_AUTH)`10811082Загружает набор стандартных сертификатов "центров сертификации" (CA) из стандартных расположений. В Windows загружает сертификаты CA из системных хранилищ `CA` и `ROOT`. На всех системах вызывает [`SSLContext.set_default_verify_paths()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_default_verify_paths). В будущем метод может также загружать сертификаты CA из других расположений.10831084Флаг *purpose* определяет, какие именно сертификаты CA загружаются. Настройка по умолчанию [`Purpose.SERVER_AUTH`](https://python-all.ru/3.13/library/ssl.html#ssl.Purpose.SERVER_AUTH) загружает сертификаты, помеченные и доверенные для аутентификации TLS веб-сервера (клиентские сокеты). [`Purpose.CLIENT_AUTH`](https://python-all.ru/3.13/library/ssl.html#ssl.Purpose.CLIENT_AUTH) загружает сертификаты CA для проверки сертификата клиента на стороне сервера.10851086Добавлено в версии 3.4.10871088#### `SSLContext.load_verify_locations(cafile=None, capath=None, cadata=None)`10891090Загружает набор сертификатов "центров сертификации" (CA), используемых для проверки сертификатов других узлов, когда [`verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) отличается от [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE). Должен быть указан хотя бы один из параметров *cafile* или *capath*.10911092Этот метод также может загружать списки отзыва сертификатов (CRL) в формате PEM или DER. Чтобы использовать CRL, необходимо правильно настроить [`SSLContext.verify_flags`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_flags).10931094Строка *cafile*, если присутствует, содержит путь к файлу, содержащему объединённые сертификаты CA в формате PEM. См. обсуждение [Сертификаты](https://python-all.ru/3.13/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как организовать сертификаты в этом файле.10951096Строка *capath*, если присутствует, задаёт путь к каталогу, содержащему несколько сертификатов CA в формате PEM, согласно [специфической структуре OpenSSL](https://python-all.ru/3.13/library/ssl.html).10971098Объект *cadata*, если присутствует, представляет собой либо ASCII-строку с одним или несколькими сертификатами в кодировке PEM, либо [байтоподобный объект](https://python-all.ru/3.13/glossary.html#term-bytes-like-object) с сертификатами в кодировке DER. Как и в случае с *capath*, дополнительные строки вокруг сертификатов в кодировке PEM игнорируются, но должен присутствовать хотя бы один сертификат.10991100Изменено в версии 3.4: Новый необязательный аргумент *cadata*11011102#### `SSLContext.get_ca_certs(binary_form=False)`11031104Возвращает список загруженных сертификатов “certification authority” (CA). Если параметр `binary_form` равен [`False`](https://python-all.ru/3.13/library/constants.html#False), каждый элемент списка представляет собой словарь, аналогичный выводу [`SSLSocket.getpeercert()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.getpeercert). В противном случае метод возвращает список сертификатов в формате DER. Возвращаемый список не содержит сертификаты из *capath*, если только сертификат не был запрошен и загружен через SSL-соединение.11051106> **Примечание**1107>1108> Сертификаты в каталоге capath не загружаются, пока не будут использованы хотя бы один раз.11091110Добавлено в версии 3.4.11111112#### `SSLContext.get_ciphers()`11131114Возвращает список включённых шифров. Список упорядочен по приоритету шифров. См. [`SSLContext.set_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_ciphers).11151116Пример:11171118```python1119>>> ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)1120>>> ctx.set_ciphers('ECDHE+AESGCM:!ECDSA')1121>>> ctx.get_ciphers()1122[{'aead': True,1123 'alg_bits': 256,1124 'auth': 'auth-rsa',1125 'description': 'ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH Au=RSA '1126 'Enc=AESGCM(256) Mac=AEAD',1127 'digest': None,1128 'id': 50380848,1129 'kea': 'kx-ecdhe',1130 'name': 'ECDHE-RSA-AES256-GCM-SHA384',1131 'protocol': 'TLSv1.2',1132 'strength_bits': 256,1133 'symmetric': 'aes-256-gcm'},1134 {'aead': True,1135 'alg_bits': 128,1136 'auth': 'auth-rsa',1137 'description': 'ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH Au=RSA '1138 'Enc=AESGCM(128) Mac=AEAD',1139 'digest': None,1140 'id': 50380847,1141 'kea': 'kx-ecdhe',1142 'name': 'ECDHE-RSA-AES128-GCM-SHA256',1143 'protocol': 'TLSv1.2',1144 'strength_bits': 128,1145 'symmetric': 'aes-128-gcm'}]1146```11471148Добавлено в версии 3.6.11491150#### `SSLContext.set_default_verify_paths()`11511152Загружает набор сертификатов по умолчанию “certification authority” (CA) из пути файловой системы, заданного при сборке библиотеки OpenSSL. К сожалению, нет простого способа узнать, успешно ли выполняется этот метод: ошибка не возвращается, если сертификаты не найдены. Однако, если библиотека OpenSSL поставляется как часть операционной системы, она, скорее всего, настроена правильно.11531154#### `SSLContext.set_ciphers(ciphers, /)`11551156Устанавливает доступные шифры для сокетов, создаваемых с этим контекстом. Значение должно быть строкой в [формате списка шифров OpenSSL](https://python-all.ru/3.13/library/ssl.html). Если ни один шифр не может быть выбран (из-за опций компиляции или других настроек, запрещающих использование всех указанных шифров), будет вызвано исключение [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError).11571158> **Примечание**1159>1160> при подключении метод [`SSLSocket.cipher()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.cipher) SSL-сокетов вернёт текущий выбранный шифр.1161>1162> Наборы шифров TLS 1.3 нельзя отключить с помощью `set_ciphers()`.11631164#### `SSLContext.set_alpn_protocols(alpn_protocols)`11651166Определяет, какие протоколы сокет должен объявлять во время рукопожатия SSL/TLS. Это должен быть список строк ASCII, например `['http/1.1', 'spdy/2']`, упорядоченных по предпочтению. Выбор протокола происходит во время рукопожатия и выполняется в соответствии с [**RFC 7301**](https://python-all.ru/3.13/library/ssl.html). После успешного рукопожатия метод [`SSLSocket.selected_alpn_protocol()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol) вернёт согласованный протокол.11671168Этот метод вызовет [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError), если [`HAS_ALPN`](https://python-all.ru/3.13/library/ssl.html#ssl.HAS_ALPN) равно `False`.11691170Добавлено в версии 3.5.11711172#### `SSLContext.set_npn_protocols(npn_protocols)`11731174Определяет, какие протоколы сокет должен объявлять во время рукопожатия SSL/TLS. Это должен быть список строк, например `['http/1.1', 'spdy/2']`, упорядоченный по предпочтению. Выбор протокола происходит во время рукопожатия и выполняется в соответствии с [Согласованием протокола прикладного уровня](https://python-all.ru/3.13/library/ssl.html) (Application Layer Protocol Negotiation). После успешного рукопожатия метод [`SSLSocket.selected_npn_protocol()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.selected_npn_protocol) вернёт согласованный протокол.11751176Этот метод вызовет [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError), если [`HAS_NPN`](https://python-all.ru/3.13/library/ssl.html#ssl.HAS_NPN) равно `False`.11771178Добавлено в версии 3.3.11791180Устарело с версии 3.10: NPN заменён на ALPN11811182#### `SSLContext.sni_callback`11831184Регистрирует функцию обратного вызова, которая будет вызвана после получения сервером SSL/TLS сообщения TLS Client Hello, когда клиент TLS указывает индикацию имени сервера. Механизм индикации имени сервера описан в [**RFC 6066**](https://python-all.ru/3.13/library/ssl.html) раздел 3 – Server Name Indication.11851186Для каждого `SSLContext` можно установить только один колбэк. Если *sni\_callback* установлено в `None`, колбэк отключается. Повторный вызов этой функции отключит ранее зарегистрированный колбэк.11871188Функция обратного вызова будет вызвана с тремя аргументами: первый – [`ssl.SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket), второй – строка, представляющая имя сервера, с которым клиент намерен установить соединение (или [`None`](https://python-all.ru/3.13/library/constants.html#None), если TLS Client Hello не содержит имя сервера), и третий аргумент – исходный [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext). Аргумент имени сервера является текстовым. Для интернационализированных доменных имён имя сервера представляет собой IDN A-метку (`"xn--pythn-mua.org"`).11891190Типичное использование этого колбэка – изменить атрибут [`SSLSocket.context`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.context) объекта [`ssl.SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) на новый объект типа [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext), представляющий цепочку сертификатов, соответствующую имени сервера.11911192Из-за ранней фазы согласования TLS-соединения доступны только ограниченные методы и атрибуты, такие как [`SSLSocket.selected_alpn_protocol()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol) и [`SSLSocket.context`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.context). Методы [`SSLSocket.getpeercert()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.getpeercert), [`SSLSocket.get_verified_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_verified_chain), [`SSLSocket.get_unverified_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_unverified_chain) [`SSLSocket.cipher()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.cipher) и [`SSLSocket.compression()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.compression) требуют, чтобы TLS-соединение продвинулось дальше TLS Client Hello, и поэтому не вернут значимых значений, и их нельзя безопасно вызывать.11931194Функция *sni\_callback* должна возвращать `None`, чтобы позволить продолжить согласование TLS. Если требуется ошибка TLS, можно вернуть константу [`ALERT_DESCRIPTION_*`](https://python-all.ru/3.13/library/ssl.html#ssl.ALERT_DESCRIPTION_INTERNAL_ERROR). Другие возвращаемые значения приведут к фатальной ошибке TLS с `ALERT_DESCRIPTION_INTERNAL_ERROR`.11951196Если из функции *sni\_callback* будет вызвано исключение, TLS-соединение будет завершено с фатальным предупреждением TLS [`ALERT_DESCRIPTION_HANDSHAKE_FAILURE`](https://python-all.ru/3.13/library/ssl.html#ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE).11971198Этот метод вызовет исключение [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError), если библиотека OpenSSL была собрана с определённым OPENSSL\_NO\_TLSEXT.11991200Добавлено в версии 3.7.12011202#### `SSLContext.set_servername_callback(server_name_callback)`12031204Это устаревший API, сохранённый для обратной совместимости. По возможности следует использовать [`sni_callback`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.sni_callback). Заданный *server\_name\_callback* похож на *sni\_callback*, за исключением того, что когда имя хоста сервера является интернационализированным доменным именем в кодировке IDN, *server\_name\_callback* получает декодированную U-метку (`"pythön.org"`).12051206Если при декодировании имени сервера произошла ошибка, TLS-соединение будет завершено с фатальным предупреждением TLS [`ALERT_DESCRIPTION_INTERNAL_ERROR`](https://python-all.ru/3.13/library/ssl.html#ssl.ALERT_DESCRIPTION_INTERNAL_ERROR) клиенту.12071208Добавлено в версии 3.4.12091210#### `SSLContext.load_dh_params(dhfile, /)`12111212Загружает параметры генерации ключей для обмена ключами Диффи-Хеллмана (DH). Использование обмена ключами DH улучшает прямую секретность ценой вычислительных ресурсов (как на сервере, так и на клиенте). Параметр *dhfile* должен указывать путь к файлу, содержащему параметры DH в формате PEM.12131214Этот параметр не применяется к клиентским сокетам. Также можно использовать опцию [`OP_SINGLE_DH_USE`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_SINGLE_DH_USE) для дальнейшего повышения безопасности.12151216Добавлено в версии 3.3.12171218#### `SSLContext.set_ecdh_curve(curve_name, /)`12191220Устанавливает имя кривой для обмена ключами на основе эллиптических кривых (ECDH). ECDH значительно быстрее обычного DH, при этом, возможно, столь же безопасен. Параметр *curve\_name* должен быть строкой, описывающей известную эллиптическую кривую, например `prime256v1` для широко поддерживаемой кривой.12211222Этот параметр не применяется к клиентским сокетам. Также можно использовать опцию [`OP_SINGLE_ECDH_USE`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_SINGLE_ECDH_USE) для дальнейшего повышения безопасности.12231224Этот метод недоступен, если [`HAS_ECDH`](https://python-all.ru/3.13/library/ssl.html#ssl.HAS_ECDH) имеет значение `False`.12251226Добавлено в версии 3.3.12271228> **См. также**1229>1230> **[SSL/TLS и совершенная прямая секретность](https://python-all.ru/3.13/library/ssl.html)**1231>1232> Vincent Bernat.12331234#### `SSLContext.wrap_socket(sock, server_side=False, do_handshake_on_connect=True, suppress_ragged_eofs=True, server_hostname=None, session=None)`12351236Оборачивает существующий сокет Python *sock* и возвращает экземпляр [`SSLContext.sslsocket_class`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.sslsocket_class) (по умолчанию [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket)). Возвращаемый SSL-сокет привязан к контексту, его настройкам и сертификатам. *sock* должен быть сокетом [`SOCK_STREAM`](https://python-all.ru/3.13/library/socket.html#socket.SOCK_STREAM); другие типы сокетов не поддерживаются.12371238Параметр `server_side` – это логическое значение, указывающее, требуется ли поведение серверной или клиентской стороны для этого сокета.12391240Для клиентских сокетов построение контекста выполняется лениво; если базовый сокет ещё не подключён, построение контекста будет выполнено после вызова `connect()` на сокете. Для серверных сокетов, если у сокета нет удалённого узла, считается, что это слушающий сокет, и SSL-обёртка на стороне сервера автоматически выполняется для клиентских подключений, принятых через метод `accept()`. Метод может возбудить исключение [`SSLError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLError).12411242Для клиентских подключений необязательный параметр *server\_hostname* задаёт имя хоста службы, к которой выполняется подключение. Это позволяет одному серверу размещать несколько SSL-служб с разными сертификатами, аналогично виртуальным хостам HTTP. Указание *server\_hostname* вызовет исключение [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError), если *server\_side* равно true.12431244Параметр `do_handshake_on_connect` определяет, следует ли выполнять рукопожатие SSL автоматически после `socket.connect()`, или же прикладная программа будет вызывать его явно с помощью метода [`SSLSocket.do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake). Явный вызов `SSLSocket.do_handshake()` даёт программе контроль над блокирующим поведением ввода-вывода сокета, участвующего в рукопожатии.12451246Параметр `suppress_ragged_eofs` определяет, как метод `SSLSocket.recv()` должен сигнализировать о неожиданном EOF от другого конца соединения. Если задано значение [`True`](https://python-all.ru/3.13/library/constants.html#True) (по умолчанию), он возвращает обычный EOF (пустой объект bytes) в ответ на ошибки неожиданного EOF, возникшие в базовом сокете; если [`False`](https://python-all.ru/3.13/library/constants.html#False), то исключения будут переданы обратно вызывающему коду.12471248*session*, см. [`session`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.session).12491250Чтобы обернуть [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) в другой `SSLSocket`, используйте [`SSLContext.wrap_bio()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_bio).12511252Изменено в версии 3.5: Всегда разрешается передавать server\_hostname, даже если OpenSSL не поддерживает SNI.12531254Изменено в версии 3.6: Добавлен аргумент *session*.12551256Изменено в версии 3.7: Метод возвращает экземпляр [`SSLContext.sslsocket_class`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.sslsocket_class) вместо жёстко заданного [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket).12571258#### `SSLContext.sslsocket_class`12591260Возвращаемый тип [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket), по умолчанию [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket). Этому атрибуту можно присвоить значение на экземплярах [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext), чтобы возвращать пользовательский подкласс `SSLSocket`.12611262Добавлено в версии 3.7.12631264#### `SSLContext.wrap_bio(incoming, outgoing, server_side=False, server_hostname=None, session=None)`12651266Оборачивает объекты BIO *incoming* и *outgoing* и возвращает экземпляр [`SSLContext.sslobject_class`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.sslobject_class) (по умолчанию [`SSLObject`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLObject)). Процедуры SSL будут читать входные данные из входящего BIO и записывать данные в исходящий BIO.12671268Параметры *server\_side*, *server\_hostname* и *session* имеют тот же смысл, что и в [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket).12691270Изменено в версии 3.6: Добавлен аргумент *session*.12711272Изменено в версии 3.7: Метод возвращает экземпляр [`SSLContext.sslobject_class`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.sslobject_class) вместо жёстко заданного [`SSLObject`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLObject).12731274#### `SSLContext.sslobject_class`12751276Возвращаемый тип [`SSLContext.wrap_bio()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_bio), по умолчанию [`SSLObject`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLObject). Атрибут можно переопределить на экземпляре класса, чтобы возвращать пользовательский подкласс `SSLObject`.12771278Добавлено в версии 3.7.12791280#### `SSLContext.session_stats()`12811282Получает статистику о сеансах SSL, созданных или управляемых этим контекстом. Возвращается словарь, который сопоставляет названия каждого [фрагмента информации](https://python-all.ru/3.13/library/ssl.html) с их числовыми значениями. Например, вот общее количество попаданий и промахов в кэше сеансов с момента создания контекста:12831284```python1285>>> stats = context.session_stats()1286>>> stats['hits'], stats['misses']1287(0, 0)1288```12891290#### `SSLContext.check_hostname`12911292Определяет, нужно ли проверять hostname в сертификате однорангового узла в [`SSLSocket.do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake). Атрибут [`verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) контекста должен быть установлен в [`CERT_OPTIONAL`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED), а для проверки hostname необходимо передать *server\_hostname* в [`wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket). Включение проверки hostname автоматически меняет `verify_mode` с [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE) на `CERT_REQUIRED`. Его нельзя вернуть обратно на `CERT_NONE`, пока проверка hostname включена. Протокол [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) включает проверку hostname по умолчанию. Для остальных протоколов проверку hostname нужно включать явно.12931294Пример:12951296```python1297import socket, ssl12981299context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)1300context.verify_mode = ssl.CERT_REQUIRED1301context.check_hostname = True1302context.load_default_certs()13031304s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)1305ssl_sock = context.wrap_socket(s, server_hostname='www.verisign.com')1306ssl_sock.connect(('www.verisign.com', 443))1307```13081309Добавлено в версии 3.4.13101311Изменено в версии 3.7: [`verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) теперь автоматически меняется на [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED), когда включена проверка hostname, а `verify_mode` равен [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE). Раньше та же операция завершилась бы с ошибкой [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError).13121313#### `SSLContext.keylog_filename`13141315Записывает ключи TLS в файл журнала ключей каждый раз, когда генерируется или принимается ключевой материал. Файл журнала предназначен только для отладки. Формат файла определён NSS и используется многими анализаторами трафика, такими как Wireshark. Файл открывается в режиме только добавления. Записи синхронизируются между потоками, но не между процессами.13161317Добавлено в версии 3.8.13181319#### `SSLContext.maximum_version`13201321Элемент перечисления [`TLSVersion`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion), представляющий самую высокую поддерживаемую версию TLS. Значение по умолчанию – [`TLSVersion.MAXIMUM_SUPPORTED`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion.MAXIMUM_SUPPORTED). Атрибут доступен только для чтения для протоколов, отличных от [`PROTOCOL_TLS`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS), [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) и [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER).13221323Атрибуты `maximum_version`, [`minimum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.minimum_version) и [`SSLContext.options`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.options) влияют на поддерживаемые версии SSL и TLS контекста. Реализация не предотвращает недопустимые комбинации. Например, контекст с [`OP_NO_TLSv1_2`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_TLSv1_2) в `options` и `maximum_version`, установленным в [`TLSVersion.TLSv1_2`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion.TLSv1_2), не сможет установить соединение TLS 1.2.13241325Добавлено в версии 3.7.13261327#### `SSLContext.minimum_version`13281329Аналогично [`SSLContext.maximum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.maximum_version), но задаёт самую низкую поддерживаемую версию или [`TLSVersion.MINIMUM_SUPPORTED`](https://python-all.ru/3.13/library/ssl.html#ssl.TLSVersion.MINIMUM_SUPPORTED).13301331Добавлено в версии 3.7.13321333#### `SSLContext.num_tickets`13341335Управляет количеством сессионных билетов TLS 1.3 для контекста [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER). Настройка не влияет на соединения TLS 1.0–1.2.13361337Добавлено в версии 3.8.13381339#### `SSLContext.options`13401341Целое число, представляющее набор опций SSL, включённых в этом контексте. Значение по умолчанию – [`OP_ALL`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_ALL), но можно указать другие опции, например [`OP_NO_SSLv2`](https://python-all.ru/3.13/library/ssl.html#ssl.OP_NO_SSLv2), комбинируя их с помощью OR.13421343Изменено в версии 3.6: `SSLContext.options` возвращает флаги [`Options`](https://python-all.ru/3.13/library/ssl.html#ssl.Options):13441345```python1346>>> ssl.create_default_context().options1347<Options.OP_ALL|OP_NO_SSLv3|OP_NO_SSLv2|OP_NO_COMPRESSION: 2197947391>1348```13491350Устарело с версии 3.7: Все опции `OP_NO_SSL*` и `OP_NO_TLS*` устарели начиная с Python 3.7. Используйте вместо них [`SSLContext.minimum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.minimum_version) и [`SSLContext.maximum_version`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.maximum_version).13511352#### `SSLContext.post_handshake_auth`13531354Включает аутентификацию клиента после рукопожатия TLS 1.3. По умолчанию аутентификация после рукопожатия отключена, и сервер может запрашивать TLS-сертификат клиента только во время начального рукопожатия. При включении сервер может запрашивать сертификат клиента в любое время после рукопожатия.13551356При включении на клиентских сокетах клиент сообщает серверу, что он поддерживает аутентификацию после рукопожатия.13571358При включении на серверных сокетах [`SSLContext.verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) также должен быть установлен в [`CERT_OPTIONAL`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED). Фактический обмен сертификатами клиента откладывается до вызова [`SSLSocket.verify_client_post_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.verify_client_post_handshake) и выполнения некоторого ввода-вывода.13591360Добавлено в версии 3.8.13611362#### `SSLContext.protocol`13631364Версия протокола, выбранная при создании контекста. Этот атрибут доступен только для чтения.13651366#### `SSLContext.hostname_checks_common_name`13671368Определяет, будет ли [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname) проверять общее имя (common name) субъекта сертификата при отсутствии расширения subject alternative name (по умолчанию: true).13691370Добавлено в версии 3.7.13711372Изменено в версии 3.10: Этот флаг не действовал в OpenSSL версий ниже 1.1.1l. Python 3.8.9, 3.9.3 и 3.10 содержат обходные пути для предыдущих версий.13731374#### `SSLContext.security_level`13751376Целое число, представляющее [уровень безопасности](https://python-all.ru/3.13/library/ssl.html) для контекста. Этот атрибут доступен только для чтения.13771378Добавлено в версии 3.10.13791380#### `SSLContext.verify_flags`13811382Флаги для операций проверки сертификатов. Можно устанавливать такие флаги, как [`VERIFY_CRL_CHECK_LEAF`](https://python-all.ru/3.13/library/ssl.html#ssl.VERIFY_CRL_CHECK_LEAF), комбинируя их с помощью OR. По умолчанию OpenSSL не требует и не проверяет списки отзыва сертификатов (CRL).13831384Добавлено в версии 3.4.13851386Изменено в версии 3.6: `SSLContext.verify_flags` возвращает флаги [`VerifyFlags`](https://python-all.ru/3.13/library/ssl.html#ssl.VerifyFlags):13871388```python1389>>> ssl.create_default_context().verify_flags1390<VerifyFlags.VERIFY_X509_TRUSTED_FIRST: 32768>1391```13921393#### `SSLContext.verify_mode`13941395Определяет, следует ли проверять сертификаты других одноранговых узлов и как вести себя при неудачной проверке. Значение атрибута должно быть одним из [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE), [`CERT_OPTIONAL`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED).13961397Изменено в версии 3.6: `SSLContext.verify_mode` возвращает перечисление [`VerifyMode`](https://python-all.ru/3.13/library/ssl.html#ssl.VerifyMode):13981399```python1400>>> ssl.create_default_context().verify_mode1401<VerifyMode.CERT_REQUIRED: 2>1402```14031404#### `SSLContext.set_psk_client_callback(callback)`14051406Включает аутентификацию TLS-PSK (предварительный общий ключ) на стороне клиента.14071408В целом аутентификация на основе сертификатов предпочтительнее этого метода.14091410The parameter `callback` is a callable object with the signature: `def callback(hint: str | None) -> tuple[str | None, bytes]`. The `hint` parameter is an optional identity hint sent by the server. The return value is a tuple in the form (client-identity, psk). Client-identity is an optional string which may be used by the server to select a corresponding PSK for the client. The string must be less than or equal to `256` octets when UTF-8 encoded. PSK is a [bytes-like object](https://python-all.ru/3.13/glossary.html#term-bytes-like-object) representing the pre-shared key. Return a zero length PSK to reject the connection.14111412Установка `callback` в [`None`](https://python-all.ru/3.13/library/constants.html#None) удаляет существующий колбэк.14131414> **Примечание**1415>1416> При использовании TLS 1.3:1417>1418> - параметр `hint` всегда равен [`None`](https://python-all.ru/3.13/library/constants.html#None).1419> - client-identity должна быть непустой строкой.14201421Пример использования:14221423```python1424context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)1425context.check_hostname = False1426context.verify_mode = ssl.CERT_NONE1427context.maximum_version = ssl.TLSVersion.TLSv1_21428context.set_ciphers('PSK')14291430# Простая лямбда:1431psk = bytes.fromhex('c0ffee')1432context.set_psk_client_callback(lambda hint: (None, psk))14331434# Таблица с использованием подсказки от сервера:1435psk_table = { 'ServerId_1': bytes.fromhex('c0ffee'),1436 'ServerId_2': bytes.fromhex('facade')1437}1438def callback(hint):1439 return 'ClientId_1', psk_table.get(hint, b'')1440context.set_psk_client_callback(callback)1441```14421443Этот метод вызовет [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError), если [`HAS_PSK`](https://python-all.ru/3.13/library/ssl.html#ssl.HAS_PSK) равно `False`.14441445Добавлено в версии 3.13.14461447#### `SSLContext.set_psk_server_callback(callback, identity_hint=None)`14481449Включает аутентификацию TLS-PSK (предварительный общий ключ) на стороне сервера.14501451В целом аутентификация на основе сертификатов предпочтительнее этого метода.14521453The parameter `callback` is a callable object with the signature: `def callback(identity: str | None) -> bytes`. The `identity` parameter is an optional identity sent by the client which can be used to select a corresponding PSK. The return value is a [bytes-like object](https://python-all.ru/3.13/glossary.html#term-bytes-like-object) representing the pre-shared key. Return a zero length PSK to reject the connection.14541455Установка `callback` в [`None`](https://python-all.ru/3.13/library/constants.html#None) удаляет существующий колбэк.14561457Параметр `identity_hint` – необязательная строка подсказки идентификатора, отправляемая клиенту. Строка должна быть не длиннее `256` октетов при кодировке UTF-8.14581459> **Примечание**1460>1461> При использовании TLS 1.3 параметр `identity_hint` не отправляется клиенту.14621463Пример использования:14641465```python1466context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)1467context.maximum_version = ssl.TLSVersion.TLSv1_21468context.set_ciphers('PSK')14691470# Простая лямбда:1471psk = bytes.fromhex('c0ffee')1472context.set_psk_server_callback(lambda identity: psk)14731474# Таблица с использованием идентификатора клиента:1475psk_table = { 'ClientId_1': bytes.fromhex('c0ffee'),1476 'ClientId_2': bytes.fromhex('facade')1477}1478def callback(identity):1479 return psk_table.get(identity, b'')1480context.set_psk_server_callback(callback, 'ServerId_1')1481```14821483Этот метод вызовет [`NotImplementedError`](https://python-all.ru/3.13/library/exceptions.html#NotImplementedError), если [`HAS_PSK`](https://python-all.ru/3.13/library/ssl.html#ssl.HAS_PSK) равно `False`.14841485Добавлено в версии 3.13.14861487## Сертификаты14881489Сертификаты в целом являются частью системы открытых и закрытых ключей. В этой системе каждому *субъекту* (которым может быть машина, человек или организация) присваивается уникальный двухчастный ключ шифрования. Одна часть ключа является открытой и называется *открытым ключом*; другая часть хранится в секрете и называется *закрытым ключом*. Две части связаны так, что если зашифровать сообщение одной частью, его можно расшифровать только другой частью, и **только** другой частью.14901491Сертификат содержит информацию о двух субъектах. Он содержит имя *субъекта* и его открытый ключ. Также он содержит заявление второго субъекта – *эмитента*, о том, что субъект является тем, за кого себя выдаёт, и что это действительно его открытый ключ. Заявление эмитента подписано закрытым ключом эмитента, который знает только эмитент. Однако любой может проверить заявление эмитента, найдя его открытый ключ, расшифровав им заявление и сравнив его с другой информацией в сертификате. Сертификат также содержит информацию о периоде времени, в течение которого он действителен. Это выражается двумя полями, называемыми «notBefore» и «notAfter».14921493При использовании сертификатов в Python клиент или сервер может использовать сертификат для подтверждения своей личности. Другая сторона сетевого соединения также может быть обязана предоставить сертификат, и этот сертификат может быть проверен к удовлетворению клиента или сервера, требующего такой проверки. Можно настроить попытку соединения так, чтобы она вызывала исключение, если проверка не удалась. Проверка выполняется автоматически базовым фреймворком OpenSSL; приложению не нужно вникать в её механику. Но приложению обычно необходимо предоставить наборы сертификатов, чтобы этот процесс мог происходить.14941495Python uses files to contain certificates. They should be formatted as “PEM” (see [**RFC 1422**](https://python-all.ru/3.13/library/ssl.html)), which is a base-64 encoded form wrapped with a header line and a footer line:14961497```python1498-----BEGIN CERTIFICATE-----1499... (certificate in base64 PEM encoding) ...1500-----END CERTIFICATE-----1501```15021503### Цепочки сертификатов15041505The Python files which contain certificates can contain a sequence of certificates, sometimes called a *certificate chain*. This chain should start with the specific certificate for the principal who “is” the client or server, and then the certificate for the issuer of that certificate, and then the certificate for the issuer of *that* certificate, and so on up the chain till you get to a certificate which is *self-signed*, that is, a certificate which has the same subject and issuer, sometimes called a *root certificate*. The certificates should just be concatenated together in the certificate file. For example, suppose we had a three certificate chain, from our server certificate to the certificate of the certification authority that signed our server certificate, to the root certificate of the agency which issued the certification authority’s certificate:15061507```python1508-----BEGIN CERTIFICATE-----1509... (certificate for your server)...1510-----END CERTIFICATE-----1511-----BEGIN CERTIFICATE-----1512... (the certificate for the CA)...1513-----END CERTIFICATE-----1514-----BEGIN CERTIFICATE-----1515... (the root certificate for the CA's issuer)...1516-----END CERTIFICATE-----1517```15181519### Сертификаты УЦ15201521Если требуется проверка сертификата другой стороны соединения, необходимо предоставить файл «CA certs», содержащий цепочки сертификатов для каждого эмитента, которому вы готовы доверять. Этот файл просто содержит эти цепочки, объединённые вместе. Для проверки Python будет использовать первую найденную в файле подходящую цепочку. Файл сертификатов платформы можно использовать, вызвав [`SSLContext.load_default_certs()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_default_certs); это делается автоматически с помощью [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context).15221523### Объединённый ключ и сертификат15241525Часто закрытый ключ хранится в том же файле, что и сертификат; в этом случае достаточно передать только параметр `certfile` для [`SSLContext.load_cert_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_cert_chain). Если закрытый ключ хранится вместе с сертификатом, он должен располагаться перед первым сертификатом в цепочке сертификатов:15261527```python1528-----BEGIN RSA PRIVATE KEY-----1529... (private key in base64 encoding) ...1530-----END RSA PRIVATE KEY-----1531-----BEGIN CERTIFICATE-----1532... (certificate in base64 PEM encoding) ...1533-----END CERTIFICATE-----1534```15351536### Самоподписанные сертификаты15371538Если планируется создать сервер, предоставляющий услуги SSL-защищённого соединения, потребуется приобрести сертификат для этой службы. Существует много способов получения подходящих сертификатов, например покупка в удостоверяющем центре. Ещё одна распространённая практика – сгенерировать самоподписанный сертификат. Самый простой способ сделать это – использовать пакет OpenSSL, примерно следующим образом:15391540```python1541% openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem1542Generating a 1024 bit RSA private key1543.......++++++1544.............................++++++1545writing new private key to 'cert.pem'1546-----1547You are about to be asked to enter information that will be incorporated1548into your certificate request.1549What you are about to enter is what is called a Distinguished Name or a DN.1550There are quite a few fields but you can leave some blank1551For some fields there will be a default value,1552If you enter '.', the field will be left blank.1553-----1554Country Name (2 letter code) [AU]:US1555State or Province Name (full name) [Some-State]:MyState1556Locality Name (eg, city) []:Some City1557Organization Name (eg, company) [Internet Widgits Pty Ltd]:My Organization, Inc.1558Organizational Unit Name (eg, section) []:My Group1559Common Name (eg, YOUR name) []:myserver.mygroup.myorganization.com1560Email Address []:ops@myserver.mygroup.myorganization.com1561%1562```15631564Недостаток самоподписанного сертификата в том, что он является собственным корневым сертификатом, и никто другой не будет иметь его в своём кэше известных (и доверенных) корневых сертификатов.15651566## Примеры15671568### Проверка поддержки SSL15691570Чтобы проверить наличие поддержки SSL в установке Python, в пользовательском коде следует использовать следующую идиому:15711572```python1573try:1574 import ssl1575except ImportError:1576 pass1577else:1578 ... # сделать что-то, что требует поддержки SSL1579```15801581### Операции на стороне клиента15821583Этот пример создаёт контекст SSL с рекомендуемыми настройками безопасности для клиентских сокетов, включая автоматическую проверку сертификатов:15841585```python1586>>> context = ssl.create_default_context()1587```15881589Если вы предпочитаете настраивать параметры безопасности самостоятельно, можно создать контекст с нуля (но имейте в виду, что настройки могут оказаться неверными):15901591```python1592>>> context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)1593>>> context.load_verify_locations("/etc/ssl/certs/ca-bundle.crt")1594```15951596(этот фрагмент предполагает, что ваша операционная система размещает набор всех сертификатов CA в `/etc/ssl/certs/ca-bundle.crt`; если нет, вы получите ошибку и придётся изменить расположение)15971598Протокол [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) настраивает контекст для проверки сертификатов и проверки имени хоста. [`verify_mode`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.verify_mode) установлен в [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED), а [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname) установлен в `True`. Все остальные протоколы создают контексты SSL с небезопасными настройками по умолчанию.15991600При использовании контекста для подключения к серверу [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED) и [`check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname) проверяют сертификат сервера: они гарантируют, что сертификат сервера был подписан одним из сертификатов ЦС, проверяют корректность подписи, а также проверяют другие свойства, такие как срок действия и идентификация имени хоста:16011602```python1603>>> conn = context.wrap_socket(socket.socket(socket.AF_INET),1604... server_hostname="www.python.org")1605>>> conn.connect(("www.python.org", 443))1606```16071608Затем можно получить сертификат:16091610```python1611>>> cert = conn.getpeercert()1612```16131614Визуальная проверка показывает, что сертификат действительно идентифицирует нужный сервис (то есть HTTPS-хост `www.python.org`):16151616```python1617>>> pprint.pprint(cert)1618{'OCSP': ('http://ocsp.digicert.com',),1619 'caIssuers': ('http://cacerts.digicert.com/DigiCertSHA2ExtendedValidationServerCA.crt',),1620 'crlDistributionPoints': ('http://crl3.digicert.com/sha2-ev-server-g1.crl',1621 'http://crl4.digicert.com/sha2-ev-server-g1.crl'),1622 'issuer': ((('countryName', 'US'),),1623 (('organizationName', 'DigiCert Inc'),),1624 (('organizationalUnitName', 'www.digicert.com'),),1625 (('commonName', 'DigiCert SHA2 Extended Validation Server CA'),)),1626 'notAfter': 'Sep 9 12:00:00 2016 GMT',1627 'notBefore': 'Sep 5 00:00:00 2014 GMT',1628 'serialNumber': '01BB6F00122B177F36CAB49CEA8B6B26',1629 'subject': ((('businessCategory', 'Private Organization'),),1630 (('1.3.6.1.4.1.311.60.2.1.3', 'US'),),1631 (('1.3.6.1.4.1.311.60.2.1.2', 'Delaware'),),1632 (('serialNumber', '3359300'),),1633 (('streetAddress', '16 Allen Rd'),),1634 (('postalCode', '03894-4801'),),1635 (('countryName', 'US'),),1636 (('stateOrProvinceName', 'NH'),),1637 (('localityName', 'Wolfeboro'),),1638 (('organizationName', 'Python Software Foundation'),),1639 (('commonName', 'www.python.org'),)),1640 'subjectAltName': (('DNS', 'www.python.org'),1641 ('DNS', 'python.org'),1642 ('DNS', 'pypi.org'),1643 ('DNS', 'docs.python.org'),1644 ('DNS', 'testpypi.org'),1645 ('DNS', 'bugs.python.org'),1646 ('DNS', 'wiki.python.org'),1647 ('DNS', 'hg.python.org'),1648 ('DNS', 'mail.python.org'),1649 ('DNS', 'packaging.python.org'),1650 ('DNS', 'pythonhosted.org'),1651 ('DNS', 'www.pythonhosted.org'),1652 ('DNS', 'test.pythonhosted.org'),1653 ('DNS', 'us.pycon.org'),1654 ('DNS', 'id.python.org')),1655 'version': 3}1656```16571658Теперь, когда SSL-канал установлен и сертификат проверен, можно продолжить обмен данными с сервером:16591660```python1661>>> conn.sendall(b"HEAD / HTTP/1.0\r\nHost: linuxfr.org\r\n\r\n")1662>>> pprint.pprint(conn.recv(1024).split(b"\r\n"))1663[b'HTTP/1.1 200 OK',1664 b'Date: Sat, 18 Oct 2014 18:27:20 GMT',1665 b'Server: nginx',1666 b'Content-Type: text/html; charset=utf-8',1667 b'X-Frame-Options: SAMEORIGIN',1668 b'Content-Length: 45679',1669 b'Accept-Ranges: bytes',1670 b'Via: 1.1 varnish',1671 b'Age: 2188',1672 b'X-Served-By: cache-lcy1134-LCY',1673 b'X-Cache: HIT',1674 b'X-Cache-Hits: 11',1675 b'Vary: Cookie',1676 b'Strict-Transport-Security: max-age=63072000; includeSubDomains',1677 b'Connection: close',1678 b'',1679 b'']1680```16811682См. обсуждение [соображений безопасности](https://python-all.ru/3.13/library/ssl.html#ssl-security) ниже.16831684### Операции на стороне сервера16851686Для работы на стороне сервера обычно нужно иметь сертификат сервера и закрытый ключ, каждый в отдельном файле. Сначала создаётся контекст, содержащий ключ и сертификат, чтобы клиенты могли проверить подлинность. Затем открывается сокет, привязывается к порту, вызывается `listen()`, и начинается ожидание подключения клиентов:16871688```python1689import socket, ssl16901691context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)1692context.load_cert_chain(certfile="mycertfile", keyfile="mykeyfile")16931694bindsocket = socket.socket()1695bindsocket.bind(('myaddr.example.com', 10023))1696bindsocket.listen(5)1697```16981699Когда клиент подключается, вызывается `accept()` на сокете, чтобы получить новый сокет с другого конца, и используется метод контекста [`SSLContext.wrap_socket()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_socket) для создания серверного SSL-сокета для этого соединения:17001701```python1702while True:1703 newsocket, fromaddr = bindsocket.accept()1704 connstream = context.wrap_socket(newsocket, server_side=True)1705 try:1706 deal_with_client(connstream)1707 finally:1708 connstream.shutdown(socket.SHUT_RDWR)1709 connstream.close()1710```17111712Затем читаются данные из `connstream` и что-то с ними делается, пока не будет завершена работа с клиентом (или клиент не завершит работу с вами):17131714```python1715def deal_with_client(connstream):1716 data = connstream.recv(1024)1717 # пустые данные означают, что клиент закончил работу с нами1718 while data:1719 if not do_something(connstream, data):1720 # будем считать, что do_something возвращает False1721 # когда мы закончили с клиентом1722 break1723 data = connstream.recv(1024)1724 # закончили с клиентом1725```17261727И возвращаемся к ожиданию новых подключений клиентов (конечно, настоящий сервер вероятно обрабатывал бы каждое клиентское соединение в отдельном потоке или переводил сокеты в [неблокирующий режим](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) и использовал цикл событий).17281729## Примечания о неблокирующих сокетах17301731SSL-сокеты ведут себя несколько иначе, чем обычные сокеты в неблокирующем режиме. При работе с неблокирующими сокетами необходимо учитывать несколько моментов:17321733- Большинство методов [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) возбуждают либо [`SSLWantWriteError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantWriteError), либо [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError) вместо [`BlockingIOError`](https://python-all.ru/3.13/library/exceptions.html#BlockingIOError), если операция ввода-вывода могла бы заблокироваться. `SSLWantReadError` возбуждается, если необходима операция чтения из базового сокета, а `SSLWantWriteError` – для операции записи в базовый сокет. Обратите внимание, что попытки *записи* в SSL-сокет могут сначала потребовать *чтения* из базового сокета, а попытки *чтения* из SSL-сокета могут потребовать предварительной *записи* в базовый сокет.17341735 Изменено в версии 3.5: В более ранних версиях Python метод `SSLSocket.send()` возвращал ноль вместо возбуждения [`SSLWantWriteError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantWriteError) или [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError).1736- Вызов [`select()`](https://python-all.ru/3.13/library/select.html#select.select) сообщает, что с сокета на уровне ОС можно читать (или в него можно писать), но это не означает, что на верхнем уровне SSL достаточно данных. Например, может прибыть только часть SSL-фрейма. Поэтому необходимо быть готовым обрабатывать ошибки `SSLSocket.recv()` и `SSLSocket.send()` и повторить попытку после очередного вызова `select()`.1737- И наоборот, поскольку уровень SSL имеет собственную структуру фреймов, SSL-сокет может по-прежнему иметь доступные для чтения данные без ведома [`select()`](https://python-all.ru/3.13/library/select.html#select.select). Поэтому сначала следует вызвать `SSLSocket.recv()`, чтобы извлечь все потенциально доступные данные, и затем блокироваться на вызове `select()` только в случае необходимости.17381739 (конечно, аналогичные меры применимы и при использовании других примитивов, таких как [`poll()`](https://python-all.ru/3.13/library/select.html#select.poll), или из модуля [`selectors`](https://python-all.ru/3.13/library/selectors.html#module-selectors))1740- Само SSL-рукопожатие будет неблокирующим: метод [`SSLSocket.do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake) должен повторяться до тех пор, пока он не выполнится успешно. Вот краткая схема с использованием [`select()`](https://python-all.ru/3.13/library/select.html#select.select) для ожидания готовности сокета:17411742 ```python1743 while True:1744 try:1745 sock.do_handshake()1746 break1747 except ssl.SSLWantReadError:1748 select.select([sock], [], [])1749 except ssl.SSLWantWriteError:1750 select.select([], [sock], [])1751 ```17521753> **См. также**1754>1755> Модуль [`asyncio`](https://python-all.ru/3.13/library/asyncio.html#module-asyncio) поддерживает [неблокирующие SSL-сокеты](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking) и предоставляет высокоуровневый [API потоков данных](https://python-all.ru/3.13/library/asyncio-stream.html#asyncio-streams). Он опрашивает события с помощью модуля [`selectors`](https://python-all.ru/3.13/library/selectors.html#module-selectors) и обрабатывает исключения [`SSLWantWriteError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantWriteError), [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError) и [`BlockingIOError`](https://python-all.ru/3.13/library/exceptions.html#BlockingIOError). Он также выполняет рукопожатие SSL асинхронно.17561757## Поддержка Memory BIO17581759Добавлено в версии 3.5.17601761С момента появления модуля SSL в Python 2.6 класс [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) предоставляет две связанные, но различные области функциональности:17621763- Обработка протокола SSL1764- Сетевой ввод-вывод17651766API сетевого ввода-вывода идентичен тому, который предоставляет [`socket.socket`](https://python-all.ru/3.13/library/socket.html#socket.socket), от которого также наследует [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket). Это позволяет использовать SSL-сокет в качестве прямой замены обычного сокета, что значительно упрощает добавление поддержки SSL в существующее приложение.17671768Объединение обработки протокола SSL и сетевого ввода-вывода обычно работает хорошо, но есть случаи, когда это не так. Примером являются асинхронные фреймворки ввода-вывода, которые хотят использовать другую модель мультиплексирования ввода-вывода, отличную от модели «select/poll на файловом дескрипторе» (основанной на готовности), которая предполагается [`socket.socket`](https://python-all.ru/3.13/library/socket.html#socket.socket) и внутренними процедурами сокетного ввода-вывода OpenSSL. Это в основном актуально для таких платформ, как Windows, где эта модель неэффективна. Для этой цели предоставляется вариант [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) с ограниченной функциональностью, называемый [`SSLObject`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLObject).17691770#### `class ssl.SSLObject`17711772Урезанная версия [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket), представляющая экземпляр протокола SSL, не содержащая методов сетевого ввода‑вывода. Этот класс обычно используется разработчиками фреймворков, желающими реализовать асинхронный ввод‑вывод для SSL через буферы памяти.17731774Этот класс реализует интерфейс поверх низкоуровневого объекта SSL, реализованного в OpenSSL. Данный объект хранит состояние SSL-соединения, но сам не обеспечивает никакого сетевого ввода‑вывода. Ввод‑вывод должен выполняться через отдельные объекты «BIO», которые являются уровнем абстракции ввода‑вывода в OpenSSL.17751776У этого класса нет открытого конструктора. Экземпляр `SSLObject` должен создаваться с помощью метода [`wrap_bio()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_bio). Этот метод создаст экземпляр `SSLObject` и свяжет его с парой BIO. *Входящий* BIO используется для передачи данных из Python в экземпляр протокола SSL, а *исходящий* BIO – для передачи данных в обратном направлении.17771778Доступны следующие методы:17791780- [`context`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.context)1781- [`server_side`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.server_side)1782- [`server_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.server_hostname)1783- [`session`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.session)1784- [`session_reused`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.session_reused)1785- [`read()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.read)1786- [`write()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.write)1787- [`getpeercert()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.getpeercert)1788- [`get_verified_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_verified_chain)1789- [`get_unverified_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_unverified_chain)1790- [`selected_alpn_protocol()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol)1791- [`selected_npn_protocol()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.selected_npn_protocol)1792- [`cipher()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.cipher)1793- [`shared_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.shared_ciphers)1794- [`compression()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.compression)1795- [`pending()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.pending)1796- [`do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake)1797- [`verify_client_post_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.verify_client_post_handshake)1798- [`unwrap()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.unwrap)1799- [`get_channel_binding()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.get_channel_binding)1800- [`version()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.version)18011802По сравнению с [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket), у этого объекта отсутствуют следующие возможности:18031804- Любая форма сетевого ввода‑вывода; `recv()` и `send()` читают и пишут только в нижележащие буферы [`MemoryBIO`](https://python-all.ru/3.13/library/ssl.html#ssl.MemoryBIO).1805- Нет механизма *do\_handshake\_on\_connect*. Для запуска рукопожатия всегда нужно вручную вызывать [`do_handshake()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.do_handshake).1806- Нет обработки *suppress\_ragged\_eofs*. Все ситуации конца файла, нарушающие протокол, сообщаются через исключение [`SSLEOFError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLEOFError).1807- Вызов метода [`unwrap()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.unwrap) ничего не возвращает, в отличие от SSL-сокета, где он возвращает нижележащий сокет.1808- Колбэк *server\_name\_callback*, переданный в [`SSLContext.set_servername_callback()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_servername_callback), получит экземпляр `SSLObject` вместо экземпляра [`SSLSocket`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket) в качестве первого параметра.18091810Несколько замечаний, касающихся использования `SSLObject`:18111812- Весь ввод‑вывод на `SSLObject` является [неблокирующим](https://python-all.ru/3.13/library/ssl.html#ssl-nonblocking). Это означает, что, например, [`read()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.read) возбудит исключение [`SSLWantReadError`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLWantReadError), если ему потребуется больше данных, чем доступно во входящем BIO.18131814Изменено в версии 3.7: экземпляры `SSLObject` должны создаваться с помощью [`wrap_bio()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.wrap_bio). В более ранних версиях можно было создавать экземпляры напрямую. Это никогда не было документировано или официально поддерживалось.18151816SSLObject взаимодействует с внешним миром с помощью буферов памяти. Класс [`MemoryBIO`](https://python-all.ru/3.13/library/ssl.html#ssl.MemoryBIO) предоставляет буфер памяти, который можно использовать для этой цели. Он оборачивает объект OpenSSL memory BIO (Basic IO):18171818#### `class ssl.MemoryBIO`18191820Буфер памяти, который можно использовать для передачи данных между Python и экземпляром протокола SSL.18211822#### `pending`18231824Возвращает количество байтов, находящихся в данный момент в буфере памяти.18251826#### `eof`18271828Логическое значение, указывающее, находится ли память BIO в позиции конца файла.18291830#### `read(n=-1, /)`18311832Читает до *n* байтов из буфера памяти. Если *n* не указан или отрицателен, возвращаются все байты.18331834#### `write(buf, /)`18351836Записывает байты из *buf* в память BIO. Аргумент *buf* должен быть объектом, поддерживающим протокол буфера.18371838Возвращаемое значение – количество записанных байтов, которое всегда равно длине *buf*.18391840#### `write_eof()`18411842Записывает маркер конца файла (EOF) в память BIO. После вызова этого метода нельзя вызывать [`write()`](https://python-all.ru/3.13/library/ssl.html#ssl.MemoryBIO.write). Атрибут [`eof`](https://python-all.ru/3.13/library/ssl.html#ssl.MemoryBIO.eof) станет истинным после того, как все данные в буфере будут прочитаны.18431844## SSL-сеанс18451846Добавлено в версии 3.6.18471848#### `class ssl.SSLSession`18491850Объект сеанса, используемый [`session`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.session).18511852#### `id`18531854#### `time`18551856#### `timeout`18571858#### `ticket_lifetime_hint`18591860#### `has_ticket`18611862## Соображения безопасности18631864### Рекомендуемые настройки по умолчанию18651866Для **клиентского использования**, при отсутствии особых требований к политике безопасности, настоятельно рекомендуется применять функцию [`create_default_context()`](https://python-all.ru/3.13/library/ssl.html#ssl.create_default_context) для создания SSL-контекста. Она загрузит доверенные сертификаты ЦС системы, включит проверку сертификатов и имени хоста, а также попытается выбрать достаточно безопасные настройки протокола и шифров.18671868Например, вот как можно использовать класс [`smtplib.SMTP`](https://python-all.ru/3.13/library/smtplib.html#smtplib.SMTP) для создания доверенного защищённого соединения с SMTP-сервером:18691870```python1871>>> import ssl, smtplib1872>>> smtp = smtplib.SMTP("mail.python.org", port=587)1873>>> context = ssl.create_default_context()1874>>> smtp.starttls(context=context)1875(220, b'2.0.0 Ready to start TLS')1876```18771878Если для соединения требуется клиентский сертификат, его можно добавить с помощью [`SSLContext.load_cert_chain()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.load_cert_chain).18791880Напротив, при создании SSL-контекста через вызов конструктора [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) самостоятельно, в нём по умолчанию не будут включены ни проверка сертификатов, ни проверка имени хоста. В этом случае следует прочитать приведённые ниже абзацы, чтобы достичь хорошего уровня безопасности.18811882### Ручная настройка18831884#### Проверка сертификатов18851886При прямом вызове конструктора [`SSLContext`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext) значением по умолчанию является [`CERT_NONE`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_NONE). Поскольку он не аутентифицирует другую сторону, это может быть небезопасно, особенно в клиентском режиме, когда в большинстве случаев требуется удостовериться в подлинности сервера, к которому идёт обращение. Поэтому в клиентском режиме настоятельно рекомендуется использовать [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED). Однако сам по себе он не достаточен; необходимо также проверить, что сертификат сервера, который можно получить вызовом [`SSLSocket.getpeercert()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.getpeercert), соответствует нужному сервису. Для многих протоколов и приложений сервис может быть идентифицирован по имени хоста. Эта распространённая проверка выполняется автоматически, если включён [`SSLContext.check_hostname`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.check_hostname).18871888Изменено в версии 3.7: Сопоставление имён хостов теперь выполняется библиотекой OpenSSL. Python больше не использует `match_hostname()`.18891890В серверном режиме, чтобы аутентифицировать клиентов на уровне SSL (а не с помощью механизма аутентификации более высокого уровня), необходимо также указать [`CERT_REQUIRED`](https://python-all.ru/3.13/library/ssl.html#ssl.CERT_REQUIRED) и аналогично проверить сертификат клиента.18911892#### Версии протоколов18931894Версии SSL 2 и 3 считаются небезопасными и поэтому опасны для использования. Для обеспечения максимальной совместимости между клиентами и серверами рекомендуется использовать в качестве версии протокола [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) или [`PROTOCOL_TLS_SERVER`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_SERVER). SSLv2 и SSLv3 отключены по умолчанию.18951896```python1897>>> client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)1898>>> client_context.minimum_version = ssl.TLSVersion.TLSv1_21899>>> client_context.maximum_version = ssl.TLSVersion.TLSv1_31900```19011902Созданный выше SSL-контекст клиента будет разрешать только соединения TLSv1.2 и TLSv1.3 (если они поддерживаются системой) с сервером. [`PROTOCOL_TLS_CLIENT`](https://python-all.ru/3.13/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT) подразумевает проверку сертификатов и имён хостов по умолчанию. В контекст необходимо загрузить сертификаты.19031904#### Выбор шифров19051906При наличии повышенных требований к безопасности точная настройка шифров, используемых при согласовании SSL-сеанса, возможна с помощью метода [`SSLContext.set_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_ciphers). Начиная с Python 3.2.3 модуль ssl отключает некоторые слабые шифры по умолчанию, но может потребоваться дополнительно ограничить выбор шифров. Обязательно прочтите документацию OpenSSL о [формате списка шифров](https://python-all.ru/3.13/library/ssl.html). Чтобы проверить, какие шифры разрешены для данного списка шифров, используйте [`SSLContext.get_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.get_ciphers) или команду `openssl ciphers` в системе.19071908### Многопроцессная работа19091910Если этот модуль используется в составе многопроцессного приложения (например, с модулями [`multiprocessing`](https://python-all.ru/3.13/library/multiprocessing.html#module-multiprocessing) или [`concurrent.futures`](https://python-all.ru/3.13/library/concurrent.futures.html#module-concurrent.futures)), следует учитывать, что внутренний генератор случайных чисел OpenSSL некорректно обрабатывает порождённые процессы. Приложения должны изменить состояние PRNG родительского процесса, если они используют любую SSL-функцию с [`os.fork()`](https://python-all.ru/3.13/library/os.html#os.fork). Для этого достаточно любого успешного вызова [`RAND_add()`](https://python-all.ru/3.13/library/ssl.html#ssl.RAND_add) или [`RAND_bytes()`](https://python-all.ru/3.13/library/ssl.html#ssl.RAND_bytes).19111912## TLS 1.319131914Добавлено в версии 3.7.19151916Протокол TLS 1.3 ведёт себя несколько иначе, чем предыдущие версии TLS/SSL. Некоторые новые возможности TLS 1.3 пока недоступны.19171918- TLS 1.3 использует отдельный набор наборов шифров. Все наборы шифров AES-GCM и ChaCha20 включены по умолчанию. Метод [`SSLContext.set_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.set_ciphers) пока не может включать или отключать шифры TLS 1.3, но [`SSLContext.get_ciphers()`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLContext.get_ciphers) возвращает их.1919- Сессионные билеты больше не отправляются в составе исходного рукопожатия и обрабатываются иначе. [`SSLSocket.session`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSocket.session) и [`SSLSession`](https://python-all.ru/3.13/library/ssl.html#ssl.SSLSession) несовместимы с TLS 1.3.1920- Сертификаты клиента также больше не проверяются во время начального рукопожатия. Сервер может запросить сертификат в любой момент. Клиенты обрабатывают запросы сертификатов во время отправки или получения данных приложения от сервера.1921- Возможности TLS 1.3, такие как ранние данные, отложенный запрос клиентского сертификата TLS, настройка алгоритма подписи и смена ключей, пока не поддерживаются.19221923> **См. также**1924>1925> **Класс [`socket.socket`](https://python-all.ru/3.13/library/socket.html#socket.socket)**1926>1927> Документация базового класса [`socket`](https://python-all.ru/3.13/library/socket.html#module-socket)1928>1929> **[SSL/TLS: надёжное шифрование. Введение](https://python-all.ru/3.13/library/ssl.html)**1930>1931> Введение из документации Apache HTTP Server1932>1933> **[**RFC 1422: Улучшение конфиденциальности для электронной почты в Интернете: Часть II: Управление ключами на основе сертификатов**](https://python-all.ru/3.13/library/ssl.html)**1934>1935> Steve Kent1936>1937> **[**RFC 4086: Требования к случайности для обеспечения безопасности**](https://python-all.ru/3.13/library/ssl.html)**1938>1939> Donald E. Eastlake, Jeffrey I. Schiller, Steve Crocker1940>1941> **[**RFC 5280: Профиль инфраструктуры открытых ключей X.509 Интернета: сертификаты и списки отзыва сертификатов (CRL)**](https://python-all.ru/3.13/library/ssl.html)**1942>1943> David Cooper et al.1944>1945> **[**RFC 5246: Протокол безопасности транспортного уровня (TLS) версии 1.2**](https://python-all.ru/3.13/library/ssl.html)**1946>1947> Tim Dierks and Eric Rescorla.1948>1949> **[**RFC 6066: Расширения безопасности транспортного уровня (TLS)**](https://python-all.ru/3.13/library/ssl.html)**1950>1951> Donald E. Eastlake1952>1953> **[IANA TLS: Параметры безопасности транспортного уровня (TLS)](https://python-all.ru/3.13/library/ssl.html)**1954>1955> IANA1956>1957> **[**RFC 7525: Рекомендации по безопасному использованию безопасности транспортного уровня (TLS) и безопасности дейтаграммного транспортного уровня (DTLS)**](https://python-all.ru/3.13/library/ssl.html)**1958>1959> IETF1960>1961> **[Рекомендации Mozilla по TLS на стороне сервера](https://python-all.ru/3.13/library/ssl.html)**1962>1963> Mozilla1964