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

This module does not work or is not available on WebAssembly. See
WebAssembly 平台 for more information.

這個章節記錄了 "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)]

   適用：只有 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" 可能的值。除了 "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 物件 方法：

   * "accept()"

   * "bind()"

   * "close()"

   * "connect()"

   * "detach()"

   * "fileno()"

   * "getpeername()"、"getsockname()"

   * "getsockopt()"、"setsockopt()"

   * "gettimeout()"、"settimeout()"、"setblocking()"

   * "listen()"

   * "makefile()"

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

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

   * "sendfile()" （但 "os.sendfile" 只能用於純文本 sockets，其餘則會
     使用 "send()"）

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

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

備註:

  The "read()" and "write()" methods are the low-level methods that
  read and write unencrypted, application-level data and
  decrypt/encrypt it to encrypted, wire-level data. These methods
  require an active SSL connection, i.e. the handshake was completed
  and "SSLSocket.unwrap()" was not called.Normally you should use the
  socket API methods like "recv()" and "send()" instead of these
  methods.

SSLSocket.do_handshake()

   Perform the SSL setup handshake.

   在 3.4 版的變更: The handshake method also performs
   "match_hostname()" when the "check_hostname" attribute of the
   socket's "context" is true.

   在 3.5 版的變更: The socket timeout is no longer reset each time
   bytes are received or sent. The socket timeout is now the maximum
   total duration of the handshake.

   在 3.7 版的變更: Hostname or IP address is matched by OpenSSL
   during handshake. The function "match_hostname()" is no longer
   used. In case OpenSSL refuses a hostname or IP address, the
   handshake is aborted early and a TLS alert message is sent to the
   peer.

SSLSocket.getpeercert(binary_form=False)

   If there is no certificate for the peer on the other end of the
   connection, return "None".  If the SSL handshake hasn't been done
   yet, raise "ValueError".

   If the "binary_form" parameter is "False", and a certificate was
   received from the peer, this method returns a "dict" instance.  If
   the certificate was not validated, the dict is empty.  If the
   certificate was validated, it returns a dict with several keys,
   amongst them "subject" (the principal for which the certificate was
   issued) and "issuer" (the principal issuing the certificate).  If a
   certificate contains an instance of the *Subject Alternative Name*
   extension (see **RFC 3280**), there will also be a "subjectAltName"
   key in the dictionary.

   The "subject" and "issuer" fields are tuples containing the
   sequence of relative distinguished names (RDNs) given in the
   certificate's data structure for the respective fields, and each
   RDN is a sequence of name-value pairs.  Here is a real-world
   example:

      {'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}

   If the "binary_form" parameter is "True", and a certificate was
   provided, this method returns the DER-encoded form of the entire
   certificate as a sequence of bytes, or "None" if the peer did not
   provide a certificate.  Whether the peer provides a certificate
   depends on the SSL socket's role:

   * for a client SSL socket, the server will always provide a
     certificate, regardless of whether validation was required;

   * for a server SSL socket, the client will only provide a
     certificate when requested by the server; therefore
     "getpeercert()" will return "None" if you used "CERT_NONE"
     (rather than "CERT_OPTIONAL" or "CERT_REQUIRED").

   請見 "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         |
   +--------------------------+--------------+--------------+---------------+-----------+-------------+-------------+

   -[ 註解 ]-

   [1] "SSLContext" 預設會關閉 SSLv2 的 "OP_NO_SSLv2"。

   [2] "SSLContext" 預設會關閉 SSLv3 的 "OP_NO_SSLv3"。

   [3] 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" 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:

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