As the complexity of cyber security threats continues to increase, organizations express deep concern regarding Remote Code Execution (RCE) attacks, which can potentially take control of an entire system. In dynamic cloud and container-based environments, the attack surface expands, and the number of management points increases, making RCE vulnerability defense more challenging. Neglecting RCE vulnerabilities in a production environment is akin to a ticking time bomb, and the impact when a breach actually occurs is beyond imagination.
Scenario Introduction
A growing SaaS company was operating its services based on AWS cloud and Kubernetes clusters. To achieve rapid service expansion and agile development, the company actively adopted a cloud-native architecture, which significantly contributed to business growth. However, with increasing infrastructure complexity, the security team faced new challenges. Initially, efforts focused on simple DDoS prevention and Web Application Firewall (WAF) operation. As the service's importance grew and user data increased, it became urgent to establish a defense strategy against RCE, a more critical attack. The company's objective was to go beyond mere regulatory compliance to protect core assets from RCE attacks and ensure service continuity in an actual operational environment. Many organizations face similar challenges.
Challenges
The key challenges faced by the organization were as follows. Firstly, obtaining integrated visibility across cloud resources and Kubernetes clusters proved difficult. Existing security tools, managed by different teams, were fragmented, making it challenging to grasp the overall security posture at a glance. Secondly, the process of pre-identifying and patching potential RCE vulnerabilities was largely manual, leading to inefficiency and delays. Security review processes that could not keep pace with development speed inevitably resulted in technical debt. Thirdly, RCE attacks can penetrate through various vectors, revealing clear limitations in simple signature-based detection. Particularly in cases exploiting zero-day attacks or unknown vulnerabilities, existing security solutions could be rendered ineffective. A frequently overlooked aspect was that improper configurations could lead to serious security loopholes. Consequently, there were difficulties in promptly tracing the root cause and responding to RCE attacks when they occurred. Ultimately, the core requirement was to 'detect RCE threats in real-time, respond in an automated manner, and enhance the overall security posture of cloud and Kubernetes environments.'
Technology Selection Process
To address the challenges, several solution candidates were reviewed. The first option was to extend the functionalities of existing WAF and EDR solutions; however, this approach had limitations in fully encompassing the dynamic characteristics of cloud-native environments and the complexity of Kubernetes. EDR, in particular, primarily focused on endpoints, lacking in-depth management for container workload runtime security. The second option involved maximizing the use of basic security services provided by Cloud Service Providers (CSPs). While this offered a certain level of security, it imposed restrictions on scalability for multi-cloud environments or the application of custom detection rules. The last approach considered was a hybrid method, integrating a Cloud Native Application Protection Platform (CNAPP, which combines Cloud Security Posture Management (CSPM) and Container and Workload Protection (CWPP) functionalities) with advanced SIEM/SOAR solutions.
Real-time detection capabilities, automated response mechanisms, and flexible integration possibilities with existing infrastructure were established as core selection criteria. Considering these criteria comprehensively, the integration of `FRIIM CNAPP` and `Seekurity SIEM/SOAR` was determined to be the most suitable approach. `FRIIM CNAPP` detects misconfigurations in cloud environments and provides runtime protection for Kubernetes workloads, while `Seekurity SIEM/SOAR` centrally collects and analyzes all security events occurring in the cloud and containers, enabling real-time detection of RCE-related threats and automated responses. This approach was expected to effectively cover a broad attack surface and maximize operational efficiency.
Implementation Process
Strengthening Cloud Infrastructure Security and Minimizing RCE Attack Surface (Leveraging FRIIM CNAPP)
The initial step involved strengthening the foundational security posture of the cloud infrastructure. AWS IAM (Identity and Access Management) policies were configured with the principle of Least Privilege according to Zero Trust principles, and unnecessary public access was restricted. Particular caution was exercised regarding public access settings for AWS S3 buckets or RDS instances, as overlooking these settings in production could lead to severe issues such as data breaches or service tampering, potentially resulting in RCE vulnerabilities. To address this, `FRIIM CNAPP` was implemented to leverage its Cloud Security Posture Management (CSPM) capabilities across all AWS accounts. `FRIIM CNAPP` continuously monitors the security configurations of cloud resources in alignment with industry standards such as CIS Benchmarks, identifies potential misconfigurations, and provides immediate recommendations for improvement. Furthermore, Pod Security Standards (PSS) for Kubernetes clusters were strengthened, and Network Policies were meticulously configured to block unnecessary communication between pods. The importance of this configuration lies in its ability to minimize damage by preventing the spread of an RCE attack to other pods, even if one pod becomes compromised. Below is an example of a Kubernetes Network Policy.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-all-ingress
namespace: default
spec:
podSelector:
matchLabels:
app: my-app
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: frontend
ports:
- protocol: TCP
port: 80
egress:
- to:
- ipBlock:
cidr: 0.0.0.0/0
except:
- 10.0.0.0/8
ports:
- protocol: TCP
port: 443
The Network Policy above configures the my-app pod to allow Ingress traffic only from the frontend pod on port 80, and Egress traffic only to external port 443, excluding internal IP ranges. Modifying these values will alter inter-pod communication and external communication rules, making it crucial to define them precisely according to the application's requirements.
Establishing Real-time RCE Threat Detection and Response System (Seekurity SIEM/SOAR Integration)
For early detection of RCE attacks, all security-related logs originating from cloud services (e.g., AWS CloudTrail, VPC Flow Logs, GuardDuty) and Kubernetes (e.g., Audit Logs, Falco events) were centralized. `Seekurity SIEM` was utilized for this purpose to collect and normalize numerous log data. Specifically, custom detection rules were configured in `Seekurity SIEM` to identify events indicative of RCE attack patterns, such as abnormal process execution, shell command execution, and privilege escalation attempts. By reviewing logs, such anomalous behaviors can be identified. For instance, logs showing unexpected shell commands being executed from a web server process serve as a strong indicator of RCE.
For detected threats, automated response playbooks were established by integrating `Seekurity SOAR`. When suspicious RCE-related activities are detected, `Seekurity SOAR` automatically takes actions such as blocking the originating IP address or isolating and restarting suspected compromised containers. This is a critical factor in enabling rapid response to threats without manual intervention from the security team, thereby preventing the spread of damage. In the event of an actual incident, swift automated response plays a decisive role in maintaining service continuity.
Implementing Code and Image Static Analysis Pipeline
Security scanning tools were integrated into the CI/CD pipeline to prevent RCE vulnerabilities from the early stages of development. During the Docker image build phase, container image scanners such as Trivy were used to check for known vulnerabilities, and Static Application Security Testing (SAST) tools like SonarQube were utilized to analyze source code for potential RCE vulnerability patterns. This process is highly effective in reducing potential RCE attack vectors. Below is an example of a GitHub Actions workflow that adds a Trivy scanning step to the CI/CD pipeline.
name: Scan Docker Image for Vulnerabilities
on:
push:
branches:
- main
jobs:
build-and-scan:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Build Docker image
run: docker build -t my-app:latest .
- name: Run Trivy scan
uses: aquasecurity/trivy-action@master
with:
image-ref: 'my-app:latest'
format: 'table'
exit-code: '1'
severity: 'HIGH,CRITICAL'
This workflow builds a Docker image and then uses Trivy to scan the image for high-severity (HIGH, CRITICAL) vulnerabilities. By causing the build to fail based on scan results, it proactively prevents vulnerable images from being deployed to production environments. Tracing the root causes reveals that such preventative measures significantly contribute to reducing subsequent RCE attack attempts.
Results and Achievements
| Metric | Before Implementation | After Implementation |
|---|---|---|
| Number of Critical/High Security Alerts (Monthly Average) | Over 150 | Under 60 |
| Average Response Time for Suspected RCE Activities | Several hours | Several minutes |
| Need for Manual Security Team Intervention | High | Low |
| Overall Security Visibility | Low (Fragmented) | High (Integrated) |
Lessons Learned and Retrospective
During the project, several aspects differed from expectations. Initially, overly strict detection rules in `Seekurity SIEM` generated excessive false positive alerts, leading to increased fatigue for the security team. Tracing the root cause revealed that applying general rules without sufficient understanding of actual traffic patterns and normal application behavior in the production environment was the issue. To address this, continuous rule tuning was performed, alongside repeated simulation and analysis of new threat patterns using `KYRA AI Guardrail`. If this project were to be conducted again, a more thorough analysis of each service's 'normal' behavior would be undertaken from the initial stages, and detection rules would be progressively strengthened based on this understanding. An unexpected ancillary benefit was that the communication between the development and security teams became more active during the RCE defense strategy formulation process, elevating the organization's overall security awareness. This can be considered a very positive change from a long-term perspective.
Application Guide
For organizations intending to apply similar RCE defense strategies in cloud and Kubernetes environments, several recommendations are provided. Firstly, a fundamental understanding of cloud infrastructure and infrastructure management through Infrastructure as Code (IaC) must be a prerequisite. This forms the basis for consistent security policy application. Secondly, establishing a phased implementation roadmap is effective. Rather than applying to all systems at once, it is recommended to start with core services and gradually expand. For instance, the first phase could involve strengthening cloud security posture using `FRIIM CNAPP`, followed by establishing a log collection and detection system via `Seekurity SIEM` in the next phase, and finally enhancing automated responses with `Seekurity SOAR`. Documenting potential issues and solutions at each stage and accumulating knowledge is crucial. This approach ensures the stable application of the RCE defense system in the operational environment and secures service stability.
Related Article: Java Vulnerability Java4Shell (CVE-2026-114938) Targets and Patch - This article summarizes the affected targets, patching order, and temporary measures before patching for a Java vulnerability that allows unauthenticated remote code execution.







