Domain 5 涵蓋了我們日常工作中確保安全的各項措施。這是關於組態、修補程式、變更管理，密碼學和雜湊，以及對密碼學的攻擊，資料處理、分類、標記、保留、銷毀/處置，管理（指導性）控制，安全意識訓練和社交工程。

組態管理 (Configuration Management)

組態管理涉及建立和維護系統和應用程式的標準化配置。這確保了環境的一致性。

修補程式管理 (Patch Management)

修補程式管理是用來解決系統和應用程式中的已知漏洞。更新修補程式是修正這些弱點的控制措施。

變更管理 (Change Management)

變更管理是組織處理環境變更的正式流程。如果做得正確，變更管理應該具備完整的文件記錄、對變更的理解，並將變更傳達給相關方。變更審查委員會應由 IT 和組織內的其他營運部門組成。

變更管理的步驟包括：

• Request (請求)
• Review (審查)
• Approve or Reject (批准或拒絕)
• Test (測試)
• Implement (實施)
• Document (記錄)
  這通常縮寫為 RRA/RTID。

密碼學 (Cryptography)

密碼學是保護通訊安全的科學。密碼學幫助我們：

• 保護我們的秘密 (機密性) - 確保未經授權的人員無法存取資料。大多數人認為密碼學就只是做這件事。
• 保持資料不被篡改 (完整性)。
• 提供驗證主體身份的方法 (身份驗證)，它還可以提供不可否認性。

歷史密碼 (Historical Ciphers) 包括：

• 斯巴達密碼棒 (Spartan Scytale)：訊息通過將羊皮紙纏繞在木棍上進行解密。
• 凱撒密碼 (Caesar Cipher)：通過將字母表中的字母移動一定數量的位置進行替換。
• 書籍密碼 (Book Cipher)：使用一本書作為金鑰，並使用座標（例如，頁碼、句子、單詞）進行加密。
• 連續金鑰密碼 (Running-Key Cipher)：使用已知文本和短語進行加密。

加密類型 (Encryption Types)：

• 非對稱加密 (Asymmetric / Public Key Encryption)：使用一對公鑰和私鑰。
  • 優點：不需要預共享金鑰；可擴展。
  • 缺點：速度較慢；每位元的強度較弱。
• 對稱加密 (Symmetric)：使用相同的金鑰進行加密和解密。
  • 優點：速度較快；每位元的強度較強。
  • 缺點：需要預共享金鑰；用戶多時複雜。
• 混合加密 (Hybrid)：結合非對稱加密和對稱加密。使用非對稱加密來共享對稱工作階段金鑰，然後使用對稱加密進行資料傳輸。

雜湊 (Hashing)

雜湊函數從可變長度的輸入產生固定長度的雜湊值。即使資料發生微小的變化，也會產生完全不同的雜湊值。雜湊用於確保資料的完整性。具有 “HA” 或 “MD” 字樣的名稱通常表示雜湊算法。例如，訊息摘要也稱為雜湊。

對密碼學的攻擊 (Attacks on Cryptography)

對密碼學的攻擊可能包括：

• 竊取金鑰 (Steal the Key)：由於現代加密很難破解，攻擊者發現從系統或金鑰儲存庫中恢復私鑰更容易。執法部門有時會通過搜查令恢復金鑰。
• 暴力破解 (Brute Force)：嘗試所有可能的金鑰來解密資料。除了單次墊以外，暴力破解對基於金鑰的密碼是有效的。
• 金鑰延展 (Key Stretching)：延遲密碼驗證以阻止暴力破解嘗試。
• 中間人攻擊 (Man-in-the-Middle Attack - MITM)：攻擊者截取並可能篡改兩方之間的通訊。這需要存取通訊管道。
• 側通道攻擊 (Side Channel Attacks)：利用物理數據（例如 CPU 週期、功耗）來破解加密。
• 社交工程 (Social Engineering)：這比破解金鑰容易得多，它是說服金鑰持有者將其交給冒充「幫助台」的人。社交工程利用說服技巧來獲取敏感資訊。這部分更詳細的內容將在後面涵蓋。

資料處理、分類、標記、保留、銷毀/處置 (Data Handling, Classification, Labeling, Retention, Destruction/Disposal)

敏感資訊管理 (Sensitive Information Management) 包括：

• 資料處理 (Data Handling)：只有信任的個人應該處理資料。應該制定關於如何、何處、何時以及為何處理資料的政策，並應建立日誌以顯示這些指標。
• 資料儲存 (Data Storage)：敏感資料應儲存在安全、氣候控制的設施中。最好位於地理位置較遠的地方，以防止單一事件影響多個設施。應避免不安全的做法，例如無人監控的磁帶備份。
• 資料保留 (Data Retention)：僅在必要時或法律要求的情況下保留資料。法規（例如 HIPAA、PCI-DSS）規定了保留期限；必須確保合規。資料保留政策規定了需要保留數據的時間長度，通常由法規或業務需求決定。
• 資料銷毀 (Data Disposal)：
  • 紙質文件銷毀：應使用安全的方法，例如交叉碎紙，以防止重組。
  • 數位資料銷毀：
    • 軟性銷毀 (Soft Destruction)：包括刪除、格式化和覆寫。刪除文件只是刪除了指標，而資料仍然存在，可以使用資料恢復軟體恢復。格式化也做同樣的事情，但它會在舊文件結構上放置一個新的文件結構，大多數情況下仍然可以恢復。覆寫是通過寫入 0 或隨機字符覆寫資料。這些方法並非萬無一失。
    • 清理 (Sanitization)：一個過程，使媒體上的目標資料難以在給定的恢復努力程度下恢復。
    • 清除 (Purge)：將敏感資料從系統或設備中移除到即使在實驗室環境中也無法恢復資料的程度。
    • 消磁 (Degaussing)：通過暴露在非常強的磁場中來銷毀磁性媒體。這也會很可能破壞媒體的完整性。
    • 物理銷毀 (Physical Destruction)：這是比軟性銷毀更安全的方法。包括磁碟壓碎（用於傳統硬碟）、碎紙（用於金屬）、焚燒、粉碎、熔化和酸處理。通常與軟性方法一起使用。對敏感資料執行多種資料銷毀類型（例如消磁和磁碟壓碎/碎紙）是很常見的。

資訊生命週期 (Information Life Cycle) 包括：

• 資料獲取 (Data Acquisition)：資料的建立或複製、索引和儲存。

管理（指導性）控制 (Administrative (Directive) Controls)

管理（指導性）控制是存取控制類別之一。它們包括組織政策和程序、法規以及培訓和意識。

管理控制也可以是存取控制的類型之一。它們可以是：

• 預防性 (Preventative)：防止動作發生。
• 偵測性 (Detective)：在發生過程中或之後識別動作。
• 矯正性 (Corrective)：在發生後修復問題。
• 恢復性 (Recovery)：協助事件發生後的恢復。
• 威懾性 (Deterrent)：阻止動作。
• 補償性 (Compensating)：當主要控制措施不切實際時提供替代控制措施。

政策 (Policies) 是強制性的且是高層次的。它們可以包含「修補程式、更新、強加密」等內容，但不會具體到「作業系統、加密類型、供應商技術」。

常見的政策包括：

• 可接受使用政策 (Acceptable Use Policy - AUP)：定義了網路、資料、資源等的可接受使用方式。
• 自帶設備政策 (Bring Your Own Device - BYOD Policy)：關於個人設備在一定參數範圍內使用的指南。
• 隱私政策 (Privacy Policy)：關於收集、使用和管理私人資料的詳細資訊。
• 密碼政策 (Password Policy)：規定了密碼的要求。
  • 記住最後 24 個密碼。
  • 最大密碼有效期：90 天。
  • 最小密碼有效期：2 天（防止用戶循環使用密碼）。
  • 最小密碼長度：8 個字符 (ISC2 CC® 的要求)，雖然其他建議可能為 14 個字符。
  • 複雜度要求。
  • 儲存時不使用可逆加密。
• 資料處理政策 (Data Handling Policy)：包括分類、標記、加密、儲存、備份和處置/銷毀資料。

資料的三種狀態 (3 States of Data)：

• 靜態資料 (Data at Rest)：儲存的資料。
• 傳輸中資料 (Data in Motion)：正在網路上傳輸的資料。
• 使用中資料 (Data in Use)：正在主動使用的文件/資料，通常無法加密。

訓練與意識 (Training and Awareness)

使用者往往是最大的安全風險。

• 訓練 (Training)：為使用者提供技能組合。這很好，但如果他們忽略了知識，就沒有任何作用。
• 意識 (Awareness)：旨在改變使用者的行為。這是我們想要的，我們希望他們改變他們的行為。
  我們希望通過良好的網路衛生習慣建立一種網路安全文化。

社交工程 (Social Engineering)

社交工程是說服金鑰持有者將其交給冒充「幫助台」的人，這比破解加密金鑰容易得多。社交工程是一種利用說服技巧來獲取敏感資訊的密碼學攻擊手段。

社交工程攻擊的技巧可能包括：

• 緊迫感 (Urgency)：讓受害者覺得必須立即行動，否則會發生不好的事情（例如，如果文件不按時填寫，公司將被起訴）。這常與釣魚攻擊結合使用。
• 熟悉感 (Familiarity)：提前了解受害者的一些資訊，然後在交流中提及。這可以顯著提高攻擊成功的機會。人們希望提供幫助，如果他們覺得認識你，他們就更願意提供幫助。這常在語音釣魚和面對面的社交工程中成功應用。

釣魚攻擊 (Phishing, Spear Phishing, and Whale Phishing)：「釣魚」在駭客術語中寫成 Phishing。

• 釣魚 (Phishing)：一種社交工程郵件攻擊。這類郵件發送給成千上萬的人，例如「點擊贏取」或「發送信息領取遺產」。即使只有極少數的收件人按照指示操作，攻擊者也能獲得大量受害者。
• 魚叉式網絡釣魚 (Spear Phishing)：有針對性的釣魚攻擊，而不是隨機發送的垃圾郵件，目標是特定個人。這類郵件包含了關於目標的資訊（個人或公司），熟悉度提高了成功率。
• 捕鯨式網絡釣魚 (Whale Phishing / Whaling)：針對組織高層領導的魚叉式網絡釣魚。這可能是一封郵件，聲稱「如果您不填寫附件中的文件（其中包含木馬）並在兩週內發回給我們，您的公司將被起訴」。
• 語音釣魚 (Vishing / Voice Phishing)：通過自動語音系統發起的攻擊，類似於批量垃圾郵件。這些通常是「您的稅款已到期」、「您的帳戶已被鎖定」或「輸入您的個人身份信息以防止此情況」之類的電話。

好的，這是有關您提供的來源中關於 領域 4 (Domain 4) 的詳細資訊。這是一個非常廣泛的領域，涵蓋了網路、系統、雲端、恢復以及一些核心的安全原則。

領域 4：營運安全 (Security Operations)

雖然來源標題標示為 Domain 4，但內容涵蓋了廣泛的營運安全主題，包括網路安全、雲端安全、復原原則、硬體安全和一些通用安全設計原則。

網路基礎與定義 (Network Basics and Definitions)

• 網路 (Networking)：是一組共享資源或資料的電腦集合。
• 縱深防禦 (Defense-in-depth)：用於保護內部網路以及通過網際網路傳輸的資料。
• 通訊類型 (Communication Types)：
  • 單工 (Simplex)：單向通訊。
  • 半雙工 (Half-Duplex)：一次只能發送或接收。
  • 全雙工 (Full-Duplex)：可同時發送和接收。
• 網路類型 (Network Types)：
  • 基頻 (Baseband)：單一通道，一次傳輸一個訊號 (例如：乙太網路)。
  • 寬頻 (Broadband)：多個通道，可同時傳輸多個訊號。
• 網路範圍 (Network Scope)：
  • 區域網路 (LAN)：在有限區域內連接設備。
  • 廣域網路 (WAN)：連接地理上分散的 LANs。
  • 網際網路 (Internet)：全球互連的 WAN 網路集合。
  • 內部網路 (Intranet)：組織私有的網路。
  • 外部網路 (Extranet)：連接不同組織內部網路的連線。
• 交換方式 (Switching Methods)：
  • 電路交換 (Circuit Switching)：昂貴但始終可用，建立專用通訊通道，保證頻寬。
  • 分組交換 (Packet Switching)：資料被分成封包傳輸。

OSI 與 TCP/IP 模型 (The OSI and TCP/IP Model)

• OSI 模型 (OSI Model)：一個具有 7 層抽象的模型。
  • 層級 (從低到高)：實體層 (Physical)、資料連結層 (Datalink)、網路層 (Network)、傳輸層 (Transport)、會話層 (Session)、表示層 (Presentation)、應用層 (Application)。
  • 記憶法 (1-7)：Please Do Not Throw Sausage Pizza Away。
  • 記憶法 (7-1)：All People Seem To Need Data Processing。
  • 協定資料單元 (PDU)：每一層的資料單位名稱，從高到低為 Data, Segments, Packets, Frames, Bits。
  • 層級特性：層級越高越智慧但速度越慢。
  • 各層協定與威脅 (Protocols and Threats per Layer)：
    • Layer 1 (Physical)：硬體、纜線、無線電波、集線器。威脅包括資料洩漏、竊盜、竊聽、干擾。
    • Layer 2 (Data Link)：同一網路上的節點間傳輸資料，處理 MAC 位址、錯誤偵測。協定如 ARP, CSMA/CD, CSMA/CA。威脅包括 MAC 欺騙、泛洪。
    • Layer 3 (Network)：處理 IP 通訊，連接不同網路。協定如 IP, ICMP, IPSEC。威脅包括死亡之 Ping、IP 修改、DHCP 攻擊。
    • Layer 4 (Transport)：提供可靠 (TCP) 或不可靠 (UDP) 的資料傳輸。協定如 TCP, UDP, SSL/TLS (跨越 4-7 層)。威脅如 SYN 泛洪、Fraggle 攻擊。
    • Layer 5 (Session)：管理應用程式間的會話。
    • Layer 6 (Presentation)：格式化、壓縮、加密資料 (檔案層級)。
    • Layer 7 (Application)：與使用者應用程式互動。協定如 HTTP, HTTPS, FTP, SMTP, DNS, DHCP。威脅包括病毒、蠕蟲、應用程式漏洞。
  • 封裝 (Encapsulation)：每一層都會添加或移除協定資訊。
• TCP/IP 模型 (TCP/IP Model)：也稱為網際網路協定套件，提供端到端資料通訊。
  • 4 層：網路存取層 (Network access)、網際網路層 (Internet)、傳輸層 (Transport)、應用程式層 (Application)。或 連結層 (Link)、網際網路層 (Internet)、傳輸層 (Transport)、應用程式層 (Application)。
  • 對應 OSI 層級。

IP 位址、埠號與 MAC 位址 / IP 支援協定 (IP Addresses, Port Numbers, and MAC Addresses / IP Support Protocols)

• MAC 位址 (MAC Addresses)：網卡獨特的識別碼。48 位 (MAC-48) 或 64 位 (EUI-64)。前 24 位是製造商識別碼，其餘識別主機。容易被欺騙 (spoofed)。
• IP 位址 (IP Addresses)：
  • IPv4：32 位元，約 42 億個位址。無連線，不保證傳輸。
  • IPv6：128 位元，位址空間龐大，包含 IPSec。
  • 公有 IP (Public IPs)：可在網際網路路由。
  • 私有 IP (Private IPs)：不可路由 (例如：10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16)。
• 埠號 (Ports)：
  • 周知埠 (Well-known Ports)：0-1023，多用於協定。
  • 註冊埠 (Registered Ports)：1024-49151，多用於供應商特定應用程式。
  • 動態、私有或臨時埠 (Dynamic, Private or Ephemeral Ports)：49152-65535，任何人皆可使用。
  • 常用埠號：HTTP 80, HTTPS 443, SSH 22, FTP 20/21, SMTP 25, RDP 3389 等。
• IP 支援協定 (IP Support Protocols)：
  • ARP (Address Resolution Protocol)：將 IP 位址轉譯為 MAC 位址。容易受到 ARP 投毒攻擊。
  • ICMP (Internet Control Message Protocol)：用於故障排除 (例如：Ping, Traceroute)。
  • HTTP/HTTPS：HTTP 使用 TCP 埠 80，未加密；HTTPS 使用 TCP 埠 443，已加密。
  • DHCP (Dynamic Host Configuration Protocol)：動態分配 IP 位址，使用 UDP 埠 67/68。

纜線 (Cables)

• 類型：銅纜 (雙絞線 TP) 較便宜，但安全性較低，容易被竊聽、干擾、竊取資料；光纖更安全，不易受竊聽。
• 安全漏洞：電磁干擾 (EMI) 可能破壞資料可用性和完整性；串擾 (Crosstalk) 是訊號從一條纜線洩漏到另一條。
• 速率單位：Kbps, Mbps, Gbps, Tbps, Pbps。

LAN 拓樸 (LAN Topologies)

• 常見類型：匯流排 (Bus)、星狀 (Star)、環狀 (Ring)、網狀 (Mesh)。
• 網狀拓樸 (Mesh Topology)：分為部分網狀 (Partial Mesh) 和全網狀 (Full Mesh)。全網狀冗餘度最高，常用於高可用性 (HA) 環境。

Wi-Fi 與其他無線網路 (Wi-Fi and Other Wireless Networks)

• Wi-Fi (IEEE 802.11)：在有限區域內無線連接設備。
• 安全疑慮：比有線連接更容易被入侵。
• 威脅：
  • 干擾 (Interference)：可能破壞完整性和可用性。
  • 惡意雙胞胎 (Evil Twin)：建立偽造的熱點 (rogue access point)，誘騙使用者連線，竊取資料。
• 藍牙 (Bluetooth)：短距離無線技術 (2.4 GHz)，建立個人區域網路 (PAN)。裝置分類 (Class 1/2/3)，距離不同。使用 E0 串流加密 (較弱)。漏洞：Bluejacking, Bluesnarfing, Bluebugging。對策：不使用時停用、關閉探索模式、更新韌體。
• Li-Fi：使用光進行高速資料傳輸，適用於易受 EMI 影響的區域。
• Zigbee：低功耗、低資料速率的網狀網路，範圍約 10-100 米。
• 衛星網路 (Satellite)：透過衛星連線。
• 蜂巢式網路 (Cellular Networks)：分為不同區域的基地台，提供行動通訊服務 (3G, 4G, 5G)。5G 使用高頻短距離訊號，需要更多基地台且易受實體障礙物阻擋。

VLANs 與路由器 / VPNs, NAC, 第三方連線 (VLANs and Routers / VPNs, NAC, and Third-Party Connectivity)

• VLAN (Virtual LAN)：在 Layer 2 隔離廣播域，將交換器上的特定埠分配到 VLAN。VLAN Trunk 連接交換器以跨越 VLAN。
• VXLAN (Virtual eXtensible Local Area Network)：用於雲端運算，解決 VLAN 數量限制 (4094) 的問題。
• 路由器 (Routers)：Layer 3 裝置，根據 IP 位址和埠轉發流量，連接 LANs 到 WANs，使用路由表。包括靜態路由、預設閘道、動態路由協定 (OSPF, EIGRP, BGP)。
• VPN (Virtual Private Network)：透過專用連線、虛擬通道協定或流量加密建立虛擬點對點連線。
• NAC (Network Access Control)：自動確保系統符合安全政策。
• 第三方連線 (Third-Party Connectivity)：與供應商、合作夥伴的連線。必須進行徹底的風險評估，確保其安全狀態符合組織政策。可以使用 MOUs/MOAs 和 ISAs 作為安全協定。

SDN, SD-WAN, SDX (Software-Defined Networking, SD-WAN, SDX)

• SDN：透過軟體實現動態網路管理，將控制層與資料層分離。
• SD-WAN：在 WAN 上建立疊加網路，抽象化傳輸，提供流量管理、敏捷性。
• SDX：泛指軟體定義一切。

攻擊與攻擊者 (Attacks and Attackers)

• 攻擊者：可分為外部攻擊者 (Outsiders) 和內部攻擊者 (Insiders)。
• 惡意軟體 (Malware)：惡意程式碼的統稱。
• 殭屍程式/殭屍網路 (Bots/Botnets)：受控於殭屍網路主機 (bot-herders) 的命令與控制 (C&C) 網路，可發送垃圾郵件、竊取資料等。
• 誘捕系統 (Honeypots)：設計成看似合法目標，用於吸引攻擊者以研究漏洞和攻擊策略。
• 誘捕網路 (Honeynets)：誘捕系統的網路，模擬整個伺服器群，最佳實踐是將其與主要網路隔離 (使用 DMZ/防火牆)。從誘捕網路收集的資料由 SIEM/SOAR 系統分析。
• 防火牆 (Firewalls)：在信任的安全內部網路與外部非信任網路 (如網際網路) 之間建立屏障。
  • 類型：封包過濾防火牆 (L1-3)、狀態檢測防火牆 (L1-4)、代理伺服器 (Proxy servers, L7, 特定應用程式閘道)、應用層防火牆 (L7, 理解應用程式和協定，可檢查酬載)。
  • 設計：DMZ (非軍事區)，物理或邏輯子網路，用於暴露外部服務給非信任網路。通常使用兩個防火牆構成屏障，也可使用一個防火牆構成三腳 DMZ。DMZ 為 LAN 增加了額外的安全層。
• 零日攻擊 (0-day Attacks)：利用未知漏洞的攻擊。
• 漏洞掃描/測試 (Vulnerability Scanning/Testing)：掃描網路或系統中預定義的漏洞 (如錯誤配置、過時軟體、未修補系統)。理解掃描結果非常重要，報告可能非常長。必須分析漏洞與威脅和風險的關係 (風險 = 威脅 x 漏洞)。基於風險評估規劃有效的緩解措施。

虛擬化、雲端與分散式運算 (Virtualization, Cloud, and Distributed Computing)

• 虛擬化 (Virtualization)：在單一硬體平台 (主機) 上運行多個虛擬伺服器 (客戶機)。
  • 優點：降低成本、易於設置伺服器、資源分配、縮小實體空間。
  • 虛擬化監管程式 (Hypervisors)：Type 1 (裸金屬型，直接運行在硬體上)、Type 2 (運行在現有作業系統上)。
  • 安全疑慮：虛擬機逃逸 (VM escape)、虛擬化監管程式存取、資源耗盡。客戶機應像實體伺服器一樣在邏輯上隔離。
• 分散式系統 (Distributed Systems)：一組獨立系統共同工作以支援資源或提供服務，使用者通常視其為單一實體。
  • 優點：水平擴展性、模組化成長、容錯能力、成本效益、低延遲。
  • 應用廣泛：網際網路、P2P 網路、區塊鏈等。
  • 高效能運算 (HPC)：聚合計算節點以高速解決複雜計算。
• 雲端運算 (Cloud Computing)：外包部分 IT 基礎設施、儲存或應用程式，本質上是遠端的電腦。
  • 類型：私有雲 (Private)、公有雲 (Public, 共用租戶)、混合雲 (Hybrid)、社群雲 (Community)。
  • 模型：IaaS (基礎設施即服務，提供硬體到作業系統以下)、PaaS (平台即服務，提供作業系統以上)、SaaS (軟體即服務，提供作業系統及應用程式)。
  • 共享責任 (Shared Responsibility)：雲端提供商和客戶共同分擔安全責任。

物聯網 (IoT) / 資產追蹤與硬體強化 (Asset Tracking and Hardware Hardening)

• 物聯網 (IoT)：涵蓋廣泛的裝置和系統。
• 資產追蹤 (Asset Tracking)：手動或自動化方式追蹤資產。
• 硬體強化 (Hardware Hardening)：對伺服器和工作站等硬體設備進行安全配置。包括應用所有修補程式、封鎖不需要的埠、刪除預設使用者等。停用埠 (USB, CD) 可通過物理或邏輯 (如 Active Directory) 方式實現。

電力與備份 (Electricity and Backups)

• 電力：對於系統正常運行至關重要。
  • UPS (不間斷電源)：提供持續穩定的電源，並在停電時提供暫時備用電源，兼具浪湧保護功能。
  • 發電機 (Generators)：在停電時自動或手動啟動，提供更長的備用電源。
  • PDU (電源分配單元)：在機架或設施內分配電源。
• 備份 (Backups)：對於容錯、高可用性和冗餘至關重要。但經常被忽視。
  • 類型：
    • 完整備份 (Full Backup)：備份政策中的所有內容，清除存檔位元，恢復最簡單但耗時。
    • 增量備份 (Incremental Backup)：備份自上次備份以來的更改，清除存檔位元，執行速度快但恢復需要多個備份。
    • 差異備份 (Differential Backup)：備份自上次完整備份以來的更改，不清除存檔位元，恢復需要完整備份和最後一個差異備份。不要對同一份資料同時使用增量備份和差異備份。

容錯、冗餘與彈性 (Fault Tolerance, Redundancy, and Resiliency)

• 容錯 (Fault Tolerance)：確保高可用性和冗餘。
• 冗餘 (Redundancy)：提供備援能力。
  • RAID (磁碟陣列)：透過磁碟分條 (Striping) 提高速度，透過鏡像 (Mirroring) 或同位元 (Parity) 提供冗餘。
    • RAID 0：分條，無冗餘，需要至少 2 個磁碟。
    • RAID 1：鏡像，提供冗餘，需要 2 個磁碟。
    • RAID 5：帶有分散式同位元的塊級分條，提供速度和冗餘，需要至少 3 個磁碟。
  • RAID 在單一磁碟故障時提供幫助 (對於容錯類型)，但多個磁碟故障時需要從備份恢復。
  • 其他冗餘範例：網路路徑、電源、HVAC (空調系統)、人員。
  • 高可用性 (HA) 環境使用集群和負載平衡。
  • 日誌記錄 (Journaling)：遠端或電子方式將交易日誌發送到遠端站點。
• 彈性 (Resiliency)：系統從故障中恢復的能力。

消防 (Fire Suppression)

• 火災三要素 (Fire Requirements)：需要氧氣、熱源和燃料。撲滅火災需要移除其中一個要素。
• 滅火方法 (Methods of Suppression)：移除氧氣 (使用 Halon, FM200, Argon 等氣體)、移除熱源 (使用化學物質或水)、移除燃料 (很少見，因為設備常是燃料)。
• 火災類別 (Fire Classes)：A (可燃物)、B (液體)、C (電器)、D (金屬)、K (廚房油/脂)。來源強調從安全角度和自上而下的組織結構考慮火災類別。
• 自動滅火系統 (Automatic Fire Suppression Systems)：
  • 水 (Water)：透過降溫移除熱源，是最安全的滅火劑，但對資料中心硬體有害；應在用水前斷開電源。
  • 氣體 (Gas)：透過取代氧氣滅火，不留殘餘物。
• 手提滅火器 (Portable Fire Extinguishers)：應標明適用火災類型。使用 PASS 方法：Pull (拉插銷)、Aim (對準火源底部)、Squeeze (壓下手把)、Sweep (左右掃射)。

安全設計原則 (Secure Design Principles)

• 最小權限 (Least Privilege)：賦予員工或系統僅完成其職責所需的最低限度存取權限。
• 需要知道 (Need to Know)：即使擁有存取權限，如果工作不需要，就不應存取該資訊。
• 職責分離 (Separation of Duties)：將任務分配給多個人員，以防止欺詐和錯誤。如果不可行，需要補償性控制。
• 縱深防禦 (Defense in Depth)：使用多個重疊的安全控制措施保護資產，包括物理、行政和邏輯措施。
• 安全預設 (Secure Defaults)：系統在實施時應盡可能安全，然後根據可用性需求調整安全性。
• 故障安全 (Fail Securely)：系統設計應確保在故障時也能維持安全狀態。
• 保持簡單 (Keep It Simple)：簡單的安全措施更容易管理和理解。
• 信任但驗證 (Trust but Verify)：在信任的基礎上進行驗證。
• 零信任 (Zero Trust)：不對裝置或使用者給予隱含信任，在建立企業資源會話之前，始終對主體和裝置進行身份驗證和授權。
• 隱私設計 (Privacy by Design)：主動而非被動，預設即隱私，將隱私嵌入設計，全程安全，透明可見，尊重使用者隱私。

領域 3：安全架構與工程 (Security Architecture and Engineering)

雖然您的來源將此領域稱為「存取控制類別與類型 (Access Control Categories and Types)」，但從內容來看，它涵蓋了更廣泛的安全架構和工程原則，特別是關於如何實施和管理存取控制，以及相關的物理和技術控制措施。本領域旨在確保資訊系統和環境的安全，防止未經授權的存取和潛在威脅。

存取控制類別 (Access Control Categories)

存取控制措施可分為三大類:

1. 行政 (指令性) 控制 (Administrative, Directive, Controls)：這是基於組織的政策、程序、法規以及員工訓練和意識。它們是高階的、指導性的控制措施。
2. 技術 (邏輯) 控制 (Technical (Logical) Controls)：這是透過硬體、軟體或韌體實現的控制措施，例如防火牆、路由器和加密。
3. 物理控制 (Physical Controls)：這是保護實體資產和區域的控制措施，例如鎖、圍籬、警衛、大門和防撞柱。

存取控制類型 (Access Control Types)

除了類別，存取控制也可以根據其功能分為不同類型。許多控制措施可能同時屬於多種類型，在評估時應根據具體情境判斷其主要類型:

• 預防性控制 (Preventative)：在行動發生前阻止其發生。例子包括：最小權限原則 (Least Privilege)、藥物測試、入侵防禦系統 (IPS)、防火牆和加密。
• 偵測性控制 (Detective)：在攻擊期間或之後偵測到行動。例子包括：入侵偵測系統 (IDS)、閉路電視 (CCTV)、警報和防毒軟體。
• 糾正性控制 (Corrective)：在事件發生後修復問題。例子包括：防毒軟體、修補程式和入侵防禦系統 (IPS)。
• 復原性控制 (Recovery)：協助在事件發生後進行復原。例子包括：災害復原環境 (DR Environment)、備份和高可用性環境 (HA Environments)。
• 威懾性控制 (Deterrent)：阻止潛在的惡意行動。例子包括：圍籬、警衛、狗、燈光和「小心惡犬」標誌。
• 補償性控制 (Compensating)：當主要的控制措施無法實施或成本過高時，提供的替代控制措施。

物理安全控制 (Physical Security Controls)

物理安全控制是確保組織資產和人員安全的重要組成部分。細節包括：

• 周邊防禦 (Perimeter defense)：使用圍籬作為威懾或預防手段。較小的圍籬（如 3 英尺/1 米）可以起到威懾作用，而較高的圍籬（如 8 英尺/2.4 米）則能有效預防入侵。
• 大門 (Gates)：應進行監控或配備警衛。
• 障礙物/防撞柱 (Barriers/Bollards)：用於控制車輛通行，防止車輛攻擊設施。
• 燈光 (Lights)：作為偵測和威懾控制，應全面照亮區域，可使用靜態或運動感應燈。
• 閉路電視 (CCTV)：作為偵測和威懾控制，監控周邊和內部區域，並進行數位錄影。
• 鎖 (Locks)：有多種類型。
  • 鑰匙鎖 (Key Locks)：需要實體鑰匙，容易被複製或被鎖匠工具開啟。
  • 密碼鎖 (Combination Locks)：安全性較低，容易受到暴力破解攻擊。
  • 任何鑰匙鎖都可以被撬開或撞開，所需時間取決於鎖的品質。應嚴密保管主鑰匙及其保管地點。
• 門禁卡 (Access Cards)：
  • 智慧卡 (Smart Cards)：接觸式或非接觸式，使用 ICC 或 RFID 技術。
  • 磁條卡 (Magnetic Stripe Cards)：容易複製。
• 人員閘道 (Mantraps)：一個有兩扇門的房間。第一扇門必須完全關閉後，第二扇門才能打開。每扇門可以使用不同的認證方法（知識、持有物、生物特徵）。有時會使用重量感測器來偵測是否有額外的人員進入。
• 旋轉閘門 (Turnstiles)：允許單人進入，防止尾隨。
• 限制區域 (Restricted Areas)：訪客需要佩戴徽章、簽署訪客日誌並由人員陪同。供應商也應由人員陪同並進行安全檢查。
• 牆壁、地板和天花板 (Walls, Floors, and Ceilings)：應符合縱深防禦策略，確保入侵者無法透過這些途徑進入安全區域。應使用足夠堅固的材料，且牆壁應從真實地板延伸到真實天花板，以防止繞過。
• 警衛 (Guards)：可以是專業（經過訓練，可能攜帶武器）或業餘（未經訓練，可能攜帶武器）的警衛。擬警衛 (Pseudo Guard) 則是不攜帶武器的警衛。警衛應有明確的規章制度，並接受訓練以防止社交工程攻擊。
• 警犬 (Dogs)：作為威懾、偵測和補償控制措施，通常用於受控的封閉區域。潛在問題包括責任風險。

技術或邏輯安全控制 (Technical or Logical Security Controls)

技術或邏輯控制是透過軟體或硬體實現的。

• 存取控制系統 (Access Control Systems)：根據存取控制列表 (ACL) 或其他機制來確定是否允許或拒絕存取。最常見的配置是控制面板作為中心 (hub)，讀卡機作為分支 (spokes)。
• 集中式 vs. 分散式 vs. 混合式 (Centralized vs. Decentralized vs. Hybrid)：
  • 集中式 (Centralized)：單一系統控制所有存取，易於管理，但可能存在流量開銷和響應時間問題。如果中央系統被破壞，整個網路可能受到影響。
  • 分散式 (Decentralized)：本地系統獨立控制存取，響應時間更快，但安全性可能不一致，管理更困難。
  • 混合式 (Hybrid)：結合集中式控制和本地伺服器更新。

身份識別與存取佈建 (Identity and Access Provisioning)

• 概念 (Concept)：一個實體（例如用戶）可以擁有多個身份，每個身份可以有多個屬性。組織也可以有多個身份，例如母公司及其子公司。
• 生命週期 (Lifecycle)：一個建議的身份與存取佈建生命週期包括：創建身份、管理屬性、管理憑證、啟用身份、管理存取、監控活動、撤銷身份、刪除身份。應制定明確的政策，例如定期審查閒置帳戶並在一定時間後刪除。
• 聯合身份管理 (Federated Identity Management - FIDM)：將個人在不同身份管理系統中的電子身份和屬性連結起來。

存取控制模型 (Access Control Models)

組織可以根據其安全目標選擇不同的存取控制模型。

• 自主存取控制 (Discretionary Access Control - DAC)：通常用於當 可用性 (Availability) 最重要時。存取權限由物件的擁有者自行決定。大多數作業系統普遍使用此模型。使用 DACL (Discretionary ACL)，基於使用者身份。
• 強制存取控制 (Mandatory Access Control - MAC)：通常用於當 機密性 (Confidentiality) 最重要時。存取權限由標籤 (Labels) 和許可等級 (Clearance) 決定。這在軍事或高度重視機密性的組織中常見。
  • 標籤 (Labels)：分配給物件。
  • 許可等級 (Clearance)：分配給主體 (Subject)。主體的許可等級必須「支配」物件的標籤才能存取。標籤可以比「最高機密」更細緻，例如「最高機密 – 核武」。
• 基於角色 (Role-Based Access Control - RBAC)：通常用於當 完整性 (Integrity) 最重要時。存取權限基於用戶的角色和權限，有助於用戶管理。這在私營組織中很常見，例如根據用戶的職位（如薪資人員）賦予相應的存取權限。
• 基於屬性 (Attribute-Based Access Control - ABAC)：存取權限基於主體、物件和環境的屬性。屬性可以包括用戶的姓名、角色、ID、許可等級；物件的名稱、擁有者、創建日期；以及環境（例如存取的地點或時間、威脅等級）。這也被稱為基於政策的存取控制 (PBAC) 或基於聲明的存取控制 (CBAC)。
• 基於上下文 (Context-Based Access Control)：存取物件的權限基於某些上下文參數。例如：存取時間、地點、回應順序或存取歷史記錄。要求用戶在輸入用戶名和密碼後回答 CAPTCHA 挑戰，或根據 MAC 位址過濾無線網路存取，都是基於上下文的存取控制。
• 基於內容 (Content-Based Access Control)：存取權限基於物件的屬性或內容。例如：根據內容的值或屬性來決定是否顯示應用程式中的選單、資料庫中的視圖，或限制對機密資訊的存取。

此外，技術上還有基於規則的存取控制 (Rule Based Access Control - RUBAC)，主要用於防火牆的 IF/THEN 語句，但也可以與其他模型結合使用以提供縱深防禦。

存取控制的關鍵原則 (Key Principles of Access Control)

這些原則是實施有效存取控制的基礎：

• 最小權限 (Least Privilege)：給予員工或系統僅夠其執行職責所需的最低限度的存取權限，不多也不少。這是一種預防性控制。
• 需要知道 (Need to Know)：即使你有存取權限，如果你的工作不需要知道該資訊，就不應該存取它。
• 職責分離 (Separation of Duties)：將任務分配給多個人員，以防止欺詐和錯誤。如果職責分離不可行，則需要補償性控制。

行政安全 (Administrative Security)

除了政策和訓練等行政控制外，還有一些與行政安全相關的措施：

• 工作輪換 (Job Rotation)：在考試中，這被視為一種偵測錯誤和欺詐的手段。
• 資料分類政策 (Data Classification Policies)：雖然在領域 5 中有更詳細的討論，但在領域 3 中也提到了資料分類政策作為行政控制的一部分。這有助於確定應對不同類型資料採取的安全措施。

希望這個詳細的解釋對您理解領域 3 有所幫助！

Domain 2：業務連續性 (Business Continuity) 與災害復原 (Disaster Recovery)

Domain 2 涵蓋了組織在面對中斷事件時如何維持運作以及如何從中恢復。這個領域非常重要，因為它提供了應對災害情境和確保業務生存的架構。

業務連續性計劃 (BCP)

• 目的： BCP 是組織的 長期戰略計劃，旨在確保在發生中斷事件後能持續運作。它是一個 總括性計劃，包含許多子計劃。BCP 涵蓋了 整個組織，而不僅僅是 IT。
• 組成部分： BCP 包含了災害情境和復原步驟。它是一個 疊代過程，需要與關鍵員工和顧問一起編寫。
• 相關計劃： BCP 包含或與其他計劃相關聯:
  • 營運持續計劃 (COOP)：詳細說明如何在災害期間維持營運，包括如何安排員工前往備用站點，以及在減少容量下運作最多 30 天所需的所有營運事項。
  • 危機溝通計劃 (Crisis Communications Plan)：CMP 的子計劃，說明在危機期間如何進行內部和外部溝通。它指定了誰可以對媒體發言，以及誰可以向內部人員傳達什麼訊息。
  • 網路事件應變計劃 (Cyber Incident Response Plan)：說明如何在網路事件（如 DDOS、病毒等）中應對。這可以是 DRP 的一部分，也可以是獨立的計劃。
  • 人員緊急應變計劃 (OEP - Occupant Emergency Plan)：說明如何在災害事件中保護設施、員工和環境。這可能包括火災、颶風、洪水、犯罪攻擊、恐怖主義等。它著重於安全和疏散，並詳細說明如何疏散以及員工應接受的訓練。
  • 業務復原計劃 (BRP - Business Recovery Plan)：列出了從中斷事件中復原後恢復正常業務營運所需的步驟。這可能包括將營運從備用站點切換回（已修復的）主要站點。
  • 支援持續性計劃 (Continuity of Support Plan)：狹隘地關注特定 IT 系統和應用程式的支援。也被稱為 IT 應急計劃 (IT Contingency Plan)，強調 IT 而非一般的業務支援。
  • 危機管理計劃 (CMP - The Crisis Management Plan)：確保組織管理層在緊急或中斷事件發生時能進行有效的協調。它詳細說明了管理層必須採取的步驟，以確保在災害發生時立即保護人員的生命安全和財產。
• 高階管理層的角色： 高階管理層必須參與 BCP/DRP 過程的啟動和最終批准。他們對計劃負責並擁有計劃。他們最終負有責任，必須展現 應有的謹慎 (due-care) 和 應有的努力 (due-diligence)。在嚴重的災害中，應由高階管理層或法律部門的人員對媒體發言。他們對優先順序、實施和計劃本身擁有最終決定權。組織應該有 由上而下的 IT 安全文化。
• BCP 步驟： 典型的 BCP 流程包括：BCP 政策 → 業務影響分析 (BIA) → 識別預防性控制 → 制定復原策略 → 制定 DRP → DRP 訓練/測試 → BCP/DRP 維護。

災害復原計劃 (DRP)

• 目的： DRP 專注於 IT 系統。它回答了在災害情境中如何 足夠快地復原 的問題。
• DRP 生命週期： DRP 具有一個生命週期，包括 緩解 (Mitigation)、準備 (Preparation)、應對 (Response) 和 復原 (Recovery)。
  • 緩解： 減少災害影響和發生的可能性。
  • 準備： 開發計劃、程序和工具。
    • 復原考量： 評估供應商、承包商和基礎設施的影響。確保資料中心的功能和連接性。
    • 模擬測試： 用於在實際災害發生前找出計劃中的不足之處。
      • DRP 審查 (DRP Review)：DRP 團隊成員快速審查計劃，尋找明顯的遺漏或空白部分。
      • 通讀/清單檢查 (Read-Through/Checklist)：經理和各功能領域的員工通讀計劃，並檢查復原過程中所需的各項要素清單。
      • 演練/桌面演練 (Walk/Talk-through/Tabletop)：一組經理和關鍵人員坐下來討論復原過程。這通常可以暴露可能阻礙復原的漏洞、遺漏或技術不準確性。
      • 模擬測試/演練 (Simulation Test/Walkthrough Drill)：團隊模擬一個災害情境，各團隊根據 DRP 做出反應。
    • 實體測試 (Physical Tests)：
      • 部分中斷 (Partial Interruption)：中斷單一應用程式，並將其故障轉移到備用設施。通常在非上班時間進行。
  • 應對： 在災害發生時快速有效地做出反應。評估警報或發現的事件是否嚴重到可能構成災害。
  • 復原： 將系統恢復到可運行的狀態。

業務影響分析 (BIA)

• 目的： BIA 是 BCP 的一個組成部分。它用於識別關鍵業務功能及其對中斷的依賴性和影響。
• 關鍵指標： BIA 幫助定義了幾個關鍵的時間和數據指標，用於確定復原策略和目標:
  • 最大可容忍停機時間 (MTD - Maximum Tolerable Downtime)：系統在對組織造成嚴重影響之前可以停運的總時間。MTD 必須大於或等於 RTO + WRT。其他術語包括 MAD、MTO、MAO、MTPoD。請記住，經歷數據嚴重損失的公司，有 43% 永不再營業，29% 在兩年內關閉。
  • 復原時間目標 (RTO - Recovery Time Objective)：恢復系統（硬體）所需的時間。RTO 必須在 MTD 限制內。
  • 工作復原時間 (WRT - Work Recovery Time)：配置恢復的系統以恢復業務功能所需的時間。
  • 復原點目標 (RPO - Recovery Point Objective)：可以容忍丟失的數據量。RPO 必須確保每個系統、功能或活動的最大可容忍數據損失不被超過。
  • 平均故障間隔時間 (MTBF - Mean Time Between Failures)：系統在發生故障前的平均運行時間。
  • 平均修復時間 (MTTR - Mean Time to Repair)：修復故障系統所需的時間。
  • 最低營運要求 (MOR - Minimum Operating Requirements)：關鍵系統運行所需的最低要求。

復原策略 (Recovery Strategies)

根據 MTD，組織可以確定其應對災害的方法和採取的防範措施。主要的復原站點類型包括:

• 冗餘站點 (Redundant Site)：與生產站點完全相同，接收實時數據副本。具備自動故障轉移功能，應地理位置上遠離。這是最昂貴的選項，使用者不會注意到故障轉移。
• 熱站點 (Hot Site)：容納關鍵系統，數據接近實時或實時。通常是較小的完整數據中心，但需手動故障轉移。切換可以在一小時內完成。
• 溫站點 (Warm Site)：基於備份的數據，需要手動故障轉移。切換和恢復需要 4-24 小時或更長時間。通常是一個較小的完整數據中心，但沒有實時或近實時數據。
• 冷站點 (Cold Site)：只提供基礎設施，沒有硬體或備份。這是最便宜但復原時間最長的選項（可能需要數週或更長）。
• 互惠協議站點 (Reciprocal Agreement Site)：與另一組織簽訂合同，在災害發生時互相提供空間。可以是承諾的空間或完全獨立的機櫃。
• 訂閱/雲站點 (Subscription/Cloud Site)：支付外部提供商，根據服務等級協議 (SLA) 提供復原服務。
• 移動站點 (Mobile Site)：輪式數據中心，設備齊全。可能需要電源和網路連接。

事後檢討 (Lessons Learned)

• 在經歷中斷事件或故障轉移測試後，進行 事後檢討 非常重要。這個階段經常被忽略。
• 事後檢討應 專注於改進，而不是歸咎責任。
• 從中獲得的見解應被納入 BCP 和 DRP 的更新中。

計劃維護 (Plan Maintenance)

• BCP 和 DRP 是 疊代過程，需要 定期更新。
• 應 每年至少審查和更新一次。
• 取回並銷毀過期版本，分發當前版本。

事件管理 (Incident Management)

• 目的： 監控和應對安全事件。確保應對是可預測且眾所周知的。
• 事件類型： 事件可以分為幾類:
  • 自然災害 (Natural)：由自然引起，例如地震、洪水、龍捲風、雪災等。
  • 人為事件 (Human)：由人類引起。可以是 故意的 (Intentional)（如惡意軟體、恐怖主義、DOS 攻擊、駭客行動主義、釣魚等）或 無意的 (Unintentional)（如錯誤、疏忽、員工使用個人 USB 傳播惡意軟體等）。
  • 環境事件 (Environmental)：與自然災害不同。例如停電、硬體故障、環境控制問題（熱、壓力、濕度）等。
• 其他定義：
  • 事件 (Incident)：發生在系統或網路上的多個不利事件，通常由人引起。
  • 問題 (Problem)：起因不明的事件，需要進行根本原因分析以防止再次發生。
  • 不便 (Inconvenience)：非破壞性故障，如硬碟故障或伺服器集群中一台伺服器宕機。
  • 緊急情況/危機 (Emergency/Crisis)：具有潛在生命或財產損失風險的緊急事件。
  • 災害 (Disaster)：整個設施在 24 小時或更長時間內無法使用。如果具備地理分散和冗餘，可以極大緩解這種情況。雪災也可以是災害。
  • 浩劫 (Catastrophe)：設施被摧毀。
• 事件管理步驟： 標準的事件管理流程包括:
  • 偵測 (Detection)：識別潛在的安全事件。
  • 應對 (Response)：採取初步行動來遏制事件。
  • 緩解 (Mitigation)：理解並解決事件的根本原因。
  • 報告 (Reporting)：記錄事件細節並通知管理層。報告是持續的，從偵測到惡意活動就開始。報告分為技術和非技術兩方面。
  • 復原 (Recovery)：將系統恢復到可運行的狀態。
  • 補救 (Remediation)：在系統間擴大緩解措施。
  • 事後檢討 (Lessons Learned)：分析和改進未來的應對措施。包括 根本原因分析 (Root-Cause Analysis)，試圖確定導致事件發生的潛在弱點或漏洞。
• 網路事件應變小組 (CIRT - Cyber Incident Response Team)：通常包括高階管理層、事件經理、技術負責人及團隊、IT 安全人員、公關、人資、法務以及 IT/財務稽核師。

常見的威脅和問題 (Common Threats and Issues)

• 錯誤和遺漏 (Errors and Omissions - 人為)：員工的錯誤，通常影響較小，但可能造成損害。如果這些問題被認為非常常見或具有潛在破壞性，可以建立控制措施來緩解它們。
• 電氣/電力問題 (Electrical/Power Problems - 環境)：停電和電壓波動。需要不斷電系統 (UPS) 和發電機備份。
• 環境控制 (Environmental Controls)：管理資料中心的熱、壓力、濕度以保護硬體。正壓保持外部污染物不進入。濕度應保持在 40% 到 60% 之間，低濕度會產生靜電，高濕度會腐蝕金屬（電子設備）。
• 戰爭、恐怖主義和蓄意破壞 (Warfare, Terrorism, and Sabotage - 人為)：除了傳統衝突外，還有許多發生在網路上的活動，駭客攻擊為了各種原因（國家、宗教等）。

希望這個詳細的解釋對您有所幫助！

CIA 被認為是資訊安全領域非常重要的基礎。其核心內容構成了其他知識網域的基礎。此網域涵蓋了資訊安全、IT 安全和網路安全之間的區別、CIA 三要素、IAAA、隱私、風險管理、存取控制、道德規範、治理與管理以及法律與規範。

資訊安全、IT 安全和網路安全之間的區別：

• 資訊安全 (Information Security)：保護所有類型的資訊，包括紙本文件和語音資料。
• IT 安全 (IT Security)：保護硬體、軟體和資料，例如電腦和網路系統。
• 網路安全 (Cybersecurity)：特別保護可透過網際網路存取的 IT 系統。

CIA 三要素：機密性、完整性和可用性。

• (Confidentiality)
• (Integrity)
• (Availability)

• 機密性 (Confidentiality)：這是許多人對 IT 安全的主要理解。我們保持資料和機密資訊的秘密。確保未經授權的人員無法存取資料。威脅包括揭露 (Disclosure)，即未經授權地存取資訊。為實現機密性，我們使用：
  • 加密：用於靜態資料（例如 AES256、全磁碟加密） 和傳輸中的資料（例如安全的傳輸加密協定 SSL、TLS）。
  • 存取控制。
• 完整性 (Integrity)：保護資料和系統免受修改。確保資料未被更改。威脅包括變更 (Alteration)，即未經授權地更改資料。為實現完整性，我們使用：
  • 密碼學。
  • 檢查碼 (Check sums)，例如 CRC。
  • 訊息摘要 (Message Digests)，也稱為雜湊 (hash)，例如 MD5、SHA1 或 SHA2。
  • 數位簽章：提供不可否認性 (Non-repudiation)。
  • 存取控制。
  • 補丁管理。
• 可用性 (Availability)：確保被授權的人員在需要時可以存取所需的資料和系統。威脅包括惡意攻擊（如 DDOS、物理攻擊、系統入侵、員工攻擊）、應用程式故障（程式碼錯誤）和組件故障（硬體故障）。未能提供可用性可能導致銷毀 (Destruction)，即資料或系統被破壞或無法存取。為實現可用性，我們使用：
  • IPS/IDS (入侵防禦系統/入侵偵測系統)。
  • 補丁管理。
  • 冗餘 (Redundancy)：在硬體電源（多個電源供應器、UPS、發電機）、磁碟（RAID）、流量路徑（網路設計）、HVAC、人員、HA (高可用性) 等方面實現。
  • SLA (服務級別協議)：定義所需的正常執行時間（例如 99.9%）。

DAD (Disclosure, Alteration, and Destruction) 是 CIA 三要素的對立面。

IAAA：識別 (Identification)、身份驗證 (Authentication)、授權 (Authorization) 和當責 (Accountability)。

• 識別：宣告身份。範例包括使用者名稱、ID 號碼或員工社會安全碼。「我是Elliot」即為識別的範例。
• 身份驗證：證明身份。「證明你是Elliot」。應該始終使用多因素身份驗證。身份驗證因素通常分為三種類型：
  • 類型 1：知識因素 (Knowledge factors)：你知道的東西。例如密碼、通行碼、PIN 碼。這是最常用的身份驗證形式。組織應執行密碼政策來增強安全性：建議最低長度為 8 個字元，包含大小寫字母、數f字和符號，定期更新且不重複使用（例如記住最後 24 個密碼，最長使用期 90 天，最短使用期 2 天）。金鑰延展 (Key stretching) 可延遲密碼驗證，阻礙暴力破解。
  • 類型 2：持有因素 (Possession factors)：你擁有的東西。例如 ID、智慧卡、權杖、電腦上的 Cookie。
  • 類型 3：生物特徵因素 (Biometric factors)：你是誰。例如指紋、虹膜掃描、面部幾何形狀。生物特徵可以是生理性（如指紋）或行為性（如打字節奏）。生物特徵驗證涉及錯誤率：
    • FRR (False Rejection Rate)：錯誤拒絕授權使用者。
    • FAR (False Acceptance Rate)：錯誤接受未授權使用者。
    • CER (Crossover Error Rate)：FRR 和 FAR 達到最佳平衡的點。
  • 使用生物特徵驗證需要考慮隱私問題（揭示個人資訊）和安全風險（可能被偽造）。生物特徵資料一旦洩漏，比密碼更難替換。
• 授權：決定主體被允許存取什麼。我們使用存取控制模型來實現授權。主要原則包括最小權限 (Least Privilege) 和需要知道 (Need to Know)。
  • 最小權限：員工或系統只獲得其角色所需的最低必要存取權限。不多也不少。
  • 需要知道：即使你有存取權限，如果你的工作不需要知道該資訊，你就不應該存取它。
  • 職責分離 (Separation of Duties)：將單一任務分配給多個不同的人員來執行，以防止詐欺和錯誤。在小型組織不切實際時，應實施補償性控制。
  • 存取控制模型包括：
    • DAC (Discretionary Access Control)：通常用於可用性最重要時。存取權限由物件擁有者自行決定。擁有者可以使用 DACL (Discretionary ACL) 授予或撤銷權限。大多數作業系統廣泛使用此模型。
    • MAC (Mandatory Access Control)：通常用於機密性最重要時。存取權限基於標籤和許可等級。物件被分配標籤，主體的許可等級必須支配物件的標籤。這常應用於軍事或高度重視機密性的組織。標籤可以比「最高機密」更細緻，例如「最高機密 – 核子」。許可等級基於對主體當前和未來能力的正式決定。
    • RBAC (Role-Based Access Control)：通常用於完整性。存取權限基於使用者的角色和權限。這有助於簡化使用者管理。例如，薪資部門的員工獲得薪資相關存取權限，調到 HR 部門後則獲得 HR 相關權限。
    • ABAC (Attribute-Based Access Control)：存取權限基於主體、物件和環境的屬性和條件。屬性可以包括主體（姓名、角色、ID、許可等級）、物件（姓名、擁有者、建立日期）和環境（位置、時間、威脅級別）。此模型預計未來幾年內在大型企業中廣泛採用。它也被稱為策略導向存取控制 (PBAC) 或聲明導向存取控制 (CBAC)。
    • 情境相關存取控制 (Context-Based Access Control)：存取權限基於特定的情境參數，例如位置、時間、回應順序或存取歷史。範例包括要求 CAPTCHA 回應、基於 MAC 位址過濾無線存取，或防火牆基於封包分析過濾資料。
    • 內容相關存取控制 (Content-Based Access Control)：存取權限基於物件的屬性或內容。例如，應用程式中隱藏或顯示選單、資料庫中的檢視或對機密資訊的存取權限都屬於此類。
• 當責 ：確保行動可追溯到執行者。提供不可否認性，確保使用者不能否認自己執行了某項特定行動。透過稽核軌跡 (Audit Trails) 記錄行動。

隱私 (Privacy)：

• 定義：免受觀察或干擾的自由。保護個人免受未經授權的侵入。
• 權利：隱私是一種人權。包括保護個人身份資訊 (PII)。
• 規範：
  • 美國：法律零散，覆蓋範圍不一致。
  • 歐盟：對資料收集、使用和儲存有嚴格規定。
  • GDPR (General Data Protection Regulation)：歐盟的資料保護和隱私法規。適用於所有處理歐盟/歐洲經濟區個人資料的組織，無論其位於何處。GDPR 對於違反者有嚴格的罰款。GDPR 賦予個人多項權利，包括存取權（資料控制者必須免費提供個人資料副本）、被遺忘權（資料刪除權）、資料可攜性（以電子格式獲取資料）。要求在資料洩露發生後 72 小時內通知使用者和資料控制者。強調設計內建隱私 (Privacy by Design)，在設計資料處理過程時，應確保個人資料的安全，並確保只收集完成任務絕對必要的資料。要求某些公司任命資料保護官 (Data protection officers)。

風險管理 (Risk Management)：

• 風險管理生命週期是迭代的過程。包括識別、評估、回應與緩解和監控階段。
• 風險公式：
  • 風險 = 威脅 * 弱點（或可能性）。
  • 我們也可以使用風險 = 威脅 * 弱點 * 影響。
  • 總風險 (Total Risk) = 威脅 * 弱點 * 資產價值 (Asset Value)。
  • 殘餘風險 (Residual Risk) = 總風險 – 對策 (Countermeasures)。
• 組成部分：
  • 威脅 (Threat)：可能導致損害的事件。
  • 弱點 (Vulnerability)：允許威脅利用並造成損害的弱點。
  • 資產價值 (Asset Value, AV)：資產的價值。
  • 應盡職責 (Due Diligence, DD)：實施前的研究。例如，在實施安全措施之前進行研究。縮寫為「Do Detect」。
  • 應盡關懷 (Due Care, DC)：實施安全措施。是應盡職責的實施。縮寫為「Do Correct」。
• 風險評估：
  • 定性分析 (Qualitative Analysis)：評估風險的可能性和影響。通常使用風險矩陣將風險分類（如低、中、高、極高）。
  • 定量分析 (Quantitative Analysis)：基於成本的風險評估。涉及計算損失預期。
    • 暴露因素 (Exposure Factor, EF)：資產損失的百分比。
    • 單一損失預期 (Single Loss Expectancy, SLE) = AV x EF：事件發生一次的成本。例如，遺失價值 $1000 的筆記型電腦（AV）包含 $10000 的 PII（AV），如果遺失是 100%（EF），則 SLE = ($1000 + $10000) x 100% = $11000。來源使用不同的 AV 範例，僅為筆記型電腦價值 $1000 加上 PII 損失 $10000。
    • 年度發生率 (Annual Rate of Occurrence, ARO)：事件每年發生的頻率。例如，組織每年遺失 25 台筆記型電腦。
    • 年度損失預期 (Annualized Loss Expectancy, ALE) = SLE x ARO：如果不採取任何措施，每年預期的成本。例如，ALE = $11000 x 25 = $275000。
    • 總擁有成本 (Total Cost of Ownership, TCO)：緩解措施的總成本（前期成本 + 持續成本）。
• 風險回應 (Risk Responses)：處理風險的選項。
  • 接受風險 (Accept the Risk)：知道風險存在，但緩解成本高於風險成本（通常用於低風險）。
  • 緩解風險 (Mitigate the Risk, Reduction)：實施控制措施將風險降低到可接受的水準。剩餘的風險即為殘餘風險。例如，對筆記型電腦實施加密或遠端清除。
  • 轉移風險 (Transfer the Risk)：將風險轉移給第三方，例如透過購買保險。
  • 避免風險 (Risk Avoidance)：修改計劃或活動以完全避免風險。例如，不向員工發放筆記型電腦（如果可能），或在不會發生水災的區域建造資料中心。
  • 拒絕風險 (Risk Rejection)：知道風險存在但選擇忽視它。這是不可接受的回應策略。
• 監控與報告：風險管理是一個持續的過程。需要持續監控風險和已實施的控制措施。可以利用主要風險指標 (KRI) 和主要績效指標 (KPI)。通常每年進行風險管理生命週期評估，並對關鍵項目進行週期外評估。

存取控制類別和類型。

• 存取控制類別：控制如何保護資產或資源。
  • 行政控制 (Administrative Controls, Directive Controls)：透過政策、程序和訓練來管理安全性。例如組織政策、規範、訓練和意識。
  • 技術控制 (Technical Controls, Logical Controls)：透過硬體、軟體或韌體來實施安全性。例如防火牆、路由器和加密。
  • 實體控制 (Physical Controls)：透過實體措施限制或監控存取。例如鎖、圍籬、警衛、門和防撞柱。
• 存取控制類型：描述控制的功能或目的。同一控制可能屬於多種類型。
  • 預防性控制 (Preventative Controls)：在行動發生之前阻止它們。例如最小權限、藥物測試、IPS、防火牆、加密。
  • 偵測性控制 (Detective Controls)：在事件發生期間或之後識別行動。例如 IDS、CCTV、警報、防毒軟體。
  • 矯正性控制 (Corrective Controls)：在事件發生後修復問題。例如防毒軟體、補丁、IPS。
  • 復原性控制 (Recovery Controls)：在事件發生後協助復原。例如災難復原環境、備份、高可用性環境。
  • 嚇阻性控制 (Deterrent Controls)：阻礙行動。例如圍籬、保全警衛、狗、燈光、「小心惡犬」標誌。
  • 補償性控制 (Compensating Controls)：在無法實施主要控制或成本過高時提供替代方案。

道德規範：

• ISC2 道德規範：保護社會、正直誠信地行動、提供專業服務、推進專業發展。
• 電腦道德：不使用電腦傷害他人、不干涉他人電腦工作、不偷窺他人檔案、不使用電腦偷竊、不使用盜版軟體、不使用他人電腦資源而未經授權或補償、不侵佔他人智慧財產、思考所寫程式或設計系統的社會影響、永遠以確保考慮和尊重他人權利的方式使用電腦。
• 組織道德：需要了解並遵守自己組織內部的道德規範。

治理與管理：

• 治理 (Governance)：設定目標、監控績效、定義風險容忍度。由高階主管負責。
• 管理 (Management)：規劃和執行活動以達成治理設定的目標。在治理設定的方向內運作。
• C 級主管 (C-Level Executives) 對於安全負有最終責任。需要了解的 C 級主管包括 CEO、CIO、CTO、CSO、CISO 和 CFO。

法律與規範：

• 法律類型：
  • 刑事法 (Criminal Law)：目的是懲罰並嚇阻對社會有害的行為。「社會」是受害者。證明標準為「排除合理懷疑」。刑罰可能包括監禁、死刑或罰款。
  • 民法 (Civil Law, Tort Law)：目的是賠償受害者。個人、團體或組織是受害者。證明標準為「大多數證據」。賠償通常是財務罰款。
  • 行政法 (Administrative Law)：政府制定的規範。例如 HIPAA。
  • 私人規範 (Private Regulations)：合約要求。例如 PCI-DSS。
  • 習慣法 (Customary Law)：基於傳統。
  • 宗教法 (Religious Law)：基於信仰。
• 關鍵規範：
  • HIPAA (Health Insurance Portability and Accountability Act)：美國關於健康資訊隱私的法律。
  • ECPA (Electronic Communications Privacy Act)：保護電子通訊。
  • PATRIOT Act (Uniting and Strengthening America by Providing Appropriate Tools Required to Intercept and Obstruct Terrorism Act)：擴大執法機構的能力。
  • CFAA (Computer Fraud and Abuse Act)：起訴電腦犯罪。
  • GDPR：如前所述，歐盟的資料保護法規。

資訊安全治理：價值觀、願景、使命和計劃。

• 治理原則包括：
  • 價值觀：我們的價值是什麼？包括道德、原則和信念。
  • 願景：我們渴望成為什麼？代表希望和抱負。
  • 使命：我們為誰服務？代表動機和目的。
  • 策略目標：我們將如何進步？包括計劃、目標和排序。
  • 行動與 KPI：我們需要做什麼以及如何知道我們是否達成目標？包括行動、資源、結果、負責人和時間框架。
• 安全治理文件類型：
  • 政策 (Policies)：強制性，高層次且非特定。可能包含「補丁、更新、強加密」等，但不指定具體的作業系統、加密類型或供應商技術。
  • 標準 (Standards)：強制性，描述特定技術的使用。例如，所有筆記型電腦必須是 W10、64 位元、8GB 記憶體等。
  • 指引 (Guidelines)：非強制性，提供建議或酌情處理的方式。
  • 程序 (Procedures)：強制性，低層次的逐步指南，非常特定。會指定具體的作業系統、加密類型或供應商技術。

以上是根據來源資料對網域 1 內容的詳細概述。

Code Snapshot: Connection Borrowing Logic

Here’s a key piece of HikariCP internals when a thread tries to borrow a connection from the pool:

1
2
3
4
5
6
7
8

// ②
// Get a connection from the pool, with a timeout
final PoolEntry poolEntry = connectionBag.borrow(timeout, MILLISECONDS);

// The borrow method returns null only if it times out
if (poolEntry == null) {
  break; // We timed out... break and throw exception
}

This code attempts to borrow a connection from the internal connectionBag. If it doesn’t succeed within the specified timeout, it returns null, and the calling code exits the loop and throws an exception.

Behind the Scenes: What’s connectionBag?

The connectionBag is a custom concurrent structure used by HikariCP to manage connections. Internally, it uses a CopyOnWriteArrayList to store available PoolEntry objects.

Why Use CopyOnWriteArrayList?

CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (like add, remove) are implemented by making a fresh copy of the underlying array. It shines in situations where:

• Reads are far more frequent than writes.
• Thread safety is critical, but locking overhead must be minimized.

This fits HikariCP’s use case perfectly—connections are borrowed and returned frequently under high concurrency, and most operations are reads (checking for available connections).

What Happens During borrow()?

The borrow() method performs the following steps:

1. Iterates over the CopyOnWriteArrayList of available connections.
2. Tries to atomically claim one via compareAndSet.
3. If no connection is immediately available, it waits until:
   • A connection is returned.
   • The timeout expires.

Thanks to CopyOnWriteArrayList, multiple threads can safely iterate and borrow connections without the risk of ConcurrentModificationException or complex locking strategies.

Timeout Behavior

If no connection is available within the timeout window:

1
2
3

if (poolEntry == null) {
  break; // We timed out... break and throw exception
}

The system recognizes that it’s better to fail fast than to block indefinitely. This ensures predictability and avoids resource starvation under load.

Trade-offs of CopyOnWriteArrayList

While CopyOnWriteArrayList is great for safe, lock-free reads, it does have drawbacks:

• Writes (adds/removes) are costly since the array is copied.
• It’s not ideal if the list is modified very frequently.

In HikariCP’s case, connection availability doesn’t change every millisecond—so this trade-off is acceptable and even advantageous.

Takeaways

• CopyOnWriteArrayList plays a crucial role in enabling fast, concurrent access to connection entries in HikariCP.
• It ensures safety and performance without heavyweight synchronization.
• The timeout logic provides a safety net to prevent system hangs under high load.

Final Thoughts

This case study shows how a seemingly simple collection choice—like CopyOnWriteArrayList—can dramatically influence the performance and reliability of a high-throughput system like HikariCP. It’s a perfect example of using the right tool for the job in a multithreaded environment.

HikariCP Case Study: Understanding FAUX_LOCK

HikariCP, a high-performance JDBC connection pool, is renowned for its minimalist design and efficient concurrency handling. One of its clever optimizations is the FAUX_LOCK, a no-op (no operation) implementation of the SuspendResumeLock class. In this short case study, we’ll explore the purpose of FAUX_LOCK, its implementation, and how it leverages JIT (Just-In-Time) compilation to boost performance.

What is FAUX_LOCK?

The SuspendResumeLock class in HikariCP manages the suspension and resumption of connection acquisition, typically during pool maintenance or shutdown. The FAUX_LOCK is a static instance of SuspendResumeLock that overrides its methods—acquire, release, suspend, and resume—to do nothing:

1
2
3
4
5
6
7
8
9
10

public static final SuspendResumeLock FAUX_LOCK = new SuspendResumeLock(false) {
    @Override
    public void acquire() {}
    @Override
    public void release() {}
    @Override
    public void suspend() {}
    @Override
    public void resume() {}
};

This “fake” lock acts as a placeholder when actual locking is unnecessary, minimizing overhead in high-performance scenarios.

Why Use FAUX_LOCK?

HikariCP is designed for speed, and every cycle matters in high-throughput applications. The FAUX_LOCK is used when the pool is configured to operate without suspension or locking, specifically when allowPoolSuspension is false (the default). Its key purposes are:

1. Single-Threaded or Non-Suspended Pools: When pool suspension is disabled, there’s no need for lock operations. FAUX_LOCK eliminates synchronization overhead.
2. Simplified Code Path: Using FAUX_LOCK avoids conditional logic to check whether locking is needed, maintaining a consistent SuspendResumeLock interface.
3. Performance Optimization: By providing empty method implementations, FAUX_LOCK reduces the cost of lock operations to zero.

JIT Optimization: The Hidden Benefit

So, what’s the real advantage of this approach? When pool suspension is disabled, FAUX_LOCK provides an empty implementation, with the expectation that the JVM’s Just-In-Time (JIT) compiler will optimize it away. Each call to acquire, release, suspend, or resume is an empty method that does nothing. After the code runs multiple times, the JIT compiler may recognize these methods as no-ops and inline or eliminate them entirely.

This means that, over time, the overhead of calling these methods disappears. When acquiring a connection, the application skips the token acquisition step entirely, as the JIT-optimized code bypasses the empty method calls. This results in significant performance savings, especially in high-concurrency scenarios where connection acquisition is frequent.

When is FAUX_LOCK Used?

FAUX_LOCK is employed when allowPoolSuspension is false. In this mode, HikariCP does not support suspending the pool for tasks like shrinking or reaping idle connections. By using FAUX_LOCK, calls to lock-related methods become no-ops, allowing HikariCP to focus solely on connection management. For example, in a web application with a fixed pool size and no need for suspension, FAUX_LOCK ensures minimal overhead.

Benefits of FAUX_LOCK

• Zero Overhead: Empty methods eliminate lock-related costs, and JIT optimization may remove them entirely.
• Code Simplicity: A consistent SuspendResumeLock interface avoids complex branching logic.
• Flexibility: Supports both high-performance (with FAUX_LOCK) and maintenance-friendly modes (with a real lock).
• Performance Boost: JIT-eliminated method calls reduce connection acquisition time.

Considerations

FAUX_LOCK is ideal for performance-critical applications but unsuitable when pool suspension is needed (e.g., for dynamic resizing). Enabling allowPoolSuspension requires a real SuspendResumeLock, and misconfiguration could disrupt pool maintenance.

Conclusion

The FAUX_LOCK in HikariCP is a brilliant optimization that showcases how small design choices can yield big performance gains. By providing a no-op lock and leveraging JIT compilation to eliminate method call overhead, FAUX_LOCK ensures HikariCP remains blazingly fast in non-suspended pools. For developers, this underscores the importance of aligning HikariCP’s configuration with application requirements to unlock its full potential.

When configuring your HikariCP pool, check if allowPoolSuspension is necessary. If not, FAUX_LOCK and JIT optimization will work behind the scenes to make your application faster and more efficient.

HikariCP Case Study: Understanding the getConnection Semaphore

One of its key mechanisms for managing connections efficiently is the use of a Semaphore in the getConnection method. In this case study, we’ll dive into how HikariCP leverages Semaphore to manage database connections, ensuring thread safety and optimal resource utilization.

Background on HikariCP

HikariCP is a JDBC connection pool designed for speed and simplicity. Unlike traditional connection pools that may rely on heavy synchronization or complex locking mechanisms, HikariCP uses modern concurrency utilities from Java’s java.util.concurrent package, such as ConcurrentBag and Semaphore, to achieve low-latency connection management.

The getConnection method is the primary entry point for applications to acquire a database connection from the pool. This method must balance speed, thread safety, and resource constraints, especially under high concurrency. The use of a Semaphore in this context is critical to controlling access to the finite number of connections.

The Role of Semaphore in getConnection

In HikariCP, a Semaphore is used to limit the number of threads that can simultaneously attempt to acquire a connection from the pool. A Semaphore is a concurrency primitive that maintains a set of permits. Threads must acquire a permit to proceed, and if no permits are available, they block until one is released.

Here’s how HikariCP employs a Semaphore in the getConnection process:

1. Connection Acquisition Limit: The Semaphore is initialized with a number of permits corresponding to the maximum pool size (maximumPoolSize). This ensures that no more than the configured number of connections are ever allocated.

2. Thread Safety: When a thread calls getConnection, it must first acquire a permit from the Semaphore. This prevents excessive threads from overwhelming the pool or attempting to create new connections beyond the pool’s capacity.

3. Timeout Handling: HikariCP’s getConnection method supports a timeout parameter (connectionTimeout). If a thread cannot acquire a permit within this timeout, the Semaphore’s tryAcquire method fails, and HikariCP throws a SQLException, informing the application that no connection is available.

4. Efficient Resource Management: Once a connection is acquired or created, the thread proceeds to use it. After the connection is returned to the pool (via close), the permit is released back to the Semaphore, allowing another thread to acquire a connection.

This approach ensures that HikariCP remains both thread-safe and efficient, avoiding the overhead of traditional locking mechanisms like synchronized blocks.

Case Study: High-Concurrency Scenario

Let’s consider a real-world scenario where a web application handles thousands of concurrent requests, each requiring a database connection. Without proper concurrency control, the application could exhaust the database’s connection limit, leading to errors or crashes. Here’s how HikariCP’s Semaphore-based getConnection handles this:

Setup

• HikariCP Configuration:
  • maximumPoolSize: 20
  • connectionTimeout: 30000ms (30 seconds)
  • minimumIdle: 5
• Application: A Java-based REST API using Spring Boot, handling 1000 concurrent requests.
• Database: PostgreSQL with a maximum of 100 connections.

Observations

1. Initial State: The pool starts with 5 idle connections (as per minimumIdle). The Semaphore has 20 permits available, corresponding to maximumPoolSize.

2. Spike in Requests: When 1000 requests hit the API simultaneously, each thread calls getConnection. The Semaphore ensures that only 20 threads can proceed at a time. Other threads wait for permits to become available.

3. Connection Reuse: As threads complete their database operations and return connections to the pool, permits are released. Waiting threads acquire these permits and reuse existing connections, preventing the need to create new ones unnecessarily.

4. Timeout Behavior: If the pool is fully utilized and no connections are available within 30 seconds, threads that cannot acquire a permit receive a SQLException. This allows the application to gracefully handle overload scenarios, perhaps by retrying or returning an error to the client.

Results

• Stability: The Semaphore prevented the pool from exceeding 20 connections, avoiding overwhelming the PostgreSQL server.
• Performance: Connection reuse and efficient concurrency control minimized latency, with most requests served within milliseconds.
• Error Handling: Threads that timed out received clear exceptions, allowing the application to implement fallback logic.

Code Example

Below is a simplified view of how HikariCP’s getConnection logic might look, focusing on the Semaphore usage:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class HikariPool {
    private final Semaphore connectionSemaphore;
    private final int maxPoolSize;
    private final long connectionTimeout;

    public HikariPool(int maxPoolSize, long connectionTimeoutMs) {
        this.maxPoolSize = maxPoolSize;
        this.connectionTimeout = connectionTimeoutMs;
        this.connectionSemaphore = new Semaphore(maxPoolSize, true);
    }

    public Connection getConnection() throws SQLException {
        try {
            // Attempt to acquire a permit within the timeout
            if (!connectionSemaphore.tryAcquire(connectionTimeout, TimeUnit.MILLISECONDS)) {
                throw new SQLException("Connection timeout after " + connectionTimeout + "ms");
            }
            // Logic to acquire or create a connection from the pool
            return acquireConnection();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new SQLException("Interrupted while waiting for connection", e);
        } finally {
            // Release the permit back to the semaphore after returning the connection
            connectionSemaphore.release();
        }
    }

    private Connection acquireConnection() {
        // Placeholder for actual connection acquisition logic
        return null;
    }
}

This example illustrates the Semaphore’s role in controlling access to the connection pool. In the actual HikariCP implementation, additional optimizations like the ConcurrentBag for connection storage and housekeeping threads for pool maintenance further enhance performance.

Advantages of Using Semaphore

• Lightweight Concurrency: Compared to traditional locks, Semaphore provides a more flexible and lightweight mechanism for controlling access.
• Fairness: HikariCP’s Semaphore is configured to be fair, ensuring that threads are served in the order they request permits, reducing starvation.
• Timeout Support: The ability to specify a timeout for permit acquisition aligns with HikariCP’s focus on predictable behavior under load.
• Scalability: The Semaphore scales well under high concurrency, allowing HikariCP to handle thousands of requests efficiently.

Challenges and Considerations

While the Semaphore-based approach is highly effective, there are some considerations:

1. Configuration Tuning: The maximumPoolSize and connectionTimeout must be carefully tuned based on the application’s workload and the database’s capacity. Setting maximumPoolSize too high can overwhelm the database, while setting it too low can lead to timeouts.

2. Timeout Handling: Applications must be prepared to handle SQLExceptions caused by timeouts, possibly with retry logic or user-friendly error messages.

3. Monitoring: Under high load, monitoring the pool’s metrics (e.g., active connections, wait time) is crucial to detect bottlenecks or misconfigurations.

Conclusion

HikariCP’s use of a Semaphore in the getConnection method is a brilliant example of leveraging Java’s concurrency utilities to build a high-performance connection pool. By limiting concurrent access to connections, enforcing timeouts, and ensuring thread safety, the Semaphore enables HikariCP to deliver reliable and efficient database access in demanding environments.

For developers and architects, understanding this mechanism provides valuable insights into designing scalable systems. Properly configuring HikariCP and monitoring its behavior can make the difference between a sluggish application and one that performs flawlessly under pressure.

If you’re using HikariCP in your projects, take the time to review your pool configuration and consider how the Semaphore-based concurrency control impacts your application’s performance. With the right setup, HikariCP can be a game-changer for your database-driven applications.

HikariCP Source Code Analysis: HikariPool Initialization

HikariCP is a high-performance JDBC connection pool framework, and one of its core components is the HikariPool class. This article dives into the initialization process of HikariPool, focusing on the following line of code:

1

pool = fastPathPool = new HikariPool(this);

This line appears in the initialization flow of HikariDataSource or related configuration logic, serving as a critical step in creating the HikariCP connection pool. Below, we’ll analyze its meaning, context, and implementation details from the source code perspective.

1. Context: Background of HikariPool Creation

In HikariCP, HikariPool is the core class responsible for managing database connections, including their creation, recycling, borrowing, and destruction. When an application starts and configures a HikariDataSource, HikariCP initializes a HikariPool instance based on the provided configuration.

The line of code in question typically appears in the initialization logic of HikariDataSource, such as:

1
2
3
4
5

private void initializePool() {
    if (pool == null) {
        pool = fastPathPool = new HikariPool(this);
    }
}

Here, pool and fastPathPool are member variables of HikariDataSource, both pointing to the same HikariPool instance. Let’s break down what this code does.

2. Code Analysis: pool = fastPathPool = new HikariPool(this)

2.1 Key Components

• pool: A member variable in HikariDataSource that stores the HikariPool instance. It serves as the primary entry point for interacting with the connection pool.
• fastPathPool: Another member variable pointing to the same HikariPool instance. The name fastPathPool suggests a potential performance optimization (more on this- new HikariPool(this): Creates a new HikariPool instance, passing the current HikariDataSource (or its configuration object) as a parameter to the HikariPool constructor.
• this: Refers to the HikariDataSource or its related configuration object (e.g., HikariConfig), used to pass configuration details to the pool.

2.2 Why Two Variables?

Assigning the same HikariPool instance to both pool and fastPathPool may seem redundant, but it reflects a design choice for flexibility:

• pool: Acts as the primary reference to the connection pool, used in most scenarios.
• fastPathPool: Indicates a potential performance-optimized path (fast path). While fastPathPool currently points to the same object as pool, this design allows HikariCP to potentially switch to a more optimized pool implementation in specific scenarios without altering the external interface.

This approach provides HikariCP with the flexibility to evolve its internal implementation while maintaining compatibility.

3. HikariPool Constructor Analysis

To understand what new HikariPool(this) does, let’s examine the HikariPool constructor (simplified version):

1
2
3
4
5
6
7
8
9
10
11

public HikariPool(final HikariConfig config) {
    super(config);
    this.connectionTimeout = config.getConnectionTimeout();
    this.validationTimeout = config.getValidationTimeout();
    this.maxLifetime = config.getMaxLifetime();
    this.idleTimeout = config.getIdleTimeout();
    this.leakDetectionThreshold = config.getLeakDetectionThreshold();
    this.poolName = config.getPoolName();
    // Initialize other properties...
    initializeConnections();
}

3.1 Main Tasks of the Constructor

1. Inheritance and Configuration Setup:

   • HikariPool extends PoolBase, which handles foundational operations like creating and closing connections.
   • The constructor takes a HikariConfig object, extracts configuration parameters (e.g., maximum pool size, minimum idle connections, connection timeout), and assigns them to HikariPool member variables.

2. Connection Pool Initialization:

   • Calls initializeConnections() to create the initial set of database connections and populate the pool.
   • Starts background threads (e.g., HouseKeeper) to periodically check connection health, recycle idle connections, and perform other maintenance tasks.

3. Performance Optimization:

   • Uses efficient data structures like ConcurrentBag to manage connections, ensuring high concurrency and low-latency operations for borrowing and returning connections.

3.2 Role of the this Parameter

The this parameter (typically HikariDataSource or HikariConfig) provides the configuration details, such as:

• Database URL, username, and password
• Maximum pool size (maximumPoolSize)
• Minimum idle connections (minimumIdle)
• Connection timeout (connectionTimeout)
• Advanced settings (e.g., connection validation query, leak detection)

HikariPool uses these settings to determine how to initialize and manage connections.

4. Potential Role of fastPathPool

Although fastPathPool currently points to the same object as pool, its naming and design suggest performance optimization possibilities. Here are some speculations and insights:

• Fast Path Optimization: HikariCP might intend to use a specialized pool implementation in certain scenarios, potentially skipping checks (e.g., connection validation) for better performance.
• Dynamic Switching: The existence of fastPathPool allows HikariCP to dynamically switch to a more efficient pool implementation based on runtime conditions or configuration.
• Backward Compatibility: By maintaining both pool and fastPathPool, HikariCP can introduce new pool implementations without breaking existing code.

While fastPathPool’s full potential is not yet utilized, its design leaves room for future enhancements.

5. Conclusion

The line pool = fastPathPool = new HikariPool(this); is a pivotal part of HikariCP’s connection pool initialization. It creates a HikariPool instance and assigns it to both pool and fastPathPool, setting up the core component for managing database connections. The HikariPool constructor handles configuration parsing, pool initialization, and background maintenance tasks.

This code reflects HikariCP’s key strengths:

• High Performance: Efficient data structures and optimized logic ensure low latency and high throughput.
• Flexibility: The fastPathPool design allows for future performance enhancements.
• Simplicity: The initialization logic is clear and maintainable.

By analyzing this code, we gain insight into HikariCP’s connection pool creation process and appreciate its forward-thinking design. For those interested in diving deeper, exploring components like ConcurrentBag or HouseKeeper in the HikariCP source code can reveal even more about its robust implementation.

HikariCP case study 1 Thread Safety

HikariDataSource is a high-performance JDBC connection pooling library widely used in Java applications to manage database connections efficiently. This case study explores a critical aspect of HikariDataSource’s implementation: thread safety, focusing on how it ensures consistent behavior in high-concurrency environments.

Thread Safety in HikariDataSource

A key piece of code in HikariDataSource prevents the use of the connection pool after it has been closed:

1
2
3

if (isClosed()) {
    throw new SQLException("HikariDataSource " + this + " has been closed.");
}

This code checks whether the connection pool is closed. If isClosed() returns true, it throws an exception to prevent further operations. While this appears to be a simple check, it reveals important design considerations for thread safety.

The isClosed() Method

The isClosed() method is implemented as:

1

return isShutdown.get();

Here, isShutdown is a field defined as:

1

private final AtomicBoolean isShutdown = new AtomicBoolean();

The use of AtomicBoolean ensures that the isShutdown state is thread-safe, meaning its value remains consistent across multiple threads, even in high-concurrency scenarios. Java’s Atomic classes, such as AtomicBoolean, AtomicInteger, and AtomicLong, provide atomic operations that guarantee thread safety without explicit synchronization.

This design ensures that when the connection pool is closed, all threads can reliably detect this state, preventing race conditions or inconsistent behavior.

Why Thread Safety Matters

To understand why AtomicBoolean is necessary, we need to explore the root cause of thread safety issues.

Modern CPUs have multiple levels of caching: L1, L2, and L3 caches, which are exclusive to each CPU core, and main memory, which is shared across all cores. When a CPU core performs a computation, it loads data from main memory into its L1 cache for faster access. However, this caching mechanism can lead to inconsistencies across cores.

For example, if one thread updates the isShutdown value on one CPU core, that update may remain in the core’s L1 cache and not immediately propagate to other cores. As a result, other threads running on different cores might read an outdated value of isShutdown, leading to thread-unsafe behavior.

How AtomicBoolean Ensures Thread Safety

AtomicBoolean addresses this issue through the use of a volatile field:

1

private volatile int value;

The value field stores the boolean state (0 for false, 1 for true). The volatile keyword plays a crucial role in ensuring thread safety by enforcing the following:

1. Write Synchronization: When a thread modifies the value, the change is immediately written to main memory, bypassing the CPU cache.
2. Read Synchronization: When a thread reads the value, it always fetches the latest value from main memory, not from the CPU cache.

This ensures that all threads see a consistent value for isShutdown, regardless of which CPU core they are running on.

The Trade-Off of volatile

While volatile guarantees thread safety, it comes with a performance cost. Reading from and writing to main memory is significantly slower than accessing CPU caches. Therefore, using volatile introduces latency, which can impact performance in high-throughput systems.

This trade-off highlights an important lesson: volatile should only be used when thread safety is critical. In cases where a state variable is rarely updated or does not require real-time consistency, a non-volatile field might suffice to avoid the performance overhead.

Lessons from HikariCP’s Source Code

HikariCP’s use of AtomicBoolean demonstrates a careful consideration of thread safety in a high-performance system. However, this is just one example of the library’s low-level optimizations. Other aspects of HikariCP’s design include:

• Bytecode Size Control: HikariCP minimizes bytecode size to improve JVM optimization and reduce overhead.
• Concurrency Patterns: HikariCP employs advanced concurrency techniques, similar to those found in frameworks like Disruptor, which is known for its CPU cache-aware design and exceptional performance.

These optimizations show how understanding low-level details, such as CPU caching and memory synchronization, can lead to more efficient code. For developers, studying frameworks like HikariCP and Disruptor offers valuable insights into writing high-performance applications.

Takeaways

Reading HikariCP’s source code can feel like a deep dive into computer science fundamentals, from CPU caches to JVM optimizations. It serves as a reminder that the abstractions we use in high-level programming are built on intricate low-level mechanisms. As developers, investing time in understanding these details can help us write better, more efficient code.

Reflecting on this, I can’t help but think: All those naps I took in university lectures on operating systems and computer architecture? It’s time to pay them back by diving into the source code!

By learning from frameworks like HikariCP, we can bridge the gap between high-level programming and low-level optimizations, ultimately becoming better engineers.