Skip to content

日志里的「百度蜘蛛」九成是假的?用 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 解析认证",两步:

  1. 反向解析(PTR):对访问 IP 做反向 DNS 解析,百度蜘蛛的主机名一定以 *.baidu.com 或 *.baidu.jp 结尾——注意还有个 .baidu.jp 的域名空间,只认 .baidu.com 会误判一部分真蜘蛛。格式长这样:baiduspider-220-181-108-151.crawl.baidu.com(主机名里嵌着 IP,用点分格式写的)。
  2. 正向解析:把反查到的这个主机名再做一次正向解析,必须能回到日志里的原始 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 为准。