ssl
--- socket 物件的 TLS/SSL 包裝器¶
原始碼:Lib/ssl.py
這個模組向客戶端及伺服器端提供了對於網路 socket 的傳輸層安全性協定(或稱為「安全通訊協定 (Secure Sockets Layer)」)加密及身分驗證功能。這個模組使用 OpenSSL 套件,它可以在所有的 Unix 系統、Windows、macOS、以及其他任何可能的平台上使用,只要事先在該平台上安裝 OpenSSL。
備註
由於呼叫了作業系統的 socket APIs,有些行為會根據平台而有所不同。OpenSSL 的安裝版本也會對模組的運作產生影響。例如,OpenSSL 版本 1.1.1 附帶 TLSv1.3。
警告
在使用此模組之前,請閱讀 Security considerations。如果不這樣做,可能會產生錯誤的安全性認知,因為 ssl 模組的預設設定未必適合你的應用程式。
Availability: not WASI.
此模組在 WebAssembly 平台上不起作用或無法使用。更多資訊請參閱 WebAssembly 平台。
這個章節記錄了 ssl
模組的物件及函式;關於 TSL、SSL、以及憑證的更多資訊,可以去參考此章節底部的「詳情」部分。
This module provides a class, ssl.SSLSocket
, which is derived from the
socket.socket
type, and provides a socket-like wrapper that also
encrypts and decrypts the data going over the socket with SSL. It supports
additional methods such as getpeercert()
, which retrieves the
certificate of the other side of the connection, cipher()
, which
retrieves the cipher being used for the secure connection or
get_verified_chain()
, get_unverified_chain()
which retrieves
certificate chain.
對於更複雜的應用程式,ssl.SSLContext
類別有助於管理設定及認證,然後可以透過 SSLContext.wrap_socket()
方法建立的 SSL socket 繼承這些設定和認證。
在 3.5.3 版的變更: 更新以支援與 OpenSSL 1.1.0 進行連結
在 3.6 版的變更: OpenSSL 0.9.8, 1.0.0 及 1.0.1 版本已被棄用且不再支援。在未來 ssl 模組將需要至少 OpenSSL 1.0.2 版本或 1.1.0 版本。
在 3.10 版的變更: PEP 644 已經被實作。ssl 模組需要 OpenSSL 1.1.1 以上的版本才能使用。
使用已經被棄用的常數或函式將會導致棄用警示。
函式、常數與例外¶
Socket 建立¶
SSLSocket
實例必須使用 SSLContext.wrap_socket()
方法來建立。輔助函式 create_default_context()
會回傳有安全預設設定的新語境 (context)。
使用預設語境及 IPv4/IPv6 雙協定堆疊的客戶端 socket 範例:
import socket
import ssl
hostname = 'www.python.org'
context = ssl.create_default_context()
with socket.create_connection((hostname, 443)) as sock:
with context.wrap_socket(sock, server_hostname=hostname) as ssock:
print(ssock.version())
使用自訂語境及 IPv4 的客戶端 socket範例:
hostname = 'www.python.org'
# PROTOCOL_TLS_CLIENT requires valid cert chain and hostname
context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
context.load_verify_locations('path/to/cabundle.pem')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
with context.wrap_socket(sock, server_hostname=hostname) as ssock:
print(ssock.version())
在本地 IPv4 上監聽伺服器 socket 的範例:
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain('/path/to/certchain.pem', '/path/to/private.key')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
sock.bind(('127.0.0.1', 8443))
sock.listen(5)
with context.wrap_socket(sock, server_side=True) as ssock:
conn, addr = ssock.accept()
...
語境建立¶
一個可以幫忙建立出 SSLContext
物件以用於一般目的的方便函式。
- ssl.create_default_context(purpose=Purpose.SERVER_AUTH, cafile=None, capath=None, cadata=None)¶
回傳一個新的
SSLContext
物件,使用給定 purpose 的預設值。這些設定是由ssl
選擇,通常比直接呼叫SSLContext
有更高的安全性。cafile, capath, cadata 是用來選擇用於憑證認證的 CA 憑證,就像
SSLContext.load_verify_locations()
一樣。如果三個值都是None
,此函式會自動選擇系統預設的 CA 憑證。這些設定包含:
PROTOCOL_TLS_CLIENT
或PROTOCOL_TLS_SERVER
、OP_NO_SSLv2
、以及OP_NO_SSLv3
,使用高等加密套件但不包含 RC4 和未經身份驗證的加密套件。如果將 purpose 設定為SERVER_AUTH
,則會把verify_mode
設為CERT_REQUIRED
並使用設定的 CA 憑證(當 cafile、capath 或 cadata 其中一個值有被設定時) 或使用預設的 CA 憑證SSLContext.load_default_certs()
。當系統有支援
keylog_filename
並且有設定環境變數SSLKEYLOGFILE
時create_default_context()
會啟用密鑰日誌記錄 (logging)。The default settings for this context include
VERIFY_X509_PARTIAL_CHAIN
andVERIFY_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
andVERIFY_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¶
-
在 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.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 tupleDefaultVerifyPaths
:cafile
- 解析後的 cafile 路徑,如果檔案不存在則為None
,capath
- 解析後的 capath 路徑,如果目錄不存在則為None
,openssl_cafile_env
- 指向 cafile 的 OpenSSL 環境密鑰,openssl_cafile
- hard coded 的 cafile 路徑,openssl_capath_env
- 指向 capath 的 OpenSSL 環境密鑰,openssl_capath
- hard coded 的 capath 目錄路徑
在 3.4 版被加入.
- ssl.enum_certificates(store_name)¶
從 Windows 的系統憑證儲存庫中搜尋憑證。store_name 可以是
CA
、ROOT
或MY
的其中一個。Windows 也可能會提供額外的憑證儲存庫。此函式會回傳一個元組 (cert_bytes, encoding_type, trust) 串列。encoding_type 指定了 cert_bytes 的編碼格式。它可以是用來表示 X.509 ASN.1 資料的
x509_asn
或是用來表示 PKCS#7 ASN.1 資料的pkcs_7_asn
。Trust 通過一組 OIDS 來指定憑證的用途,或是如果憑證對所有用途都可以使用則回傳True
。範例:
>>> ssl.enum_certificates("CA") [(b'data...', 'x509_asn', {'1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2'}), (b'data...', 'x509_asn', True)]
Availability: Windows.
在 3.4 版被加入.
- ssl.enum_crls(store_name)¶
從 Windows 的系統憑證儲存庫中搜尋 CRLs。store_name 可以是
CA
、ROOT
或MY
的其中一個。Windows 也可能會提供額外的憑證儲存庫。此函式會回傳一個元組 (cert_bytes, encoding_type, trust) 串列。encoding_type 指定了 cert_bytes 的編碼格式。它可以是用來表示 X.509 ASN.1 資料的
x509_asn
或是用來表示 PKCS#7 ASN.1 資料的pkcs_7_asn
。Availability: Windows.
在 3.4 版被加入.
常數¶
所有的常數現在都是
enum.IntEnum
或enum.IntFlag
的集合。在 3.6 版被加入.
- ssl.CERT_NONE¶
SSLContext.verify_mode
可能的值。除了SSLContext.verify_mode
外,這是預設的模式。對於客戶端的 sockets,幾乎任何憑證都能被允許。驗證錯誤,像是不被信任或是過期的憑證,會被忽略並不會中止 TLS/SSL 握手。在伺服器模式下,不會從客戶端請求任何憑證,所以客戶端不用發送任何用於客戶端憑證身分驗證的憑證。
參閱下方 Security considerations 的討論。
- ssl.CERT_OPTIONAL¶
SSLContext.verify_mode
可能的值。在客戶端模式下,CERT_OPTIONAL
具有與CERT_REQUIRED
相同的含意。對於客戶端 sockets 推薦改用CERT_REQUIRED
。在伺服器模式下,客戶憑證請求會被發送給客戶端。客戶端可以選擇忽略請求或是選擇發送憑證來執行 TLS 客戶端憑證身分驗證。如果客戶端選擇發送憑證,則會對其進行驗證。任何驗證錯誤都會立刻終止 TLS 握手。
使用此設定需要將一組有效的 CA 憑證傳送給
SSLContext.load_verify_locations()
。
- ssl.CERT_REQUIRED¶
SSLContext.verify_mode
可能的值。在這個模式下,需要從 socket 連線的另一端獲取憑證;如果未提供憑證或是驗證失敗,則將會導致SSLError
。此模式 不能 在客戶端模式下對憑證進行驗證,因為它無法去配對主機名稱。check_hostname
也必須被開起來來驗證憑證的真實性。PROTOCOL_TLS_CLIENT
會使用CERT_REQUIRED
並預設開啟check_hostname
。對於 socket 伺服器,此模式會提供強制的 TLS 客戶端憑證驗證。客戶端憑證請求會被發送給客戶端並且客戶端必須提供有效且被信任的憑證。
使用此設定需要將一組有效的 CA 憑證傳送給
SSLContext.load_verify_locations()
。
- class ssl.VerifyMode¶
enum.IntEnum
為 CERT_* 常數的一個集合。在 3.6 版被加入.
- ssl.VERIFY_DEFAULT¶
SSLContext.verify_flags
可能的值。在此模式下,不會檢查憑證吊銷列表 (CRLs)。預設的 OpenSSL 並不會請求及驗證 CRLs。在 3.4 版被加入.
- ssl.VERIFY_CRL_CHECK_LEAF¶
SSLContext.verify_flags
可能的值。在此模式下,只會檢查同等的憑證而不會去檢查中間的 CA 憑證。此模式需要提供由對等憑證發行者 (它的直接上級 CA) 的有效的 CRL 簽名。如果沒有用SSLContext.load_verify_locations
載入適當的 CRL,則會驗證失敗。在 3.4 版被加入.
- ssl.VERIFY_CRL_CHECK_CHAIN¶
SSLContext.verify_flags
可能的值。在此模式下,會檢查對等憑證鍊中所有憑證的 CRLs。在 3.4 版被加入.
- ssl.VERIFY_X509_STRICT¶
SSLContext.verify_flags
可能的值,用來禁用已損壞的 X.509 憑證的解決方法。在 3.4 版被加入.
- ssl.VERIFY_ALLOW_PROXY_CERTS¶
SSLContext.verify_flags
可能的值,用來啟用憑證代理驗證。在 3.10 版被加入.
- ssl.VERIFY_X509_TRUSTED_FIRST¶
SSLContext.verify_flags
可能的值。它指示 OpenSSL 在構建信任鍊來驗證憑證時會優先使用被信任的憑證。此旗標預設開啟。在 3.4.4 版被加入.
- ssl.VERIFY_X509_PARTIAL_CHAIN¶
SSLContext.verify_flags
可能的值。它指示 OpenSSL 接受信任存儲中的中間 CAs 作為信任錨,就像自簽名的根 CA 憑證。這樣就能去信任中間 CA 所頒發的憑證,而不一定非要去信任其祖先的根 CA。在 3.10 版被加入.
- class ssl.VerifyFlags¶
enum.IntFlag
為 VERIFY_* 常數的其中一個集合。在 3.6 版被加入.
- ssl.PROTOCOL_TLS¶
選擇客戶端及伺服器均可以支援最高協定版本。儘管名稱只有 「TLS」,但實際上「SSL」和「TLS」均可以選擇。
在 3.6 版被加入.
在 3.10 版之後被棄用: TLS 的客戶端及伺服器端需要不同的預設值來實現安全通訊。通用的 TLS 協定常數已被廢除,並改用
PROTOCOL_TLS_CLIENT
和PROTOCOL_TLS_SERVER
。
- ssl.PROTOCOL_TLS_CLIENT¶
自動協商客戶端和服務器都支援的最高協議版本,並配置客戶端語境連線。該協定預設啟用
CERT_REQUIRED
和check_hostname
。在 3.6 版被加入.
- ssl.PROTOCOL_TLS_SERVER¶
自動協商客戶端和服務器都支援的最高協議版本,並配置客戶端語境連線。
在 3.6 版被加入.
- ssl.PROTOCOL_SSLv23¶
PROTOCOL_TLS
的別名。在 3.6 版之後被棄用: 請改用
PROTOCOL_TLS
。
- ssl.PROTOCOL_SSLv3¶
選擇第三版的 SSL 做為通道加密協定。
如果 OpenSSL 是用
no-ssl3
編譯的,則此項協議無法使用。警告
第三版的 SSL 是不安全的,強烈建議不要使用。
在 3.6 版之後被棄用: OpenSSL 已經終止了所有特定版本的協定。請改用預設的
PROTOCOL_TLS_SERVER
協定或帶有SSLContext.minimum_version
和SSLContext.maximum_version
的PROTOCOL_TLS_CLIENT
。
- ssl.PROTOCOL_TLSv1¶
選擇 1.0 版的 TLS 做為通道加密協定。
在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。
- ssl.PROTOCOL_TLSv1_1¶
選擇 1.1 版的 TLS 做為通道加密協定。只有在 1.0.1 版本以上的 OpenSSL 才可以選用。
在 3.4 版被加入.
在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。
- ssl.PROTOCOL_TLSv1_2¶
選擇 1.2 版的 TLS 做為通道加密協定。只有在 1.0.1 版本以上的 OpenSSL 才可以選用。
在 3.4 版被加入.
在 3.6 版之後被棄用: OpenSSL 已經將所有版本特定的協定棄用。
- ssl.OP_ALL¶
啟用對 SSL 實作時所產生的各種錯誤的緩解措施。此選項預設被設定。它不一定設定與 OpenSSL 的
SSL_OP_ALL
常數相同的旗標。在 3.2 版被加入.
- ssl.OP_NO_SSLv2¶
防止 SSLv2 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級 (peer)選用 SSLv2 做為協定版本。在 3.2 版被加入.
在 3.6 版之後被棄用: SSLv2 已被棄用
- ssl.OP_NO_SSLv3¶
防止 SSLv3 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級選用 SSLv3 做為協定版本。在 3.2 版被加入.
在 3.6 版之後被棄用: SSLv3 已被棄用
- ssl.OP_NO_TLSv1¶
防止 TLSv1 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級選用 TLSv1 做為協定版本。在 3.2 版被加入.
在 3.7 版之後被棄用: 該選項自從 OpenSSL 1.1.0 以後已被棄用,請改用新的
SSLContext.minimum_version
及SSLContext.maximum_version
代替。
- ssl.OP_NO_TLSv1_1¶
防止 TLSv1.1 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級選用 TLSv1.1 做為協定版本。只有 1.0.1 版後的 OpenSSL 版本才能使用。在 3.4 版被加入.
在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 版已被棄用。
- ssl.OP_NO_TLSv1_2¶
防止 TLSv1.2 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級選用 TLSv1.2 做為協定版本。只有 1.0.1 版後的 OpenSSL 版本才能使用。在 3.4 版被加入.
在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 版已被棄用。
- ssl.OP_NO_TLSv1_3¶
防止 TLSv1.3 連線。此選項只可以跟
PROTOCOL_TLS
一起使用。它會防止同級選用 TLSv1.3 做為協定版本。TSL1.3 只適用於 1.1.1 版以後的 OpenSSL。當使用 Python 編譯舊版的 OpenSSL 時,該標志預設為 0。在 3.6.3 版被加入.
在 3.7 版之後被棄用: 此選項自 OpenSSL 1.1.0 以後已被棄用。它被添加到 2.7.15 和 3.6.3 中,以向後相容 OpenSSL 1.0.2。
- ssl.OP_NO_RENEGOTIATION¶
停用所有在 TLSv1.2 及更早版本的重協商 (renegotiation)。不發送 HelloRequest 訊息,並忽略通過 ClientHello 的重協商請求。
此選項僅適用於 OpenSSL 1.1.0h 及更新版本。
在 3.7 版被加入.
- ssl.OP_CIPHER_SERVER_PREFERENCE¶
使用伺服器的加密方法名稱字串排序優先順序,而不是客戶端的。此選項並不會影響到客戶端及 SSLv2 伺服器的 sockets。
在 3.3 版被加入.
- ssl.OP_SINGLE_DH_USE¶
防止對不同的 SSL 會談重複使用相同的 DH 密鑰。這會加強向前保密但需要更多的運算資源。此選項只適用於伺服器 sockets。
在 3.3 版被加入.
- ssl.OP_SINGLE_ECDH_USE¶
防止對不同的 SSL 會談重複使用相同的 ECDH 密鑰。這會加強向前保密但需要更多的運算資源。此選項只適用於伺服器 sockets。
在 3.3 版被加入.
- ssl.OP_ENABLE_MIDDLEBOX_COMPAT¶
在 TLS 1.3 握手中發送虛擬的變更加密方法規範 (CCS) 消息,以使 TLS 1.3 連接看起來更像 TLS 1.2 連線。
此選項僅適用於 OpenSSL 1.1.1 及更新版本。
在 3.8 版被加入.
- ssl.OP_NO_COMPRESSION¶
在 SSL 通道上禁用壓縮。如果應用程序協定支援自己的壓縮方案,這會很有用。
在 3.3 版被加入.
- class ssl.Options¶
enum.IntFlag
為 OP_* 常數中的一個集合。
- ssl.OP_NO_TICKET¶
防止客戶端請求會談票據。
在 3.6 版被加入.
- ssl.OP_IGNORE_UNEXPECTED_EOF¶
忽略意外關閉的 TLS 連線。
此選項僅適用於 OpenSSL 3.0.0 及更新版本。
在 3.10 版被加入.
- ssl.OP_ENABLE_KTLS¶
允許使用 TLS 核心。要想受益於該功能,OpenSSL 必須編譯為支援該功能,並且想使用的加密套件及擴充套件也必須被該功能支援 (該功能所支援的列表可能會因平台及核心而有所差異)。
請注意當允許使用 TLS 核心時,一些加密操作將直接由核心執行而不是經由任何由可用的 OpenSSL 所提供的程序,而這可能並非你所想使用的,例如:當應用程式要求所有的加密操作由 FIPS 提供執行。
此選項僅適用於 OpenSSL 3.0.0 及更新版本。
在 3.12 版被加入.
- ssl.OP_LEGACY_SERVER_CONNECT¶
只允許 OpenSSL 與未修補的伺服器進行遺留 (legacy) 不安全重協商。
在 3.12 版被加入.
- ssl.HAS_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_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.HAS_PHA¶
Whether the OpenSSL library has built-in support for TLS-PHA.
在 3.14.0a3 (unreleased) 版被加入.
- 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 物件 方法:
recv()
、recv_into()
(但不允許傳遞非零的flags
引數)sendfile()
(但os.sendfile
只能用於純文本 sockets,其餘則會使用send()
)
然而,由於 SSL(和 TLS)協定在 TCP 之上有自己的框架,因此在某些方面,SSL sockets 的抽象可能會與普通操作系統級別的 sockets 規範有所不同。特別是請參閱關於 non-blocking sockets 的說明。
SSLSocket
的實例必須使用SSLContext.wrap_socket()
方法建立。在 3.5 版的變更: 新增
sendfile()
方法。在 3.5 版的變更:
shutdown()
不會在每次接收或發送位元組時重置 socket 超時時間。現在,socket 超時時間是關閉操作的最大總持續時間。在 3.6 版之後被棄用: 直接建立
SSLSocket
實例的方式已被棄用,請使用SSLContext.wrap_socket()
來包裝 socket。在 3.7 版的變更:
SSLSocket
實例必須使用wrap_socket()
建立。在較早的版本中可以直接建立實例,但這從未被記錄或正式支援。在 3.10 版的變更: Python 現在內部使用了
SSL_read_ex
和SSL_write_ex
函式。這些函式支援讀取和寫入大於 2 GB 的資料。寫入零長度的資料不再會導致協定違規錯誤。
SSL sockets 還具有以下附加方法和屬性:
- SSLSocket.read(len=1024, buffer=None)¶
從 SSL socket 讀取 len 位元組的資料,並將結果以
bytes
實例的形式回傳。如果指定了 buffer,則將資料讀入緩衝區,並回傳讀取的位元組。如果 socket 是非阻塞的則會引發
SSLWantReadError
或SSLWantWriteError
並且讀取操作將會被阻塞。由於在任何時刻都可能發生重新協商,呼叫
read()
也可能觸發寫入操作。在 3.5 版的變更: 當接收或發送位元組時,socket 的超時時間將不再重置。現在,socket 超時時間是讀取最多 len 位元組的總最大持續時間。
在 3.6 版之後被棄用: 請改用
recv()
來替換掉read()
。
- SSLSocket.write(buf)¶
將 buf 寫入 SSL socket 並回傳寫入的位元組數量。buf 引數必須是支援緩衝區介面的物件。
如果 socket 是非阻塞的則會引發
SSLWantReadError
或SSLWantWriteError
並且寫入操作將會被阻塞。由於在任何時刻都可能發生重新協商,呼叫
write()
也可能觸發讀取操作。在 3.5 版的變更: 當接收或發送位元組時,socket 的超時時間將不再重置。現在,socket 超時時間是寫入 buf 的總最大持續時間。
在 3.6 版之後被棄用: 請改用
send()
來替換掉write()
。
備註
read()
和 write()
方法為低階層的方法,負責讀取和寫入未加密的應用層資料,並將其加密/解密為加密的寫入層資料。這些方法需要一個已建立的 SSL 連接,即握手已完成,且未呼叫 SSLSocket.unwrap()
。
- SSLSocket.do_handshake()¶
執行 SSL 設定握手。
在 3.4 版的變更: 當 socket 的
context
的check_hostname
屬性質為 true 時,握手方法也會執行match_hostname()
。在 3.5 版的變更: Socket 超時時間已經不會在每次接收或傳送位元組時重置。現在,超時時間是握手過程的最大總持續時間。
在 3.7 版的變更: 在握手過程中,OpenSSL 會去配對主機名稱或 IP 地址。已不再使用
match_hostname()
函式。如果 OpenSSL 拒絕某個主機名稱或 IP 地址,握手將會提前中止,並向對方發送 TLS 警報訊息。
- SSLSocket.getpeercert(binary_form=False)¶
如果連線端沒有證書,則回傳
None
。如果 SSL 握手尚未完成,則引發ValueError
。如果
binary_form
參數為False
,且從對等 (peer) 接收到證書,則該方法回傳一個dict
實例。如果證書未被驗證,則該字典為空。若證書已被驗證,則回傳的字典將包含數個鍵值,包括subject
(證書所簽發的對象) 和issuer
(簽發證書的主體)。如果證書中包含 Subject Alternative Name 擴充 (參考RFC 3280),字典中還會有一個subjectAltName
鍵。subject
和issuer
欄位欄位是包含相對識別名稱 (relative distinguished names, RDNs) 序列的元組,這些 RDN 來自證書資料結構中的相應欄位。每個 RDN 都是一組名稱與值的對。以下是現實中的範例:{'issuer': ((('countryName', 'IL'),), (('organizationName', 'StartCom Ltd.'),), (('organizationalUnitName', 'Secure Digital Certificate Signing'),), (('commonName', 'StartCom Class 2 Primary Intermediate Server CA'),)), 'notAfter': 'Nov 22 08:15:19 2013 GMT', 'notBefore': 'Nov 21 03:09:52 2011 GMT', 'serialNumber': '95F0', 'subject': ((('description', '571208-SLe257oHY9fVQ07Z'),), (('countryName', 'US'),), (('stateOrProvinceName', 'California'),), (('localityName', 'San Francisco'),), (('organizationName', 'Electronic Frontier Foundation, Inc.'),), (('commonName', '*.eff.org'),), (('emailAddress', 'hostmaster@eff.org'),)), 'subjectAltName': (('DNS', '*.eff.org'), ('DNS', 'eff.org')), 'version': 3}
如果
binary_form
參數設定為True
,且對等提供了證書,則該方法會以 DER 編碼形式 將整個證書以位元組序列形式回傳。如果對等未提供證書,則回傳None
。對等是否提供證書取決於 SSL socket 的腳色:對於客戶端 SSL socket,伺服器將永遠提供證書,無論是否需要進行驗證;
對於伺服器 SSL socket,客戶端僅在伺服器要求時才會提供證書;因此,如果你使用的是
CERT_NONE
(而非CERT_OPTIONAL
或CERT_REQUIRED
),則getpeercert()
會回傳None
。
在 3.2 版的變更: The returned dictionary includes additional items such as
issuer
andnotBefore
.在 3.4 版的變更:
ValueError
is raised when the handshake isn't done. The returned dictionary includes additional X509v3 extension items such ascrlDistributionPoints
,caIssuers
andOCSP
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
.
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()
returnsNone
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 returnNone
.在 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 andFalse
for client-side sockets.在 3.2 版被加入.
- SSLSocket.server_hostname¶
Hostname of the server:
str
type, orNone
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 beforedo_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 isPROTOCOL_TLS
; it provides the most compatibility with other versions.Here's a table showing which versions in a client (down the side) can connect to which versions in a server (along the top):
client / server
SSLv2
SSLv3
TLS [3]
TLSv1
TLSv1.1
TLSv1.2
SSLv2
yes
no
no [1]
no
no
no
SSLv3
no
yes
no [2]
no
no
no
TLS (SSLv23) [3]
no [1]
no [2]
yes
yes
yes
yes
TLSv1
no
no
yes
yes
no
no
TLSv1.1
no
no
yes
no
yes
no
TLSv1.2
no
no
yes
no
no
yes
註解
也參考
create_default_context()
lets thessl
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
, andOP_NO_SSLv3
(except forPROTOCOL_SSLv3
) are set by default. The initial cipher suite list contains onlyHIGH
ciphers, noNULL
ciphers and noMD5
ciphers.在 3.10 版之後被棄用:
SSLContext
without protocol argument is deprecated. The context class will either requirePROTOCOL_TLS_CLIENT
orPROTOCOL_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
, andPROTOCOL_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
andROOT
system stores. On all systems it callsSSLContext.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 thanCERT_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 isFalse
each list entry is a dict like the output ofSSLSocket.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, theSSLSocket.selected_alpn_protocol()
method will return the agreed-upon protocol.This method will raise
NotImplementedError
ifHAS_ALPN
isFalse
.在 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, theSSLSocket.selected_npn_protocol()
method will return the agreed-upon protocol.This method will raise
NotImplementedError
ifHAS_NPN
isFalse
.在 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 toNone
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 (orNone
if the TLS Client Hello does not contain a server name) and the third argument is the originalSSLContext
. 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
'sSSLSocket.context
attribute to a new object of typeSSLContext
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()
andSSLSocket.context
. TheSSLSocket.getpeercert()
,SSLSocket.get_verified_chain()
,SSLSocket.get_unverified_chain()
SSLSocket.cipher()
andSSLSocket.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 constantALERT_DESCRIPTION_*
can be returned. Other return values will result in a TLS fatal error withALERT_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
isFalse
.在 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
(defaultSSLSocket
). The returned SSL socket is tied to the context, its settings and certificates. sock must be aSOCK_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 theaccept()
method. The method may raiseSSLError
.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 asocket.connect()
, or whether the application program will call it explicitly, by invoking theSSLSocket.do_handshake()
method. CallingSSLSocket.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 theSSLSocket.recv()
method should signal unexpected EOF from the other end of the connection. If specified asTrue
(the default), it returns a normal EOF (an empty bytes object) in response to unexpected EOF errors raised from the underlying socket; ifFalse
, it will raise the exceptions back to the caller.session, see
session
.To wrap an
SSLSocket
in anotherSSLSocket
, useSSLContext.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-codedSSLSocket
.
- SSLContext.sslsocket_class¶
The return type of
SSLContext.wrap_socket()
, defaults toSSLSocket
. The attribute can be overridden on instance of class in order to return a custom subclass ofSSLSocket
.在 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
(defaultSSLObject
). 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-codedSSLObject
.
- SSLContext.sslobject_class¶
The return type of
SSLContext.wrap_bio()
, defaults toSSLObject
. The attribute can be overridden on instance of class in order to return a custom subclass ofSSLObject
.在 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'sverify_mode
must be set toCERT_OPTIONAL
orCERT_REQUIRED
, and you must pass server_hostname towrap_socket()
in order to match the hostname. Enabling hostname checking automatically setsverify_mode
fromCERT_NONE
toCERT_REQUIRED
. It cannot be set back toCERT_NONE
as long as hostname checking is enabled. ThePROTOCOL_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 toCERT_REQUIRED
when hostname checking is enabled andverify_mode
isCERT_NONE
. Previously the same operation would have failed with aValueError
.
- 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 toTLSVersion.MAXIMUM_SUPPORTED
. The attribute is read-only for protocols other thanPROTOCOL_TLS
,PROTOCOL_TLS_CLIENT
, andPROTOCOL_TLS_SERVER
.The attributes
maximum_version
,minimum_version
andSSLContext.options
all affect the supported SSL and TLS versions of the context. The implementation does not prevent invalid combination. For example a context withOP_NO_TLSv1_2
inoptions
andmaximum_version
set toTLSVersion.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 orTLSVersion.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 asOP_NO_SSLv2
by ORing them together.在 3.6 版的變更:
SSLContext.options
returnsOptions
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*
andOP_NO_TLS*
options have been deprecated since Python 3.7. UseSSLContext.minimum_version
andSSLContext.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 toCERT_OPTIONAL
orCERT_REQUIRED
, too. The actual client cert exchange is delayed untilSSLSocket.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
returnsVerifyFlags
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
orCERT_REQUIRED
.在 3.6 版的變更:
SSLContext.verify_mode
returnsVerifyMode
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]
. Thehint
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 to256
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
toNone
removes any existing callback.備註
When using TLS 1.3:
the
hint
parameter is alwaysNone
.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
ifHAS_PSK
isFalse
.在 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
. Theidentity
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
toNone
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 to256
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
ifHAS_PSK
isFalse
.在 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 eitherSSLWantWriteError
orSSLWantReadError
instead ofBlockingIOError
if an I/O operation would block.SSLWantReadError
will be raised if a read operation on the underlying socket is necessary, andSSLWantWriteError
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 raisingSSLWantWriteError
orSSLWantReadError
.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 handleSSLSocket.recv()
andSSLSocket.send()
failures, and retry after another call toselect()
.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 callSSLSocket.recv()
to drain any potentially available data, and then only block on aselect()
call if still necessary.(of course, similar provisions apply when using other primitives such as
poll()
, or those in theselectors
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 usingselect()
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.
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 thewrap_bio()
method. This method will create theSSLObject
instance and bind it to a pair of BIOs. The incoming BIO is used to pass data from Python to the SSL protocol instance, while the outgoing BIO is used to pass data the other way around.The following methods are available:
When compared to
SSLSocket
, this object lacks the following features:Any form of network IO;
recv()
andsend()
read and write only to the underlyingMemoryBIO
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 anSSLObject
instance instead of aSSLSocket
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 exampleread()
will raise anSSLWantReadError
if it needs more data than the incoming BIO has available.
在 3.7 版的變更:
SSLObject
instances must be created withwrap_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.
SSL session¶
在 3.6 版被加入.
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, butSSLContext.get_ciphers()
returns them.Session tickets are no longer sent as part of the initial handshake and are handled differently.
SSLSocket.session
andSSLSession
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