利用 Podman Pod 和 Java Sidecar 为存量 PHP 应用构建非侵入式运行时安全防护架构

架构设计

文章字数: 3.8k

阅读时长: 16 分

一个棘手的现实摆在面前：团队维护着一个关键的、基于 PHP 5.6 的遗留业务系统。它稳定运行多年，但代码库陈旧，缺乏现代安全实践，并且没有任何原始开发人员可供咨询。业务方要求在不进行大规模代码重构的前提下，紧急加固其安全防线，以应对日益增长的自动化扫描和注入攻击威胁。

直接修改 PHP 代码，风险极高，几乎等于重写。在入口处部署一套昂贵的商业 WAF (Web Application Firewall) 是一个选项，但通用 WAF 缺乏对我们特定业务逻辑的深度感知，误报率和漏报率始终是悬在头顶的达摩克利斯之剑。我们需要一个更贴近应用、更具控制力，同时又保持非侵入性的方案。

最终的技术决策是采用一种 Sidecar（边车）模式，在一个 Podman Pod 中将 PHP 应用容器与一个用 Java 编写的高性能安全代理容器并置。所有外部流量首先进入 Java 安全代理，经过严格的规则校验后，再被转发至同一 Pod 内的 PHP 应用。这种架构的核心优势在于，它利用了 Pod 共享网络命名空间（通过localhost进行通信）的超低延迟特性，实现了对遗留应用的“透明”防护。

架构权衡：为什么是 Podman + Java Sidecar？

在确定最终方案前，我们评估了两种主流的替代方案。

方案 A: 纯网络层防火墙/WAF

这是最容易想到的方案。在应用服务器的前端部署 Nginx 配合 ModSecurity 模块，或者直接采购云厂商的 WAF 服务。

优势:
- 与应用完全解耦，部署简单，不触碰任何应用代码。
- 成熟的解决方案，有大量的预设规则集可用。
劣势:
- 上下文缺失: WAF 工作在 OSI 模型的第 7 层，但它不理解应用的业务逻辑。例如，某个 API 端点接受包含 SQL 片段的 JSON 作为正常业务数据，这很容易被通用 WAF 误判为 SQL 注入。
- HTTPS 困境: 如果 TLS 在应用层终结，WAF 想要检测流量就必须参与 TLS 解密和再加密，这增加了配置复杂性和潜在的性能瓶颈。
- 成本与灵活性: 高质量的 WAF 服务通常价格不菲，而自定义规则的灵活性有限，响应新型攻击的速度也受限于供应商的更新周期。

方案 B: PHP 层面的代码注入或扩展

另一种思路是在 PHP 运行时层面进行干预，比如使用 auto_prepend_file 机制在每个脚本执行前加载一个安全检查钩子，或者编写一个自定义的 PHP C 扩展。

优势:
- 拥有最完整的应用上下文，可以访问请求参数、Session、甚至数据库连接前的最终 SQL 语句。
- 可以实现非常精细的访问控制和数据过滤。
劣势:
- 致命的侵入性: 这是我们最需要避免的。对于一个缺乏文档和测试覆盖的遗留系统，任何代码层面的改动都可能引发雪崩式的未知错误。
- 性能损耗: PHP 是解释性语言，在每次请求的生命周期中增加额外的脚本处理，尤其是在高并发下，对性能的影响不可小觑。
- 技术栈限制: 必须使用 PHP 来编写安全逻辑，这限制了我们使用更适合做高性能网络代理和并发处理的技术栈（如 Java/Go/Rust）。

最终选择：Podman Pod + Java Sidecar

该方案融合了前两者的优点，并规避了它们的主要缺点。

非侵入性: PHP 应用容器完全无需改动，它甚至不知道自己正被保护。它依然监听在自己的端口上，只不过流量来源从外部网络变成了 localhost。
高性能与技术栈自由: 我们选择 Java 和 Netty 来构建安全代理。Netty 是一个成熟的异步事件驱动的网络应用框架，非常适合构建高并发、低延迟的代理服务。Java 的 JIT 编译器和多线程能力，能确保 Sidecar 本身不会成为性能瓶颈。
高度定制化与上下文感知: 我们可以为这个 Java Sidecar 编写任何复杂的、针对特定业务场景的安全规则。例如，可以轻易实现一个“用户 A 绝不能访问属于用户 B 的资源 ID”这类业务层面的安全检查。
原子化部署与管理: Podman Pod 将应用及其安全组件打包成一个逻辑单元。它们的生命周期是绑定的，可以作为一个整体进行部署、启动、停止和扩展。这大大简化了运维的复杂性。

下面是这个架构的流量走向示意图。

graph TD
    subgraph "Podman Host"
        subgraph "Pod (Shared Network: localhost)"
            A[Java Security Sidecar
Listens on :8080] -->|If request is valid| B(PHP Application
Listens on :80)
        end
        C(External Traffic) -- maps to --> A
        B -- response --> A
        A -- response --> C
    end

核心实现概览

整个实现分为两个部分：一是定义和运行 Podman Pod，二是编写 Java 安全代理的核心代码。

1. 使用 Quadlet 定义 Podman Pod

为了以声明方式管理我们的 Pod，我们不直接使用 podman 命令行，而是采用 Podman 4.4 之后引入的 Quadlet。它允许我们用类似 systemd unit file 的语法来定义容器和 Pod，然后由 systemd 负责管理它们的生命周期。

创建一个名为 legacy-app.pod 的文件：

# /etc/containers/systemd/legacy-app.pod

[Unit]
Description=Pod for Legacy PHP Application with Security Sidecar
Requires=network-online.target
After=network-online.target

[Pod]
# 将主机的 8080 端口映射到 Pod 的 8080 端口
PublishPort=8080:8080

[Install]
WantedBy=multi-user.target

接着，为 Java Sidecar 创建一个 legacy-app-sidecar.container 文件：

# /etc/containers/systemd/legacy-app-sidecar.container

[Unit]
Description=Java Security Sidecar
# 声明此容器属于 legacy-app.pod
Pod=legacy-app.pod

[Container]
# 使用预先构建好的镜像
Image=docker.io/my-registry/java-security-sidecar:1.0.0
# Sidecar 监听在 8080 端口，接收外部流量
# 将 PHP 应用的目标地址通过环境变量传入
Environment=TARGET_HOST=localhost
Environment=TARGET_PORT=80
Environment=LOG_LEVEL=INFO
# 在 Pod 内命名此容器，方便服务发现
Name=security-sidecar

# 资源限制，这是生产环境中必须考虑的
CPUQuota=50%
MemoryLimit=512M

[Install]
# 确保它被 legacy-app.pod 拉起
RequiredBy=legacy-app.pod

最后是我们的 PHP 应用容器 legacy-app-main.container：

# /etc/containers/systemd/legacy-app-main.container

[Unit]
Description=Legacy PHP Application
Pod=legacy-app.pod

[Container]
# 使用官方的 php:5.6-apache 镜像，并挂载我们的应用代码
Image=docker.io/library/php:5.6-apache
Volume=/path/to/my/php/app:/var/www/html
# PHP 应用在 Pod 内部监听 80 端口，不对外暴露
# 只有 Sidecar 可以通过 localhost:80 访问它
Name=php-app

# 资源限制
CPUQuota=100%
MemoryLimit=1G

[Install]
RequiredBy=legacy-app.pod

配置完成后，只需运行 systemctl --user daemon-reload 和 systemctl --user start legacy-app.pod，Podman 就会自动创建 Pod 并拉起这两个容器。

2. Java 安全 Sidecar 核心代码

我们将使用 Netty 来构建这个代理。它的核心是一个 ChannelInboundHandler，它会拦截所有进入的请求，应用安全规则，然后决定是转发还是拒绝。

项目依赖 (pom.xml):

<dependencies>
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.99.Final</version>
    </dependency>
    <!-- For logging -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>2.0.9</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.4.11</version>
    </dependency>
</dependencies>

主启动类 SecuritySidecar.java:

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class SecuritySidecar {

    private static final Logger logger = LoggerFactory.getLogger(SecuritySidecar.class);
    static final int LOCAL_PORT = 8080;

    public static void main(String[] args) throws Exception {
        // 从环境变量获取目标 PHP 应用的地址和端口
        // 在真实项目中，这里应该有更健壮的配置管理
        String targetHost = System.getenv("TARGET_HOST");
        int targetPort = Integer.parseInt(System.getenv("TARGET_PORT"));

        if (targetHost == null || targetHost.isEmpty()) {
            logger.error("TARGET_HOST environment variable not set.");
            System.exit(1);
        }

        logger.info("Starting security sidecar proxy for target: {}:{}", targetHost, targetPort);

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                // ChannelInitializer 负责为每一个新的连接设置 pipeline
                .childHandler(new ProxyInitializer(targetHost, targetPort))
                .childOption(ChannelOption.AUTO_READ, false)
                .bind(LOCAL_PORT).sync().channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

通道初始化器 ProxyInitializer.java:

这个类的作用是为每个新建立的连接的 ChannelPipeline 添加处理器。

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;

public class ProxyInitializer extends ChannelInitializer<SocketChannel> {

    private final String remoteHost;
    private final int remotePort;

    public ProxyInitializer(String remoteHost, int remotePort) {
        this.remoteHost = remoteHost;
        this.remotePort = remotePort;
    }

    @Override
    public void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(
            // HTTP 编解码器，将字节流转换为 HTTP 对象
            new HttpServerCodec(),
            // 我们的核心安全处理和代理逻辑
            new SecurityProxyHandler(remoteHost, remotePort)
        );
    }
}

核心处理器 SecurityProxyHandler.java:

这是所有魔法发生的地方。它连接到后端的 PHP 应用，并在两者之间转发流量，同时插入我们的安全检查逻辑。

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.regex.Pattern;

public class SecurityProxyHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(SecurityProxyHandler.class);

    private final String remoteHost;
    private final int remotePort;

    // 后端连接的 Channel
    private Channel outboundChannel;
    
    // 简化的安全规则：检测常见的 SQL 注入模式
    private static final Pattern SQL_INJECTION_PATTERN = Pattern.compile(
        "'.*(--|;)|(\\%27|\\')\\s*(OR|or|AND|and)\\s*(\\%27|\\')\\w+(\\%27|\\')\\s*=\\s*(\\%27|\\')\\w+(\\%27|\\')",
        Pattern.CASE_INSENSITIVE
    );

    public SecurityProxyHandler(String remoteHost, int remotePort) {
        this.remoteHost = remoteHost;
        this.remotePort = remotePort;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        final Channel inboundChannel = ctx.channel();

        // 建立到后端 PHP 服务的连接
        Bootstrap b = new Bootstrap();
        b.group(inboundChannel.eventLoop())
            .channel(ctx.channel().getClass())
            // 为后端连接设置处理器
            .handler(new BackendProxyHandler(inboundChannel))
            .option(ChannelOption.AUTO_READ, false);
            
        ChannelFuture f = b.connect(remoteHost, remotePort);
        outboundChannel = f.channel();
        
        f.addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                // 连接成功，开始读取客户端请求
                inboundChannel.read();
            } else {
                // 连接失败，关闭客户端连接
                logger.error("Failed to connect to backend: {}:{}", remoteHost, remotePort, future.cause());
                inboundChannel.close();
            }
        });
    }

    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) {
        // 安全检查逻辑
        if (msg instanceof HttpRequest) {
            HttpRequest request = (HttpRequest) msg;
            
            // 1. SQL注入检测
            if (isSqlInjection(request.uri())) {
                logger.warn("SQL Injection attempt detected from {}. URI: {}", 
                    ctx.channel().remoteAddress(), request.uri());
                sendErrorResponse(ctx, HttpResponseStatus.FORBIDDEN);
                return; // 终止请求
            }
            
            // 2. 可以在这里添加更多规则，如XSS检测、路径遍历等...
            // 3. 甚至可以解析 body (如果是 FullHttpRequest) 来检查 POST 数据

            logger.info("Request passed security checks. Forwarding to backend.");
        }

        if (outboundChannel.isActive()) {
            // 将消息写入后端通道，并监听写入结果
            outboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {
                if (future.isSuccess()) {
                    // 写入成功，继续从客户端读取数据
                    ctx.channel().read();
                } else {
                    logger.error("Failed to write to backend channel.", future.cause());
                    future.channel().close();
                }
            });
        }
    }
    
    private boolean isSqlInjection(String uri) {
        // 这是一个非常基础的检测，生产环境需要更复杂的规则引擎
        return SQL_INJECTION_PATTERN.matcher(uri).find();
    }

    private void sendErrorResponse(ChannelHandlerContext ctx, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(
            HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer(status.toString().getBytes()));
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-t");
        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes());
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        if (outboundChannel != null) {
            closeOnFlush(outboundChannel);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        logger.error("Exception caught in SecurityProxyHandler", cause);
        closeOnFlush(ctx.channel());
    }

    static void closeOnFlush(Channel ch) {
        if (ch.isActive()) {
            ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        }
    }
}

// 这个 Handler 负责将后端服务器的响应写回给客户端
class BackendProxyHandler extends ChannelInboundHandlerAdapter {
    private final Channel inboundChannel;

    public BackendProxyHandler(Channel inboundChannel) {
        this.inboundChannel = inboundChannel;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.read();
    }

    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) {
        inboundChannel.writeAndFlush(msg).addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                ctx.channel().read();
            } else {
                future.channel().close();
            }
        });
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        SecurityProxyHandler.closeOnFlush(inboundChannel);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        SecurityProxyHandler.closeOnFlush(ctx.channel());
    }
}

这段代码实现了一个基础但功能完整的安全代理。在 SecurityProxyHandler 的 channelRead 方法中，我们嵌入了安全检查的核心逻辑。目前它只实现了一个简单的 SQL 注入检测，但在真实项目中，这里可以发展成一个复杂的、可配置的规则引擎。它可以解析 HTTP Body，检查文件上传，实施 IP 黑白名单，或者根据请求频率进行限流。

架构的扩展性与局限性

这个架构虽然优雅地解决了当前的问题，但它并非万能药。

可扩展路径:

动态规则引擎: 可以将安全规则外部化到配置文件（如 YAML 或 JSON），甚至是一个集中的配置中心（如 Nacos）。Java Sidecar 可以动态加载和热更新这些规则，无需重启应用。
可观测性集成: Sidecar 是一个绝佳的数据采集点。可以轻松地集成 Micrometer 来暴露 Prometheus 指标（如请求延迟、拒绝率、规则命中次数），并将结构化日志推送到 ELK 或 Loki，为安全审计和告警提供数据支持。
服务网格的雏形: 如果将这个模式推广到多个服务，并增加服务发现、负载均衡、熔断等功能，它实际上就演变成了服务网格（Service Mesh）中数据平面的基本思想。这个方案可以看作是迈向服务网格架构的一个务实的第一步。
响应内容检查: 当前的实现只检查了请求。可以扩展它来缓冲和检查从 PHP 应用返回的响应，防止数据泄露（如在错误信息中暴露堆栈跟踪或敏感信息）。

固有限制:

非万能安全层: 它本质上是一个“边界防护”方案。如果攻击者通过其他途径（例如，一个被攻陷的内部服务）绕过了 Sidecar 直接访问 PHP 应用，或者利用了 PHP 代码本身存在的、与输入无关的漏洞（如反序列化漏洞），这个防护层就会失效。
增加了运维复杂性: 虽然 Podman 简化了部署，但我们现在需要维护两个组件而非一个。Java Sidecar 的 JVM 调优、内存管理、日志监控都成了新的运维负担。
性能开销: 尽管 localhost 通信非常快，但一次请求/响应的完整路径上还是增加了一次网络转发和两次上下文切换。对于延迟极其敏感的应用，这微秒级的增加也需要被仔细评估。
TLS 处理: 当前方案假设 TLS 在更上游的负载均衡器或网关上被终结。如果需要 Sidecar 来处理 TLS，就需要引入证书管理、加密卸载等复杂性，这会显著增加 Sidecar 的资源消耗和配置难度。

这个架构的真正价值在于，它为保护那些“不可触碰”的遗留系统提供了一个现代化的、云原生的解决思路，在风险、成本和效果之间找到了一个精妙的平衡点。它不是终极解决方案，但却是在资源和时间限制下，一个极其有效的工程实践。

微服务 PHP 网络安全 Java Podman

使用 Terraform 与 Kubernetes 为 Android Relay 应用构建动态后端预览环境

2023-10-27 DevOps

Kubernetes Terraform Android 开发 Relay CI/CD 平台工程

GKE 驱动的计算机视觉特征工程平台：从图数据建模到 Redis 实时服务

2023-10-27 MLOps

Redis NoSQL GCP GKE Computer Vision Sass/SCSS