API安全設計與最佳實踐

– 10 分鐘閱讀

現代應用程式仰賴 API 交換資料，因此 API 安全至關重要。本文從身份驗證和授權開始，探討如何利用 OAuth 2.0 和 API 金鑰保護 API。接著，我們將深入研究根據角色的存取控制（RBAC）和根據屬性的存取控制（ABAC），比較它們的優缺點，並提供 Python 程式碼範例。最後，我們將探討輸入驗證、錯誤處理、日誌記錄和安全驗證等最佳實踐，以建立更安全的 API。這些技術有助於開發人員構建更安全可靠的 API，保護敏感資料並確保應用程式穩定執行。

圖表翻譯

以下是一個使用 Mermaid 語法繪製的圖表，展示了 OAuth 2.0 的工作流程：

  flowchart TD
    A[使用者] -->|請求授權|> B[授權伺服器]
    B -->|傳回授權碼|> A
    A -->|請求token|> C[Token伺服器]
    C -->|傳回token|> A
    A -->|使用token存取資源|> D[資源伺服器]

這個圖表展示了 OAuth 2.0 的工作流程，包括使用者請求授權、授權伺服器傳回授權碼、使用者請求 token、Token 伺服器傳回 token 和使用者使用 token 存取資源等步驟。

使用 OAuth 2.0 和 API 金鑰進行身份驗證

在設計安全的 API 時，身份驗證是一個至關重要的步驟。OAuth 2.0 和 API 金鑰是兩種常見的身份驗證機制。下面，我們將探討如何使用這兩種機制來保護 API。

OAuth 2.0

OAuth 2.0 是一種業界標準的授權框架，允許使用者授權第三方應用程式存取其資源，而無需分享密碼。以下是使用 OAuth 2.0 進行身份驗證的範例：

import jwt

def validate_oauth_token(token, public_key, audience):
    try:
        payload = jwt.decode(token, public_key, audience=audience)
        if 'scope' not in payload or not payload['scope']:
            raise Exception("Required scopes missing in token")
        return payload
    except jwt.ExpiredSignatureError:
        raise Exception("Token expired")
    except jwt.InvalidAudienceError:
        raise Exception("Invalid audience")
    except Exception as e:
        raise Exception("Invalid token: " + str(e))

在這個範例中，我們使用了 PyJWT 函式庫來解碼和驗證 OAuth 2.0 令牌。令牌被解碼並驗證其簽名、audience 和 scope。如果令牌有效，則傳回 payload。

API 金鑰

API 金鑰是一種簡單的身份驗證機制，使用了一個唯一的金鑰來識別使用者。以下是使用 API 金鑰進行身份驗證的範例：

from flask import Flask, request, jsonify

app = Flask(__name__)

VALID_API_KEYS = {"API_KEY_12345", "API_KEY_67890"}

@app.before_request
def authenticate_api_key():
    api_key = request.headers.get("X-API-Key")
    if not api_key or api_key not in VALID_API_KEYS:
        return jsonify({"error": "Unauthorized"}), 401

@app.route('/resource', methods=['GET'])
def get_resource():
    return jsonify({"data": "secured resource"})

if __name__ == '__main__':
    app.run()

在這個範例中，我們使用了 Flask 框架來建立一個 API。API 金鑰被儲存在VALID_API_KEYS集合中。在每個請求之前，authenticate_api_key函式被呼叫來驗證 API 金鑰。如果金鑰有效，則允許請求；否則，傳回 401 錯誤。

比較 OAuth 2.0 和 API 金鑰

OAuth 2.0API 金鑰
安全性高中
複雜性高低
授權支援不支援
過期支援不支援

OAuth 2.0 提供了更高的安全性和授權功能，但也更加複雜。API 金鑰則提供了一種簡單的身份驗證機制，但缺乏授權和過期功能。

API 金鑰驗證與許可權控制

在設計 API 時，安全性是首要考量。API 金鑰驗證是一種常見的安全機制，用於確保只有授權的使用者才能存取 API 端點。透過使用中介軟體（middleware）來實作金鑰驗證，可以使得驗證過程更為透明和集中。

中介軟體式實作

以下是使用 Python 實作的一個簡單中介軟體式金鑰驗證範例：

import requests

# 定義有效金鑰集合
valid_keys = ["key1", "key2", "key3"]

# 定義預請求 hook
def verify_api_key(request):
    api_key = request.headers.get("X-API-KEY")
    if api_key not in valid_keys:
        raise Exception("Invalid API key")
    return request

# 使用中介軟體來驗證金鑰
app = Flask(__name__)
app.before_request(verify_api_key)

這種實作方式可以減少程式碼冗餘，並確保所有端點都經過金鑰驗證。

許可權控制

除了金鑰驗證外，許可權控制也是 API 安全性的重要組成部分。Role-Based Access Control（RBAC）和 Attribute-Based Access Control（ABAC）是兩種常見的許可權控制策略。

RBAC 實作

以下是使用 Python 實作的一個簡單 RBAC 範例：

def require_role(required_role):
    def decorator(func):
        def wrapper(*args, **kwargs):
            request = kwargs.get("request")
            user_roles = getattr(request, "user_roles", [])
            if required_role not in user_roles:
                raise Exception("Insufficient privileges")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@require_role("admin")
def update_resource(request, resource_id, data):
    # 要求更新操作，需要管理員許可權
    perform_update(resource_id, data)

這種實作方式可以根據使用者角色來控制其存取端點的許可權。

Token 驗證和復原

在高規模系統中，Token 驗證和復原是非常重要的。可以使用中央化的 Token 驗證端點或與身份提供者（IdP）整合來確保 Token 的有效性和復原。

Token 驗證範例

以下是使用 Python 實作的一個簡單 Token 驗證範例：

import requests

def introspect_token(token, introspection_url, client_id, client_secret):
    response = requests.post(introspection_url, data={
        "token": token,
        "client_id": client_id,
        "client_secret": client_secret
    })
    if response.status_code!= 200:
        raise Exception("Failed introspection")
    result = response.json()
    if not result.get("active"):
        raise Exception("Token is inactive or revoked")
    return result

這種實作方式可以將 Token 驗證邏輯解除安裝到專門的服務，從而提高整體安全性。

根據屬性存取控制（ABAC）的授權機制

在複雜的授權場景中，根據屬性存取控制（ABAC）提供了一種動態評估使用者屬性和環境因素的方法，實作細粒度的存取控制。與根據角色的存取控制（RBAC）不同，ABAC 不僅僅依靠固定的角色，而是根據使用者的動態屬性和環境因素進行授權決策。

實作 ABAC 的關鍵要素

  1. 政策評估引擎：ABAC 系統需要一個政策評估引擎來處理環境引數、使用者上下文和資源的相關資料。這個引擎負責根據定義的政策規則進行授權決策。
  2. 外部授權伺服器：許多先進的系統與外部授權伺服器整合，後者提供政策評估作為一項服務。這些伺服器可以使用像 Rego 或 XACML 這樣的政策語言進行組態，並維護存取規則與業務邏輯程式碼的獨立性。
  3. 分散式組態：存取政策可以儲存在分散式組態中，或透過一個政策決策點（PDP）進行管理，PDP 接受查詢、評估政策並傳回授權結果。

示例：使用 Python 實作 ABAC 授權

以下是一個簡單的示例，展示如何使用 Python 實作 ABAC 授權：

import requests

def check_authorization(user_id, action, resource):
    # 建立政策輸入資料
    policy_input = {
        "subject": {"id": user_id},
        "action": action,
        "resource": {"id": resource}
    }

    # 向政策決策點傳送請求
    response = requests.post("https://example.com/pdp", json=policy_input)

    # 處理回應
    if response.status_code!= 200:
        raise Exception("授權服務不可用")

    result = response.json()

    if not result.get("allowed", False):
        raise Exception("存取被拒絕")

    return True

def update_resource_with_policy(request, resource_id, data):
    user_id = request.user_id
    check_authorization(user_id, "update", resource_id)
    perform_update(resource_id, data)
    return {"status": "updated"}

組合授權機制

在高度敏感的環境中，建議結合多層授權檢查機制。例如，API 端點可以先驗證 OAuth 令牌，然後進行 API 金鑰檢查，最後呼叫政策引擎驗證資源級別許可。這種深度防禦機制可以降低令牌洩露或組態錯誤的風險。

def composite_auth_middleware(func):
    def wrapper(*args, **kwargs):
        request = kwargs.get('request')

        # 步驟1：驗證Bearer令牌
        token = request.headers.get("Authorization").split(" ")[1]
        token_payload = validate_oauth_token(token, public_key, "api_service")
        request.user_id = token_payload.get("sub")
        request.user_roles = token_payload.get("roles", [])

        # 步驟2：驗證API金鑰（如果需要）
        api_key = request.headers.get("X-API-Key")
        if not api_key or api_key not in VALID_API_KEYS:
            raise Exception("無效的API金鑰")

        # 步驟3：進行額外的ABAC檢查
        check_authorization(request.user_id, "access", "resource")

        return func(*args, **kwargs)

透過這種方式，可以實作一個更為強大和靈活的授權系統，既能夠滿足複雜的業務需求，又能夠確保系統的安全性和可靠性。

安全 API 設計的重要性

在現代網路應用中，API（Application Programming Interface）已成為一個重要的組成部分。然而，API 的安全性卻是一個令人頭痛的問題。一個不安全的 API 可能會導致敏感資料的洩露、身份驗證和授權機制的破壞，甚至是整個系統的當機。

身份驗證和授權機制

一個安全的 API 應該具備強大的身份驗證和授權機制。這可以透過使用複合身份驗證中介軟體（Composite Authentication Middleware）來實作。這種方法可以將多個身份驗證機制結合起來，提供更強大的安全保障。

def composite_auth_middleware(func):
    def wrapper(*args, **kwargs):
        # 進行身份驗證和授權
        return func(*args, **kwargs)
    return wrapper

@composite_auth_middleware
def secured_endpoint(request):
    # 只有透過身份驗證和授權的請求才能存取這個端點
    return {"data": "secured data"}

日誌記錄和稽核

除了身份驗證和授權機制外，日誌記錄和稽核也是 API 安全性的重要組成部分。透過記錄所有的請求和回應，包括身份驗證事件、授權決策和異常情況，可以幫助開發者快速定位和解決安全問題。

import logging

# 設定日誌記錄級別
logging.basicConfig(level=logging.INFO)

def log_request(request):
    # 記錄請求資訊
    logging.info(f"Request: {request.method} {request.path}")

def log_response(response):
    # 記錄回應資訊
    logging.info(f"Response: {response.status_code} {response.reason}")

輸入驗證和錯誤處理

輸入驗證和錯誤處理是 API 安全性的另一個重要方面。透過驗證使用者輸入的資料，可以防止惡意攻擊和資料損壞。同時，錯誤處理機制可以幫助開發者快速定位和解決問題。

from pydantic import BaseModel, Field, ValidationError

class UserInput(BaseModel):
    username: str = Field(..., min_length=3, max_length=30, regex=r"^[a-zA-Z0-9]+$")
    email: str = Field(..., regex=r"^\S+@\S+\.\S+$")
    age: int = Field(..., ge=0, le=150)

def process_user_input(data):
    try:
        validated_data = UserInput(**data)
        return validated_data.dict()
    except ValidationError as ve:
        raise Exception("Invalid input parameters") from ve
圖表翻譯：
  flowchart TD
    A[使用者請求] --> B[身份驗證]
    B --> C[授權]
    C --> D[日誌記錄]
    D --> E[輸入驗證]
    E --> F[錯誤處理]
    F --> G[回應]

這個流程圖展示了 API 請求的處理流程，包括身份驗證、授權、日誌記錄、輸入驗證、錯誤處理和回應。透過這個流程圖，可以清晰地看到 API 安全性的各個組成部分和其之間的關係。

錯誤處理與安全驗證

在 API 設計中，錯誤處理和安全驗證是兩個至關重要的方面。良好的錯誤處理機制可以幫助開發人員快速診斷和修復問題，而安全驗證則可以保護 API 免受惡意攻擊。

結構化錯誤

結構化錯誤可以提供一個統一的 JSON 格式，包含錯誤碼、開發人員訊息和相關上下文，同時避免包含敏感的堆積疊追蹤資訊。這可以透過 Flask 的錯誤處理機制實作，允許集中化錯誤回應。

from flask import Flask, jsonify, request

app = Flask(__name__)

class APIError(Exception):
    def __init__(self, message, status_code, error_code):
        super().__init__(message)
        self.status_code = status_code
        self.error_code = error_code

class ValidationError(APIError):
    def __init__(self, message):
        super().__init__(message, 422, "VALIDATION_ERROR")

class AuthenticationError(APIError):
    def __init__(self, message):
        super().__init__(message, 401, "AUTHENTICATION_ERROR")

@app.errorhandler(APIError)
def handle_api_error(error):
    response = {
        "error": {
            "code": error.error_code,
            "message": str(error)
        }
    }
    return jsonify(response), error.status_code

日誌記錄

日誌記錄在錯誤處理和安全驗證中扮演著重要角色。全面性的日誌記錄可以捕捉到時間戳、輸入引數（為了避免隱私問題進行過濾）、使用者識別符號和錯誤碼等上下文資訊，從而幫助診斷事件和監控可疑活動。

import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s')

try:
    # 程式碼執行
except Exception as e:
    logging.error("錯誤發生", exc_info=True)

時間攻擊和側通道洩漏

在設計驗證例程時，開發人員必須考慮到成功驗證和失敗驗證的執行時間的一致性。例如，密碼雜湊驗證或令牌簽名驗證應該使用恆定時間演算法，以避免可能洩漏有效令牌或金鑰資訊的時間差異。

import hmac

def safe_compare(value_a, value_b):
    return hmac.compare_digest(value_a, value_b)

錯誤訊息和資訊洩漏

錯誤訊息本身也需要被仔細設計，以避免為攻擊者提供任何可利用的線索。例如，錯誤訊息不應確認某些資源的存在或以區分有效和無效輸入的方式驗證格式，從而最小化可能幫助攻擊者進行偵查的資訊洩漏。

自動化測試

最後，將驗證和錯誤處理嵌入到自動化測試管道中，可以系統地生成不規則的輸入並觀察 API 在壓力或意外輸入引數下的行為。這些自動化測試作為早期警告系統，可以幫助開發人員及時發現驗證規則的迴歸或敏感錯誤資訊的意外暴露。

from hypothesis import given, strategies as st

@given(username=st.text(min_size=3, max_size=30), email=st.emails(), age=st.integers(min_value=18, max_value=100))
def test_api_validation(username, email, age):
    # 測試API的驗證行為
    pass

透過這些措施，開發人員可以提高 API 的安全性和可靠性，同時也能夠更好地管理和維護 API 的錯誤處理和安全驗證機制。

保護 API 安全：玄貓的最佳實踐

API 的安全性是現代網路應用中的一個關鍵問題。隨著 API 的普遍使用，攻擊者也開始將目光投向這些 API。因此，開發人員必須採取嚴格的安全措施來保護 API 免受各種攻擊。

輸入驗證和過濾

輸入驗證和過濾是 API 安全的第一道防線。開發人員應該確保所有輸入都經過嚴格的驗證和過濾，以防止惡意程式碼的注入。這可以透過使用白名單機制來實作，只允許已知的安全輸入透過。

def test_valid_user_input(username, email, age):
    user_data = {"username": username, "email": email, "age": age}
    result = process_user_input(user_data)
    assert isinstance(result, dict)

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

XSS 是一種常見的攻擊方式，攻擊者透過注入惡意指令碼來實作任意程式碼執行。為了防止 XSS 攻擊，開發人員應該確保所有輸出都經過適當的編碼和過濾。

import bleach

def sanitize_html(input_html):
    allowed_tags = ['b', 'i', 'u', 'a', 'p']
    allowed_attributes = {'a': ['href', 'title']}
    return bleach.clean(input_html, tags=allowed_tags, attributes=allowed_attributes)

跨站請求偽造（CSRF）防護

CSRF 是一種攻擊方式，攻擊者透過偽造請求來實作任意操作。為了防止 CSRF 攻擊，開發人員應該實作反偽造令牌機制，確保所有敏感操作都經過令牌驗證。

import os
import hmac
import hashlib
from flask import Flask, request, jsonify, make_response

app = Flask(__name__)

def generate_csrf_token():
    # 生成反偽造令牌
    pass

def verify_csrf_token():
    # 驗證反偽造令牌
    csrf_header = request.headers.get('X-CSRF-Token')
    if not csrf_header:
        return make_response(jsonify({"error": "CSRF token validation fail"}), 403)

@app.route('/get-token', methods=['GET'])
def get_token():
    token = generate_csrf_token()
    resp = make_response(jsonify({"csrf_token": token}))
    resp.set_cookie('csrf_token', token, httponly=True, secure=True)
    return resp

@app.route('/update', methods=['POST'])
def update():
    # 驗證反偽造令牌
    verify_csrf_token()
    # 進行更新操作
    pass

保護 API 安全：防止 SQL 注入和實施安全的日誌記錄

在 API 安全中，防止 SQL 注入是一個至關重要的方面。SQL 注入是指攻擊者將惡意的 SQL 程式碼注入到應用程式的查詢中，從而獲得未經授權的存取資料函式庫或執行任意 SQL 命令。為了防止 SQL 注入，開發人員可以採用引數化查詢或預備陳述式，這些方法可以可靠地將程式碼和資料分離。

從技術架構視角來看，構建安全的 API 需要多層級的防禦機制。本文探討了 OAuth 2.0、API 金鑰、ABAC 等授權機制，以及輸入驗證、錯誤處理、日誌記錄等安全措施。透過比較不同方案的優劣，我們發現單一機制並不足以應對複雜的安全挑戰。例如，API 金鑰雖然易於實作，但缺乏授權和過期機制，安全性相對較低。而 OAuth 2.0 雖然安全性高，但實作複雜度也相對較高。技術限制主要體現在平衡安全性和易用性，以及在不同情境下選擇合適的授權和驗證策略。對於追求高安全性的應用，建議採用多因素驗證和 ABAC 等更精細的授權機制。此外，應重視安全日誌記錄和錯誤處理，以便及時發現和應對安全事件。玄貓認為，API 安全是一個持續演進的過程，開發者需要保持警覺，持續更新安全策略，才能有效防禦不斷變化的攻擊手段。未來，零信任安全模型和 AI 驅動的安全分析將成為 API 安全的重要趨勢，值得關注和探索。

玄貓

玄貓

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