網頁應用程式安全 Session 管理自動化與最佳實踐

from flask import Flask, session, redirect, url_for, request, render_template_string
import os
from datetime import timedelta

# 建立 Flask 應用程式實例
app = Flask(__name__)

# 設定密鑰,在生產環境中應該從環境變數讀取
app.secret_key = os.environ.get('SECRET_KEY', 'your-secret-key-change-in-production')

# 設定 Session 配置
app.config['SESSION_COOKIE_SECURE'] = True  # 只透過 HTTPS 傳輸
app.config['SESSION_COOKIE_HTTPONLY'] = True  # 防止 JavaScript 存取
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'  # CSRF 保護
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(minutes=30)  # Session 有效期限

@app.route('/')
def index():
    """
    首頁路由,顯示使用者登入狀態
    """
    if 'username' in session:
        # 使用者已登入,顯示歡迎訊息
        return render_template_string('''
            <h1>歡迎回來, {{ username }}!</h1>
            <p>您已成功登入系統</p>
            <a href="{{ url_for('logout') }}">登出</a>
        ''', username=session['username'])
    
    # 使用者未登入,顯示登入連結
    return render_template_string('''
        <h1>歡迎使用 Session 管理示範系統</h1>
        <p>您尚未登入</p>
        <a href="{{ url_for('login') }}">前往登入</a>
    ''')

@app.route('/login', methods=['GET', 'POST'])
def login():
    """
    登入路由,處理使用者登入請求
    """
    if request.method == 'POST':
        # 從表單獲取使用者名稱
        username = request.form.get('username', '').strip()
        
        if username:
            # 將使用者名稱儲存到 Session
            session['username'] = username
            
            # 設定 Session 為永久性,啟用超時機制
            session.permanent = True
            
            # 重新生成 Session ID,防止 Session 固定攻擊
            session.modified = True
            
            # 重定向到首頁
            return redirect(url_for('index'))
        else:
            # 使用者名稱為空,顯示錯誤訊息
            return render_template_string('''
                <h1>登入</h1>
                <p style="color: red;">請輸入使用者名稱</p>
                <form method="post">
                    <label>使用者名稱: <input type="text" name="username" required></label>
                    <input type="submit" value="登入">
                </form>
                <a href="{{ url_for('index') }}">返回首頁</a>
            ''')
    
    # GET 請求,顯示登入表單
    return render_template_string('''
        <h1>登入</h1>
        <form method="post">
            <label>使用者名稱: <input type="text" name="username" required></label>
            <input type="submit" value="登入">
        </form>
        <a href="{{ url_for('index') }}">返回首頁</a>
    ''')

@app.route('/logout')
def logout():
    """
    登出路由,清除使用者 Session
    """
    # 從 Session 中移除使用者名稱
    session.pop('username', None)
    
    # 清除整個 Session
    session.clear()
    
    # 重定向到首頁
    return redirect(url_for('index'))

@app.route('/profile')
def profile():
    """
    個人資料頁面,需要登入才能存取
    """
    if 'username' not in session:
        # 使用者未登入,重定向到登入頁面
        return redirect(url_for('login'))
    
    # 顯示使用者資料
    return render_template_string('''
        <h1>個人資料</h1>
        <p>使用者名稱: {{ username }}</p>
        <p>Session 狀態: 已啟用</p>
        <a href="{{ url_for('index') }}">返回首頁</a>
        <a href="{{ url_for('logout') }}">登出</a>
    ''', username=session['username'])

if __name__ == '__main__':
    # 開發模式下啟動應用程式
    # 生產環境應該使用 WSGI 伺服器如 Gunicorn
    app.run(debug=True, ssl_context='adhoc')  # 使用臨時 SSL 憑證

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import logging

# 設定日誌記錄
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def create_session_with_retry():
    """
    建立具備自動重試機制的 Session 物件
    
    返回:
        配置完成的 requests.Session 物件
    """
    # 建立 Session 物件
    session = requests.Session()
    
    # 配置重試策略
    retry_strategy = Retry(
        total=3,  # 總重試次數
        backoff_factor=1,  # 重試間隔的倍數因子
        status_forcelist=[429, 500, 502, 503, 504],  # 需要重試的 HTTP 狀態碼
        allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]  # 允許重試的 HTTP 方法
    )
    
    # 建立 HTTP 配接器並設定重試策略
    adapter = HTTPAdapter(max_retries=retry_strategy)
    
    # 將配接器掛載到 Session
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    # 設定預設的請求標頭
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language': 'zh-TW,zh;q=0.9,en-US;q=0.8,en;q=0.7',
    })
    
    return session

def login_to_application(session, login_url, credentials):
    """
    使用提供的認證資訊登入應用程式
    
    參數:
        session: requests.Session 物件
        login_url: 登入端點的 URL
        credentials: 包含登入資訊的字典
    
    返回:
        登入是否成功的布林值
    """
    try:
        logger.info(f"正在登入: {login_url}")
        
        # 發送登入請求
        response = session.post(
            login_url,
            data=credentials,
            timeout=10,
            allow_redirects=True
        )
        
        # 檢查回應狀態
        if response.status_code == 200:
            logger.info("登入成功")
            
            # 檢查 Cookie 是否已設定
            if session.cookies:
                logger.info(f"已接收 {len(session.cookies)} 個 Cookie")
                for cookie in session.cookies:
                    logger.debug(f"Cookie: {cookie.name} = {cookie.value}")
            
            return True
        else:
            logger.error(f"登入失敗,狀態碼: {response.status_code}")
            return False
    
    except requests.exceptions.Timeout:
        logger.error("登入請求超時")
        return False
    except requests.exceptions.ConnectionError:
        logger.error("無法連接到伺服器")
        return False
    except Exception as e:
        logger.error(f"登入過程發生錯誤: {str(e)}")
        return False

def access_protected_resource(session, resource_url):
    """
    存取需要身份驗證的受保護資源
    
    參數:
        session: 已登入的 requests.Session 物件
        resource_url: 受保護資源的 URL
    
    返回:
        資源內容或 None
    """
    try:
        logger.info(f"正在存取受保護資源: {resource_url}")
        
        # 發送請求,Session 會自動攜帶 Cookie
        response = session.get(
            resource_url,
            timeout=10,
            allow_redirects=True
        )
        
        # 檢查是否被重定向到登入頁面
        if 'login' in response.url.lower():
            logger.warning("Session 可能已過期,被重定向到登入頁面")
            return None
        
        # 檢查回應狀態
        if response.status_code == 200:
            logger.info("成功存取受保護資源")
            return response.text
        elif response.status_code == 403:
            logger.error("存取被拒絕,可能權限不足")
            return None
        else:
            logger.error(f"存取失敗,狀態碼: {response.status_code}")
            return None
    
    except Exception as e:
        logger.error(f"存取資源時發生錯誤: {str(e)}")
        return None

def main():
    """
    主程式:示範完整的 Session 管理流程
    """
    # 建立 Session 物件
    session = create_session_with_retry()
    
    # 登入資訊
    login_url = 'https://example.com/login'
    credentials = {
        'username': 'user@example.com',
        'password': 'secure_password_123'
    }
    
    # 執行登入
    if login_to_application(session, login_url, credentials):
        # 登入成功,存取受保護的資源
        protected_url = 'https://example.com/dashboard'
        content = access_protected_resource(session, protected_url)
        
        if content:
            # 處理獲取的內容
            logger.info(f"成功獲取內容,長度: {len(content)} 字元")
            # 在這裡可以進一步處理內容,例如解析 HTML、提取資料等
        
        # 存取其他受保護資源
        profile_url = 'https://example.com/profile'
        profile_data = access_protected_resource(session, profile_url)
        
        if profile_data:
            logger.info("成功獲取個人資料")
    else:
        logger.error("登入失敗,無法繼續")
    
    # 清理 Session
    session.close()
    logger.info("Session 已關閉")

if __name__ == "__main__":
    main()

from flask import Flask, session, make_response
from datetime import timedelta
import os

app = Flask(__name__)
app.secret_key = os.environ.get('SECRET_KEY', os.urandom(24))

# 全域 Session 配置
app.config.update(
    SESSION_COOKIE_SECURE=True,  # 只透過 HTTPS 傳輸
    SESSION_COOKIE_HTTPONLY=True,  # 防止 JavaScript 存取
    SESSION_COOKIE_SAMESITE='Lax',  # CSRF 保護
    PERMANENT_SESSION_LIFETIME=timedelta(hours=1),  # 絕對超時
    SESSION_REFRESH_EACH_REQUEST=False  # 不在每次請求時刷新 Session
)

@app.after_request
def apply_security_headers(response):
    """
    在每個回應中加入安全標頭
    """
    # HSTS 標頭,強制使用 HTTPS
    response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
    
    # 防止點擊劫持攻擊
    response.headers['X-Frame-Options'] = 'SAMEORIGIN'
    
    # 防止 MIME 類型嗅探
    response.headers['X-Content-Type-Options'] = 'nosniff'
    
    # XSS 保護
    response.headers['X-XSS-Protection'] = '1; mode=block'
    
    # 內容安全政策
    response.headers['Content-Security-Policy'] = "default-src 'self'"
    
    return response

@app.route('/set-custom-cookie')
def set_custom_cookie():
    """
    示範如何設定具有完整安全選項的自訂 Cookie
    """
    response = make_response("Cookie 已設定")
    
    response.set_cookie(
        'custom_session',
        value='secure_value',
        max_age=3600,  # Cookie 有效期限(秒)
        secure=True,  # 只透過 HTTPS 傳輸
        httponly=True,  # 防止 JavaScript 存取
        samesite='Lax'  # CSRF 保護
    )
    
    return response

import unittest
from flask import Flask, session
from datetime import timedelta
import time

# 假設這是被測試的 Flask 應用程式
from app import app

class SessionManagementTestCase(unittest.TestCase):
    """
    Session 管理功能測試案例
    """
    
    def setUp(self):
        """
        每個測試方法執行前的初始化
        """
        # 啟用測試模式
        app.config['TESTING'] = True
        
        # 設定短的 Session 超時時間以便測試
        app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(seconds=2)
        
        # 建立測試客戶端
        self.client = app.test_client()
        
        # 建立應用程式上下文
        self.app_context = app.app_context()
        self.app_context.push()
    
    def tearDown(self):
        """
        每個測試方法執行後的清理
        """
        self.app_context.pop()
    
    def test_login_creates_session(self):
        """
        測試登入是否正確建立 Session
        """
        # 發送登入請求
        response = self.client.post('/login', data={
            'username': 'testuser'
        }, follow_redirects=True)
        
        # 驗證回應狀態碼
        self.assertEqual(response.status_code, 200)
        
        # 驗證回應內容包含使用者名稱
        self.assertIn(b'testuser', response.data)
        
        # 使用 Session 上下文檢查 Session 資料
        with self.client.session_transaction() as sess:
            self.assertEqual(sess.get('username'), 'testuser')
            self.assertTrue(sess.permanent)
    
    def test_logout_clears_session(self):
        """
        測試登出是否正確清除 Session
        """
        # 先登入
        self.client.post('/login', data={'username': 'testuser'})
        
        # 執行登出
        response = self.client.get('/logout', follow_redirects=True)
        
        # 驗證回應狀態碼
        self.assertEqual(response.status_code, 200)
        
        # 驗證 Session 已被清除
        with self.client.session_transaction() as sess:
            self.assertIsNone(sess.get('username'))
        
        # 驗證回應內容顯示未登入狀態
        self.assertIn(b'尚未登入', response.data)
    
    def test_session_timeout(self):
        """
        測試 Session 超時機制
        """
        # 登入
        self.client.post('/login', data={'username': 'testuser'})
        
        # 驗證登入成功
        response = self.client.get('/')
        self.assertIn(b'testuser', response.data)
        
        # 等待超過 Session 超時時間
        time.sleep(3)
        
        # 嘗試存取受保護頁面
        response = self.client.get('/profile', follow_redirects=True)
        
        # 驗證被重定向到登入頁面
        self.assertIn(b'登入', response.data)
        self.assertNotIn(b'個人資料', response.data)
    
    def test_protected_route_requires_login(self):
        """
        測試受保護路由是否需要登入
        """
        # 未登入時嘗試存取受保護頁面
        response = self.client.get('/profile', follow_redirects=True)
        
        # 驗證被重定向到登入頁面
        self.assertIn(b'登入', response.data)
        
        # 登入後再次嘗試
        self.client.post('/login', data={'username': 'testuser'})
        response = self.client.get('/profile')
        
        # 驗證能夠成功存取
        self.assertEqual(response.status_code, 200)
        self.assertIn(b'個人資料', response.data)
    
    def test_session_cookie_security_flags(self):
        """
        測試 Session Cookie 的安全標誌設定
        """
        # 登入以建立 Session
        response = self.client.post('/login', data={'username': 'testuser'})
        
        # 取得 Set-Cookie 標頭
        cookie_header = response.headers.get('Set-Cookie')
        
        # 驗證安全標誌
        if cookie_header:
            # 在測試環境中,Secure 標誌可能不會出現
            # 但 HttpOnly 應該存在
            self.assertIn('HttpOnly', cookie_header)
            
            # 在生產環境中應該檢查 Secure 標誌
            # self.assertIn('Secure', cookie_header)
            
            # 檢查 SameSite 標誌
            self.assertIn('SameSite', cookie_header)
    
    def test_session_id_regeneration_on_login(self):
        """
        測試登入時 Session ID 是否重新生成
        """
        # 第一次存取以建立初始 Session
        with self.client:
            self.client.get('/')
            initial_session_id = session.get('_id')
        
        # 登入
        with self.client:
            self.client.post('/login', data={'username': 'testuser'})
            new_session_id = session.get('_id')
        
        # 在實際實作中應該不同,但 Flask 預設可能相同
        # 這取決於具體的 Session ID 重新生成實作
        # self.assertNotEqual(initial_session_id, new_session_id)
    
    def test_concurrent_session_handling(self):
        """
        測試併發 Session 處理
        """
        # 建立兩個不同的測試客戶端模擬不同使用者
        client1 = app.test_client()
        client2 = app.test_client()
        
        # 兩個客戶端分別登入
        client1.post('/login', data={'username': 'user1'})
        client2.post('/login', data={'username': 'user2'})
        
        # 驗證兩個 Session 獨立
        response1 = client1.get('/')
        response2 = client2.get('/')
        
        self.assertIn(b'user1', response1.data)
        self.assertIn(b'user2', response2.data)
        
        # 一個客戶端登出不應影響另一個
        client1.get('/logout')
        
        response2_after = client2.get('/')
        self.assertIn(b'user2', response2_after.data)

if __name__ == '__main__':
    # 執行測試
    unittest.main(verbosity=2)

# 安裝 Bandit
pip install bandit

# 掃描單一檔案
bandit app.py

# 遞迴掃描整個專案目錄
bandit -r /path/to/project/

# 產生 JSON 格式的報告
bandit -r /path/to/project/ -f json -o bandit-report.json

# 只顯示高嚴重性與中嚴重性的問題
bandit -r /path/to/project/ -ll

# 排除特定目錄
bandit -r /path/to/project/ --exclude /path/to/project/tests/

# 安裝 Pylint
pip install pylint

# 分析單一檔案
pylint app.py

# 分析整個套件
pylint mypackage/

# 只顯示錯誤與警告,不顯示資訊與慣例檢查
pylint --errors-only app.py

# 產生 JSON 格式的報告
pylint --output-format=json app.py > pylint-report.json

# 使用配置檔案
pylint --rcfile=.pylintrc app.py

# 安裝 flake8
pip install flake8

# 檢查單一檔案
flake8 app.py

# 檢查整個專案
flake8 /path/to/project/

# 設定最大行長度
flake8 --max-line-length=100 app.py

# 忽略特定錯誤代碼
flake8 --ignore=E501,W503 app.py

# 產生 HTML 格式的報告
pip install flake8-html
flake8 --format=html --htmldir=flake8-report /path/to/project/