Home / Mikko Docs

Anveesa Mikko

SOC platform that replaces the Wazuh dashboard: Wazuh's brain, your face

Rust + Vue 3 Wazuh-native Self-Hosted Correlation Engine Case Management

On 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 Design

Mikko never re-indexes Wazuh data. Alerts, agents, vulnerabilities, SCA, and MITRE coverage are all fetched live: nothing duplicated.

Threat Hunting

Attacker-centric pivot by source IP: ranked attackers, per-IP profiles with timeline, targeted agents, MITRE, raw payloads, and VirusTotal / AbuseIPDB links.

Correlation Engine

Background Tokio task that continuously correlates the live event stream into higher-order threats (campaigns, floods, surges) and can auto-block when armed.

Case Management

Incident cases with observables, append-only timelines, status workflows, and direct escalation from detections or threat hunts.

Active Response

Block attacker IPs via Wazuh's firewall-drop command. Dry-run by default, allowlist-guarded, with a full audit trail on every action.

Multi-User Auth

Argon2 passwords, stateless JWT, mandatory TOTP MFA, and RBAC (admin / analyst / viewer) roles with per-action gates.

Tech Stack

LayerTechnology
BackendRust · axum 0.7 · tokio · reqwest (rustls) · sqlx 0.8 · tracing
FrontendVue 3 · Vite 6 · vue-router · Pinia · ECharts · axios
App StatePostgreSQL 16 (optional: cases, response audit, detections)
UpstreamsWazuh 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.

AreaWazuh Dashboard Anveesa Mikko
Alert viewRaw table, manual KQL queriesPeriod-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 correlationManualBackground 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 ResponseManual Wazuh AR commandOne-click block from any view; allowlist-guarded, audited, broadcast to all agents
ComplianceTag-based, manualAutomated 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 + MFAWazuh handles its ownArgon2 passwords, JWT, mandatory TOTP, RBAC (admin / analyst / viewer) + ABAC grants
Short version: Wazuh gives you the data. Mikko gives you the analysis, workflow, and response on top of it, without re-indexing anything.

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.

PlatformTheir approach Mikko's edge
Splunk / IBM QRadarExpensive, heavy; re-indexes all data into their own storeZero re-index (thin proxy), Rust backend means low resource cost, open and extensible
Elastic SIEM / SecurityTightly coupled to Elastic stack licensing; generic dashboardsPurpose-built for the Wazuh + Suricata signal set: every view is designed around what that data actually contains
Microsoft SentinelCloud-only, Azure-tied, expensive at scale (pay-per-GB ingested)On-prem / self-hosted, no ingestion cost, no vendor lock-in
Graylog / GrafanaLog visualisation, not a SOC workflow toolTriage, cases, active response, kill-chain reconstruction, not just dashboards
OSSIM / AlienVaultOutdated UI, heavy footprint, abandoned by AT&TModern Vue 3 SPA, fast Rust backend, actively developed
Commercial SOAR
Palo Alto XSOAR, Splunk SOAR
Expensive, complex playbook builders, often overkill for most teamsResponse 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

RequirementNotes
Wazuh stackManager (:55000) + Indexer/OpenSearch (:9200): existing deployment
Docker + ComposeDocker 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.

1 Extract the deployment package

Unpack the Mikko deployment archive you received and enter the directory.

2 Point to your Wazuh stack

Set environment variables for your Wazuh API and Indexer. Wazuh running on the same Docker host uses host.docker.internal by default.

shell
 # 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 UI

Navigate to http://localhost:8088. The backend API runs on :8080. Log in with the admin credentials you configured.

Docker Compose Services

ServiceImagePortNotes
dbpostgres:16-alpineNot exposedApp state; volume mikko-pg-data; healthchecked
backend./backend8080Rust API; waits for db healthy
frontend./frontend8088Static SPA served by nginx

Configuration Reference

VariableDefaultPurpose
BIND_ADDR0.0.0.0:8080API listen address
WAZUH_API_URLhttps://localhost:55000Wazuh manager API
WAZUH_API_USER / PASSWORDwazuh / wazuhManager API credentials
INDEXER_URLhttps://localhost:9200Wazuh Indexer (OpenSearch)
INDEXER_USER / PASSWORDadmin / adminIndexer credentials
WAZUH_INSECURE_TLStrueAccept self-signed Wazuh certs
ALERTS_INDEXwazuh-alerts-*Alert index pattern
VULN_INDEXwazuh-states-vulnerabilities-*Vulnerability states index
DATABASE_URLunsetPostgreSQL 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.

DocumentContents
ArchitectureSystem design, data flow, module map, thin-proxy model, optional Postgres layer
API ReferenceFull REST + WebSocket endpoint reference
DatabasePostgreSQL schema, migrations, config singleton tables
Active ResponseThe blocking safety model: dry-run mode, allowlist, arming procedure, auto-block
Correlation EngineDetection rules, scoring formulas, deduplication, tuning parameters
DeploymentDocker Compose setup, production considerations, TLS/secrets guidance
FeaturesDeep-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

Mikko reads alerts live from the Wazuh API and indexer and never stores a copy. Only its own case data goes to PostgreSQL.

The Two Upstream APIs

UpstreamPortWhat Mikko reads
Wazuh Manager API:55000Agent list, agent detail, SCA results, active response, restart commands, configuration
Wazuh Indexer (OpenSearch):9200Alert 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 TypeStorageExamples
Alerts, agents, vulnerabilities, MITRE, SCANever stored: live from WazuhAlert feed, agent fleet, CVE states
Cases & observablesPostgreSQL (cases, case_entities, case_events)Incident records, timeline, comments
Response auditPostgreSQL (response_actions)Every block/unblock with reason, source, dry-run flag
Correlation detectionsPostgreSQL (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:

RuleQuery typeFires when
CampaignTerms agg on source IP with sub-agg on agent cardinalityOne IP hits ≥ 3 distinct agents
Bruteforce / FloodTerms agg on source IP, event count≥ 80 events from one IP to < 3 agents
SurgeTerms 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:

APIHow 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.

ServiceWhat it enriches
VirusTotalIP reputation, malware associations, passive DNS
AbuseIPDBAbuse 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:

CommandEffect
firewall-dropBlock an IP via iptables (default; used by Mikko)
host-denyAdd IP to /etc/hosts.deny
route-nullNull-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

ResourceMinimumRecommended
CPU1 vCPU2 vCPU (enables correlation engine headroom)
RAM512 MB1 GB (with PostgreSQL + correlation engine running)
Disk5 GB20 GB (Docker images + PostgreSQL data growth)
NetworkLAN access to Wazuh API and IndexerSame 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:

ScaleWazuh Indexer RAMWazuh Manager RAM
Small (< 25 agents)4 GB2 GB
Medium (25–100 agents)8–16 GB4 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)

RequirementDetails
OSAny modern Linux distribution (Ubuntu 22.04+, Debian 12+, RHEL 8+, etc.)
DockerDocker Engine 24+ + Compose v2
Network accessMust reach Wazuh Manager (:55000) and Wazuh Indexer (:9200); TCP inbound on :8080 (API) and :8088 (UI)
TLS terminationProduction deployments should sit behind a reverse proxy (nginx, Caddy, Traefik) for HTTPS

Client (SOC Analyst Browser)

RequirementDetails
BrowserAny modern browser: Chrome 100+, Firefox 100+, Safari 16+, Edge 100+
JavaScriptMust be enabled (Vue 3 SPA)
Screen resolution1280×768 minimum; 1440×900+ recommended for dashboard and graph views
NetworkHTTP/HTTPS access to the Mikko frontend port; WebSocket support required for live alert stream
MFA appA 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

ComponentScalable?Notes
Backend (API)Yes: horizontallyStateless; any replica handles any request
Frontend (nginx)Yes: CDN or multi-replicaPure static files
PostgreSQLManaged instance recommendedUse RDS, Cloud SQL, or similar for HA
Correlation EngineSingle instance onlyRun 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

RuleDetectsDefault threshold
CampaignOne source IP hitting many distinct agents: coordinated scanning or lateral movement≥ 3 distinct agents
Bruteforce / FloodOne IP generating high event volume against fewer than 3 agents: brute-force or DoS≥ 80 events
SurgeA 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 Studio

Navigate to Detections → Detection Studio in the sidebar.

Define your rule

Set 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 saving

Click 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 rule

Save 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.

ParameterDefaultEffect
enabledtrueMaster on/off for the whole engine
interval_sec60How often the engine runs a detection pass
window_min15Look-back window per pass (minutes)
cooldown_min30Dedup window per entity + rule (prevents re-firing)
campaign_min_agents3Minimum distinct agents to trigger Campaign rule
bruteforce_min80Minimum events to trigger Bruteforce rule
surge_min15Minimum 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.

LayerWhat 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 PulseDetects 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 / BeaconingClusters IPs by shared JA3 fingerprints + distinctive signatures: a coordinated zero-day campaign can be grouped before individual signatures exist.
Correlation Engine + Detection StudioCustom 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 PathReconstructs 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 Pull

Pulls listening ports, processes, packages, and hardware from every active agent via Wazuh's syscollector module.

Port Classification

Each listening port is classified: loopback (safe) → exposed (non-loopback bind) → risky (database, remote-admin, or sensitive service facing the network).

Surface Score

Score 0–100 per host: min(100, (exposed×3) + (risky×15)): risky services weigh 5× more than exposed ports.

Fleet-Wide KPIs

Top-of-page summary: hosts at risk, total exposed ports, and risky service count across the entire agent fleet.

Host Drilldown

Drawer per host showing the full port/process table, hardware summary (CPU, RAM, cores), and risky service chips.

Attack Path Feed

Surface 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.

LayerTechnology
Backend languageRust (stable)
HTTP frameworkaxum 0.7
Async runtimetokio
HTTP clientreqwest (rustls TLS)
Database ORMsqlx 0.8 (runtime queries, embedded migrations)
DatabasePostgreSQL 16
Authargon2 passwords · JWT (stateless) · TOTP/MFA (RFC 6238) · RBAC + ABAC
Frontend frameworkVue 3 (Composition API)
Frontend buildVite 6
State managementPinia
ChartsApache ECharts
Package managerBun
ContainerizationDocker + Docker Compose
Upstream dataWazuh Manager (:55000) + Wazuh Indexer / OpenSearch (:9200)
IDSSuricata (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.com

We 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

DetailWhy it helps
Wazuh versionConfirms API compatibility before delivery
Number of agentsHelps size the correlation engine and PostgreSQL
Deployment targetOn-prem, cloud VM, managed Kubernetes: affects packaging
Required featuresActive 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 Proxy

Place 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 Management

Inject *_PASSWORD and DATABASE_URL via your secrets manager or an .env file that is not committed to version control. Never bake credentials into images.

TLS for Wazuh Connections

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.

Managed PostgreSQL

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.

5 Active Response Arming

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.