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

原始碼：Lib/ssl.py

這個模組向用戶端及伺服器端提供了對於網路 socket 的傳輸層安全性協定（或稱為「安全通訊協定 (Secure Sockets Layer)」）加密及身分驗證功能。這個模組使用 OpenSSL 套件。

This is an optional module. If it is missing from your copy of CPython, look for documentation from your distributor (that is, whoever provided Python to you). If you are the distributor, see 可選模組的需求.

備註

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

警告

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

可用性: not WASI.

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

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

此模組提供了一個 `ssl.SSLSocket` 類別，它是從 `socket.socket` 衍生出來的，並且提供類似 socket 的包裝器，讓使用 SSL 進行資料傳輸時，可以進行資料的加密及解密。它也提供了一些額外的方法，如 `getpeercert()`，用於取得連結另一端的憑證；以及 `cipher()`，用於搜尋用於安全連接的加密方法 (cipher)；和 `get_verified_chain()`、`get_unverified_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)

  Return a new `SSLContext` object with default settings for the given purpose. The settings are chosen by the `ssl` module, and usually represent a higher security level than when calling the `SSLContext` constructor directly.

  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.

### Signature algorithms

ssl.get_sigalgs()

  Return a list of available TLS signature algorithm names used by servers to complete the TLS handshake or clients requesting certificate-based authentication. For example:

      >>> ssl.get_sigalgs()
      ['ecdsa_secp256r1_sha256', 'ecdsa_secp384r1_sha384', ...]

  These names can be used when building string values to pass to the `SSLContext.set_client_sigalgs()` and `SSLContext.set_server_sigalgs()` methods.

  在 3.15 版被加入.

### 例外

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()

  Return `True` if the SSL pseudo-random number generator has been seeded with 'enough' randomness, and `False` otherwise. Use `ssl.RAND_add()` to increase the randomness of the pseudo-random number generator.

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)]

  可用性: 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`。

  可用性: Windows.

  在 3.4 版被加入.

### 常數

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

> 在 3.6 版被加入.

ssl.CERT_NONE

  `SSLContext.verify_mode` 可能的值。除了 `PROTOCOL_TLS_CLIENT` 外，這是預設的模式。對於用戶端的 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

  此 OpenSSL 函式庫是否內建支援 TLS-PSK。

  在 3.13 版被加入.

ssl.HAS_PSK_TLS13

  Whether the OpenSSL library has built-in support for External PSKs in TLS 1.3 as described in RFC 9258.

  在 3.15 版被加入.

ssl.HAS_PHA

  此 OpenSSL 函式庫是否內建支援 TLS-PHA。

  在 3.14 版被加入.

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 物件 方法：

  - `accept()`

  - `bind()`

  - `close()`

  - `connect()`

  - `detach()`

  - `fileno()`

  - `getpeername()`、`getsockname()`

  - `getsockopt()`、`setsockopt()`

  - `gettimeout()`、`settimeout()`、`setblocking()`

  - `listen()`

  - `makefile()`

  - `recv()`、`recv_into()` （但不允許傳遞非零的 `flags` 引數）

  - `send()`、`sendall()` （同樣不允許傳遞非零的 `flags` 引數）

  - `sendfile()` (it may be high-performant only when the kernel TLS is enabled by setting `OP_ENABLE_KTLS` or when a socket is plain-text, else `send()` will be used)

  - `shutdown()`

  然而，由於 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 的資料。寫入零長度的資料不再會導致協定違規錯誤。

  在 3.15 版的變更: Python now uses `SSL_sendfile` internally when possible. The function sends a file more efficiently because it performs TLS encryption in the kernel to avoid additional context switches.

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(data)

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

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

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

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

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

備註

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

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

SSLSocket.do_handshake(block=False)

  執行 SSL 設定握手。

  If block is true and the timeout obtained by `gettimeout()` is zero, the socket is set in blocking mode until the handshake is performed.

  在 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.group()

  Return the group used for doing key agreement on this connection. If no connection has been established, returns `None`.

  在 3.15 版被加入.

SSLSocket.client_sigalg()

  Return the signature algorithm used for performing certificate-based client authentication on this connection, or `None` if no connection has been established or client authentication didn't occur.

  在 3.15 版被加入.

SSLSocket.server_sigalg()

  Return the signature algorithm used by the server to complete the TLS handshake on this connection, or `None` if no connection has been established or the cipher suite has no signature.

  在 3.15 版被加入.

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

  註腳

  [1] (1,2)

  `SSLContext` 預設會關閉 SSLv2 的 `OP_NO_SSLv2`。

  [2] (1,2)

  `SSLContext` 預設會關閉 SSLv3 的 `OP_NO_SSLv3`。

  [3] (1,2)

  TLS 1.3 protocol will be available with `PROTOCOL_TLS` in OpenSSL >= 1.1.1. There is no dedicated PROTOCOL constant for just TLS 1.3.

  也參考

  `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` 物件具有以下方法和屬性：

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 版的變更: 新增可選引數 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 版的變更: 新增可選引數 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.get_groups(*, include_aliases=False)

  Get a list of groups implemented for key agreement, taking into account the current TLS `minimum_version` and `maximum_version` values. For example:

      >>> ctx = ssl.create_default_context()
      >>> ctx.minimum_version = ssl.TLSVersion.TLSv1_3
      >>> ctx.maximum_version = ssl.TLSVersion.TLSv1_3
      >>> ctx.get_groups()
      ['secp256r1', 'secp384r1', 'secp521r1', 'x25519', 'x448', ...]

  By default, this method returns only the preferred IANA names for the available groups. However, if the `include_aliases` parameter is set to `True` this method will also return any associated aliases such as the ECDH curve names supported in older versions of OpenSSL.

  在 3.15 版被加入.

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 allowed ciphers for sockets created with this context when connecting using TLS 1.2 and earlier. The ciphers argument should be a string in the OpenSSL cipher list format. To set allowed TLS 1.3 ciphers, use `SSLContext.set_ciphersuites()`.

  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 return details about the negotiated cipher.

SSLContext.set_ciphersuites(ciphersuites, /)

  Set the allowed ciphers for sockets created with this context when connecting using TLS 1.3. The ciphersuites argument should be a colon-separate string of TLS 1.3 cipher names. 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 return details about the negotiated cipher.

  在 3.15 版被加入.

SSLContext.set_groups(groups, /)

  Set the groups allowed for key agreement for sockets created with this context. It should be a string in the OpenSSL group list format.

  備註

  When connected, the `SSLSocket.group()` method of SSL sockets will return the group used for key agreement on that connection.

  在 3.15 版被加入.

SSLContext.set_client_sigalgs(sigalgs, /)

  Set the signature algorithms allowed for certificate-based client authentication. It should be a string in the OpenSSL client sigalgs list format.

  備註

  When connected, the `SSLSocket.client_sigalg()` method of SSL sockets will return the signature algorithm used for performing certificate-based client authentication on that connection.

  在 3.15 版被加入.

SSLContext.set_server_sigalgs(sigalgs, /)

  Set the signature algorithms allowed for the server to complete the TLS handshake. It should be a string in the OpenSSL sigalgs list format.

  備註

  When connected, the `SSLSocket.server_sigalg()` method of SSL sockets will return the signature algorithm used by the server to complete the TLS handshake on that connection.

  在 3.15 版被加入.

SSLContext.set_alpn_protocols(alpn_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.

  此方法會在 `HAS_ALPN` 為 `False` 時引發 `NotImplementedError`。

  在 3.5 版被加入.

SSLContext.set_npn_protocols(npn_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.

  此方法會在 `HAS_NPN` 為 `False` 時引發 `NotImplementedError`。

  在 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.

  此方法在 `HAS_ECDH` 為 `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 assigned to on instances of `SSLContext` 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` 會回傳 `Options` 旗標：

      >>> 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` 會回傳 `VerifyFlags` 旗標：

      >>> 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` 會回傳 `VerifyMode` 列舉：

      >>> 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.

  備註

  使用 TLS 1.3 時：

  - `hint` 參數始終為 `None`。

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

  範例用法：

      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.

  範例用法：

      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 的討論。

### 伺服器端操作

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 Streams API. It polls for events using the `selectors` module and handles `SSLWantWriteError`, `SSLWantReadError` and `BlockingIOError` exceptions. It runs the SSL handshake asynchronously as well.

## 記憶體 BIO 支援

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

  - `context`

  - `server_side`

  - `server_hostname`

  - `session`

  - `session_reused`

  - `read()`

  - `write()`

  - `getpeercert()`

  - `get_verified_chain()`

  - `get_unverified_chain()`

  - `selected_alpn_protocol()`

  - `selected_npn_protocol()`

  - `cipher()`

  - `shared_ciphers()`

  - `compression()`

  - `pending()`

  - `do_handshake()`

  - `verify_client_post_handshake()`

  - `unwrap()`

  - `get_channel_binding()`

  - `version()`

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

  - All IO on an `SSLObject` is non-blocking. This means that for example `read()` will raise an `SSLWantReadError` if it needs more data than the incoming BIO has available.

  在 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. To restrict which TLS 1.3 ciphers are allowed, the `SSLContext.set_ciphersuites()` method should be called instead of `SSLContext.set_ciphers()`, which only affects ciphers in older TLS versions. The `SSLContext.get_ciphers()` method returns information about ciphers for both TLS 1.3 and earlier versions and the method `SSLSocket.cipher()` returns information about the negotiated cipher for both TLS 1.3 and earlier versions once a connection is established.

- 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, 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. Eastlake, Jeffrey I. Schiller, Steve Crocker

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

  David Cooper et al.

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

  Tim Dierks 與 Eric Rescorla.

RFC 6066: Transport Layer Security (TLS) Extensions

  Donald E. 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