1
2
3
4
5
6

# 從 GitHub 下載最新版本
# https://github.com/BloodHoundAD/SharpHound/releases

# 或者使用 PowerShell 直接下載
Invoke-WebRequest -Uri "https://github.com/BloodHoundAD/SharpHound/releases/latest/download/SharpHound-v2.0.0.zip" -OutFile "SharpHound.zip"
Expand-Archive -Path "SharpHound.zip" -DestinationPath ".\SharpHound"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 執行預設收集（Default）
.\SharpHound.exe

# 指定收集方法
.\SharpHound.exe --collectionmethods All

# 收集特定類型的資料
.\SharpHound.exe --collectionmethods DCOnly
.\SharpHound.exe --collectionmethods Session
.\SharpHound.exe --collectionmethods LoggedOn
.\SharpHound.exe --collectionmethods Trusts
.\SharpHound.exe --collectionmethods ACL
.\SharpHound.exe --collectionmethods ObjectProps

 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

# 指定網域
.\SharpHound.exe --domain corp.local

# 指定 Domain Controller
.\SharpHound.exe --domaincontroller dc01.corp.local

# 使用 LDAPS（加密連線）
.\SharpHound.exe --secureldap

# 排除 Domain Controller
.\SharpHound.exe --excludedcs

# 設定執行緒數量
.\SharpHound.exe --threads 50

# 設定 Jitter（隨機延遲，用於規避偵測）
.\SharpHound.exe --jitter 20

# 指定輸出目錄
.\SharpHound.exe --outputdirectory C:\Temp\BloodHound

# 指定輸出檔案前綴
.\SharpHound.exe --outputprefix corp_audit

# 循環收集 Session 資訊
.\SharpHound.exe --collectionmethods Session --loop --loopduration 02:00:00

1
2
3
4
5
6

# 使用 runas 以不同使用者身份執行
runas /netonly /user:CORP\username "SharpHound.exe --collectionmethods All"

# 或者使用 PowerShell 建立憑證
$cred = Get-Credential
Start-Process -FilePath ".\SharpHound.exe" -ArgumentList "--collectionmethods All" -Credential $cred

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 安裝 bloodhound.py
pip install bloodhound

# 基本收集
bloodhound-python -u username -p 'password' -d corp.local -ns 10.10.10.1 -c All

# 使用 LDAPS
bloodhound-python -u username -p 'password' -d corp.local -ns 10.10.10.1 -c All --ssl

# 使用 Kerberos 認證
bloodhound-python -u username -p 'password' -d corp.local -ns 10.10.10.1 -c All -k

# 使用 NTLM 雜湊
bloodhound-python -u username --hashes :NTLM_HASH -d corp.local -ns 10.10.10.1 -c All

# 指定收集方法
bloodhound-python -u username -p 'password' -d corp.local -ns 10.10.10.1 -c DCOnly
bloodhound-python -u username -p 'password' -d corp.local -ns 10.10.10.1 -c Group,LocalAdmin,Session

1
2
3
4
5
6
7
8

20251127093000_BloodHound.zip
├── 20251127093000_computers.json
├── 20251127093000_containers.json
├── 20251127093000_domains.json
├── 20251127093000_gpos.json
├── 20251127093000_groups.json
├── 20251127093000_ous.json
└── 20251127093000_users.json

1
2
3
4
5
6
7
8

# 下載 Neo4j Community Edition
# https://neo4j.com/download-center/

# 或使用 Chocolatey 安裝
choco install neo4j-community

# 安裝完成後，啟動 Neo4j 服務
neo4j console

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 添加 Neo4j 儲存庫
wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
echo 'deb https://debian.neo4j.com stable 4.4' | sudo tee /etc/apt/sources.list.d/neo4j.list

# 安裝 Neo4j
sudo apt-get update
sudo apt-get install neo4j

# 啟動服務
sudo systemctl start neo4j
sudo systemctl enable neo4j

# 檢查狀態
sudo systemctl status neo4j

 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

# 使用 Docker 執行 Neo4j
docker run -d \
    --name neo4j \
    -p 7474:7474 \
    -p 7687:7687 \
    -e NEO4J_AUTH=neo4j/bloodhound \
    -v neo4j_data:/data \
    neo4j:4.4

# 使用 Docker Compose
cat > docker-compose.yml << 'EOF'
version: '3'
services:
  neo4j:
    image: neo4j:4.4
    container_name: neo4j-bloodhound
    ports:
      - "7474:7474"
      - "7687:7687"
    environment:
      - NEO4J_AUTH=neo4j/bloodhound
      - NEO4J_dbms_memory_heap_initial__size=1G
      - NEO4J_dbms_memory_heap_max__size=1G
    volumes:
      - neo4j_data:/data
volumes:
  neo4j_data:
EOF

docker-compose up -d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 編輯 Neo4j 設定檔
sudo nano /etc/neo4j/neo4j.conf

# 調整記憶體設定
dbms.memory.heap.initial_size=1G
dbms.memory.heap.max_size=2G
dbms.memory.pagecache.size=1G

# 允許遠端連線（如果需要）
dbms.default_listen_address=0.0.0.0

# 設定 Bolt 連線
dbms.connector.bolt.listen_address=:7687
dbms.connector.bolt.enabled=true

# 重啟服務
sudo systemctl restart neo4j

1
2
3
4
5
6
7
8

# 使用 cypher-shell 測試連線
cypher-shell -u neo4j -p bloodhound

# 執行簡單查詢
MATCH (n) RETURN COUNT(n);

# 退出
:exit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 從 GitHub 下載最新版本
# https://github.com/BloodHoundAD/BloodHound/releases

# Linux 安裝範例
wget https://github.com/BloodHoundAD/BloodHound/releases/download/v4.3.1/BloodHound-linux-x64.zip
unzip BloodHound-linux-x64.zip
chmod +x BloodHound-linux-x64/BloodHound
./BloodHound-linux-x64/BloodHound

# 如果遇到依賴問題，安裝必要的套件
sudo apt-get install libgconf-2-4 libatk1.0-0 libatk-bridge2.0-0 libgdk-pixbuf2.0-0 libgtk-3-0 libgbm-dev libnss3-dev libxss-dev

1
2
3
4
5
6
7

方法一：拖放匯入
1. 將 ZIP 檔案直接拖放到 BloodHound 視窗

方法二：使用匯入按鈕
1. 點擊右側的 "Upload Data" 按鈕
2. 選擇 ZIP 檔案或 JSON 檔案
3. 等待匯入完成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

節點操作：
- 左鍵點擊：選擇節點，顯示詳細資訊
- 右鍵點擊：開啟內容選單
- 雙擊：展開節點的關係

圖形操作：
- 滾輪：縮放視圖
- 拖動：移動視圖
- Ctrl + 滾輪：調整節點大小

快捷鍵：
- Ctrl + L：清除圖形
- Ctrl + Shift + I：開啟開發者工具

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Analysis 分類：
1. Find all Domain Admins - 找出所有 Domain Admin
2. Find Shortest Paths to Domain Admins - 找到 Domain Admin 的最短路徑
3. Find Principals with DCSync Rights - 找出具有 DCSync 權限的主體
4. Users with Foreign Domain Group Membership - 跨網域群組成員
5. Groups with Foreign Domain Group Membership - 具有外部網域成員的群組
6. Map Domain Trusts - 映射網域信任關係
7. Shortest Paths to Unconstrained Delegation Systems - 到無限制委派系統的路徑
8. Shortest Paths from Kerberoastable Users - 從可 Kerberoast 使用者的路徑
9. Shortest Paths to Domain Admins from Kerberoastable Users - 從可 Kerberoast 使用者到 DA 的路徑
10. Shortest Path from Owned Principals - 從已控制主體的最短路徑
11. Find Computers where Domain Users are Local Admin - 找出 Domain Users 是本地管理員的電腦
12. Find Computers where Domain Users can RDP - 找出 Domain Users 可以 RDP 的電腦

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

步驟一：標記已控制的節點
1. 右鍵點擊已控制的使用者節點
2. 選擇 "Mark User as Owned"

步驟二：執行路徑查詢
1. 開啟查詢面板
2. 選擇 "Find Shortest Paths to Domain Admins"
3. 或執行自訂查詢：
   MATCH p=shortestPath((u:User {owned:true})-[*1..]->(g:Group {name:"DOMAIN ADMINS@CORP.LOCAL"}))
   RETURN p

1
2
3
4
5

路徑示例：
User1 --[MemberOf]--> Group1 --[MemberOf]--> Group2 --[MemberOf]--> Domain Admins

攻擊說明：
透過巢狀的群組成員關係，低權限使用者可能間接成為高權限群組的成員。

1
2
3
4
5
6
7
8
9

路徑示例：
User1 --[AdminTo]--> Computer1 <--[HasSession]-- DomainAdmin

攻擊步驟：
1. User1 對 Computer1 有本地管理員權限
2. Domain Admin 在 Computer1 有活躍 Session
3. 攻擊者使用 User1 登入 Computer1
4. 使用 Mimikatz 竊取 Domain Admin 的憑證
5. 使用竊取的憑證進行權限提升

1
2
3
4
5
6
7

路徑示例：
User1 --[GenericAll]--> User2 --[MemberOf]--> Domain Admins

攻擊步驟：
1. User1 對 User2 有 GenericAll 權限
2. 攻擊者使用 User1 重設 User2 的密碼
3. 使用 User2 的身份（已是 Domain Admin）

1
2
3
4
5
6
7

路徑示例：
User1 --[AdminTo]--> Computer1 --[AllowedToDelegate]--> Domain Controller

攻擊步驟：
1. User1 是 Computer1 的本地管理員
2. Computer1 被設定為可以委派到 Domain Controller
3. 攻擊者利用委派模擬任意使用者存取 DC

1
2
3
4
5
6
7

路徑示例：
User1 --[GenericAll]--> GPO1 --[GPLink]--> OU1 --[Contains]--> DomainAdmin

攻擊步驟：
1. User1 對 GPO1 有完全控制權限
2. GPO1 連結到包含 Domain Admin 的 OU
3. 修改 GPO 執行惡意腳本或新增本地管理員

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

高價值目標類型：
1. Domain Admins - 網域管理員群組
2. Enterprise Admins - 企業管理員群組
3. Domain Controllers - 網域控制器
4. Schema Admins - Schema 管理員
5. Account Operators - 帳戶操作員
6. Backup Operators - 備份操作員
7. DnsAdmins - DNS 管理員（可能用於權限提升）
8. GPO Creator Owners - GPO 建立者
9. 具有 DCSync 權限的帳戶
10. 無限制委派的系統

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

場景：已取得 jsmith 使用者的憑證

步驟 1：標記已控制的節點
- 在 BloodHound 中將 jsmith 標記為 "Owned"

步驟 2：執行路徑查詢
- 查詢：Find Shortest Paths from Owned Principals

步驟 3：分析發現的路徑
發現路徑：
jsmith --[MemberOf]--> IT-Support --[GenericAll]--> svc_backup --[MemberOf]--> Backup Operators --[HasSession]--> DC01

步驟 4：規劃攻擊步驟
1. 使用 jsmith（IT-Support 成員）
2. 利用 GenericAll 權限重設 svc_backup 密碼
3. 以 svc_backup 身份登入
4. 利用 Backup Operators 權限存取 DC01
5. 使用 Session 竊取或其他技術取得 Domain Admin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

-- 基本節點查詢
MATCH (n:User) RETURN n LIMIT 10

-- 查詢特定屬性
MATCH (u:User {name: "JSMITH@CORP.LOCAL"}) RETURN u

-- 查詢關係
MATCH (u:User)-[r:MemberOf]->(g:Group) RETURN u, r, g LIMIT 20

-- 使用 WHERE 子句
MATCH (u:User) WHERE u.enabled = true RETURN u.name

-- 計數查詢
MATCH (n:Computer) RETURN COUNT(n)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

-- 列出所有啟用的使用者
MATCH (u:User {enabled: true}) RETURN u.name ORDER BY u.name

-- 找出密碼永不過期的使用者
MATCH (u:User {pwdneverexpires: true, enabled: true}) RETURN u.name

-- 找出不需要 Kerberos 預認證的使用者（AS-REP Roasting）
MATCH (u:User {dontreqpreauth: true}) RETURN u.name

-- 找出具有 SPN 的使用者（Kerberoastable）
MATCH (u:User) WHERE u.hasspn = true RETURN u.name, u.serviceprincipalnames

-- 找出 Domain Admin 群組的所有成員（包含巢狀）
MATCH p=(u:User)-[:MemberOf*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"})
RETURN DISTINCT u.name

-- 找出特權群組的直接成員
MATCH (u)-[:MemberOf]->(g:Group)
WHERE g.name =~ ".*ADMIN.*"
RETURN u.name, g.name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

-- 找出所有 Domain Controller
MATCH (c:Computer) WHERE c.name =~ ".*DC.*" RETURN c.name

-- 找出無限制委派的電腦
MATCH (c:Computer {unconstraineddelegation: true}) RETURN c.name

-- 找出有 Domain Admin Session 的電腦
MATCH (c:Computer)<-[:HasSession]-(u:User)-[:MemberOf*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"})
RETURN DISTINCT c.name, u.name

-- 找出特定使用者有 Session 的電腦
MATCH (c:Computer)<-[:HasSession]-(u:User {name: "ADMIN@CORP.LOCAL"})
RETURN c.name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

-- 找出對 Domain Admin 有 GenericAll 權限的使用者
MATCH (u)-[:GenericAll]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"})
RETURN u.name

-- 找出可以 DCSync 的非 Domain Admin 使用者
MATCH (u:User)-[:DCSync|GetChangesAll|GetChanges*1..]->(d:Domain)
WHERE NOT (u)-[:MemberOf*1..]->(:Group {name: "DOMAIN ADMINS@CORP.LOCAL"})
RETURN u.name

-- 找出可以修改 GPO 的使用者
MATCH (u:User)-[:GenericAll|GenericWrite|WriteOwner|WriteDacl]->(g:GPO)
RETURN u.name, g.name

-- 找出可以重設密碼的使用者
MATCH (u1:User)-[:ForceChangePassword]->(u2:User)
RETURN u1.name AS CanReset, u2.name AS Target

-- 找出可以新增群組成員的使用者
MATCH (u:User)-[:AddMember]->(g:Group)
RETURN u.name, g.name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

-- 找出到 Domain Admin 的所有路徑（限制長度）
MATCH p=shortestPath((u:User)-[*1..5]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
WHERE u.enabled = true
RETURN p

-- 從已控制的使用者找路徑
MATCH p=shortestPath((u:User {owned: true})-[*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
RETURN p

-- 找出透過 Kerberoasting 的攻擊路徑
MATCH (u:User {hasspn: true, enabled: true})
MATCH p=shortestPath((u)-[*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
RETURN p

-- 找出透過 Session 的攻擊路徑
MATCH (u1:User {owned: true})-[:AdminTo]->(c:Computer)<-[:HasSession]-(u2:User)
MATCH p=shortestPath((u2)-[*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
RETURN p

-- 找出最容易攻擊的路徑（考慮路徑長度）
MATCH p=allShortestPaths((u:User {owned: true})-[*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
RETURN p, LENGTH(p) AS PathLength
ORDER BY PathLength ASC

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

-- 統計各類型節點數量
MATCH (n) RETURN labels(n), COUNT(n) ORDER BY COUNT(n) DESC

-- 統計使用者權限分佈
MATCH (u:User)-[r]->(t)
RETURN TYPE(r), COUNT(r)
ORDER BY COUNT(r) DESC

-- 找出擁有最多權限的使用者
MATCH (u:User)-[r]->(t)
RETURN u.name, COUNT(r) AS PermissionCount
ORDER BY PermissionCount DESC LIMIT 10

-- 找出最多人有權限的目標
MATCH (s)-[r]->(t)
RETURN t.name, labels(t), COUNT(r) AS IncomingCount
ORDER BY IncomingCount DESC LIMIT 10

-- 計算平均到 Domain Admin 的路徑長度
MATCH p=shortestPath((u:User {enabled: true})-[*1..]->(g:Group {name: "DOMAIN ADMINS@CORP.LOCAL"}))
RETURN AVG(LENGTH(p)) AS AvgPathLength

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

步驟：
1. 點擊查詢面板右上角的 "Custom Queries" 標籤
2. 點擊 "+" 按鈕新增查詢
3. 輸入查詢名稱和 Cypher 語句
4. 儲存查詢

查詢檔案位置：
- Linux: ~/.config/bloodhound/customqueries.json
- Windows: %APPDATA%\bloodhound\customqueries.json
- macOS: ~/Library/Application Support/bloodhound/customqueries.json

 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

{
    "queries": [
        {
            "name": "Find Kerberoastable Users with Path to DA",
            "category": "Custom",
            "queryList": [
                {
                    "final": true,
                    "query": "MATCH (u:User {hasspn: true, enabled: true}) MATCH p=shortestPath((u)-[*1..]->(g:Group {name: 'DOMAIN ADMINS@CORP.LOCAL'})) RETURN p"
                }
            ]
        },
        {
            "name": "Find Computers with Unconstrained Delegation",
            "category": "Custom",
            "queryList": [
                {
                    "final": true,
                    "query": "MATCH (c:Computer {unconstraineddelegation: true}) RETURN c"
                }
            ]
        },
        {
            "name": "Find Users Who Can DCSync",
            "category": "Custom",
            "queryList": [
                {
                    "final": true,
                    "query": "MATCH (u)-[:DCSync|GetChangesAll|GetChanges*1..]->(d:Domain) RETURN u.name"
                }
            ]
        }
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 下載 BloodHound CE
git clone https://github.com/SpecterOps/BloodHound.git
cd BloodHound/examples/docker-compose

# 或者直接下載 docker-compose 檔案
curl -L https://ghst.ly/getbhce -o docker-compose.yml

# 啟動服務
docker-compose up -d

# 檢查服務狀態
docker-compose ps

# 查看初始密碼
docker-compose logs bloodhound | grep "Initial Password"

 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
39
40

version: '3'
services:
  bloodhound:
    image: specterops/bloodhound:latest
    container_name: bloodhound-ce
    ports:
      - "8080:8080"
    environment:
      - bhe_disable_cypher_qc=false
    depends_on:
      - graph-db
      - app-db
    volumes:
      - bloodhound-config:/bloodhound

  graph-db:
    image: neo4j:4.4
    container_name: bloodhound-neo4j
    environment:
      - NEO4J_AUTH=neo4j/bloodhoundcommunityedition
      - NEO4J_dbms_allow__upgrade=true
    volumes:
      - neo4j-data:/data
      - neo4j-logs:/logs

  app-db:
    image: postgres:13
    container_name: bloodhound-postgres
    environment:
      - POSTGRES_USER=bloodhound
      - POSTGRES_PASSWORD=bloodhoundcommunityedition
      - POSTGRES_DB=bloodhound
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  bloodhound-config:
  neo4j-data:
  neo4j-logs:
  postgres-data:

1
2
3
4
5
6
7
8
9

方法一：Web 介面上傳
1. 點擊左側選單的 "File Ingest"
2. 拖放或選擇 ZIP 檔案
3. 等待處理完成

方法二：API 上傳
curl -X POST "http://localhost:8080/api/v2/file-upload" \
  -H "Authorization: Bearer <token>" \
  -F "file=@bloodhound_data.zip"

1
2
3
4
5
6
7
8

# 下載 SharpHound for BloodHound CE
# https://github.com/SpecterOps/SharpHound/releases

# 執行收集
.\SharpHound.exe --collectionmethods All --outputdirectory C:\Temp

# 新增的收集選項
.\SharpHound.exe --collectionmethods All --dolocal --certservices

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

1. 節點搜尋
   - 在搜尋欄輸入物件名稱
   - 支援模糊搜尋和過濾器

2. 路徑搜尋
   - 選擇起點和終點
   - 自動計算攻擊路徑

3. Cypher 查詢
   - 開啟 Cypher 編輯器
   - 執行自訂查詢

4. 預定義分析
   - 使用內建的分析功能
   - 包含改進的視覺化效果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 取得認證 Token
curl -X POST "http://localhost:8080/api/v2/login" \
  -H "Content-Type: application/json" \
  -d '{"login_method": "secret", "secret": "your_api_key"}'

# 列出所有使用者
curl -X GET "http://localhost:8080/api/v2/users" \
  -H "Authorization: Bearer <token>"

# 執行 Cypher 查詢
curl -X POST "http://localhost:8080/api/v2/graphs/cypher" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"query": "MATCH (u:User) RETURN u.name LIMIT 10"}'

# 取得特定節點資訊
curl -X GET "http://localhost:8080/api/v2/base/CORP.LOCAL" \
  -H "Authorization: Bearer <token>"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 審計 Domain Admin 群組成員
Get-ADGroupMember -Identity "Domain Admins" -Recursive

# 審計特權群組
$privilegedGroups = @(
    "Domain Admins",
    "Enterprise Admins",
    "Schema Admins",
    "Account Operators",
    "Backup Operators",
    "Server Operators",
    "Print Operators"
)

foreach ($group in $privilegedGroups) {
    Write-Host "Members of $group:"
    Get-ADGroupMember -Identity $group -Recursive | Select-Object Name, SamAccountName
}

# 使用 AdminCount 找出特權帳戶
Get-ADUser -Filter {AdminCount -eq 1} -Properties AdminCount

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 找出對 Domain Admins 有危險權限的帳戶
Import-Module ActiveDirectory

# 取得 Domain Admins 的 ACL
$domainAdmins = Get-ADGroup "Domain Admins"
$acl = Get-Acl "AD:\$($domainAdmins.DistinguishedName)"

# 分析權限
$acl.Access | Where-Object {
    $_.ActiveDirectoryRights -match "GenericAll|GenericWrite|WriteDacl|WriteOwner"
} | Format-Table IdentityReference, ActiveDirectoryRights, AccessControlType

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 限制 WMI 存取
# 設定 DCOM 權限限制本地管理員的橫向移動能力

# 啟用 Windows Firewall 規則
New-NetFirewallRule -DisplayName "Block WMI" -Direction Inbound -LocalPort 135 -Protocol TCP -Action Block

# 限制 PsExec 和類似工具
# 透過 GPO 限制 ADMIN$ 共享的存取

# 啟用 Credential Guard
# 需要在 GPO 中設定 Device Guard

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 啟用 LDAP 查詢日誌
# Event ID 2889: LDAP 簽章警告
# Event ID 1644: LDAP 查詢資訊（需要額外設定）

# 啟用 LDAP 查詢記錄
$baseDN = "CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=corp,DC=local"
Set-ADObject -Identity $baseDN -Replace @{
    "15 Field Engineering" = 5
}

# 監控異常的 LDAP 查詢模式
# 查詢所有使用者的 servicePrincipalName 屬性
# 查詢所有群組的成員
# 查詢 ACL 資訊

1
2
3
4
5
6
7
8

# 監控 Event ID 4624（登入成功）和 4648（使用明確憑證登入）
# 監控 NetSessionEnum 呼叫

# 使用 Sysmon 監控
# Event ID 18: PipeEvent (Pipe Connected) - 監控 \PIPE\srvsvc

# 啟用 Object Access 稽核
auditpol /set /subcategory:"Handle Manipulation" /success:enable /failure:enable

1
2
3
4
5
6

監控指標：
1. 短時間內大量 LDAP 查詢
2. 對多台電腦的 NetSessionEnum 呼叫
3. 對多台電腦的 NetLocalGroupGetMembers 呼叫
4. 異常的 SAMR 查詢模式
5. 對 Domain Controller 的密集連線

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 1. 啟用 Protected Users 群組
Add-ADGroupMember -Identity "Protected Users" -Members "sensitive_account"

# 2. 設定 AdminSDHolder
# 限制對特權物件的權限修改

# 3. 啟用 LAPS（Local Administrator Password Solution）
# 自動管理本地管理員密碼

# 4. 限制 Kerberos 委派
# 審計無限制委派的電腦
Get-ADComputer -Filter {TrustedForDelegation -eq $true}

# 使用限制委派替代無限制委派
Set-ADComputer -Identity "server1" -TrustedForDelegation $false

# 5. 啟用 Kerberos AES 加密
Set-ADUser -Identity "service_account" -KerberosEncryptionType AES256

# 6. 設定密碼原則
# 要求複雜密碼，定期更換

# 7. 停用 LLMNR 和 NetBIOS
# 透過 GPO 設定

1
2
3
4
5
6
7
8

重要事件監控：
1. Event ID 4769 - Kerberos 服務票證請求（監控 Kerberoasting）
2. Event ID 4768 - Kerberos TGT 請求（監控 AS-REP Roasting）
3. Event ID 4662 - 目錄服務存取（監控 DCSync）
4. Event ID 4672 - 特權指派（監控特權帳戶使用）
5. Event ID 4624/4625 - 登入成功/失敗
6. Event ID 4728/4732/4756 - 群組成員變更
7. Event ID 5136 - 目錄服務變更（監控 ACL 修改）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 偵測 Kerberoasting
index=windows EventCode=4769 Ticket_Encryption_Type=0x17
| stats count by Account_Name, Service_Name, Client_Address
| where count > 10

# 偵測 DCSync
index=windows EventCode=4662
Access_Mask="0x100" OR Access_Mask="0x80"
Properties="*1131f6aa-9c07-11d1-f79f-00c04fc2dcd2*" OR
Properties="*1131f6ad-9c07-11d1-f79f-00c04fc2dcd2*"
| stats count by Account_Name, Object_Name

# 偵測密碼噴灑攻擊
index=windows EventCode=4625
| bucket _time span=5m
| stats count dc(TargetUserName) as unique_users by _time, IpAddress
| where count > 20 AND unique_users > 10

# 偵測異常 LDAP 查詢
index=windows EventCode=1644
| stats count by Src_IP, Filter
| where count > 1000

 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

建議的評估項目：

1. 路徑分析
   - 定期執行 BloodHound 收集和分析
   - 追蹤攻擊路徑的數量和長度變化
   - 識別新增的危險路徑

2. 權限審計
   - 審計特權群組成員
   - 審計危險的 ACL 設定
   - 審計 Kerberos 委派設定

3. 配置審查
   - 審計 GPO 設定
   - 審計服務帳戶權限
   - 審計共享資料夾權限

4. 漏洞評估
   - 檢查 Kerberoastable 帳戶
   - 檢查 AS-REP Roastable 帳戶
   - 檢查弱密碼

5. 改進追蹤
   - 記錄修復的問題
   - 追蹤改進效果
   - 更新基準線

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

防守使用案例：

1. 識別高風險路徑
   - 執行 "Find Shortest Paths to Domain Admins"
   - 優先處理最短的攻擊路徑

2. 識別過度授權
   - 查詢不必要的 GenericAll 權限
   - 查詢危險的群組成員關係

3. 監控變更
   - 定期收集資料並比較差異
   - 追蹤新增的危險配置

4. 報告生成
   - 產生管理層報告
   - 追蹤修復進度

5. 紅隊模擬
   - 使用 BloodHound 規劃紅隊路徑
   - 驗證偵測能力