GCPRecon使用教程#

软件介绍#

GCPRecon是一款专门用于Google Cloud Platform（GCP）云平台侦察和信息收集的工具。它能够自动发现和枚举GCP项目中的资源，包括计算实例、存储桶、数据库、函数等，是GCP云安全评估和渗透测试的重要工具。

主要功能#

GCP项目资源枚举
Cloud Storage存储桶发现
Compute Engine实例信息收集
IAM权限分析
安全配置检测
漏洞识别
合规性检查
报告生成

适用场景#

云安全评估
渗透测试
资产发现
风险评估
合规性审计
威胁情报收集

入门级使用#

安装GCPRecon#

使用Python安装#

# 安装Python依赖
pip install google-cloud-compute
pip install google-cloud-storage
pip install google-cloud-iam
pip install google-cloud-logging
pip install google-cloud-monitoring
pip install google-cloud-bigquery
pip install google-cloud-sql

# 克隆GCPRecon仓库
git clone https://github.com/google/gcp-recon.git
cd gcp-recon

# 安装依赖
pip install -r requirements.txt

使用Docker安装#

# 使用Docker运行
docker run -it --rm gcp-recon:latest

# 或构建本地镜像
git clone https://github.com/google/gcp-recon.git
cd gcp-recon
docker build -t gcp-recon .
docker run -it gcp-recon

配置GCP凭证#

使用gcloud CLI认证#

# 安装Google Cloud SDK
curl https://sdk.cloud.google.com | bash

# 初始化gcloud
gcloud init

# 登录
gcloud auth login

# 设置项目
gcloud config set project your-project-id

使用服务账户#

# 创建服务账户
gcloud iam service-accounts create gcp-recon \
    --display-name "GCP Recon"

# 授予服务账户权限
gcloud projects add-iam-policy-binding your-project-id \
    --member="serviceAccount:gcp-recon@your-project-id.iam.gserviceaccount.com" \
    --role="roles/viewer"

# 创建并下载密钥
gcloud iam service-accounts keys create key.json \
    --iam-account=gcp-recon@your-project-id.iam.gserviceaccount.com

# 设置环境变量
export GOOGLE_APPLICATION_CREDENTIALS="key.json"

使用环境变量#

# 设置环境变量
export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/key.json"
export GOOGLE_CLOUD_PROJECT="your-project-id"
export GOOGLE_CLOUD_REGION="us-central1"

基本侦察#

快速扫描#

# 快速扫描所有资源
python gcp_recon.py --all

# 扫描特定项目
python gcp_recon.py --project your-project-id

# 扫描特定区域
python gcp_recon.py --region us-central1

# 扫描特定服务
python gcp_recon.py --service compute
python gcp_recon.py --service storage
python gcp_recon.py --service sql

枚举计算实例#

# 枚举所有计算实例
python gcp_recon.py --compute

# 枚举特定区域的实例
python gcp_recon.py --compute --region us-central1

# 枚举实例的详细信息
python gcp_recon.py --compute --detailed

初级使用#

资源枚举#

Cloud Storage枚举#

# 枚举所有存储桶
python gcp_recon.py --storage

# 枚举存储桶的对象
python gcp_recon.py --storage --objects

# 检查存储桶的ACL
python gcp_recon.py --storage --acl

# 检查存储桶的IAM策略
python gcp_recon.py --storage --iam

Cloud SQL枚举#

# 枚举所有Cloud SQL实例
python gcp_recon.py --sql

# 枚举SQL数据库
python gcp_recon.py --sql --databases

# 枚举SQL用户
python gcp_recon.py --sql --users

# 枚举SQL备份
python gcp_recon.py --sql --backups

网络枚举#

VPC网络枚举#

# 枚举所有VPC网络
python gcp_recon.py --network

# 枚举子网
python gcp_recon.py --network --subnets

# 枚举防火墙规则
python gcp_recon.py --network --firewalls

# 枚举路由
python gcp_recon.py --network --routes

负载均衡器枚举#

# 枚举负载均衡器
python gcp_recon.py --load-balancers

# 枚举目标池
python gcp_recon.py --load-balancers --target-pools

# 枚举转发规则
python gcp_recon.py --load-balancers --forwarding-rules

中级使用#

IAM分析#

角色和权限枚举#

# 枚举所有IAM策略
python gcp_recon.py --iam

# 枚举特定用户的权限
python gcp_recon.py --iam --user user@example.com

# 枚举特定服务账户的权限
python gcp_recon.py --iam --service-account gcp-recon@your-project-id.iam.gserviceaccount.com

# 枚举自定义角色
python gcp_recon.py --iam --custom-roles

权限提升检测#

# 检测权限提升路径
python gcp_recon.py --privilege-escalation

# 检测可写的角色定义
python gcp_recon.py --iam --writable-roles

# 检测具有所有者权限的账户
python gcp_recon.py --iam --owners

# 检测服务账户的权限
python gcp_recon.py --iam --service-accounts

漏洞扫描#

检查不安全的配置#

# 检查公开的存储桶
python gcp_recon.py --scan --public-storage

# 检查开放的防火墙规则
python gcp_recon.py --scan --open-firewalls

# 检查未加密的存储
python gcp_recon.py --scan --unencrypted-storage

# 检查过期的访问密钥
python gcp_recon.py --scan --expired-keys

检查合规性问题#

# 检查安全中心配置
python gcp_recon.py --security-command-center

# 检查策略合规性
python gcp_recon.py --policy-compliance

# 检查Cloud Armor状态
python gcp_recon.py --cloud-armor

数据导出#

导出为JSON#

# 导出所有侦察结果
python gcp_recon.py --all --output json > results.json

# 导出特定服务
python gcp_recon.py --compute --output json > compute.json

# 导出特定项目
python gcp_recon.py --project your-project-id --output json > project.json

导出为CSV#

# 导出为CSV格式
python gcp_recon.py --compute --output csv > compute.csv

# 导出存储桶列表
python gcp_recon.py --storage --output csv > storage.csv

中上级使用#

高级分析#

攻击面分析#

#!/bin/bash
# GCP攻击面分析脚本

OUTPUT_DIR="gcp_attack_surface"
mkdir -p "$OUTPUT_DIR"

# 1. 分析公开的端点
echo "[1/5] 分析公开端点..."
python gcp_recon.py --compute --output json > "$OUTPUT_DIR/compute.json"
python gcp_recon.py --load-balancers --output json > "$OUTPUT_DIR/load_balancers.json"

# 2. 分析存储桶
echo "[2/5] 分析存储桶..."
python gcp_recon.py --storage --output json > "$OUTPUT_DIR/storage.json"
python gcp_recon.py --storage --objects --output json > "$OUTPUT_DIR/storage_objects.json"

# 3. 分析网络
echo "[3/5] 分析网络..."
python gcp_recon.py --network --output json > "$OUTPUT_DIR/network.json"
python gcp_recon.py --network --firewalls --output json > "$OUTPUT_DIR/firewalls.json"

# 4. 分析权限
echo "[4/5] 分析权限..."
python gcp_recon.py --iam --output json > "$OUTPUT_DIR/iam.json"

# 5. 生成攻击面报告
echo "[5/5] 生成攻击面报告..."
python gcp_recon.py --attack-surface --output json > "$OUTPUT_DIR/attack_surface.json"

echo "攻击面分析完成，结果保存在 $OUTPUT_DIR 目录"

风险评估#

#!/bin/bash
# GCP风险评估脚本

OUTPUT_FILE="gcp_risk_assessment.txt"

echo "=== GCP风险评估 ===" > "$OUTPUT_FILE"
echo "评估时间: $(date)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# 检查公开的存储桶
echo "=== 公开存储桶 ===" >> "$OUTPUT_FILE"
python gcp_recon.py --scan --public-storage >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查开放的防火墙规则
echo "=== 开放的防火墙规则 ===" >> "$OUTPUT_FILE"
python gcp_recon.py --scan --open-firewalls >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查未加密的资源
echo "=== 未加密的资源 ===" >> "$OUTPUT_FILE"
python gcp_recon.py --scan --unencrypted-storage >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查权限提升路径
echo "=== 权限提升路径 ===" >> "$OUTPUT_FILE"
python gcp_recon.py --privilege-escalation >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查安全中心状态
echo "=== 安全中心状态 ===" >> "$OUTPUT_FILE"
python gcp_recon.py --security-command-center >> "$OUTPUT_FILE" 2>&1

echo "风险评估完成，结果已保存到 $OUTPUT_FILE"

自动化侦察#

完整侦察脚本#

#!/bin/bash
# 完整GCP侦察脚本

PROJECT_ID=$(gcloud config get-value project)
OUTPUT_DIR="gcp_recon_$PROJECT_ID"
mkdir -p "$OUTPUT_DIR"

echo "=== GCP项目侦察 ==="
echo "项目ID: $PROJECT_ID"
echo "输出目录: $OUTPUT_DIR"

# 1. 枚举计算实例
echo "[1/12] 枚举计算实例..."
python gcp_recon.py --compute --output json > "$OUTPUT_DIR/compute.json"

# 2. 枚举存储桶
echo "[2/12] 枚举存储桶..."
python gcp_recon.py --storage --output json > "$OUTPUT_DIR/storage.json"

# 3. 枚举Cloud SQL
echo "[3/12] 枚举Cloud SQL..."
python gcp_recon.py --sql --output json > "$OUTPUT_DIR/sql.json"

# 4. 枚举BigQuery
echo "[4/12] 枚举BigQuery..."
python gcp_recon.py --bigquery --output json > "$OUTPUT_DIR/bigquery.json"

# 5. 枚举VPC网络
echo "[5/12] 枚举VPC网络..."
python gcp_recon.py --network --output json > "$OUTPUT_DIR/network.json"

# 6. 枚举防火墙规则
echo "[6/12] 枚举防火墙规则..."
python gcp_recon.py --network --firewalls --output json > "$OUTPUT_DIR/firewalls.json"

# 7. 枚举公共IP
echo "[7/12] 枚举公共IP..."
python gcp_recon.py --compute --public-ips --output json > "$OUTPUT_DIR/public_ips.json"

# 8. 枚举Cloud Functions
echo "[8/12] 枚举Cloud Functions..."
python gcp_recon.py --functions --output json > "$OUTPUT_DIR/functions.json"

# 9. 枚举App Engine
echo "[9/12] 枚举App Engine..."
python gcp_recon.py --app-engine --output json > "$OUTPUT_DIR/app_engine.json"

# 10. 枚举IAM
echo "[10/12] 枚举IAM..."
python gcp_recon.py --iam --output json > "$OUTPUT_DIR/iam.json"

# 11. 枚举服务账户
echo "[11/12] 枚举服务账户..."
python gcp_recon.py --iam --service-accounts --output json > "$OUTPUT_DIR/service_accounts.json"

# 12. 生成汇总报告
echo "[12/12] 生成汇总报告..."
cat > "$OUTPUT_DIR/summary.txt" << EOF
GCP项目侦察汇总报告
====================
项目ID: $PROJECT_ID
侦察时间: $(date)

资源统计:
- 计算实例: $(jq length "$OUTPUT_DIR/compute.json")
- 存储桶: $(jq length "$OUTPUT_DIR/storage.json")
- Cloud SQL实例: $(jq length "$OUTPUT_DIR/sql.json")
- BigQuery数据集: $(jq length "$OUTPUT_DIR/bigquery.json")
- VPC网络: $(jq length "$OUTPUT_DIR/network.json")
- 防火墙规则: $(jq length "$OUTPUT_DIR/firewalls.json")
- 公共IP: $(jq length "$OUTPUT_DIR/public_ips.json")
- Cloud Functions: $(jq length "$OUTPUT_DIR/functions.json")
- App Engine服务: $(jq length "$OUTPUT_DIR/app_engine.json")
- IAM策略: $(jq length "$OUTPUT_DIR/iam.json")
- 服务账户: $(jq length "$OUTPUT_DIR/service_accounts.json")
EOF

echo "GCP侦察完成！所有结果已保存到 $OUTPUT_DIR 目录"

高级使用#

云安全分析#

攻击路径分析#

#!/usr/bin/env python3
import json
from collections import defaultdict

def analyze_gcp_attack_paths(recon_data):
    """分析GCP攻击路径"""
    
    attack_paths = {
        "public_exposure": [],
        "privilege_escalation": [],
        "data_exfiltration": [],
        "lateral_movement": []
    }
    
    # 分析公开暴露
    for instance in recon_data.get("compute", []):
        if instance.get("public_ip"):
            attack_paths["public_exposure"].append({
                "type": "instance",
                "name": instance["name"],
                "public_ip": instance["public_ip"],
                "issue": "实例具有公共IP"
            })
    
    # 分析存储桶
    for bucket in recon_data.get("storage", []):
        if bucket.get("acl") == "publicRead":
            attack_paths["data_exfiltration"].append({
                "type": "storage",
                "name": bucket["name"],
                "acl": bucket["acl"],
                "issue": "存储桶公开可读"
            })
    
    # 分析权限
    for policy in recon_data.get("iam", []):
        if policy.get("role") == "roles/owner":
            attack_paths["privilege_escalation"].append({
                "type": "iam",
                "member": policy["member"],
                "role": policy["role"],
                "issue": "具有所有者权限"
            })
    
    return attack_paths

# 使用示例
with open("gcp_recon_results.json") as f:
    results = json.load(f)
    
attack_paths = analyze_gcp_attack_paths(results)
print(json.dumps(attack_paths, indent=2))

漏洞检测#

#!/bin/bash
# GCP漏洞检测脚本

OUTPUT_FILE="gcp_vulnerability_scan.txt"

echo "=== GCP漏洞扫描报告 ===" > "$OUTPUT_FILE"
echo "扫描时间: $(date)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# 1. 检测公开的存储桶
echo "[1] 检测公开的存储桶..." >> "$OUTPUT_FILE"
python gcp_recon.py --scan --public-storage 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 2. 检测开放SSH的防火墙规则
echo "[2] 检测开放SSH的防火墙规则..." >> "$OUTPUT_FILE"
gcloud compute firewall-rules list --filter="allowed[].ports:22" --format="table(name,network,sourceRanges)" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 3. 检测开放RDP的防火墙规则
echo "[3] 检测开放RDP的防火墙规则..." >> "$OUTPUT_FILE"
gcloud compute firewall-rules list --filter="allowed[].ports:3389" --format="table(name,network,sourceRanges)" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 4. 检测未加密的存储
echo "[4] 检测未加密的存储..." >> "$OUTPUT_FILE"
python gcp_recon.py --scan --unencrypted-storage 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 5. 检测公开的存储桶策略
echo "[5] 检测公开的存储桶策略..." >> "$OUTPUT_FILE"
gsutil ls -p $(gcloud config get-value project) | while read bucket; do
    iam=$(gsutil iam get "$bucket" 2>/dev/null)
    if [ -n "$iam" ]; then
        echo "存储桶: $bucket" >> "$OUTPUT_FILE"
        echo "$iam" >> "$OUTPUT_FILE"
    fi
done
echo "" >> "$OUTPUT_FILE"

echo "漏洞扫描完成！"

合规性检查#

GCP安全基准检查#

#!/bin/bash
# GCP安全基准检查脚本

GCP_CHECKS=(
    "1.1: 确保启用了Cloud Audit Logs"
    "1.2: 确保配置了VPC Service Controls"
    "1.3: 确保启用了MFA"
    "1.4: 确保配置了IAM条件"
    "2.1: 确保存储桶已加密"
    "2.2: 确保计算实例已加密"
    "2.3: 确保数据库已加密"
    "3.1: 确保防火墙规则已配置"
    "3.2: 确保应用了网络安全最佳实践"
    "3.3: 确保配置了Cloud Armor"
)

OUTPUT_FILE="gcp_compliance.txt"

echo "=== GCP安全基准合规性检查 ===" > "$OUTPUT_FILE"
echo "检查时间: $(date)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

for check in "${GCP_CHECKS[@]}"; do
    echo "检查: $check" >> "$OUTPUT_FILE"
    # 这里可以添加具体的检查逻辑
    echo "状态: 待实现" >> "$OUTPUT_FILE"
    echo "" >> "$OUTPUT_FILE"
done

echo "合规性检查完成！"

大师级使用#

威胁建模#

攻击图构建#

#!/usr/bin/env python3
import json
from collections import defaultdict

class GCPAttackGraph:
    def __init__(self, recon_data):
        self.data = recon_data
        self.graph = defaultdict(list)
    
    def build_graph(self):
        """构建攻击图"""
        # 从计算实例开始
        for instance in self.data.get("compute", []):
            self.graph["instance:" + instance["name"]] = []
            
            # 添加公共IP
            if instance.get("public_ip"):
                self.graph["instance:" + instance["name"]].append(
                    f"public_ip:{instance['public_ip']}"
                )
            
            # 添加服务账户
            if instance.get("service_account"):
                self.graph["instance:" + instance["name"]].append(
                    f"service_account:{instance['service_account']}"
                )
        
        # 从存储桶
        for bucket in self.data.get("storage", []):
            self.graph["storage:" + bucket["name"]] = []
        
        # 从数据库
        for db in self.data.get("sql", []):
            self.graph["sql:" + db["name"]] = []
        
        return self.graph
    
    def find_attack_paths(self):
        """查找攻击路径"""
        attack_paths = []
        
        # 检查具有所有者权限的账户
        for policy in self.data.get("iam", []):
            if policy.get("role") == "roles/owner":
                attack_paths.append({
                    "member": policy["member"],
                    "path": "可以直接控制所有资源",
                    "risk": "高"
                })
        
        return attack_paths
    
    def find_data_exposure(self):
        """查找数据暴露"""
        exposure_paths = []
        
        # 检查公开的存储桶
        for bucket in self.data.get("storage", []):
            if bucket.get("acl") == "publicRead":
                exposure_paths.append({
                    "bucket": bucket["name"],
                    "issue": "存储桶公开可读",
                    "risk": "高"
                })
        
        # 检查开放的防火墙规则
        for fw in self.data.get("firewalls", []):
            if fw.get("source_ranges") and "0.0.0.0/0" in fw["source_ranges"]:
                if fw.get("allowed"):
                    for rule in fw["allowed"]:
                        if rule.get("ports") and any(p in ["22", "3389", "80", "443"] for p in rule["ports"]):
                            exposure_paths.append({
                                "firewall": fw["name"],
                                "port": rule["ports"],
                                "issue": f"端口{rule['ports']}对公网开放",
                                "risk": "中"
                            })
        
        return exposure_paths

# 使用示例
with open("gcp_recon_results.json") as f:
    data = json.load(f)

graph_builder = GCPAttackGraph(data)
graph = graph_builder.build_graph()
attack_paths = graph_builder.find_attack_paths()
exposure = graph_builder.find_data_exposure()

print("=== 攻击路径 ===")
for path in attack_paths:
    print(json.dumps(path, indent=2))

print("\n=== 数据暴露 ===")
for path in exposure:
    print(json.dumps(path, indent=2))

持续监控#

实时监控脚本#

#!/bin/bash
# GCP资源实时监控脚本

PROJECT_ID=$(gcloud config get-value project)
OUTPUT_DIR="gcp_monitoring"
mkdir -p "$OUTPUT_DIR"

INTERVAL=300  # 每5分钟检查一次

while true; do
    TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    LOG_FILE="$OUTPUT_DIR/monitor_$TIMESTAMP.log"
    
    echo "$(date): 开始监控" > "$LOG_FILE"
    
    # 监控计算实例状态
    echo "=== 计算实例状态 ===" >> "$LOG_FILE"
    gcloud compute instances list --format="table(name,status,zone,machineType)" >> "$LOG_FILE"
    
    # 监控存储桶
    echo "=== 存储桶 ===" >> "$LOG_FILE"
    gsutil ls -p "$PROJECT_ID" >> "$LOG_FILE"
    
    # 监控防火墙规则
    echo "=== 防火墙规则 ===" >> "$LOG_FILE"
    gcloud compute firewall-rules list --format="table(name,network,sourceRanges)" >> "$LOG_FILE"
    
    # 监控IAM变更
    echo "=== IAM策略 ===" >> "$LOG_FILE"
    gcloud projects get-iam-policy "$PROJECT_ID" >> "$LOG_FILE"
    
    # 检查异常
    echo "=== 异常检测 ===" >> "$LOG_FILE"
    
    # 检测新的公共IP
    NEW_PUBLIC_IPS=$(gcloud compute instances list --filter="networkInterfaces[0].accessConfigs[0].natIP:*" --format="value(networkInterfaces[0].accessConfigs[0].natIP,name)")
    if [ -n "$NEW_PUBLIC_IPS" ]; then
        echo "警告: 发现新的公共IP" >> "$LOG_FILE"
        echo "$NEW_PUBLIC_IPS" >> "$LOG_FILE"
    fi
    
    # 检测公开的存储桶
    PUBLIC_BUCKETS=$(gsutil ls -p "$PROJECT_ID" | while read bucket; do
        iam=$(gsutil iam get "$bucket" 2>/dev/null)
        if echo "$iam" | grep -q "allUsers"; then
            echo "$bucket"
        fi
    done)
    if [ -n "$PUBLIC_BUCKETS" ]; then
        echo "警告: 发现公开的存储桶" >> "$LOG_FILE"
        echo "$PUBLIC_BUCKETS" >> "$LOG_FILE"
    fi
    
    # 检测开放的高危端口
    OPEN_PORTS=$(gcloud compute firewall-rules list --filter="sourceRanges:0.0.0.0/0" --format="value(name,allowed[].ports)" | grep -E "22|3389|80|443")
    if [ -n "$OPEN_PORTS" ]; then
        echo "警告: 发现开放的高危端口" >> "$LOG_FILE"
        echo "$OPEN_PORTS" >> "$LOG_FILE"
    fi
    
    echo "$(date): 监控完成" >> "$LOG_FILE"
    
    sleep "$INTERVAL"
done

实战案例#

案例1: GCP项目安全评估#

场景描述#

对GCP项目进行全面的安全评估，识别潜在的安全风险和配置问题。

实施步骤#

#!/bin/bash
# GCP安全评估脚本

PROJECT_ID=$(gcloud config get-value project)
OUTPUT_DIR="gcp_security_assessment_$PROJECT_ID"
mkdir -p "$OUTPUT_DIR"

echo "=== GCP安全评估 ==="
echo "项目ID: $PROJECT_ID"
echo "输出目录: $OUTPUT_DIR"
echo ""

# 1. 身份和访问管理评估
echo "[1/8] 评估IAM配置..."
cat > "$OUTPUT_DIR/iam_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== IAM安全评估 ==="

# 检查项目信息
echo "项目信息:"
gcloud projects describe $(gcloud config get-value project)

# 检查用户
echo "用户列表:"
gcloud iam service-accounts list

# 检查角色分配
echo "角色分配:"
gcloud projects get-iam-policy $(gcloud config get-value project)

# 检查服务账户
echo "服务账户:"
gcloud iam service-accounts list
EOF
chmod +x "$OUTPUT_DIR/iam_assessment.sh"
"$OUTPUT_DIR/iam_assessment.sh" > "$OUTPUT_DIR/iam_report.txt" 2>&1

# 2. 网络安全评估
echo "[2/8] 评估网络安全..."
cat > "$OUTPUT_DIR/network_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== 网络安全评估 ==="

# 检查VPC网络
echo "VPC网络列表:"
gcloud compute networks list

# 检查子网
echo "子网列表:"
gcloud compute networks subnets list

# 检查防火墙规则
echo "防火墙规则:"
gcloud compute firewall-rules list

# 检查路由
echo "路由列表:"
gcloud compute routes list
EOF
chmod +x "$OUTPUT_DIR/network_assessment.sh"
"$OUTPUT_DIR/network_assessment.sh" > "$OUTPUT_DIR/network_report.txt" 2>&1

# 3. 存储安全评估
echo "[3/8] 评估存储安全..."
cat > "$OUTPUT_DIR/storage_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== 存储安全评估 ==="

# 检查存储桶
echo "存储桶列表:"
gsutil ls -p $(gcloud config get-value project)

# 检查存储桶的IAM策略
for bucket in $(gsutil ls -p $(gcloud config get-value project)); do
    echo "存储桶: $bucket"
    gsutil iam get "$bucket" 2>/dev/null || echo "无法访问"
done

# 检查存储桶的加密
for bucket in $(gsutil ls -p $(gcloud config get-value project)); do
    echo "存储桶: $bucket"
    gsutil ls -L "$bucket" | grep -i encryption
done
EOF
chmod +x "$OUTPUT_DIR/storage_assessment.sh"
"$OUTPUT_DIR/storage_assessment.sh" > "$OUTPUT_DIR/storage_report.txt" 2>&1

# 4. 计算资源评估
echo "[4/8] 评估计算资源..."
cat > "$OUTPUT_DIR/compute_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== 计算资源评估 ==="

# 计算实例
echo "计算实例列表:"
gcloud compute instances list

# Cloud Functions
echo "Cloud Functions列表:"
gcloud functions list

# App Engine
echo "App Engine服务:"
gcloud app services list
EOF
chmod +x "$OUTPUT_DIR/compute_assessment.sh"
"$OUTPUT_DIR/compute_assessment.sh" > "$OUTPUT_DIR/compute_report.txt" 2>&1

# 5. 数据库评估
echo "[5/8] 评估数据库..."
cat > "$OUTPUT_DIR/database_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== 数据库评估 ==="

# Cloud SQL实例
echo "Cloud SQL实例:"
gcloud sql instances list

# BigQuery数据集
echo "BigQuery数据集:"
bq ls --project_id=$(gcloud config get-value project)
EOF
chmod +x "$OUTPUT_DIR/database_assessment.sh"
"$OUTPUT_DIR/database_assessment.sh" > "$OUTPUT_DIR/database_report.txt" 2>&1

# 6. 日志和监控评估
echo "[6/8] 评估日志和监控..."
cat > "$OUTPUT_DIR/logging_assessment.sh" << 'EOF'
#!/bin/bash
echo "=== 日志和监控评估 ==="

# 检查日志
echo "日志接收器:"
gcloud logging sinks list

# 检查监控
echo "监控策略:"
gcloud alpha monitoring policies list 2>/dev/null || echo "监控策略未配置"
EOF
chmod +x "$OUTPUT_DIR/logging_assessment.sh"
"$OUTPUT_DIR/logging_assessment.sh" > "$OUTPUT_DIR/logging_report.txt" 2>&1

# 7. 生成综合报告
echo "[7/8] 生成综合报告..."
cat > "$OUTPUT_DIR/final_report.txt" << EOF
GCP安全评估综合报告
====================
项目ID: $PROJECT_ID
评估时间: $(date)

1. 身份和访问管理
2. 网络安全
3. 存储安全
4. 计算资源
5. 数据库
6. 日志和监控

详细报告请查看各分类报告文件。
EOF

# 8. 生成HTML报告
echo "[8/8] 生成HTML报告..."
cat > "$OUTPUT_DIR/report.html" << EOF
<!DOCTYPE html>
<html>
<head>
    <title>GCP安全评估报告</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { color: #333; }
        h2 { color: #666; }
        .section { margin: 20px 0; padding: 10px; border: 1px solid #ddd; }
        .warning { color: orange; }
        .danger { color: red; }
        .safe { color: green; }
    </style>
</head>
<body>
    <h1>GCP安全评估报告</h1>
    <p>项目ID: $PROJECT_ID</p>
    <p>评估时间: $(date)</p>
    
    <div class="section">
        <h2>身份和访问管理</h2>
        <p>详细报告: iam_report.txt</p>
    </div>
    
    <div class="section">
        <h2>网络安全</h2>
        <p>详细报告: network_report.txt</p>
    </div>
    
    <div class="section">
        <h2>存储安全</h2>
        <p>详细报告: storage_report.txt</p>
    </div>
    
    <div class="section">
        <h2>计算资源</h2>
        <p>详细报告: compute_report.txt</p>
    </div>
    
    <div class="section">
        <h2>数据库</h2>
        <p>详细报告: database_report.txt</p>
    </div>
    
    <div class="section">
        <h2>日志和监控</h2>
        <p>详细报告: logging_report.txt</p>
    </div>
</body>
</html>
EOF

echo ""
echo "GCP安全评估完成！所有结果已保存到 $OUTPUT_DIR 目录"
echo ""
echo "报告文件:"
ls -la "$OUTPUT_DIR"

案例2: 云环境渗透测试#

场景描述#

在授权的GCP环境中进行渗透测试，识别安全漏洞和攻击路径。

实施步骤#

#!/bin/bash
# GCP环境渗透测试脚本

OUTPUT_DIR="gcp_pentest_results"
mkdir -p "$OUTPUT_DIR"

echo "=== GCP环境渗透测试 ==="
echo ""

# 1. 信息收集阶段
echo "[1/5] 信息收集..."

# 收集项目信息
gcloud projects describe $(gcloud config get-value project) > "$OUTPUT_DIR/project.json"

# 收集区域信息
gcloud compute regions list > "$OUTPUT_DIR/regions.json"

# 2. 资产发现阶段
echo "[2/5] 资产发现..."

# 发现计算实例
gcloud compute instances list > "$OUTPUT_DIR/instances.json"

# 发现Cloud Functions
gcloud functions list > "$OUTPUT_DIR/functions.json"

# 发现存储桶
gsutil ls -p $(gcloud config get-value project) > "$OUTPUT_DIR/buckets.json"

# 3. 漏洞识别阶段
echo "[3/5] 漏洞识别..."

# 检查公开的存储桶
cat > "$OUTPUT_DIR/storage_vulns.txt" << 'EOF'
公开存储桶检查:
EOF
gsutil ls -p $(gcloud config get-value project) | while read bucket; do
    iam=$(gsutil iam get "$bucket" 2>/dev/null)
    if echo "$iam" | grep -q "allUsers"; then
        echo "警告: 存储桶 $bucket 公开可读" >> "$OUTPUT_DIR/storage_vulns.txt"
    fi
done

# 检查开放的防火墙规则
cat > "$OUTPUT_DIR/firewall_vulns.txt" << 'EOF'
开放防火墙规则检查:
EOF
gcloud compute firewall-rules list --filter="sourceRanges:0.0.0.0/0" >> "$OUTPUT_DIR/firewall_vulns.txt"

# 4. 权限提升尝试
echo "[4/5] 权限提升..."

# 检查当前权限
cat > "$OUTPUT_DIR/current_permissions.txt" << 'EOF'
当前权限检查:
EOF
gcloud projects get-iam-policy $(gcloud config get-value project) > "$OUTPUT_DIR/iam.json"

# 5. 生成测试报告
echo "[5/5] 生成测试报告..."

cat > "$OUTPUT_DIR/pentest_report.txt" << EOF
GCP环境渗透测试报告
==================
测试时间: $(date)

1. 收集的项目信息
2. 发现的资产
3. 识别的漏洞
4. 权限提升路径
5. 建议修复措施

详细结果请查看各个JSON和TXT文件。
EOF

echo ""
echo "渗透测试完成！所有结果已保存到 $OUTPUT_DIR 目录"

总结#

GCPRecon是一款功能强大的GCP云平台侦察工具，为GCP云安全评估和渗透测试提供了全面的支持。

核心优势#

全面覆盖: 支持几乎所有GCP服务的侦察
自动化: 自动枚举和分析GCP资源
漏洞检测: 内置多种漏洞检测规则
报告生成: 支持多种输出格式
易于使用: 简单的命令行界面

应用场景#

GCP云安全评估和渗透测试
GCP项目资产发现
安全配置审计
合规性检查
威胁情报收集

最佳实践#

权限控制: 使用最小权限原则运行侦察
结果保护: 妥善保管侦察结果，避免泄露敏感信息
定期扫描: 定期进行安全扫描，及时发现新风险
结果验证: 对发现的问题进行验证，避免误报
持续监控: 建立持续监控机制，及时响应安全事件

注意事项#

仅在获得授权的项目上运行
遵守GCP服务条款和使用政策
注意API调用限制和成本
妥善处理敏感信息
定期更新工具以获取最新功能