frp增加IP限制

核心设计理念

传统frp安全方案的不足

  1. 静态配置文件管理白名单IP，修改需要重启服务

  2. 分布式环境下多节点配置同步困难

  3. 缺乏实时阻断恶意IP的能力

Redis作为动态白名单存储的优势

  1. 实时生效：IP规则变更无需重启frp服务

  2. 集中管理：多台frp服务器共享同一套白名单规则

  3. 高性能验证：Redis的极速查询能力支持高频率IP检查

  4. 灵活扩展：可与安全系统集成实现动态封禁

 

技术实现解析

在 frp/server/proxy/proxy.go 文件中的 handleUserTCPConnection 方法中，增加了对 Redis 动态白名单的校验逻辑，确保只有授权 IP 可访问代理服务。

示例代码如下（仅展示关键片段）：

func isIPAllowedV1(ctx context.Context, serverCfg *v1.ServerConfig, ip string) bool {
 
 
	xlog.FromContextSafe(ctx).Infof("Redis config: Addr=%s, Password=%s, DB=%d, EnableRedisIPWhitelist=%v",
    serverCfg.RedisAddr,
    serverCfg.RedisPassword,
    serverCfg.RedisDB,
    serverCfg.EnableRedisIPWhitelist,
)
	if !serverCfg.EnableRedisIPWhitelist {
		return true
	}

	

	rdb := redis.NewClient(&redis.Options{
		Addr:     serverCfg.RedisAddr,
		Password: serverCfg.RedisPassword,
		DB:       serverCfg.RedisDB,
	})

	xlog.FromContextSafe(ctx).Errorf("redis check isIPAllowed db %s",serverCfg.RedisDB)

	key := serverCfg.RedisWhitelistPrefix + ip
	exists, err := rdb.Exists(ctx, key).Result()
	if err != nil {
		xlog.FromContextSafe(ctx).Errorf("redis check error for key [%s]: %v", key, err)
		return false
	}
	return exists == 1
}



// HandleUserTCPConnection is used for incoming user TCP connections.
func (pxy *BaseProxy) handleUserTCPConnection(userConn net.Conn) {
	xl := xlog.FromContextSafe(pxy.Context())
	defer userConn.Close()

	// 添加白名单验证
	remoteIP, _, errx := net.SplitHostPort(userConn.RemoteAddr().String())
	if errx != nil {
		xl.Warnf("invalid remote address: %v", errx)
		return
	}

	//xl.Warnf("IP [%s] is not in whitelist, connection begin", remoteIP)

	if !isIPAllowedV1(pxy.ctx, pxy.serverCfg, remoteIP) {

	//if !isIPAllowed(pxy.ctx, &pxy.serverCfg.ServerCommon, remoteIP) {
		xl.Warnf("IP [%s] is not in whitelist, connection rejected", remoteIP)
		return
	}
	 
		xl.Warnf("IP [%s] isIPAllowed  ", remoteIP)
	 

  // 后续代理连接逻辑

 

WEB 服务端修改

  1. 前端使用VUE3，增加对应的菜单和组件

  2. 前端代码需要发到到目录assets\frps\static

  3. 服务端增加接口，文件路径 server\dashboard_api.go

// /api/redis
func (svr *Service) apiRedisWhitelist(w http.ResponseWriter, r *http.Request) {
	res := GeneralResponse{Code: 200}
	defer func() {
		log.Infof("http response [%s]: code [%d]", r.URL.Path, res.Code)
		w.WriteHeader(res.Code)
		if len(res.Msg) > 0 {
			_, _ = w.Write([]byte(res.Msg))
		}
	}()

	log.Infof("http request: [%s]", r.URL.Path)

	// 初始化 Redis 客户端
	cfg := svr.cfg // 假设 svr.cfg 是你的 *ServerConfig
	rdb := redis.NewClient(&redis.Options{
		Addr:     cfg.RedisAddr,
		Password: cfg.RedisPassword,
		DB:       cfg.RedisDB,
	})
	ctx := context.Background()

	// 扫描符合前缀的所有键
	var cursor uint64
	var ipList []IPItem
	prefix := cfg.RedisWhitelistPrefix

	for {
		keys, newCursor, err := rdb.Scan(ctx, cursor, prefix+"*", 100).Result()
		if err != nil {
			res.Code = 500
			res.Msg = "redis scan error: " + err.Error()
			return
		}
		for _, key := range keys {
			// 提取 IP
			ip := strings.TrimPrefix(key, prefix)

			// 获取过期时间
			ttl, err := rdb.TTL(ctx, key).Result()
			if err != nil {
				continue
			}

			var expireAt string
			if ttl > 0 {
				expireAt = time.Now().Add(ttl).UTC().Format(time.RFC3339)
			} else if ttl == -1 {
				expireAt = "永不过期" // 永不过期
			} else {
				// 已过期或无效
				continue
			}

			ipList = append(ipList, IPItem{
				IP:       ip,
				ExpireAt: expireAt,
			})
		}
		if newCursor == 0 {
			break
		}
		cursor = newCursor
	}

	// 构建响应 JSON
	result := map[string]interface{}{
		"status":    "success",
		"whitelist": ipList,
	}

	buf, _ := json.Marshal(result)

	// 构造静态响应数据
	// svrResp := map[string]interface{}{
	// 	"status": "success",
	// 	"whitelist": []IPItem{
	// 		{
	// 			IP:       "192.168.1.100",
	// 			ExpireAt: "2025-06-01T12:00:00Z",
	// 		},
	// 		{
	// 			IP:       "10.0.0.0/24",
	// 			ExpireAt: "2025-06-10T00:00:00Z",
	// 		},
	// 		{
	// 			IP:       "127.0.0.1",
	// 			ExpireAt: "9999-12-31T23:59:59Z", // 永久有效
	// 		},
	// 	},
	// }

	//	buf, _ := json.Marshal(&svrResp)
	res.Msg = string(buf)
}

// /api/addip
func (svr *Service) apiRedisAddIp(w http.ResponseWriter, r *http.Request) {
	res := GeneralResponse{Code: 200}
	defer func() {
		log.Infof("http response [%s]: code [%d]", r.URL.Path, res.Code)
		w.WriteHeader(res.Code)
		if len(res.Msg) > 0 {
			_, _ = w.Write([]byte(res.Msg))
		}
	}()

	log.Infof("http request: [%s]", r.URL.Path)
	// 解析参数
	var req struct {
		IP         string `json:"ip"`
		ExpireDays int    `json:"expire_days"` // 0 表示永不过期
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		res.Code = 400
		res.Msg = "invalid json"
		return
	}
	if strings.TrimSpace(req.IP) == "" {
		res.Code = 400
		res.Msg = "ip is empty"
		return
	}

	// Redis
	cfg := svr.cfg
	rdb := redis.NewClient(&redis.Options{
		Addr:     cfg.RedisAddr,
		Password: cfg.RedisPassword,
		DB:       cfg.RedisDB,
	})
	ctx := context.Background()

	key := cfg.RedisWhitelistPrefix + req.IP
	var expiration time.Duration
	if req.ExpireDays <= 0 {
		expiration = 0 // 永久
	} else {
		expiration = time.Duration(req.ExpireDays) * 24 * time.Hour
	}

	err := rdb.Set(ctx, key, "", expiration).Err()
	if err != nil {
		res.Code = 500
		res.Msg = "redis set error: " + err.Error()
		return
	}

	res.Msg = `{"status":"ok"}`
}

// /api/delip
func (svr *Service) apiRedisDelIp(w http.ResponseWriter, r *http.Request) {
	res := GeneralResponse{Code: 200}
	defer func() {
		log.Infof("http response [%s]: code [%d]", r.URL.Path, res.Code)
		w.WriteHeader(res.Code)
		if len(res.Msg) > 0 {
			_, _ = w.Write([]byte(res.Msg))
		}
	}()

	var req struct {
		IP string `json:"ip"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.IP) == "" {
		res.Code = 400
		res.Msg = "invalid request"
		return
	}

	cfg := svr.cfg
	rdb := redis.NewClient(&redis.Options{
		Addr:     cfg.RedisAddr,
		Password: cfg.RedisPassword,
		DB:       cfg.RedisDB,
	})
	ctx := context.Background()

	key := cfg.RedisWhitelistPrefix + req.IP
	if err := rdb.Del(ctx, key).Err(); err != nil {
		res.Code = 500
		res.Msg = "delete redis key failed: " + err.Error()
		return
	}

	res.Msg = `{"status":"deleted"}`
}

　　

 

结语

frp-redis 项目通过结合 frp 的安全特性和 Redis 的灵活性，提供了一种相对安全的远程访问方案。开源这个项目是希望帮助更多开发者避免我遇到的这些问题，同时也欢迎社区贡献更好的安全实践。

在网络安全形势日益严峻的今天，作为开发者我们必须时刻保持警惕，采取纵深防御策略保护我们的服务和数据。frp-redis 只是这个过程中的一个小小尝试，但安全无小事，每一个环节都值得认真对待。

项目地址：https://github.com/wx37668827/frp-redis

From:https://www.cnblogs.com/xiaorong/p/18892424
未来帅哥
100+评论
captcha
    相关文章
    1. 异步日志分析：MongoDB与FastAPI的高效存储揭秘
      title: 异步日志分析：MongoDB与FastAPI的高效存储揭秘 date: 2025/05/22 17:04:56 updated: 2025/05/22 17:04:56 author: cmdragon excerpt: MongoDB与FastAPI集成构建日志分析系统，通过Moto
      Amd794
      2 周前
    3. 好端端的线程池，怎么就卡死了？
      写在前面 最近，我们的业务收到一项报障，线上某个业务模块偶尔会出现无法正常工作的情况。 经过多方排查，最终确认是线程池使用方式不合理导致的。鉴于线程池使用的普遍性和该类问题的隐秘性，本文将其中涉及的“坑”整理出来，与大家分享。 本文将尽可能淡化业务本身，着重介绍其中的技术问题。 场景说明 该业务链路
      xiaoxi666
      2 周前
    4. 鸿蒙仓颉开发语言实战教程：实现商城应用首页
      经过了几天的入门教程，我们终于进入到了仓颉开发语言的实战环节，今天分享的内容是实现商城应用的首页页面，效果图如下： 首页的内容包括导航栏、轮播图、商品分类和商品列表，我们下面逐一介绍。 导航栏 仓颉语言中是没有导航栏组件的，我们需要自己去开发。此处的导航栏也比较简单，只有一个搜索框，仓颉中的常见组件
      幽蓝计划
      2 周前
    5. 一个基于 C# 编写的事件驱动、具备专业水准的算法交易平台（量化交易引擎）
      前言 今天大姚给大家分享一个基于 C# 编写的事件驱动、采用模块化设计、具备专业水准的算法交易平台（量化交易引擎）：Lean。 项目介绍 Lean 是由 QuantConnect 提供的一个基于 C# 编写的事件驱动、采用模块化设计、具备专业水准的算法交易平台（量化交易引擎），该引擎是一个用于在多个
      追逐时光者
      2 周前
    6. .NET外挂系列：6. harmony中一些实用的反射工具包
      一：背景 1. 讲故事 本来想研究一下 IL编织和反向补丁的相关harmony知识，看了下其实这些东西对 .NET高级调试 没什么帮助，所以本篇就来说一些比较实用的反射工具包吧。 二：反射工具包 1. AccessTools AccessTools这个工具包用来简化反射操作，你如果看过 harmon
      一线码农
      2 周前
    8. 为何PostgreSQL没有聚集索引？解读两大数据库的设计差异
      为何PostgreSQL没有聚集索引？解读两大数据库的设计差异 前言 高效的数据检索是数据库管理的基石， PostgreSQL和SQL Server都能提供强大的数据访问方法以支持各种工作负载方面表现出色。然而，它们的实现方式存在显著差异，反映了各自独特的设计理念和使用场景。 在这篇文章中将介绍Po
      桦仔
      2 周前
    9. 分享一个异地组网软件，比扬云SD-WAN，在飞牛上使用教程
      上一篇文章https://www.cnblogs.com/yingjiuzou/p/18891935分享了比杨云SD-WAN的一些产品逻辑和收费逻辑，我个人觉得是很务实很诚恳的一家企业和产品。 从这期文章开始我开始分享干货教程，这是这个系列文章的第二篇，全系列文章目前规划包括以下内容： 比扬云SD-
      六度之外
      2 周前
    10. 聚类是如何度量数据间的“远近”的？
      在聚类分析中，距离度量是核心概念之一，它决定了数据点之间的相似性或差异性，从而影响聚类结果的质量。 选择合适的距离度量方法，就像为数据选择合适的“观察视角”，能够帮助我们发现隐藏的模式结构。 本文将详细介绍几种常用的聚类距离度量方法，包括它们的原理、代码实现，以及这些方法满足的基本性质。 1. 常用
      wang_yb
      2 周前