ssl --- socket 物件的 TLS/SSL 包裝器

原始碼：Lib/ssl.py

這個模組向客戶端及伺服器端提供了對於網路 socket 的傳輸層安全性協定（或稱為「安全通訊協定 (Secure Sockets Layer)」）加密及身分驗證功能。這個模組使用 OpenSSL 套件，它可以在所有的 Unix 系統、Windows、macOS、以及其他任何可能的平台上使用，只要事先在該平台上安裝 OpenSSL。

備註

由於呼叫了作業系統的 socket APIs，有些行為會根據平台而有所不同。OpenSSL 的安裝版本也會對模組的運作產生影響。例如，OpenSSL 版本 1.1.1 附帶 TLSv1.3。

警告

在使用此模組之前，請閱讀 Security considerations。如果不這樣做，可能會產生錯誤的安全性認知，因為 ssl 模組的預設設定未必適合你的應用程式。

Availability: not WASI.

此模組在 WebAssembly 平台上不起作用或無法使用。更多資訊請參閱 WebAssembly 平台。

這個章節記錄了 ssl 模組的物件及函式；關於 TSL、SSL、以及憑證的更多資訊，可以去參考此章節底部的「詳情」部分。

This module provides a class, ssl.SSLSocket, which is derived from the socket.socket type, and provides a socket-like wrapper that also encrypts and decrypts the data going over the socket with SSL. It supports additional methods such as getpeercert(), which retrieves the certificate of the other side of the connection, cipher(), which retrieves the cipher being used for the secure connection or get_verified_chain(), get_unverified_chain() which retrieves certificate chain.

對於更複雜的應用程式，ssl.SSLContext 類別有助於管理設定及認證，然後可以透過 SSLContext.wrap_socket() 方法建立的 SSL socket 繼承這些設定和認證。

在 3.5.3 版的變更: 更新以支援與 OpenSSL 1.1.0 進行連結

在 3.6 版的變更: OpenSSL 0.9.8, 1.0.0 及 1.0.1 版本已被棄用且不再支援。在未來 ssl 模組將需要至少 OpenSSL 1.0.2 版本或 1.1.0 版本。

在 3.10 版的變更: PEP 644 已經被實作。ssl 模組需要 OpenSSL 1.1.1 以上的版本才能使用。

使用已經被棄用的常數或函式將會導致棄用警示。

函式、常數與例外

Socket 建立

SSLSocket 實例必須使用 SSLContext.wrap_socket() 方法來建立。輔助函式 create_default_context() 會回傳有安全預設設定的新語境 (context)。

使用預設語境及 IPv4/IPv6 雙協定堆疊的客戶端 socket 範例：

import socket
import ssl

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

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

使用自訂語境及 IPv4 的客戶端 socket範例：

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

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

在本地 IPv4 上監聽伺服器 socket 的範例：

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

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

語境建立

一個可以幫忙建立出 SSLContext 物件以用於一般目的的方便函式。

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

回傳一個新的 SSLContext 物件，使用給定 purpose 的預設值。這些設定是由 ssl 選擇，通常比直接呼叫 SSLContext 有更高的安全性。

cafile, capath, cadata 是用來選擇用於憑證認證的 CA 憑證，就像 SSLContext.load_verify_locations() 一樣。如果三個值都是 None，此函式會自動選擇系統預設的 CA 憑證。

這些設定包含：PROTOCOL_TLS_CLIENT 或 PROTOCOL_TLS_SERVER、OP_NO_SSLv2、以及 OP_NO_SSLv3，使用高等加密套件但不包含 RC4 和未經身份驗證的加密套件。如果將 purpose 設定為 SERVER_AUTH，則會把 verify_mode 設為 CERT_REQUIRED 並使用設定的 CA 憑證(當 cafile、capath 或 cadata 其中一個值有被設定時) 或使用預設的 CA 憑證 SSLContext.load_default_certs() 。

當系統有支援 keylog_filename 並且有設定環境變數 SSLKEYLOGFILE 時 create_default_context() 會啟用密鑰日誌記錄 (logging)。

The default settings for this context include VERIFY_X509_PARTIAL_CHAIN and VERIFY_X509_STRICT. These make the underlying OpenSSL implementation behave more like a conforming implementation of RFC 5280, in exchange for a small amount of incompatibility with older X.509 certificates.

備註

協定、選項、加密方式和其它設定可以在不捨棄舊值的情況下直接更改成新的值，這些值代表了在相容性和安全性之間取得的合理平衡。

如果你的應用程式需要特殊的設定，你應該要自行建立一個 SSLContext 並自行調整設定。

備註

如果你發現某些舊的客戶端或伺服器常適用此函式建立的 SSLContext 連線時，收到 "Protocol or cipher suite mismatch" 錯誤，這可能是因為他們的系統僅支援 SSL3.0，然而 SSL3.0 已被此函式用 OP_NO_SSLv3 排除。目前廣泛認為 SSL3.0 已經被完全破解。如果你仍然希望在允許 SSL3.0 連線的情況下使用此函式，可以使用下面的方法：

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

備註

This context enables VERIFY_X509_STRICT by default, which may reject pre-RFC 5280 or malformed certificates that the underlying OpenSSL implementation otherwise would accept. While disabling this is not recommended, you can do so using:

ctx = ssl.create_default_context()
ctx.verify_flags &= ~ssl.VERIFY_X509_STRICT

在 3.4 版被加入.

在 3.4.4 版的變更: 把 RC4 從預設加密方法字串中捨棄。

在 3.6 版的變更: 把 ChaCha20/Poly1305 加入預設加密方法字串。

把 3DES 從預設加密方法字串中捨棄。

在 3.8 版的變更: 增加了 SSLKEYLOGFILE 對密鑰日誌記錄 (logging) 的支援。

在 3.10 版的變更: 當前語境使用 PROTOCOL_TLS_CLIENT 協定或 PROTOCOL_TLS_SERVER 協定而非通用的 PROTOCOL_TLS。

在 3.13 版的變更: The context now uses VERIFY_X509_PARTIAL_CHAIN and VERIFY_X509_STRICT in its default verify flags.

例外

exception ssl.SSLError

引發由底層 SSL 實作（目前由 OpenSSL 函式庫提供）所引發的錯誤訊息。這表示在覆蓋底層網路連線的高階加密和身份驗證層中存在一些問題。這項錯誤是 OSError 的一個子型別。SSLError 實例的錯誤程式代碼和訊息是由 OpenSSL 函式庫提供。

在 3.3 版的變更: SSLError 曾經是 socket.error 的一個子型別。

library

一個字串符號 (string mnemonic)，用來指定發生錯誤的 OpenSSL 子模組，如：SSL、PEM 或 X509。可能值的範圍取決於 OpenSSL 的版本。

在 3.3 版被加入.

reason

一個字串符號，用來指定發生錯誤的原因，如：CERTIFICATE_VERIFY_FAILED。可能值的範圍取決於 OpenSSL 的版本。

在 3.3 版被加入.

exception ssl.SSLZeroReturnError

一個 SSLError 的子類別，當嘗試去讀寫已經被完全關閉的 SSL 連線時會被引發。請注意，這並不表示底層傳輸（例如 TCP）已經被關閉。

在 3.3 版被加入.

exception ssl.SSLWantReadError

一個 SSLError 的子類別，當嘗試去讀寫資料前，底層 TCP 傳輸需要先接收更多資料時會由非阻塞的 SSL socket 引發該錯誤。

在 3.3 版被加入.

exception ssl.SSLWantWriteError

一個 SSLError 的子類別，當嘗試去讀寫資料前，底層 TCP 傳輸需要先發送更多資料時會由非阻塞的 SSL socket 引發該錯誤。

在 3.3 版被加入.

exception ssl.SSLSyscallError

一個 SSLError 的子類別，當嘗試去操作 SSL socket 時有系統錯誤產生會引發此錯誤。不幸的是，目前沒有任何簡單的方法可以去檢查原本的的 errno 編號。

在 3.3 版被加入.

exception ssl.SSLEOFError

一個 SSLError 的子類別，當 SSL 連線被突然終止時會引發此錯誤。通常，當此錯誤發生時，你不該再去重新使用底層傳輸。

在 3.3 版被加入.

exception ssl.SSLCertVerificationError

當憑證驗證失敗時會引發的一個 SSLError 子類別。

在 3.7 版被加入.

verify_code

一個表示驗證錯誤的錯誤數值編號。

verify_message

一個人類可讀的驗證錯誤字串。

exception ssl.CertificateError

SSLCertVerificationError 的別名。

在 3.7 版的變更: 此例外現在是 SSLCertVerificationError 的別名。

隨機產生

ssl.RAND_bytes(num)

回傳 num 個加密性強的偽隨機位元組。如果 PRNG 未使用足夠的資料做為隨機種子 (seed) 或是目前的 RAND 方法不支持該操作則會導致 SSLError 錯誤。RAND_status() 函式可以用來檢查 PRNG 函式，而 RAND_add() 則可以用來為 PRNG 設定隨機種子。

在幾乎所有的應用程式中，os.urandom() 會是較好的選擇。

請閱讀維基百科的密碼學安全偽隨機數產生器 (CSPRNG)文章來了解密碼學安全偽隨機數產生器的需求。

在 3.3 版被加入.

ssl.RAND_status()

如果 SSL 偽隨機數產生器已經使用「足夠的」隨機性進行隨機種子生成，則回傳 True ，否則回傳 False。你可以使用 ssl.RAND_egd() 函式和 ssl.RAND_add() 函式來增加偽隨機數產生器的隨機性。

ssl.RAND_add(bytes, entropy)

將給定的 bytes 混進 SSL 隨機偽隨機數產生器中。 entropy 參數（float 值）是指字串中包含熵值的下限（因此你可以將其設為 0.0）。請參閱 RFC 1750 了解有關熵源的更多資訊。

在 3.5 版的變更: 可寫入的類位元組物件現在可被接受。

認證處理

ssl.cert_time_to_seconds(cert_time)

回傳自紀元以來的秒數，給定的 cert_time 字串表示憑證的 "notBefore" 或 "notAfter" 日期，字串採用 "%b %d %H:%M:%S %Y %Z" 格式（C 語言區域設定）。

以下是一個範例：

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

"notBefore" 或 "notAfter" 日期必須使用 GMT (RFC 5280)。

在 3.5 版的變更: 將輸入的時間直譯為 UTC 時間，如輸入字串中指定的 'GMT' 時區。在之前是使用本地的時區。回傳一個整數（在輸入格式中不包括秒的小數部分）。

ssl.get_server_certificate(addr, ssl_version=PROTOCOL_TLS_CLIENT, ca_certs=None[, timeout])

輸入使用 SSL 保護的伺服器的地址 addr，輸入形式為一個 pair (hostname, port-number)，獲取該伺服器的憑證，並以 PEM 編碼字串的形式回傳。如果指定了 ssl_version，則使用指定的 SSL 協議來嘗試與伺服器連線。如果指定 ca_certs，則它應該是一個包含根憑證列表的檔案，並與 SSLContext.load_verify_locations() 中的參數 cafile 所使用的格式相同。此呼叫將嘗試使用該組根憑證對伺服器憑證進行驗證，如果驗證失敗，呼叫將失敗。可以使用 timeout 參數指定超時時間。

在 3.3 版的變更: 此函式現在是與 IPv6 相容的。

在 3.5 版的變更: 預設的 ssl_version 已經從 PROTOCOL_SSLv3 改為 PROTOCOL_TLS，已確保與現今的伺服器有最大的相容性。

在 3.10 版的變更: 新增 timeout 參數。

ssl.DER_cert_to_PEM_cert(DER_cert_bytes)

給定一個以 DER 編碼的位元組 blob 作為憑證，回傳以 PEM 編碼字串版本的相同憑證。

ssl.PEM_cert_to_DER_cert(PEM_cert_string)

給定一個以 ASCII PEM 的字串作為憑證，回傳以 DER 編碼的位元組序列的相同憑證。

ssl.get_default_verify_paths()

回傳一個具有 OpenSSL 的預設 cafile 和 capath 路徑的附名元組。這些路徑與 SSLContext.set_default_verify_paths() 使用的相同。回傳值是一個 named tuple DefaultVerifyPaths：

  • cafile - 解析後的 cafile 路徑，如果檔案不存在則為 None，

  • capath - 解析後的 capath 路徑，如果目錄不存在則為 None，

  • openssl_cafile_env - 指向 cafile 的 OpenSSL 環境密鑰，

  • openssl_cafile - hard coded 的 cafile 路徑，

  • openssl_capath_env - 指向 capath 的 OpenSSL 環境密鑰，

  • openssl_capath - hard coded 的 capath 目錄路徑

在 3.4 版被加入.

ssl.enum_certificates(store_name)

從 Windows 的系統憑證儲存庫中搜尋憑證。store_name 可以是 CA、ROOT 或 MY 的其中一個。Windows 也可能會提供額外的憑證儲存庫。

此函式會回傳一個元組 (cert_bytes, encoding_type, trust) 串列。encoding_type 指定了 cert_bytes 的編碼格式。它可以是用來表示 X.509 ASN.1 資料的 x509_asn 或是用來表示 PKCS#7 ASN.1 資料的 pkcs_7_asn。Trust 通過一組 OIDS 來指定憑證的用途，或是如果憑證對所有用途都可以使用則回傳 True。

範例：

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

Availability: Windows.

在 3.4 版被加入.

ssl.enum_crls(store_name)

從 Windows 的系統憑證儲存庫中搜尋 CRLs。store_name 可以是 CA、ROOT 或 MY 的其中一個。Windows 也可能會提供額外的憑證儲存庫。

此函式會回傳一個元組 (cert_bytes, encoding_type, trust) 串列。encoding_type 指定了 cert_bytes 的編碼格式。它可以是用來表示 X.509 ASN.1 資料的 x509_asn 或是用來表示 PKCS#7 ASN.1 資料的 pkcs_7_asn。

Availability: Windows.

在 3.4 版被加入.

常數

所有的常數現在都是 enum.IntEnum 或 enum.IntFlag 的集合。

在 3.6 版被加入.

ssl.CERT_NONE

SSLContext.verify_mode 可能的值。除了 SSLContext.verify_mode 外，這是預設的模式。對於客戶端的 sockets，幾乎任何憑證都能被允許。驗證錯誤，像是不被信任或是過期的憑證，會被忽略並不會中止 TLS/SSL 握手。

在伺服器模式下，不會從客戶端請求任何憑證，所以客戶端不用發送任何用於客戶端憑證身分驗證的憑證。

參閱下方 Security considerations 的討論。

ssl.CERT_OPTIONAL

SSLContext.verify_mode 可能的值。在客戶端模式下，CERT_OPTIONAL 具有與 CERT_REQUIRED 相同的含意。對於客戶端 sockets 推薦改用 CERT_REQUIRED。

在伺服器模式下，客戶憑證請求會被發送給客戶端。客戶端可以選擇忽略請求或是選擇發送憑證來執行 TLS 客戶端憑證身分驗證。如果客戶端選擇發送憑證，則會對其進行驗證。任何驗證錯誤都會立刻終止 TLS 握手。

使用此設定需要將一組有效的 CA 憑證傳送給 SSLContext.load_verify_locations()。

ssl.CERT_REQUIRED

SSLContext.verify_mode 可能的值。在這個模式下，需要從 socket 連線的另一端獲取憑證；如果未提供憑證或是驗證失敗，則將會導致 SSLError。此模式 不能 在客戶端模式下對憑證進行驗證，因為它無法去配對主機名稱。check_hostname 也必須被開起來來驗證憑證的真實性。PROTOCOL_TLS_CLIENT 會使用 CERT_REQUIRED 並預設開啟 check_hostname。

對於 socket 伺服器，此模式會提供強制的 TLS 客戶端憑證驗證。客戶端憑證請求會被發送給客戶端並且客戶端必須提供有效且被信任的憑證。

使用此設定需要將一組有效的 CA 憑證傳送給 SSLContext.load_verify_locations()。

class ssl.VerifyMode

enum.IntEnum 為 CERT_* 常數的一個集合。

在 3.6 版被加入.

ssl.VERIFY_DEFAULT

SSLContext.verify_flags 可能的值。在此模式下，不會檢查憑證吊銷列表 (CRLs)。預設的 OpenSSL 並不會請求及驗證 CRLs。

在 3.4 版被加入.

ssl.VERIFY_CRL_CHECK_LEAF

SSLContext.verify_flags 可能的值。在此模式下，只會檢查同等的憑證而不會去檢查中間的 CA 憑證。此模式需要提供由對等憑證發行者 (它的直接上級 CA) 的有效的 CRL 簽名。如果沒有用 SSLContext.load_verify_locations 載入適當的 CRL，則會驗證失敗。

在 3.4 版被加入.

ssl.VERIFY_CRL_CHECK_CHAIN

SSLContext.verify_flags 可能的值。在此模式下，會檢查對等憑證鍊中所有憑證的 CRLs。

在 3.4 版被加入.

ssl.VERIFY_X509_STRICT

SSLContext.verify_flags 可能的值，用來禁用已損壞的 X.509 憑證的解決方法。

在 3.4 版被加入.

ssl.VERIFY_ALLOW_PROXY_CERTS

SSLContext.verify_flags 可能的值，用來啟用憑證代理驗證。

在 3.10 版被加入.

ssl.VERIFY_X509_TRUSTED_FIRST

SSLContext.verify_flags 可能的值。它指示 OpenSSL 在構建信任鍊來驗證憑證時會優先使用被信任的憑證。此旗標預設開啟。

在 3.4.4 版被加入.

ssl.VERIFY_X509_PARTIAL_CHAIN

SSLContext.verify_flags 可能的值。它指示 OpenSSL 接受信任存儲中的中間 CAs 作為信任錨，就像自簽名的根 CA 憑證。這樣就能去信任中間 CA 所頒發的憑證，而不一定非要去信任其祖先的根 CA。

在 3.10 版被加入.

class ssl.VerifyFlags

enum.IntFlag 為 VERIFY_* 常數的其中一個集合。

在 3.6 版被加入.

ssl.PROTOCOL_TLS

選擇客戶端及伺服器均可以支援最高協定版本。儘管名稱只有 「TLS」，但實際上「SSL」和「TLS」均可以選擇。

在 3.6 版被加入.

在 3.10 版之後被棄用: TLS 的客戶端及伺服器端需要不同的預設值來實現安全通訊。通用的 TLS 協定常數已被廢除，並改用 PROTOCOL_TLS_CLIENT 和 PROTOCOL_TLS_SERVER。

ssl.PROTOCOL_TLS_CLIENT

自動協商客戶端和服務器都支援的最高協議版本，並配置客戶端語境連線。該協定預設啟用 CERT_REQUIRED 和 check_hostname。

在 3.6 版被加入.

ssl.PROTOCOL_TLS_SERVER

自動協商客戶端和服務器都支援的最高協議版本，並配置客戶端語境連線。

在 3.6 版被加入.

ssl.PROTOCOL_SSLv23

PROTOCOL_TLS 的別名。

在 3.6 版之後被棄用: 請改用 PROTOCOL_TLS。

ssl.PROTOCOL_SSLv3

選擇第三版的 SSL 做為通道加密協定。

如果 OpenSSL 是用 no-ssl3 編譯的，則此項協議無法使用。

警告

第三版的 SSL 是不安全的，強烈建議不要使用。

在 3.6 版之後被棄用: OpenSSL 已經終止了所有特定版本的協定。請改用預設的 PROTOCOL_TLS_SERVER 協定或帶有 SSLContext.minimum_version 和 SSLContext.maximum_version 的 PROTOCOL_TLS_CLIENT。

ssl.PROTOCOL_TLSv1

選擇 1.0 版的 TLS 做為通道加密協定。

在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。

ssl.PROTOCOL_TLSv1_1

選擇 1.1 版的 TLS 做為通道加密協定。只有在 1.0.1 版本以上的 OpenSSL 才可以選用。

在 3.4 版被加入.

在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。

ssl.PROTOCOL_TLSv1_2

選擇 1.2 版的 TLS 做為通道加密協定。只有在 1.0.1 版本以上的 OpenSSL 才可以選用。

在 3.4 版被加入.

在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。

ssl.OP_ALL

啟用對 SSL 實作時所產生的各種錯誤的緩解措施。此選項預設被設定。它不一定設定與 OpenSSL 的 SSL_OP_ALL 常數相同的旗標。

在 3.2 版被加入.

ssl.OP_NO_SSLv2

防止 SSLv2 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級 (peer)選用 SSLv2 做為協定版本。

在 3.2 版被加入.

在 3.6 版之後被棄用: SSLv2 已被棄用

ssl.OP_NO_SSLv3

防止 SSLv3 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級選用 SSLv3 做為協定版本。

在 3.2 版被加入.

在 3.6 版之後被棄用: SSLv3 已被棄用

ssl.OP_NO_TLSv1

防止 TLSv1 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級選用 TLSv1 做為協定版本。

在 3.2 版被加入.

在 3.7 版之後被棄用: 該選項自從 OpenSSL 1.1.0 以後已被棄用，請改用新的 SSLContext.minimum_version 及 SSLContext.maximum_version 代替。

ssl.OP_NO_TLSv1_1

防止 TLSv1.1 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級選用 TLSv1.1 做為協定版本。只有 1.0.1 版後的 OpenSSL 版本才能使用。

在 3.4 版被加入.

在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 版已被棄用。

ssl.OP_NO_TLSv1_2

防止 TLSv1.2 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級選用 TLSv1.2 做為協定版本。只有 1.0.1 版後的 OpenSSL 版本才能使用。

在 3.4 版被加入.

在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 版已被棄用。

ssl.OP_NO_TLSv1_3

防止 TLSv1.3 連線。此選項只可以跟 PROTOCOL_TLS 一起使用。它會防止同級選用 TLSv1.3 做為協定版本。TSL1.3 只適用於 1.1.1 版以後的 OpenSSL。當使用 Python 編譯舊版的 OpenSSL 時，該標志預設為 0。

在 3.6.3 版被加入.

在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 以後已被棄用。它被添加到 2.7.15 和 3.6.3 中，以向後相容 OpenSSL 1.0.2。

ssl.OP_NO_RENEGOTIATION

停用所有在 TLSv1.2 及更早版本的重協商 (renegotiation)。不發送 HelloRequest 訊息，並忽略通過 ClientHello 的重協商請求。

此選項僅適用於 OpenSSL 1.1.0h 及更新版本。

在 3.7 版被加入.

ssl.OP_CIPHER_SERVER_PREFERENCE

使用伺服器的加密方法名稱字串排序優先順序，而不是客戶端的。此選項並不會影響到客戶端及 SSLv2 伺服器的 sockets。

在 3.3 版被加入.

ssl.OP_SINGLE_DH_USE

防止對不同的 SSL 會談重複使用相同的 DH 密鑰。這會加強向前保密但需要更多的運算資源。此選項只適用於伺服器 sockets。

在 3.3 版被加入.

ssl.OP_SINGLE_ECDH_USE

防止對不同的 SSL 會談重複使用相同的 ECDH 密鑰。這會加強向前保密但需要更多的運算資源。此選項只適用於伺服器 sockets。

在 3.3 版被加入.

ssl.OP_ENABLE_MIDDLEBOX_COMPAT

在 TLS 1.3 握手中發送虛擬的變更加密方法規範 (CCS) 消息，以使 TLS 1.3 連接看起來更像 TLS 1.2 連線。

此選項僅適用於 OpenSSL 1.1.1 及更新版本。

在 3.8 版被加入.

ssl.OP_NO_COMPRESSION

在 SSL 通道上禁用壓縮。如果應用程序協定支援自己的壓縮方案，這會很有用。

在 3.3 版被加入.

class ssl.Options

enum.IntFlag 為 OP_* 常數中的一個集合。

ssl.OP_NO_TICKET

防止客戶端請求會談票據。

在 3.6 版被加入.

ssl.OP_IGNORE_UNEXPECTED_EOF

忽略意外關閉的 TLS 連線。

此選項僅適用於 OpenSSL 3.0.0 及更新版本。

在 3.10 版被加入.

ssl.OP_ENABLE_KTLS

允許使用 TLS 核心。要想受益於該功能，OpenSSL 必須編譯為支援該功能，並且想使用的加密套件及擴充套件也必須被該功能支援 (該功能所支援的列表可能會因平台及核心而有所差異)。

請注意當允許使用 TLS 核心時，一些加密操作將直接由核心執行而不是經由任何由可用的 OpenSSL 所提供的程序，而這可能並非你所想使用的，例如：當應用程式要求所有的加密操作由 FIPS 提供執行。

此選項僅適用於 OpenSSL 3.0.0 及更新版本。

在 3.12 版被加入.

ssl.OP_LEGACY_SERVER_CONNECT

只允許 OpenSSL 與未修補的伺服器進行遺留 (legacy) 不安全重協商。

在 3.12 版被加入.

ssl.HAS_ALPN

OpenSSL 函式庫是否內建支援 應用層協定協商 TLS 擴充套件，該擴充套件描述在 RFC 7301 中。

在 3.5 版被加入.

ssl.HAS_NEVER_CHECK_COMMON_NAME

OpenSSL 函式庫是否內建支援不檢查主題通用名稱及 SSLContext.hostname_checks_common_name 是否可寫。

在 3.7 版被加入.

ssl.HAS_ECDH

OpenSSL 函式庫是否內建支援基於橢圓曲線的 (Elliptic Curve-based) Diffie-Hellman 金鑰交換。此回傳值應該要為 true 除非發布者明確禁用此功能。

在 3.3 版被加入.

ssl.HAS_SNI

OpenSSL 函式庫是否內建支援 伺服器名稱提示 擴充套件 (在 RFC 6066 中定義)。

在 3.2 版被加入.

ssl.HAS_NPN

OpenSSL 函式庫是否內建支援 下一代協定協商 該功能在應用層協定協商 中有描述。當此值為 true 時，你可以使用 SSLContext.set_npn_protocols() 方法來公告你想支援的協定。

在 3.3 版被加入.

ssl.HAS_SSLv2

此 OpenSSL 函式庫是否內建支援 SSL 2.0 協定。

在 3.7 版被加入.

ssl.HAS_SSLv3

此 OpenSSL 函式庫是否內建支援 SSL 3.0 協定。

在 3.7 版被加入.

ssl.HAS_TLSv1

此 OpenSSL 函式庫是否內建支援 TLS 1.0 協定。

在 3.7 版被加入.

ssl.HAS_TLSv1_1

此 OpenSSL 函式庫是否內建支援 TLS 1.1 協定。

在 3.7 版被加入.

ssl.HAS_TLSv1_2

此 OpenSSL 函式庫是否內建支援 TLS 1.2 協定。

在 3.7 版被加入.

ssl.HAS_TLSv1_3

此 OpenSSL 函式庫是否內建支援 TLS 1.3 協定。

在 3.7 版被加入.

ssl.HAS_PSK

Whether the OpenSSL library has built-in support for TLS-PSK.

在 3.13 版被加入.

ssl.CHANNEL_BINDING_TYPES

支援的 TLS 通道綁定類型列表。列表中的字串可以作為 SSLSocket.get_channel_binding() 的參數。

在 3.3 版被加入.

ssl.OPENSSL_VERSION

直譯器所加載的 OpenSSL 函式庫的版本字串:

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

在 3.2 版被加入.

ssl.OPENSSL_VERSION_INFO

代表 OpenSSL 函式庫版本資訊的五個整數的元組：

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

在 3.2 版被加入.

ssl.OPENSSL_VERSION_NUMBER

OpenSSL 函式庫的初始版本，以單一整數表示:

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

在 3.2 版被加入.

ssl.ALERT_DESCRIPTION_HANDSHAKE_FAILURE
ssl.ALERT_DESCRIPTION_INTERNAL_ERROR
ALERT_DESCRIPTION_*

來自 RFC 5246 和其他文檔的警報描述。IANA TLS Alert Registry 包含了此列表以及其含義定義所在的 RFC 的引用。

被用來做為 SSLContext.set_servername_callback() 中回呼函式的回傳值。

在 3.4 版被加入.

class ssl.AlertDescription

enum.IntEnum 為 ALERT_DESCRIPTION_* 常數中的一個集合。

在 3.6 版被加入.

Purpose.SERVER_AUTH

create_default_context() 和 SSLContext.load_default_certs() 的選項。此值表示該語境可能會用於驗證網頁伺服器 (因此它將用於建立用戶端 socket）。

在 3.4 版被加入.

Purpose.CLIENT_AUTH

create_default_context() 和 SSLContext.load_default_certs() 的選項。此值表示該語境可能會用於驗證網頁用戶端 (因此，它將用於建立伺服器端的 socket）。

在 3.4 版被加入.

class ssl.SSLErrorNumber

enum.IntEnum 為 SSL_ERROR_* 常數中的一個集合。

在 3.6 版被加入.

class ssl.TLSVersion

用於 SSLContext.maximum_version 和 SSLContext.minimum_version 的 SSL 和 TLS 版本 enum.IntEnum 集合。

在 3.7 版被加入.

TLSVersion.MINIMUM_SUPPORTED
TLSVersion.MAXIMUM_SUPPORTED

最低或最高支援的 SSL 或 TLS 版本。這些是特殊常數。它們的值並不反映可用的最低和最高 TLS/SSL 版本。

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

SSL 3.0 到 TLS 1.3。

在 3.10 版之後被棄用: 除了 TLSVersion.TLSv1_2 和 TLSVersion.TLSv1_3 之外，所有的 TLSVersion 成員都已被棄用。

SSL Sockets

class ssl.SSLSocket(socket.socket)

SSL sockets 提供以下 Socket 物件 方法：

然而，由於 SSL（和 TLS）協定在 TCP 之上有自己的框架，因此在某些方面，SSL sockets 的抽象可能會與普通操作系統級別的 sockets 規範有所不同。特別是請參閱關於 non-blocking sockets 的說明。

SSLSocket 的實例必須使用 SSLContext.wrap_socket() 方法建立。

在 3.5 版的變更: 新增 sendfile() 方法。

在 3.5 版的變更: shutdown() 不會在每次接收或發送位元組時重置 socket 超時時間。現在，socket 超時時間是關閉操作的最大總持續時間。

在 3.6 版之後被棄用: 直接建立 SSLSocket 實例的方式已被棄用，請使用 SSLContext.wrap_socket() 來包裝 socket。

在 3.7 版的變更: SSLSocket 實例必須使用 wrap_socket() 建立。在較早的版本中可以直接建立實例，但這從未被記錄或正式支援。

在 3.10 版的變更: Python 現在內部使用了 SSL_read_ex 和 SSL_write_ex 函式。這些函式支援讀取和寫入大於 2 GB 的資料。寫入零長度的資料不再會導致協定違規錯誤。

SSL sockets 還具有以下附加方法和屬性：

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

從 SSL socket 讀取 len 位元組的資料，並將結果以 bytes 實例的形式回傳。如果指定了 buffer，則將資料讀入緩衝區，並回傳讀取的位元組。

如果 socket 是非阻塞的則會引發 SSLWantReadError 或 SSLWantWriteError 並且讀取操作將會被阻塞。

由於在任何時刻都可能發生重新協商，呼叫 read() 也可能觸發寫入操作。

在 3.5 版的變更: 當接收或發送位元組時，socket 的超時時間將不再重置。現在，socket 超時時間是讀取最多 len 位元組的總最大持續時間。

在 3.6 版之後被棄用: 請改用 recv() 來替換掉 read()。

SSLSocket.write(buf)

將 buf 寫入 SSL socket 並回傳寫入的位元組數量。buf 引數必須是支援緩衝區介面的物件。

如果 socket 是非阻塞的則會引發 SSLWantReadError 或 SSLWantWriteError 並且寫入操作將會被阻塞。

由於在任何時刻都可能發生重新協商，呼叫 write() 也可能觸發讀取操作。

在 3.5 版的變更: 當接收或發送位元組時，socket 的超時時間將不再重置。現在，socket 超時時間是寫入 buf 的總最大持續時間。

在 3.6 版之後被棄用: 請改用 send() 來替換掉 write()。

備註

read() 和 write() 方法為低階層的方法，負責讀取和寫入未加密的應用層資料，並將其加密/解密為加密的寫入層資料。這些方法需要一個已建立的 SSL 連接，即握手已完成，且未呼叫 SSLSocket.unwrap()。

通常你應該使用像 recv() 和 send() 這樣的 socket API 方法，而不是直接使用這些方法。

SSLSocket.do_handshake()

執行 SSL 設定握手。

在 3.4 版的變更: 當 socket 的 context 的 check_hostname 屬性質為 true 時，握手方法也會執行 match_hostname()。

在 3.5 版的變更: Socket 超時時間已經不會在每次接收或傳送位元組時重置。現在，超時時間是握手過程的最大總持續時間。

在 3.7 版的變更: 在握手過程中，OpenSSL 會去配對主機名稱或 IP 地址。已不再使用 match_hostname() 函式。如果 OpenSSL 拒絕某個主機名稱或 IP 地址，握手將會提前中止，並向對方發送 TLS 警報訊息。

SSLSocket.getpeercert(binary_form=False)

如果連線端沒有證書，則回傳 None。如果 SSL 握手尚未完成，則引發 ValueError。

如果 binary_form 參數為 False，且從對等 (peer) 接收到證書，則該方法回傳一個 dict 實例。如果證書未被驗證，則該字典為空。若證書已被驗證，則回傳的字典將包含數個鍵值，包括 subject (證書所簽發的對象) 和 issuer (簽發證書的主體)。如果證書中包含 Subject Alternative Name 擴充 (參考RFC 3280)，字典中還會有一個 subjectAltName 鍵。

subject 和 issuer 欄位欄位是包含相對識別名稱 (relative distinguished names, RDNs) 序列的元組，這些 RDN 來自證書資料結構中的相應欄位。每個 RDN 都是一組名稱與值的對。以下是現實中的範例：

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

如果 binary_form 參數設定為 True，且對等提供了證書，則該方法會以 DER 編碼形式 將整個證書以位元組序列形式回傳。如果對等未提供證書，則回傳 None。對等是否提供證書取決於 SSL socket 的腳色：

  • 對於客戶端 SSL socket，伺服器將永遠提供證書，無論是否需要進行驗證；

  • 對於伺服器 SSL socket，客戶端僅在伺服器要求時才會提供證書；因此，如果你使用的是 CERT_NONE (而非 CERT_OPTIONAL 或 CERT_REQUIRED)，則 getpeercert() 會回傳 None。

請見 SSLContext.check_hostname。

在 3.2 版的變更: The returned dictionary includes additional items such as issuer and notBefore.

在 3.4 版的變更: ValueError is raised when the handshake isn't done. The returned dictionary includes additional X509v3 extension items such as crlDistributionPoints, caIssuers and OCSP URIs.

在 3.9 版的變更: IPv6 address strings no longer have a trailing new line.

SSLSocket.get_verified_chain()

Returns verified certificate chain provided by the other end of the SSL channel as a list of DER-encoded bytes. If certificate verification was disabled method acts the same as get_unverified_chain().

在 3.13 版被加入.

SSLSocket.get_unverified_chain()

Returns raw certificate chain provided by the other end of the SSL channel as a list of DER-encoded bytes.

在 3.13 版被加入.

SSLSocket.cipher()

Returns a three-value tuple containing the name of the cipher being used, the version of the SSL protocol that defines its use, and the number of secret bits being used. If no connection has been established, returns None.

SSLSocket.shared_ciphers()

Return the list of ciphers available in both the client and server. Each entry of the returned list is a three-value tuple containing the name of the cipher, the version of the SSL protocol that defines its use, and the number of secret bits the cipher uses. shared_ciphers() returns None if no connection has been established or the socket is a client socket.

在 3.5 版被加入.

SSLSocket.compression()

Return the compression algorithm being used as a string, or None if the connection isn't compressed.

If the higher-level protocol supports its own compression mechanism, you can use OP_NO_COMPRESSION to disable SSL-level compression.

在 3.3 版被加入.

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

Get channel binding data for current connection, as a bytes object. Returns None if not connected or the handshake has not been completed.

The cb_type parameter allow selection of the desired channel binding type. Valid channel binding types are listed in the CHANNEL_BINDING_TYPES list. Currently only the 'tls-unique' channel binding, defined by RFC 5929, is supported. ValueError will be raised if an unsupported channel binding type is requested.

在 3.3 版被加入.

SSLSocket.selected_alpn_protocol()

Return the protocol that was selected during the TLS handshake. If SSLContext.set_alpn_protocols() was not called, if the other party does not support ALPN, if this socket does not support any of the client's proposed protocols, or if the handshake has not happened yet, None is returned.

在 3.5 版被加入.

SSLSocket.selected_npn_protocol()

Return the higher-level protocol that was selected during the TLS/SSL handshake. If SSLContext.set_npn_protocols() was not called, or if the other party does not support NPN, or if the handshake has not yet happened, this will return None.

在 3.3 版被加入.

在 3.10 版之後被棄用: NPN has been superseded by ALPN

SSLSocket.unwrap()

Performs the SSL shutdown handshake, which removes the TLS layer from the underlying socket, and returns the underlying socket object. This can be used to go from encrypted operation over a connection to unencrypted. The returned socket should always be used for further communication with the other side of the connection, rather than the original socket.

SSLSocket.verify_client_post_handshake()

Requests post-handshake authentication (PHA) from a TLS 1.3 client. PHA can only be initiated for a TLS 1.3 connection from a server-side socket, after the initial TLS handshake and with PHA enabled on both sides, see SSLContext.post_handshake_auth.

The method does not perform a cert exchange immediately. The server-side sends a CertificateRequest during the next write event and expects the client to respond with a certificate on the next read event.

If any precondition isn't met (e.g. not TLS 1.3, PHA not enabled), an SSLError is raised.

備註

Only available with OpenSSL 1.1.1 and TLS 1.3 enabled. Without TLS 1.3 support, the method raises NotImplementedError.

在 3.8 版被加入.

SSLSocket.version()

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

在 3.5 版被加入.

SSLSocket.pending()

Returns the number of already decrypted bytes available for read, pending on the connection.

SSLSocket.context

The SSLContext object this SSL socket is tied to.

在 3.2 版被加入.

SSLSocket.server_side

A boolean which is True for server-side sockets and False for client-side sockets.

在 3.2 版被加入.

SSLSocket.server_hostname

Hostname of the server: str type, or None for server-side socket or if the hostname was not specified in the constructor.

在 3.2 版被加入.

在 3.7 版的變更: The attribute is now always ASCII text. When server_hostname is an internationalized domain name (IDN), this attribute now stores the A-label form ("xn--pythn-mua.org"), rather than the U-label form ("pythön.org").

SSLSocket.session

The SSLSession for this SSL connection. The session is available for client and server side sockets after the TLS handshake has been performed. For client sockets the session can be set before do_handshake() has been called to reuse a session.

在 3.6 版被加入.

SSLSocket.session_reused

在 3.6 版被加入.

SSL Contexts

在 3.2 版被加入.

An SSL context holds various data longer-lived than single SSL connections, such as SSL configuration options, certificate(s) and private key(s). It also manages a cache of SSL sessions for server-side sockets, in order to speed up repeated connections from the same clients.

class ssl.SSLContext(protocol=None)

Create a new SSL context. You may pass protocol which must be one of the PROTOCOL_* constants defined in this module. The parameter specifies which version of the SSL protocol to use. Typically, the server chooses a particular protocol version, and the client must adapt to the server's choice. Most of the versions are not interoperable with the other versions. If not specified, the default is PROTOCOL_TLS; it provides the most compatibility with other versions.

Here's a table showing which versions in a client (down the side) can connect to which versions in a server (along the top):

client / server

SSLv2

SSLv3

TLS [3]

TLSv1

TLSv1.1

TLSv1.2

SSLv2

yes

no

no [1]

no

no

no

SSLv3

no

yes

no [2]

no

no

no

TLS (SSLv23) [3]

no [1]

no [2]

yes

yes

yes

yes

TLSv1

no

no

yes

yes

no

no

TLSv1.1

no

no

yes

no

yes

no

TLSv1.2

no

no

yes

no

no

yes

註解

也參考

create_default_context() lets the ssl module choose security settings for a given purpose.

在 3.6 版的變更: The context is created with secure default values. The options OP_NO_COMPRESSION, OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE, OP_SINGLE_ECDH_USE, OP_NO_SSLv2, and OP_NO_SSLv3 (except for PROTOCOL_SSLv3) are set by default. The initial cipher suite list contains only HIGH ciphers, no NULL ciphers and no MD5 ciphers.

在 3.10 版之後被棄用: SSLContext without protocol argument is deprecated. The context class will either require PROTOCOL_TLS_CLIENT or PROTOCOL_TLS_SERVER protocol in the future.

在 3.10 版的變更: The default cipher suites now include only secure AES and ChaCha20 ciphers with forward secrecy and security level 2. RSA and DH keys with less than 2048 bits and ECC keys with less than 224 bits are prohibited. PROTOCOL_TLS, PROTOCOL_TLS_CLIENT, and PROTOCOL_TLS_SERVER use TLS 1.2 as minimum TLS version.

備註

SSLContext only supports limited mutation once it has been used by a connection. Adding new certificates to the internal trust store is allowed, but changing ciphers, verification settings, or mTLS certificates may result in surprising behavior.

備註

SSLContext is designed to be shared and used by multiple connections. Thus, it is thread-safe as long as it is not reconfigured after being used by a connection.

SSLContext objects have the following methods and attributes:

SSLContext.cert_store_stats()

Get statistics about quantities of loaded X.509 certificates, count of X.509 certificates flagged as CA certificates and certificate revocation lists as dictionary.

Example for a context with one CA cert and one other cert:

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

在 3.4 版被加入.

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

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

The password argument may be a function to call to get the password for decrypting the private key. It will only be called if the private key is encrypted and a password is necessary. It will be called with no arguments, and it should return a string, bytes, or bytearray. If the return value is a string it will be encoded as UTF-8 before using it to decrypt the key. Alternatively a string, bytes, or bytearray value may be supplied directly as the password argument. It will be ignored if the private key is not encrypted and no password is needed.

If the password argument is not specified and a password is required, OpenSSL's built-in password prompting mechanism will be used to interactively prompt the user for a password.

An SSLError is raised if the private key doesn't match with the certificate.

在 3.3 版的變更: New optional argument password.

SSLContext.load_default_certs(purpose=Purpose.SERVER_AUTH)

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

The purpose flag specifies what kind of CA certificates are loaded. The default settings Purpose.SERVER_AUTH loads certificates, that are flagged and trusted for TLS web server authentication (client side sockets). Purpose.CLIENT_AUTH loads CA certificates for client certificate verification on the server side.

在 3.4 版被加入.

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

Load a set of "certification authority" (CA) certificates used to validate other peers' certificates when verify_mode is other than CERT_NONE. At least one of cafile or capath must be specified.

This method can also load certification revocation lists (CRLs) in PEM or DER format. In order to make use of CRLs, SSLContext.verify_flags must be configured properly.

The cafile string, if present, is the path to a file of concatenated CA certificates in PEM format. See the discussion of Certificates for more information about how to arrange the certificates in this file.

The capath string, if present, is the path to a directory containing several CA certificates in PEM format, following an OpenSSL specific layout.

The cadata object, if present, is either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates. Like with capath extra lines around PEM-encoded certificates are ignored but at least one certificate must be present.

在 3.4 版的變更: New optional argument cadata

SSLContext.get_ca_certs(binary_form=False)

Get a list of loaded "certification authority" (CA) certificates. If the binary_form parameter is False each list entry is a dict like the output of SSLSocket.getpeercert(). Otherwise the method returns a list of DER-encoded certificates. The returned list does not contain certificates from capath unless a certificate was requested and loaded by a SSL connection.

備註

Certificates in a capath directory aren't loaded unless they have been used at least once.

在 3.4 版被加入.

SSLContext.get_ciphers()

Get a list of enabled ciphers. The list is in order of cipher priority. See SSLContext.set_ciphers().

範例：

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

在 3.6 版被加入.

SSLContext.set_default_verify_paths()

Load a set of default "certification authority" (CA) certificates from a filesystem path defined when building the OpenSSL library. Unfortunately, there's no easy way to know whether this method succeeds: no error is returned if no certificates are to be found. When the OpenSSL library is provided as part of the operating system, though, it is likely to be configured properly.

SSLContext.set_ciphers(ciphers)

Set the available ciphers for sockets created with this context. It should be a string in the OpenSSL cipher list format. If no cipher can be selected (because compile-time options or other configuration forbids use of all the specified ciphers), an SSLError will be raised.

備註

when connected, the SSLSocket.cipher() method of SSL sockets will give the currently selected cipher.

TLS 1.3 cipher suites cannot be disabled with set_ciphers().

SSLContext.set_alpn_protocols(protocols)

Specify which protocols the socket should advertise during the SSL/TLS handshake. It should be a list of ASCII strings, like ['http/1.1', 'spdy/2'], ordered by preference. The selection of a protocol will happen during the handshake, and will play out according to RFC 7301. After a successful handshake, the SSLSocket.selected_alpn_protocol() method will return the agreed-upon protocol.

This method will raise NotImplementedError if HAS_ALPN is False.

在 3.5 版被加入.

SSLContext.set_npn_protocols(protocols)

Specify which protocols the socket should advertise during the SSL/TLS handshake. It should be a list of strings, like ['http/1.1', 'spdy/2'], ordered by preference. The selection of a protocol will happen during the handshake, and will play out according to the Application Layer Protocol Negotiation. After a successful handshake, the SSLSocket.selected_npn_protocol() method will return the agreed-upon protocol.

This method will raise NotImplementedError if HAS_NPN is False.

在 3.3 版被加入.

在 3.10 版之後被棄用: NPN has been superseded by ALPN

SSLContext.sni_callback

Register a callback function that will be called after the TLS Client Hello handshake message has been received by the SSL/TLS server when the TLS client specifies a server name indication. The server name indication mechanism is specified in RFC 6066 section 3 - Server Name Indication.

Only one callback can be set per SSLContext. If sni_callback is set to None then the callback is disabled. Calling this function a subsequent time will disable the previously registered callback.

The callback function will be called with three arguments; the first being the ssl.SSLSocket, the second is a string that represents the server name that the client is intending to communicate (or None if the TLS Client Hello does not contain a server name) and the third argument is the original SSLContext. The server name argument is text. For internationalized domain name, the server name is an IDN A-label ("xn--pythn-mua.org").

A typical use of this callback is to change the ssl.SSLSocket's SSLSocket.context attribute to a new object of type SSLContext representing a certificate chain that matches the server name.

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

The sni_callback function must return None to allow the TLS negotiation to continue. If a TLS failure is required, a constant ALERT_DESCRIPTION_* can be returned. Other return values will result in a TLS fatal error with ALERT_DESCRIPTION_INTERNAL_ERROR.

If an exception is raised from the sni_callback function the TLS connection will terminate with a fatal TLS alert message ALERT_DESCRIPTION_HANDSHAKE_FAILURE.

This method will raise NotImplementedError if the OpenSSL library had OPENSSL_NO_TLSEXT defined when it was built.

在 3.7 版被加入.

SSLContext.set_servername_callback(server_name_callback)

This is a legacy API retained for backwards compatibility. When possible, you should use sni_callback instead. The given server_name_callback is similar to sni_callback, except that when the server hostname is an IDN-encoded internationalized domain name, the server_name_callback receives a decoded U-label ("pythön.org").

If there is a decoding error on the server name, the TLS connection will terminate with an ALERT_DESCRIPTION_INTERNAL_ERROR fatal TLS alert message to the client.

在 3.4 版被加入.

SSLContext.load_dh_params(dhfile)

Load the key generation parameters for Diffie-Hellman (DH) key exchange. Using DH key exchange improves forward secrecy at the expense of computational resources (both on the server and on the client). The dhfile parameter should be the path to a file containing DH parameters in PEM format.

This setting doesn't apply to client sockets. You can also use the OP_SINGLE_DH_USE option to further improve security.

在 3.3 版被加入.

SSLContext.set_ecdh_curve(curve_name)

Set the curve name for Elliptic Curve-based Diffie-Hellman (ECDH) key exchange. ECDH is significantly faster than regular DH while arguably as secure. The curve_name parameter should be a string describing a well-known elliptic curve, for example prime256v1 for a widely supported curve.

This setting doesn't apply to client sockets. You can also use the OP_SINGLE_ECDH_USE option to further improve security.

This method is not available if HAS_ECDH is False.

在 3.3 版被加入.

也參考

SSL/TLS & Perfect Forward Secrecy

Vincent Bernat.

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

Wrap an existing Python socket sock and return an instance of SSLContext.sslsocket_class (default SSLSocket). The returned SSL socket is tied to the context, its settings and certificates. sock must be a SOCK_STREAM socket; other socket types are unsupported.

The parameter server_side is a boolean which identifies whether server-side or client-side behavior is desired from this socket.

For client-side sockets, the context construction is lazy; if the underlying socket isn't connected yet, the context construction will be performed after connect() is called on the socket. For server-side sockets, if the socket has no remote peer, it is assumed to be a listening socket, and the server-side SSL wrapping is automatically performed on client connections accepted via the accept() method. The method may raise SSLError.

On client connections, the optional parameter server_hostname specifies the hostname of the service which we are connecting to. This allows a single server to host multiple SSL-based services with distinct certificates, quite similarly to HTTP virtual hosts. Specifying server_hostname will raise a ValueError if server_side is true.

The parameter do_handshake_on_connect specifies whether to do the SSL handshake automatically after doing a socket.connect(), or whether the application program will call it explicitly, by invoking the SSLSocket.do_handshake() method. Calling SSLSocket.do_handshake() explicitly gives the program control over the blocking behavior of the socket I/O involved in the handshake.

The parameter suppress_ragged_eofs specifies how the SSLSocket.recv() method should signal unexpected EOF from the other end of the connection. If specified as True (the default), it returns a normal EOF (an empty bytes object) in response to unexpected EOF errors raised from the underlying socket; if False, it will raise the exceptions back to the caller.

session, see session.

To wrap an SSLSocket in another SSLSocket, use SSLContext.wrap_bio().

在 3.5 版的變更: Always allow a server_hostname to be passed, even if OpenSSL does not have SNI.

在 3.6 版的變更: 新增 session 引數。

在 3.7 版的變更: The method returns an instance of SSLContext.sslsocket_class instead of hard-coded SSLSocket.

SSLContext.sslsocket_class

The return type of SSLContext.wrap_socket(), defaults to SSLSocket. The attribute can be overridden on instance of class in order to return a custom subclass of SSLSocket.

在 3.7 版被加入.

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

Wrap the BIO objects incoming and outgoing and return an instance of SSLContext.sslobject_class (default SSLObject). The SSL routines will read input data from the incoming BIO and write data to the outgoing BIO.

The server_side, server_hostname and session parameters have the same meaning as in SSLContext.wrap_socket().

在 3.6 版的變更: 新增 session 引數。

在 3.7 版的變更: The method returns an instance of SSLContext.sslobject_class instead of hard-coded SSLObject.

SSLContext.sslobject_class

The return type of SSLContext.wrap_bio(), defaults to SSLObject. The attribute can be overridden on instance of class in order to return a custom subclass of SSLObject.

在 3.7 版被加入.

SSLContext.session_stats()

Get statistics about the SSL sessions created or managed by this context. A dictionary is returned which maps the names of each piece of information to their numeric values. For example, here is the total number of hits and misses in the session cache since the context was created:

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

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

範例：

import socket, ssl

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

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

在 3.4 版被加入.

在 3.7 版的變更: verify_mode is now automatically changed to CERT_REQUIRED when hostname checking is enabled and verify_mode is CERT_NONE. Previously the same operation would have failed with a ValueError.

SSLContext.keylog_filename

Write TLS keys to a keylog file, whenever key material is generated or received. The keylog file is designed for debugging purposes only. The file format is specified by NSS and used by many traffic analyzers such as Wireshark. The log file is opened in append-only mode. Writes are synchronized between threads, but not between processes.

在 3.8 版被加入.

SSLContext.maximum_version

A TLSVersion enum member representing the highest supported TLS version. The value defaults to TLSVersion.MAXIMUM_SUPPORTED. The attribute is read-only for protocols other than PROTOCOL_TLS, PROTOCOL_TLS_CLIENT, and PROTOCOL_TLS_SERVER.

The attributes maximum_version, minimum_version and SSLContext.options all affect the supported SSL and TLS versions of the context. The implementation does not prevent invalid combination. For example a context with OP_NO_TLSv1_2 in options and maximum_version set to TLSVersion.TLSv1_2 will not be able to establish a TLS 1.2 connection.

在 3.7 版被加入.

SSLContext.minimum_version

Like SSLContext.maximum_version except it is the lowest supported version or TLSVersion.MINIMUM_SUPPORTED.

在 3.7 版被加入.

SSLContext.num_tickets

Control the number of TLS 1.3 session tickets of a PROTOCOL_TLS_SERVER context. The setting has no impact on TLS 1.0 to 1.2 connections.

在 3.8 版被加入.

SSLContext.options

An integer representing the set of SSL options enabled on this context. The default value is OP_ALL, but you can specify other options such as OP_NO_SSLv2 by ORing them together.

在 3.6 版的變更: SSLContext.options returns Options flags:

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

在 3.7 版之後被棄用: All OP_NO_SSL* and OP_NO_TLS* options have been deprecated since Python 3.7. Use SSLContext.minimum_version and SSLContext.maximum_version instead.

SSLContext.post_handshake_auth

Enable TLS 1.3 post-handshake client authentication. Post-handshake auth is disabled by default and a server can only request a TLS client certificate during the initial handshake. When enabled, a server may request a TLS client certificate at any time after the handshake.

When enabled on client-side sockets, the client signals the server that it supports post-handshake authentication.

When enabled on server-side sockets, SSLContext.verify_mode must be set to CERT_OPTIONAL or CERT_REQUIRED, too. The actual client cert exchange is delayed until SSLSocket.verify_client_post_handshake() is called and some I/O is performed.

在 3.8 版被加入.

SSLContext.protocol

The protocol version chosen when constructing the context. This attribute is read-only.

SSLContext.hostname_checks_common_name

Whether check_hostname falls back to verify the cert's subject common name in the absence of a subject alternative name extension (default: true).

在 3.7 版被加入.

在 3.10 版的變更: The flag had no effect with OpenSSL before version 1.1.1l. Python 3.8.9, 3.9.3, and 3.10 include workarounds for previous versions.

SSLContext.security_level

An integer representing the security level for the context. This attribute is read-only.

在 3.10 版被加入.

SSLContext.verify_flags

The flags for certificate verification operations. You can set flags like VERIFY_CRL_CHECK_LEAF by ORing them together. By default OpenSSL does neither require nor verify certificate revocation lists (CRLs).

在 3.4 版被加入.

在 3.6 版的變更: SSLContext.verify_flags returns VerifyFlags flags:

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

Whether to try to verify other peers' certificates and how to behave if verification fails. This attribute must be one of CERT_NONE, CERT_OPTIONAL or CERT_REQUIRED.

在 3.6 版的變更: SSLContext.verify_mode returns VerifyMode enum:

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

Enables TLS-PSK (pre-shared key) authentication on a client-side connection.

In general, certificate based authentication should be preferred over this method.

The 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 representing the pre-shared key. Return a zero length PSK to reject the connection.

Setting callback to None removes any existing callback.

備註

When using TLS 1.3:

  • the hint parameter is always None.

  • client-identity must be a non-empty string.

Example usage:

context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
context.maximum_version = ssl.TLSVersion.TLSv1_2
context.set_ciphers('PSK')

# A simple lambda:
psk = bytes.fromhex('c0ffee')
context.set_psk_client_callback(lambda hint: (None, psk))

# A table using the hint from the server:
psk_table = { 'ServerId_1': bytes.fromhex('c0ffee'),
              'ServerId_2': bytes.fromhex('facade')
}
def callback(hint):
    return 'ClientId_1', psk_table.get(hint, b'')
context.set_psk_client_callback(callback)

This method will raise NotImplementedError if HAS_PSK is False.

在 3.13 版被加入.

SSLContext.set_psk_server_callback(callback, identity_hint=None)

Enables TLS-PSK (pre-shared key) authentication on a server-side connection.

In general, certificate based authentication should be preferred over this method.

The 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 representing the pre-shared key. Return a zero length PSK to reject the connection.

Setting callback to None removes any existing callback.

The parameter identity_hint is an optional identity hint string sent to the client. The string must be less than or equal to 256 octets when UTF-8 encoded.

備註

When using TLS 1.3 the identity_hint parameter is not sent to the client.

Example usage:

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.maximum_version = ssl.TLSVersion.TLSv1_2
context.set_ciphers('PSK')

# A simple lambda:
psk = bytes.fromhex('c0ffee')
context.set_psk_server_callback(lambda identity: psk)

# A table using the identity of the client:
psk_table = { 'ClientId_1': bytes.fromhex('c0ffee'),
              'ClientId_2': bytes.fromhex('facade')
}
def callback(identity):
    return psk_table.get(identity, b'')
context.set_psk_server_callback(callback, 'ServerId_1')

This method will raise NotImplementedError if HAS_PSK is False.

在 3.13 版被加入.

Certificates

Certificates in general are part of a public-key / private-key system. In this system, each principal, (which may be a machine, or a person, or an organization) is assigned a unique two-part encryption key. One part of the key is public, and is called the public key; the other part is kept secret, and is called the private key. The two parts are related, in that if you encrypt a message with one of the parts, you can decrypt it with the other part, and only with the other part.

A certificate contains information about two principals. It contains the name of a subject, and the subject's public key. It also contains a statement by a second principal, the issuer, that the subject is who they claim to be, and that this is indeed the subject's public key. The issuer's statement is signed with the issuer's private key, which only the issuer knows. However, anyone can verify the issuer's statement by finding the issuer's public key, decrypting the statement with it, and comparing it to the other information in the certificate. The certificate also contains information about the time period over which it is valid. This is expressed as two fields, called "notBefore" and "notAfter".

In the Python use of certificates, a client or server can use a certificate to prove who they are. The other side of a network connection can also be required to produce a certificate, and that certificate can be validated to the satisfaction of the client or server that requires such validation. The connection attempt can be set to raise an exception if the validation fails. Validation is done automatically, by the underlying OpenSSL framework; the application need not concern itself with its mechanics. But the application does usually need to provide sets of certificates to allow this process to take place.

Python uses files to contain certificates. They should be formatted as "PEM" (see RFC 1422), which is a base-64 encoded form wrapped with a header line and a footer line:

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

Certificate chains

The 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:

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

CA certificates

If you are going to require validation of the other side of the connection's certificate, you need to provide a "CA certs" file, filled with the certificate chains for each issuer you are willing to trust. Again, this file just contains these chains concatenated together. For validation, Python will use the first chain it finds in the file which matches. The platform's certificates file can be used by calling SSLContext.load_default_certs(), this is done automatically with create_default_context().

Combined key and certificate

Often the private key is stored in the same file as the certificate; in this case, only the certfile parameter to SSLContext.load_cert_chain() needs to be passed. If the private key is stored with the certificate, it should come before the first certificate in the certificate chain:

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

Self-signed certificates

If you are going to create a server that provides SSL-encrypted connection services, you will need to acquire a certificate for that service. There are many ways of acquiring appropriate certificates, such as buying one from a certification authority. Another common practice is to generate a self-signed certificate. The simplest way to do this is with the OpenSSL package, using something like the following:

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

The disadvantage of a self-signed certificate is that it is its own root certificate, and no one else will have it in their cache of known (and trusted) root certificates.

範例

Testing for SSL support

To test for the presence of SSL support in a Python installation, user code should use the following idiom:

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

Client-side operation

This example creates a SSL context with the recommended security settings for client sockets, including automatic certificate verification:

>>> context = ssl.create_default_context()

If you prefer to tune security settings yourself, you might create a context from scratch (but beware that you might not get the settings right):

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

(this snippet assumes your operating system places a bundle of all CA certificates in /etc/ssl/certs/ca-bundle.crt; if not, you'll get an error and have to adjust the location)

The PROTOCOL_TLS_CLIENT protocol configures the context for cert validation and hostname verification. verify_mode is set to CERT_REQUIRED and check_hostname is set to True. All other protocols create SSL contexts with insecure defaults.

When you use the context to connect to a server, CERT_REQUIRED and check_hostname validate the server certificate: it ensures that the server certificate was signed with one of the CA certificates, checks the signature for correctness, and verifies other properties like validity and identity of the hostname:

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

You may then fetch the certificate:

>>> cert = conn.getpeercert()

Visual inspection shows that the certificate does identify the desired service (that is, the HTTPS host www.python.org):

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

Now the SSL channel is established and the certificate verified, you can proceed to talk with the server:

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

參閱下方 Security considerations 的討論。

Server-side operation

For server operation, typically you'll need to have a server certificate, and private key, each in a file. You'll first create a context holding the key and the certificate, so that clients can check your authenticity. Then you'll open a socket, bind it to a port, call listen() on it, and start waiting for clients to connect:

import socket, ssl

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

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

When a client connects, you'll call accept() on the socket to get the new socket from the other end, and use the context's SSLContext.wrap_socket() method to create a server-side SSL socket for the connection:

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

Then you'll read data from the connstream and do something with it till you are finished with the client (or the client is finished with you):

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

And go back to listening for new client connections (of course, a real server would probably handle each client connection in a separate thread, or put the sockets in non-blocking mode and use an event loop).

Notes on non-blocking sockets

SSL sockets behave slightly different than regular sockets in non-blocking mode. When working with non-blocking sockets, there are thus several things you need to be aware of:

  • Most SSLSocket methods will raise either SSLWantWriteError or SSLWantReadError instead of BlockingIOError if an I/O operation would block. SSLWantReadError will be raised if a read operation on the underlying socket is necessary, and SSLWantWriteError for a write operation on the underlying socket. Note that attempts to write to an SSL socket may require reading from the underlying socket first, and attempts to read from the SSL socket may require a prior write to the underlying socket.

    在 3.5 版的變更: In earlier Python versions, the SSLSocket.send() method returned zero instead of raising SSLWantWriteError or SSLWantReadError.

  • Calling select() tells you that the OS-level socket can be read from (or written to), but it does not imply that there is sufficient data at the upper SSL layer. For example, only part of an SSL frame might have arrived. Therefore, you must be ready to handle SSLSocket.recv() and SSLSocket.send() failures, and retry after another call to select().

  • Conversely, since the SSL layer has its own framing, a SSL socket may still have data available for reading without select() being aware of it. Therefore, you should first call SSLSocket.recv() to drain any potentially available data, and then only block on a select() call if still necessary.

    (of course, similar provisions apply when using other primitives such as poll(), or those in the selectors module)

  • The SSL handshake itself will be non-blocking: the SSLSocket.do_handshake() method has to be retried until it returns successfully. Here is a synopsis using select() to wait for the socket's readiness:

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

也參考

The asyncio module supports non-blocking SSL sockets and provides a higher level API. It polls for events using the selectors module and handles SSLWantWriteError, SSLWantReadError and BlockingIOError exceptions. It runs the SSL handshake asynchronously as well.

Memory BIO Support

在 3.5 版被加入.

Ever since the SSL module was introduced in Python 2.6, the SSLSocket class has provided two related but distinct areas of functionality:

  • SSL protocol handling

  • Network IO

The network IO API is identical to that provided by socket.socket, from which SSLSocket also inherits. This allows an SSL socket to be used as a drop-in replacement for a regular socket, making it very easy to add SSL support to an existing application.

Combining SSL protocol handling and network IO usually works well, but there are some cases where it doesn't. An example is async IO frameworks that want to use a different IO multiplexing model than the "select/poll on a file descriptor" (readiness based) model that is assumed by socket.socket and by the internal OpenSSL socket IO routines. This is mostly relevant for platforms like Windows where this model is not efficient. For this purpose, a reduced scope variant of SSLSocket called SSLObject is provided.

class ssl.SSLObject

A reduced-scope variant of SSLSocket representing an SSL protocol instance that does not contain any network IO methods. This class is typically used by framework authors that want to implement asynchronous IO for SSL through memory buffers.

This class implements an interface on top of a low-level SSL object as implemented by OpenSSL. This object captures the state of an SSL connection but does not provide any network IO itself. IO needs to be performed through separate "BIO" objects which are OpenSSL's IO abstraction layer.

This class has no public constructor. An SSLObject instance must be created using the wrap_bio() method. This method will create the SSLObject instance and bind it to a pair of BIOs. The incoming BIO is used to pass data from Python to the SSL protocol instance, while the outgoing BIO is used to pass data the other way around.

The following methods are available:

When compared to SSLSocket, this object lacks the following features:

  • Any form of network IO; recv() and send() read and write only to the underlying MemoryBIO buffers.

  • There is no do_handshake_on_connect machinery. You must always manually call do_handshake() to start the handshake.

  • There is no handling of suppress_ragged_eofs. All end-of-file conditions that are in violation of the protocol are reported via the SSLEOFError exception.

  • The method unwrap() call does not return anything, unlike for an SSL socket where it returns the underlying socket.

  • The server_name_callback callback passed to SSLContext.set_servername_callback() will get an SSLObject instance instead of a SSLSocket instance as its first parameter.

Some notes related to the use of SSLObject:

在 3.7 版的變更: SSLObject instances must be created with wrap_bio(). In earlier versions, it was possible to create instances directly. This was never documented or officially supported.

An SSLObject communicates with the outside world using memory buffers. The class MemoryBIO provides a memory buffer that can be used for this purpose. It wraps an OpenSSL memory BIO (Basic IO) object:

class ssl.MemoryBIO

A memory buffer that can be used to pass data between Python and an SSL protocol instance.

pending

Return the number of bytes currently in the memory buffer.

eof

A boolean indicating whether the memory BIO is current at the end-of-file position.

read(n=-1)

Read up to n bytes from the memory buffer. If n is not specified or negative, all bytes are returned.

write(buf)

Write the bytes from buf to the memory BIO. The buf argument must be an object supporting the buffer protocol.

The return value is the number of bytes written, which is always equal to the length of buf.

write_eof()

Write an EOF marker to the memory BIO. After this method has been called, it is illegal to call write(). The attribute eof will become true after all data currently in the buffer has been read.

SSL session

在 3.6 版被加入.

class ssl.SSLSession

Session object used by session.

id
time
timeout
ticket_lifetime_hint
has_ticket

Security considerations

Best defaults

For client use, if you don't have any special requirements for your security policy, it is highly recommended that you use the create_default_context() function to create your SSL context. It will load the system's trusted CA certificates, enable certificate validation and hostname checking, and try to choose reasonably secure protocol and cipher settings.

For example, here is how you would use the smtplib.SMTP class to create a trusted, secure connection to a SMTP server:

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

If a client certificate is needed for the connection, it can be added with SSLContext.load_cert_chain().

By contrast, if you create the SSL context by calling the SSLContext constructor yourself, it will not have certificate validation nor hostname checking enabled by default. If you do so, please read the paragraphs below to achieve a good security level.

手動設定

驗證憑證

When calling the SSLContext constructor directly, CERT_NONE is the default. Since it does not authenticate the other peer, it can be insecure, especially in client mode where most of the time you would like to ensure the authenticity of the server you're talking to. Therefore, when in client mode, it is highly recommended to use CERT_REQUIRED. However, it is in itself not sufficient; you also have to check that the server certificate, which can be obtained by calling SSLSocket.getpeercert(), matches the desired service. For many protocols and applications, the service can be identified by the hostname. This common check is automatically performed when SSLContext.check_hostname is enabled.

在 3.7 版的變更: Hostname matchings is now performed by OpenSSL. Python no longer uses match_hostname().

In server mode, if you want to authenticate your clients using the SSL layer (rather than using a higher-level authentication mechanism), you'll also have to specify CERT_REQUIRED and similarly check the client certificate.

協定版本

SSL versions 2 and 3 are considered insecure and are therefore dangerous to use. If you want maximum compatibility between clients and servers, it is recommended to use PROTOCOL_TLS_CLIENT or PROTOCOL_TLS_SERVER as the protocol version. SSLv2 and SSLv3 are disabled by default.

>>> client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
>>> client_context.minimum_version = ssl.TLSVersion.TLSv1_3
>>> client_context.maximum_version = ssl.TLSVersion.TLSv1_3

The SSL context created above will only allow TLSv1.3 and later (if supported by your system) connections to a server. PROTOCOL_TLS_CLIENT implies certificate validation and hostname checks by default. You have to load certificates into the context.

Cipher selection

If you have advanced security requirements, fine-tuning of the ciphers enabled when negotiating a SSL session is possible through the SSLContext.set_ciphers() method. Starting from Python 3.2.3, the ssl module disables certain weak ciphers by default, but you may want to further restrict the cipher choice. Be sure to read OpenSSL's documentation about the cipher list format. If you want to check which ciphers are enabled by a given cipher list, use SSLContext.get_ciphers() or the openssl ciphers command on your system.

Multi-processing

If using this module as part of a multi-processed application (using, for example the multiprocessing or concurrent.futures modules), be aware that OpenSSL's internal random number generator does not properly handle forked processes. Applications must change the PRNG state of the parent process if they use any SSL feature with os.fork(). Any successful call of RAND_add() or RAND_bytes() is sufficient.

TLS 1.3

在 3.7 版被加入.

The TLS 1.3 protocol behaves slightly differently than previous version of TLS/SSL. Some new TLS 1.3 features are not yet available.

  • TLS 1.3 uses a disjunct set of cipher suites. All AES-GCM and ChaCha20 cipher suites are enabled by default. The method SSLContext.set_ciphers() cannot enable or disable any TLS 1.3 ciphers yet, but SSLContext.get_ciphers() returns them.

  • Session tickets are no longer sent as part of the initial handshake and are handled differently. SSLSocket.session and SSLSession are not compatible with TLS 1.3.

  • Client-side certificates are also no longer verified during the initial handshake. A server can request a certificate at any time. Clients process certificate requests while they send or receive application data from the server.

  • TLS 1.3 features like early data, deferred TLS client cert request, signature algorithm configuration, and rekeying are not supported yet.

也參考

socket.socket 類別

底層 socket 類別的文件

SSL/TLS Strong Encryption: An Introduction

Apache HTTP Server 文件的介紹

RFC 1422: Privacy Enhancement for Internet Electronic Mail: Part II: Certificate-Based Key Management

Steve Kent

RFC 4086: Randomness Requirements for Security

Donald E., Jeffrey I. Schiller

RFC 5280: Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile

D. Cooper

RFC 5246: The Transport Layer Security (TLS) Protocol Version 1.2

T. Dierks et. al.

RFC 6066: Transport Layer Security (TLS) Extensions

D. Eastlake

IANA TLS: Transport Layer Security (TLS) Parameters

IANA

RFC 7525: Recommendations for Secure Use of Transport Layer Security (TLS) and Datagram Transport Layer Security (DTLS)

IETF

Mozilla's Server Side TLS recommendations

Mozilla