图片代理网关服务

约 1981 字大约 7 分钟

Nest.js

2025-07-06

核心代码

image-gateway.controller.ts

import { Controller, Get, Post, Req, Res, Query, HttpException, HttpStatus } from '@nestjs/common';
import { AppService } from './image-gateway.service';
import { Request, Response } from 'express';
import { AppConfigService, IPWhitelistService } from '../ConfigService';

// 图片代理控制器
@Controller('image')
export class ImageProxyController {
  private readonly token = 'admin';

  constructor(
    private readonly appService: AppService,
    private readonly appConfigService: AppConfigService,
    private readonly ipWhitelistService: IPWhitelistService
  ) { }

  // 动态获取允许的域名列表
  private get allowedDomains(): string[] {
    return this.appConfigService.getAllowedDomains();
  }

  // IP 白名单列表
  // 动态获取 IP 白名单列表
  private get allowedIPs(): string[] {
    return this.ipWhitelistService.getAllowedIPs();
  }

  // 验证 IP 地址
  private validateIP(ip: string): boolean {
    if (!ip) {
      return false;
    }

    // 检查是否在白名单中
    return this.allowedIPs.some(allowedIP => {
      // 如果是通配符 *，允许所有 IP
      if (allowedIP === '*') {
        return true;
      }
      // 如果是 CIDR 格式（如 192.168.0.0/16）
      if (allowedIP.includes('/')) {
        return this.isIPInRange(ip, allowedIP);
      }
      // 直接 IP 匹配
      return ip === allowedIP;
    });
  }

  // 检查 IP 是否在指定范围内
  private isIPInRange(ip: string, cidr: string): boolean {
    try {
      const [range, bits] = cidr.split('/');
      const mask = ~((1 << (32 - parseInt(bits))) - 1);
      const ipLong = this.ipToLong(ip);
      const rangeLong = this.ipToLong(range);
      return (ipLong & mask) === (rangeLong & mask);
    } catch (error) {
      return false;
    }
  }

  // IP 地址转长整型
  private ipToLong(ip: string): number {
    return ip.split('.').reduce((acc, octet) => (acc << 8) + parseInt(octet), 0) >>> 0;
  }

  // 获取真实 IP 地址
  private getRealIP(req: Request): string {
    // 按优先级获取 IP
    return req.headers['x-forwarded-for'] as string ||
      req.headers['x-real-ip'] as string ||
      req.connection.remoteAddress ||
      req.socket.remoteAddress ||
      req.ip ||
      'unknown';
  }

  // 验证 Referer
  private validateReferer(referer: string): boolean {
    if (!referer) {
      return true; // 没有 Referer 允许访问
    }

    try {
      const url = new URL(referer);
      const host = url.hostname + (url.port ? `:${url.port}` : '');

      return this.allowedDomains.some(domain => {
        // 支持通配符匹配
        if (domain.startsWith('*.')) {
          const wildcardDomain = domain.slice(2);
          return host === wildcardDomain || host.endsWith('.' + wildcardDomain);
        }
        return host === domain;
      });
    } catch (error) {
      return false; // URL 解析失败，拒绝请求
    }
  }

  // 统一的验证函数
  private validateRequest(req: Request, res: Response, token?: string): void {
    // 1. 校验token
    if (token && token !== this.token) {
      this.setNoCacheHeaders(res);
      throw new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED);
    }

    // 2. 校验 IP 地址
    const realIP = this.getRealIP(req);
    if (!this.validateIP(realIP)) {
      this.setNoCacheHeaders(res);
      throw new HttpException('IP not allowed', HttpStatus.FORBIDDEN);
    }

    // 3. 校验 Referer
    const referer = req.headers.referer || req.headers.referrer;
    if (!this.validateReferer(referer as string)) {
      this.setNoCacheHeaders(res);
      throw new HttpException('Invalid Referer', HttpStatus.FORBIDDEN);
    }
  }

  // 设置不缓存响应头
  private setNoCacheHeaders(res: Response): void {
    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
    res.setHeader('Pragma', 'no-cache');
    res.setHeader('Expires', '0');
  }

  // 配置管理接口
  @Get('config/domains')
  async getCurrentDomains() {
    return {
      success: true,
      data: {
        allowedDomains: this.allowedDomains,
        timestamp: new Date().toISOString()
      }
    };
  }

  @Get('config/ips')
  async getCurrentIPs() {
    return {
      success: true,
      data: {
        allowedIPs: this.allowedIPs,
        timestamp: new Date().toISOString()
      }
    };
  }

  @Post('config/refresh')
  async refreshConfig() {
    try {
      // 清除缓存并重新加载所有配置
      await Promise.all([
        this.appConfigService.clearCacheAndReload(),
        this.ipWhitelistService.clearCacheAndReload()
      ]);

      return {
        success: true,
        message: '配置刷新成功',
        data: {
          allowedDomains: this.allowedDomains,
          allowedIPs: this.allowedIPs,
          timestamp: new Date().toISOString()
        }
      };
    } catch (error) {
      console.error('配置刷新失败:', error);
      return {
        success: false,
        message: '配置刷新失败，使用默认配置',
        data: {
          allowedDomains: this.allowedDomains,
          allowedIPs: this.allowedIPs,
          timestamp: new Date().toISOString()
        }
      };
    }
  }

  @Post('config/refresh/domains')
  async refreshDomainsConfig() {
    try {
      await this.appConfigService.clearCacheAndReload();
      return {
        success: true,
        message: '域名配置刷新成功',
        data: {
          allowedDomains: this.allowedDomains,
          timestamp: new Date().toISOString()
        }
      };
    } catch (error) {
      console.error('域名配置刷新失败:', error);
      return {
        success: false,
        message: '域名配置刷新失败，使用默认配置',
        data: {
          allowedDomains: this.allowedDomains,
          timestamp: new Date().toISOString()
        }
      };
    }
  }

  @Post('config/refresh/ips')
  async refreshIPsConfig() {
    try {
      await this.ipWhitelistService.clearCacheAndReload();
      return {
        success: true,
        message: 'IP白名单配置刷新成功',
        data: {
          allowedIPs: this.allowedIPs,
          timestamp: new Date().toISOString()
        }
      };
    } catch (error) {
      console.error('IP白名单配置刷新失败:', error);
      return {
        success: false,
        message: 'IP白名单配置刷新失败，使用默认配置',
        data: {
          allowedIPs: this.allowedIPs,
          timestamp: new Date().toISOString()
        }
      };
    }
  }

  // 匹配 image/后所有路径（包括多级目录和文件名）
  @Get('*path')
  async proxyImage(
    @Req() req: Request,
    @Res() res: Response,
    @Query('token') token: string
  ) {
    // 统一验证请求
    this.validateRequest(req, res, token);

    // 获取原始图片路径（去掉 /image/ 前缀）
    const imgPath = req.path.replace(/^\/image\//, '');

    // 代理图片
    return this.appService.proxyImage(imgPath, res);
  }

  // 也支持 POST 请求
  @Post('*path')
  async proxyImagePost(
    @Req() req: Request,
    @Res() res: Response,
    @Query('token') token: string
  ) {
    // 统一验证请求
    this.validateRequest(req, res, token);

    // 获取原始图片路径（去掉 /image/ 前缀）
    const imgPath = req.path.replace(/^\/image\//, '');

    // 代理图片
    return this.appService.proxyImage(imgPath, res);
  }
}

image-gateway.module.ts

import { Module } from '@nestjs/common';
import { ImageProxyController } from './image-gateway.controller';
import { AppService } from './image-gateway.service';
import { AppConfigService, IPWhitelistService } from '../ConfigService';

@Module({
  controllers: [ImageProxyController],
  providers: [AppService, AppConfigService, IPWhitelistService],
  exports: [AppService], // 导出服务，以便其他模块可以使用
})
export class ImageGatewayModule { }

image-gateway.service.ts

import { Injectable, Scope, HttpException, HttpStatus, ImATeapotException } from '@nestjs/common';
import axios from 'axios';
import { Response } from 'express';

@Injectable()
export class AppService {
  // 图片代理方法
  async proxyImage(imgPath: string, res: Response) {
    // 拼接原始图片地址
    const originUrl = `https://image.yumeng.icu/${imgPath}`;

    try {
      // 拉取图片内容
      const response = await axios.get(originUrl, {
        responseType: 'stream',
      });

      // 设置响应头
      res.setHeader('Content-Type', response.headers['content-type'] || 'image/jpeg');
      // 为图片设置适当的缓存策略，但确保验证失败不会被缓存
      res.setHeader('Cache-Control', 'public, max-age=3600, s-maxage=3600'); // 缓存1小时
      res.setHeader('Vary', 'Referer'); // 根据Referer变化缓存

      // 直接把图片流返回给前端
      response.data.pipe(res);
    } catch (err) {
      throw new HttpException('Image not found', HttpStatus.NOT_FOUND);
    }
  }
}

ConfigService.ts

import { Injectable, OnModuleInit } from '@nestjs/common';
import { createClient, SupabaseClient } from '@supabase/supabase-js';

@Injectable()
export class AppConfigService implements OnModuleInit {
    private supabase: SupabaseClient;
    private allowedDomains: string[] = [];

    constructor() {
        const supabaseUrl = process.env.SUPABASE_URL;
        const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;


        if (!supabaseUrl || !supabaseKey) {
            console.warn('Supabase 环境变量未配置，使用默认配置');
            this.allowedDomains = [
                'localhost:3000',
                'localhost:3001',
                'localhost:5000',
                'yumeng.icu',
                'www.yumeng.icu',
                'images.yumeng.icu'
            ];
            return;
        }

        this.supabase = createClient(supabaseUrl, supabaseKey);
    }

    async onModuleInit() {
        await this.loadAllowedDomains();
    }

    async loadAllowedDomains() {
        // 如果没有配置 Supabase，直接返回
        if (!this.supabase) {
            console.log('使用默认配置，跳过数据库加载');
            return;
        }

        try {
            const { data, error } = await this.supabase
                .from('app_config')
                .select('value')
                .eq('key', 'allowed_domains')
                .single(); // 查询结果必须只有一行

            if (error) {
                console.error('加载配置失败:', error);
                // 保持默认配置，不重置为空数组
                return;
            } else {
                try {
                    this.allowedDomains = JSON.parse(data.value);
                    console.log('加载允许域名:', this.allowedDomains);
                } catch (e) {
                    console.error('配置 JSON 解析失败:', e);
                    // 保持默认配置，不重置为空数组
                }
            }
        } catch (error) {
            console.error('Supabase 连接失败:', error);
            // 保持默认配置
        }
    }

    getAllowedDomains(): string[] {
        return this.allowedDomains;
    }

    // 你可以再加个定时刷新配置的方法，比如每5分钟自动更新
    // 清除缓存并重新加载配置
    async clearCacheAndReload(): Promise<void> {
        console.log('🧹 清除缓存并重新加载配置...');
        // 清空当前配置
        this.allowedDomains = [];
        // 重新加载
        await this.loadAllowedDomains();
    }
}


// ------------------------------------------------------------------

@Injectable()
export class IPWhitelistService implements OnModuleInit {
  private supabase: SupabaseClient;
  private allowedIPs: string[] = [];

  constructor() {
    const supabaseUrl = process.env.SUPABASE_URL;
    const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;

    if (!supabaseUrl || !supabaseKey) {
      console.warn('Supabase 环境变量未配置，使用默认IP白名单');
      this.allowedIPs = [
        '127.0.0.1',        // 本地回环
        '::1',              // IPv6 本地回环
        '192.168.1.100',    // 局域网 IP
        '192.168.220.1',    // 局域网 IP
        '10.0.0.0/8',       // 内网段
        '172.16.0.0/12',    // 内网段
        '192.168.0.0/16',   // 内网段
        '*'                 // 允许所有IP（开发环境）
      ];
      return;
    }

    this.supabase = createClient(supabaseUrl, supabaseKey);
  }

  async onModuleInit() {
    await this.loadAllowedIPs();
  }

  async loadAllowedIPs() {
    // 如果没有配置 Supabase，直接返回
    if (!this.supabase) {
      console.log('使用默认IP白名单，跳过数据库加载');
      return;
    }

    try {
      const { data, error } = await this.supabase
        .from('ip_whitelist')
        .select('ip')
        .eq('enabled', true);

      if (error) {
        console.error('加载 IP 白名单失败:', error);
        // 保持默认配置，不重置为空数组
        return;
      } else {
        this.allowedIPs = data.map(item => item.ip);
        console.log('加载允许 IP 列表:', this.allowedIPs);
      }
    } catch (error) {
      console.error('Supabase 连接失败:', error);
      // 保持默认配置
    }
  }

  getAllowedIPs(): string[] {
    return this.allowedIPs;
  }

  // 清除缓存并重新加载IP白名单配置
  async clearCacheAndReload(): Promise<void> {
    console.log('🧹 清除IP白名单缓存并重新加载配置...');
    // 清空当前配置
    this.allowedIPs = [];
    // 重新加载
    await this.loadAllowedIPs();
  }
}

SQL代码：

ip_whitelist

-- 1. 创建 IP 白名单配置表
create table if not exists public.ip_whitelist (
  id serial primary key,
  ip text not null,
  description text,
  enabled boolean default true,
  updated_at timestamp with time zone default now()
);

-- 2. 插入默认的白名单 IP，包括本地回环和内网段
insert into public.ip_whitelist (ip, description) values
  ('127.0.0.1', 'IPv4 本地回环'),
  ('::1', 'IPv6 本地回环'),
  ('192.168.1.100', '自定义局域网 IP'),
  ('192.168.220.1', '自定义局域网 IP'),
  ('10.0.0.0/8', 'Class A 私有网络'),
  ('172.16.0.0/12', 'Class B 私有网络'),
  ('192.168.0.0/16', 'Class C 私有网络'),
  ('*', '允许所有 IP');

-- 3. 授权认证用户（authenticated）查询该表
grant select on public.ip_whitelist to authenticated;

-- 4. 启用 RLS（行级权限控制）
alter table public.ip_whitelist enable row level security;

-- 5. 创建策略：允许所有认证用户读取（你后端可用 service_role 绕过）
create policy "authenticated can read ip whitelist"
  on public.ip_whitelist
  for select
  to authenticated
  using (true);

app_config

-- 创建配置表
create table if not exists public.app_config (
  id serial primary key,
  key text not null unique,
  value text not null,
  description text,
  updated_at timestamp with time zone default now()
);

-- 授权给认证用户读权限（authenticated 是 Supabase 默认认证用户角色）
grant select on public.app_config to authenticated;

-- 如果需要管理权限（写、更新、删除），可以单独授权给你管理的角色（假设是 "admin"）
-- grant insert, update, delete on public.app_config to admin;

-- 你也可以创建视图或者函数进一步控制权限，但以上是基本的权限配置

insert into public.app_config (key, value, description)
values (
  'allowed_domains',
  '["localhost:3000","localhost:3001","yumeng.icu","your-domain.com"]',
  '允许的域名列表'
);


select * from public.app_config where key = 'allowed_domains';