Python 安全性：限制令牌與檔案系統授權控制

– 16 分鐘閱讀

在 Python 開發中，確保系統安全至關重要。本文將探討如何限制令牌存取範圍和時間，以及如何安全地操作檔案系統，包含檔案開啟、建立暫存檔案以及執行外部命令等。同時，我們也將探討如何防禦常見的 Web 安全攻擊，例如命令注入、跨站指令碼（XSS）和跨站請求偽造（CSRF），並提供使用 Python 內建模組和第三方函式庫的防禦策略，以提升程式碼的安全性，並降低潛在風險。 我們將深入探討檔案系統授權控制，包含如何使用 os 和 stat 模組來設定和檢查檔案的授權，以及如何變更檔案的許可權和所有權。最後，我們將探討如何使用 subprocess 模組安全地執行外部程式，以及如何使用 GitPython 進行 Git Repository 管理。

限制令牌存取範圍和時間以降低風險

為了確保系統安全，限制令牌的存取範圍和時間是非常重要的。這可以透過以下幾種方式實作：

  • 限制令牌的作用範圍：令牌的作用範圍應該被限制在最小的範圍內，以避免令牌被濫用。
  • 限制令牌的有效時間：令牌的有效時間應該被限制在最短的時間內，以避免令牌被長期使用。

檔案系統授權

檔案系統授權是指對檔案系統的存取進行控制和限制。Python 內建了對檔案系統的存取功能，無需額外的函式庫。

安全開啟檔案

開啟檔案時，應該使用 try-except 陳述式來處理可能的錯誤，例如檔案不存在或無法開啟。

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except PermissionError:
    print("無法開啟檔案")

安全建立暫存檔案

建立暫存檔案時，應該使用 tempfile 函式庫來確保檔案被安全地建立和刪除。

import tempfile

with tempfile.TemporaryFile() as tmp:
    tmp.write(b'Hello world!')

執行外部命令

執行外部命令時，應該使用 subprocess 函式庫來確保命令被安全地執行。

import subprocess

subprocess.run(['ls', '-l'])

防禦命令注入攻擊

命令注入攻擊是指攻擊者將惡意命令注入到系統中，然後由系統執行。為了防禦這種攻擊，應該使用以下幾種方式：

  • 使用安全的命令執行方式：應該使用 subprocess 函式庫的 run 函式來執行命令，同時傳入 shell=False 引數，以避免命令被注入。
  • 驗證使用者輸入：應該驗證使用者輸入的內容，以確保它們不包含惡意命令。
import subprocess

subprocess.run(['ls', '-l'], shell=False)

防禦跨站指令碼攻擊（XSS）

跨站指令碼攻擊（XSS）是指攻擊者將惡意指令碼注入到網頁中，然後由使用者端執行。為了防禦這種攻擊，應該使用以下幾種方式：

  • 驗證使用者輸入：應該驗證使用者輸入的內容，以確保它們不包含惡意指令碼。
  • 使用安全的輸出方式：應該使用安全的輸出方式，例如 html.escape() 函式來輸出使用者輸入的內容。
import html

user_input = '<script>alert("XSS")</script>'
output = html.escape(user_input)
print(output)

防禦跨站請求偽造攻擊（CSRF）

跨站請求偽造攻擊（CSRF）是指攻擊者偽造使用者請求，然後由使用者端執行。為了防禦這種攻擊，應該使用以下幾種方式：

  • 驗證請求來源：應該驗證請求來源，以確保它們是合法的。
  • 使用安全的請求方式：應該使用安全的請求方式，例如 POST 方法來傳送請求。
from flask import request

@app.route('/example', methods=['POST'])
def example():
    if request.method == 'POST':
        # 驗證請求來源
        if request.referrer == 'https://example.com':
            # 處理請求
            pass
        else:
            # 拒絕請求
            pass
    else:
        # 拒絕請求
        pass

檔案系統授權控制

在檔案系統中，授權控制是一個非常重要的議題。不同的使用者和群組可能具有不同的存取許可權，包括讀取、寫入和執行。Python 提供了多種方式來控制檔案系統的授權。

檔案系統中級別的授權

在 UNIX-like 系統中，每個檔案和目錄都具有三種類別的授權：使用者、群組和其他。每個類別都定義了三種授權：讀取、寫入和執行。使用者和群組類別適用於檔案的所有者和群組成員，而其他類別則適用於所有其他使用者。

使用 Python 控制檔案系統授權

Python 提供了多種函式來控制檔案系統的授權，包括 os 和 stat 模組。這些函式可以用來設定和檢查檔案的授權。

os 模組

os 模組提供了多種函式來控制檔案系統的授權，包括 os.chmod()、os.chown() 和 os.chgrp()。這些函式可以用來設定檔案的授權和所有者。

stat 模組

stat 模組提供了多種函式來檢查檔案的狀態，包括 stat.S_IRUSR、stat.S_IWUSR 和 stat.S_IXUSR。這些函式可以用來檢查檔案的讀取、寫入和執行授權。

範例

以下是使用 Python 控制檔案系統授權的範例：

import os
import stat

# 設定檔案的授權
os.chmod('example.txt', stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)

# 檢查檔案的授權
mode = os.stat('example.txt').st_mode
if mode & stat.S_IRUSR:
    print("使用者具有讀取授權")
if mode & stat.S_IWUSR:
    print("使用者具有寫入授權")
if mode & stat.S_IXUSR:
    print("使用者具有執行授權")

在這個範例中，我們使用 os.chmod() 函式來設定檔案的授權，並使用 stat 模組來檢查檔案的狀態。

變更檔案許可權和所有權

在 Python 中，os 模組提供了多個函式來修改檔案系統的中繼資料，例如變更檔案許可權和所有權。這些函式允許 Python 程式直接與作業系統互動，而不需要呼叫外部程式。

變更檔案許可權

os.chmod() 函式用於變更檔案的許可權。它需要一個檔案路徑和至少一個許可權值作為引數。每個許可權值都定義為 stat 模組中的常數（見表 12.2）。

許可權所有者群組其他
讀取S_IRUSRS_IRGRPS_IROTH
寫入S_IWUSRS_IWGRPS_IWOTH
執行S_IXUSRS_IXGRPS_IXOTH

以下範例示範如何使用 os.chmod()：

import os
import stat

# 給所有者讀取許可權並取消其他所有許可權
os.chmod(path_to_file, stat.S_IRUSR)

# 給群組讀取許可權並取消其他所有許可權
os.chmod(path_to_file, stat.S_IRGRP)

注意，每次呼叫 os.chmod() 都會覆寫之前的許可權設定，而不是修改它們。

給多個使用者群組授予許可權

如果需要給多個使用者群組授予許可權，可以使用位元運運算元 (|) 將多個許可權值合併：

os.chmod(path_to_file, stat.S_IRUSR | stat.S_IRGRP)

這個範例給所有者和群組讀取許可權。

變更檔案所有權

os.chown() 函式用於變更檔案的所有者和群組。它需要一個檔案路徑、使用者 ID 和群組 ID 作為引數。如果將 -1 作為使用者 ID 或群組 ID 傳遞，則相應的 ID 將保持不變。

以下範例示範如何變更檔案的所有者和群組：

os.chown(path_to_file, 42, -1)

這個範例變更檔案的所有者為 ID 42，並保持群組 ID 不變。

讀取檔案中繼資料

os.stat() 函式傳回檔案或目錄的中繼資料，包括使用者 ID 和群組 ID。然而，在 Windows 系統中，這些 ID 始終為 0。

以下範例示範如何讀取檔案的中繼資料：

import os

path = './alice/alice/settings.py'
stat = os.stat(path)

print(stat.st_uid)  # 使用者 ID
print(stat.st_gid)  # 群組 ID

這個範例讀取檔案的中繼資料並印出使用者 ID 和群組 ID。

圖表翻譯：

  flowchart TD
    A[開始] --> B[變更檔案許可權]
    B --> C[使用 os.chmod()]
    C --> D[給多個使用者群組授予許可權]
    D --> E[使用位元運運算元]
    E --> F[變更檔案所有權]
    F --> G[使用 os.chown()]
    G --> H[讀取檔案中繼資料]
    H --> I[使用 os.stat()]
    I --> J[結束]

這個流程圖示範瞭如何變更檔案許可權和所有權，以及如何讀取檔案中繼資料。

12.2 執行外部可執行檔案

在某些情況下，您可能需要從 Python 執行另一個程式，例如使用不同語言編寫的程式或使用 Python 中不存在的功能。Python 提供了多種方法來執行外部可執行檔案，但有些方法可能存在風險。在本文中，我們將探討幾種工具來識別、防止和最小化這些風險。

12.2.1 使用內部 API 解決問題

在執行外部程式之前，請問自己是否真的需要這樣做。通常，Python 內部已經有解決方案可以處理大多數常見的任務。例如，下面的程式碼示範如何使用 os.remove() 刪除檔案，而不需要使用 os.system()：

file_name = input('選擇要刪除的檔案：')
os.remove(file_name)

這種方法比使用 os.system() 更安全，因為它只執行單一操作，不會接受命令列輸入，因此不會受到命令注入攻擊的影響。此外，os.remove() 不會使用 shell，因此也不會受到 shell 注入攻擊的影響。

Python 中有許多其他函式可以取代外部程式的功能，例如 os.chmod()、os.chown() 等。這些函式可以更安全地執行檔案操作，而不需要依賴外部程式。

12.2.2 使用 subprocess 模組

如果您確實需要執行外部程式，Python 的 subprocess 模組提供了一種更安全的方法。這個模組允許您執行外部程式，並捕捉其輸出和錯誤訊息。

import subprocess

file_name = input('選擇要刪除的檔案：')
subprocess.run(['rm', file_name])

這種方法比使用 os.system() 更安全，因為它不會接受命令列輸入，因此不會受到命令注入攻擊的影響。此外，subprocess 模組提供了更多控制權，允許您指定要執行的程式和引數。

12.2.3 防止命令注入攻擊

當您執行外部程式時，必須小心避免命令注入攻擊。這種攻擊發生在攻擊者注入惡意命令到您的程式中，然後由您的程式執行。

import subprocess

file_name = input('選擇要刪除的檔案：')
subprocess.run(['rm', file_name])  # 不安全！

在這個例子中，如果攻擊者輸入 ; rm -rf /，您的程式將會刪除整個檔案系統。

為了防止這種攻擊，您應該使用 subprocess 模組的 args 引數，指定要執行的程式和引數。

import subprocess

file_name = input('選擇要刪除的檔案：')
subprocess.run(['rm', '-f', file_name])  # 安全！

在這個例子中，即使攻擊者輸入 ; rm -rf /，您的程式也只會刪除指定的檔案，而不會受到命令注入攻擊的影響。

使用Python進行系統操作

Python提供了多種方式來與作業系統進行互動，包括檔案操作、目錄操作、網路操作等。以下是幾個常用的Python模組和函式：

檔案操作

  • os.remove('檔案名稱')：刪除檔案
  • os.mkdir('目錄名稱')：建立新目錄
  • os.listdir()：傳回目錄內容的列表
  • os.getcwd()：傳回目前的工作目錄

網路操作

  • socket.gethostname()：傳回主機名稱

安全性考量

在使用Python進行系統操作時，需要注意安全性問題。例如，使用os.remove()刪除檔案時，需要確保檔案存在且可以刪除。另外，使用socket.gethostname()時，需要注意主機名稱的安全性。

替代方案

如果Python沒有提供必要的安全功能，可能需要使用第三方函式庫。以下是一些常用的第三方函式庫：

  • requests：用於HTTP請求
  • cryptography：用於加密和解密
  • ping3：用於ping主機
  • nslookup：用於DNS查詢
  • paramiko：用於SSH連線

範例程式碼

import os
import socket

# 刪除檔案
os.remove('example.txt')

# 建立新目錄
os.mkdir('new_dir')

# 傳回目錄內容的列表
print(os.listdir())

# 傳回目前的工作目錄
print(os.getcwd())

# 傳回主機名稱
print(socket.gethostname())

使用 GitPython 和 subprocess 模組進行 Git Repository 管理和外部命令執行

GitPython

GitPython 是一個 Python 的 Git Repository 管理函式庫，提供了 Git 的功能。以下是使用 GitPython 進行 Git Repository 管理的範例：

from git import Repo

# 建立一個新的 Git Repository
repo = Repo.init('path/to/repo')

# 進行 commit
repo.index.add(['file1.txt', 'file2.txt'])
repo.index.commit('Initial commit')

subprocess 模組

subprocess 模組是 Python 的一個內建模組，提供了執行外部命令的功能。以下是使用 subprocess 模組進行外部命令執行的範例：

import subprocess

# 執行一個外部命令
completed_process = subprocess.run(['ruby', 'list_domains.rb', 'charlie'], capture_output=True, check=True)

# 取得命令的輸出和傳回碼
print(completed_process.stdout)
print(completed_process.returncode)

安全性考量

在使用 subprocess 模組時，需要考慮安全性問題。以下是幾個安全性考量：

  • 命令注入攻擊：如果外部命令中包含使用者輸入的資料，可能會發生命令注入攻擊。為了避免這種攻擊，應該使用 subprocess 模組的 run 函式，並將命令作為一個列表傳遞。
  • Shell 注入攻擊：如果外部命令中包含 Shell 特殊字元，可能會發生 Shell 注入攻擊。為了避免這種攻擊，應該使用 subprocess 模組的 run 函式，並將 shell 引數設為 False。

內容解密：

在上述範例中，我們使用了 subprocess 模組的 run 函式來執行外部命令。這個函式會傳回一個 CompletedProcess 物件，包含了命令的輸出和傳回碼。

completed_process = subprocess.run(['ruby', 'list_domains.rb', 'charlie'], capture_output=True, check=True)

這裡的 capture_output=True 引數表示我們想要捕捉命令的輸出，而 check=True 引數表示如果命令傳回非零值，我們想要引發一個異常。

圖表翻譯：

以下是 subprocess 模組的工作流程圖：

  flowchart TD
    A[開始] --> B[建立 subprocess 物件]
    B --> C[設定命令和引數]
    C --> D[執行命令]
    D --> E[捕捉輸出和傳回碼]
    E --> F[結束]

這個圖表顯示了 subprocess 模組的工作流程，從建立 subprocess 物件到執行命令和捕捉輸出和傳回碼。

使用Pipenv進行Python套件管理的安全性

在Python開發中，套件管理是一個非常重要的環節。Pipenv是一個流行的套件管理工具，它可以幫助開發者輕鬆地管理套件依賴關係。然而，在使用Pipenv時，還需要注意一些安全性問題。

Pipenv的安全性優勢

Pipenv有一些安全性優勢，包括：

  • 自動檢查套件完整性：Pipenv可以自動檢查套件的完整性，確保套件沒有被篡改。
  • 使用雜湊值驗證套件：Pipenv使用雜湊值驗證套件，確保套件的正確性。
  • 支援安全的套件更新：Pipenv支援安全的套件更新，確保更新的套件是安全的。

如何使用Pipenv進行安全的套件管理

要使用Pipenv進行安全的套件管理，需要注意以下幾點：

  1. 使用Pipenv.lock檔案：Pipenv.lock檔案是用於記錄套件依賴關係的檔案。應該定期更新Pipenv.lock檔案，以確保套件依賴關係是最新的。
  2. 檢查套件完整性：在安裝套件之前，應該檢查套件的完整性，以確保套件沒有被篡改。
  3. 使用雜湊值驗證套件：在安裝套件之前，應該使用雜湊值驗證套件，以確保套件的正確性。
  4. 支援安全的套件更新：應該定期更新套件，以確保套件是最新的和安全的。
內容解密：

在上述內容中，我們討論瞭如何使用Pipenv進行安全的套件管理。首先，我們介紹了Pipenv的安全性優勢，包括自動檢查套件完整性、使用雜湊值驗證套件和支援安全的套件更新。然後，我們討論瞭如何使用Pipenv進行安全的套件管理，包括使用Pipenv.lock檔案、檢查套件完整性、使用雜湊值驗證套件和支援安全的套件更新。最後，我們總結了Pipenv的優勢和如何使用它進行安全的套件管理。

  flowchart TD
    A[開始] --> B[安裝Pipenv]
    B --> C[建立Pipenv.lock檔案]
    C --> D[安裝套件]
    D --> E[檢查套件完整性]
    E --> F[使用雜湊值驗證套件]
    F --> G[支援安全的套件更新]
    G --> H[完成]

圖表翻譯：

上述圖表展示瞭如何使用Pipenv進行安全的套件管理。首先，安裝Pipenv，然後建立Pipenv.lock檔案。接下來，安裝套件，並檢查套件完整性。然後，使用雜湊值驗證套件，並支援安全的套件更新。最後，完成了安全的套件管理。

SHA-256與安全性

SHA-256是一種廣泛使用的加密雜湊函式，能夠確保資料的完整性和真實性。在軟體開發中，SHA-256常被用於驗證軟體包的完整性，防止惡意程式碼的注入。

SHA-256的工作原理

SHA-256透過計算輸入資料的雜湊值來確保其完整性。當資料被修改時，其雜湊值也會隨之改變。這使得我們可以輕易地檢測出資料是否被篡改過。

Pipenv與SHA-256

Pipenv是一種Python的包管理工具，它使用SHA-256來驗證包的完整性。當我們安裝一個包時，Pipenv會計算包的雜湊值，並將其與包檔案中的雜湊值進行比較。如果兩個雜湊值不匹配，Pipenv會報錯，提示包可能被篡改過。

YAML與安全性

YAML是一種常用的資料序列化格式，但它也存在安全風險。當我們使用YAML來序列化和反序列化資料時，我們需要注意可能的安全問題。例如，YAML的反序列化過程中可能會執行任意程式碼，這使得攻擊者可以注入惡意程式碼。

PyYAML與安全性

PyYAML是一種Python的YAML解析函式庫，它提供了多種方式來解析YAML資料。然而，PyYAML的解析過程中也存在安全風險。例如，PyYAML的BaseLoader可以用來執行任意程式碼，這使得攻擊者可以注入惡意程式碼。

安全解析YAML

為了避免YAML的安全風險，我們可以使用PyYAML的SafeLoader來解析YAML資料。SafeLoader只允許解析簡單的Python物件，例如字串和列表，這使得攻擊者無法注入惡意程式碼。

import yaml

document = """
title: Full Stack Python Security
characters:
  - Alice
  - Bob
  - Charlie
  - Eve
  - Mallory
"""

book = yaml.load(document, Loader=yaml.SafeLoader)

print(book['title'])
print(book['characters'])

XML實體擴充套件攻擊

XML實體擴充套件是一種功能，允許使用者在XML檔案中定義和命名任意資料。這些實體可以被參照到XML檔案中，以便在解析時將其替換為實際的資料。然而，這種功能也可能被用來進行攻擊。

XML實體擴充套件攻擊原理

攻擊者可以建立一個包含多個實體參照的XML檔案，每個實體參照都指向同一個實體。當XML解析器解析這個檔案時，它會將每個實體參照替換為實際的實體資料。這樣就會導致XML檔案中出現大量的重覆資料，從而導致系統資源耗盡。

Python中XML實體擴充套件攻擊示例

以下是Python中使用xml.etree.ElementTree模組進行XML實體擴充套件攻擊的示例：

from xml.etree.ElementTree import fromstring

xml = """
<!DOCTYPE example [
    <!ENTITY a "Alice">
]>
<root>&a;&a;</root>
"""

root = fromstring(xml)
print(root.text)  # Output: AliceAlice

在這個示例中，我們定義了一個包含一個實體參照的XML檔案。當我們使用fromstring()函式解析這個檔案時，它會將實體參照替換為實際的實體資料。

防禦XML實體擴充套件攻擊

為了防禦XML實體擴充套件攻擊，可以使用以下方法：

  1. 限制XML檔案大小：限制XML檔案的大小，可以防止攻擊者建立過大的XML檔案。
  2. 停用實體擴充套件：停用XML實體擴充套件功能，可以防止攻擊者使用這種功能進行攻擊。
  3. 使用安全的XML解析器：使用安全的XML解析器，可以防止攻擊者利用解析器的漏洞進行攻擊。

XML實體攻擊：瞭解XML炸彈和億笑攻擊

XML實體攻擊是一種利用XML檔案中實體參考機制的安全漏洞，攻擊者可以透過精心設計的XML檔案來實作拒絕服務（DoS）攻擊甚至是程式碼執行。這類別攻擊包括XML炸彈（Quadratic Blowup）和億笑攻擊（Billion Laughs Attack），兩者都利用XML檔案中的實體參考機制來達到攻擊目的。

XML炸彈（Quadratic Blowup）

XML炸彈是一種透過建立一個包含多個實體參考的XML檔案來實作的DoS攻擊。當XML解析器嘗試解析這個檔案時，它會不斷地展開實體參考，導致系統資源耗盡，最終導致系統當機。

以下是一個簡單的XML炸彈示例：

<!DOCTYPE bomb [
  <!ENTITY e "a loooooooooooooooooooooooooong entity...">
]>

<bomb>&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;</bomb>

在這個示例中，實體e被定義為一個長字串，然後在bomb元素中多次參照。當XML解析器嘗試解析這個檔案時，它會不斷地展開實體參考，導致系統資源耗盡。

億笑攻擊（Billion Laughs Attack）

億笑攻擊是一種更為複雜的XML實體攻擊，透過建立一個包含多級實體參考的XML檔案來實作。這種攻擊可以導致系統資源耗盡，甚至是程式碼執行。

以下是一個簡單的億笑攻擊示例：

<!DOCTYPE bomb [
  <!ENTITY a "lol">
  <!ENTITY b "&a;&a;&a;&a;&a;&a;&a;&a;&a;&a;">
  <!ENTITY c "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
  <!ENTITY d "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">

]>

<bomb>&d;</bomb>

在這個示例中，實體a被定義為一個簡單的字串，然後在實體b中多次參照。實體b再次在實體c中多次參照，依此類別推。當XML解析器嘗試解析這個檔案時，它會不斷地展開實體參考，導致系統資源耗盡。

防禦措施

為了防禦XML實體攻擊，可以採取以下措施：

  1. 驗證輸入: 驗證所有輸入的XML檔案，以確保它們不包含惡意的實體參考。
  2. 限制實體參考: 限制XML檔案中實體參考的數量和深度，以防止系統資源耗盡。
  3. 使用安全的XML解析器: 使用安全的XML解析器，例如defusedxml，它可以檢測和防止XML實體攻擊。
  4. 監控系統資源: 監控系統資源，例如記憶體和CPU使用率，以快速發現和回應潛在的DoS攻擊。

透過採取這些措施，可以有效地防禦XML實體攻擊，保護系統免受DoS攻擊和程式碼執行的威脅。

隨著軟體系統複雜度的提升，安全性議題已成為不容忽視的關鍵環節。本文深入探討了Python程式碼中，關於檔案系統授權、命令注入、跨站指令碼（XSS）、跨站請求偽造（CSRF）以及XML實體擴充套件攻擊等多種安全風險，並分析了其成因、潛在危害及防禦策略。技術限制深析顯示，單純依靠程式碼層面的防禦並不足以完全抵禦複雜多變的攻擊手段。整合價值分析指出，將程式碼安全審查、自動化安全測試、持續安全監控等多種安全機制整合至軟體開發生命週期，才能構建更全面的安全防護體系。風險與機會並重，雖然安全威脅日益嚴峻，但也催生了更先進的安全技術和解決方案。玄貓認為，開發者應持續提升安全意識，積極學習和應用最佳安全實踐，才能在保障系統安全的同時，持續釋放技術創新的價值。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。