資訊安全管理系統 ISMS 建置與 ISO 27001 認證實務：從風險評估到零信任架構的完整指南

# =============================================================================
# risk_assessment.py - 資訊安全風險評估模組
# =============================================================================
# 此模組實作資訊安全風險評估的核心邏輯功能，涵蓋資產管理、威脅識別、
# 脆弱性評估與風險等級計算等完整的風險評估流程
# =============================================================================

# -----------------------------------------------------------------------------
# 匯入必要的 Python 標準函式庫
# -----------------------------------------------------------------------------

# dataclass 裝飾器用於簡化資料容器類別的定義，自動產生 __init__ 等方法
from dataclasses import dataclass, field

# Enum 列舉型別用於定義具有固定選項值的常數集合
from enum import Enum, auto

# typing 模組提供型別提示功能，提升程式碼的可讀性與維護性
from typing import List, Dict, Optional, Tuple

# datetime 模組用於記錄風險評估執行的時間戳記
from datetime import datetime

# json 模組用於支援風險評估結果的序列化儲存與交換
import json

# -----------------------------------------------------------------------------
# 列舉型別定義區塊
# 定義風險評估過程中使用的各種分類選項
# -----------------------------------------------------------------------------

class Likelihood(Enum):
    """
    威脅發生可能性等級列舉

    定義五個可能性等級，從極低到極高，用於評估特定威脅
    在特定時間範圍內實際發生的機率高低
    """
    VERY_LOW = 1    # 極低：事件發生機率極小，幾乎不可能發生
    LOW = 2         # 低：事件發生機率較低，不太可能發生
    MEDIUM = 3      # 中：事件有一定機率發生，需要關注
    HIGH = 4        # 高：事件發生機率較高，很可能會發生
    VERY_HIGH = 5   # 極高：事件幾乎確定會發生，需立即處理

class Impact(Enum):
    """
    資安事件影響程度等級列舉

    定義五個影響程度等級，從可忽略到災難性，用於評估
    資安事件一旦發生對組織造成的損害嚴重程度
    """
    NEGLIGIBLE = 1      # 可忽略：對組織營運幾乎沒有影響
    MINOR = 2           # 輕微：造成輕微不便，可快速恢復
    MODERATE = 3        # 中度：需要投入額外資源處理，有明顯影響
    SIGNIFICANT = 4     # 重大：嚴重影響業務營運，需大量資源復原
    CATASTROPHIC = 5    # 災難性：威脅組織存續，可能造成永久損害

class RiskLevel(Enum):
    """
    風險等級列舉

    根據可能性與影響程度的組合計算得出的整體風險等級，
    用於決定風險處理的優先順序與處理策略
    """
    LOW = auto()        # 低風險：可接受的風險，定期監控即可
    MEDIUM = auto()     # 中風險：需要處理的風險，應排入處理時程
    HIGH = auto()       # 高風險：應優先處理的風險，需儘速採取行動
    CRITICAL = auto()   # 極高風險：必須立即處理的風險，不可延遲

class AssetCategory(Enum):
    """
    資訊資產類別列舉

    定義組織可能擁有的各種資訊資產類型，用於資產清冊
    的分類管理與統計分析
    """
    INFORMATION = auto()    # 資訊資產：文件檔案、資料庫、智慧財產
    SOFTWARE = auto()       # 軟體資產：應用程式、作業系統、開發工具
    HARDWARE = auto()       # 硬體資產：伺服器、網路設備、終端設備
    PERSONNEL = auto()      # 人員資產：具有關鍵技能或知識的人員
    FACILITY = auto()       # 設施資產：機房、辦公室、資料中心
    SERVICE = auto()        # 服務資產：雲端服務、外包服務、網路服務

class TreatmentOption(Enum):
    """
    風險處理選項列舉

    定義組織面對已識別風險時可以選擇的處理策略，
    每種策略有其適用情境與考量因素
    """
    MITIGATE = auto()   # 降低風險：實施控制措施以降低風險的可能性或影響
    TRANSFER = auto()   # 轉移風險：透過保險或委外將風險轉移給第三方
    AVOID = auto()      # 迴避風險：停止或改變導致風險的業務活動
    ACCEPT = auto()     # 接受風險：在充分評估後決定接受風險，不採取行動

# -----------------------------------------------------------------------------
# 資料類別定義區塊
# 使用 dataclass 裝飾器定義風險評估過程中使用的資料結構
# -----------------------------------------------------------------------------

@dataclass
class Asset:
    """
    資訊資產資料類別

    封裝組織資訊資產的各項屬性資訊，包括基本識別資訊、
    分類歸屬、擁有者責任歸屬，以及機密性、完整性、可用性
    三個安全面向的價值評估分數

    屬性說明:
        asset_id: 資產唯一識別碼，用於系統內部識別
        name: 資產名稱，人類可讀的識別名稱
        category: 資產類別，使用 AssetCategory 列舉值
        owner: 資產擁有者，負責資產安全的責任人
        description: 資產描述，說明資產的用途與內容
        confidentiality_value: 機密性價值評分（1-5）
        integrity_value: 完整性價值評分（1-5）
        availability_value: 可用性價值評分（1-5）
        location: 資產存放位置
    """
    asset_id: str                   # 資產唯一識別碼
    name: str                       # 資產名稱
    category: AssetCategory         # 資產類別
    owner: str                      # 資產擁有者
    description: str                # 資產描述
    confidentiality_value: int      # 機密性價值（1-5）
    integrity_value: int            # 完整性價值（1-5）
    availability_value: int         # 可用性價值（1-5）
    location: str = ""              # 資產位置（選填）

    def calculate_asset_value(self) -> int:
        """
        計算資產整體價值分數

        採用取最大值的方式計算資產整體價值，這種方法確保
        在任何一個安全面向具有高價值的資產都能獲得適當的
        保護優先順序

        回傳:
            int: 資產價值分數，範圍 1-5
        """
        # 資產整體價值取機密性、完整性、可用性三者的最大值
        # 這確保高價值資產在任一面向都能獲得適當的保護
        return max(
            self.confidentiality_value,
            self.integrity_value,
            self.availability_value
        )

@dataclass
class Threat:
    """
    威脅資料類別

    封裝可能對資訊資產造成傷害的威脅相關資訊，包括
    威脅的識別資訊、描述說明、來源類型與基礎發生可能性

    屬性說明:
        threat_id: 威脅唯一識別碼
        name: 威脅名稱
        description: 威脅詳細描述
        source: 威脅來源類型（自然災害、人為意外、惡意攻擊）
        base_likelihood: 威脅的基礎發生可能性
        affected_properties: 威脅影響的安全屬性清單（C/I/A）
    """
    threat_id: str                              # 威脅唯一識別碼
    name: str                                   # 威脅名稱
    description: str                            # 威脅描述
    source: str                                 # 威脅來源
    base_likelihood: Likelihood                 # 基礎發生可能性
    affected_properties: List[str] = field(default_factory=list)  # 影響的安全屬性

@dataclass
class Vulnerability:
    """
    脆弱性資料類別

    封裝可能被威脅利用的弱點相關資訊，包括脆弱性的
    識別資訊、描述說明、嚴重程度評分，以及受影響的
    資產清單與現有的控制措施

    屬性說明:
        vulnerability_id: 脆弱性唯一識別碼
        name: 脆弱性名稱
        description: 脆弱性詳細描述
        severity: 嚴重程度評分（1-5）
        affected_assets: 受此脆弱性影響的資產識別碼清單
        existing_controls: 已實施的控制措施清單
    """
    vulnerability_id: str                       # 脆弱性唯一識別碼
    name: str                                   # 脆弱性名稱
    description: str                            # 脆弱性描述
    severity: int                               # 嚴重程度（1-5）
    affected_assets: List[str] = field(default_factory=list)      # 受影響資產
    existing_controls: List[str] = field(default_factory=list)    # 現有控制措施

@dataclass
class RiskScenario:
    """
    風險情境資料類別

    封裝特定風險情境的完整評估資訊，結合資產、威脅與
    脆弱性形成完整的風險描述，包含風險評估結果與處理決策

    屬性說明:
        scenario_id: 風險情境唯一識別碼
        asset: 相關的資產物件
        threat: 相關的威脅物件
        vulnerability: 相關的脆弱性物件
        likelihood: 評估後的發生可能性
        impact: 評估後的影響程度
        risk_level: 計算得出的風險等級
        treatment: 選擇的風險處理選項
        treatment_plan: 風險處理計畫說明
        residual_risk_level: 處理後的殘餘風險等級
    """
    scenario_id: str                            # 情境唯一識別碼
    asset: Asset                                # 相關資產
    threat: Threat                              # 相關威脅
    vulnerability: Vulnerability                # 相關脆弱性
    likelihood: Likelihood = Likelihood.MEDIUM  # 發生可能性
    impact: Impact = Impact.MODERATE            # 影響程度
    risk_level: RiskLevel = RiskLevel.MEDIUM    # 風險等級
    treatment: TreatmentOption = TreatmentOption.MITIGATE  # 處理選項
    treatment_plan: str = ""                    # 處理計畫
    residual_risk_level: Optional[RiskLevel] = None  # 殘餘風險等級

# -----------------------------------------------------------------------------
# 風險評估引擎類別
# 提供風險評估的核心運算與管理功能
# -----------------------------------------------------------------------------

class RiskAssessmentEngine:
    """
    風險評估引擎類別

    提供資訊安全風險評估的完整核心功能，實作風險評估
    的完整流程，包括資產管理、威脅識別、脆弱性評估、
    風險計算、處理建議與報告產生等功能
    """

    def __init__(self, organization_name: str):
        """
        初始化風險評估引擎實例

        參數:
            organization_name: 執行風險評估的組織名稱
        """
        # 儲存組織基本資訊
        self.organization_name = organization_name

        # 初始化資產、威脅、脆弱性與風險情境的儲存容器
        # 使用字典結構便於透過識別碼快速存取
        self.assets: Dict[str, Asset] = {}
        self.threats: Dict[str, Threat] = {}
        self.vulnerabilities: Dict[str, Vulnerability] = {}
        self.risk_scenarios: Dict[str, RiskScenario] = {}

        # 初始化風險矩陣，定義可能性與影響程度組合對應的風險等級
        self.risk_matrix = self._initialize_risk_matrix()

        # 記錄評估執行的時間戳記
        self.assessment_date = datetime.now()

    def _initialize_risk_matrix(self) -> Dict[Tuple[int, int], RiskLevel]:
        """
        初始化風險評估矩陣

        建立 5x5 的風險矩陣，定義可能性與影響程度各種組合
        所對應的風險等級，風險分數計算採用可能性乘以影響程度
        的簡單乘法模型

        回傳:
            Dict: 風險矩陣字典，鍵為（可能性值, 影響程度值）元組
        """
        matrix = {}

        # 建立 5x5 風險矩陣
        # 可能性與影響程度均為 1-5 的整數值
        for likelihood in range(1, 6):
            for impact in range(1, 6):
                # 風險分數 = 可能性 x 影響程度
                score = likelihood * impact

                # 根據風險分數決定風險等級分類
                if score <= 4:
                    # 低風險區間：分數 1-4
                    level = RiskLevel.LOW
                elif score <= 9:
                    # 中風險區間：分數 5-9
                    level = RiskLevel.MEDIUM
                elif score <= 16:
                    # 高風險區間：分數 10-16
                    level = RiskLevel.HIGH
                else:
                    # 極高風險區間：分數 17-25
                    level = RiskLevel.CRITICAL

                matrix[(likelihood, impact)] = level

        return matrix

    def add_asset(self, asset: Asset) -> None:
        """
        新增資訊資產至評估範圍

        將資產物件加入資產清冊，在加入前會驗證資產價值
        評分是否在有效範圍內

        參數:
            asset: 要新增的 Asset 資產物件

        例外:
            ValueError: 當資產價值評分超出 1-5 範圍時拋出
        """
        # 驗證資產三項安全屬性的價值評分都在有效範圍內
        for value in [asset.confidentiality_value,
                      asset.integrity_value,
                      asset.availability_value]:
            if not 1 <= value <= 5:
                raise ValueError(f"資產價值評分必須在 1-5 之間，收到無效值: {value}")

        # 將資產加入清冊，使用資產識別碼作為索引鍵
        self.assets[asset.asset_id] = asset

    def add_threat(self, threat: Threat) -> None:
        """
        新增威脅至威脅清單

        參數:
            threat: 要新增的 Threat 威脅物件
        """
        self.threats[threat.threat_id] = threat

    def add_vulnerability(self, vulnerability: Vulnerability) -> None:
        """
        新增脆弱性至脆弱性清單

        在加入前會驗證脆弱性嚴重程度評分是否在有效範圍內

        參數:
            vulnerability: 要新增的 Vulnerability 脆弱性物件

        例外:
            ValueError: 當嚴重程度評分超出 1-5 範圍時拋出
        """
        # 驗證嚴重程度評分在有效範圍內
        if not 1 <= vulnerability.severity <= 5:
            raise ValueError(
                f"脆弱性嚴重程度必須在 1-5 之間，收到無效值: {vulnerability.severity}"
            )

        self.vulnerabilities[vulnerability.vulnerability_id] = vulnerability

    def calculate_risk_level(
        self,
        likelihood: Likelihood,
        impact: Impact
    ) -> RiskLevel:
        """
        計算風險等級

        根據可能性與影響程度從風險矩陣查詢對應的風險等級

        參數:
            likelihood: 發生可能性列舉值
            impact: 影響程度列舉值

        回傳:
            RiskLevel: 對應的風險等級列舉值
        """
        return self.risk_matrix[(likelihood.value, impact.value)]

    def assess_risk_scenario(
        self,
        asset_id: str,
        threat_id: str,
        vulnerability_id: str,
        adjusted_likelihood: Optional[Likelihood] = None,
        adjusted_impact: Optional[Impact] = None
    ) -> RiskScenario:
        """
        評估特定風險情境

        結合資產、威脅與脆弱性建立風險情境，並計算風險等級。
        可選擇性地提供調整後的可能性與影響程度，若未提供
        則根據威脅基礎可能性與資產價值自動計算

        參數:
            asset_id: 資產識別碼
            threat_id: 威脅識別碼
            vulnerability_id: 脆弱性識別碼
            adjusted_likelihood: 調整後的可能性（選填）
            adjusted_impact: 調整後的影響程度（選填）

        回傳:
            RiskScenario: 評估完成的風險情境物件

        例外:
            ValueError: 當識別碼無效找不到對應物件時拋出
        """
        # 根據識別碼取得對應的物件
        asset = self.assets.get(asset_id)
        threat = self.threats.get(threat_id)
        vulnerability = self.vulnerabilities.get(vulnerability_id)

        # 驗證所有必要物件都存在
        if not all([asset, threat, vulnerability]):
            raise ValueError("資產、威脅或脆弱性識別碼無效，找不到對應物件")

        # 決定發生可能性
        if adjusted_likelihood:
            # 使用提供的調整值
            likelihood = adjusted_likelihood
        else:
            # 自動計算：基礎可能性加上脆弱性嚴重程度的調整
            base_value = threat.base_likelihood.value
            # 脆弱性嚴重程度中間值為 3，高於 3 增加可能性，低於 3 降低可能性
            adjustment = (vulnerability.severity - 3) * 0.5
            adjusted_value = max(1, min(5, int(base_value + adjustment)))
            likelihood = Likelihood(adjusted_value)

        # 決定影響程度
        if adjusted_impact:
            # 使用提供的調整值
            impact = adjusted_impact
        else:
            # 自動計算：根據資產整體價值決定影響程度
            asset_value = asset.calculate_asset_value()
            impact = Impact(asset_value)

        # 計算風險等級
        risk_level = self.calculate_risk_level(likelihood, impact)

        # 產生風險情境識別碼
        scenario_id = f"RS-{asset_id}-{threat_id}-{vulnerability_id}"

        # 建立並儲存風險情境物件
        scenario = RiskScenario(
            scenario_id=scenario_id,
            asset=asset,
            threat=threat,
            vulnerability=vulnerability,
            likelihood=likelihood,
            impact=impact,
            risk_level=risk_level
        )

        self.risk_scenarios[scenario_id] = scenario

        return scenario

    def recommend_treatment(self, scenario: RiskScenario) -> str:
        """
        根據風險情境產生處理建議

        分析風險情境的特性，產生適當的風險處理建議說明，
        包括處理優先順序建議與具體的控制措施方向

        參數:
            scenario: 要產生處理建議的風險情境物件

        回傳:
            str: 風險處理建議說明文字
        """
        recommendations = []

        # 根據風險等級提供對應層級的處理建議
        if scenario.risk_level == RiskLevel.CRITICAL:
            recommendations.append(
                "極高風險等級：建議立即採取行動降低風險。"
                "應考慮暫停相關業務活動直到風險獲得有效控制。"
            )
            scenario.treatment = TreatmentOption.MITIGATE

        elif scenario.risk_level == RiskLevel.HIGH:
            recommendations.append(
                "高風險等級：建議列為優先處理項目，在短期內實施控制措施。"
                "應評估是否需要投入額外資源以加速處理。"
            )
            scenario.treatment = TreatmentOption.MITIGATE

        elif scenario.risk_level == RiskLevel.MEDIUM:
            recommendations.append(
                "中風險等級：建議排入風險處理計畫，依優先順序安排處理時程。"
                "可進行成本效益分析後決定最適當的處理方式。"
            )
            scenario.treatment = TreatmentOption.MITIGATE

        else:
            recommendations.append(
                "低風險等級：風險在可接受範圍內。"
                "建議維持定期監控，確保風險持續維持在可接受水準。"
            )
            scenario.treatment = TreatmentOption.ACCEPT

        # 根據威脅類型提供更具體的控制措施建議
        if "惡意" in scenario.threat.source or "攻擊" in scenario.threat.name:
            recommendations.append(
                "針對惡意攻擊類型威脅，建議加強存取控制機制、"
                "部署入侵偵測系統並強化人員資安意識訓練。"
            )

        if "人為" in scenario.threat.source and "意外" in scenario.threat.source:
            recommendations.append(
                "針對人為意外類型威脅，建議強化標準作業程序、"
                "實施適當的職責分離機制並加強人員操作訓練。"
            )

        # 組合所有建議為完整的處理計畫說明
        scenario.treatment_plan = "\n".join(recommendations)

        return scenario.treatment_plan

    def generate_risk_register(self) -> List[Dict]:
        """
        產生風險登錄表

        將所有已評估的風險情境彙整為風險登錄表格式，
        按風險等級由高到低排序，便於管理階層審查與追蹤

        回傳:
            List[Dict]: 風險登錄資料的字典清單
        """
        register = []

        # 按風險等級降序排序，高風險優先顯示
        sorted_scenarios = sorted(
            self.risk_scenarios.values(),
            key=lambda s: s.risk_level.value,
            reverse=True
        )

        for scenario in sorted_scenarios:
            # 建立風險登錄項目
            entry = {
                "情境識別碼": scenario.scenario_id,
                "資產名稱": scenario.asset.name,
                "資產類別": scenario.asset.category.name,
                "威脅名稱": scenario.threat.name,
                "脆弱性名稱": scenario.vulnerability.name,
                "發生可能性": scenario.likelihood.name,
                "影響程度": scenario.impact.name,
                "風險等級": scenario.risk_level.name,
                "處理選項": scenario.treatment.name,
                "處理計畫": scenario.treatment_plan,
                "殘餘風險": (
                    scenario.residual_risk_level.name
                    if scenario.residual_risk_level else "待評估"
                )
            }
            register.append(entry)

        return register

    def calculate_risk_statistics(self) -> Dict:
        """
        計算風險統計資料

        統計分析所有已評估風險情境的分布情況，產生摘要
        統計資料供管理報告使用

        回傳:
            Dict: 包含各項統計數據的字典
        """
        # 統計各風險等級的數量
        level_counts = {level: 0 for level in RiskLevel}
        for scenario in self.risk_scenarios.values():
            level_counts[scenario.risk_level] += 1

        # 計算風險分布百分比
        total = len(self.risk_scenarios)
        level_percentages = {
            level.name: (count / total * 100) if total > 0 else 0
            for level, count in level_counts.items()
        }

        # 統計各資產類別的風險數量
        asset_category_risks = {}
        for scenario in self.risk_scenarios.values():
            category = scenario.asset.category.name
            if category not in asset_category_risks:
                asset_category_risks[category] = 0
            asset_category_risks[category] += 1

        return {
            "評估日期": self.assessment_date.isoformat(),
            "組織名稱": self.organization_name,
            "資產總數": len(self.assets),
            "威脅總數": len(self.threats),
            "脆弱性總數": len(self.vulnerabilities),
            "風險情境總數": total,
            "風險等級分布": {
                level.name: count for level, count in level_counts.items()
            },
            "風險等級百分比": level_percentages,
            "資產類別風險分布": asset_category_risks
        }

# -----------------------------------------------------------------------------
# 使用範例函式
# 展示風險評估模組的實際使用方式
# -----------------------------------------------------------------------------

def demonstrate_risk_assessment():
    """
    展示風險評估模組的使用方式

    建立範例資產、威脅與脆弱性，執行風險評估並輸出結果，
    作為使用此模組的參考範例
    """
    # 建立風險評估引擎實例，指定組織名稱
    engine = RiskAssessmentEngine("範例科技股份有限公司")

    # 建立範例資產：客戶資料庫
    customer_db = Asset(
        asset_id="A001",
        name="客戶資料庫",
        category=AssetCategory.INFORMATION,
        owner="資訊部經理",
        description="儲存所有客戶個人資料與歷史交易紀錄",
        confidentiality_value=5,  # 高機密性需求：包含個人敏感資料
        integrity_value=4,        # 高完整性需求：交易紀錄需正確
        availability_value=4,     # 高可用性需求：業務營運依賴
        location="主機房 Rack-A03"
    )
    engine.add_asset(customer_db)

    # 建立範例威脅：SQL 注入攻擊
    sql_injection = Threat(
        threat_id="T001",
        name="SQL 注入攻擊",
        description="攻擊者透過惡意建構的 SQL 語句存取或竄改資料庫內容",
        source="惡意攻擊",
        base_likelihood=Likelihood.HIGH,
        affected_properties=["機密性", "完整性"]
    )
    engine.add_threat(sql_injection)

    # 建立範例脆弱性：輸入驗證不足
    input_validation = Vulnerability(
        vulnerability_id="V001",
        name="使用者輸入驗證不足",
        description="應用程式未充分驗證與過濾使用者輸入資料",
        severity=4,
        affected_assets=["A001"],
        existing_controls=["Web 應用程式防火牆"]
    )
    engine.add_vulnerability(input_validation)

    # 執行風險評估
    scenario = engine.assess_risk_scenario(
        asset_id="A001",
        threat_id="T001",
        vulnerability_id="V001"
    )

    # 產生處理建議
    recommendation = engine.recommend_treatment(scenario)

    # 計算統計資料
    statistics = engine.calculate_risk_statistics()

    # 輸出評估結果
    print(f"風險情境識別碼：{scenario.scenario_id}")
    print(f"風險等級：{scenario.risk_level.name}")
    print(f"處理建議：\n{recommendation}")
    print(f"\n風險統計資料：")
    print(json.dumps(statistics, ensure_ascii=False, indent=2))

# 程式進入點
if __name__ == "__main__":
    demonstrate_risk_assessment()

#!/bin/bash
# =============================================================================
# isms_compliance_check.sh - 資訊安全管理系統技術控制符合性檢查腳本
# =============================================================================
# 此腳本執行基礎的技術安全控制檢查，協助組織驗證 ISO 27001 附錄 A
# 相關技術控制措施的實施狀態，產生符合性檢查報告供稽核參考使用
# =============================================================================

# -----------------------------------------------------------------------------
# 腳本嚴格模式設定
# 啟用嚴格模式可以及早發現腳本執行過程中的錯誤
# -----------------------------------------------------------------------------

# -e: 當任何命令執行失敗時立即終止腳本執行
# -u: 當使用未定義的變數時視為錯誤並終止執行
# -o pipefail: 管線命令中任何一個命令失敗時回傳失敗狀態
set -euo pipefail

# -----------------------------------------------------------------------------
# 輸出顏色代碼定義
# 使用顏色代碼提升報告輸出的視覺可讀性
# -----------------------------------------------------------------------------

readonly RED='\033[0;31m'      # 紅色：用於標示失敗或高風險項目
readonly GREEN='\033[0;32m'    # 綠色：用於標示通過或正常項目
readonly YELLOW='\033[0;33m'   # 黃色：用於標示警告項目
readonly BLUE='\033[0;34m'     # 藍色：用於標示一般資訊訊息
readonly NC='\033[0m'          # 無顏色：重設顏色設定

# -----------------------------------------------------------------------------
# 檢查結果計數器
# 追蹤各類檢查結果的數量以便產生統計摘要
# -----------------------------------------------------------------------------

PASS_COUNT=0    # 通過項目數量
FAIL_COUNT=0    # 失敗項目數量
WARN_COUNT=0    # 警告項目數量

# -----------------------------------------------------------------------------
# 報告輸出檔案
# 以時間戳記命名確保每次執行產生獨立的報告檔案
# -----------------------------------------------------------------------------

REPORT_FILE="isms_compliance_report_$(date +%Y%m%d_%H%M%S).txt"

# -----------------------------------------------------------------------------
# 輔助函式定義區塊
# 提供日誌記錄與報告輸出的共用功能
# -----------------------------------------------------------------------------

log_message() {
    # 輸出帶有時間戳記的格式化訊息
    # 參數:
    #   $1: 訊息等級（INFO, WARN, ERROR, PASS, FAIL）
    #   $2: 訊息內容

    local level="$1"
    local message="$2"
    local timestamp
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')

    # 根據訊息等級設定對應的顏色
    local color
    case "$level" in
        INFO)  color="$BLUE" ;;
        WARN)  color="$YELLOW" ;;
        ERROR) color="$RED" ;;
        PASS)  color="$GREEN" ;;
        FAIL)  color="$RED" ;;
        *)     color="$NC" ;;
    esac

    # 輸出到螢幕（含顏色）
    echo -e "${color}[$timestamp] [$level] $message${NC}"

    # 同時寫入報告檔案（不含顏色代碼）
    echo "[$timestamp] [$level] $message" >> "$REPORT_FILE"
}

print_section() {
    # 輸出檢查項目的章節標題
    # 參數:
    #   $1: 章節標題文字

    local title="$1"
    local separator="========================================"

    # 輸出到螢幕
    echo ""
    echo -e "${BLUE}$separator${NC}"
    echo -e "${BLUE}$title${NC}"
    echo -e "${BLUE}$separator${NC}"
    echo ""

    # 寫入報告檔案
    {
        echo ""
        echo "$separator"
        echo "$title"
        echo "$separator"
        echo ""
    } >> "$REPORT_FILE"
}

record_pass() {
    # 記錄檢查通過項目
    # 參數:
    #   $1: 檢查項目描述
    log_message "PASS" "$1"
    ((PASS_COUNT++))
}

record_fail() {
    # 記錄檢查失敗項目
    # 參數:
    #   $1: 檢查項目描述
    log_message "FAIL" "$1"
    ((FAIL_COUNT++))
}

record_warn() {
    # 記錄檢查警告項目
    # 參數:
    #   $1: 檢查項目描述
    log_message "WARN" "$1"
    ((WARN_COUNT++))
}

# -----------------------------------------------------------------------------
# 安全控制檢查函式
# 實作各項 ISO 27001 附錄 A 技術控制措施的檢查邏輯
# -----------------------------------------------------------------------------

check_firewall_status() {
    # A.8.1 使用者端點裝置 - 檢查防火牆狀態
    # 驗證系統防火牆是否已正確啟用並設定

    print_section "A.8.1 使用者端點裝置 - 防火牆狀態檢查"

    # 根據作業系統類型執行對應的檢查
    if [[ "$OSTYPE" == "darwin"* ]]; then
        # macOS 系統：檢查應用程式防火牆狀態
        local fw_status
        fw_status=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate 2>/dev/null || echo "unknown")

        if echo "$fw_status" | grep -q "enabled"; then
            record_pass "macOS 應用程式防火牆已啟用"
        else
            record_fail "macOS 應用程式防火牆未啟用，建議執行：sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate on"
        fi

        # 檢查防火牆隱身模式設定
        local stealth_mode
        stealth_mode=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getstealthmode 2>/dev/null || echo "unknown")

        if echo "$stealth_mode" | grep -q "enabled"; then
            record_pass "防火牆隱身模式已啟用"
        else
            record_warn "防火牆隱身模式未啟用，建議啟用以提升安全性"
        fi

    elif [[ "$OSTYPE" == "linux"* ]]; then
        # Linux 系統：檢查 iptables 或 firewalld 狀態
        if command -v firewall-cmd &> /dev/null; then
            # 使用 firewalld 的 Linux 發行版
            if systemctl is-active --quiet firewalld; then
                record_pass "firewalld 防火牆服務正在運行"

                # 檢查預設防火牆區域設定
                local default_zone
                default_zone=$(firewall-cmd --get-default-zone 2>/dev/null || echo "unknown")
                log_message "INFO" "預設防火牆區域：$default_zone"
            else
                record_fail "firewalld 防火牆服務未運行"
            fi

        elif command -v ufw &> /dev/null; then
            # 使用 ufw 的 Linux 發行版（如 Ubuntu）
            local ufw_status
            ufw_status=$(ufw status 2>/dev/null | head -1 || echo "unknown")

            if echo "$ufw_status" | grep -q "active"; then
                record_pass "ufw 防火牆已啟用"
            else
                record_fail "ufw 防火牆未啟用"
            fi

        elif command -v iptables &> /dev/null; then
            # 直接使用 iptables 的 Linux 系統
            local rules_count
            rules_count=$(iptables -L -n 2>/dev/null | wc -l || echo "0")

            if [[ "$rules_count" -gt 8 ]]; then
                record_pass "iptables 已設定防火牆規則"
            else
                record_warn "iptables 規則數量較少，建議檢視防火牆設定"
            fi
        else
            record_fail "未偵測到已安裝的防火牆軟體"
        fi
    fi
}

check_password_policy() {
    # A.8.5 安全認證 - 檢查密碼政策設定
    # 驗證系統密碼政策是否符合安全要求

    print_section "A.8.5 安全認證 - 密碼政策檢查"

    if [[ "$OSTYPE" == "darwin"* ]]; then
        # macOS：檢查密碼政策設定
        log_message "INFO" "檢查 macOS 密碼政策設定..."

        local policy_info
        policy_info=$(pwpolicy -getglobalpolicy 2>/dev/null || echo "無法取得政策")

        if [[ "$policy_info" != "無法取得政策" ]]; then
            log_message "INFO" "密碼政策已設定"

            # 解析最小長度要求
            if echo "$policy_info" | grep -q "minChars"; then
                record_pass "已設定密碼最小長度要求"
            else
                record_warn "建議設定密碼最小長度要求"
            fi
        else
            record_warn "無法取得系統密碼政策，可能需要管理員權限"
        fi

    elif [[ "$OSTYPE" == "linux"* ]]; then
        # Linux：檢查 PAM 密碼品質設定
        local pam_file="/etc/security/pwquality.conf"

        if [[ -f "$pam_file" ]]; then
            log_message "INFO" "檢查 $pam_file 設定..."

            # 檢查密碼最小長度設定
            if grep -q "^minlen" "$pam_file" 2>/dev/null; then
                local min_len
                min_len=$(grep "^minlen" "$pam_file" | cut -d= -f2 | tr -d ' ')
                if [[ "$min_len" -ge 12 ]]; then
                    record_pass "密碼最小長度設定為 $min_len（符合建議值 12 以上）"
                else
                    record_warn "密碼最小長度為 $min_len，建議設定為 12 以上"
                fi
            else
                record_fail "未設定密碼最小長度"
            fi

            # 檢查密碼複雜度要求
            if grep -q "^dcredit\|^ucredit\|^lcredit\|^ocredit" "$pam_file" 2>/dev/null; then
                record_pass "已設定密碼複雜度要求"
            else
                record_warn "建議設定密碼複雜度要求（包含大小寫字母、數字、特殊字元）"
            fi
        else
            record_warn "找不到 pwquality.conf 設定檔，可能使用其他密碼政策機制"
        fi

        # 檢查密碼過期設定
        local login_defs="/etc/login.defs"
        if [[ -f "$login_defs" ]]; then
            local pass_max_days
            pass_max_days=$(grep "^PASS_MAX_DAYS" "$login_defs" 2>/dev/null | awk '{print $2}' || echo "未設定")

            if [[ "$pass_max_days" != "未設定" ]] && [[ "$pass_max_days" -le 90 ]]; then
                record_pass "密碼最長有效期設定為 $pass_max_days 天"
            else
                record_warn "密碼最長有效期為 $pass_max_days 天，建議設定為 90 天以內"
            fi
        fi
    fi
}

check_system_updates() {
    # A.8.9 組態管理 - 檢查系統更新狀態
    # 驗證作業系統與軟體套件是否維持最新狀態

    print_section "A.8.9 組態管理 - 系統更新狀態檢查"

    if [[ "$OSTYPE" == "darwin"* ]]; then
        # macOS：檢查軟體更新狀態
        log_message "INFO" "檢查 macOS 軟體更新狀態..."

        local updates
        updates=$(softwareupdate -l 2>&1)

        if echo "$updates" | grep -q "No new software available"; then
            record_pass "系統已是最新版本，無待安裝的更新"
        else
            local update_count
            update_count=$(echo "$updates" | grep -c "^\*" 2>/dev/null || echo "0")

            if [[ "$update_count" -gt 0 ]]; then
                record_fail "發現 $update_count 個待安裝的更新，建議盡快更新"
                log_message "INFO" "可用更新清單："
                echo "$updates" | grep "^\*" || true
            else
                record_pass "未發現重大待安裝更新"
            fi
        fi

        # 檢查自動更新設定
        local auto_update
        auto_update=$(defaults read /Library/Preferences/com.apple.SoftwareUpdate AutomaticCheckEnabled 2>/dev/null || echo "0")

        if [[ "$auto_update" == "1" ]]; then
            record_pass "自動檢查更新功能已啟用"
        else
            record_warn "自動檢查更新功能未啟用，建議啟用"
        fi

    elif [[ "$OSTYPE" == "linux"* ]]; then
        # Linux：根據發行版檢查套件更新
        if command -v apt &> /dev/null; then
            # Debian/Ubuntu 系列發行版
            log_message "INFO" "檢查 APT 套件更新..."

            # 更新套件清單
            apt update -qq 2>/dev/null || true

            # 計算可更新套件數量
            local upgradable
            upgradable=$(apt list --upgradable 2>/dev/null | grep -c "upgradable" || echo "0")

            if [[ "$upgradable" -eq 0 ]]; then
                record_pass "所有套件已是最新版本"
            else
                record_warn "發現 $upgradable 個可更新的套件"
            fi

            # 特別檢查安全性更新
            local security_updates
            security_updates=$(apt list --upgradable 2>/dev/null | grep -i "security" | wc -l || echo "0")

            if [[ "$security_updates" -gt 0 ]]; then
                record_fail "發現 $security_updates 個安全性更新待安裝，建議立即更新"
            fi

        elif command -v yum &> /dev/null; then
            # RHEL/CentOS 系列發行版
            log_message "INFO" "檢查 YUM 套件更新..."

            local updates_count
            updates_count=$(yum check-update 2>/dev/null | grep -c "^[a-zA-Z]" || echo "0")

            if [[ "$updates_count" -eq 0 ]]; then
                record_pass "所有套件已是最新版本"
            else
                record_warn "發現 $updates_count 個可更新的套件"
            fi
        fi
    fi
}

check_audit_logging() {
    # A.8.15 日誌記錄 - 檢查稽核日誌設定
    # 驗證系統稽核日誌機制是否正確設定並運作

    print_section "A.8.15 日誌記錄 - 稽核日誌設定檢查"

    if [[ "$OSTYPE" == "darwin"* ]]; then
        # macOS：檢查稽核設定
        log_message "INFO" "檢查 macOS 稽核設定..."

        # 檢查 auditd 服務是否運行
        if launchctl list | grep -q "com.apple.auditd"; then
            record_pass "auditd 稽核服務正在運行"
        else
            record_warn "auditd 稽核服務可能未運行"
        fi

        # 檢查稽核控制檔案
        local audit_control="/etc/security/audit_control"
        if [[ -f "$audit_control" ]]; then
            record_pass "稽核控制檔案存在：$audit_control"

            # 檢查日誌保留設定
            if grep -q "^expire-after" "$audit_control" 2>/dev/null; then
                local expire_setting
                expire_setting=$(grep "^expire-after" "$audit_control" | cut -d: -f2)
                log_message "INFO" "日誌過期設定：$expire_setting"
            fi
        else
            record_fail "找不到稽核控制檔案"
        fi

    elif [[ "$OSTYPE" == "linux"* ]]; then
        # Linux：檢查 auditd 設定
        log_message "INFO" "檢查 Linux auditd 設定..."

        # 檢查 auditd 服務狀態
        if systemctl is-active --quiet auditd 2>/dev/null; then
            record_pass "auditd 稽核服務正在運行"
        elif service auditd status &>/dev/null; then
            record_pass "auditd 稽核服務正在運行"
        else
            record_fail "auditd 稽核服務未運行，建議啟用稽核日誌"
        fi

        # 檢查稽核規則數量
        if command -v auditctl &> /dev/null; then
            local rules_count
            rules_count=$(auditctl -l 2>/dev/null | wc -l || echo "0")

            if [[ "$rules_count" -gt 5 ]]; then
                record_pass "已設定 $rules_count 條稽核規則"
            else
                record_warn "稽核規則數量較少（$rules_count），建議增加關鍵事件的稽核規則"
            fi
        fi

        # 檢查 rsyslog 服務狀態
        if systemctl is-active --quiet rsyslog 2>/dev/null; then
            record_pass "rsyslog 系統日誌服務正在運行"
        else
            record_warn "rsyslog 服務未運行"
        fi
    fi
}

check_network_security() {
    # A.8.20 網路安全 - 檢查網路安全設定
    # 驗證系統網路安全相關設定是否符合安全要求

    print_section "A.8.20 網路安全 - 網路設定檢查"

    if [[ "$OSTYPE" == "linux"* ]]; then
        log_message "INFO" "檢查 Linux 網路安全設定..."

        # 檢查 IPv4 封包轉發是否停用
        local ip_forward
        ip_forward=$(cat /proc/sys/net/ipv4/ip_forward 2>/dev/null || echo "unknown")

        if [[ "$ip_forward" == "0" ]]; then
            record_pass "IPv4 封包轉發已停用"
        else
            record_warn "IPv4 封包轉發已啟用，除非作為路由器使用，否則建議停用"
        fi

        # 檢查 ICMP 重導向設定
        local icmp_redirect
        icmp_redirect=$(cat /proc/sys/net/ipv4/conf/all/accept_redirects 2>/dev/null || echo "unknown")

        if [[ "$icmp_redirect" == "0" ]]; then
            record_pass "ICMP 重導向已停用"
        else
            record_warn "ICMP 重導向已啟用，建議停用以防止中間人攻擊"
        fi

        # 檢查 SYN Cookie 保護設定
        local syn_cookies
        syn_cookies=$(cat /proc/sys/net/ipv4/tcp_syncookies 2>/dev/null || echo "unknown")

        if [[ "$syn_cookies" == "1" ]]; then
            record_pass "SYN Cookie 保護已啟用"
        else
            record_warn "SYN Cookie 保護未啟用，建議啟用以防止 SYN Flood 攻擊"
        fi

    elif [[ "$OSTYPE" == "darwin"* ]]; then
        log_message "INFO" "檢查 macOS 網路安全設定..."

        # 檢查 IPv4 封包轉發設定
        local ip_forward
        ip_forward=$(sysctl -n net.inet.ip.forwarding 2>/dev/null || echo "unknown")

        if [[ "$ip_forward" == "0" ]]; then
            record_pass "IPv4 封包轉發已停用"
        else
            record_warn "IPv4 封包轉發已啟用"
        fi
    fi

    # 檢查網路監聽服務
    log_message "INFO" "檢查網路監聽服務..."

    if command -v netstat &> /dev/null; then
        local listening_count
        listening_count=$(netstat -an 2>/dev/null | grep -c "LISTEN" || echo "0")
        log_message "INFO" "目前有 $listening_count 個服務正在監聽網路連線"
    elif command -v ss &> /dev/null; then
        local listening_count
        listening_count=$(ss -ln 2>/dev/null | grep -c "LISTEN" || echo "0")
        log_message "INFO" "目前有 $listening_count 個服務正在監聽網路連線"
    fi
}

check_encryption_settings() {
    # A.8.24 密碼學的使用 - 檢查加密設定
    # 驗證系統加密機制是否正確設定

    print_section "A.8.24 密碼學的使用 - 加密設定檢查"

    # 檢查磁碟加密狀態
    log_message "INFO" "檢查磁碟加密狀態..."

    if [[ "$OSTYPE" == "darwin"* ]]; then
        # macOS：檢查 FileVault 磁碟加密
        local fv_status
        fv_status=$(fdesetup status 2>/dev/null || echo "unknown")

        if echo "$fv_status" | grep -q "FileVault is On"; then
            record_pass "FileVault 磁碟加密已啟用"
        else
            record_fail "FileVault 磁碟加密未啟用，建議啟用以保護靜態資料"
        fi

    elif [[ "$OSTYPE" == "linux"* ]]; then
        # Linux：檢查 LUKS 磁碟加密
        if command -v lsblk &> /dev/null; then
            local encrypted_volumes
            encrypted_volumes=$(lsblk -o NAME,TYPE 2>/dev/null | grep -c "crypt" || echo "0")

            if [[ "$encrypted_volumes" -gt 0 ]]; then
                record_pass "偵測到 $encrypted_volumes 個加密磁碟區"
            else
                record_warn "未偵測到加密磁碟區，建議對敏感資料使用 LUKS 加密"
            fi
        fi
    fi

    # 檢查 SSH 加密設定
    log_message "INFO" "檢查 SSH 加密設定..."

    local ssh_config="/etc/ssh/sshd_config"
    if [[ -f "$ssh_config" ]]; then
        # 檢查加密演算法設定
        if grep -q "^Ciphers" "$ssh_config" 2>/dev/null; then
            local ciphers
            ciphers=$(grep "^Ciphers" "$ssh_config" | head -1)
            log_message "INFO" "SSH 加密演算法設定：$ciphers"

            # 檢查是否包含已知的弱加密演算法
            if echo "$ciphers" | grep -qi "arcfour\|3des\|blowfish"; then
                record_warn "SSH 設定包含弱加密演算法，建議移除"
            else
                record_pass "SSH 未使用已知的弱加密演算法"
            fi
        else
            record_warn "SSH 未明確指定加密演算法，建議設定強加密演算法清單"
        fi

        # 檢查 SSH 協定版本設定
        if grep -q "^Protocol 2" "$ssh_config" 2>/dev/null || ! grep -q "^Protocol" "$ssh_config" 2>/dev/null; then
            record_pass "SSH 使用安全的協定版本 2"
        else
            record_fail "SSH 可能允許使用舊版不安全協定，建議只允許 Protocol 2"
        fi
    else
        log_message "INFO" "找不到 SSH 伺服器設定檔，可能未安裝 SSH 伺服器服務"
    fi
}

# -----------------------------------------------------------------------------
# 報告產生函式
# 彙整所有檢查結果並產生摘要報告
# -----------------------------------------------------------------------------

generate_summary_report() {
    # 產生檢查結果摘要報告

    print_section "檢查結果摘要"

    local total=$((PASS_COUNT + FAIL_COUNT + WARN_COUNT))

    echo ""
    echo "=========================================="
    echo "    ISMS 技術控制符合性檢查報告          "
    echo "=========================================="
    echo ""
    echo "檢查時間：$(date '+%Y-%m-%d %H:%M:%S')"
    echo "主機名稱：$(hostname)"
    echo "作業系統：$OSTYPE"
    echo ""
    echo "------------------------------------------"
    echo "檢查項目統計"
    echo "------------------------------------------"
    echo -e "通過項目：${GREEN}$PASS_COUNT${NC}"
    echo -e "失敗項目：${RED}$FAIL_COUNT${NC}"
    echo -e "警告項目：${YELLOW}$WARN_COUNT${NC}"
    echo "檢查總數：$total"
    echo ""

    # 計算符合率
    if [[ "$total" -gt 0 ]]; then
        local compliance_rate
        compliance_rate=$(echo "scale=1; $PASS_COUNT * 100 / $total" | bc)
        echo "符合率：$compliance_rate%"
    fi

    echo ""
    echo "詳細報告已儲存至：$REPORT_FILE"
    echo "=========================================="

    # 寫入報告檔案
    {
        echo ""
        echo "=========================================="
        echo "          檢查結果摘要                    "
        echo "=========================================="
        echo "通過項目：$PASS_COUNT"
        echo "失敗項目：$FAIL_COUNT"
        echo "警告項目：$WARN_COUNT"
        echo "檢查總數：$total"
        echo "=========================================="
    } >> "$REPORT_FILE"
}

# -----------------------------------------------------------------------------
# 主程式進入點
# 依序執行各項檢查並產生報告
# -----------------------------------------------------------------------------

main() {
    # 初始化報告檔案，寫入標頭資訊
    {
        echo "=========================================="
        echo "ISMS 技術控制符合性檢查報告"
        echo "=========================================="
        echo "產生時間：$(date '+%Y-%m-%d %H:%M:%S')"
        echo "主機名稱：$(hostname)"
        echo "作業系統：$OSTYPE"
        echo ""
    } > "$REPORT_FILE"

    log_message "INFO" "開始執行 ISMS 技術控制符合性檢查..."

    # 依序執行各項安全控制檢查
    check_firewall_status
    check_password_policy
    check_system_updates
    check_audit_logging
    check_network_security
    check_encryption_settings

    # 產生檢查結果摘要報告
    generate_summary_report
}

# 執行主程式
main "$@"