Appearance
日志里的「百度蜘蛛」九成是假的?用 Go 三步验证真伪(反查 DNS + IP 归属地)
站长群里隔三差五就有人说"百度蜘蛛今天爬了我五万次",配一张访问日志截图。真有这么多吗?多数情况是:里面九成以上是伪蜘蛛。
伪蜘蛛的来源不复杂——采集器为了绕过反爬,把自己伪装成搜索引擎;CC 探测顺手带上蜘蛛 UA 碰运气;还有专门"刷蜘蛛日志"的服务,用海量假 UA 请求把日志冲花。后果很实在:真蜘蛛和假蜘蛛混在一起,你没法从日志里读出任何 SEO 信号;要是防不住,直接按 UA 把"百度蜘蛛"全封了,真实抓取被挡,收录就掉。
所以需要一套能验证的判断。这件事百度官方给过明确方法,只是官方文档写得很短,很多人没照着做。
一、只看 UA 等于没看
User-Agent 就是一行字符串,Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html) 谁都能原样发。而且真百度自己就有好几个变体(PC 端 Baiduspider、渲染用的 Baiduspider-render、移动端和小程序端还有各自的 UA),拿 UA 列表去做白名单,维护成本高、漏判还多。
百度搜索资源平台的官方教程给的方法是"双向 DNS 解析认证",两步:
- 反向解析(PTR):对访问 IP 做反向 DNS 解析,百度蜘蛛的主机名一定以
*.baidu.com或*.baidu.jp结尾——注意还有个.baidu.jp的域名空间,只认.baidu.com会误判一部分真蜘蛛。格式长这样:baiduspider-220-181-108-151.crawl.baidu.com(主机名里嵌着 IP,用点分格式写的)。 - 正向解析:把反查到的这个主机名再做一次正向解析,必须能回到日志里的原始 IP。这一步是为了防 PTR 伪造——反向解析记录是 IP 持有者自己配的,伪造合法的反向域名理论上是可行的,正反一对就堵住了。
顺带说一个常见误解:网上流传的"百度蜘蛛 IP 段大全"不是官方发布的。 官方明确说过蜘蛛 IP 段动态变化、不对外公布,所以那段名单只能当参考。真正的判据是双向 DNS,别拿 IP 段当判据——按名单误封真蜘蛛,代价是掉收录。
二、IP 归属地在这里扮演什么角色
双向 DNS 是判决书,IP 归属地是旁证和善后工具,三个用处:
- 旁证:实测百度蜘蛛的 IP 在归属地库里通常能直接看出身份——
220.181.108.151返回的isp字段是"百度/蜘蛛/电信",116.179.32.226是"百度蜘蛛/联通",180.76.15.1是"百度/蜘蛛"。也就是说运营商字段本身就带"蜘蛛"标记,可以拿来做一层粗筛(不能当判据,但能把"明显不像百度机房"的请求先挑出来)。 - 定位伪蜘蛛的窝:伪蜘蛛很少来自家宽,多来自机房和云,
isp一看就知道是哪家(配合 VIP 版的ip_type,能直接判定 IDC 机房)。把伪蜘蛛 IP 按机房聚合,你会发现它们高度集中在几个网段——这比"封单个 IP"有效得多。 - 判断是否误封:真蜘蛛的归属地地理分布很固定(北京、山西阳泉这类百度自有机房城市高密度出现),封禁规则误伤了真蜘蛛,从归属地分布上能立刻看出来。
三、Go 实现:读日志 → 三步验证 → 输出真伪报告
一份单文件 Go 程序,做四件事:解析 nginx 访问日志、筛出"自称是蜘蛛"的记录、对涉及的独立 IP 做三步验证(并发 + 缓存 + 限速)、输出报告。
go
// go run main.go access.log
package main
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net"
"net/http"
"net/url"
"os"
"regexp"
"sort"
"strings"
"sync"
"time"
)
const (
geoAPI = "https://ip9.com.cn/get?ip="
ua = "spider-verify/1.0 (+https://example.com)" // 不带 UA 会被挡:HTTP 403 / error code: 1010
)
var (
ipRE = regexp.MustCompile(`^(\S+)`) // 行首第一段是客户端 IP
uaRE = regexp.MustCompile(`"([^"]*)"\s*$`) // 行尾最后一个引号串是 User-Agent(nginx combined 格式)
baiduRE = regexp.MustCompile(`(?i)baiduspider`)
client = &http.Client{Timeout: 3 * time.Second}
gate = &rateGate{gap: 1100 * time.Millisecond} // 免费版 60 次/分钟,留点余量
cacheMu sync.Mutex
verdictC = map[string]*verdict{}
)
type claim struct {
count int
}
type verdict struct {
IP string
Baidu bool
Reason string
ISP string
Country string
Prov string
City string
}
type rateGate struct {
mu sync.Mutex
next time.Time
gap time.Duration
}
func (g *rateGate) wait(ctx context.Context) error {
g.mu.Lock()
now := time.Now()
if d := g.next.Sub(now); d > 0 {
g.next = g.next.Add(g.gap)
g.mu.Unlock()
select {
case <-time.After(d):
return nil
case <-ctx.Done():
return ctx.Err()
}
}
g.next = now.Add(g.gap)
g.mu.Unlock()
return nil
}
// 第 3 步:查 IP 归属地(旁证用,失败不影响主判定)
func lookupGeo(ctx context.Context, ip string) (isp, country, prov, city string) {
if err := gate.wait(ctx); err != nil {
return
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, geoAPI+url.QueryEscape(ip), nil)
if err != nil {
return
}
req.Header.Set("User-Agent", ua)
req.Header.Set("Accept", "application/json")
resp, err := client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return // 403(缺 UA)/ 429(限速)都在这里被忽略
}
var payload struct {
Ret int `json:"ret"`
Data *struct {
CountryCode string `json:"country_code"`
Country string `json:"country"`
Prov string `json:"prov"`
City string `json:"city"`
ISP string `json:"isp"`
} `json:"data"`
}
// 非法 IP 时接口返回的 data 是空数组,这里会解析报错,直接当失败
if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil || payload.Ret != 200 || payload.Data == nil {
return
}
return payload.Data.ISP, payload.Data.Country, payload.Data.Prov, payload.Data.City
}
func verify(ctx context.Context, ip string) *verdict {
cacheMu.Lock()
if v, ok := verdictC[ip]; ok {
cacheMu.Unlock()
return v
}
cacheMu.Unlock()
v := &verdict{IP: ip}
// 第 2 步之一:反向解析,PTR 必须落在 *.baidu.com / *.baidu.jp
rctx, rcancel := context.WithTimeout(ctx, 2*time.Second)
names, err := net.DefaultResolver.LookupAddr(rctx, ip)
rcancel()
host := ""
if err == nil && len(names) > 0 {
host = strings.TrimSuffix(strings.ToLower(names[0]), ".")
}
switch {
case host == "":
v.Reason = "ptr_missing"
case !strings.HasSuffix(host, ".baidu.com") && !strings.HasSuffix(host, ".baidu.jp"):
v.Reason = "ptr_not_baidu:" + host
default:
// 第 2 步之二:正向解析回去,必须能回到原 IP(防 PTR 伪造)
fctx, fcancel := context.WithTimeout(ctx, 2*time.Second)
addrs, ferr := net.DefaultResolver.LookupHost(fctx, host)
fcancel()
if ferr != nil || !contains(addrs, ip) {
v.Reason = "forward_mismatch:" + host
} else {
v.Baidu = true
v.Reason = "verified:" + host
}
}
v.ISP, v.Country, v.Prov, v.City = lookupGeo(ctx, ip)
cacheMu.Lock()
verdictC[ip] = v
cacheMu.Unlock()
return v
}
func contains(list []string, want string) bool {
for _, s := range list {
if s == want {
return true
}
}
return false
}
func main() {
if len(os.Args) < 2 {
fmt.Fprintln(os.Stderr, "用法: go run main.go <access.log>")
os.Exit(1)
}
f, err := os.Open(os.Args[1])
if err != nil {
fmt.Fprintln(os.Stderr, "打开日志失败:", err)
os.Exit(1)
}
defer f.Close()
claims := map[string]*claim{}
total, claimed := 0, 0
sc := bufio.NewScanner(f)
sc.Buffer(make([]byte, 1024*1024), 1024*1024)
for sc.Scan() {
total++
ipm := ipRE.FindStringSubmatch(sc.Text())
uam := uaRE.FindStringSubmatch(sc.Text())
if ipm == nil || uam == nil || !baiduRE.MatchString(uam[1]) {
continue
}
claimed++
ip := ipm[1]
c := claims[ip]
if c == nil {
c = &claim{}
claims[ip] = c
}
c.count++
}
ctx := context.Background()
type row struct {
IP string
Hit int
V *verdict
}
rows := make([]row, 0, len(claims))
var mu sync.Mutex
sem := make(chan struct{}, 4) // 并发 4:DNS 反查别打太猛,接口本身有限速
var wg sync.WaitGroup
for ip, c := range claims {
wg.Add(1)
sem <- struct{}{}
go func(ip string, c *claim) {
defer wg.Done()
defer func() { <-sem }()
v := verify(ctx, ip)
mu.Lock()
rows = append(rows, row{IP: ip, Hit: c.count, V: v})
mu.Unlock()
}(ip, c)
}
wg.Wait()
sort.Slice(rows, func(i, j int) bool { return rows[i].Hit > rows[j].Hit })
verifiedHits, fakeHits := 0, 0
fakeByISP := map[string]int{}
for _, r := range rows {
if r.V.Baidu {
verifiedHits += r.Hit
} else {
fakeHits += r.Hit
key := r.V.Country + " " + r.V.Prov + " " + r.V.City + " / " + r.V.ISP
fakeByISP[strings.TrimSpace(key)] += r.Hit
}
}
fmt.Printf("日志总行数:%d,其中自称百度蜘蛛的请求:%d 次(%d 个独立 IP)\n", total, claimed, len(rows))
fmt.Printf("验证通过:%d 次(真蜘蛛);疑似伪蜘蛛:%d 次\n\n", verifiedHits, fakeHits)
fmt.Println("伪蜘蛛 Top 10(按请求次数):")
shown := 0
for _, r := range rows {
if r.V.Baidu || shown >= 10 {
continue
}
fmt.Printf(" %-16s %6d 次 %s %s %s / %s [%s]\n", r.IP, r.Hit,
r.V.Country, r.V.Prov, r.V.City, r.V.ISP, r.V.Reason)
shown++
}
fmt.Println("\n伪蜘蛛来源机房 Top 5:")
type kv struct {
K string
V int
}
list := make([]kv, 0, len(fakeByISP))
for k, v := range fakeByISP {
list = append(list, kv{k, v})
}
sort.Slice(list, func(i, j int) bool { return list[i].V > list[j].V })
for i, e := range list {
if i >= 5 {
break
}
fmt.Printf(" %6d 次 %s\n", e.V, e.K)
}
}跑起来大概长这样(下面是一份 9 行的玩具日志的真实输出):
text
日志总行数:9,其中自称百度蜘蛛的请求:8 次(5 个独立 IP)
验证通过:3 次(真蜘蛛);疑似伪蜘蛛:5 次
伪蜘蛛 Top 10(按请求次数):
103.235.46.96 3 次 中国 香港 香港 / 百度 [ptr_missing]
8.8.8.8 1 次 美国 / Google Cloud [ptr_not_baidu:dns.google]
1.1.1.1 1 次 澳大利亚 / Cloudflare [ptr_not_baidu:one.one.one.one]
伪蜘蛛来源机房 Top 5:
3 次 中国 香港 香港 / 百度
1 次 美国 / Google Cloud
1 次 澳大利亚 / Cloudflare注意报告里第一条:103.235.46.96 的归属地明确写着"百度",但它没有 baiduspider- 开头的反向域名——它是百度自家网站服务器的网段,不是抓取用的蜘蛛 IP。归属地像百度,不等于它就是蜘蛛,这条结果本身就是"归属地只能做旁证"的最好例子。
几个实现上的取舍:
- 解析按 nginx 默认的 combined 格式:行首第一段是 IP,行尾最后一个引号串是 UA。 如果你的日志格式改过(比如把 UA 放中间、或者用了 JSON 日志),改这两个正则就行——之所以不写一个"全字段"大正则,是因为 UA 字符串里本身可能带引号,匹配到最后一个引号串反而最稳。
- 只对"自称是蜘蛛"的请求做校验。 反查 DNS 有延迟(几十到几百毫秒),接口还有限速,把全部流量都过一遍不现实。正常情况下蜘蛛请求占日志的百分之几,成本完全可以接受。
- 按 IP 缓存结果。 日志里同一个 IP 会重复出现很多次,验证过一次就记下来,整体耗时基本等于"独立 IP 数 × 单次验证时间"。上面的玩具日志只有 5 个独立 IP,秒级跑完;137 个独立 IP 的站点,按 1.1 秒一次的真实查询节奏,约两分半钟。
- PTR 失败和 PTR 不属于百度要分开记录。 家用宽带、云主机的大量 IP 根本没有 PTR 记录(
ptr_missing),和"有 PTR 但不是百度的"(ptr_not_baidu:xxx)性质不同:前者包含真蜘蛛之外的正常爬虫,后者更接近刻意伪造。分成两类再看,判断会清楚很多。 - 并发和限速都要有。 DNS 反查并发太高会被本地解析器限流,接口请求太快会吃
429,所以代码里并发开 4、真实请求之间隔 1.1 秒——这个节奏对一份百万行的日志也够用。
四、验证结果怎么用
真蜘蛛放行,伪蜘蛛按普通访客对待。 最常见的错误做法是看到一个 IP 行为异常就直接封段,结果把真蜘蛛也封了。正确姿势是把验证结果接到限流层:伪蜘蛛走普通访客的频控(比如 20 次/分钟),验证通过的真蜘蛛单独放行并降低限流阈值——毕竟它们抓得越勤,收录越快。
伪蜘蛛的归属地分布是封禁策略的输入。 如果 3000 次伪蜘蛛请求里有 1400 次来自同一个机房,那就不是"封几个 IP"的问题,是那个网段整体可疑。可以按"国家 + ISP"做维度化的限流规则,比逐 IP 维护黑名单省事得多。
别把归属地当判据。 归属地库也有漂移和滞后,百度自己还会用一些看起来不像百度机房的出口。所以最终判定只认双向 DNS,归属地只用来做分布统计和旁证——这一点和我之前那篇讲反爬的文章是同一个道理:IP 特征适合做粗筛和降级,不适合做单向判决。
顺手做一件小事:把每天的验证结果落成一行数字(真蜘蛛次数、伪蜘蛛次数、伪蜘蛛占蜘蛛请求的比例)。哪天这个比例从 5% 跳到 60%,说明有人开始大规模扫你的站了,比看访问总量更早发现问题。
总结
判断"百度蜘蛛"真伪,官方给的答案是双向 DNS 解析认证:反查 IP 要落在 baidu.com/baidu.jp,再正向解析回到同一个 IP。 写成一个 Go 小工具,配上 IP 归属地做旁证和机房聚合,就能把日志里真真假假的蜘蛛分开——真蜘蛛放行、伪蜘蛛限流、伪蜘蛛的窝一览无余。
归属地查询用的是 https://ip9.com.cn/get?ip=<IP>,返回国家、省市、运营商等字段,免费版 60 次/分钟/IP,IPv4 和 IPv6 都支持;要更细的机房判断(ip_type 区分 IDC/家庭宽带)和 ASN,用 VIP 版。计费与额度以官网 https://www.ip9.com.cn 为准。