Appearance
公司网络 IP 归属地全显示总部?用 Go 写个中间件把员工真实城市找回来
去年冬天一家连锁餐饮的技术负责人给我看了一张截图:门店点餐屏上,一碗牛肉面标价 32 元,而这家店在合肥,当地定价是 26 元。后台查了半天,价格配置没错,是「城市」这个变量取错了——系统按 IP 判城市,判出来是上海。
原因不复杂。他们一年前上了 SD-WAN,把全国 300 多家门店的流量统一收到上海机房出网,省了专线钱,也统一了安全策略。代价是所有门店的请求在应用看来都来自上海那一个出口 IP 段。按 IP 做的城市判断,从那天起就全废了:菜单价、门店库存、区域活动、甚至外卖配送范围,全按上海算。
这不是个案。任何做过「总部集中出网」的公司都会撞上:你把网络拓扑收拢了,IP 就不再代表用户在哪儿。 这篇讲清楚三件事:为什么 IP 会骗你、哪些场景还救得回来、以及怎么用 Go 写一个中间件把「真实城市」这件事重新做对。
一、先分清三个「地」
大部分人把「IP 归属地」当成一个东西,其实至少有三个:
| 概念 | 含义 | 谁决定 |
|---|---|---|
| 出口地 | 这个请求是从哪个网络节点出去的 | 你的网络架构 |
| 接入地 | 用户实际连在哪个网络(Wi-Fi、基站、宽带) | 用户的物理位置 |
| 归属地 | 账号注册地、收货地、门店所在地 | 业务数据 |
IP 归属地只能回答第一个。正常家用宽带里三者高度重合,所以大家默认它可靠;一旦公司把出口收拢,第一个就和第二个彻底脱钩,而且没有任何技术手段能从 IP 层把它们重新对上——运营商、CDN、任何 IP 库都做不到,因为信息在 NAT 那一刻就丢了。
顺便说一句,这也是很多人问「为什么我查自己 IP 显示别的城市」的原因之一,另一个常见原因是运营商级 NAT(CGNAT),机制不同但后果一样:你看到的出口不是你的位置。
二、企业侧的五种「抹平」方式
按我见过的案例排一下,从轻到重:
- 总部统一 NAT 出网。 分公司、门店走专线或 VPN 回总部,出口是总部公网 IP。IP 城市 = 总部城市,误差几百到几千公里。
- SD-WAN 集中出网。 和上面一样,只是链路更便宜、策略更统一,覆盖门店更多。
- 云桌面 / VDI。 员工在本地操作,浏览器实际跑在机房虚拟机里,出口是机房 IP。跨省办公时 IP 城市错得离谱。
- 零信任网关(ZTNA)。 流量先到厂商的云 POP,再回源到你的应用。出口 IP 是 POP 的地址,可能连省都不对。
- 移动办公 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 官网。