ssl.md

1> **Источник:** https://python-all.ru/2.7/library/ssl.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 17.3. [`ssl`](https://python-all.ru/2.7/library/ssl.html#module-ssl) – обёртка TLS/SSL для объектов сокетов89Новое в версии 2.6.1011**Исходный код:** [Lib/ssl.py](https://python-all.ru/src/2.7/Lib/ssl.py)1213---1415Этот модуль предоставляет доступ к шифрованию и аутентификации одноранговых узлов с помощью протокола Transport Layer Security (часто называемого «Secure Sockets Layer») для сетевых сокетов, как на стороне клиента, так и на стороне сервера. В этом модуле используется библиотека OpenSSL. Он доступен на всех современных Unix-системах, Windows, Mac OS X и, вероятно, на других платформах, если на них установлен OpenSSL.1617Изменено в версии 2.7.13: Обновлено для поддержки связывания с OpenSSL 1.1.01819> **Примечание**20>21> Некоторые особенности поведения могут зависеть от платформы, так как вызовы производятся к API сокетов операционной системы. Установленная версия OpenSSL также может приводить к различиям в поведении. Например, TLSv1.1 и TLSv1.2 поставляются с openssl версии 1.0.1.2223> **Предупреждение**24>25> Не следует использовать этот модуль без ознакомления с [рекомендациями по безопасности](https://python-all.ru/2.7/library/ssl.html#ssl-security). В противном случае может возникнуть ложное ощущение безопасности, поскольку настройки по умолчанию модуля ssl не обязательно подходят для конкретного приложения.2627В этом разделе описываются объекты и функции модуля `ssl`; более общую информацию о TLS, SSL и сертификатах можно найти в документах, перечисленных в разделе «См. также» внизу.2829Этот модуль предоставляет класс `ssl.SSLSocket`, производный от типа [`socket.socket`](https://python-all.ru/2.7/library/socket.html#socket.socket), и предоставляет обёртку, подобную сокету, которая также шифрует и расшифровывает данные, передаваемые через сокет по SSL. Он поддерживает дополнительные методы, такие как `getpeercert()`, который извлекает сертификат другой стороны соединения, и `cipher()`, который извлекает шифр, используемый для защищённого соединения.3031Для более сложных приложений класс [`ssl.SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) помогает управлять настройками и сертификатами, которые затем могут наследоваться SSL-сокетами, созданными через метод [`SSLContext.wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.wrap_socket).3233## 17.3.1. Функции, константы и исключения3435#### `exception ssl.SSLError`3637Поднимается для обозначения ошибки в базовой реализации SSL (в настоящее время предоставляется библиотекой OpenSSL). Это сигнализирует о проблеме в высокоуровневом уровне шифрования и аутентификации, наложенном на сетевое соединение. Данная ошибка является подтипом [`socket.error`](https://python-all.ru/2.7/library/socket.html#socket.error), который, в свою очередь, является подтипом [`IOError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.IOError). Код ошибки и сообщение экземпляров [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError) предоставляются библиотекой OpenSSL.3839#### `library`4041Строковый мнемонический код, обозначающий подмодуль OpenSSL, в котором произошла ошибка, например `SSL`, `PEM` или `X509`. Набор возможных значений зависит от версии OpenSSL.4243Новое в версии 2.7.9.4445#### `reason`4647Строковый мнемонический код, обозначающий причину этой ошибки, например `CERTIFICATE_VERIFY_FAILED`. Набор возможных значений зависит от версии OpenSSL.4849Новое в версии 2.7.9.5051#### `exception ssl.SSLZeroReturnError`5253Подкласс [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), возбуждаемый при попытке чтения или записи, когда SSL-соединение было корректно закрыто. Обратите внимание, что это не означает, что нижележащий транспорт (например, TCP) был закрыт.5455Новое в версии 2.7.9.5657#### `exception ssl.SSLWantReadError`5859Подкласс [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), возбуждаемый [неблокирующим SSL-сокетом](https://python-all.ru/2.7/library/ssl.html#ssl-nonblocking) при попытке чтения или записи данных, но для выполнения запроса необходимо получить больше данных по нижележащему TCP-транспорту.6061Новое в версии 2.7.9.6263#### `exception ssl.SSLWantWriteError`6465Подкласс [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), возбуждаемый [неблокирующим SSL-сокетом](https://python-all.ru/2.7/library/ssl.html#ssl-nonblocking) при попытке чтения или записи данных, но для выполнения запроса необходимо отправить больше данных по нижележащему TCP-транспорту.6667Новое в версии 2.7.9.6869#### `exception ssl.SSLSyscallError`7071Подкласс [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), возбуждаемый при возникновении системной ошибки во время выполнения операции с SSL-сокетом. К сожалению, нет простого способа узнать исходный номер errno.7273Новое в версии 2.7.9.7475#### `exception ssl.SSLEOFError`7677Подкласс [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), возбуждаемый при внезапном завершении SSL-соединения. Обычно не следует пытаться повторно использовать нижележащий транспорт при возникновении этой ошибки.7879Новое в версии 2.7.9.8081#### `exception ssl.CertificateError`8283Возбуждается при ошибке с сертификатом (например, несовпадающее имя хоста). Ошибки сертификата, обнаруженные OpenSSL, тем не менее, возбуждают [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError).8485### 17.3.1.1. Создание сокета8687Следующая функция позволяет создавать сокеты как отдельные объекты. Начиная с Python 2.7.9, для большей гибкости можно использовать [`SSLContext.wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.wrap_socket).8889#### `ssl.wrap_socket(sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version={see docs}, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None)`9091Принимает экземпляр `sock` класса [`socket.socket`](https://python-all.ru/2.7/library/socket.html#socket.socket) и возвращает экземпляр `ssl.SSLSocket`, подтипа [`socket.socket`](https://python-all.ru/2.7/library/socket.html#socket.socket), который оборачивает базовый сокет в контекст SSL. `sock` должен быть сокетом [`SOCK_STREAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_STREAM); другие типы сокетов не поддерживаются.9293Для клиентских сокетов создание контекста является отложенным; если базовый сокет ещё не подключён, создание контекста будет выполнено после вызова `connect()` для сокета. Для серверных сокетов, если у сокета нет удалённого партнёра, предполагается, что это слушающий сокет, и серверная обёртка SSL автоматически применяется к клиентским подключениям, принятым через метод `accept()`. [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket) может возбуждать [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError).9495Параметры `keyfile` и `certfile` указывают необязательные файлы, которые содержат сертификат, используемый для идентификации локальной стороны соединения. См. обсуждение [Сертификатов](https://python-all.ru/2.7/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как сертификат хранится в `certfile`.9697Параметр `server_side` – это логическое значение, указывающее, требуется ли поведение серверной или клиентской стороны для этого сокета.9899Параметр `cert_reqs` определяет, требуется ли сертификат от другой стороны соединения, и будет ли он проверен, если предоставлен. Он должен быть одним из трёх значений: [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE) (сертификаты игнорируются), [`CERT_OPTIONAL`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_OPTIONAL) (не требуется, но проверяется если предоставлен) или [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED) (требуется и проверяется). Если значение этого параметра не равно [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE), то параметр `ca_certs` должен указывать на файл сертификатов ЦС.100101Файл `ca_certs` содержит набор объединённых сертификатов «удостоверяющего центра», которые используются для проверки сертификатов, переданных с другого конца соединения. См. обсуждение [Сертификатов](https://python-all.ru/2.7/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как организовать сертификаты в этом файле.102103Параметр `ssl_version` определяет, какую версию протокола SSL использовать. Обычно сервер выбирает определённую версию протокола, и клиент должен адаптироваться к выбору сервера. Большинство версий не совместимы с другими версиями. Если не указано, по умолчанию используется [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23); он обеспечивает наибольшую совместимость с другими версиями.104105Ниже приведена таблица, показывающая, какие версии на стороне клиента (по вертикали) могут подключаться к каким версиям на стороне сервера (по горизонтали):106107> | *клиент* / **сервер** | **SSLv2** | **SSLv3** | **SSLv23** | **TLSv1** | **TLSv1.1** | **TLSv1.2** |108> | --- | --- | --- | --- | --- | --- | --- |109> | *SSLv2* | да | нет | да | нет | нет | нет |110> | *SSLv3* | нет | да | да | нет | нет | нет |111> | *SSLv23* [1](https://python-all.ru/2.7/library/ssl.html#id2) | нет | да | да | да | да | да |112> | *TLSv1* | нет | нет | да | да | нет | нет |113> | *TLSv1.1* | нет | нет | да | нет | да | нет |114> | *TLSv1.2* | нет | нет | да | нет | нет | да |115116Сноски117118**[1](https://python-all.ru/2.7/library/ssl.html#id1)**119120Протокол TLS 1.3 будет доступен с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23) в OpenSSL \>= 1.1.1. Для одного только TLS 1.3 не существует отдельной константы PROTOCOL.121122> **Примечание**123>124> Какие соединения будут успешными, зависит от версии OpenSSL. Например, до OpenSSL 1.0.0 клиент SSLv23 всегда пытался устанавливать соединения SSLv2.125126Параметр *ciphers* задаёт доступные шифры для этого объекта SSL. Он должен быть строкой в [формате списка шифров OpenSSL](https://python-all.ru/2.7/library/ssl.html).127128Параметр `do_handshake_on_connect` определяет, следует ли выполнять рукопожатие SSL автоматически после `socket.connect()`, или же прикладная программа будет вызывать его явно с помощью метода [`SSLSocket.do_handshake()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.do_handshake). Явный вызов [`SSLSocket.do_handshake()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.do_handshake) даёт программе контроль над блокирующим поведением ввода-вывода сокета, участвующего в рукопожатии.129130Параметр `suppress_ragged_eofs` определяет, как метод `SSLSocket.read()` должен сигнализировать о неожиданном EOF от другого конца соединения. Если задано значение [`True`](https://python-all.ru/2.7/library/constants.html#True) (по умолчанию), он возвращает обычный EOF (пустой объект bytes) в ответ на ошибки неожиданного EOF, возникшие в базовом сокете; если [`False`](https://python-all.ru/2.7/library/constants.html#False), то исключения будут переданы обратно вызывающему коду.131132Изменено в версии 2.7: Новый необязательный аргумент *ciphers*.133134### 17.3.1.2. Создание контекста135136Вспомогательная функция помогает создавать объекты [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) для распространённых целей.137138#### `ssl.create_default_context(purpose=Purpose.SERVER_AUTH, cafile=None, capath=None, cadata=None)`139140Возвращает новый объект [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) с настройками по умолчанию для указанного *назначения*. Настройки выбираются модулем [`ssl`](https://python-all.ru/2.7/library/ssl.html#module-ssl) и обычно представляют более высокий уровень безопасности, чем при непосредственном вызове конструктора [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext).141142*cafile*, *capath*, *cadata* представляют необязательные сертификаты ЦС, которым следует доверять при проверке сертификатов, как в [`SSLContext.load_verify_locations()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_verify_locations). Если все три равны [`None`](https://python-all.ru/2.7/library/constants.html#None), эта функция может вместо этого доверять системным сертификатам ЦС по умолчанию.143144Настройки таковы: [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23), [`OP_NO_SSLv2`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv2) и [`OP_NO_SSLv3`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv3) с наборами шифров высокого уровня без RC4 и без неаутентифицированных наборов шифров. Передача [`SERVER_AUTH`](https://python-all.ru/2.7/library/ssl.html#ssl.Purpose.SERVER_AUTH) в качестве *purpose* устанавливает [`verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) в [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED) и либо загружает сертификаты CA (когда задан хотя бы один из *cafile*, *capath* или *cadata*), либо использует [`SSLContext.load_default_certs()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_default_certs) для загрузки сертификатов CA по умолчанию.145146> **Примечание**147>148> Протокол, параметры, шифр и другие настройки могут в любой момент измениться на более строгие значения без предварительного уведомления об устаревании. Эти значения представляют собой разумный баланс между совместимостью и безопасностью.149>150> Если приложению требуются особые настройки, нужно создать [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) и применить их самостоятельно.151152> **Примечание**153>154> Если при попытке некоторых старых клиентов или серверов подключиться с помощью [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext), созданного этой функцией, возникает ошибка «Несовпадение протокола или набора шифров», возможно, они поддерживают только SSL 3.0, который эта функция исключает с помощью [`OP_NO_SSLv3`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv3). SSL 3.0 общепризнанно [полностью скомпрометирован](https://python-all.ru/2.7/library/ssl.html). Если всё же необходимо продолжить использование этой функции, но при этом разрешить подключения SSL 3.0, можно снова включить их с помощью:155>156> ```python157> ctx = ssl.create_default_context(Purpose.CLIENT_AUTH)158> ctx.options &= ~ssl.OP_NO_SSLv3159> ```160161Новое в версии 2.7.9.162163Изменено в версии 2.7.10: RC4 был удалён из строки шифров по умолчанию.164165Изменено в версии 2.7.13: ChaCha20/Poly1305 добавлен в строку шифров по умолчанию.1661673DES был удалён из строки шифров по умолчанию.168169#### `ssl._https_verify_certificates(enable=True)`170171Определяет, проверяются ли сертификаты сервера при создании клиентских HTTPS-соединений без указания конкретного SSL-контекста.172173Начиная с Python 2.7.9, [`httplib`](https://python-all.ru/2.7/library/httplib.html#module-httplib) и модули, которые его используют, такие как [`urllib2`](https://python-all.ru/2.7/library/urllib2.html#module-urllib2) и [`xmlrpclib`](https://python-all.ru/2.7/library/xmlrpclib.html#module-xmlrpclib), по умолчанию проверяют сертификаты удалённых серверов, полученные при установке клиентских HTTPS-соединений. Эта проверка по умолчанию удостоверяется, что сертификат подписан центром сертификации из системного хранилища доверенных сертификатов, и что общее имя (или альтернативное имя субъекта) в представленном сертификате соответствует запрошенному хосту.174175Присвоение *enable* значения [`True`](https://python-all.ru/2.7/library/constants.html#True) гарантирует, что поведение по умолчанию остаётся в силе.176177Установка *enable* в значение [`False`](https://python-all.ru/2.7/library/constants.html#False) возвращает обработку сертификатов HTTPS по умолчанию к версии Python 2.7.8 и более ранних, разрешая подключения к серверам, использующим самоподписанные сертификаты, серверам с сертификатами, подписанными центром сертификации, отсутствующим в системном хранилище доверенных сертификатов, а также к серверам, где имя хоста не соответствует представленному сертификату.178179Наличие начального подчёркивания в имени этой функции указывает на то, что она намеренно отсутствует в любой реализации Python 3 и может отсутствовать во всех реализациях Python 2.7. Переносимым способом обхода проверки сертификатов или системного хранилища доверенных сертификатов при необходимости является включение этой возможности в каждом конкретном случае инструментами путём явной передачи соответствующе настроенного SSL-контекста, а не возврат к поведению клиентских модулей стандартной библиотеки по умолчанию.180181Новое в версии 2.7.12.182183> **См. также**184>185> - [CVE-2014-9365](https://python-all.ru/2.7/library/ssl.html) – HTTPS-атака «человек посередине» на клиентов Python, использующих настройки по умолчанию186> - [**PEP 476**](https://python-all.ru/2.7/library/ssl.html) – Включение проверки сертификатов по умолчанию для HTTPS187> - [**PEP 493**](https://python-all.ru/2.7/library/ssl.html) – Инструменты миграции проверки HTTPS для Python 2.7188189### 17.3.1.3. Генерация случайных чисел190191> Устарело с версии 2.7.13: OpenSSL объявил устаревшим `ssl.RAND_pseudo_bytes()`, используйте `ssl.RAND_bytes()` вместо него.192193#### `ssl.RAND_status()`194195Возвращает `True`, если ГПСЧ (псевдослучайный генератор чисел) SSL был инициализирован достаточным количеством случайных данных, и `False` в противном случае. Можно использовать [`ssl.RAND_egd()`](https://python-all.ru/2.7/library/ssl.html#ssl.RAND_egd) и [`ssl.RAND_add()`](https://python-all.ru/2.7/library/ssl.html#ssl.RAND_add) для увеличения случайности генератора псевдослучайных чисел.196197#### `ssl.RAND_egd(path)`198199Если где-то запущен демон сбора энтропии (EGD) и *path* – это имя пути к сокетному соединению, открытому для него, то из сокета будет прочитано 256 байт случайных данных и добавлено в генератор псевдослучайных чисел SSL для повышения безопасности генерируемых секретных ключей. Обычно это необходимо только в системах, где нет более качественных источников случайности.200201См. [http://egd.sourceforge.net/](https://python-all.ru/2.7/library/ssl.html) или [http://prngd.sourceforge.net/](https://python-all.ru/2.7/library/ssl.html) для получения исходных текстов демонов сбора энтропии.202203Доступность: недоступно с LibreSSL и OpenSSL \> 1.1.0204205#### `ssl.RAND_add(bytes, entropy)`206207Смешивает заданные *bytes* (байты) с генератором псевдослучайных чисел SSL. Параметр *entropy* (число с плавающей точкой) задаёт нижнюю границу энтропии, содержащейся в строке (поэтому всегда можно использовать `0.0`). См. [**RFC 1750**](https://python-all.ru/2.7/library/ssl.html) для получения дополнительной информации об источниках энтропии.208209### 17.3.1.4. Обработка сертификатов210211#### `ssl.match_hostname(cert, hostname)`212213Проверяет, что *cert* (в декодированном виде, как возвращается [`SSLSocket.getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert)) соответствует заданному *hostname*. Применяются правила проверки идентичности HTTPS-серверов, описанные в [**RFC 2818**](https://python-all.ru/2.7/library/ssl.html) и [**RFC 6125**](https://python-all.ru/2.7/library/ssl.html), за исключением того, что IP-адреса в настоящее время не поддерживаются. Помимо HTTPS, эта функция подходит для проверки идентичности серверов в различных протоколах на основе SSL, таких как FTPS, IMAPS, POPS и других.214215[`CertificateError`](https://python-all.ru/2.7/library/ssl.html#ssl.CertificateError) возбуждается при неудаче. При успехе функция не возвращает ничего:216217```python218>>> cert = {'subject': ((('commonName', 'example.com'),),)}219>>> ssl.match_hostname(cert, "example.com")220>>> ssl.match_hostname(cert, "example.org")221Traceback (most recent call last):222  File "<stdin>", line 1, in <module>223  File "/home/py3k/Lib/ssl.py", line 130, in match_hostname224ssl.CertificateError: hostname 'example.org' doesn't match 'example.com'225```226227Новое в версии 2.7.9.228229#### `ssl.cert_time_to_seconds(cert_time)`230231Возвращает время в секундах с начала эпохи (Epoch), используя строку `cert_time` представляющую дату “notBefore” или “notAfter” из сертификата в формате `"%b %d %H:%M:%S %Y %Z"` strptime (локаль C).232233Вот пример:234235```pycon236>>> import ssl237>>> timestamp = ssl.cert_time_to_seconds("Jan  5 09:34:43 2018 GMT")238>>> timestamp2391515144883240>>> from datetime import datetime241>>> print(datetime.utcfromtimestamp(timestamp))2422018-01-05 09:34:43243```244245Даты “notBefore” or “notAfter” должны использовать GMT ([**RFC 5280**](https://python-all.ru/2.7/library/ssl.html)).246247Изменено в версии 2.7.9: Интерпретирует входное время как время в UTC, как указано часовым поясом 'GMT' во входной строке. Ранее использовался местный часовой пояс. Возвращает целое число (без долей секунды во входном формате).248249#### `ssl.get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None)`250251Получает сертификат сервера по адресу `addr` SSL-защищённого сервера, заданному в виде пары (*hostname*, *port-number*), и возвращает его в виде строки в кодировке PEM. Если указан `ssl_version`, используется эта версия протокола SSL для попытки подключения к серверу. Если указан `ca_certs`, это должен быть файл со списком корневых сертификатов, в том же формате, что и для одноимённого параметра в [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket). Вызов попытается проверить сертификат сервера относительно этого набора корневых сертификатов; если проверка не удастся, будет ошибка.252253Изменено в версии 2.7.9: Эта функция теперь совместима с IPv6, а значение по умолчанию *ssl\_version* изменено с [`PROTOCOL_SSLv3`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv3) на [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23) для максимальной совместимости с современными серверами.254255#### `ssl.DER_cert_to_PEM_cert(DER_cert_bytes)`256257Принимая сертификат в виде набора байтов в кодировке DER, возвращает версию того же сертификата в виде строки в кодировке PEM.258259#### `ssl.PEM_cert_to_DER_cert(PEM_cert_string)`260261Принимая сертификат в виде строки ASCII в формате PEM, возвращает последовательность байтов в кодировке DER для того же сертификата.262263#### `ssl.get_default_verify_paths()`264265Возвращает именованный кортеж с путями к файлу cafile и каталогу capath OpenSSL по умолчанию. Эти пути совпадают с используемыми в [`SSLContext.set_default_verify_paths()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_default_verify_paths). Возвращаемое значение – это [именованный кортеж](https://python-all.ru/2.7/glossary.html#term-named-tuple) `DefaultVerifyPaths`:266267- `cafile` – разрешённый (абсолютный) путь к cafile или `None`, если файл не существует,268- `capath` – разрешённый путь к capath или `None`, если каталог не существует,269- `openssl_cafile_env` – переменная окружения OpenSSL, указывающая на cafile,270- `openssl_cafile` – жёстко заданный путь к cafile,271- `openssl_capath_env` – переменная окружения OpenSSL, указывающая на capath,272- `openssl_capath` – жёстко заданный путь к каталогу capath273274Доступность: LibreSSL игнорирует переменные окружения `openssl_cafile_env` и `openssl_capath_env`275276Новое в версии 2.7.9.277278#### `ssl.enum_certificates(store_name)`279280Извлекает сертификаты из системного хранилища сертификатов Windows. *store\_name* может быть одним из `CA`, `ROOT` или `MY`. Windows также может предоставлять дополнительные хранилища сертификатов.281282Функция возвращает список кортежей (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`, если сертификат считается надёжным для всех целей.283284Пример:285286```python287>>> ssl.enum_certificates("CA")288[(b'data...', 'x509_asn', {'1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2'}),289 (b'data...', 'x509_asn', True)]290```291292Доступность: Windows.293294Новое в версии 2.7.9.295296#### `ssl.enum_crls(store_name)`297298Извлекает CRL из системного хранилища сертификатов Windows. *store\_name* может быть одним из `CA`, `ROOT` или `MY`. Windows также может предоставлять дополнительные хранилища сертификатов.299300Функция возвращает список кортежей (cert\_bytes, encoding\_type, trust). Параметр encoding\_type задаёт кодировку cert\_bytes. Это может быть `x509_asn` для данных X.509 ASN.1 или `pkcs_7_asn` для данных PKCS#7 ASN.1.301302Доступность: Windows.303304Новое в версии 2.7.9.305306### 17.3.1.5. Константы307308#### `ssl.CERT_NONE`309310Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) или параметра `cert_reqs` в [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket). В этом режиме (по умолчанию) сертификаты не требуются от другой стороны сокетного соединения. Если сертификат получен от другой стороны, попытка его проверки не предпринимается.311312См. обсуждение [соображений безопасности](https://python-all.ru/2.7/library/ssl.html#ssl-security) ниже.313314#### `ssl.CERT_OPTIONAL`315316Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) или параметра `cert_reqs` в [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket). В этом режиме сертификаты не требуются от другой стороны сокетного соединения; но если они предоставлены, будет предпринята попытка проверки и в случае неудачи будет возбуждено [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError).317318Использование этой настройки требует передачи действительного набора сертификатов ЦС: либо в [`SSLContext.load_verify_locations()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_verify_locations), либо в качестве значения параметра `ca_certs` для [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket).319320#### `ssl.CERT_REQUIRED`321322Возможное значение для [`SSLContext.verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) или параметра `cert_reqs` в [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket). В этом режиме сертификаты требуются от другой стороны сокетного соединения; [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError) будет возбуждено, если сертификат не предоставлен или его проверка не удалась.323324Использование этой настройки требует передачи действительного набора сертификатов ЦС: либо в [`SSLContext.load_verify_locations()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_verify_locations), либо в качестве значения параметра `ca_certs` для [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket).325326#### `ssl.VERIFY_DEFAULT`327328Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме списки отзыва сертификатов (CRL) не проверяются. По умолчанию OpenSSL не требует и не проверяет CRL.329330Новое в версии 2.7.9.331332#### `ssl.VERIFY_CRL_CHECK_LEAF`333334Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме проверяется только сертификат пира, но ни один из промежуточных сертификатов ЦС. Режим требует действительный CRL, подписанный издателем сертификата пира (его непосредственным вышестоящим ЦС). Если надлежащий не был загружен [`SSLContext.load_verify_locations`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_verify_locations), проверка завершится ошибкой.335336Новое в версии 2.7.9.337338#### `ssl.VERIFY_CRL_CHECK_CHAIN`339340Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags). В этом режиме проверяются CRL всех сертификатов в цепочке сертификата однорангового узла.341342Новое в версии 2.7.9.343344#### `ssl.VERIFY_X509_STRICT`345346Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags) для отключения обходных путей для повреждённых сертификатов X.509.347348Новое в версии 2.7.9.349350#### `ssl.VERIFY_X509_TRUSTED_FIRST`351352Возможное значение для [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags). Оно указывает OpenSSL отдавать предпочтение доверенным сертификатам при построении цепочки доверия для проверки сертификата. Этот флаг включён по умолчанию.353354Новое в версии 2.7.10.355356#### `ssl.PROTOCOL_TLS`357358Выбирает самую высокую версию протокола, поддерживаемую как клиентом, так и сервером. Несмотря на название, этот параметр может выбирать протоколы «TLS», а также «SSL».359360Новое в версии 2.7.13.361362#### `ssl.PROTOCOL_SSLv23`363364Псевдоним для `PROTOCOL_TLS`.365366Устарело с версии 2.7.13: Используйте `PROTOCOL_TLS` вместо этого.367368#### `ssl.PROTOCOL_SSLv2`369370Выбирает SSL версии 2 в качестве протокола шифрования канала.371372Этот протокол недоступен, если OpenSSL скомпилирован с флагом `OPENSSL_NO_SSL2`.373374> **Предупреждение**375>376> SSL версии 2 небезопасен. Его использование крайне не рекомендуется.377378Устарело с версии 2.7.13: OpenSSL удалил поддержку SSLv2.379380#### `ssl.PROTOCOL_SSLv3`381382Выбирает SSL версии 3 в качестве протокола шифрования канала.383384Этот протокол недоступен, если OpenSSL скомпилирован с флагом `OPENSSL_NO_SSLv3`.385386> **Предупреждение**387>388> SSL версии 3 небезопасен. Его использование крайне не рекомендуется.389390Устарело с версии 2.7.13: OpenSSL объявил устаревшими все протоколы, привязанные к версиям. Используйте протокол по умолчанию с флагами, такими как `OP_NO_SSLv3`, вместо этого.391392#### `ssl.PROTOCOL_TLSv1`393394Выбирает TLS версии 1.0 в качестве протокола шифрования канала.395396Устарело с версии 2.7.13: OpenSSL объявил устаревшими все протоколы, привязанные к версиям. Используйте протокол по умолчанию с флагами, такими как `OP_NO_SSLv3`, вместо этого.397398#### `ssl.PROTOCOL_TLSv1_1`399400Выбирает TLS версии 1.1 в качестве протокола шифрования канала. Доступно только в openssl версии 1.0.1+.401402Новое в версии 2.7.9.403404Устарело с версии 2.7.13: OpenSSL объявил устаревшими все протоколы, привязанные к версиям. Используйте протокол по умолчанию с флагами, такими как `OP_NO_SSLv3`, вместо этого.405406#### `ssl.PROTOCOL_TLSv1_2`407408Выбирает TLS версии 1.2 в качестве протокола шифрования канала. Это самая современная версия и, вероятно, лучший выбор для максимальной защиты, если обе стороны могут её поддерживать. Доступна только с openssl версии 1.0.1 и выше.409410Новое в версии 2.7.9.411412Устарело с версии 2.7.13: OpenSSL объявил устаревшими все протоколы, привязанные к версиям. Используйте протокол по умолчанию с флагами, такими как `OP_NO_SSLv3`, вместо этого.413414#### `ssl.OP_ALL`415416Включает обходные пути для различных ошибок, присутствующих в других реализациях SSL. Эта опция включена по умолчанию. Она не обязательно устанавливает те же флаги, что и константа `SSL_OP_ALL` от OpenSSL.417418Новое в версии 2.7.9.419420#### `ssl.OP_NO_SSLv2`421422Предотвращает подключение по SSLv2. Эта опция применима только в сочетании с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23). Она не позволяет сторонам выбирать SSLv2 в качестве версии протокола.423424Новое в версии 2.7.9.425426#### `ssl.OP_NO_SSLv3`427428Предотвращает подключение по SSLv3. Этот параметр применим только в сочетании с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23). Он не позволяет участникам выбирать SSLv3 в качестве версии протокола.429430Новое в версии 2.7.9.431432#### `ssl.OP_NO_TLSv1`433434Предотвращает подключение по TLSv1. Этот параметр применим только в сочетании с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23). Он не позволяет участникам выбирать TLSv1 в качестве версии протокола.435436Новое в версии 2.7.9.437438#### `ssl.OP_NO_TLSv1_1`439440Предотвращает подключение по TLSv1.1. Этот параметр применим только в сочетании с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23). Он не позволяет участникам выбирать TLSv1.1 в качестве версии протокола. Доступно только для OpenSSL версии 1.0.1 и выше.441442Новое в версии 2.7.9.443444#### `ssl.OP_NO_TLSv1_2`445446Предотвращает подключение по TLSv1.2. Этот параметр применим только в сочетании с [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23). Он не позволяет участникам выбирать TLSv1.2 в качестве версии протокола. Доступно только для OpenSSL версии 1.0.1 и выше.447448Новое в версии 2.7.9.449450#### `ssl.OP_NO_TLSv1_3`451452Предотвращает подключение по TLSv1.3. Этот параметр применим только в сочетании с [`PROTOCOL_TLS`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_TLS). Он не позволяет участникам выбирать TLSv1.3 в качестве версии протокола. TLS 1.3 доступен начиная с OpenSSL 1.1.1. Если Python был собран с более старой версией OpenSSL, этот флаг по умолчанию равен *0*.453454Новое в версии 2.7.15.455456#### `ssl.OP_CIPHER_SERVER_PREFERENCE`457458Использовать порядок шифров, заданный на сервере, а не на клиенте. Этот параметр не влияет на клиентские сокеты и сокеты сервера SSLv2.459460Новое в версии 2.7.9.461462#### `ssl.OP_SINGLE_DH_USE`463464Предотвращает повторное использование одного и того же DH-ключа для разных SSL-сессий. Это улучшает прямую секретность, но требует больше вычислительных ресурсов. Данная опция применяется только к серверным сокетам.465466Новое в версии 2.7.9.467468#### `ssl.OP_SINGLE_ECDH_USE`469470Предотвращает повторное использование одного и того же ECDH-ключа для разных SSL-сессий. Это улучшает прямую секретность, но требует больше вычислительных ресурсов. Данная опция применяется только к серверным сокетам.471472Новое в версии 2.7.9.473474#### `ssl.OP_ENABLE_MIDDLEBOX_COMPAT`475476Отправляет фиктивные сообщения Change Cipher Spec (CCS) в процессе рукопожатия TLS 1.3, чтобы подключение TLS 1.3 выглядело больше как подключение TLS 1.2.477478Этот параметр доступен только в OpenSSL 1.1.1 и выше.479480Новое в версии 2.7.16.481482#### `ssl.OP_NO_COMPRESSION`483484Отключает сжатие в SSL-канале. Это полезно, если прикладной протокол поддерживает собственный механизм сжатия.485486Эта опция доступна только в OpenSSL 1.0.0 и более поздних версиях.487488Новое в версии 2.7.9.489490#### `ssl.HAS_ALPN`491492Указывает, имеет ли библиотека OpenSSL встроенную поддержку расширения TLS *Согласование протокола прикладного уровня*, как описано в [**RFC 7301**](https://python-all.ru/2.7/library/ssl.html).493494Новое в версии 2.7.10.495496#### `ssl.HAS_ECDH`497498Определяет, имеет ли библиотека OpenSSL встроенную поддержку обмена ключами Диффи-Хеллмана на основе эллиптических кривых. Должно быть истинно, если только эта возможность не была явно отключена распространителем.499500Новое в версии 2.7.9.501502#### `ssl.HAS_SNI`503504Указывает, имеет ли библиотека OpenSSL встроенную поддержку расширения *Server Name Indication* (как определено в [**RFC 4366**](https://python-all.ru/2.7/library/ssl.html)).505506Новое в версии 2.7.9.507508#### `ssl.HAS_NPN`509510Whether the OpenSSL library has built-in support for *Next Protocol Negotiation* as described in the [NPN draft specification](https://python-all.ru/2.7/library/ssl.html). When true, you can use the [`SSLContext.set_npn_protocols()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_npn_protocols) method to advertise which protocols you want to support.511512Новое в версии 2.7.9.513514#### `ssl.HAS_TLSv1_3`515516Определяет, поддерживает ли библиотека OpenSSL протокол TLS 1.3 на встроенном уровне.517518Новое в версии 2.7.15.519520#### `ssl.CHANNEL_BINDING_TYPES`521522Список поддерживаемых типов привязки каналов TLS. Строки из этого списка можно использовать в качестве аргументов для [`SSLSocket.get_channel_binding()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.get_channel_binding).523524Новое в версии 2.7.9.525526#### `ssl.OPENSSL_VERSION`527528Строка с версией библиотеки OpenSSL, загруженной интерпретатором:529530```python531>>> ssl.OPENSSL_VERSION532'OpenSSL 0.9.8k 25 Mar 2009'533```534535Новое в версии 2.7.536537#### `ssl.OPENSSL_VERSION_INFO`538539Кортеж из пяти целых чисел, содержащий информацию о версии библиотеки OpenSSL:540541```python542>>> ssl.OPENSSL_VERSION_INFO543(0, 9, 8, 11, 15)544```545546Новое в версии 2.7.547548#### `ssl.OPENSSL_VERSION_NUMBER`549550Сырой номер версии библиотеки OpenSSL в виде целого числа:551552```python553>>> ssl.OPENSSL_VERSION_NUMBER5549470143L555>>> hex(ssl.OPENSSL_VERSION_NUMBER)556'0x9080bfL'557```558559Новое в версии 2.7.560561#### `ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE`562563#### `ssl.ALERT_DESCRIPTION_INTERNAL_ERROR`564565#### `ALERT_DESCRIPTION_*`566567Описания предупреждений из [**RFC 5246**](https://python-all.ru/2.7/library/ssl.html) и других источников. [Реестр предупреждений TLS IANA](https://python-all.ru/2.7/library/ssl.html) содержит этот список и ссылки на RFC, где определено их значение.568569Используется как возвращаемое значение колбэка в [`SSLContext.set_servername_callback()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_servername_callback).570571Новое в версии 2.7.9.572573#### `Purpose.SERVER_AUTH`574575Опция для [`create_default_context()`](https://python-all.ru/2.7/library/ssl.html#ssl.create_default_context) и [`SSLContext.load_default_certs()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_default_certs). Это значение указывает, что контекст может использоваться для аутентификации веб-серверов (следовательно, он будет использоваться для создания клиентских сокетов).576577Новое в версии 2.7.9.578579#### `Purpose.CLIENT_AUTH`580581Опция для [`create_default_context()`](https://python-all.ru/2.7/library/ssl.html#ssl.create_default_context) и [`SSLContext.load_default_certs()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_default_certs). Это значение указывает, что контекст может использоваться для аутентификации веб-клиентов (поэтому он будет использоваться для создания серверных сокетов).582583Новое в версии 2.7.9.584585## 17.3.2. SSL-сокеты586587SSL-сокеты предоставляют следующие методы [объектов сокетов](https://python-all.ru/2.7/library/socket.html#socket-objects):588589- [`accept()`](https://python-all.ru/2.7/library/socket.html#socket.socket.accept)590- [`bind()`](https://python-all.ru/2.7/library/socket.html#socket.socket.bind)591- [`close()`](https://python-all.ru/2.7/library/socket.html#socket.socket.close)592- [`connect()`](https://python-all.ru/2.7/library/socket.html#socket.socket.connect)593- [`fileno()`](https://python-all.ru/2.7/library/socket.html#socket.socket.fileno)594- [`getpeername()`](https://python-all.ru/2.7/library/socket.html#socket.socket.getpeername), [`getsockname()`](https://python-all.ru/2.7/library/socket.html#socket.socket.getsockname)595- [`getsockopt()`](https://python-all.ru/2.7/library/socket.html#socket.socket.getsockopt), [`setsockopt()`](https://python-all.ru/2.7/library/socket.html#socket.socket.setsockopt)596- [`gettimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.gettimeout), [`settimeout()`](https://python-all.ru/2.7/library/socket.html#socket.socket.settimeout), [`setblocking()`](https://python-all.ru/2.7/library/socket.html#socket.socket.setblocking)597- [`listen()`](https://python-all.ru/2.7/library/socket.html#socket.socket.listen)598- [`makefile()`](https://python-all.ru/2.7/library/socket.html#socket.socket.makefile)599- [`recv()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv), [`recv_into()`](https://python-all.ru/2.7/library/socket.html#socket.socket.recv_into) (однако передача ненулевого аргумента `flags` не разрешена)600- [`send()`](https://python-all.ru/2.7/library/socket.html#socket.socket.send), [`sendall()`](https://python-all.ru/2.7/library/socket.html#socket.socket.sendall) (с тем же ограничением)601- [`shutdown()`](https://python-all.ru/2.7/library/socket.html#socket.socket.shutdown)602603Однако, поскольку протокол SSL (и TLS) имеет собственную структуру поверх TCP, абстракция SSL-сокетов может в некоторых аспектах отличаться от спецификации обычных сокетов на уровне ОС. Особенно см. [примечания о неблокирующих сокетах](https://python-all.ru/2.7/library/ssl.html#ssl-nonblocking).604605SSL-сокеты также имеют следующие дополнительные методы и атрибуты:606607#### `SSLSocket.do_handshake()`608609Выполняет рукопожатие для настройки SSL.610611Изменено в версии 2.7.9: Метод handshake также выполняет [`match_hostname()`](https://python-all.ru/2.7/library/ssl.html#ssl.match_hostname), когда атрибут [`check_hostname`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.check_hostname) сокета [`context`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.context) имеет значение true.612613#### `SSLSocket.getpeercert(binary_form=False)`614615Если для однорангового узла на другом конце соединения нет сертификата, возвращается `None`. Если рукопожатие SSL еще не выполнено, вызывается исключение [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError).616617Если параметр `binary_form` равен [`False`](https://python-all.ru/2.7/library/constants.html#False) и от однорангового узла получен сертификат, этот метод возвращает экземпляр [`dict`](https://python-all.ru/2.7/library/stdtypes.html#dict). Если сертификат не был проверен, словарь пуст. Если сертификат был проверен, возвращается словарь с несколькими ключами, среди которых `subject` (субъект, для которого выдан сертификат) и `issuer` (субъект, выдавший сертификат). Если сертификат содержит экземпляр расширения *Subject Alternative Name* (см. [**RFC 3280**](https://python-all.ru/2.7/library/ssl.html)), в словаре также будет ключ `subjectAltName`.618619Поля `subject` и `issuer` – это кортежи, содержащие последовательность относительных отличительных имен (RDN) в структуре данных сертификата для соответствующих полей, причем каждый RDN является последовательностью пар имя-значение. Вот реальный пример:620621```python622{'issuer': ((('countryName', 'IL'),),623            (('organizationName', 'StartCom Ltd.'),),624            (('organizationalUnitName',625              'Secure Digital Certificate Signing'),),626            (('commonName',627              'StartCom Class 2 Primary Intermediate Server CA'),)),628 'notAfter': 'Nov 22 08:15:19 2013 GMT',629 'notBefore': 'Nov 21 03:09:52 2011 GMT',630 'serialNumber': '95F0',631 'subject': ((('description', '571208-SLe257oHY9fVQ07Z'),),632             (('countryName', 'US'),),633             (('stateOrProvinceName', 'California'),),634             (('localityName', 'San Francisco'),),635             (('organizationName', 'Electronic Frontier Foundation, Inc.'),),636             (('commonName', '*.eff.org'),),637             (('emailAddress', 'hostmaster@eff.org'),)),638 'subjectAltName': (('DNS', '*.eff.org'), ('DNS', 'eff.org')),639 'version': 3}640```641642> **Примечание**643>644> Для проверки сертификата для конкретной службы можно использовать функцию [`match_hostname()`](https://python-all.ru/2.7/library/ssl.html#ssl.match_hostname).645646Если параметр `binary_form` равен [`True`](https://python-all.ru/2.7/library/constants.html#True) и сертификат был предоставлен, этот метод возвращает DER-кодированную форму всего сертификата в виде последовательности байтов или [`None`](https://python-all.ru/2.7/library/constants.html#None), если одноранговый узел не предоставил сертификат. Предоставляет ли одноранговый узел сертификат, зависит от роли SSL-сокета:647648- для клиентского SSL-сокета сервер всегда предоставляет сертификат, независимо от того, требовалась ли проверка;649- для серверного SSL-сокета клиент предоставляет сертификат только по запросу сервера; поэтому [`getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert) вернет [`None`](https://python-all.ru/2.7/library/constants.html#None), если использовался [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE) (а не [`CERT_OPTIONAL`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED)).650651Изменено в версии 2.7.9: Возвращаемый словарь содержит дополнительные элементы, такие как `issuer` и `notBefore`. Кроме того, [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError) вызывается, если рукопожатие не выполнено. Возвращаемый словарь содержит дополнительные элементы расширения X509v3, такие как `crlDistributionPoints`, `caIssuers` и URI `OCSP`.652653#### `SSLSocket.cipher()`654655Возвращает кортеж из трех значений: название используемого шифра, версию протокола SSL, определяющую его использование, и количество используемых секретных бит. Если соединение не установлено, возвращает `None`.656657#### `SSLSocket.compression()`658659Возвращает используемый алгоритм сжатия в виде строки или `None`, если соединение не сжато.660661Если протокол более высокого уровня поддерживает собственный механизм сжатия, можно использовать [`OP_NO_COMPRESSION`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_COMPRESSION) для отключения сжатия на уровне SSL.662663Новое в версии 2.7.9.664665#### `SSLSocket.get_channel_binding(cb_type="tls-unique")`666667Получает данные привязки канала для текущего соединения в виде объекта bytes. Возвращает `None`, если нет соединения или рукопожатие не завершено.668669Параметр *cb\_type* позволяет выбрать желаемый тип привязки канала. Допустимые типы привязки канала перечислены в списке [`CHANNEL_BINDING_TYPES`](https://python-all.ru/2.7/library/ssl.html#ssl.CHANNEL_BINDING_TYPES). В настоящее время поддерживается только привязка канала 'tls-unique', определяемая [**RFC 5929**](https://python-all.ru/2.7/library/ssl.html). Если запрошен неподдерживаемый тип привязки канала, будет вызвано [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError).670671Новое в версии 2.7.9.672673#### `SSLSocket.selected_alpn_protocol()`674675Возвращает протокол, выбранный во время рукопожатия TLS. Если [`SSLContext.set_alpn_protocols()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_alpn_protocols) не был вызван, другая сторона не поддерживает ALPN, этот сокет не поддерживает ни один из предложенных клиентом протоколов, или рукопожатие ещё не произошло, возвращается `None`.676677Новое в версии 2.7.10.678679#### `SSLSocket.selected_npn_protocol()`680681Возвращает протокол более высокого уровня, выбранный во время рукопожатия TLS/SSL. Если [`SSLContext.set_npn_protocols()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_npn_protocols) не был вызван, или другая сторона не поддерживает NPN, или рукопожатие ещё не произошло, возвращается `None`.682683Новое в версии 2.7.9.684685#### `SSLSocket.unwrap()`686687Выполняет рукопожатие завершения SSL, которое удаляет слой TLS из базового сокета и возвращает объект базового сокета. Это можно использовать для перехода от зашифрованной работы по соединению к незашифрованной. Возвращённый сокет всегда следует использовать для дальнейшего обмена данными с другой стороной соединения, а не исходный сокет.688689#### `SSLSocket.version()`690691Возвращает фактическую версию SSL-протокола, согласованную соединением, в виде строки, или `None`, если безопасное соединение не установлено. На момент написания возможные возвращаемые значения включают `"SSLv2"`, `"SSLv3"`, `"TLSv1"`, `"TLSv1.1"` и `"TLSv1.2"`. В новых версиях OpenSSL могут быть добавлены другие возвращаемые значения.692693Новое в версии 2.7.9.694695#### `SSLSocket.context`696697Объект [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext), к которому привязан этот SSL-сокет. Если SSL-сокет был создан с помощью функции верхнего уровня [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket) (а не [`SSLContext.wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.wrap_socket)), это собственный объект контекста, созданный для этого SSL-сокета.698699Новое в версии 2.7.9.700701## 17.3.3. Контексты SSL702703Новое в версии 2.7.9.704705Контекст SSL хранит различные данные, которые живут дольше, чем отдельные SSL-соединения, такие как параметры конфигурации SSL, сертификат(ы) и закрытый(е) ключ(и). Он также управляет кешем SSL-сессий для серверных сокетов, чтобы ускорить повторные подключения от одних и тех же клиентов.706707#### `class ssl.SSLContext(protocol)`708709Создаёт новый SSL-контекст. Необходимо передать *протокол*, который должен быть одной из констант `PROTOCOL_*`, определённых в этом модуле. [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23) в настоящее время рекомендуется для максимальной совместимости.710711> **См. также**712>713> [`create_default_context()`](https://python-all.ru/2.7/library/ssl.html#ssl.create_default_context) позволяет модулю [`ssl`](https://python-all.ru/2.7/library/ssl.html#module-ssl) выбирать настройки безопасности для заданной цели.714715Изменено в версии 2.7.16: Контекст создаётся с безопасными значениями по умолчанию. По умолчанию устанавливаются опции [`OP_NO_COMPRESSION`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_COMPRESSION), [`OP_CIPHER_SERVER_PREFERENCE`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_CIPHER_SERVER_PREFERENCE), [`OP_SINGLE_DH_USE`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_SINGLE_DH_USE), [`OP_SINGLE_ECDH_USE`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_SINGLE_ECDH_USE), [`OP_NO_SSLv2`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv2) (кроме [`PROTOCOL_SSLv2`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv2)) и [`OP_NO_SSLv3`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv3) (кроме [`PROTOCOL_SSLv3`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv3)). Исходный список наборов шифров содержит только `HIGH` шифры, без `NULL` шифров и без `MD5` шифров (кроме [`PROTOCOL_SSLv2`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv2)).716717Объекты [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) имеют следующие методы и атрибуты:718719#### `SSLContext.cert_store_stats()`720721Возвращает словарь со статистикой о количестве загруженных X.509 сертификатов, количестве сертификатов X.509, помеченных как сертификаты CA, и списках отзыва сертификатов.722723Пример для контекста с одним сертификатом CA и одним другим сертификатом:724725```python726>>> context.cert_store_stats()727{'crl': 0, 'x509_ca': 1, 'x509': 2}728```729730#### `SSLContext.load_cert_chain(certfile, keyfile=None, password=None)`731732Загружает закрытый ключ и соответствующий сертификат. Строка *certfile* должна быть путём к одному файлу в формате PEM, содержащему сертификат, а также любое количество сертификатов УЦ, необходимых для подтверждения подлинности сертификата. Строка *keyfile*, если указана, должна указывать на файл, содержащий закрытый ключ. В противном случае закрытый ключ также будет взят из *certfile*. Смотрите обсуждение [Certificates](https://python-all.ru/2.7/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как сертификат хранится в *certfile*.733734Аргумент *password* может быть функцией, вызываемой для получения пароля для расшифровки закрытого ключа. Она будет вызвана только в том случае, если закрытый ключ зашифрован и требуется пароль. Она будет вызвана без аргументов, и должна возвращать строку, bytes или bytearray. Если возвращаемое значение – строка, она будет закодирована в UTF-8 перед использованием для расшифровки ключа. В качестве альтернативы, строка, bytes или bytearray могут быть переданы напрямую в качестве аргумента *password*. Этот аргумент будет проигнорирован, если закрытый ключ не зашифрован и пароль не требуется.735736Если аргумент *password* не указан и требуется пароль, будет использован встроенный механизм запроса пароля OpenSSL для интерактивного запроса пароля у пользователя.737738Вызывается исключение [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError), если закрытый ключ не соответствует сертификату.739740#### `SSLContext.load_default_certs(purpose=Purpose.SERVER_AUTH)`741742Загружает набор сертификатов по умолчанию от «центров сертификации» (CA) из расположений по умолчанию. В Windows загружает сертификаты CA из системных хранилищ `CA` и `ROOT`. В других системах вызывает [`SSLContext.set_default_verify_paths()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_default_verify_paths). В будущем метод может также загружать сертификаты CA из других расположений.743744Флаг *purpose* определяет, какие именно сертификаты CA загружаются. Настройка по умолчанию [`Purpose.SERVER_AUTH`](https://python-all.ru/2.7/library/ssl.html#ssl.Purpose.SERVER_AUTH) загружает сертификаты, помеченные и доверенные для аутентификации TLS веб-сервера (клиентские сокеты). [`Purpose.CLIENT_AUTH`](https://python-all.ru/2.7/library/ssl.html#ssl.Purpose.CLIENT_AUTH) загружает сертификаты CA для проверки сертификата клиента на стороне сервера.745746#### `SSLContext.load_verify_locations(cafile=None, capath=None, cadata=None)`747748Загружает набор сертификатов "центров сертификации" (CA), используемых для проверки сертификатов других узлов, когда [`verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) отличается от [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE). Должен быть указан хотя бы один из параметров *cafile* или *capath*.749750Этот метод также может загружать списки отзыва сертификатов (CRL) в формате PEM или DER. Чтобы использовать CRL, необходимо правильно настроить [`SSLContext.verify_flags`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_flags).751752Строка *cafile*, если присутствует, содержит путь к файлу, содержащему объединённые сертификаты CA в формате PEM. См. обсуждение [Сертификаты](https://python-all.ru/2.7/library/ssl.html#ssl-certificates) для получения дополнительной информации о том, как организовать сертификаты в этом файле.753754Строка *capath*, если присутствует, задаёт путь к каталогу, содержащему несколько сертификатов CA в формате PEM, согласно [специфической структуре OpenSSL](https://python-all.ru/2.7/library/ssl.html).755756Объект *cadata*, если он присутствует, представляет собой либо ASCII-строку с одним или несколькими сертификатами в кодировке PEM, либо байтоподобный объект с сертификатами в кодировке DER. Как и в случае с *capath*, дополнительные строки вокруг сертификатов в кодировке PEM игнорируются, но должен присутствовать хотя бы один сертификат.757758#### `SSLContext.get_ca_certs(binary_form=False)`759760Возвращает список загруженных сертификатов “certification authority” (CA). Если параметр `binary_form` равен [`False`](https://python-all.ru/2.7/library/constants.html#False), каждый элемент списка представляет собой словарь, аналогичный выводу [`SSLSocket.getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert). В противном случае метод возвращает список сертификатов в формате DER. Возвращаемый список не содержит сертификаты из *capath*, если только сертификат не был запрошен и загружен через SSL-соединение.761762> **Примечание**763>764> Сертификаты в каталоге capath не загружаются, пока не будут использованы хотя бы один раз.765766#### `SSLContext.set_default_verify_paths()`767768Загружает набор сертификатов по умолчанию “certification authority” (CA) из пути файловой системы, заданного при сборке библиотеки OpenSSL. К сожалению, нет простого способа узнать, успешно ли выполняется этот метод: ошибка не возвращается, если сертификаты не найдены. Однако, если библиотека OpenSSL поставляется как часть операционной системы, она, скорее всего, настроена правильно.769770#### `SSLContext.set_ciphers(ciphers)`771772Устанавливает доступные шифры для сокетов, создаваемых с этим контекстом. Значение должно быть строкой в [формате списка шифров OpenSSL](https://python-all.ru/2.7/library/ssl.html). Если ни один шифр не может быть выбран (из-за опций компиляции или других настроек, запрещающих использование всех указанных шифров), будет вызвано исключение [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError).773774> **Примечание**775>776> при подключении метод [`SSLSocket.cipher()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.cipher) SSL-сокетов вернёт текущий выбранный шифр.777>778> OpenSSL 1.1.1 включает наборы шифров TLS 1.3 по умолчанию. Эти наборы нельзя отключить с помощью [`set_ciphers()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_ciphers).779780#### `SSLContext.set_alpn_protocols(protocols)`781782Определяет, какие протоколы сокет должен объявлять во время рукопожатия SSL/TLS. Это должен быть список строк ASCII, например `['http/1.1', 'spdy/2']`, упорядоченных по предпочтению. Выбор протокола происходит во время рукопожатия и выполняется в соответствии с [**RFC 7301**](https://python-all.ru/2.7/library/ssl.html). После успешного рукопожатия метод [`SSLSocket.selected_alpn_protocol()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol) вернёт согласованный протокол.783784Этот метод вызовет [`NotImplementedError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.NotImplementedError), если [`HAS_ALPN`](https://python-all.ru/2.7/library/ssl.html#ssl.HAS_ALPN) равно False.785786OpenSSL 1.1.0 – 1.1.0e прерывает рукопожатие и вызывает [`SSLError`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLError) когда обе стороны поддерживают ALPN, но не могут согласовать протокол. Начиная с 1.1.0f поведение аналогично версии 1.0.2, [`SSLSocket.selected_alpn_protocol()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol) возвращает None.787788Новое в версии 2.7.10.789790#### `SSLContext.set_npn_protocols(protocols)`791792Указывает, какие протоколы сокет должен объявлять во время рукопожатия SSL/TLS. Это должен быть список строк, например `['http/1.1', 'spdy/2']`, отсортированный по предпочтению. Выбор протокола произойдет во время рукопожатия и будет выполняться в соответствии с [черновой спецификацией NPN](https://python-all.ru/2.7/library/ssl.html). После успешного рукопожатия метод [`SSLSocket.selected_npn_protocol()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.selected_npn_protocol) вернет согласованный протокол.793794Этот метод вызовет [`NotImplementedError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.NotImplementedError), если [`HAS_NPN`](https://python-all.ru/2.7/library/ssl.html#ssl.HAS_NPN) равно False.795796#### `SSLContext.set_servername_callback(server_name_callback)`797798Регистрирует функцию обратного вызова, которая будет вызвана после получения сервером SSL/TLS сообщения TLS Client Hello, когда клиент TLS указывает индикацию имени сервера. Механизм индикации имени сервера описан в [**RFC 6066**](https://python-all.ru/2.7/library/ssl.html) раздел 3 – Server Name Indication.799800Для одного `SSLContext` можно установить только один колбэк. Если *server\_name\_callback* равен `None`, то колбэк отключается. Повторный вызов этой функции отключит ранее зарегистрированный колбэк.801802Функция обратного вызова *server\_name\_callback* будет вызвана с тремя аргументами: первый – `ssl.SSLSocket`, второй – строка, представляющая имя сервера, с которым клиент намерен установить связь (или [`None`](https://python-all.ru/2.7/library/constants.html#None), если TLS Client Hello не содержит имени сервера), а третий аргумент – исходный [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext). Аргумент имени сервера – это декодированное по IDNA имя сервера.803804Типичное использование этого колбэка – изменить атрибут [`SSLSocket.context`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.context) объекта `ssl.SSLSocket` на новый объект типа [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext), представляющий цепочку сертификатов, соответствующую имени сервера.805806Из-за ранней фазы согласования TLS-соединения доступны только ограниченные методы и атрибуты, такие как [`SSLSocket.selected_alpn_protocol()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.selected_alpn_protocol) и [`SSLSocket.context`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.context). Методы [`SSLSocket.getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert), [`SSLSocket.getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert), [`SSLSocket.cipher()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.cipher) и `SSLSocket.compress()` требуют, чтобы TLS-соединение прошло стадию TLS Client Hello, и поэтому не будут возвращать осмысленные значения, и их нельзя вызывать безопасно.807808Функция *server\_name\_callback* должна возвращать `None`, чтобы продолжить согласование TLS. Если требуется ошибка TLS, можно вернуть константу [`ALERT_DESCRIPTION_*`](https://python-all.ru/2.7/library/ssl.html#ssl.ALERT_DESCRIPTION_INTERNAL_ERROR). Другие возвращаемые значения приведут к фатальной ошибке TLS с [`ALERT_DESCRIPTION_INTERNAL_ERROR`](https://python-all.ru/2.7/library/ssl.html#ssl.ALERT_DESCRIPTION_INTERNAL_ERROR).809810Если при декодировании имени сервера по IDNA произошла ошибка, TLS-соединение будет завершено с фатальным предупреждением TLS [`ALERT_DESCRIPTION_INTERNAL_ERROR`](https://python-all.ru/2.7/library/ssl.html#ssl.ALERT_DESCRIPTION_INTERNAL_ERROR) для клиента.811812Если из функции *server\_name\_callback* возникнет исключение, TLS-соединение будет завершено с фатальным предупреждением TLS [`ALERT_DESCRIPTION_HANDSHAKE_FAILURE`](https://python-all.ru/2.7/library/ssl.html#ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE).813814Этот метод вызовет исключение [`NotImplementedError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.NotImplementedError), если библиотека OpenSSL была собрана с определённым OPENSSL\_NO\_TLSEXT.815816#### `SSLContext.load_dh_params(dhfile)`817818Загружает параметры генерации ключей для обмена ключами Диффи-Хеллмана (DH). Использование обмена ключами DH улучшает прямую секретность за счет вычислительных ресурсов (как на сервере, так и на клиенте). Параметр *dhfile* должен быть путем к файлу, содержащему параметры DH в формате PEM.819820Этот параметр не применяется к клиентским сокетам. Также можно использовать опцию [`OP_SINGLE_DH_USE`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_SINGLE_DH_USE) для дальнейшего повышения безопасности.821822#### `SSLContext.set_ecdh_curve(curve_name)`823824Устанавливает имя кривой для обмена ключами на основе эллиптических кривых (ECDH). ECDH значительно быстрее обычного DH, при этом, возможно, столь же безопасен. Параметр *curve\_name* должен быть строкой, описывающей известную эллиптическую кривую, например `prime256v1` для широко поддерживаемой кривой.825826Этот параметр не применяется к клиентским сокетам. Также можно использовать опцию [`OP_SINGLE_ECDH_USE`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_SINGLE_ECDH_USE) для дальнейшего повышения безопасности.827828Этот метод недоступен, если [`HAS_ECDH`](https://python-all.ru/2.7/library/ssl.html#ssl.HAS_ECDH) имеет значение `False`.829830> **См. также**831>832> **[SSL/TLS и совершенная прямая секретность](https://python-all.ru/2.7/library/ssl.html)**833>834> Vincent Bernat.835836#### `SSLContext.wrap_socket(sock, server_side=False, do_handshake_on_connect=True, suppress_ragged_eofs=True, server_hostname=None)`837838Оборачивает существующий сокет Python *sock* и возвращает объект `SSLSocket`. *sock* должен быть сокетом [`SOCK_STREAM`](https://python-all.ru/2.7/library/socket.html#socket.SOCK_STREAM); другие типы сокетов не поддерживаются.839840Возвращаемый SSL-сокет привязан к контексту, его настройкам и сертификатам. Параметры *server\_side*, *do\_handshake\_on\_connect* и *suppress\_ragged\_eofs* имеют тот же смысл, что и в функции верхнего уровня [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket).841842Для клиентских подключений необязательный параметр *server\_hostname* задаёт имя хоста службы, к которой выполняется подключение. Это позволяет одному серверу размещать несколько SSL-служб с разными сертификатами, аналогично виртуальным хостам HTTP. Указание *server\_hostname* вызовет исключение [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError), если *server\_side* равно true.843844Изменено в версии 2.7.9: Всегда разрешается передавать server\_hostname, даже если в OpenSSL нет SNI.845846#### `SSLContext.session_stats()`847848Получает статистику о сеансах SSL, созданных или управляемых этим контекстом. Возвращается словарь, который сопоставляет названия каждого [фрагмента информации](https://python-all.ru/2.7/library/ssl.html) с их числовыми значениями. Например, вот общее количество попаданий и промахов в кэше сеансов с момента создания контекста:849850```python851>>> stats = context.session_stats()852>>> stats['hits'], stats['misses']853(0, 0)854```855856#### `SSLContext.check_hostname`857858Определяет, следует ли сопоставлять имя хоста сертификата узла с [`match_hostname()`](https://python-all.ru/2.7/library/ssl.html#ssl.match_hostname) в [`SSLSocket.do_handshake()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.do_handshake). Для контекста [`verify_mode`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.verify_mode) должно быть установлено значение [`CERT_OPTIONAL`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED), и необходимо передать *server\_hostname* в [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.wrap_socket), чтобы сопоставить имя хоста.859860Пример:861862```python863import socket, ssl864865context = ssl.SSLContext(ssl.PROTOCOL_TLS)866context.verify_mode = ssl.CERT_REQUIRED867context.check_hostname = True868context.load_default_certs()869870s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)871ssl_sock = context.wrap_socket(s, server_hostname='www.verisign.com')872ssl_sock.connect(('www.verisign.com', 443))873```874875> **Примечание**876>877> Эта возможность требует OpenSSL 0.9.8f или новее.878879#### `SSLContext.options`880881Целое число, представляющее набор опций SSL, включённых в этом контексте. Значение по умолчанию – [`OP_ALL`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_ALL), но можно указать другие опции, например [`OP_NO_SSLv2`](https://python-all.ru/2.7/library/ssl.html#ssl.OP_NO_SSLv2), комбинируя их с помощью OR.882883> **Примечание**884>885> В версиях OpenSSL старше 0.9.8m можно только устанавливать параметры, но не сбрасывать их. Попытка сбросить параметр (обнулив соответствующие биты) приведёт к `ValueError`.886887#### `SSLContext.protocol`888889Версия протокола, выбранная при создании контекста. Этот атрибут доступен только для чтения.890891#### `SSLContext.verify_flags`892893Флаги для операций проверки сертификатов. Можно устанавливать флаги, например [`VERIFY_CRL_CHECK_LEAF`](https://python-all.ru/2.7/library/ssl.html#ssl.VERIFY_CRL_CHECK_LEAF), комбинируя их с помощью ИЛИ. По умолчанию OpenSSL не требует и не проверяет списки отзыва сертификатов (CRL). Доступно только с OpenSSL версии 0.9.8 и выше.894895#### `SSLContext.verify_mode`896897Определяет, следует ли проверять сертификаты других одноранговых узлов и как вести себя при неудачной проверке. Значение атрибута должно быть одним из [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE), [`CERT_OPTIONAL`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_OPTIONAL) или [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED).898899## 17.3.4. Сертификаты900901Сертификаты в целом являются частью системы открытых и закрытых ключей. В этой системе каждому *субъекту* (которым может быть машина, человек или организация) присваивается уникальный двухчастный ключ шифрования. Одна часть ключа является открытой и называется *открытым ключом*; другая часть хранится в секрете и называется *закрытым ключом*. Две части связаны так, что если зашифровать сообщение одной частью, его можно расшифровать только другой частью, и **только** другой частью.902903Сертификат содержит информацию о двух субъектах. Он содержит имя *субъекта* и его открытый ключ. Также он содержит заявление второго субъекта – *эмитента*, о том, что субъект является тем, за кого себя выдаёт, и что это действительно его открытый ключ. Заявление эмитента подписано закрытым ключом эмитента, который знает только эмитент. Однако любой может проверить заявление эмитента, найдя его открытый ключ, расшифровав им заявление и сравнив его с другой информацией в сертификате. Сертификат также содержит информацию о периоде времени, в течение которого он действителен. Это выражается двумя полями, называемыми «notBefore» и «notAfter».904905При использовании сертификатов в Python клиент или сервер может использовать сертификат для подтверждения своей личности. Другая сторона сетевого соединения также может быть обязана предоставить сертификат, и этот сертификат может быть проверен к удовлетворению клиента или сервера, требующего такой проверки. Можно настроить попытку соединения так, чтобы она вызывала исключение, если проверка не удалась. Проверка выполняется автоматически базовым фреймворком OpenSSL; приложению не нужно вникать в её механику. Но приложению обычно необходимо предоставить наборы сертификатов, чтобы этот процесс мог происходить.906907Python uses files to contain certificates. They should be formatted as “PEM” (see [**RFC 1422**](https://python-all.ru/2.7/library/ssl.html)), which is a base-64 encoded form wrapped with a header line and a footer line:908909```python910-----BEGIN CERTIFICATE-----911... (certificate in base64 PEM encoding) ...912-----END CERTIFICATE-----913```914915### 17.3.4.1. Цепочки сертификатов916917The 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:918919```python920-----BEGIN CERTIFICATE-----921... (certificate for your server)...922-----END CERTIFICATE-----923-----BEGIN CERTIFICATE-----924... (the certificate for the CA)...925-----END CERTIFICATE-----926-----BEGIN CERTIFICATE-----927... (the root certificate for the CA's issuer)...928-----END CERTIFICATE-----929```930931### 17.3.4.2. Сертификаты CA932933Если требуется проверка сертификата другой стороны соединения, необходимо предоставить файл «CA certs», содержащий цепочки сертификатов для каждого эмитента, которому вы готовы доверять. Этот файл просто содержит эти цепочки, объединённые вместе. Для проверки Python будет использовать первую найденную в файле подходящую цепочку. Файл сертификатов платформы можно использовать, вызвав [`SSLContext.load_default_certs()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_default_certs); это делается автоматически с помощью [`create_default_context()`](https://python-all.ru/2.7/library/ssl.html#ssl.create_default_context).934935### 17.3.4.3. Объединенный ключ и сертификат936937Часто закрытый ключ хранится в том же файле, что и сертификат; в этом случае достаточно передать только параметр `certfile` функциям [`SSLContext.load_cert_chain()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_cert_chain) и [`wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.wrap_socket). Если закрытый ключ хранится вместе с сертификатом, он должен располагаться перед первым сертификатом в цепочке сертификатов:938939```python940-----BEGIN RSA PRIVATE KEY-----941... (private key in base64 encoding) ...942-----END RSA PRIVATE KEY-----943-----BEGIN CERTIFICATE-----944... (certificate in base64 PEM encoding) ...945-----END CERTIFICATE-----946```947948### 17.3.4.4. Самоподписанные сертификаты949950Если планируется создать сервер, предоставляющий услуги SSL-защищённого соединения, потребуется приобрести сертификат для этой службы. Существует много способов получения подходящих сертификатов, например покупка в удостоверяющем центре. Ещё одна распространённая практика – сгенерировать самоподписанный сертификат. Самый простой способ сделать это – использовать пакет OpenSSL, примерно следующим образом:951952```python953% openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem954Generating a 1024 bit RSA private key955.......++++++956.............................++++++957writing new private key to 'cert.pem'958-----959You are about to be asked to enter information that will be incorporated960into your certificate request.961What you are about to enter is what is called a Distinguished Name or a DN.962There are quite a few fields but you can leave some blank963For some fields there will be a default value,964If you enter '.', the field will be left blank.965-----966Country Name (2 letter code) [AU]:US967State or Province Name (full name) [Some-State]:MyState968Locality Name (eg, city) []:Some City969Organization Name (eg, company) [Internet Widgits Pty Ltd]:My Organization, Inc.970Organizational Unit Name (eg, section) []:My Group971Common Name (eg, YOUR name) []:myserver.mygroup.myorganization.com972Email Address []:ops@myserver.mygroup.myorganization.com973%974```975976Недостаток самоподписанного сертификата в том, что он является собственным корневым сертификатом, и никто другой не будет иметь его в своём кэше известных (и доверенных) корневых сертификатов.977978## 17.3.5. Примеры979980### 17.3.5.1. Проверка поддержки SSL981982Чтобы проверить наличие поддержки SSL в установке Python, в пользовательском коде следует использовать следующую идиому:983984```python985try:986    import ssl987except ImportError:988    pass989else:990    ...  # сделать что-то, что требует поддержки SSL991```992993### 17.3.5.2. Работа на стороне клиента994995Этот пример создаёт контекст SSL с рекомендуемыми настройками безопасности для клиентских сокетов, включая автоматическую проверку сертификатов:996997```python998>>> context = ssl.create_default_context()999```10001001Если вы предпочитаете настраивать параметры безопасности самостоятельно, можно создать контекст с нуля (но имейте в виду, что настройки могут оказаться неверными):10021003```python1004>>> context = ssl.SSLContext(ssl.PROTOCOL_TLS)1005>>> context.verify_mode = ssl.CERT_REQUIRED1006>>> context.check_hostname = True1007>>> context.load_verify_locations("/etc/ssl/certs/ca-bundle.crt")1008```10091010(этот фрагмент предполагает, что ваша операционная система размещает набор всех сертификатов CA в `/etc/ssl/certs/ca-bundle.crt`; если нет, вы получите ошибку и придётся изменить расположение)10111012При использовании контекста для подключения к серверу [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED) проверяет сертификат сервера: он удостоверяется, что сертификат сервера был подписан одним из сертификатов CA, и проверяет подпись на корректность:10131014```python1015>>> conn = context.wrap_socket(socket.socket(socket.AF_INET),1016...                            server_hostname="www.python.org")1017>>> conn.connect(("www.python.org", 443))1018```10191020Затем можно получить сертификат:10211022```python1023>>> cert = conn.getpeercert()1024```10251026Визуальная проверка показывает, что сертификат действительно идентифицирует нужный сервис (то есть HTTPS-хост `www.python.org`):10271028```python1029>>> pprint.pprint(cert)1030{'OCSP': ('http://ocsp.digicert.com',),1031 'caIssuers': ('http://cacerts.digicert.com/DigiCertSHA2ExtendedValidationServerCA.crt',),1032 'crlDistributionPoints': ('http://crl3.digicert.com/sha2-ev-server-g1.crl',1033                           'http://crl4.digicert.com/sha2-ev-server-g1.crl'),1034 'issuer': ((('countryName', 'US'),),1035            (('organizationName', 'DigiCert Inc'),),1036            (('organizationalUnitName', 'www.digicert.com'),),1037            (('commonName', 'DigiCert SHA2 Extended Validation Server CA'),)),1038 'notAfter': 'Sep  9 12:00:00 2016 GMT',1039 'notBefore': 'Sep  5 00:00:00 2014 GMT',1040 'serialNumber': '01BB6F00122B177F36CAB49CEA8B6B26',1041 'subject': ((('businessCategory', 'Private Organization'),),1042             (('1.3.6.1.4.1.311.60.2.1.3', 'US'),),1043             (('1.3.6.1.4.1.311.60.2.1.2', 'Delaware'),),1044             (('serialNumber', '3359300'),),1045             (('streetAddress', '16 Allen Rd'),),1046             (('postalCode', '03894-4801'),),1047             (('countryName', 'US'),),1048             (('stateOrProvinceName', 'NH'),),1049             (('localityName', 'Wolfeboro,'),),1050             (('organizationName', 'Python Software Foundation'),),1051             (('commonName', 'www.python.org'),)),1052 'subjectAltName': (('DNS', 'www.python.org'),1053                    ('DNS', 'python.org'),1054                    ('DNS', 'pypi.org'),1055                    ('DNS', 'docs.python.org'),1056                    ('DNS', 'testpypi.python.org'),1057                    ('DNS', 'bugs.python.org'),1058                    ('DNS', 'wiki.python.org'),1059                    ('DNS', 'hg.python.org'),1060                    ('DNS', 'mail.python.org'),1061                    ('DNS', 'packaging.python.org'),1062                    ('DNS', 'pythonhosted.org'),1063                    ('DNS', 'www.pythonhosted.org'),1064                    ('DNS', 'test.pythonhosted.org'),1065                    ('DNS', 'us.pycon.org'),1066                    ('DNS', 'id.python.org')),1067 'version': 3}1068```10691070Теперь, когда SSL-канал установлен и сертификат проверен, можно продолжить обмен данными с сервером:10711072```python1073>>> conn.sendall(b"HEAD / HTTP/1.0\r\nHost: linuxfr.org\r\n\r\n")1074>>> pprint.pprint(conn.recv(1024).split(b"\r\n"))1075[b'HTTP/1.1 200 OK',1076 b'Date: Sat, 18 Oct 2014 18:27:20 GMT',1077 b'Server: nginx',1078 b'Content-Type: text/html; charset=utf-8',1079 b'X-Frame-Options: SAMEORIGIN',1080 b'Content-Length: 45679',1081 b'Accept-Ranges: bytes',1082 b'Via: 1.1 varnish',1083 b'Age: 2188',1084 b'X-Served-By: cache-lcy1134-LCY',1085 b'X-Cache: HIT',1086 b'X-Cache-Hits: 11',1087 b'Vary: Cookie',1088 b'Strict-Transport-Security: max-age=63072000; includeSubDomains',1089 b'Connection: close',1090 b'',1091 b'']1092```10931094См. обсуждение [соображений безопасности](https://python-all.ru/2.7/library/ssl.html#ssl-security) ниже.10951096### 17.3.5.3. Работа на стороне сервера10971098Для работы на стороне сервера обычно нужно иметь сертификат сервера и закрытый ключ, каждый в отдельном файле. Сначала создаётся контекст, содержащий ключ и сертификат, чтобы клиенты могли проверить подлинность. Затем открывается сокет, привязывается к порту, вызывается `listen()`, и начинается ожидание подключения клиентов:10991100```python1101import socket, ssl11021103context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)1104context.load_cert_chain(certfile="mycertfile", keyfile="mykeyfile")11051106bindsocket = socket.socket()1107bindsocket.bind(('myaddr.mydomain.com', 10023))1108bindsocket.listen(5)1109```11101111Когда клиент подключается, вызывается `accept()` на сокете, чтобы получить новый сокет с другого конца, и используется метод контекста [`SSLContext.wrap_socket()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.wrap_socket) для создания серверного SSL-сокета для этого соединения:11121113```python1114while True:1115    newsocket, fromaddr = bindsocket.accept()1116    connstream = context.wrap_socket(newsocket, server_side=True)1117    try:1118        deal_with_client(connstream)1119    finally:1120        connstream.shutdown(socket.SHUT_RDWR)1121        connstream.close()1122```11231124Затем читаются данные из `connstream` и что-то с ними делается, пока не будет завершена работа с клиентом (или клиент не завершит работу с вами):11251126```python1127def deal_with_client(connstream):1128    data = connstream.read()1129    # null-данные означают, что клиент завершил работу с нами1130    while data:1131        if not do_something(connstream, data):1132            # будем считать, что do_something возвращает False1133            # когда мы закончили с клиентом1134            break1135        data = connstream.read()1136    # закончили с клиентом1137```11381139И возврат к ожиданию новых клиентских подключений (конечно, настоящий сервер, вероятно, обрабатывал бы каждое клиентское соединение в отдельном потоке или переводил сокеты в неблокирующий режим и использовал цикл событий).11401141## 17.3.6. Примечания по неблокирующим сокетам11421143При работе с неблокирующими сокетами необходимо учитывать несколько моментов:11441145- Вызов [`select()`](https://python-all.ru/2.7/library/select.html#select.select) сообщает, что с сокета на уровне ОС можно читать (или в него можно писать), но это не означает, что на верхнем уровне SSL достаточно данных. Например, может прибыть только часть SSL-фрейма. Поэтому необходимо быть готовым обрабатывать ошибки `SSLSocket.recv()` и `SSLSocket.send()` и повторить попытку после очередного вызова [`select()`](https://python-all.ru/2.7/library/select.html#select.select).1146- И наоборот, поскольку уровень SSL имеет собственную структуру фреймов, SSL-сокет может по-прежнему иметь доступные для чтения данные без ведома [`select()`](https://python-all.ru/2.7/library/select.html#select.select). Поэтому сначала следует вызвать `SSLSocket.recv()`, чтобы извлечь все потенциально доступные данные, и затем блокироваться на вызове [`select()`](https://python-all.ru/2.7/library/select.html#select.select) только в случае необходимости.11471148  (конечно, аналогичные меры применимы и при использовании других примитивов, таких как [`poll()`](https://python-all.ru/2.7/library/select.html#select.poll), или из модуля `selectors`)1149- Само SSL-рукопожатие будет неблокирующим: метод [`SSLSocket.do_handshake()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.do_handshake) должен повторяться до тех пор, пока он не выполнится успешно. Вот краткая схема с использованием [`select()`](https://python-all.ru/2.7/library/select.html#select.select) для ожидания готовности сокета:11501151  ```python1152  while True:1153      try:1154          sock.do_handshake()1155          break1156      except ssl.SSLWantReadError:1157          select.select([sock], [], [])1158      except ssl.SSLWantWriteError:1159          select.select([], [sock], [])1160  ```11611162## 17.3.7. Вопросы безопасности11631164### 17.3.7.1. Оптимальные настройки по умолчанию11651166Для **клиентского использования**, при отсутствии особых требований к политике безопасности, настоятельно рекомендуется применять функцию [`create_default_context()`](https://python-all.ru/2.7/library/ssl.html#ssl.create_default_context) для создания SSL-контекста. Она загрузит доверенные сертификаты ЦС системы, включит проверку сертификатов и имени хоста, а также попытается выбрать достаточно безопасные настройки протокола и шифров.11671168Если для соединения требуется клиентский сертификат, его можно добавить с помощью [`SSLContext.load_cert_chain()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.load_cert_chain).11691170Напротив, при создании SSL-контекста через вызов конструктора [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) самостоятельно, в нём по умолчанию не будут включены ни проверка сертификатов, ни проверка имени хоста. В этом случае следует прочитать приведённые ниже абзацы, чтобы достичь хорошего уровня безопасности.11711172### 17.3.7.2. Ручные настройки11731174#### 17.3.7.2.1. Проверка сертификатов11751176При непосредственном вызове конструктора [`SSLContext`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext) значением по умолчанию является [`CERT_NONE`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_NONE). Поскольку он не аутентифицирует другую сторону, это может быть небезопасно, особенно в режиме клиента, где в большинстве случаев хотелось бы убедиться в подлинности сервера, с которым ведётся общение. Поэтому в режиме клиента настоятельно рекомендуется использовать [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED). Однако сам по себе он этого не гарантирует; необходимо также проверить, что сертификат сервера, который можно получить вызовом [`SSLSocket.getpeercert()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.getpeercert), соответствует нужному сервису. Для многих протоколов и приложений сервис можно определить по имени хоста; в этом случае можно использовать функцию [`match_hostname()`](https://python-all.ru/2.7/library/ssl.html#ssl.match_hostname). Эта стандартная проверка выполняется автоматически, когда включён [`SSLContext.check_hostname`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.check_hostname).11771178В серверном режиме, чтобы аутентифицировать клиентов на уровне SSL (а не с помощью механизма аутентификации более высокого уровня), необходимо также указать [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED) и аналогично проверить сертификат клиента.11791180> > **Примечание**1181> >1182> > В клиентском режиме [`CERT_OPTIONAL`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_OPTIONAL) и [`CERT_REQUIRED`](https://python-all.ru/2.7/library/ssl.html#ssl.CERT_REQUIRED) эквивалентны, если не включены анонимные шифры (отключены по умолчанию).11831184#### 17.3.7.2.2. Версии протоколов11851186Версии SSL 2 и 3 считаются небезопасными и поэтому опасны для использования. Если требуется максимальная совместимость между клиентами и серверами, рекомендуется использовать [`PROTOCOL_SSLv23`](https://python-all.ru/2.7/library/ssl.html#ssl.PROTOCOL_SSLv23) в качестве версии протокола, а затем явно отключить SSLv2 и SSLv3 с помощью атрибута [`SSLContext.options`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.options):11871188```python1189context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)1190context.options |= ssl.OP_NO_SSLv21191context.options |= ssl.OP_NO_SSLv31192```11931194Созданный выше SSL-контекст будет разрешать только соединения TLSv1 и выше (если поддерживается вашей системой).11951196#### 17.3.7.2.3. Выбор шифров11971198При повышенных требованиях безопасности тонкая настройка шифров, включённых при согласовании SSL-сеанса, возможна с помощью метода [`SSLContext.set_ciphers()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_ciphers). Начиная с Python 2.7.9, модуль ssl по умолчанию отключает некоторые слабые шифры, но может потребоваться дополнительно ограничить выбор шифров. Обязательно прочтите документацию OpenSSL о [формате списка шифров](https://python-all.ru/2.7/library/ssl.html). Если требуется проверить, какие шифры включены для данного списка, используйте команду `openssl ciphers` в вашей системе.11991200### 17.3.7.3. Многопроцессорность12011202При использовании этого модуля в составе многопроцессного приложения (с помощью, например, модулей [`multiprocessing`](https://python-all.ru/2.7/library/multiprocessing.html#module-multiprocessing) или `concurrent.futures`) следует учитывать, что внутренний генератор случайных чисел OpenSSL некорректно обрабатывает порождённые процессы. Приложения должны изменять состояние PRNG родительского процесса, если они используют любую функцию SSL с [`os.fork()`](https://python-all.ru/2.7/library/os.html#os.fork). Любого успешного вызова [`RAND_add()`](https://python-all.ru/2.7/library/ssl.html#ssl.RAND_add), `RAND_bytes()` или `RAND_pseudo_bytes()` достаточно.12031204## 17.3.8. Поддержка LibreSSL12051206LibreSSL – это форк OpenSSL 1.0.1. Модуль ssl имеет ограниченную поддержку LibreSSL. Некоторые возможности недоступны, если модуль ssl скомпилирован с LibreSSL.12071208- LibreSSL \>= 2.6.1 больше не поддерживает NPN. Методы [`SSLContext.set_npn_protocols()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_npn_protocols) и [`SSLSocket.selected_npn_protocol()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLSocket.selected_npn_protocol) недоступны.1209- [`SSLContext.set_default_verify_paths()`](https://python-all.ru/2.7/library/ssl.html#ssl.SSLContext.set_default_verify_paths) игнорирует переменные окружения `SSL_CERT_FILE` и `SSL_CERT_PATH`, хотя [`get_default_verify_paths()`](https://python-all.ru/2.7/library/ssl.html#ssl.get_default_verify_paths) всё ещё сообщает о них.12101211> **См. также**1212>1213> **Класс [`socket.socket`](https://python-all.ru/2.7/library/socket.html#socket.socket)**1214>1215> Документация базового класса [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket)1216>1217> **[SSL/TLS: надёжное шифрование. Введение](https://python-all.ru/2.7/library/ssl.html)**1218>1219> Введение из документации веб-сервера Apache1220>1221> **[RFC 1422: Улучшение конфиденциальности для интернет-электронной почты: Часть II: Управление ключами на основе сертификатов](https://python-all.ru/2.7/library/ssl.html)**1222>1223> Steve Kent1224>1225> **[RFC 1750: Рекомендации по случайности для безопасности](https://python-all.ru/2.7/library/ssl.html)**1226>1227> D. Eastlake et. al.1228>1229> **[RFC 3280: Инфраструктура открытых ключей Internet X.509 – профиль сертификатов и списков отзыва](https://python-all.ru/2.7/library/ssl.html)**1230>1231> Housley et. al.1232>1233> **[RFC 4366: Расширения безопасности транспортного уровня (TLS)](https://python-all.ru/2.7/library/ssl.html)**1234>1235> Blake-Wilson et. al.1236>1237> **[RFC 5246: Протокол безопасности транспортного уровня (TLS) версии 1.2](https://python-all.ru/2.7/library/ssl.html)**1238>1239> T. Dierks et. al.1240>1241> **[RFC 6066: Расширения безопасности транспортного уровня (TLS)](https://python-all.ru/2.7/library/ssl.html)**1242>1243> D. Eastlake1244>1245> **[IANA TLS: Параметры безопасности транспортного уровня (TLS)](https://python-all.ru/2.7/library/ssl.html)**1246>1247> IANA1248>1249> **[RFC 7525: Рекомендации по безопасному использованию протоколов защиты транспортного уровня (TLS) и дейтаграммной защиты транспортного уровня (DTLS)](https://python-all.ru/2.7/library/ssl.html)**1250>1251> IETF1252>1253> **[Рекомендации Mozilla по TLS на стороне сервера](https://python-all.ru/2.7/library/ssl.html)**1254>1255> Mozilla1256