IP地址信息收集 on Linux邪修

IPinfo使用教程

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

IPinfo使用教程#

软件介绍#

IPinfo是一款强大的IP地址信息查询工具，提供详细的IP地址地理位置、ISP、ASN、域名、VPN检测等信息。它支持命令行工具、API接口和Web界面，是网络安全、渗透测试和系统管理的重要工具。

主要功能#

IP地址地理位置查询
ISP和ASN信息获取
域名解析查询
VPN/代理检测
批量IP查询
历史数据查询
隐私检测
托管服务识别

适用场景#

网络安全分析
渗透测试
风险评估
地理位置分析
流量分析
威胁情报收集

入门级使用#

安装IPinfo#

Windows系统#

# 使用pip安装
pip install ipinfo

# 或使用npm安装
npm install -g ipinfo-cli

Linux/macOS系统#

# 使用pip安装
pip install ipinfo

# 或使用npm安装
npm install -g ipinfo-cli

# 或下载二进制文件
wget https://github.com/ipinfo/cli/releases/latest/download/ipinfo-amd64
chmod +x ipinfo-amd64
sudo mv ipinfo-amd64 /usr/local/bin/ipinfo

基本IP查询#

查询单个IP地址#

# 基本查询
ipinfo 8.8.8.8

# 输出示例
{
 "ip": "8.8.8.8",
 "hostname": "dns.google",
 "city": "Mountain View",
 "region": "California",
 "country": "US",
 "loc": "37.4056,-122.0775",
 "org": "AS15169 Google LLC",
 "postal": "94043",
 "timezone": "America/Los_Angeles"
}

查询当前IP#

# 查询本机IP信息
ipinfo

# 输出当前IP的详细信息

JSON格式输出#

# 以JSON格式输出
ipinfo 8.8.8.8 --json

# 美化JSON输出
ipinfo 8.8.8.8 --json | jq .

基本信息字段说明#

ip: IP地址
hostname: 主机名
city: 城市
region: 州/省
country: 国家代码
loc: 经纬度坐标
org: 组织信息（ASN）
postal: 邮政编码
timezone: 时区

初级使用#

批量IP查询#

从文件读取IP列表#

# 创建IP列表文件
cat > ip_list.txt << EOF
8.8.8.8
1.1.1.1
208.67.222.222
EOF

# 批量查询
ipinfo 8.8.8.8,1.1.1.1,208.67.222.222

# 或从文件读取
while read ip; do
 ipinfo "$ip"
done < ip_list.txt

查询特定字段#

# 只查询地理位置
ipinfo 8.8.8.8 --field city,region,country

# 只查询ISP信息
ipinfo 8.8.8.8 --field org

# 只查询经纬度
ipinfo 8.8.8.8 --field loc

域名查询#

域名解析查询#

# 查询域名的IP信息
ipinfo google.com

# 查询多个域名
ipinfo google.com,facebook.com,twitter.com

API密钥配置#

获取API密钥#

访问 https://ipinfo.io/signup
注册账号
获取免费API密钥

配置API密钥#

# 设置环境变量
export IPINFO_TOKEN="your_api_key"

# 或在命令中指定
ipinfo 8.8.8.8 --token "your_api_key"

# 或创建配置文件
mkdir -p ~/.ipinfo
echo "token = your_api_key" > ~/.ipinfo/config

中级使用#

ASN查询#

查询ASN信息#

# 查询特定ASN
ipinfo AS15169

# 查询ASN的IP范围
ipinfo AS15169 --field prefix

# 查询ASN的详细信息
ipinfo AS15169 --json | jq .

批量ASN查询#

# 查询多个ASN
ipinfo AS15169,AS13335,AS16509

# 从文件查询ASN
cat > asn_list.txt << EOF
AS15169
AS13335
AS16509
EOF

while read asn; do
 ipinfo "$asn"
done < asn_list.txt

隐私检测#

VPN/代理检测#

# 检测IP是否为VPN
ipinfo 8.8.8.8 --field privacy

# 检测多个IP的隐私状态
ipinfo 8.8.8.8,1.1.1.1 --field privacy

# 输出示例
{
 "vpn": false,
 "proxy": false,
 "tor": false,
 "relay": false,
 "hosting": false,
 "service": ""
}

托管服务检测#

# 检测IP是否为托管服务
ipinfo 8.8.8.8 --field privacy.hosting

# 检测是否为云服务
ipinfo 8.8.8.8 --field privacy.service

历史数据查询#

查询IP历史信息#

# 查询IP的历史数据
ipinfo 8.8.8.8 --history

# 查询特定时间范围的历史数据
ipinfo 8.8.8.8 --history --start-date "2024-01-01" --end-date "2024-12-31"

中上级使用#

高级过滤#

按国家过滤#

# 查询特定国家的IP
ipinfo 8.8.8.8 --filter country=US

# 查询多个国家
ipinfo 8.8.8.8 --filter country=US,CN,JP

按ISP过滤#

# 查询特定ISP的IP
ipinfo 8.8.8.8 --filter org="Google LLC"

# 按ASN过滤
ipinfo 8.8.8.8 --filter org="AS15169"

数据导出#

导出为CSV#

# 导出为CSV格式
ipinfo 8.8.8.8 --format csv

# 批量导出
ipinfo 8.8.8.8,1.1.1.1,208.67.222.222 --format csv > ip_info.csv

导出为JSON#

# 导出为JSON格式
ipinfo 8.8.8.8 --json > ip_info.json

# 批量导出
for ip in 8.8.8.8 1.1.1.1 208.67.222.222; do
 ipinfo "$ip" --json >> ip_list.json
done

自定义脚本#

Python脚本示例#

#!/usr/bin/env python3
import ipinfo
import json

# 初始化API
handler = ipinfo.getHandler(access_token='your_api_key')

# 查询单个IP
ip_address = '8.8.8.8'
details = handler.getDetails(ip_address)
print(json.dumps(details, indent=2))

# 批量查询
ip_list = ['8.8.8.8', '1.1.1.1', '208.67.222.222']
for ip in ip_list:
 details = handler.getDetails(ip)
 print(f"{ip}: {details['city']}, {details['country']}")

Bash脚本示例#

#!/bin/bash
# IP信息批量查询脚本

API_KEY="your_api_key"
IP_FILE="ip_list.txt"
OUTPUT_FILE="ip_info.json"

echo "[" > "$OUTPUT_FILE"

first=true
while read ip; do
 if [ "$first" = true ]; then
 first=false
 else
 echo "," >> "$OUTPUT_FILE"
 fi
 ipinfo "$ip" --token "$API_KEY" --json >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "]" >> "$OUTPUT_FILE"
echo "查询完成，结果已保存到 $OUTPUT_FILE"

高级使用#

网络拓扑分析#

分析ASN网络#

#!/bin/bash
# ASN网络分析脚本

ASN=$1
echo "分析ASN: $ASN"

# 获取ASN信息
ipinfo "$ASN" --json > asn_info.json

# 提取IP前缀
prefix=$(jq -r '.prefix' asn_info.json)
echo "IP前缀: $prefix"

# 获取ASN名称
name=$(jq -r '.name' asn_info.json)
echo "ASN名称: $name"

# 分析网络规模
echo "网络规模分析:"
echo "IP前缀数量: $(echo "$prefix" | wc -l)"

地理位置分析#

#!/bin/bash
# 地理位置分析脚本

IP_FILE="ip_list.txt"
OUTPUT_FILE="geo_analysis.txt"

echo "IP地址,城市,地区,国家,经纬度" > "$OUTPUT_FILE"

while read ip; do
 info=$(ipinfo "$ip" --json)
 city=$(echo "$info" | jq -r '.city')
 region=$(echo "$info" | jq -r '.region')
 country=$(echo "$info" | jq -r '.country')
 loc=$(echo "$info" | jq -r '.loc')
 echo "$ip,$city,$region,$country,$loc" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "地理位置分析完成，结果已保存到 $OUTPUT_FILE"

威胁情报集成#

风险IP检测#

#!/bin/bash
# 风险IP检测脚本

IP_FILE="ip_list.txt"
OUTPUT_FILE="risk_analysis.txt"

echo "IP地址,VPN,代理,TOR,中继,托管,服务" > "$OUTPUT_FILE"

while read ip; do
 privacy=$(ipinfo "$ip" --field privacy --json)
 vpn=$(echo "$privacy" | jq -r '.vpn')
 proxy=$(echo "$privacy" | jq -r '.proxy')
 tor=$(echo "$privacy" | jq -r '.tor')
 relay=$(echo "$privacy" | jq -r '.relay')
 hosting=$(echo "$privacy" | jq -r '.hosting')
 service=$(echo "$privacy" | jq -r '.service')
 echo "$ip,$vpn,$proxy,$tor,$relay,$hosting,$service" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "风险分析完成，结果已保存到 $OUTPUT_FILE"

可疑活动监控#

#!/bin/bash
# 可疑活动监控脚本

LOG_FILE="/var/log/auth.log"
OUTPUT_FILE="suspicious_ips.txt"

# 提取失败登录的IP
grep "Failed password" "$LOG_FILE" | awk '{print $(NF-3)}' | sort -u > temp_ips.txt

# 分析每个IP
while read ip; do
 privacy=$(ipinfo "$ip" --field privacy --json)
 vpn=$(echo "$privacy" | jq -r '.vpn')
 tor=$(echo "$privacy" | jq -r '.tor')
 hosting=$(echo "$privacy" | jq -r '.hosting')
 
 if [ "$vpn" = "true" ] || [ "$tor" = "true" ] || [ "$hosting" = "true" ]; then
 echo "$ip" >> "$OUTPUT_FILE"
 fi
done < temp_ips.txt

echo "可疑IP列表已保存到 $OUTPUT_FILE"

大师级使用#

自动化监控#

持续监控脚本#

#!/bin/bash
# IP地址持续监控脚本

MONITOR_FILE="monitor_ips.txt"
LOG_FILE="monitor_log.txt"
INTERVAL=3600 # 每小时检查一次

while true; do
 echo "$(date): 开始监控" >> "$LOG_FILE"
 
 while read ip; do
 current_info=$(ipinfo "$ip" --json)
 city=$(echo "$current_info" | jq -r '.city')
 org=$(echo "$current_info" | jq -r '.org')
 
 echo "$(date): $IP - $city - $org" >> "$LOG_FILE"
 
 # 检查是否有变化
 if [ -f "last_info_$ip.txt" ]; then
 diff "last_info_$ip.txt" <(echo "$current_info") > /dev/null
 if [ $? -ne 0 ]; then
 echo "$(date): $IP 信息发生变化" >> "$LOG_FILE"
 fi
 fi
 
 echo "$current_info" > "last_info_$ip.txt"
 done < "$MONITOR_FILE"
 
 echo "$(date): 监控周期完成" >> "$LOG_FILE"
 sleep "$INTERVAL"
done

实时告警系统#

#!/bin/bash
# 实时告警系统

THRESHOLD=5
LOG_FILE="/var/log/nginx/access.log"
ALERT_FILE="alerts.txt"

# 分析访问日志
tail -f "$LOG_FILE" | while read line; do
 ip=$(echo "$line" | awk '{print $1}')
 
 # 检查IP访问频率
 count=$(grep "$ip" "$LOG_FILE" | wc -l)
 
 if [ "$count" -gt "$THRESHOLD" ]; then
 # 检查IP是否为风险IP
 privacy=$(ipinfo "$ip" --field privacy --json)
 vpn=$(echo "$privacy" | jq -r '.vpn')
 tor=$(echo "$privacy" | jq -r '.tor')
 
 if [ "$vpn" = "true" ] || [ "$tor" = "true" ]; then
 alert_msg="$(date): 风险IP访问 - $IP (VPN: $vpn, TOR: $tor)"
 echo "$alert_msg" >> "$ALERT_FILE"
 echo "$alert_msg"
 fi
 fi
done

数据分析#

统计分析#

#!/bin/bash
# IP地址统计分析脚本

IP_FILE="ip_list.txt"
OUTPUT_FILE="statistics.txt"

echo "=== IP地址统计分析 ===" > "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# 统计国家分布
echo "国家分布:" >> "$OUTPUT_FILE"
while read ip; do
 country=$(ipinfo "$ip" --field country)
 echo "$country" >> temp_countries.txt
done < "$IP_FILE"
sort temp_countries.txt | uniq -c | sort -rn >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# 统计ISP分布
echo "ISP分布:" >> "$OUTPUT_FILE"
while read ip; do
 org=$(ipinfo "$ip" --field org)
 echo "$org" >> temp_orgs.txt
done < "$IP_FILE"
sort temp_orgs.txt | uniq -c | sort -rn >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# 统计风险IP
echo "风险IP统计:" >> "$OUTPUT_FILE"
risk_count=0
while read ip; do
 privacy=$(ipinfo "$ip" --field privacy --json)
 vpn=$(echo "$privacy" | jq -r '.vpn')
 tor=$(echo "$privacy" | jq -r '.tor')
 
 if [ "$vpn" = "true" ] || [ "$tor" = "true" ]; then
 risk_count=$((risk_count + 1))
 echo "$ip" >> temp_risk.txt
 fi
done < "$IP_FILE"
echo "风险IP数量: $risk_count" >> "$OUTPUT_FILE"

# 清理临时文件
rm -f temp_countries.txt temp_orgs.txt temp_risk.txt

echo "统计分析完成，结果已保存到 $OUTPUT_FILE"

地理可视化数据#

#!/bin/bash
# 生成地理可视化数据

IP_FILE="ip_list.txt"
OUTPUT_FILE="geo_data.json"

echo "[" > "$OUTPUT_FILE"

first=true
while read ip; do
 info=$(ipinfo "$ip" --json)
 city=$(echo "$info" | jq -r '.city')
 country=$(echo "$info" | jq -r '.country')
 loc=$(echo "$info" | jq -r '.loc')
 lat=$(echo "$loc" | cut -d',' -f1)
 lon=$(echo "$loc" | cut -d',' -f2)
 
 if [ "$first" = true ]; then
 first=false
 else
 echo "," >> "$OUTPUT_FILE"
 fi
 
 echo "{\"ip\":\"$ip\",\"city\":\"$city\",\"country\":\"$country\",\"lat\":$lat,\"lon\":$lon}" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "]" >> "$OUTPUT_FILE"
echo "地理数据已生成，可用于地图可视化"

实战案例#

案例1: 网络入侵检测#

场景描述#

检测服务器日志中的可疑IP访问，识别来自VPN、TOR或托管服务的连接。

IP-API使用教程

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

IP-API使用教程#

软件介绍#

IP-API是一款免费的IP地址信息查询服务，提供详细的地理位置、ISP、ASN、时区等信息。它无需API密钥即可使用，支持HTTP和HTTPS协议，是快速查询IP信息的理想选择。

主要功能#

IP地址地理位置查询
ISP和ASN信息获取
时区信息查询
货币信息查询
移动网络检测
代理/VPN检测（付费版）
批量查询（付费版）
JSON/XML/CSV格式输出

适用场景#

快速IP信息查询
网络安全分析
地理位置分析
流量分析
系统管理

入门级使用#

基本IP查询#

查询单个IP地址#

# 基本查询（JSON格式）
curl http://ip-api.com/json/8.8.8.8

# 输出示例
{
 "query": "8.8.8.8",
 "status": "success",
 "country": "United States",
 "countryCode": "US",
 "region": "CA",
 "regionName": "California",
 "city": "Mountain View",
 "zip": "94043",
 "lat": 37.4223,
 "lon": -122.085,
 "timezone": "America/Los_Angeles",
 "isp": "Google LLC",
 "org": "Google Public DNS",
 "as": "AS15169 Google LLC"
}

查询当前IP#

# 查询本机IP信息
curl http://ip-api.com/json/

# 输出当前IP的详细信息

使用HTTPS查询#

# 使用HTTPS协议查询
curl https://ip-api.com/json/8.8.8.8

基本信息字段说明#

query: 查询的IP地址
status: 查询状态（success/fail）
country: 国家名称
countryCode: 国家代码
region: 州/省代码
regionName: 州/省名称
city: 城市
zip: 邮政编码
lat: 纬度
lon: 经度
timezone: 时区
isp: ISP名称
org: 组织名称
as: AS号和名称

初级使用#

指定返回字段#

只返回特定字段#

# 只返回地理位置信息
curl "http://ip-api.com/json/8.8.8.8?fields=status,country,regionName,city"

# 只返回ISP信息
curl "http://ip-api.com/json/8.8.8.8?fields=isp,org,as"

# 只返回坐标信息
curl "http://ip-api.com/json/8.8.8.8?fields=lat,lon,timezone"

返回所有字段#

# 返回所有可用字段
curl "http://ip-api.com/json/8.8.8.8?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone,isp,org,as,reverse,mobile,proxy,hosting,query"

不同输出格式#

JSON格式（默认）#

# JSON格式输出
curl http://ip-api.com/json/8.8.8.8

XML格式#

# XML格式输出
curl http://ip-api.com/xml/8.8.8.8

# 输出示例
<?xml version="1.0" encoding="UTF-8"?>
<query>
 <status>success</status>
 <country>United States</country>
 <countryCode>US</countryCode>
 <region>CA</region>
 <regionName>California</regionName>
 <city>Mountain View</city>
 <zip>94043</zip>
 <lat>37.4223</lat>
 <lon>-122.085</lon>
 <timezone>America/Los_Angeles</timezone>
 <isp>Google LLC</isp>
 <org>Google Public DNS</org>
 <as>AS15169 Google LLC</as>
 <query>8.8.8.8</query>
</query>

CSV格式#

# CSV格式输出
curl http://ip-api.com/csv/8.8.8.8

# 输出示例
success,United States,US,CA,California,Mountain View,94043,37.4223,-122.085,America/Los_Angeles,Google LLC,Google Public DNS,AS15169 Google LLC,8.8.8.8

纯文本格式#

# 纯文本格式输出
curl http://ip-api.com/line/8.8.8.8

# 输出示例
8.8.8.8
United States
California
Mountain View
37.4223,-122.085

中级使用#

批量查询#

使用脚本批量查询#

#!/bin/bash
# 批量IP查询脚本

IP_FILE="ip_list.txt"
OUTPUT_FILE="ip_info.json"

echo "[" > "$OUTPUT_FILE"

first=true
while read ip; do
 if [ "$first" = true ]; then
 first=false
 else
 echo "," >> "$OUTPUT_FILE"
 fi
 curl -s "http://ip-api.com/json/$ip" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "]" >> "$OUTPUT_FILE"
echo "批量查询完成，结果已保存到 $OUTPUT_FILE"

使用Python批量查询#

#!/usr/bin/env python3
import requests
import json

ip_list = ['8.8.8.8', '1.1.1.1', '208.67.222.222']
results = []

for ip in ip_list:
 response = requests.get(f'http://ip-api.com/json/{ip}')
 data = response.json()
 results.append(data)

# 保存结果
with open('ip_info.json', 'w') as f:
 json.dump(results, f, indent=2)

print("批量查询完成")

错误处理#

检查查询状态#

#!/bin/bash
# 带错误处理的IP查询脚本

IP=$1
RESULT=$(curl -s "http://ip-api.com/json/$IP")
STATUS=$(echo "$RESULT" | jq -r '.status')

if [ "$STATUS" = "success" ]; then
 echo "查询成功:"
 echo "$RESULT" | jq '.'
else
 MESSAGE=$(echo "$RESULT" | jq -r '.message')
 echo "查询失败: $MESSAGE"
fi

处理无效IP#

#!/bin/bash
# 处理无效IP地址

IP=$1
RESULT=$(curl -s "http://ip-api.com/json/$IP")
STATUS=$(echo "$RESULT" | jq -r '.status')

if [ "$STATUS" = "fail" ]; then
 echo "无效的IP地址或查询失败"
 exit 1
fi

echo "IP: $IP"
echo "国家: $(echo "$RESULT" | jq -r '.country')"
echo "城市: $(echo "$RESULT" | jq -r '.city')"
echo "ISP: $(echo "$RESULT" | jq -r '.isp')"

性能优化#

并发查询#

#!/bin/bash
# 并发查询多个IP

IP_LIST=("8.8.8.8" "1.1.1.1" "208.67.222.222" "9.9.9.9" "64.6.64.6")

for ip in "${IP_LIST[@]}"; do
 {
 result=$(curl -s "http://ip-api.com/json/$ip")
 echo "$ip: $(echo "$result" | jq -r '.country')"
 } &
done

wait
echo "所有查询完成"

使用缓存#

#!/bin/bash
# 使用缓存减少重复查询

CACHE_DIR="ip_cache"
mkdir -p "$CACHE_DIR"

query_ip() {
 local ip=$1
 local cache_file="$CACHE_DIR/${ip}.json"
 
 if [ -f "$cache_file" ]; then
 cat "$cache_file"
 else
 local result=$(curl -s "http://ip-api.com/json/$ip")
 echo "$result" > "$cache_file"
 echo "$result"
 fi
}

# 使用缓存查询
query_ip "8.8.8.8" | jq '.'

中上级使用#

高级字段查询#

查询反向DNS#

# 查询反向DNS信息
curl "http://ip-api.com/json/8.8.8.8?fields=status,reverse"

# 输出示例
{
 "status": "success",
 "reverse": "dns.google"
}

查询移动网络信息#

# 查询是否为移动网络
curl "http://ip-api.com/json/8.8.8.8?fields=status,mobile"

# 输出示例
{
 "status": "success",
 "mobile": false
}

查询代理/托管信息（付费版）#

# 查询代理信息（需要付费API密钥）
curl "http://ip-api.com/json/8.8.8.8?fields=status,proxy,hosting&key=your_api_key"

# 输出示例
{
 "status": "success",
 "proxy": false,
 "hosting": false
}

数据处理#

提取特定信息#

#!/bin/bash
# 提取IP的特定信息

IP=$1
RESULT=$(curl -s "http://ip-api.com/json/$IP")

COUNTRY=$(echo "$RESULT" | jq -r '.country')
CITY=$(echo "$RESULT" | jq -r '.city')
ISP=$(echo "$RESULT" | jq -r '.isp')
LAT=$(echo "$RESULT" | jq -r '.lat')
LON=$(echo "$RESULT" | jq -r '.lon')

echo "IP地址: $IP"
echo "国家: $COUNTRY"
echo "城市: $CITY"
echo "ISP: $ISP"
echo "坐标: $LAT, $LON"

格式化输出#

#!/bin/bash
# 格式化输出IP信息

IP=$1
RESULT=$(curl -s "http://ip-api.com/json/$IP")

echo "================================"
echo "IP地址信息"
echo "================================"
echo "IP地址: $(echo "$RESULT" | jq -r '.query')"
echo "国家: $(echo "$RESULT" | jq -r '.country')"
echo "地区: $(echo "$RESULT" | jq -r '.regionName')"
echo "城市: $(echo "$RESULT" | jq -r '.city')"
echo "邮编: $(echo "$RESULT" | jq -r '.zip')"
echo "坐标: $(echo "$RESULT" | jq -r '.lat'), $(echo "$RESULT" | jq -r '.lon')"
echo "时区: $(echo "$RESULT" | jq -r '.timezone')"
echo "ISP: $(echo "$RESULT" | jq -r '.isp')"
echo "组织: $(echo "$RESULT" | jq -r '.org')"
echo "ASN: $(echo "$RESULT" | jq -r '.as')"
echo "================================"

集成到其他工具#

与Nmap集成#

#!/bin/bash
# 结合Nmap和IP-API

TARGET=$1

# 使用Nmap扫描主机
nmap -sn "$TARGET" | grep "Nmap scan report" | awk '{print $5}' > hosts.txt

# 查询每个主机的IP信息
while read ip; do
 echo "=== $ip ==="
 curl -s "http://ip-api.com/json/$ip" | jq -r '.country, .city, .isp'
 echo ""
done < hosts.txt

与日志分析集成#

#!/bin/bash
# 分析日志文件中的IP

LOG_FILE="/var/log/nginx/access.log"
OUTPUT_FILE="log_ip_analysis.txt"

echo "=== 日志IP分析 ===" > "$OUTPUT_FILE"

# 提取唯一IP
awk '{print $1}' "$LOG_FILE" | sort -u > unique_ips.txt

# 查询每个IP的信息
while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 country=$(echo "$result" | jq -r '.country')
 city=$(echo "$result" | jq -r '.city')
 echo "$ip - $country, $city" >> "$OUTPUT_FILE"
done < unique_ips.txt

echo "分析完成，结果已保存到 $OUTPUT_FILE"

高级使用#

地理位置分析#

按国家统计#

#!/bin/bash
# 按国家统计IP分布

IP_FILE="ip_list.txt"
OUTPUT_FILE="country_stats.txt"

# 统计每个国家的IP数量
declare -A country_count

while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 country=$(echo "$result" | jq -r '.country')
 country_count["$country"]=$((${country_count["$country"]} + 1))
done < "$IP_FILE"

# 输出统计结果
echo "=== 国家分布统计 ===" > "$OUTPUT_FILE"
for country in "${!country_count[@]}"; do
 echo "$country: ${country_count[$country]}" >> "$OUTPUT_FILE"
done | sort -t: -k2 -rn >> "$OUTPUT_FILE"

echo "统计完成，结果已保存到 $OUTPUT_FILE"

生成地图数据#

#!/bin/bash
# 生成地图可视化数据

IP_FILE="ip_list.txt"
OUTPUT_FILE="map_data.json"

echo "[" > "$OUTPUT_FILE"

first=true
while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 lat=$(echo "$result" | jq -r '.lat')
 lon=$(echo "$result" | jq -r '.lon')
 country=$(echo "$result" | jq -r '.country')
 
 if [ "$first" = true ]; then
 first=false
 else
 echo "," >> "$OUTPUT_FILE"
 fi
 
 echo "{\"ip\":\"$ip\",\"lat\":$lat,\"lon\":$lon,\"country\":\"$country\"}" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "]" >> "$OUTPUT_FILE"
echo "地图数据已生成"

ISP分析#

按ISP统计#

#!/bin/bash
# 按ISP统计IP分布

IP_FILE="ip_list.txt"
OUTPUT_FILE="isp_stats.txt"

# 统计每个ISP的IP数量
declare -A isp_count

while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 isp=$(echo "$result" | jq -r '.isp')
 isp_count["$isp"]=$((${isp_count["$isp"]} + 1))
done < "$IP_FILE"

# 输出统计结果
echo "=== ISP分布统计 ===" > "$OUTPUT_FILE"
for isp in "${!isp_count[@]}"; do
 echo "$isp: ${isp_count[$isp]}" >> "$OUTPUT_FILE"
done | sort -t: -k2 -rn >> "$OUTPUT_FILE"

echo "统计完成，结果已保存到 $OUTPUT_FILE"

ASN分析#

#!/bin/bash
# ASN分析脚本

IP_FILE="ip_list.txt"
OUTPUT_FILE="asn_analysis.txt"

echo "=== ASN分析 ===" > "$OUTPUT_FILE"

# 提取唯一ASN
declare -A asn_list

while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 as=$(echo "$result" | jq -r '.as')
 asn_list["$as"]=1
done < "$IP_FILE"

# 输出ASN列表
echo "发现的ASN:" >> "$OUTPUT_FILE"
for asn in "${!asn_list[@]}"; do
 echo "$asn" >> "$OUTPUT_FILE"
done | sort >> "$OUTPUT_FILE"

echo "ASN分析完成，结果已保存到 $OUTPUT_FILE"

大师级使用#

自动化监控#

实时IP监控#

#!/bin/bash
# 实时IP监控脚本

LOG_FILE="/var/log/nginx/access.log"
MONITOR_FILE="monitored_ips.txt"
OUTPUT_FILE="monitor_log.txt"

# 监控日志文件的新连接
tail -f "$LOG_FILE" | while read line; do
 ip=$(echo "$line" | awk '{print $1}')
 
 # 检查是否已监控
 if ! grep -q "$ip" "$MONITOR_FILE" 2>/dev/null; then
 echo "$(date): 新IP检测 - $ip" >> "$OUTPUT_FILE"
 
 # 查询IP信息
 result=$(curl -s "http://ip-api.com/json/$ip")
 country=$(echo "$result" | jq -r '.country')
 city=$(echo "$result" | jq -r '.city')
 isp=$(echo "$result" | jq -r '.isp')
 
 echo " 国家: $country, 城市: $city, ISP: $isp" >> "$OUTPUT_FILE"
 
 # 添加到监控列表
 echo "$ip" >> "$MONITOR_FILE"
 fi
done

定期IP检查#

#!/bin/bash
# 定期IP检查脚本

IP_FILE="check_ips.txt"
OUTPUT_FILE="check_results.txt"
INTERVAL=3600 # 每小时检查一次

while true; do
 echo "$(date): 开始检查" >> "$OUTPUT_FILE"
 
 while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 status=$(echo "$result" | jq -r '.status')
 
 if [ "$status" = "success" ]; then
 country=$(echo "$result" | jq -r '.country')
 echo "$ip: $country" >> "$OUTPUT_FILE"
 else
 echo "$ip: 查询失败" >> "$OUTPUT_FILE"
 fi
 done < "$IP_FILE"
 
 echo "$(date): 检查完成" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
 
 sleep "$INTERVAL"
done

数据库集成#

存储到SQLite#

#!/bin/bash
# 将IP信息存储到SQLite数据库

DB_FILE="ip_info.db"
IP_FILE="ip_list.txt"

# 创建数据库表
sqlite3 "$DB_FILE" "CREATE TABLE IF NOT EXISTS ip_info (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 ip TEXT UNIQUE,
 country TEXT,
 region TEXT,
 city TEXT,
 zip TEXT,
 lat REAL,
 lon REAL,
 timezone TEXT,
 isp TEXT,
 org TEXT,
 as_info TEXT,
 query_time DATETIME DEFAULT CURRENT_TIMESTAMP
);"

# 查询并存储IP信息
while read ip; do
 result=$(curl -s "http://ip-api.com/json/$ip")
 status=$(echo "$result" | jq -r '.status')
 
 if [ "$status" = "success" ]; then
 country=$(echo "$result" | jq -r '.country')
 region=$(echo "$result" | jq -r '.regionName')
 city=$(echo "$result" | jq -r '.city')
 zip=$(echo "$result" | jq -r '.zip')
 lat=$(echo "$result" | jq -r '.lat')
 lon=$(echo "$result" | jq -r '.lon')
 timezone=$(echo "$result" | jq -r '.timezone')
 isp=$(echo "$result" | jq -r '.isp')
 org=$(echo "$result" | jq -r '.org')
 as_info=$(echo "$result" | jq -r '.as')
 
 sqlite3 "$DB_FILE" "INSERT OR REPLACE INTO ip_info 
 (ip, country, region, city, zip, lat, lon, timezone, isp, org, as_info)
 VALUES ('$ip', '$country', '$region', '$city', '$zip', $lat, $lon, '$timezone', '$isp', '$org', '$as_info');"
 fi
done < "$IP_FILE"

echo "IP信息已存储到数据库 $DB_FILE"

查询数据库#

#!/bin/bash
# 查询SQLite数据库

DB_FILE="ip_info.db"

# 查询所有IP信息
echo "=== 所有IP信息 ==="
sqlite3 "$DB_FILE" "SELECT ip, country, city, isp FROM ip_info;"

# 按国家统计
echo ""
echo "=== 按国家统计 ==="
sqlite3 "$DB_FILE" "SELECT country, COUNT(*) as count FROM ip_info GROUP BY country ORDER BY count DESC;"

# 查询特定国家的IP
echo ""
echo "=== 美国IP ==="
sqlite3 "$DB_FILE" "SELECT * FROM ip_info WHERE country='United States';"

实战案例#

案例1: 网站访问者分析#

场景描述#

分析网站访问日志，了解访问者的地理分布和ISP信息。

Censys使用教程

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

Censys使用教程#

软件介绍#

Censys是一款强大的互联网搜索引擎和安全平台，用于发现网络设备、服务和基础设施。它提供对全球互联网设备的实时视图，支持搜索、监控和分析网络资产，是网络安全研究和威胁情报收集的重要工具。

主要功能#

互联网设备搜索和发现
证书透明度日志查询
网络资产监控
安全漏洞扫描
威胁情报收集
攻击面管理
合规性检查
自动化API接口

适用场景#

网络安全研究
渗透测试
资产发现和管理
威胁情报收集
安全评估
攻击面分析

入门级使用#

安装Censys CLI#

使用pip安装#

# 安装Censys命令行工具
pip install censys

# 验证安装
censys --version

使用Docker安装#

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

# 或安装到本地
docker pull censys/censys:latest

注册账号和获取API密钥#

注册Censys账号#

访问 https://search.censys.io/
点击"Sign Up"注册免费账号
验证邮箱地址
登录获取API ID和API Secret

配置API密钥#

# 配置API密钥
censys config

# 按提示输入API ID和API Secret

# 或设置环境变量
export CENSYS_API_ID="your_api_id"
export CENSYS_API_SECRET="your_api_secret"

基本搜索#

搜索特定IP#

# 搜索特定IP地址
censys search ip:8.8.8.8

# 输出示例
Found 1 result

8.8.8.8
 Autonomous System: AS15169 Google LLC
 Location: Mountain View, California, United States
 Operating System: Linux
 Services:
 - 53/tcp: DNS
 - 443/tcp: HTTPS

搜索特定端口#

# 搜索开放特定端口的设备
censys search "services.port:443"

# 搜索开放多个端口的设备
censys search "services.port:22 and services.port:80"

搜索特定服务#

# 搜索运行Apache的设备
censys search "services.software.product:Apache"

# 搜索运行Nginx的设备
censys search "services.software.product:Nginx"

初级使用#

高级搜索语法#

布尔运算符#

# AND运算符
censys search "services.port:80 and services.port:443"

# OR运算符
censys search "services.software.product:Apache or services.software.product:Nginx"

# NOT运算符
censys search "services.port:80 and not services.software.product:Apache"

通配符搜索#

# 使用通配符搜索
censys search "services.software.product:Apache*"

# 搜索特定国家
censys search "location.country_code:US"

范围搜索#

# 搜索特定IP范围
censys search "ip:[1.1.1.1 TO 1.1.1.100]"

# 搜索特定ASN范围
censys search "autonomous_system.asn:[15169 TO 15200]"

按地理位置搜索#

按国家搜索#

# 搜索美国的设备
censys search "location.country_code:US"

# 搜索中国的设备
censys search "location.country_code:CN"

# 搜索多个国家
censys search "location.country_code:(US OR CN OR JP)"

按城市搜索#

# 搜索特定城市的设备
censys search "location.city:Mountain View"

# 搜索特定地区的设备
censys search "location.province:California"

按服务搜索#

搜索Web服务器#

# 搜索HTTP服务器
censys search "services.service_name:HTTP"

# 搜索HTTPS服务器
censys search "services.service_name:HTTPS"

# 搜索FTP服务器
censys search "services.service_name:FTP"

搜索数据库服务#

# 搜索MySQL服务器
censys search "services.service_name:MYSQL"

# 搜索PostgreSQL服务器
censys search "services.service_name:POSTGRESQL"

# 搜索MongoDB服务器
censys search "services.service_name:MONGODB"

中级使用#

证书搜索#

搜索SSL证书#

# 搜索特定域名的证书
censys search "parsed.names:example.com"

# 搜索特定CA颁发的证书
censys search "parsed.issuer.common_name:Let's Encrypt"

# 搜索即将过期的证书
censys search "parsed.validity.not_after:[NOW TO NOW+30d]"

搜索证书信息#

# 搜索自签名证书
censys search "parsed.extensions.self_signed:true"

# 搜索通配符证书
censys search "parsed.names:*"

# 搜索特定组织的证书
censys search "parsed.subject.organization:Google"

网络资产监控#

监控特定IP#

# 监控特定IP的变化
censys view 8.8.8.8

# 查看IP的历史变化
censys view 8.8.8.8 --at-time "2024-01-01"

监控特定ASN#

# 搜索特定ASN的所有设备
censys search "autonomous_system.asn:15169"

# 搜索特定ASN的特定服务
censys search "autonomous_system.asn:15169 and services.port:443"

批量查询#

从文件批量查询#

#!/bin/bash
# 批量查询IP信息

IP_FILE="ip_list.txt"
OUTPUT_FILE="censys_results.txt"

while read ip; do
 echo "=== $ip ===" >> "$OUTPUT_FILE"
 censys view "$ip" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "批量查询完成，结果已保存到 $OUTPUT_FILE"

批量搜索#

#!/bin/bash
# 批量搜索不同条件

SEARCH_TERMS=(
 "services.port:22"
 "services.port:3306"
 "services.port:6379"
 "services.port:27017"
)

OUTPUT_FILE="batch_search_results.txt"

for term in "${SEARCH_TERMS[@]}"; do
 echo "=== 搜索: $term ===" >> "$OUTPUT_FILE"
 censys search "$term" --max-records 10 >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done

echo "批量搜索完成"

中上级使用#

高级过滤#

按操作系统过滤#

# 搜索Windows设备
censys search "operating_system.os:Windows"

# 搜索Linux设备
censys search "operating_system.os:Linux"

# 搜索特定版本的操作系统
censys search "operating_system.os:Ubuntu 20.04"

按软件版本过滤#

# 搜索特定版本的软件
censys search "services.software.version:2.4.41"

# 搜索包含特定漏洞的设备
censys search "services.software.version:2.4.41 and services.service_name:HTTP"

数据导出#

导出为JSON#

# 导出搜索结果为JSON
censys search "services.port:443" --format json > results.json

# 导出特定字段
censys search "services.port:443" --format json --fields ip,location.country_code,location.city > results.json

导出为CSV#

# 导出搜索结果为CSV
censys search "services.port:443" --format csv > results.csv

# 导出特定字段
censys search "services.port:443" --format csv --fields ip,location.country_code,location.city > results.csv

API编程#

Python API示例#

#!/usr/bin/env python3
from censys.search import CensysHosts

# 初始化API
h = CensysHosts(api_id="your_api_id", api_secret="your_api_secret")

# 搜索特定端口
query = h.search("services.port:443", fields=["ip", "location.country_code", "location.city"])

# 遍历结果
for page in query:
 for host in page:
 print(f"IP: {host['ip']}")
 print(f"国家: {host['location']['country_code']}")
 print(f"城市: {host['location']['city']}")
 print()

批量查询示例#

#!/usr/bin/env python3
from censys.search import CensysHosts
import json

# 初始化API
h = CensysHosts(api_id="your_api_id", api_secret="your_api_secret")

# 批量查询IP列表
ip_list = ["8.8.8.8", "1.1.1.1", "208.67.222.222"]
results = []

for ip in ip_list:
 try:
 host = h.view(ip)
 results.append(host)
 print(f"查询成功: {ip}")
 except Exception as e:
 print(f"查询失败: {ip} - {e}")

# 保存结果
with open("censys_results.json", "w") as f:
 json.dump(results, f, indent=2)

print("批量查询完成")

高级使用#

攻击面分析#

分析组织攻击面#

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

DOMAIN="example.com"
OUTPUT_DIR="attack_surface_analysis"
mkdir -p "$OUTPUT_DIR"

# 搜索组织的所有证书
echo "=== 证书分析 ===" > "$OUTPUT_DIR/certificates.txt"
censys search "parsed.names:$DOMAIN" --max-records 100 >> "$OUTPUT_DIR/certificates.txt"

# 搜索组织的所有IP
echo "=== IP地址分析 ===" > "$OUTPUT_DIR/ips.txt"
censys search "parsed.names:$DOMAIN" --fields ip --format csv | cut -d',' -f1 | sort -u >> "$OUTPUT_DIR/ips.txt"

# 分析每个IP的服务
echo "=== 服务分析 ===" > "$OUTPUT_DIR/services.txt"
while read ip; do
 echo "=== $ip ===" >> "$OUTPUT_DIR/services.txt"
 censys view "$ip" >> "$OUTPUT_DIR/services.txt"
 echo "" >> "$OUTPUT_DIR/services.txt"
done < "$OUTPUT_DIR/ips.txt"

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

子域名发现#

#!/bin/bash
# 子域名发现脚本

DOMAIN="example.com"
OUTPUT_FILE="subdomains.txt"

# 搜索包含域名的证书
censys search "parsed.names:*.$DOMAIN" --fields parsed.names --format csv | \
 grep -o "[a-zA-Z0-9-]*\.$DOMAIN" | \
 sort -u > "$OUTPUT_FILE"

echo "发现 $(wc -l < "$OUTPUT_FILE") 个子域名"
echo "子域名列表已保存到 $OUTPUT_FILE"

漏洞扫描#

搜索易受攻击的设备#

#!/bin/bash
# 搜索易受攻击的设备脚本

OUTPUT_FILE="vulnerable_devices.txt"

# 搜索运行旧版本Apache的设备
echo "=== 旧版本Apache设备 ===" > "$OUTPUT_FILE"
censys search "services.software.product:Apache and services.software.version:2.4.* and services.software.version:<2.4.50" --max-records 50 >> "$OUTPUT_FILE"

# 搜索运行旧版本Nginx的设备
echo "=== 旧版本Nginx设备 ===" >> "$OUTPUT_FILE"
censys search "services.software.product:Nginx and services.software.version:1.18.* and services.software.version:<1.18.1" --max-records 50 >> "$OUTPUT_FILE"

# 搜索开放危险端口的设备
echo "=== 开放危险端口的设备 ===" >> "$OUTPUT_FILE"
censys search "services.port:23" --max-records 50 >> "$OUTPUT_FILE"

echo "漏洞扫描完成，结果已保存到 $OUTPUT_FILE"

检测配置错误#

#!/bin/bash
# 检测配置错误脚本

OUTPUT_FILE="misconfigurations.txt"

# 搜索未加密的FTP服务
echo "=== 未加密的FTP服务 ===" > "$OUTPUT_FILE"
censys search "services.service_name:FTP and not services.tls.certificate.parsed.names:*" --max-records 50 >> "$OUTPUT_FILE"

# 搜索弱SSL配置
echo "=== 弱SSL配置 ===" >> "$OUTPUT_FILE"
censys search "services.tls.certificate.parsed.names:* and services.tls.version:TLSv1.0" --max-records 50 >> "$OUTPUT_FILE"

# 搜索开放的管理端口
echo "=== 开放的管理端口 ===" >> "$OUTPUT_FILE"
censys search "services.port:3389" --max-records 50 >> "$OUTPUT_FILE"

echo "配置错误检测完成，结果已保存到 $OUTPUT_FILE"

大师级使用#

自动化监控#

持续监控脚本#

#!/bin/bash
# 持续监控脚本

MONITOR_TARGET="example.com"
OUTPUT_DIR="monitoring"
INTERVAL=3600 # 每小时检查一次
mkdir -p "$OUTPUT_DIR"

while true; do
 TIMESTAMP=$(date +%Y%m%d_%H%M%S)
 LOG_FILE="$OUTPUT_DIR/monitor_$TIMESTAMP.txt"
 
 echo "=== 监控时间: $(date) ===" > "$LOG_FILE"
 
 # 搜索新的证书
 echo "=== 新证书 ===" >> "$LOG_FILE"
 censys search "parsed.names:$MONITOR_TARGET" --max-records 100 >> "$LOG_FILE"
 
 # 搜索新的IP
 echo "=== 新IP地址 ===" >> "$LOG_FILE"
 censys search "parsed.names:$MONITOR_TARGET" --fields ip --format csv | cut -d',' -f1 | sort -u >> "$LOG_FILE"
 
 # 搜索开放端口
 echo "=== 开放端口 ===" >> "$LOG_FILE"
 while read ip; do
 censys view "$ip" >> "$LOG_FILE"
 done < <(censys search "parsed.names:$MONITOR_TARGET" --fields ip --format csv | cut -d',' -f1 | sort -u)
 
 echo "监控完成，结果已保存到 $LOG_FILE"
 sleep "$INTERVAL"
done

变化检测#

#!/bin/bash
# 变化检测脚本

TARGET="example.com"
PREVIOUS_FILE="previous_state.txt"
CURRENT_FILE="current_state.txt"
CHANGES_FILE="changes.txt"

# 获取当前状态
censys search "parsed.names:$TARGET" --max-records 100 > "$CURRENT_FILE"

# 检查是否有变化
if [ -f "$PREVIOUS_FILE" ]; then
 diff "$PREVIOUS_FILE" "$CURRENT_FILE" > "$CHANGES_FILE"
 
 if [ -s "$CHANGES_FILE" ]; then
 echo "$(date): 检测到变化" >> change_log.txt
 cat "$CHANGES_FILE" >> change_log.txt
 echo "检测到变化，详情已记录到 change_log.txt"
 else
 echo "未检测到变化"
 fi
fi

# 保存当前状态
cp "$CURRENT_FILE" "$PREVIOUS_FILE"

数据分析#

统计分析#

#!/usr/bin/env python3
from censys.search import CensysHosts
import json
from collections import Counter

# 初始化API
h = CensysHosts(api_id="your_api_id", api_secret="your_api_secret")

# 搜索特定端口
query = h.search("services.port:443", fields=["ip", "location.country_code", "services.software.product"])

# 统计数据
countries = []
products = []

for page in query:
 for host in page:
 if 'location' in host and 'country_code' in host['location']:
 countries.append(host['location']['country_code'])
 if 'services' in host:
 for service in host['services']:
 if 'software' in service and 'product' in service['software']:
 products.append(service['software']['product'])

# 输出统计结果
print("=== 国家分布 ===")
country_counter = Counter(countries)
for country, count in country_counter.most_common(10):
 print(f"{country}: {count}")

print("\n=== 软件分布 ===")
product_counter = Counter(products)
for product, count in product_counter.most_common(10):
 print(f"{product}: {count}")

地理分布分析#

#!/usr/bin/env python3
from censys.search import CensysHosts
import json

# 初始化API
h = CensysHosts(api_id="your_api_id", api_secret="your_api_secret")

# 搜索特定ASN
query = h.search("autonomous_system.asn:15169", fields=["ip", "location.country_code", "location.city", "location.latitude", "location.longitude"])

# 生成地图数据
map_data = []

for page in query:
 for host in page:
 if 'location' in host and 'latitude' in host['location'] and 'longitude' in host['location']:
 map_data.append({
 'ip': host['ip'],
 'country': host['location'].get('country_code', ''),
 'city': host['location'].get('city', ''),
 'lat': host['location']['latitude'],
 'lon': host['location']['longitude']
 })

# 保存地图数据
with open("map_data.json", "w") as f:
 json.dump(map_data, f, indent=2)

print(f"生成了 {len(map_data)} 个地理数据点")

实战案例#

案例1: 企业资产发现#

场景描述#

发现和管理企业的网络资产，包括服务器、域名、证书等。

ZoomEye使用教程

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

ZoomEye使用教程#

软件介绍#

ZoomEye是中国著名的网络空间搜索引擎，专注于发现和识别互联网上的设备、服务和应用。它提供对全球网络空间的实时监控，支持主机、Web、设备等多种搜索类型，是网络安全研究和威胁情报收集的重要工具。

主要功能#

主机搜索和发现
Web应用搜索
设备指纹识别
网络空间测绘
威胁情报收集
漏洞扫描
资产发现
API接口支持

适用场景#

网络安全研究
渗透测试
资产发现和管理
威胁情报收集
安全评估
攻击面分析

入门级使用#

注册账号和获取API密钥#

注册ZoomEye账号#

访问 https://www.zoomeye.org/
点击"注册"创建免费账号
验证邮箱地址
登录获取API密钥

获取API密钥#

# 登录后在个人中心获取API密钥
# API密钥格式: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

安装ZoomEye CLI#

使用pip安装#

# 安装ZoomEye命令行工具
pip install zoomeye

# 验证安装
zoomeye --version

配置API密钥#

# 配置API密钥
zoomeye init

# 按提示输入API密钥

# 或设置环境变量
export ZOOMEYE_API_KEY="your_api_key"

基本搜索#

搜索特定IP#

# 搜索特定IP地址
zoomeye search ip:8.8.8.8

# 输出示例
{
 "matches": [
 {
 "ip": "8.8.8.8",
 "port": 53,
 "protocol": "dns",
 "app": "Google DNS",
 "version": "",
 "os": "",
 "country": "US",
 "city": "Mountain View",
 "as_number": 15169,
 "as_organization": "Google LLC"
 }
 ],
 "total": 1
}

搜索特定端口#

# 搜索开放特定端口的设备
zoomeye search port:80

# 搜索开放多个端口的设备
zoomeye search "port:80,443"

# 搜索端口范围
zoomeye search "port:8000-9000"

搜索特定服务#

# 搜索Apache服务器
zoomeye search app:Apache

# 搜索Nginx服务器
zoomeye search app:Nginx

# 搜索MySQL数据库
zoomeye search app:MySQL

初级使用#

高级搜索语法#

布尔运算符#

# AND运算符（默认）
zoomeye search "port:80 app:Apache"

# OR运算符
zoomeye search "app:Apache OR app:Nginx"

# NOT运算符
zoomeye search "port:80 NOT app:Apache"

国家和地区搜索#

# 搜索特定国家的设备
zoomeye search country:CN

# 搜索特定城市的设备
zoomeye search city:"Beijing"

# 搜索多个国家
zoomeye search "country:CN OR country:US"

ASN搜索#

# 搜索特定ASN的设备
zoomeye search asn:15169

# 搜索特定组织的设备
zoomeye search org:"Google LLC"

Web搜索#

搜索特定网站#

# 搜索包含特定标题的网站
zoomeye web search title:"Welcome to"

# 搜索特定域名的网站
zoomeye web search site:example.com

# 搜索特定响应头的网站
zoomeye web search header:"nginx"

搜索Web应用#

# 搜索WordPress网站
zoomeye web search app:WordPress

# 搜索Discuz论坛
zoomeye web search app:Discuz

# 搜索Dedecms
zoomeye web search app:Dedecms

搜索特定技术栈#

# 搜索使用PHP的网站
zoomeye web search app:PHP

# 搜索使用Java的网站
zoomeye web search app:Java

# 搜索使用Python的网站
zoomeye web search app:Python

中级使用#

设备搜索#

搜索IoT设备#

# 搜索摄像头设备
zoomeye search app:"Hikvision"

# 搜索路由器设备
zoomeye search app:"TP-Link"

# 搜索工业控制设备
zoomeye search app:"Siemens"

搜索网络设备#

# 搜索防火墙设备
zoomeye search app:"Fortinet"

# 搜索交换机设备
zoomeye search app:"Cisco"

# 搜索VPN设备
zoomeye search app:"OpenVPN"

批量查询#

从文件批量查询#

#!/bin/bash
# 批量查询IP信息

IP_FILE="ip_list.txt"
OUTPUT_FILE="zoomeye_results.txt"

while read ip; do
 echo "=== $ip ===" >> "$OUTPUT_FILE"
 zoomeye search "ip:$ip" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "批量查询完成，结果已保存到 $OUTPUT_FILE"

批量搜索#

#!/bin/bash
# 批量搜索不同条件

SEARCH_TERMS=(
 "port:22"
 "port:3306"
 "port:6379"
 "port:27017"
)

OUTPUT_FILE="batch_search_results.txt"

for term in "${SEARCH_TERMS[@]}"; do
 echo "=== 搜索: $term ===" >> "$OUTPUT_FILE"
 zoomeye search "$term" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done

echo "批量搜索完成"

数据导出#

导出为JSON#

# 导出搜索结果为JSON
zoomeye search "port:443" --format json > results.json

# 导出特定数量的结果
zoomeye search "port:443" --format json --limit 100 > results.json

导出为CSV#

# 导出搜索结果为CSV
zoomeye search "port:443" --format csv > results.csv

# 导出特定字段
zoomeye search "port:443" --format csv --fields ip,port,app,country > results.csv

中上级使用#

高级过滤#

按操作系统过滤#

# 搜索Windows设备
zoomeye search os:Windows

# 搜索Linux设备
zoomeye search os:Linux

# 搜索特定版本的操作系统
zoomeye search os:"Ubuntu 20.04"

按服务版本过滤#

# 搜索特定版本的软件
zoomeye search "app:Apache version:2.4.41"

# 搜索包含特定漏洞的设备
zoomeye search "app:Apache version:2.4.41"

API编程#

Python API示例#

#!/usr/bin/env python3
import zoomeye
import json

# 初始化API
api = zoomeye.ZoomEye(api_key="your_api_key")

# 搜索特定端口
results = api.search("port:443")

# 遍历结果
for match in results['matches']:
 print(f"IP: {match['ip']}")
 print(f"端口: {match['port']}")
 print(f"应用: {match['app']}")
 print(f"国家: {match.get('country', '')}")
 print()

批量查询示例#

#!/usr/bin/env python3
import zoomeye
import json

# 初始化API
api = zoomeye.ZoomEye(api_key="your_api_key")

# 批量查询IP列表
ip_list = ["8.8.8.8", "1.1.1.1", "208.67.222.222"]
results = []

for ip in ip_list:
 try:
 result = api.search(f"ip:{ip}")
 results.append(result)
 print(f"查询成功: {ip}")
 except Exception as e:
 print(f"查询失败: {ip} - {e}")

# 保存结果
with open("zoomeye_results.json", "w") as f:
 json.dump(results, f, indent=2)

print("批量查询完成")

Web搜索API示例#

#!/usr/bin/env python3
import zoomeye
import json

# 初始化API
api = zoomeye.ZoomEye(api_key="your_api_key")

# 搜索特定Web应用
results = api.web_search("app:WordPress")

# 遍历结果
for match in results['matches']:
 print(f"网站: {match['site']}")
 print(f"IP: {match['ip']}")
 print(f"端口: {match['port']}")
 print(f"应用: {match['app']}")
 print()

高级使用#

攻击面分析#

分析组织攻击面#

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

DOMAIN="example.com"
OUTPUT_DIR="attack_surface_analysis"
mkdir -p "$OUTPUT_DIR"

# 搜索组织的所有主机
echo "=== 主机分析 ===" > "$OUTPUT_DIR/hosts.txt"
zoomeye search "hostname:*.$DOMAIN" >> "$OUTPUT_DIR/hosts.txt"

# 搜索组织的所有Web应用
echo "=== Web应用分析 ===" > "$OUTPUT_DIR/web_apps.txt"
zoomeye web search "site:$DOMAIN" >> "$OUTPUT_DIR/web_apps.txt"

# 搜索组织的证书
echo "=== 证书分析 ===" > "$OUTPUT_DIR/certificates.txt"
zoomeye search "cert:$DOMAIN" >> "$OUTPUT_DIR/certificates.txt"

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

子域名发现#

#!/bin/bash
# 子域名发现脚本

DOMAIN="example.com"
OUTPUT_FILE="subdomains.txt"

# 搜索包含域名的证书
zoomeye search "cert:*.$DOMAIN" --format json | \
 jq -r '.matches[].cert.subject_alt_names[]' | \
 grep -o "[a-zA-Z0-9-]*\.$DOMAIN" | \
 sort -u > "$OUTPUT_FILE"

echo "发现 $(wc -l < "$OUTPUT_FILE") 个子域名"
echo "子域名列表已保存到 $OUTPUT_FILE"

漏洞扫描#

搜索易受攻击的设备#

#!/bin/bash
# 搜索易受攻击的设备脚本

OUTPUT_FILE="vulnerable_devices.txt"

# 搜索运行旧版本Apache的设备
echo "=== 旧版本Apache设备 ===" > "$OUTPUT_FILE"
zoomeye search "app:Apache version:2.4.*" >> "$OUTPUT_FILE"

# 搜索运行旧版本Nginx的设备
echo "=== 旧版本Nginx设备 ===" >> "$OUTPUT_FILE"
zoomeye search "app:Nginx version:1.18.*" >> "$OUTPUT_FILE"

# 搜索开放危险端口的设备
echo "=== 开放危险端口的设备 ===" >> "$OUTPUT_FILE"
zoomeye search "port:23" >> "$OUTPUT_FILE"

echo "漏洞扫描完成，结果已保存到 $OUTPUT_FILE"

检测配置错误#

#!/bin/bash
# 检测配置错误脚本

OUTPUT_FILE="misconfigurations.txt"

# 搜索未加密的FTP服务
echo "=== 未加密的FTP服务 ===" > "$OUTPUT_FILE"
zoomeye search "port:21 app:FTP" >> "$OUTPUT_FILE"

# 搜索弱SSL配置
echo "=== 弱SSL配置 ===" >> "$OUTPUT_FILE"
zoomeye search "port:443 app:Apache" >> "$OUTPUT_FILE"

# 搜索开放的管理端口
echo "=== 开放的管理端口 ===" >> "$OUTPUT_FILE"
zoomeye search "port:3389" >> "$OUTPUT_FILE"

echo "配置错误检测完成，结果已保存到 $OUTPUT_FILE"

大师级使用#

自动化监控#

持续监控脚本#

#!/bin/bash
# 持续监控脚本

MONITOR_TARGET="example.com"
OUTPUT_DIR="monitoring"
INTERVAL=3600 # 每小时检查一次
mkdir -p "$OUTPUT_DIR"

while true; do
 TIMESTAMP=$(date +%Y%m%d_%H%M%S)
 LOG_FILE="$OUTPUT_DIR/monitor_$TIMESTAMP.txt"
 
 echo "=== 监控时间: $(date) ===" > "$LOG_FILE"
 
 # 搜索新的主机
 echo "=== 新主机 ===" >> "$LOG_FILE"
 zoomeye search "hostname:*.$MONITOR_TARGET" >> "$LOG_FILE"
 
 # 搜索新的Web应用
 echo "=== 新Web应用 ===" >> "$LOG_FILE"
 zoomeye web search "site:$MONITOR_TARGET" >> "$LOG_FILE"
 
 # 搜索开放端口
 echo "=== 开放端口 ===" >> "$LOG_FILE"
 zoomeye search "hostname:*.$MONITOR_TARGET" >> "$LOG_FILE"
 
 echo "监控完成，结果已保存到 $LOG_FILE"
 sleep "$INTERVAL"
done

变化检测#

#!/bin/bash
# 变化检测脚本

TARGET="example.com"
PREVIOUS_FILE="previous_state.txt"
CURRENT_FILE="current_state.txt"
CHANGES_FILE="changes.txt"

# 获取当前状态
zoomeye search "hostname:*.$TARGET" > "$CURRENT_FILE"

# 检查是否有变化
if [ -f "$PREVIOUS_FILE" ]; then
 diff "$PREVIOUS_FILE" "$CURRENT_FILE" > "$CHANGES_FILE"
 
 if [ -s "$CHANGES_FILE" ]; then
 echo "$(date): 检测到变化" >> change_log.txt
 cat "$CHANGES_FILE" >> change_log.txt
 echo "检测到变化，详情已记录到 change_log.txt"
 else
 echo "未检测到变化"
 fi
fi

# 保存当前状态
cp "$CURRENT_FILE" "$PREVIOUS_FILE"

数据分析#

统计分析#

#!/usr/bin/env python3
import zoomeye
import json
from collections import Counter

# 初始化API
api = zoomeye.ZoomEye(api_key="your_api_key")

# 搜索特定端口
results = api.search("port:443")

# 统计数据
countries = []
apps = []

for match in results['matches']:
 if 'country' in match:
 countries.append(match['country'])
 if 'app' in match:
 apps.append(match['app'])

# 输出统计结果
print("=== 国家分布 ===")
country_counter = Counter(countries)
for country, count in country_counter.most_common(10):
 print(f"{country}: {count}")

print("\n=== 应用分布 ===")
app_counter = Counter(apps)
for app, count in app_counter.most_common(10):
 print(f"{app}: {count}")

地理分布分析#

#!/usr/bin/env python3
import zoomeye
import json

# 初始化API
api = zoomeye.ZoomEye(api_key="your_api_key")

# 搜索特定ASN
results = api.search("asn:15169")

# 生成地图数据
map_data = []

for match in results['matches']:
 if 'geoinfo' in match:
 map_data.append({
 'ip': match['ip'],
 'country': match.get('country', ''),
 'city': match.get('city', ''),
 'lat': match['geoinfo'].get('latitude', 0),
 'lon': match['geoinfo'].get('longitude', 0)
 })

# 保存地图数据
with open("map_data.json", "w") as f:
 json.dump(map_data, f, indent=2)

print(f"生成了 {len(map_data)} 个地理数据点")

实战案例#

案例1: 企业资产发现#

场景描述#

发现和管理企业的网络资产，包括服务器、域名、证书等。

Fofa使用教程

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

Fofa使用教程#

软件介绍#

Fofa是中国著名的网络空间搜索引擎，专注于发现和识别互联网上的设备、服务和应用。它提供对全球网络空间的实时监控，支持主机、Web、证书等多种搜索类型，具有强大的搜索语法和丰富的数据维度，是网络安全研究和威胁情报收集的重要工具。

主要功能#

主机搜索和发现
Web应用搜索
证书搜索和分析
网络空间测绘
威胁情报收集
漏洞扫描
资产发现
API接口支持

适用场景#

网络安全研究
渗透测试
资产发现和管理
威胁情报收集
安全评估
攻击面分析

入门级使用#

注册账号和获取API密钥#

注册Fofa账号#

访问 https://fofa.info/
点击"注册"创建免费账号
验证邮箱地址
登录获取API密钥

获取API密钥#

# 登录后在个人中心获取API密钥
# API密钥格式: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

安装Fofa CLI#

使用pip安装#

# 安装Fofa命令行工具
pip install fofa

# 验证安装
fofa --version

配置API密钥#

# 配置API密钥
fofa config

# 按提示输入API密钥和邮箱

# 或设置环境变量
export FOFA_API_KEY="your_api_key"
export FOFA_EMAIL="your_email@example.com"

基本搜索#

搜索特定IP#

# 搜索特定IP地址
fofa search "ip=8.8.8.8"

# 输出示例
{
 "results": [
 {
 "host": "8.8.8.8",
 "ip": "8.8.8.8",
 "port": 53,
 "protocol": "dns",
 "title": "",
 "country": "US",
 "as_number": 15169,
 "as_organization": "Google LLC",
 "lastupdatetime": "2024-01-01 00:00:00"
 }
 ],
 "size": 1
}

搜索特定端口#

# 搜索开放特定端口的设备
fofa search "port=80"

# 搜索开放多个端口的设备
fofa search "port=80,443"

# 搜索端口范围
fofa search "port=8000-9000"

搜索特定服务#

# 搜索Apache服务器
fofa search "server=Apache"

# 搜索Nginx服务器
fofa search "server=Nginx"

# 搜索MySQL数据库
fofa search "app=MySQL"

初级使用#

高级搜索语法#

布尔运算符#

# AND运算符（默认）
fofa search "port=80 && server=Apache"

# OR运算符
fofa search "server=Apache || server=Nginx"

# NOT运算符
fofa search "port=80 && !server=Apache"

国家和地区搜索#

# 搜索特定国家的设备
fofa search "country=CN"

# 搜索特定城市的设备
fofa search "city=Beijing"

# 搜索多个国家
fofa search "country=CN || country=US"

ASN搜索#

# 搜索特定ASN的设备
fofa search "asn=15169"

# 搜索特定组织的设备
fofa search "org=Google"

Web搜索#

搜索特定网站#

# 搜索包含特定标题的网站
fofa search "title=Welcome"

# 搜索特定域名的网站
fofa search "domain=example.com"

# 搜索特定响应头的网站
fofa search "header=nginx"

搜索Web应用#

# 搜索WordPress网站
fofa search "app=WordPress"

# 搜索Discuz论坛
fofa search "app=Discuz"

# 搜索Dedecms
fofa search "app=Dedecms"

搜索特定技术栈#

# 搜索使用PHP的网站
fofa search "app=PHP"

# 搜索使用Java的网站
fofa search "app=Java"

# 搜索使用Python的网站
fofa search "app=Python"

中级使用#

证书搜索#

搜索SSL证书#

# 搜索特定域名的证书
fofa search "cert=example.com"

# 搜索特定CA颁发的证书
fofa search "cert=Let's Encrypt"

# 搜索即将过期的证书
fofa search "cert=example.com && cert.is_valid=true"

搜索证书信息#

# 搜索自签名证书
fofa search "cert.is_self_signed=true"

# 搜索通配符证书
fofa search "cert=*"

# 搜索特定组织的证书
fofa search "cert.subject.organization=Google"

批量查询#

从文件批量查询#

#!/bin/bash
# 批量查询IP信息

IP_FILE="ip_list.txt"
OUTPUT_FILE="fofa_results.txt"

while read ip; do
 echo "=== $ip ===" >> "$OUTPUT_FILE"
 fofa search "ip=$ip" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done < "$IP_FILE"

echo "批量查询完成，结果已保存到 $OUTPUT_FILE"

批量搜索#

#!/bin/bash
# 批量搜索不同条件

SEARCH_TERMS=(
 "port=22"
 "port=3306"
 "port=6379"
 "port=27017"
)

OUTPUT_FILE="batch_search_results.txt"

for term in "${SEARCH_TERMS[@]}"; do
 echo "=== 搜索: $term ===" >> "$OUTPUT_FILE"
 fofa search "$term" >> "$OUTPUT_FILE"
 echo "" >> "$OUTPUT_FILE"
done

echo "批量搜索完成"

数据导出#

导出为JSON#

# 导出搜索结果为JSON
fofa search "port=443" --format json > results.json

# 导出特定数量的结果
fofa search "port=443" --format json --limit 100 > results.json

导出为CSV#

# 导出搜索结果为CSV
fofa search "port=443" --format csv > results.csv

# 导出特定字段
fofa search "port=443" --format csv --fields ip,port,server,country > results.csv

中上级使用#

高级过滤#

按操作系统过滤#

# 搜索Windows设备
fofa search "os=Windows"

# 搜索Linux设备
fofa search "os=Linux"

# 搜索特定版本的操作系统
fofa search "os=Ubuntu 20.04"

按服务版本过滤#

# 搜索特定版本的软件
fofa search "server=Apache && version=2.4.41"

# 搜索包含特定漏洞的设备
fofa search "server=Apache && version=2.4.41"

API编程#

Python API示例#

#!/usr/bin/env python3
from fofa import Fofa
import json

# 初始化API
client = Fofa(email="your_email@example.com", key="your_api_key")

# 搜索特定端口
results = client.search("port=443", fields=["ip", "port", "server", "country"])

# 遍历结果
for result in results:
 print(f"IP: {result[0]}")
 print(f"端口: {result[1]}")
 print(f"服务器: {result[2]}")
 print(f"国家: {result[3]}")
 print()

批量查询示例#

#!/usr/bin/env python3
from fofa import Fofa
import json

# 初始化API
client = Fofa(email="your_email@example.com", key="your_api_key")

# 批量查询IP列表
ip_list = ["8.8.8.8", "1.1.1.1", "208.67.222.222"]
results = []

for ip in ip_list:
 try:
 result = client.search(f"ip={ip}")
 results.append(result)
 print(f"查询成功: {ip}")
 except Exception as e:
 print(f"查询失败: {ip} - {e}")

# 保存结果
with open("fofa_results.json", "w") as f:
 json.dump(results, f, indent=2)

print("批量查询完成")

Web搜索API示例#

#!/usr/bin/env python3
from fofa import Fofa
import json

# 初始化API
client = Fofa(email="your_email@example.com", key="your_api_key")

# 搜索特定Web应用
results = client.search("app=WordPress", fields=["host", "ip", "port", "title"])

# 遍历结果
for result in results:
 print(f"网站: {result[0]}")
 print(f"IP: {result[1]}")
 print(f"端口: {result[2]}")
 print(f"标题: {result[3]}")
 print()

高级使用#

攻击面分析#

分析组织攻击面#

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

DOMAIN="example.com"
OUTPUT_DIR="attack_surface_analysis"
mkdir -p "$OUTPUT_DIR"

# 搜索组织的所有主机
echo "=== 主机分析 ===" > "$OUTPUT_DIR/hosts.txt"
fofa search "domain=*.$DOMAIN" >> "$OUTPUT_DIR/hosts.txt"

# 搜索组织的所有Web应用
echo "=== Web应用分析 ===" > "$OUTPUT_DIR/web_apps.txt"
fofa search "domain=$DOMAIN" >> "$OUTPUT_DIR/web_apps.txt"

# 搜索组织的证书
echo "=== 证书分析 ===" > "$OUTPUT_DIR/certificates.txt"
fofa search "cert=$DOMAIN" >> "$OUTPUT_DIR/certificates.txt"

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

子域名发现#

#!/bin/bash
# 子域名发现脚本

DOMAIN="example.com"
OUTPUT_FILE="subdomains.txt"

# 搜索包含域名的证书
fofa search "cert=*.$DOMAIN" --format json | \
 jq -r '.results[][0]' | \
 grep -o "[a-zA-Z0-9-]*\.$DOMAIN" | \
 sort -u > "$OUTPUT_FILE"

echo "发现 $(wc -l < "$OUTPUT_FILE") 个子域名"
echo "子域名列表已保存到 $OUTPUT_FILE"

漏洞扫描#

搜索易受攻击的设备#

#!/bin/bash
# 搜索易受攻击的设备脚本

OUTPUT_FILE="vulnerable_devices.txt"

# 搜索运行旧版本Apache的设备
echo "=== 旧版本Apache设备 ===" > "$OUTPUT_FILE"
fofa search "server=Apache && version=2.4.*" >> "$OUTPUT_FILE"

# 搜索运行旧版本Nginx的设备
echo "=== 旧版本Nginx设备 ===" >> "$OUTPUT_FILE"
fofa search "server=Nginx && version=1.18.*" >> "$OUTPUT_FILE"

# 搜索开放危险端口的设备
echo "=== 开放危险端口的设备 ===" >> "$OUTPUT_FILE"
fofa search "port=23" >> "$OUTPUT_FILE"

echo "漏洞扫描完成，结果已保存到 $OUTPUT_FILE"

检测配置错误#

#!/bin/bash
# 检测配置错误脚本

OUTPUT_FILE="misconfigurations.txt"

# 搜索未加密的FTP服务
echo "=== 未加密的FTP服务 ===" > "$OUTPUT_FILE"
fofa search "port=21 && app=FTP" >> "$OUTPUT_FILE"

# 搜索弱SSL配置
echo "=== 弱SSL配置 ===" >> "$OUTPUT_FILE"
fofa search "port=443 && server=Apache" >> "$OUTPUT_FILE"

# 搜索开放的管理端口
echo "=== 开放的管理端口 ===" >> "$OUTPUT_FILE"
fofa search "port=3389" >> "$OUTPUT_FILE"

echo "配置错误检测完成，结果已保存到 $OUTPUT_FILE"

大师级使用#

自动化监控#

持续监控脚本#

#!/bin/bash
# 持续监控脚本

MONITOR_TARGET="example.com"
OUTPUT_DIR="monitoring"
INTERVAL=3600 # 每小时检查一次
mkdir -p "$OUTPUT_DIR"

while true; do
 TIMESTAMP=$(date +%Y%m%d_%H%M%S)
 LOG_FILE="$OUTPUT_DIR/monitor_$TIMESTAMP.txt"
 
 echo "=== 监控时间: $(date) ===" > "$LOG_FILE"
 
 # 搜索新的主机
 echo "=== 新主机 ===" >> "$LOG_FILE"
 fofa search "domain=*.$MONITOR_TARGET" >> "$LOG_FILE"
 
 # 搜索新的Web应用
 echo "=== 新Web应用 ===" >> "$LOG_FILE"
 fofa search "domain=$MONITOR_TARGET" >> "$LOG_FILE"
 
 # 搜索开放端口
 echo "=== 开放端口 ===" >> "$LOG_FILE"
 fofa search "domain=*.$MONITOR_TARGET" >> "$LOG_FILE"
 
 echo "监控完成，结果已保存到 $LOG_FILE"
 sleep "$INTERVAL"
done

变化检测#

#!/bin/bash
# 变化检测脚本

TARGET="example.com"
PREVIOUS_FILE="previous_state.txt"
CURRENT_FILE="current_state.txt"
CHANGES_FILE="changes.txt"

# 获取当前状态
fofa search "domain=*.$TARGET" > "$CURRENT_FILE"

# 检查是否有变化
if [ -f "$PREVIOUS_FILE" ]; then
 diff "$PREVIOUS_FILE" "$CURRENT_FILE" > "$CHANGES_FILE"
 
 if [ -s "$CHANGES_FILE" ]; then
 echo "$(date): 检测到变化" >> change_log.txt
 cat "$CHANGES_FILE" >> change_log.txt
 echo "检测到变化，详情已记录到 change_log.txt"
 else
 echo "未检测到变化"
 fi
fi

# 保存当前状态
cp "$CURRENT_FILE" "$PREVIOUS_FILE"

数据分析#

统计分析#

#!/usr/bin/env python3
from fofa import Fofa
from collections import Counter

# 初始化API
client = Fofa(email="your_email@example.com", key="your_api_key")

# 搜索特定端口
results = client.search("port=443", fields=["ip", "port", "server", "country"])

# 统计数据
countries = []
servers = []

for result in results:
 if result[3]:
 countries.append(result[3])
 if result[2]:
 servers.append(result[2])

# 输出统计结果
print("=== 国家分布 ===")
country_counter = Counter(countries)
for country, count in country_counter.most_common(10):
 print(f"{country}: {count}")

print("\n=== 服务器分布 ===")
server_counter = Counter(servers)
for server, count in server_counter.most_common(10):
 print(f"{server}: {count}")

地理分布分析#

#!/usr/bin/env python3
from fofa import Fofa
import json

# 初始化API
client = Fofa(email="your_email@example.com", key="your_api_key")

# 搜索特定ASN
results = client.search("asn=15169", fields=["ip", "country", "city", "latitude", "longitude"])

# 生成地图数据
map_data = []

for result in results:
 if result[3] and result[4]:
 map_data.append({
 'ip': result[0],
 'country': result[1] if result[1] else '',
 'city': result[2] if result[2] else '',
 'lat': float(result[3]),
 'lon': float(result[4])
 })

# 保存地图数据
with open("map_data.json", "w") as f:
 json.dump(map_data, f, indent=2)

print(f"生成了 {len(map_data)} 个地理数据点")

实战案例#

案例1: 企业资产发现#

场景描述#

发现和管理企业的网络资产，包括服务器、域名、证书等。

IP扫描技术详解

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

IP扫描技术详解#

技术介绍#

IP扫描是网络安全中信息收集的重要环节，通过自动化工具和技术手段，发现目标网络的活跃主机、开放端口和运行服务，为后续的安全测试和漏洞评估提供基础。IP扫描技术广泛应用于网络安全评估、漏洞扫描和渗透测试等场景。

IP扫描核心概念#

活跃主机发现：通过各种手段发现网络中的活跃主机
端口扫描：扫描目标主机的开放端口
服务识别：识别目标端口上运行的服务和版本
操作系统探测：探测目标主机的操作系统类型和版本
网络映射：绘制目标网络的拓扑结构

IP扫描架构#

网络发现：发现网络中的活跃主机
端口扫描：扫描目标主机的开放端口
服务识别：识别目标端口上运行的服务
操作系统探测：探测目标主机的操作系统
漏洞扫描：检测目标主机的安全漏洞
报告生成：生成详细的扫描报告

入门级使用#

活跃主机发现#

使用基本工具发现活跃主机：

# 使用ping命令发现活跃主机
ping -c 1 192.168.1.1
ping -c 1 192.168.1.2

# 使用ping扫描发现活跃主机
for i in {1..254}; do ping -c 1 192.168.1.$i | grep "64 bytes" | cut -d " " -f 4; done

# 使用arp-scan发现活跃主机
arp-scan -l

# 使用nmap发现活跃主机
nmap -sn 192.168.1.0/24

# 使用fping发现活跃主机
fping -a -g 192.168.1.0/24

端口扫描#

使用基本工具扫描端口：

# 使用netcat扫描端口
nc -zv 192.168.1.1 1-1000

# 使用telnet扫描端口
telnet 192.168.1.1 80

# 使用nmap扫描端口
nmap -p 1-1000 192.168.1.1

# 使用masscan扫描端口
masscan -p 1-65535 192.168.1.1 --rate=1000

# 使用unicornscan扫描端口
unicornscan -mT 192.168.1.1:1-1000

服务识别#

识别目标端口上运行的服务：

Shodan使用教程

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

Shodan使用教程#

软件介绍#

Shodan是一款强大的互联网搜索引擎，专注于连接到互联网的设备和系统。它可以帮助安全专业人员发现网络设备、服务器、IoT设备等，并获取详细的设备信息。

入门级使用#

基本搜索#

功能说明：使用Shodan搜索互联网上的设备和系统

使用示例：

# 基本IP搜索
shodan search 8.8.8.8

# 搜索特定服务
shodan search "nginx"

# 搜索特定端口
shodan search "port:80"

# 搜索特定国家
shodan search "country:US"

参数说明：

search：执行搜索查询
支持各种搜索过滤器

基本主机信息查询#

功能说明：查询特定IP或域名的详细信息

使用示例：

# 查询IP信息
shodan host 8.8.8.8

# 查询域名信息
shodan host example.com

# 查询多个IP
for ip in 8.8.8.8 1.1.1.1; do shodan host $ip; done

参数说明：

host：查询主机信息

初级使用#

搜索过滤器#

功能说明：使用各种过滤器进行精确搜索

使用示例：

# 按产品搜索
shodan search "product:Apache"

# 按版本搜索
shodan search "version:2.4"

# 按操作系统搜索
shodan search "os:Linux"

# 按组织搜索
shodan search "org:Google"

# 组合搜索
shodan search "product:nginx country:CN port:80"

参数说明：