
SOC Pulse — A One-Command SOC Dashboard for Your AWS Ubuntu EC2 Server
A walkthrough of SOC Pulse, an open-source command center that unifies supply-chain scanning, OS hardening, automated CVE patching, and SSL auditing into one live dashboard for AWS Ubuntu EC2 — built specifically to avoid the SSH lockouts that plague most hardening scripts.
The moment an EC2 instance gets a public IPv4 address, the clock starts. Botnets are already scanning the address space, looking for open ports, default credentials, and unpatched CVEs — often within minutes of the instance going live. Most of us respond to this threat the same fragmented way: one script for SSL, another for kernel hardening, a separate tool to hunt for malicious npm packages, and a completely different process to track OS-level CVEs. None of these tools talk to each other. None of them give you a single place to answer the simple question: "Is my server actually safe right now?"
That fragmentation — and the alert fatigue it causes — is what pushed me to build SOC Pulse, a fully automated, self-hosted Security Operations Center purpose-built for AWS Ubuntu EC2.
Why I Built SOC Pulse
Commercial SOC dashboards like Datadog or CrowdStrike solve the visibility problem, but they solve it by installing a proprietary agent that ships your telemetry, code topology, and vulnerability scans to a third-party cloud. For personal projects, student deployments, and small production workloads, that's often not a trade-off you want — either for cost reasons, or because your forensic data has no business leaving your own instance.
SOC Pulse takes the opposite approach:
Everything runs locally, on your own EC2 box. The React dashboard is hosted by your server, for your server. Nothing is exfiltrated — and there is zero mock data anywhere in the UI. Every scan result, module status, and log line comes from a real, live execution on your machine.
It consolidates five independent security disciplines — supply-chain defense, web app scanning, OS hardening, CVE remediation, and SSL auditing — into a single command center, so you stop juggling SSH sessions and start seeing your actual security posture at a glance.
The Three Design Principles
Three decisions separate SOC Pulse from a typical pile of hardening scripts you'd find scattered across GitHub gists:
1. Zero Data Exfiltration
Your logs, code, and scan results never leave the instance. There's no external API call, no telemetry pipeline, no "phone home."
2. AWS Lockout Prevention
This is the one that matters most in practice, and it's the problem that actually motivated the project. Most open-source hardening scripts blindly overwrite
sshd_config with deprecated Protocol 2 and HostKey directives, or flip on UFW without staging it first. On OpenSSH 9.x, that combination silently destroys AWS EC2 Instance Connect — and you find out you're locked out of your own server only after it's too late to fix it over SSH. SOC Pulse's hardening module was engineered specifically to strip deprecated protocols while dynamically staging UFW without enabling it, guaranteeing SSH availability survives every hardening pass.3. The "No-Hang" Orchestrator
Terminal automation loves to hang —
apt-get waiting on an interactive prompt, DNS stalling mid-SSL-check, a scan that never returns. The Node.js orchestrator runs every module through a strictly buffered child_process with DEBIAN_FRONTEND=noninteractive , hard timeouts, and a 2,000-line memory cap, so the dashboard never freezes, crashes, or runs the box out of memory.Architecture: Three Planes
SOC Pulse isn't a static dashboard with hardcoded numbers bolted on top of some shell scripts — it's structured as a living orchestration engine, split cleanly into three planes.
The Visualization Plane (Frontend)
Built with React + Vite, styled in a dark, data-dense "glassmorphism" aesthetic. It uses CSS display-toggling to preserve forensic logs across navigation instead of losing them on every route change, and a custom parser renders raw terminal output into three distinct panels, in a layout inspired by Wazuh-style reporting:
- 🔴 Problems Found
- ✅ Passed Items
- 🖥️ Raw Forensic Logs
It connects to the backend over WebSocket with exponential-backoff auto-reconnection, so a dropped connection doesn't mean a dead dashboard.
The Orchestration Plane (Backend API)
A detached Express REST API paired with a Socket.io WebSocket server bound to port
5000 . When you trigger a scan from the UI, the orchestrator fires the corresponding shell or npm payload through child_process.spawn() , and the raw stdout / stderr streams are mirrored live, straight into the browser's terminal window. This is where the "No-Hang" guarantee actually lives — hard timeouts and buffering that keep a single stuck module from taking the whole system down with it.The Defensive Plane (The Micro-Modules)
Five natively executed, fully local security modules. Outbound internet dependencies were deliberately stripped out of these modules — the last thing a SOC dashboard should do is become a supply-chain risk during a supply-chain audit.
Deep Dive: The Five Security Modules
1. 🛡️ Supply Chain Defense
Threat mitigated: NPM supply-chain attacks, typosquatting, credential stealers.
The module runs a Shai-Hulud 2.0 heuristics engine against local
package.json files, checking them against a database of roughly 790+ known compromised packages. The dashboard side uses a custom brace-counting parser to extract the raw JSON output straight from the bash stream, then highlights every compromised package it finds and auto-generates the exact npm uninstall commands needed to remediate it — no manual triage required.2. 🌐 Web App Scanner
Threat mitigated:
CVE-2025-55182 — a CVSS 10.0 remote code execution vulnerability.This is a localized DAST executor that evaluates React Server Components (RSC) and Next.js topologies, specifically hunting for a dangerous RSC Flight-protocol parsing error that lets an unauthenticated attacker execute terminal commands on the server, bypassing standard network firewalls entirely. It maps out the app's framework architecture (Client-Only vs. App Router) and returns a definitive Safe or Vulnerable verdict — without your proprietary code ever touching a third-party API.
3. 🔐 System Endpoint Hardening
Threat mitigated: Brute-force SSH attacks, IP spoofing, file tampering, privilege escalation.
An autonomous OS configuration engine that detects your Ubuntu release (22.04 or 24.04 LTS) and natively locks down the kernel, enforcing Sysctls, AIDE, Fail2Ban, and AuditD. As covered above, it's engineered around the AWS Instance Connect problem specifically — stripping deprecated SSH directives while staging (not enabling) UFW. The dashboard renders the result through an Emoji Matrix Parser, giving you a live Service Health Grid of every daemon that started successfully.
4. 🩹 Autonomous CVE Remediation
Threat mitigated: Seven critical OS-level vulnerabilities (RCE & LPE).
A headless, rapid-response tracker that runs behavioral exploit tests directly on the machine and mitigates vulnerabilities without any human in the loop:
CVE | Name | Mitigation |
|---|---|---|
CVE-2024-3094 | XZ-Backdoor | Analyzes liblzma and downgrades it |
CVE-2024-6387 | regreSSHion | Secures LoginGraceTime 0 |
CVE-2021-4034 | PwnKit | Strips SUID from pkexec |
CVE-2021-3156 | Baron Samedit | Tests the sudoedit heap overflow |
CVE-2023-4911 | Looney Tunables | Behavioral exploit test + mitigation |
CVE-2022-0847 | Dirty Pipe | Behavioral exploit test + mitigation |
CVE-2021-44228 | Log4Shell | Behavioral exploit test + mitigation |
The dashboard sorts results into three categories — Vulnerable, Patched, Safe — and uses mathematical fallback counters so the "Total Scanned" metric stays accurate even when regex parsing hits unexpected bash output.
5. 🔑 Machine IP Cryptography (SSL Manager)
Threat mitigated: Expired certificates, Let's Encrypt outages, weak TLS ciphers.
Since July 2025, Let's Encrypt has allowed issuing SSL certificates directly on public AWS IPv4 addresses — but those certs expire every 6 days, which makes automated renewal non-negotiable. I rewrote the standard bash-based SSL auditor entirely as a zero-network Node.js engine (
audit.js ) that checks 8 distinct cryptographic factors locally, completely sidestepping the DNS-hang issues that plague AWS VPCs. Results are stripped of ANSI color codes and rendered into an interactive 8-Stage Audit Grid, with immediate warnings if a Cron renewal job silently broke.Inside the Codebase
The project is organized so each defensive module is fully isolated from the others:
SOC-Pulse/
├── /backend - Express REST router & Child Process Orchestrator
├── /dashboard - Vite/React UI & Socket.io listeners
├── /memory - Deep-dives on internal engineering decisions & goals
├── /setup - Configuration automated installers
├── /module-aws-hardening - The Endpoint OS protection toolkit
├── /module-aws-ssl-manager - IP Certbot validation tools & Node.js Auditor
├── /module-ir-cve-patcher - Automated 7-CVE Mitigation Scripts
├── /module-supply-chain-defense - Shai-Hulud malicious dependency sniffer
├── /module-webapp-scanner - React2Shell remote exploitation defensive suite
└── soc-pulse-start.sh - The primary runtime bootloaderGetting SOC Pulse Running on Your Own EC2 Box
Hardware & OS Requirements
Requirement | Specification | Why |
|---|---|---|
Operating System | Ubuntu 22.04 LTS or 24.04 LTS | Certified for kernel compatibility and OpenSSH 9.x behavior |
Instance Type | t2.large (2 vCPU, 8 GB RAM) minimum | Prevents Node.js out-of-memory errors during heavy DAST sweeps |
Storage | 20 GB gp2/gp3 SSD minimum | Room for node_modules, OS backups, and log retention |
Open These Security Group Ports First
Port | Protocol | Purpose | Required for |
|---|---|---|---|
22 | TCP | SSH access | Remote server management |
5000 | TCP | Backend API & WebSocket | Live-streaming terminal logs to the dashboard |
5173 | TCP | React dashboard | Accessing the SOC Pulse UI |
80 | TCP | HTTP-01 ACME challenge | Optional — only for issuing Let's Encrypt IPv4 certs |
The One-Command Deploy
SSH into your Ubuntu server, switch to root, and clone the repo:
sudo su -
git clone https://github.com/nextgensoumen/soc-pulse.git
cd soc-pulseGrant the bootloader execution rights and launch it:
chmod +x soc-pulse-start.sh
./soc-pulse-start.shWhat Actually Happens During Setup
- System prep — quietly updates
apt, suppresses interactive OS prompts, and installs Node.js 20 LTS.
- Process manager — installs PM2 globally, so the backend and dashboard keep running after you close the terminal or reboot the box.
- Compilation — navigates into each isolated module, installs dependencies, and compiles the underlying logic into executables.
- Daemon launch — PM2 forks the backend and dashboard into background daemons.
Accessing the Dashboard
Once setup finishes, open your public EC2 IP in a browser:
http://<YOUR-AWS-PUBLIC-IP>:5173Living With SOC Pulse: Day-2 Operations
Because everything runs under PM2, the services survive reboots and dropped SSH sessions. When you push new code, updating is a three-line operation:
cd /home/ubuntu/soc-pulse
git checkout backend/data/scan-history.json
git pull
pm2 restart all(The
git checkout step discards local modifications to the live scan-history file first, which avoids merge conflicts on every pull.)Essential PM2 Commands
# View the status of all running SOC Pulse services
pm2 list
# Watch a live, continuous stream of system logs (Ctrl+C to exit)
pm2 logs
# Restart specifically the backend API
pm2 restart soc-pulse-backend
# Restart specifically the React frontend
pm2 restart soc-pulse-dashboard
# Stop everything temporarily
pm2 stop allTroubleshooting Playbook
Symptom | Fix |
|---|---|
Dashboard unreachable ("site can't be reached") | Check your AWS Security Group — inbound TCP 5173 must be open |
Modules show "Offline" or won't run | The frontend can't reach the backend — open inbound TCP 5000 , and check pm2 logs soc-pulse-backend |
"Address already in use" during setup | Something's already bound to port 5000 or 5173 . The start script tries to auto-kill blockers, but you can force it: fuser -k 5000/tcp and fuser -k 5173/tcp , then rerun ./soc-pulse-start.sh |
A module stuck "Running" indefinitely | Click Stop Execution on the dashboard, or refresh if the UI desyncs — hard-timeouts (e.g. 5 minutes for scanners) will self-terminate hung processes automatically |
Contributing
SOC Pulse is MIT-licensed and genuinely open to contributions — new modules, dashboard improvements, and bug fixes are all welcome.
- Fork the repository using the Fork button at the top of the repo page.
- Clone your fork:
git clone https://github.com/YOUR_USERNAME/soc-pulse.git
- Create a branch:
git checkout -b feature/your-feature-name
- Make your changes, following the existing architecture (if adding a module, make sure it runs headlessly, with no interactive prompts).
- Commit clearly:
git commit -m 'feat: added new awesome module'
- Push and open a PR against
main, with a clear description of what changed and why.
Acknowledgments
SOC Pulse builds on the work of the wider security community — particularly gensecaihq , whose engines power the Endpoint Hardening, Supply Chain Defense, and Web App Scanner modules, and alokemajumder , whose vulnerability scripts drive the Autonomous Remediation engine.
Final Thoughts
If you're running any kind of public-facing workload on EC2 — a side project, a student deployment, a small production app — the security work doesn't have to mean ten disconnected scripts and a locked-out SSH session. SOC Pulse was built to make that visibility a one-command problem instead of a full afternoon.
I'd genuinely like to hear what's missing for your use case — drop a comment or open an issue.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article