Anveesa Mikko
SOC platform that replaces the Wazuh dashboard: Wazuh's brain, your face
Rust + Vue 3 Wazuh-native Self-Hosted Correlation Engine Case ManagementOn this page
Overview
Anveesa Mikko is a custom SOC (Security Operations Center) platform built to replace the Wazuh dashboard while keeping Wazuh doing all the heavy lifting underneath. Mikko reads from the same two upstream APIs the stock dashboard reads from and renders them in a faster, cleaner, extensible UI: then adds the capabilities Wazuh lacks: threat hunting, case management, autonomous active response, and a live correlation engine.
Thin Proxy DesignMikko never re-indexes Wazuh data. Alerts, agents, vulnerabilities, SCA, and MITRE coverage are all fetched live: nothing duplicated.
Threat HuntingAttacker-centric pivot by source IP: ranked attackers, per-IP profiles with timeline, targeted agents, MITRE, raw payloads, and VirusTotal / AbuseIPDB links.
Correlation EngineBackground Tokio task that continuously correlates the live event stream into higher-order threats (campaigns, floods, surges) and can auto-block when armed.
Case ManagementIncident cases with observables, append-only timelines, status workflows, and direct escalation from detections or threat hunts.
Active ResponseBlock attacker IPs via Wazuh's firewall-drop command. Dry-run by default, allowlist-guarded, with a full audit trail on every action.
Argon2 passwords, stateless JWT, mandatory TOTP MFA, and RBAC (admin / analyst / viewer) roles with per-action gates.
Tech Stack
| Layer | Technology |
|---|---|
| Backend | Rust · axum 0.7 · tokio · reqwest (rustls) · sqlx 0.8 · tracing |
| Frontend | Vue 3 · Vite 6 · vue-router · Pinia · ECharts · axios |
| App State | PostgreSQL 16 (optional: cases, response audit, detections) |
| Upstreams | Wazuh Manager API (:55000) · Wazuh Indexer / OpenSearch (:9200) |
Prerequisite: Mikko requires an existing Wazuh stack (manager + indexer). Mikko replaces the dashboard UI only: Wazuh keeps doing agent collection, rule evaluation, FIM, vulnerability detection, and SCA.
vs. Wazuh Dashboard
Wazuh ships with Kibana / OpenSearch Dashboards: a generic log visualisation tool. Mikko replaces it with a purpose-built SOC interface that adds the analysis, workflow, and response layer on top of the same data, without re-indexing anything.
| Area | Wazuh Dashboard | Anveesa Mikko |
|---|---|---|
| Alert view | Raw table, manual KQL queries | Period-over-period KPI deltas, "needs attention now" feed, pre-built filters |
| Threat actors | No concept | Clusters attacker IPs into crews via shared JA3 + Suricata signatures + /24 proximity |
| Attack correlation | Manual | Background engine: 3 built-in detectors + custom Detection Studio rules; auto-scores + auto-blocks |
| Attack Path | Not available | Per-host kill-chain: MITRE + Attack Surface + Exposure + Geo fused into one ordered intrusion story |
| Beaconing / C2 | Not available | DNS beaconing + TLS/JA3 fingerprint intel + periodic callback detection |
| Case management | Not available | Full case lifecycle: open, link alerts / IPs / agents, add events, resolve |
| Active Response | Manual Wazuh AR command | One-click block from any view; allowlist-guarded, audited, broadcast to all agents |
| Compliance | Tag-based, manual | Automated control coverage across PCI / NIST / GDPR / HIPAA / TSC / GPG13 from rule tags |
| Replay / time machine | Not available | Replays fleet history as accelerated footage: animated map, ticking counters, milestone reel |
| SOC Pulse | Not available | Z-score anomaly baseline: surfaces statistical spikes and brand-new signals automatically |
| Triage workflow | Not available | Per-IP dispositions (resolve / skip / false-positive / ack) reusable across every view |
| In-app help | None | Every page has a "?" Field Guide: what it answers, how to read columns, respond + prevent playbook, glossary |
| Multi-user + MFA | Wazuh handles its own | Argon2 passwords, JWT, mandatory TOTP, RBAC (admin / analyst / viewer) + ABAC grants |
vs. Other SOC / SIEM Platforms
Mikko is not a general-purpose SIEM. It is a SOC layer built specifically for the Wazuh + Suricata signal set. That focus is what gives it an edge over heavier, more generic platforms.
| Platform | Their approach | Mikko's edge |
|---|---|---|
| Splunk / IBM QRadar | Expensive, heavy; re-indexes all data into their own store | Zero re-index (thin proxy), Rust backend means low resource cost, open and extensible |
| Elastic SIEM / Security | Tightly coupled to Elastic stack licensing; generic dashboards | Purpose-built for the Wazuh + Suricata signal set: every view is designed around what that data actually contains |
| Microsoft Sentinel | Cloud-only, Azure-tied, expensive at scale (pay-per-GB ingested) | On-prem / self-hosted, no ingestion cost, no vendor lock-in |
| Graylog / Grafana | Log visualisation, not a SOC workflow tool | Triage, cases, active response, kill-chain reconstruction, not just dashboards |
| OSSIM / AlienVault | Outdated UI, heavy footprint, abandoned by AT&T | Modern Vue 3 SPA, fast Rust backend, actively developed |
| Commercial SOAR Palo Alto XSOAR, Splunk SOAR | Expensive, complex playbook builders, often overkill for most teams | Response workflow is embedded directly in investigation views: block an IP in 2 clicks from Threat Hunting, no SOAR license needed |
Installation
Mikko can be run via Docker Compose (recommended for production) or from source for local development. Both methods require access to a reachable Wazuh stack.
Prerequisites
| Requirement | Notes |
|---|---|
| Wazuh stack | Manager (:55000) + Indexer/OpenSearch (:9200): existing deployment |
| Docker + Compose | Docker Engine 24+ with Compose v2 |
Quick Start (Docker Compose)
The fastest way to get Mikko running is with Docker Compose. It starts three services: db (PostgreSQL 16), backend, and frontend. The deployment package is provided after you contact us.
Unpack the Mikko deployment archive you received and enter the directory.
2 Point to your Wazuh stackSet environment variables for your Wazuh API and Indexer. Wazuh running on the same Docker host uses host.docker.internal by default.
# Wazuh on the same host (defaults work out of the box)
docker compose up
# Remote Wazuh stack
WAZUH_API_URL=https://your-manager:55000 \
WAZUH_API_USER=wazuh-wui \
WAZUH_API_PASSWORD=your-password \
INDEXER_URL=https://your-indexer:9200 \
INDEXER_USER=admin \
INDEXER_PASSWORD=your-password \
docker compose up
3
Open the UINavigate to http://localhost:8088. The backend API runs on :8080. Log in with the admin credentials you configured.
Docker Compose Services
| Service | Image | Port | Notes |
|---|---|---|---|
db | postgres:16-alpine | Not exposed | App state; volume mikko-pg-data; healthchecked |
backend | ./backend | 8080 | Rust API; waits for db healthy |
frontend | ./frontend | 8088 | Static SPA served by nginx |
Configuration Reference
| Variable | Default | Purpose |
|---|---|---|
BIND_ADDR | 0.0.0.0:8080 | API listen address |
WAZUH_API_URL | https://localhost:55000 | Wazuh manager API |
WAZUH_API_USER / PASSWORD | wazuh / wazuh | Manager API credentials |
INDEXER_URL | https://localhost:9200 | Wazuh Indexer (OpenSearch) |
INDEXER_USER / PASSWORD | admin / admin | Indexer credentials |
WAZUH_INSECURE_TLS | true | Accept self-signed Wazuh certs |
ALERTS_INDEX | wazuh-alerts-* | Alert index pattern |
VULN_INDEX | wazuh-states-vulnerabilities-* | Vulnerability states index |
DATABASE_URL | unset | PostgreSQL app state; off when unset |
Active Response ships disarmed (dry-run) by default. All blocks are simulated and recorded: nothing touches your firewall until you explicitly arm the system. Review the audit log first before enabling live blocking.
Documentation
Mikko ships with a comprehensive set of operator documentation covering every area of the system. The full documentation package is delivered alongside the deployment bundle.
| Document | Contents |
|---|---|
| Architecture | System design, data flow, module map, thin-proxy model, optional Postgres layer |
| API Reference | Full REST + WebSocket endpoint reference |
| Database | PostgreSQL schema, migrations, config singleton tables |
| Active Response | The blocking safety model: dry-run mode, allowlist, arming procedure, auto-block |
| Correlation Engine | Detection rules, scoring formulas, deduplication, tuning parameters |
| Deployment | Docker Compose setup, production considerations, TLS/secrets guidance |
| Features | Deep-dive on every feature page with field-level descriptions |
In-App Help System
Every page in Mikko has a ? help button that explains what the page answers, how to read its columns, recommended respond and prevent actions, and a glossary of SOC terms used. The help content lives in frontend/src/lib/pageHelp.ts, playbooks.ts, and glossary.ts.
Data Ingestion
Mikko is built on a thin-proxy principle: it never re-indexes or stores Wazuh data. All security events, agent information, vulnerabilities, and MITRE coverage are fetched live from the two upstream APIs that the stock Wazuh dashboard also uses.
Architecture: How Data Flows
The Two Upstream APIs
| Upstream | Port | What Mikko reads |
|---|---|---|
| Wazuh Manager API | :55000 | Agent list, agent detail, SCA results, active response, restart commands, configuration |
| Wazuh Indexer (OpenSearch) | :9200 | Alert stream, aggregations (threat hunting, correlation), vulnerabilities, MITRE coverage |
Read-Only vs. App-State Data
Mikko distinguishes between read-only proxy data (fetched live, never stored) and app-state data (the SOC layer Wazuh doesn't own, stored in PostgreSQL).
| Data Type | Storage | Examples |
|---|---|---|
| Alerts, agents, vulnerabilities, MITRE, SCA | Never stored: live from Wazuh | Alert feed, agent fleet, CVE states |
| Cases & observables | PostgreSQL (cases, case_entities, case_events) | Incident records, timeline, comments |
| Response audit | PostgreSQL (response_actions) | Every block/unblock with reason, source, dry-run flag |
| Correlation detections | PostgreSQL (detections) | Campaigns, floods, surges raised by the engine |
Live Alert Stream (WebSocket)
The backend maintains a WebSocket connection that streams new alerts from the Wazuh Indexer in real time. The Alerts page in the UI consumes this stream and updates without requiring manual page refreshes.
Correlation Engine Ingestion
Every interval_sec (default 60 seconds), the background correlation engine runs OpenSearch aggregations over a look-back window (default 15 minutes) to detect:
| Rule | Query type | Fires when |
|---|---|---|
| Campaign | Terms agg on source IP with sub-agg on agent cardinality | One IP hits ≥ 3 distinct agents |
| Bruteforce / Flood | Terms agg on source IP, event count | ≥ 80 events from one IP to < 3 agents |
| Surge | Terms agg on agent name, rule.level ≥ 10 | ≥ 15 high-severity events on one agent |
Without DATABASE_URL set, Mikko boots in pure thin-proxy mode. All live proxy features work. Stateful routes (cases, response, detections) return a clean 503 and the correlation engine is a no-op.
Integrations
Mikko integrates natively with the Wazuh ecosystem and provides outbound pivot links to external threat intelligence services. Future notification integrations are on the roadmap.
Core Integration: Wazuh
Wazuh is Mikko's sole upstream and the only required integration. Mikko connects to two Wazuh APIs:
| API | How Mikko uses it |
|---|---|
| Wazuh Manager API (:55000) | Read agent list, agent details, SCA results, restart agents, send Active Response commands (firewall-drop), read agent config |
| Wazuh Indexer (:9200) | Query alerts (wazuh-alerts-*), run aggregations for threat hunting and correlation, query vulnerability states (wazuh-states-vulnerabilities-*), MITRE tactic/technique coverage |
Threat Intelligence Pivots
From the attacker profile and threat hunting views, Mikko provides direct pivot links to external services for enrichment. These are outbound links only: no API keys required in Mikko itself.
| Service | What it enriches |
|---|---|
| VirusTotal | IP reputation, malware associations, passive DNS |
| AbuseIPDB | Abuse reports, confidence score, country, ISP |
Active Response Integration
Mikko drives Wazuh Active Response via the manager API's PUT /active-response endpoint using the firewall-drop command. The following AR commands are available on the manager side but triggered explicitly by Mikko, not automatically by Wazuh rules:
| Command | Effect |
|---|---|
firewall-drop | Block an IP via iptables (default; used by Mikko) |
host-deny | Add IP to /etc/hosts.deny |
route-null | Null-route an IP |
Suricata IDS
If your Wazuh stack includes Suricata as an IDS, Mikko surfaces Suricata alerts automatically through the standard Wazuh alert index. Dedicated features (Network Forensics, DNS & Beaconing, TLS Intel, Threat Actors) are specifically designed around Suricata's alert format and JA3 fingerprints.
Planned Integrations
Slack, email, and webhook notifications are on the roadmap but not yet implemented. Currently, detections and alerts are visible only within the Mikko UI.
Hardware Requirements
Mikko is a Rust backend (very low memory footprint) with a static Vue SPA frontend. Its hardware requirements are minimal: the dominant cost is the pre-existing Wazuh stack, not Mikko itself.
Mikko Application Server
| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 1 vCPU | 2 vCPU (enables correlation engine headroom) |
| RAM | 512 MB | 1 GB (with PostgreSQL + correlation engine running) |
| Disk | 5 GB | 20 GB (Docker images + PostgreSQL data growth) |
| Network | LAN access to Wazuh API and Indexer | Same network segment or VPN tunnel |
The Rust backend is extremely efficient. In testing, the backend idle memory consumption is well under 50 MB. The 512 MB minimum accounts for PostgreSQL running on the same host.
Wazuh Stack (Separate Prerequisite)
Mikko does not run Wazuh: it connects to your existing Wazuh deployment. Wazuh's own hardware requirements depend on the number of agents and event volume. Refer to the Wazuh documentation for sizing guidance. As a reference point:
| Scale | Wazuh Indexer RAM | Wazuh Manager RAM |
|---|---|---|
| Small (< 25 agents) | 4 GB | 2 GB |
| Medium (25–100 agents) | 8–16 GB | 4 GB |
| Large (100+ agents) | 32 GB+ | 8 GB+ |
Host & Client Requirements
Requirements split into two categories: the server host running Mikko, and the client machines used by SOC analysts to access the Mikko UI.
Server Host (where Mikko runs)
| Requirement | Details |
|---|---|
| OS | Any modern Linux distribution (Ubuntu 22.04+, Debian 12+, RHEL 8+, etc.) |
| Docker | Docker Engine 24+ + Compose v2 |
| Network access | Must reach Wazuh Manager (:55000) and Wazuh Indexer (:9200); TCP inbound on :8080 (API) and :8088 (UI) |
| TLS termination | Production deployments should sit behind a reverse proxy (nginx, Caddy, Traefik) for HTTPS |
Client (SOC Analyst Browser)
| Requirement | Details |
|---|---|
| Browser | Any modern browser: Chrome 100+, Firefox 100+, Safari 16+, Edge 100+ |
| JavaScript | Must be enabled (Vue 3 SPA) |
| Screen resolution | 1280×768 minimum; 1440×900+ recommended for dashboard and graph views |
| Network | HTTP/HTTPS access to the Mikko frontend port; WebSocket support required for live alert stream |
| MFA app | A TOTP authenticator app (Google Authenticator, Authy, 1Password, etc.): MFA is mandatory on all accounts |
TOTP MFA is enforced for all users. On first login after account creation, analysts are presented with a QR code enrollment flow before access is granted. Ensure analysts have a TOTP app installed before provisioning their accounts.
Scaling
The Mikko backend is stateless (apart from PostgreSQL), which means it can scale horizontally. There is one important caveat: the built-in correlation engine.
Horizontal Scaling
The backend handles all state through PostgreSQL. Multiple backend replicas can safely handle REST API requests and WebSocket connections concurrently: any replica can serve any request. Put a load balancer (nginx, HAProxy, Traefik) in front of multiple backend containers to distribute load.
Correlation Engine Constraint
The correlation engine is an in-process background task. Running multiple backend replicas would run multiple engines simultaneously, causing duplicate detections and double auto-blocks. Until the engine has leader-election, run only a single backend replica or disable the engine on all replicas except one.
PostgreSQL
For anything beyond a single host, run PostgreSQL as a managed or standalone instance with backups rather than the bundled compose container. Point DATABASE_URL at it. Migrations run automatically on backend boot via embedded sqlx::migrate!.
Scaling Summary
| Component | Scalable? | Notes |
|---|---|---|
| Backend (API) | Yes: horizontally | Stateless; any replica handles any request |
| Frontend (nginx) | Yes: CDN or multi-replica | Pure static files |
| PostgreSQL | Managed instance recommended | Use RDS, Cloud SQL, or similar for HA |
| Correlation Engine | Single instance only | Run on one replica until leader election is implemented |
Adding Rules
Mikko ships with three built-in correlation rules and a Detection Studio that lets SOC analysts author custom rules directly from the UI: no code or config file editing required.
Built-in Correlation Rules
| Rule | Detects | Default threshold |
|---|---|---|
| Campaign | One source IP hitting many distinct agents: coordinated scanning or lateral movement | ≥ 3 distinct agents |
| Bruteforce / Flood | One IP generating high event volume against fewer than 3 agents: brute-force or DoS | ≥ 80 events |
| Surge | A single agent flooded with high-severity events (rule.level ≥ 10): active compromise or noisy rule | ≥ 15 high-severity events |
Detection Studio (Custom Rules)
The Detection Studio lets you create custom correlation rules from the UI. Custom rules are evaluated by the correlation engine on every pass alongside the three built-ins, using the same OpenSearch aggregation path.
Open Detection StudioNavigate to Detections → Detection Studio in the sidebar.
Define your ruleSet a rule name, description, entity type (IP or agent), aggregation field, threshold, and look-back window. Rules use the same OpenSearch aggregation framework as built-ins.
Backtest before savingClick Preview to run the rule against historical data before enabling it. This shows how many detections it would have generated so you can tune the threshold without creating noise.
4 Enable the ruleSave and enable the rule. The correlation engine will pick it up on the next pass (within interval_sec seconds, default 60).
Tuning the Correlation Engine
Global engine parameters are editable via Detections → Tuning or the API endpoint PUT /api/detections/config.
| Parameter | Default | Effect |
|---|---|---|
enabled | true | Master on/off for the whole engine |
interval_sec | 60 | How often the engine runs a detection pass |
window_min | 15 | Look-back window per pass (minutes) |
cooldown_min | 30 | Dedup window per entity + rule (prevents re-firing) |
campaign_min_agents | 3 | Minimum distinct agents to trigger Campaign rule |
bruteforce_min | 80 | Minimum events to trigger Bruteforce rule |
surge_min | 15 | Minimum high-severity events to trigger Surge rule |
Wazuh-Side Rules
Mikko does not manage Wazuh's own rule set (the XML decoder/rule files). Adding or modifying detection rules at the Wazuh level is done through the Wazuh Manager configuration (/var/ossec/etc/rules/). Mikko surfaces alerts generated by those rules automatically: no additional configuration is needed on the Mikko side.
Zero-Day Attack
Mikko does not have dedicated zero-day detection built in, but several layers contribute to catching novel and unknown threats without relying on a specific signature.
| Layer | What it catches |
|---|---|
| Suricata IDS (upstream) | Signature-based: relies on rule updates (ET Open, commercial feeds). Won't catch true zero-days unless a generic rule fires. |
| SOC Pulse | Detects statistical anomalies: if a zero-day causes unusual traffic patterns (new rule firing, spike from a new country, new technique), it surfaces as a z-score outlier even without a specific signature. |
| Threat Actors / Beaconing | Clusters IPs by shared JA3 fingerprints + distinctive signatures: a coordinated zero-day campaign can be grouped before individual signatures exist. |
| Correlation Engine + Detection Studio | Custom threshold-based rules: analysts can author rules targeting generic behaviors (e.g. "any agent with >50 events from same srcip in 5 min") that catch unknown attack tools. |
| Attack Path | Reconstructs the kill-chain from observed signals: can surface partial kill-chains even when no single alert fires a known signature. |
Bottom line: Zero-day coverage is behavioral and statistical, not signature-based. Adding a threat intel feed (e.g. MISP, AbuseCH) or sandboxed file analysis would be the natural extension, but those are not implemented yet.
Attack Surface Management
The Attack Surface page (/attack-surface) gives a fleet-wide view of exposed ports, running processes, and risky services across all Wazuh agents using syscollector data.
What it does
Syscollector PullPulls listening ports, processes, packages, and hardware from every active agent via Wazuh's syscollector module.
Port ClassificationEach listening port is classified: loopback (safe) → exposed (non-loopback bind) → risky (database, remote-admin, or sensitive service facing the network).
Surface ScoreScore 0–100 per host: min(100, (exposed×3) + (risky×15)): risky services weigh 5× more than exposed ports.
Top-of-page summary: hosts at risk, total exposed ports, and risky service count across the entire agent fleet.
Host DrilldownDrawer per host showing the full port/process table, hardware summary (CPU, RAM, cores), and risky service chips.
Attack Path FeedSurface data is one of four sources fused per host in Attack Path's kill-chain reconstruction: exposed ports inform lateral movement and initial access stages.
Limitation: Depends on syscollector being enabled on Wazuh agents and the agent being active. Agents with no syscollector data show nothing.
Tech Stack
Mikko is built entirely on modern, production-grade open-source components. Every layer is chosen for performance, security, and long-term maintainability.
| Layer | Technology |
|---|---|
| Backend language | Rust (stable) |
| HTTP framework | axum 0.7 |
| Async runtime | tokio |
| HTTP client | reqwest (rustls TLS) |
| Database ORM | sqlx 0.8 (runtime queries, embedded migrations) |
| Database | PostgreSQL 16 |
| Auth | argon2 passwords · JWT (stateless) · TOTP/MFA (RFC 6238) · RBAC + ABAC |
| Frontend framework | Vue 3 (Composition API) |
| Frontend build | Vite 6 |
| State management | Pinia |
| Charts | Apache ECharts |
| Package manager | Bun |
| Containerization | Docker + Docker Compose |
| Upstream data | Wazuh Manager (:55000) + Wazuh Indexer / OpenSearch (:9200) |
| IDS | Suricata (feeds into Wazuh agent) |
Get Mikko
Mikko is not open source. It is available to organisations on request. Reach out to discuss requirements, deployment scope, and pricing.
Email us
pandhuw58@gmail.comWe respond within one business day. Include a short description of your Wazuh setup and the number of agents you monitor.
What to include in your message
| Detail | Why it helps |
|---|---|
| Wazuh version | Confirms API compatibility before delivery |
| Number of agents | Helps size the correlation engine and PostgreSQL |
| Deployment target | On-prem, cloud VM, managed Kubernetes: affects packaging |
| Required features | Active Response, Case Management, Suricata integration, etc. |
Production Deployment Checklist
Once you have the deployment package, follow this checklist for a production-ready setup.
TLS / Reverse ProxyPlace Mikko behind a TLS-terminating reverse proxy (nginx, Caddy, or Traefik). The backend's CORS is permissive for development: tighten it at the proxy layer.
Secrets ManagementInject *_PASSWORD and DATABASE_URL via your secrets manager or an .env file that is not committed to version control. Never bake credentials into images.
If your Wazuh stack uses self-signed certificates, set WAZUH_INSECURE_TLS=true. For a hardened deployment, provision proper certificates and set it to false.
For anything beyond a single host, run PostgreSQL as a managed instance (AWS RDS, GCP Cloud SQL, etc.) with automated backups and point DATABASE_URL at it.
Active Response ships disarmed. Before arming: review the simulated audit log, add your VPN/admin IP ranges to the allowlist, and validate the wire format against a single throwaway agent first.
أسئلة شائعة
What is Anveesa Mikko?
Mikko is a SOC platform that replaces the Wazuh dashboard. It keeps Wazuh as the engine and gives your analysts threat hunting, a live correlation engine, case management and active response on top.
Does Mikko copy or re-index my Wazuh data?
No. Alerts, agents, vulnerabilities, SCA and MITRE coverage are read live from the Wazuh API and indexer. Mikko stores only its own state, such as cases and detections.
What do I need to run Mikko?
An existing Wazuh stack and a host with Docker Compose. The Rust backend idles well under 50 MB of memory; plan for 512 MB if PostgreSQL runs on the same host.
Can Mikko block an attacker automatically?
Yes, through Wazuh's active response, but it ships disarmed. You review the simulated audit log and add your own IP ranges to the allowlist before you arm it.
Is Mikko open source?
No. Mikko is licensed to teams. Write to pandhuw58@gmail.com to talk about a license.