Skip to content

公司网络 IP 归属地全显示总部?用 Go 写个中间件把员工真实城市找回来 ​

去年冬天一家连锁餐饮的技术负责人给我看了一张截图:门店点餐屏上,一碗牛肉面标价 32 元,而这家店在合肥,当地定价是 26 元。后台查了半天,价格配置没错,是「城市」这个变量取错了——系统按 IP 判城市,判出来是上海。

原因不复杂。他们一年前上了 SD-WAN,把全国 300 多家门店的流量统一收到上海机房出网,省了专线钱,也统一了安全策略。代价是所有门店的请求在应用看来都来自上海那一个出口 IP 段。按 IP 做的城市判断,从那天起就全废了:菜单价、门店库存、区域活动、甚至外卖配送范围,全按上海算。

这不是个案。任何做过「总部集中出网」的公司都会撞上:你把网络拓扑收拢了,IP 就不再代表用户在哪儿。 这篇讲清楚三件事:为什么 IP 会骗你、哪些场景还救得回来、以及怎么用 Go 写一个中间件把「真实城市」这件事重新做对。

一、先分清三个「地」 ​

大部分人把「IP 归属地」当成一个东西,其实至少有三个:

概念含义谁决定
出口地这个请求是从哪个网络节点出去的你的网络架构
接入地用户实际连在哪个网络(Wi-Fi、基站、宽带)用户的物理位置
归属地账号注册地、收货地、门店所在地业务数据

IP 归属地只能回答第一个。正常家用宽带里三者高度重合,所以大家默认它可靠;一旦公司把出口收拢,第一个就和第二个彻底脱钩,而且没有任何技术手段能从 IP 层把它们重新对上——运营商、CDN、任何 IP 库都做不到,因为信息在 NAT 那一刻就丢了。

顺便说一句,这也是很多人问「为什么我查自己 IP 显示别的城市」的原因之一,另一个常见原因是运营商级 NAT(CGNAT),机制不同但后果一样:你看到的出口不是你的位置。

二、企业侧的五种「抹平」方式 ​

按我见过的案例排一下,从轻到重:

  1. 总部统一 NAT 出网。 分公司、门店走专线或 VPN 回总部,出口是总部公网 IP。IP 城市 = 总部城市,误差几百到几千公里。
  2. SD-WAN 集中出网。 和上面一样,只是链路更便宜、策略更统一,覆盖门店更多。
  3. 云桌面 / VDI。 员工在本地操作,浏览器实际跑在机房虚拟机里,出口是机房 IP。跨省办公时 IP 城市错得离谱。
  4. 零信任网关(ZTNA)。 流量先到厂商的云 POP,再回源到你的应用。出口 IP 是 POP 的地址,可能连省都不对。
  5. 移动办公 VPN。 员工出差连公司 VPN,出口回到总部或最近节点。

这五种里,1、2 还有救——如果你在应用层之前保留了真实来源(反向代理写 X-Forwarded-For、负载均衡透传、或者终端自己上报);3、4、5 基本没救,因为客户端和你的服务之间隔了一整层别人的网络,你能拿到的只有「最后一跳」。

判断方法很简单:在应用里打印一次 RemoteAddr 和整条 X-Forwarded-For,再和用户实际所在地对一下。如果链上只剩一个总部 IP,那就是 1、2;如果链上是云厂商的地址段,那就是 4。

三、取真实 IP 的规则,很多人写错了 ​

X-Forwarded-For 是客户端可以随便写的头。所以正确做法不是「取第一个」,而是:

只有当直连来源是可信代理时,才看 XFF;然后从右往左剥,剥掉所有可信代理,第一个不可信的地址才是客户端。

为什么从右往左?因为每经过一个代理,它会在链尾追加自己的上游地址。最左边是客户端能伪造的,最右边是离你最近的、可信度最高的。

一个典型错误是 strings.Split(xff, ",")[0]——攻击者发一个 X-Forwarded-For: 1.2.3.4 就能把自己伪装成任意城市,所有地域风控瞬间失效。这个坑我在《X-Forwarded-For 能伪造吗》里拆过,这里不重复。

还有两个容易漏的点:

  • 内网地址要当可信段处理。 10.0.0.0/8、192.168.0.0/16、100.64.0.0/10(CGNAT 段)出现在链上,说明中间还有一层 NAT,不是客户端。
  • IPv6 要单独处理。 Go 的 RemoteAddr 带端口且是 [::1]:port 格式,net.SplitHostPort 能处理,但自己切字符串很容易把冒号切坏。另外 IPv6 地址在 XFF 里可能带方括号和 zone,net.ParseIP 解析不了带括号的,得先剥。

四、Go 实现 ​

一个文件,只用标准库。核心是三个函数:RealIP 负责取地址,Resolver 负责带缓存和并发合并的查询,Decide 负责「终端自报 > IP」的优先级和漂移检测。

go
// egress-city —— 企业统一出口场景下的访客城市判定中间件
package main

import (
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"net/url"
	"strings"
	"sync"
	"time"
)

type place struct {
	Country string
	Prov    string
	City    string
	ISP     string
}

type cacheEntry struct {
	p   place
	err error
	exp time.Time
}

type call struct {
	done chan struct{}
	p    place
	err  error
}

// Resolver 带 TTL 缓存与请求合并的归属地查询器
type Resolver struct {
	BaseURL string
	TTL     time.Duration
	FailTTL time.Duration
	Client  *http.Client

	mu     sync.Mutex
	cache  map[string]cacheEntry
	flight map[string]*call
}

func NewResolver() *Resolver {
	return &Resolver{
		BaseURL: "https://ip9.com.cn/get",
		TTL:     6 * time.Hour,
		FailTTL: time.Minute,
		Client:  &http.Client{Timeout: 800 * time.Millisecond},
		cache:   make(map[string]cacheEntry),
		flight:  make(map[string]*call),
	}
}

type apiResp struct {
	Ret  int `json:"ret"`
	Data struct {
		IP      string `json:"ip"`
		Country string `json:"country"`
		Prov    string `json:"prov"`
		City    string `json:"city"`
		ISP     string `json:"isp"`
		LongIP  int64  `json:"long_ip"`
	} `json:"data"`
}

func (r *Resolver) fetch(ip string) (place, error) {
	req, err := http.NewRequest(http.MethodGet, r.BaseURL+"?ip="+url.QueryEscape(ip), nil)
	if err != nil {
		return place{}, err
	}
	req.Header.Set("User-Agent", "egress-city/1.0")
	resp, err := r.Client.Do(req)
	if err != nil {
		return place{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return place{}, fmt.Errorf("http %d", resp.StatusCode)
	}
	var out apiResp
	if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<16)).Decode(&out); err != nil {
		return place{}, err
	}
	if out.Ret != 200 {
		return place{}, fmt.Errorf("api ret=%d", out.Ret)
	}
	d := out.Data
	return place{Country: d.Country, Prov: d.Prov, City: d.City, ISP: d.ISP}, nil
}

// Lookup 返回城市信息。err 非空表示这次没查到(网络/限速/非法 IP);
// err 为空但 City 为空,表示查到了,但该 IP 没有城市级数据(境外或保留段)。
func (r *Resolver) Lookup(ip string) (place, error) {
	now := time.Now()

	r.mu.Lock()
	if e, ok := r.cache[ip]; ok && now.Before(e.exp) {
		r.mu.Unlock()
		return e.p, e.err
	}
	if c, ok := r.flight[ip]; ok { // 同一个 IP 并发只打一次接口
		r.mu.Unlock()
		<-c.done
		return c.p, c.err
	}
	c := &call{done: make(chan struct{})}
	r.flight[ip] = c
	r.mu.Unlock()

	p, err := r.fetch(ip)

	r.mu.Lock()
	delete(r.flight, ip)
	exp := now.Add(r.TTL)
	if err != nil {
		exp = now.Add(r.FailTTL) // 失败短缓存,别把一次抖动钉成 6 小时
	}
	r.cache[ip] = cacheEntry{p: p, err: err, exp: exp}
	r.mu.Unlock()

	c.p, c.err = p, err
	close(c.done)
	return p, err
}

func isTrusted(ip net.IP, trusted []*net.IPNet) bool {
	if ip == nil {
		return false
	}
	for _, n := range trusted {
		if n.Contains(ip) {
			return true
		}
	}
	return false
}

// RealIP 从右往左剥离可信代理,返回第一个不可信地址。
// 直连来源不可信时,X-Forwarded-For 一律忽略(那是客户端能随便写的)。
func RealIP(r *http.Request, trusted []*net.IPNet) string {
	remote := r.RemoteAddr
	if host, _, err := net.SplitHostPort(remote); err == nil {
		remote = host
	}
	if !isTrusted(net.ParseIP(remote), trusted) {
		return remote
	}
	parts := strings.Split(r.Header.Get("X-Forwarded-For"), ",")
	for i := len(parts) - 1; i >= 0; i-- {
		ip := net.ParseIP(strings.TrimSpace(parts[i]))
		if ip == nil {
			continue
		}
		if !isTrusted(ip, trusted) {
			return ip.String()
		}
	}
	return remote
}

// Decision 是最终用于业务的城市判定结果
type Decision struct {
	IP       string `json:"ip"`
	IPCity   string `json:"ip_city"`
	TermCity string `json:"terminal_city"` // 门店终端自报(带签名,只信这个)
	City     string `json:"city"`
	Source   string `json:"source"` // terminal / ip / none
	Drift    bool   `json:"drift"`  // 终端自报与 IP 城市不一致
	Note     string `json:"note,omitempty"`
}

// Decide 的优先级:带签名的终端自报 > IP 城市 > 空(挂兜底)
func Decide(r *http.Request, res *Resolver, trusted []*net.IPNet) Decision {
	d := Decision{}
	d.IP = RealIP(r, trusted)

	// 只有门店收银终端(走双向 TLS 或带 HMAC 签名)才有权自报城市
	if r.Header.Get("X-Terminal-Sig") != "" {
		d.TermCity = strings.TrimSpace(r.Header.Get("X-Terminal-City"))
	}

	if p, err := res.Lookup(d.IP); err == nil {
		d.IPCity = p.City
	} else {
		d.Note = "ip_lookup_failed"
	}

	switch {
	case d.TermCity != "":
		d.City, d.Source = d.TermCity, "terminal"
		d.Drift = d.IPCity != "" && d.IPCity != d.TermCity
	case d.IPCity != "":
		d.City, d.Source = d.IPCity, "ip"
	default:
		d.City, d.Source = "", "none"
	}
	return d
}

func mustCIDR(s string) *net.IPNet {
	_, n, err := net.ParseCIDR(s)
	if err != nil {
		panic(err)
	}
	return n
}

func main() {
	one := flag.String("ip", "", "只查一个 IP 然后退出")
	addr := flag.String("addr", ":8089", "监听地址")
	flag.Parse()

	res := NewResolver()
	// 可信代理链:本机回环 + 内网段 + CGNAT 段(总部 NAT 就在这一层)
	trusted := []*net.IPNet{
		mustCIDR("127.0.0.0/8"), mustCIDR("10.0.0.0/8"),
		mustCIDR("172.16.0.0/12"), mustCIDR("192.168.0.0/16"),
		mustCIDR("100.64.0.0/10"),
	}

	if *one != "" {
		p, err := res.Lookup(*one)
		if err != nil {
			log.Fatalf("查询失败: %v", err)
		}
		fmt.Printf("%s -> %s %s %s (%s)\n", *one, p.Country, p.Prov, p.City, p.ISP)
		return
	}

	http.HandleFunc("/where", func(w http.ResponseWriter, r *http.Request) {
		d := Decide(r, res, trusted)
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		if d.Drift {
			log.Printf("DRIFT terminal=%s ip=%s ip_city=%s", d.TermCity, d.IP, d.IPCity)
		}
		json.NewEncoder(w).Encode(d)
	})
	log.Printf("listen %s", *addr)
	if err := http.ListenAndServe(*addr, nil); err != nil && !errors.Is(err, http.ErrServerClosed) {
		log.Fatal(err)
	}
}

go build 之后可以直接当命令行工具用,也可以起服务:

bash
./egresscity -ip 223.5.5.5
# 223.5.5.5 -> 中国 浙江 杭州 (AliDNS/DoH/DoT/阿里云)

./egresscity -addr :8089

服务起来之后,拿几个请求打一下,能明显看出问题在哪:

# 1. 门店终端带签名上报「合肥」,网络出口是北京机房
XFF: 219.141.136.10  +  X-Terminal-Sig  +  X-Terminal-City: 合肥
{"ip":"219.141.136.10","ip_city":"北京","terminal_city":"合肥",
 "city":"合肥","source":"terminal","drift":true}
日志: DRIFT terminal=合肥 ip=219.141.136.10 ip_city=北京

# 2. 同一张单子,只有 IP
{"ip":"219.141.136.10","ip_city":"北京","terminal_city":"",
 "city":"北京","source":"ip","drift":false}

# 3. 老架构,走三级代理(客户端 → 门店专线 → 区域代理)
XFF: 61.139.2.69, 10.8.0.5
{"ip":"61.139.2.69","ip_city":"成都","city":"成都","source":"ip"}

# 4. 境外访客,无城市级数据
XFF: 8.8.8.8
{"ip":"8.8.8.8","ip_city":"","city":"","source":"none"}

第 2 行就是那家餐饮公司原来的样子:source: ip,城市北京,门店在合肥,错了九百多公里,而系统对此毫无察觉。第 4 行也是一个真实边界——境外 IP 通常只有国家,prov、city 是空串,代码里必须把「查不到城市」和「查询失败」分开处理,前者是数据边界,后者是故障,混在一起会让你的降级逻辑永远走错分支。

五、落地时的七个细节 ​

**1. 终端自报必须带签名。**上面代码里我加了 X-Terminal-Sig 这个前置条件,不是装饰。如果直接信任浏览器上来的 X-Client-City,等于把地域判断交给了用户,五秒钟就被改包。正确做法是收银终端和后台共享密钥做 HMAC,或者终端走双向 TLS,签名不对就当没有。

2. 门店号和城市是两件事。IP 只能给城市,门店要精确到店。所以生产环境的链路是:终端上报 store_id → 后台查门店档案拿城市 → 再和 IP 城市比对。IP 在这里的价值不是「定位」,而是校验:一个上报合肥的门店,IP 出口却是境外地址,这单就该进风控队列。

**3. 漂移日志比报表有用。**上面每次 drift 都打一行日志,跑一周你就能看到哪些门店的网络没走本地出口、哪些终端被搬走了、哪些是配置错误。这比对账早发现三个月。

**4. 城市判定要能降级。**优先级:终端签名 > 账号历史城市 > IP 城市 > 用户手选 > 全国默认。任何一环拿不到就往下掉,别抛异常——一个菜单价接口因为查不到城市报 500,是比错价更严重的事故。

**5. 缓存是刚需,不是优化。**门店出口 IP 全国就那几个,缓存命中率接近 100%;真实用户场景里,一个城市几万个 IP 也会被反复查询。TTL 我给的是 6 小时,因为 IP 段归属变化以月为单位。失败只缓存 1 分钟,这条别省。

6. 免费接口有频率限制。https://ip9.com.cn/get 免费版 60 次/分钟,收拢出口之后查询量本来就下来了(就那几个 IP),但公网 C 端用户还是会打满。策略是本地缓存 + 排队,别在请求链路上同步查;批量补历史数据要自己循环调单 IP 接口并限速。

**7. 出口收拢之后,区域策略要重做一遍。**很多公司上 SD-WAN 时只考虑了网络和安全,没人回头看业务侧有哪些「按 IP 判地域」的逻辑。清单大概是这几类:价格与库存、活动与券、内容与语言、风控与限流、日志统计、CDN 回源策略。上面那家餐饮公司后来做了一次全量排查,找出 11 处,其中 3 处会导致资损。

总结 ​

「公司网络 IP 归属地显示总部」不是 IP 库不准,是你的网络架构让 IP 不再携带位置信息。这时候再换更贵的 IP 库、买更高精度的数据,都是白花钱——信息在 NAT 那一刻就没了。

能做的只有两件:一是在网络层尽量把真实来源透传下来(反向代理写 XFF、负载均衡别覆盖、别在中间加一层自建 NAT);二是在应用层补一个可信的位置来源(终端签名上报、门店号、账号历史),把 IP 城市降级成校验信号而不是判定依据。

上面那个中间件就是第二件事的骨架:RealIP 保证取到的地址不是伪造的,Resolver 保证不把接口打爆,Decide 保证优先级和降级清楚。三块拼起来不到 200 行,够用在大多数 B 端系统里。

接口本身很简单,GET https://ip9.com.cn/get?ip=<ip>,免费版不注册、支持 IPv4/IPv6,返回 prov、city、isp、long_ip;查不到城市时字段是空串而不是报错,这个特性在企业出口场景里反而好用——空值就代表「这一层没信息」,别硬猜。需要区县或 ip_type(区分家庭、企业、机房)判断请求是不是从 IDC 出来的,那是 VIP 版能力,细节看 IP9 官网。