云服务情报收集 on Linux邪修

AWSRecon使用教程

Mon, 01 Jan 0001 00:00:00 +0000

AWSRecon使用教程#

软件介绍#

AWSRecon是一款专门用于AWS（Amazon Web Services）云平台侦察和信息收集的工具。它能够自动发现和枚举AWS账户中的资源，包括EC2实例、S3存储桶、RDS数据库、Lambda函数等，是云安全评估和渗透测试的重要工具。

主要功能#

AWS账户资源枚举
S3存储桶发现
EC2实例信息收集
IAM策略分析
安全组检测
漏洞识别
合规性检查
报告生成

适用场景#

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

入门级使用#

安装AWSRecon#

使用Go安装#

# 安装Go语言（如果未安装）
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

# 安装AWSRecon
go install github.com/darkbitio/awsrecon@latest

# 验证安装
awsrecon --version

使用Docker安装#

# 使用Docker运行
docker run -it --rm darkbit/awsrecon:latest

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

配置AWS凭证#

创建AWS凭证#

# 安装AWS CLI
pip install awscli

# 配置AWS凭证
aws configure

# 或设置环境变量
export AWS_ACCESS_KEY_ID="your_access_key"
export AWS_SECRET_ACCESS_KEY="your_secret_key"
export AWS_DEFAULT_REGION="us-east-1"

使用IAM角色#

# 如果在EC2上运行，使用IAM角色
aws sts assume-role --role-arn "arn:aws:iam::123456789012:role/ReconRole" --role-session-name recon

基本侦察#

快速扫描#

# 快速扫描所有资源
awsrecon scan --all

# 扫描特定区域
awsrecon scan --region us-east-1

# 扫描特定服务
awsrecon scan --service ec2
awsrecon scan --service s3
awsrecon scan --service rds

枚举S3存储桶#

# 枚举所有S3存储桶
awsrecon enum s3

# 列出存储桶内容
awsrecon enum s3 --bucket my-bucket

# 检查存储桶权限
awsrecon enum s3 --acl

初级使用#

资源枚举#

EC2实例枚举#

# 枚举所有EC2实例
awsrecon enum ec2

# 枚举特定实例
awsrecon enum ec2 --instance-id i-1234567890abcdef0

# 枚举安全组
awsrecon enum ec2 --security-groups

# 枚举Volumes
awsrecon enum ec2 --volumes

RDS数据库枚举#

# 枚举所有RDS实例
awsrecon enum rds

# 枚举数据库集群
awsrecon enum rds --clusters

# 枚举快照
awsrecon enum rds --snapshots

IAM分析#

枚举IAM用户#

# 枚举所有IAM用户
awsrecon enum iam --users

# 枚举IAM角色
awsrecon enum iam --roles

# 枚举IAM策略
awsrecon enum iam --policies

# 枚举访问密钥
awsrecon enum iam --access-keys

分析IAM策略#

# 分析用户权限
awsrecon analyze iam --user myuser

# 分析策略文档
awsrecon analyze iam --policy arn:aws:iam::aws:policy/ReadOnlyAccess

# 检查过度权限
awsrecon analyze iam --privileged

中级使用#

漏洞扫描#

检查公开存储桶#

# 检查S3存储桶ACL
awsrecon scan s3 --acl

# 检查存储桶策略
awsrecon scan s3 --policy

# 检查公开访问设置
awsrecon scan s3 --public-access

检查不安全的配置#

# 检查安全组规则
awsrecon scan ec2 --security-groups --open-ports

# 检查未加密的存储
awsrecon scan ebs --unencrypted

# 检查过期的访问密钥
awsrecon scan iam --expired-keys

数据导出#

导出为JSON#

# 导出所有侦察结果
awsrecon scan --all --output json > results.json

# 导出特定服务
awsrecon enum ec2 --output json > ec2.json

# 导出特定区域
awsrecon scan --region us-west-2 --output json > west2.json

导出为CSV#

# 导出为CSV格式
awsrecon enum ec2 --output csv > ec2.csv

# 导出存储桶列表
awsrecon enum s3 --output csv > s3.csv

批量操作#

扫描多个区域#

#!/bin/bash
# 扫描多个区域的EC2实例

REGIONS=("us-east-1" "us-west-2" "eu-west-1" "ap-northeast-1")

for region in "${REGIONS[@]}"; do
 echo "=== 扫描区域: $region ==="
 awsrecon enum ec2 --region "$region" --output json > "ec2_$region.json"
done

定期扫描#

#!/bin/bash
# 定期扫描脚本

INTERVAL=86400 # 每天扫描一次
OUTPUT_DIR="aws_recon_results"

mkdir -p "$OUTPUT_DIR"

while true; do
 TIMESTAMP=$(date +%Y%m%d_%H%M%S)
 
 echo "$(date): 开始扫描"
 
 # 扫描所有资源
 awsrecon scan --all --output json > "$OUTPUT_DIR/full_scan_$TIMESTAMP.json"
 
 # 检查变化
 if [ -f "$OUTPUT_DIR/latest.json" ]; then
 diff "$OUTPUT_DIR/latest.json" "$OUTPUT_DIR/full_scan_$TIMESTAMP.json" > "$OUTPUT_DIR/changes_$TIMESTAMP.txt"
 fi
 
 cp "$OUTPUT_DIR/full_scan_$TIMESTAMP.json" "$OUTPUT_DIR/latest.json"
 
 echo "$(date): 扫描完成"
 sleep "$INTERVAL"
done

中上级使用#

高级分析#

权限提升检测#

#!/bin/bash
# 检测权限提升路径

awsrecon analyze iam --privilege-escalation

# 检查可写策略
awsrecon analyze iam --writable-policies

# 检查Lambda执行角色
awsrecon analyze iam --lambda-roles

风险评估#

#!/bin/bash
# AWS账户风险评估

OUTPUT_FILE="risk_assessment.txt"

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

# 检查公开S3存储桶
echo "=== 公开S3存储桶 ===" >> "$OUTPUT_FILE"
awsrecon scan s3 --public-access >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查开放的安全组
echo "=== 开放安全组 ===" >> "$OUTPUT_FILE"
awsrecan scan ec2 --security-groups --open-ports >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查过期的访问密钥
echo "=== 过期的访问密钥 ===" >> "$OUTPUT_FILE"
awsrecon scan iam --expired-keys >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

# 检查未加密的资源
echo "=== 未加密的资源 ===" >> "$OUTPUT_FILE"
awsrecon scan ebs --unencrypted >> "$OUTPUT_FILE" 2>&1

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

自动化侦察#

完整侦察脚本#

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

ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
OUTPUT_DIR="aws_recon_$ACCOUNT_ID"
mkdir -p "$OUTPUT_DIR"

echo "=== AWS账户侦察 ===" 
echo "账户ID: $ACCOUNT_ID"
echo "输出目录: $OUTPUT_DIR"

# 1. 枚举EC2实例
echo "[1/10] 枚举EC2实例..."
awsrecon enum ec2 --output json > "$OUTPUT_DIR/ec2.json"

# 2. 枚举S3存储桶
echo "[2/10] 枚举S3存储桶..."
awsrecon enum s3 --output json > "$OUTPUT_DIR/s3.json"

# 3. 枚举RDS实例
echo "[3/10] 枚举RDS实例..."
awsrecon enum rds --output json > "$OUTPUT_DIR/rds.json"

# 4. 枚举Lambda函数
echo "[4/10] 枚举Lambda函数..."
awsrecon enum lambda --output json > "$OUTPUT_DIR/lambda.json"

# 5. 枚举IAM用户
echo "[5/10] 枚举IAM用户..."
awsrecon enum iam --users --output json > "$OUTPUT_DIR/iam_users.json"

# 6. 枚举IAM角色
echo "[6/10] 枚举IAM角色..."
awsrecon enum iam --roles --output json > "$OUTPUT_DIR/iam_roles.json"

# 7. 扫描安全组
echo "[7/10] 扫描安全组..."
awsrecon scan ec2 --security-groups --output json > "$OUTPUT_DIR/security_groups.json"

# 8. 检查S3权限
echo "[8/10] 检查S3权限..."
awsrecon scan s3 --acl --policy --output json > "$OUTPUT_DIR/s3_permissions.json"

# 9. 检查IAM策略
echo "[9/10] 检查IAM策略..."
awsrecon analyze iam --privileged --output json > "$OUTPUT_DIR/iam_privileged.json"

# 10. 生成汇总报告
echo "[10/10] 生成汇总报告..."
cat > "$OUTPUT_DIR/summary.txt" << EOF
AWS账户侦察汇总报告
====================
账户ID: $ACCOUNT_ID
侦察时间: $(date)

资源统计:
- EC2实例: $(jq length "$OUTPUT_DIR/ec2.json")
- S3存储桶: $(jq length "$OUTPUT_DIR/s3.json")
- RDS实例: $(jq length "$OUTPUT_DIR/rds.json")
- Lambda函数: $(jq length "$OUTPUT_DIR/lambda.json")
- IAM用户: $(jq length "$OUTPUT_DIR/iam_users.json")
- IAM角色: $(jq length "$OUTPUT_DIR/iam_roles.json")
EOF

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

高级使用#

云安全分析#

攻击面分析#

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

def analyze_aws_attack_surface(recon_results):
 """分析AWS攻击面"""
 
 attack_surface = {
 "public_endpoints": [],
 "exposed_services": [],
 "privilege_paths": [],
 "data_exposure": []
 }
 
 # 分析公开的S3存储桶
 for bucket in recon_results.get("s3", []):
 if bucket.get("acl", {}).get("PublicAccessBlockConfiguration", {}).get("BlockPublicAcls") == False:
 attack_surface["public_endpoints"].append({
 "type": "s3",
 "bucket": bucket["name"],
 "issue": "公开访问未完全阻止"
 })
 
 # 分析开放的安全组
 for sg in recon_results.get("security_groups", []):
 for rule in sg.get("IpPermissions", []):
 if rule.get("IpRanges") and any(ip.get("CidrIp") == "0.0.0.0/0" for ip in rule["IpRanges"]):
 attack_surface["exposed_services"].append({
 "type": "security_group",
 "sg_id": sg["GroupId"],
 "port": rule.get("FromPort", "N/A"),
 "issue": "对0.0.0.0/0开放"
 })
 
 # 分析权限
 for user in recon_results.get("iam_users", []):
 for policy in user.get("AttachedManagedPolicies", []):
 if "AdministratorAccess" in policy.get("PolicyName", ""):
 attack_surface["privilege_paths"].append({
 "type": "iam_user",
 "user": user["UserName"],
 "policy": policy["PolicyName"],
 "issue": "具有管理员权限"
 })
 
 return attack_surface

# 使用示例
with open("aws_recon_results.json") as f:
 results = json.load(f)
 
attack_surface = analyze_aws_attack_surface(results)
print(json.dumps(attack_surface, indent=2))

漏洞检测#

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

OUTPUT_FILE="vulnerability_scan.txt"

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

# 1. 检测公开的S3存储桶
echo "[1] 检测公开的S3存储桶..." >> "$OUTPUT_FILE"
awsrecon scan s3 --public-access 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 2. 检测开放SSH的安全组
echo "[2] 检测开放SSH的安全组..." >> "$OUTPUT_FILE"
aws ec2 describe-security-groups --filters "Name=ip-permission.from-port,Values=22" "Name=ip-permission.cidr,Values=0.0.0.0/0" --query "SecurityGroups[*].{ID:GroupId,Name:GroupName}" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 3. 检测开放RDP的安全组
echo "[3] 检测开放RDP的安全组..." >> "$OUTPUT_FILE"
aws ec2 describe-security-groups --filters "Name=ip-permission.from-port,Values=3389" "Name=ip-permission.cidr,Values=0.0.0.0/0" --query "SecurityGroups[*].{ID:GroupId,Name:GroupName}" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 4. 检测未加密的EBS卷
echo "[4] 检测未加密的EBS卷..." >> "$OUTPUT_FILE"
aws ec2 describe-volumes --filters "Name=encrypted,Values=false" --query "Volumes[*].VolumeId" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 5. 检测公开的S3存储桶策略
echo "[5] 检测公开的S3存储桶策略..." >> "$OUTPUT_FILE"
aws s3api list-buckets --query "Buckets[*].Name" --output text | tr '\t' '\n' | while read bucket; do
 policy=$(aws s3api get-bucket-policy --bucket "$bucket" --query Policy --output text 2>/dev/null)
 if [ -n "$policy" ]; then
 echo "存储桶: $bucket" >> "$OUTPUT_FILE"
 echo "$policy" >> "$OUTPUT_FILE"
 fi
done
echo "" >> "$OUTPUT_FILE"

# 6. 检测公开的快照
echo "[6] 检测公开的快照..." >> "$OUTPUT_FILE"
aws ec2 describe-snapshots --OwnerIds self --query "Snapshots[*].SnapshotId" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

echo "漏洞扫描完成！"

合规性检查#

AWS CIS基准检查#

#!/bin/bash
# AWS CIS基准检查脚本

CIS_CHECKS=(
 "1.1: 确保未创建根访问密钥"
 "1.2: 确保MFA已启用"
 "1.3: 确保密码策略已配置"
 "1.4: 确保IAM用户不使用硬编码凭证"
 "2.1: 确保CloudTrail已启用"
 "2.2: 确保S3存储桶日志已启用"
 "2.3: 确保VPC流日志已启用"
 "3.1: 确保安全组未开放SSH"
 "3.2: 确保安全组未开放RDP"
 "3.3: 确保没有公开的S3存储桶"
)

OUTPUT_FILE="cis_compliance.txt"

echo "=== AWS CIS基准合规性检查 ===" > "$OUTPUT_FILE"
echo "检查时间: $(date)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

for check in "${CIS_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 AWSAttackPathAnalyzer:
 def __init__(self, recon_data):
 self.data = recon_data
 self.graph = defaultdict(list)
 
 def build_graph(self):
 """构建攻击图"""
 # 从IAM用户开始
 for user in self.data.get("iam_users", []):
 self.graph["user:" + user["UserName"]] = []
 
 # 添加访问密钥
 for key in user.get("AccessKeys", []):
 self.graph["user:" + user["UserName"]].append(
 f"key:{key['AccessKeyId']}"
 )
 
 # 从EC2实例
 for instance in self.data.get("ec2", []):
 self.graph["ec2:" + instance["InstanceId"]] = []
 
 # 添加安全组
 for sg in instance.get("SecurityGroups", []):
 self.graph["ec2:" + instance["InstanceId"]].append(
 f"sg:{sg['GroupId']}"
 )
 
 # 从S3存储桶
 for bucket in self.data.get("s3", []):
 self.graph["s3:" + bucket["name"]] = []
 
 return self.graph
 
 def find_privilege_escalation(self):
 """查找权限提升路径"""
 escalation_paths = []
 
 # 检查具有IAM写入权限的用户
 for user in self.data.get("iam_users", []):
 for policy in user.get("AttachedManagedPolicies", []):
 if "iam:AttachUserPolicy" in policy.get("PolicyName", "") or \
 "iam:PutUserPolicy" in policy.get("PolicyName", ""):
 escalation_paths.append({
 "user": user["UserName"],
 "path": "可以直接附加管理员策略",
 "risk": "高"
 })
 
 return escalation_paths
 
 def find_data_exposure(self):
 """查找数据暴露路径"""
 exposure_paths = []
 
 # 检查公开的S3存储桶
 for bucket in self.data.get("s3", []):
 if bucket.get("PublicAccessBlockConfiguration", {}).get("BlockPublicAcls") == False:
 exposure_paths.append({
 "bucket": bucket["name"],
 "issue": "S3存储桶可能公开访问",
 "risk": "高"
 })
 
 # 检查开放的安全组
 for sg in self.data.get("security_groups", []):
 for rule in sg.get("IpPermissions", []):
 if rule.get("IpRanges") and any(ip.get("CidrIp") == "0.0.0.0/0" for ip in rule["IpRanges"]):
 if rule.get("FromPort") in [22, 3389, 80, 443]:
 exposure_paths.append({
 "security_group": sg["GroupId"],
 "port": rule.get("FromPort"),
 "issue": f"端口{rule.get('FromPort')}对公网开放",
 "risk": "中"
 })
 
 return exposure_paths

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

analyzer = AWSAttackPathAnalyzer(data)
graph = analyzer.build_graph()
escalation = analyzer.find_privilege_escalation()
exposure = analyzer.find_data_exposure()

print("=== 权限提升路径 ===")
for path in escalation:
 print(json.dumps(path, indent=2))

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

持续监控#

实时监控脚本#

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

ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
OUTPUT_DIR="aws_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"
 
 # 监控EC2实例状态
 echo "=== EC2实例状态 ===" >> "$LOG_FILE"
 aws ec2 describe-instances --query "Reservations[*].Instances[*].{ID:InstanceId,State:State.Name,IP:PublicIpAddress}" >> "$LOG_FILE"
 
 # 监控安全组变更
 echo "=== 安全组变更 ===" >> "$LOG_FILE"
 aws ec2 describe-security-groups --query "SecurityGroups[*].{ID:GroupId,Name:GroupName}" >> "$LOG_FILE"
 
 # 监控S3存储桶
 echo "=== S3存储桶 ===" >> "$LOG_FILE"
 aws s3api list-buckets --query "Buckets[*].Name" >> "$LOG_FILE"
 
 # 监控IAM变更
 echo "=== IAM用户 ===" >> "$LOG_FILE"
 aws iam list-users --query "Users[*].UserName" >> "$LOG_FILE"
 
 # 检查异常
 echo "=== 异常检测 ===" >> "$LOG_FILE"
 
 # 检测新的公开S3存储桶
 aws s3api list-buckets --query "Buckets[*].Name" --output text | tr '\t' '\n' | while read bucket; do
 block_config=$(aws s3api get-public-access-block --bucket "$bucket" --query PublicAccessBlockConfiguration 2>/dev/null)
 if [ -n "$block_config" ]; then
 if echo "$block_config" | grep -q "false"; then
 echo "警告: 存储桶 $bucket 可能公开访问" >> "$LOG_FILE"
 fi
 fi
 done
 
 # 检测开放的高危端口
 aws ec2 describe-security-groups --filters "Name=ip-permission.from-port,Values=22" "Name=ip-permission.cidr,Values=0.0.0.0/0" --query "SecurityGroups[*].GroupId" --output text | tr '\t' '\n' | while read sg; do
 if [ -n "$sg" ]; then
 echo "警告: 安全组 $sg 开放SSH到公网" >> "$LOG_FILE"
 fi
 done
 
 echo "$(date): 监控完成" >> "$LOG_FILE"
 
 sleep "$INTERVAL"
done

实战案例#

案例1: AWS账户安全评估#

场景描述#

对AWS账户进行全面的安全评估，识别潜在的安全风险和配置问题。

AzRecon使用教程

Mon, 01 Jan 0001 00:00:00 +0000

AzRecon使用教程#

软件介绍#

AzRecon是一款专门用于Microsoft Azure云平台侦察和信息收集的工具。它能够自动发现和枚举Azure订阅中的资源，包括虚拟机、存储账户、数据库、函数应用等，是Azure云安全评估和渗透测试的重要工具。

主要功能#

Azure订阅资源枚举
存储账户发现
虚拟机信息收集
权限和角色分析
安全配置检测
漏洞识别
合规性检查
报告生成

适用场景#

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

入门级使用#

安装AzRecon#

使用Python安装#

# 安装Python依赖
pip install azure-identity
pip install azure-mgmt-resource
pip install azure-mgmt-compute
pip install azure-mgmt-storage
pip install azure-mgmt-network
pip install azure-mgmt-web
pip install azure-mgmt-sql

# 克隆AzRecon仓库
git clone https://github.com/microsoft/AzRecon.git
cd AzRecon

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

使用Docker安装#

# 使用Docker运行
docker run -it --rm azrecon/azrecon:latest

# 或构建本地镜像
git clone https://github.com/microsoft/AzRecon.git
cd AzRecon
docker build -t azrecon .
docker run -it azrecon

配置Azure凭证#

使用Azure CLI登录#

# 安装Azure CLI
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# 登录Azure
az login

# 设置订阅
az account set --subscription "your-subscription-id"

使用服务主体#

# 创建服务主体
az ad sp create-for-rbac --name "AzRecon" --role Contributor --scopes /subscriptions/your-subscription-id

# 输出将包含:
# - appId (客户端ID)
# - password (客户端密钥)
# - tenant (租户ID)

# 使用服务主体登录
az login --service-principal -u <appId> -p <password> --tenant <tenant>

使用环境变量#

# 设置环境变量
export AZURE_CLIENT_ID="your_client_id"
export AZURE_CLIENT_SECRET="your_client_secret"
export AZURE_TENANT_ID="your_tenant_id"
export AZURE_SUBSCRIPTION_ID="your_subscription_id"

基本侦察#

快速扫描#

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

# 扫描特定资源组
python azrecon.py --resource-group my-resource-group

# 扫描特定订阅
python azrecon.py --subscription "your-subscription-id"

枚举虚拟机#

# 枚举所有虚拟机
python azrecon.py --vms

# 枚举特定区域的虚拟机
python azrecon.py --vms --location eastus

# 枚举虚拟机的详细信息
python azrecon.py --vms --detailed

初级使用#

资源枚举#

存储账户枚举#

# 枚举所有存储账户
python azrecon.py --storage

# 枚举存储账户的容器
python azrecon.py --storage --containers

# 检查存储账户的访问级别
python azrecon.py --storage --access-tier

# 检查存储账户的加密设置
python azrecon.py --storage --encryption

数据库枚举#

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

# 枚举Cosmos DB
python azrecon.py --cosmos

# 枚举PostgreSQL数据库
python azrecon.py --postgresql

# 枚举MySQL数据库
python azrecon.py --mysql

网络枚举#

虚拟网络枚举#

# 枚举所有虚拟网络
python azrecon.py --vnets

# 枚举子网
python azrecon.py --vnets --subnets

# 枚举网络安全组
python azrecon.py --nsgs

# 枚举公共IP地址
python azrecon.py --public-ips

负载均衡器枚举#

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

# 枚举应用网关
python azrecon.py --application-gateways

中级使用#

权限分析#

角色和权限枚举#

# 枚举所有角色分配
python azrecon.py --rbac

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

# 枚举特定服务主体的权限
python azrecon.py --rbac --spn <service-principal-id>

# 枚举自定义角色
python azrecon.py --rbac --custom-roles

权限提升检测#

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

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

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

漏洞扫描#

检查不安全的配置#

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

# 检查公开的存储账户
python azrecon.py --scan --public-storage

# 检查开放的安全组规则
python azrecon.py --scan --open-nsg-rules

# 检查未启用诊断的资源
python azrecon.py --scan --no-diagnostics

检查合规性问题#

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

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

# 检查Azure Defender状态
python azrecon.py --azure-defender

数据导出#

导出为JSON#

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

# 导出特定资源
python azrecon.py --vms --output json > vms.json

# 导出特定订阅
python azrecon.py --subscription "your-subscription-id" --output json > subscription.json

导出为CSV#

# 导出为CSV格式
python azrecon.py --vms --output csv > vms.csv

# 导出存储账户列表
python azrecon.py --storage --output csv > storage.csv

中上级使用#

高级分析#

攻击面分析#

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

OUTPUT_DIR="azure_attack_surface"
mkdir -p "$OUTPUT_DIR"

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

# 2. 分析存储账户
echo "[2/5] 分析存储账户..."
python azrecon.py --storage --output json > "$OUTPUT_DIR/storage.json"
python azrecon.py --storage --containers --output json > "$OUTPUT_DIR/storage_containers.json"

# 3. 分析网络安全组
echo "[3/5] 分析网络安全组..."
python azrecon.py --nsgs --output json > "$OUTPUT_DIR/nsgs.json"

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

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

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

风险评估#

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

OUTPUT_FILE="azure_risk_assessment.txt"

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

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

echo "" >> "$OUTPUT_FILE"

# 检查开放的安全组
echo "=== 开放的安全组规则 ===" >> "$OUTPUT_FILE"
python azrecon.py --scan --open-nsg-rules >> "$OUTPUT_FILE" 2>&1

echo "" >> "$OUTPUT_FILE"

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

echo "" >> "$OUTPUT_FILE"

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

echo "" >> "$OUTPUT_FILE"

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

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

自动化侦察#

完整侦察脚本#

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

SUBSCRIPTION_ID=$(az account show --query id -o tsv)
OUTPUT_DIR="azure_recon_$SUBSCRIPTION_ID"
mkdir -p "$OUTPUT_DIR"

echo "=== Azure账户侦察 ==="
echo "订阅ID: $SUBSCRIPTION_ID"
echo "输出目录: $OUTPUT_DIR"

# 1. 枚举虚拟机
echo "[1/12] 枚举虚拟机..."
python azrecon.py --vms --output json > "$OUTPUT_DIR/vms.json"

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

# 3. 枚举SQL数据库
echo "[3/12] 枚举SQL数据库..."
python azrecon.py --sql --output json > "$OUTPUT_DIR/sql.json"

# 4. 枚举Cosmos DB
echo "[4/12] 枚举Cosmos DB..."
python azrecon.py --cosmos --output json > "$OUTPUT_DIR/cosmos.json"

# 5. 枚举虚拟网络
echo "[5/12] 枚举虚拟网络..."
python azrecon.py --vnets --output json > "$OUTPUT_DIR/vnets.json"

# 6. 枚举网络安全组
echo "[6/12] 枚举网络安全组..."
python azrecon.py --nsgs --output json > "$OUTPUT_DIR/nsgs.json"

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

# 8. 枚举函数应用
echo "[8/12] 枚举函数应用..."
python azrecon.py --functions --output json > "$OUTPUT_DIR/functions.json"

# 9. 枚举应用服务
echo "[9/12] 枚举应用服务..."
python azrecon.py --app-services --output json > "$OUTPUT_DIR/app_services.json"

# 10. 枚举RBAC
echo "[10/12] 枚举RBAC..."
python azrecon.py --rbac --output json > "$OUTPUT_DIR/rbac.json"

# 11. 枚举密钥保管库
echo "[11/12] 枚举密钥保管库..."
python azrecon.py --keyvaults --output json > "$OUTPUT_DIR/keyvaults.json"

# 12. 生成汇总报告
echo "[12/12] 生成汇总报告..."
cat > "$OUTPUT_DIR/summary.txt" << EOF
Azure账户侦察汇总报告
====================
订阅ID: $SUBSCRIPTION_ID
侦察时间: $(date)

资源统计:
- 虚拟机: $(jq length "$OUTPUT_DIR/vms.json")
- 存储账户: $(jq length "$OUTPUT_DIR/storage.json")
- SQL数据库: $(jq length "$OUTPUT_DIR/sql.json")
- Cosmos DB: $(jq length "$OUTPUT_DIR/cosmos.json")
- 虚拟网络: $(jq length "$OUTPUT_DIR/vnets.json")
- 网络安全组: $(jq length "$OUTPUT_DIR/nsgs.json")
- 公共IP: $(jq length "$OUTPUT_DIR/public_ips.json")
- 函数应用: $(jq length "$OUTPUT_DIR/functions.json")
- 应用服务: $(jq length "$OUTPUT_DIR/app_services.json")
- 密钥保管库: $(jq length "$OUTPUT_DIR/keyvaults.json")
EOF

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

高级使用#

云安全分析#

攻击路径分析#

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

def analyze_azure_attack_paths(recon_data):
 """分析Azure攻击路径"""
 
 attack_paths = {
 "public_exposure": [],
 "privilege_escalation": [],
 "data_exfiltration": [],
 "lateral_movement": []
 }
 
 # 分析公开暴露
 for vm in recon_data.get("vms", []):
 if vm.get("public_ip"):
 attack_paths["public_exposure"].append({
 "type": "vm",
 "name": vm["name"],
 "public_ip": vm["public_ip"],
 "issue": "虚拟机具有公共IP"
 })
 
 # 分析存储账户
 for storage in recon_data.get("storage", []):
 if storage.get("access_tier") == "Hot":
 attack_paths["data_exfiltration"].append({
 "type": "storage",
 "name": storage["name"],
 "access_tier": storage["access_tier"],
 "issue": "存储账户可能公开访问"
 })
 
 # 分析权限
 for assignment in recon_data.get("rbac", []):
 if assignment.get("role_name") == "Owner":
 attack_paths["privilege_escalation"].append({
 "type": "rbac",
 "principal": assignment["principal_name"],
 "scope": assignment["scope"],
 "issue": "具有所有者权限"
 })
 
 return attack_paths

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

漏洞检测#

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

OUTPUT_FILE="azure_vulnerability_scan.txt"

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

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

# 2. 检测开放SSH的安全组
echo "[2] 检测开放SSH的安全组..." >> "$OUTPUT_FILE"
az network nsg list --query "[?contains(ipConfigurations[0].properties.subnet.properties.addressPrefix, '0.0.0.0/0')]" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

# 3. 检测开放RDP的安全组
echo "[3] 检测开放RDP的安全组..." >> "$OUTPUT_FILE"
az network nsg list --query "[?contains(ipConfigurations[0].properties.subnet.properties.addressPrefix, '0.0.0.0/0')]" 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

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

# 5. 检测未启用诊断的资源
echo "[5] 检测未启用诊断的资源..." >> "$OUTPUT_FILE"
python azrecon.py --scan --no-diagnostics 2>&1 >> "$OUTPUT_FILE" || true
echo "" >> "$OUTPUT_FILE"

echo "漏洞扫描完成！"

合规性检查#

Azure安全基准检查#

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

AZURE_CHECKS=(
 "1.1: 确保启用了Azure Defender"
 "1.2: 确保配置了安全中心"
 "1.3: 确保启用了MFA"
 "1.4: 确保配置了条件访问"
 "2.1: 确保存储账户已加密"
 "2.2: 确保虚拟机已加密"
 "2.3: 确保数据库已加密"
 "3.1: 确保网络安全组已配置"
 "3.2: 确保应用了网络安全最佳实践"
 "3.3: 确保配置了网络观察程序"
)

OUTPUT_FILE="azure_compliance.txt"

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

for check in "${AZURE_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 AzureAttackGraph:
 def __init__(self, recon_data):
 self.data = recon_data
 self.graph = defaultdict(list)
 
 def build_graph(self):
 """构建攻击图"""
 # 从虚拟机开始
 for vm in self.data.get("vms", []):
 self.graph["vm:" + vm["name"]] = []
 
 # 添加公共IP
 if vm.get("public_ip"):
 self.graph["vm:" + vm["name"]].append(
 f"public_ip:{vm['public_ip']}"
 )
 
 # 添加网络安全组
 if vm.get("nsg"):
 self.graph["vm:" + vm["name"]].append(
 f"nsg:{vm['nsg']}"
 )
 
 # 从存储账户
 for storage in self.data.get("storage", []):
 self.graph["storage:" + storage["name"]] = []
 
 # 从数据库
 for db in self.data.get("sql", []):
 self.graph["sql:" + db["name"]] = []
 
 return self.graph
 
 def find_attack_paths(self):
 """查找攻击路径"""
 attack_paths = []
 
 # 检查具有所有者权限的账户
 for assignment in self.data.get("rbac", []):
 if assignment.get("role_name") == "Owner":
 attack_paths.append({
 "principal": assignment["principal_name"],
 "path": "可以直接控制所有资源",
 "risk": "高"
 })
 
 return attack_paths
 
 def find_data_exposure(self):
 """查找数据暴露"""
 exposure_paths = []
 
 # 检查公开的存储账户
 for storage in self.data.get("storage", []):
 if storage.get("allow_blob_public_access") == True:
 exposure_paths.append({
 "storage": storage["name"],
 "issue": "存储账户允许公共访问",
 "risk": "高"
 })
 
 # 检查开放的安全组
 for nsg in self.data.get("nsgs", []):
 for rule in nsg.get("security_rules", []):
 if rule.get("access") == "Allow" and \
 rule.get("direction") == "Inbound":
 if rule.get("source_address_prefix") == "*":
 exposure_paths.append({
 "nsg": nsg["name"],
 "port": rule.get("destination_port_range"),
 "issue": f"端口{rule.get('destination_port_range')}对公网开放",
 "risk": "中"
 })
 
 return exposure_paths

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

graph_builder = AzureAttackGraph(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
# Azure资源实时监控脚本

SUBSCRIPTION_ID=$(az account show --query id -o tsv)
OUTPUT_DIR="azure_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"
 az vm list --query "[].{Name:name,State:powerState,Location:location}" >> "$LOG_FILE"
 
 # 监控存储账户
 echo "=== 存储账户 ===" >> "$LOG_FILE"
 az storage account list --query "[].{Name:name,Location:location,AccessTier:accessTier}" >> "$LOG_FILE"
 
 # 监控网络安全组
 echo "=== 网络安全组 ===" >> "$LOG_FILE"
 az network nsg list --query "[].{Name:name,Location:location}" >> "$LOG_FILE"
 
 # 监控公共IP
 echo "=== 公共IP ===" >> "$LOG_FILE"
 az network public-ip list --query "[].{Name:name,IPAddress:ipAddress,Location:location}" >> "$LOG_FILE"
 
 # 检查异常
 echo "=== 异常检测 ===" >> "$LOG_FILE"
 
 # 检测新的公共IP
 NEW_PUBLIC_IPS=$(az network public-ip list --query "[?ipAddress != null].{Name:name,IPAddress:ipAddress}" --output json)
 if [ -n "$NEW_PUBLIC_IPS" ]; then
 echo "警告: 发现新的公共IP" >> "$LOG_FILE"
 echo "$NEW_PUBLIC_IPS" >> "$LOG_FILE"
 fi
 
 # 检测公开的存储账户
 PUBLIC_STORAGE=$(az storage account list --query "[?allowBlobPublicAccess == true].{Name:name}" --output json)
 if [ -n "$PUBLIC_STORAGE" ]; then
 echo "警告: 发现公开的存储账户" >> "$LOG_FILE"
 echo "$PUBLIC_STORAGE" >> "$LOG_FILE"
 fi
 
 # 检测开放的安全组
 OPEN_NSG=$(az network nsg list --query "[?contains(to_string(securityRules[?access == 'Allow' && direction == 'Inbound' && sourceAddressPrefix == '*'][].destinationPortRange), '22,3389,80,443')].{Name:name}" --output json)
 if [ -n "$OPEN_NSG" ]; then
 echo "警告: 发现开放的安全组" >> "$LOG_FILE"
 echo "$OPEN_NSG" >> "$LOG_FILE"
 fi
 
 echo "$(date): 监控完成" >> "$LOG_FILE"
 
 sleep "$INTERVAL"
done

实战案例#

案例1: Azure账户安全评估#

场景描述#

对Azure订阅进行全面的安全评估，识别潜在的安全风险和配置问题。

GCPRecon使用教程

Mon, 01 Jan 0001 00:00:00 +0000

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项目进行全面的安全评估，识别潜在的安全风险和配置问题。

云服务安全评估技术详解

Mon, 01 Jan 0001 00:00:00 +0000

云服务安全评估技术详解#

技术介绍#

云服务安全评估是网络安全中信息收集的重要环节，通过自动化工具和技术手段，发现和分析目标组织的云服务配置、资源部署和安全漏洞，为后续的安全测试和漏洞利用提供基础。云服务安全评估技术广泛应用于渗透测试、安全审计和漏洞评估等场景。

云服务安全评估核心概念#

云服务发现：通过各种手段发现目标组织使用的云服务
云资源枚举：枚举目标组织在云服务中的资源
云配置分析：分析云服务的配置，识别安全漏洞
云权限评估：评估云服务的权限设置，识别权限漏洞
云日志分析：分析云服务的日志，发现异常行为

云服务安全评估架构#

信息收集：通过搜索引擎、DNS记录、云服务API等方式收集云服务相关信息
云服务发现：使用专用工具和技术发现云服务
云资源枚举：枚举云服务中的资源，如虚拟机、存储桶、数据库等
云配置分析：分析云服务的配置，识别安全漏洞
云权限评估：评估云服务的权限设置，识别权限漏洞
云日志分析：分析云服务的日志，发现异常行为
报告生成：生成详细的云服务安全评估报告

入门级使用#

云服务发现#

使用基本工具发现云服务：

# 使用搜索引擎发现云服务
curl -s "https://api.google.com/customsearch/v1?key=API_KEY&cx=CX&q=site:example.com+aws|azure|gcp"

# 使用DNS枚举发现云服务
nslookup example.com
nslookup www.example.com

# 使用云服务DNS特征发现云服务
dig example.com NS
dig example.com MX

# 使用云服务IP范围发现云服务
# AWS IP范围
curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq '.prefixes[] | select(.region=="us-east-1") | .ip_prefix'

# Azure IP范围
curl -s https://download.microsoft.com/download/7/1/D/71D86715-5596-4529-9B13-DA13A5DE5B63/ServiceTags_Public_20230101.json | jq '.values[] | select(.name=="Storage") | .properties.addressPrefixes[]'

# GCP IP范围
curl -s https://www.gstatic.com/ipranges/cloud.json | jq '.prefixes[] | select(.scope=="gcp") | .ipv4Prefix'

云资源枚举#

使用基本工具枚举云资源：