GuiderFöretag och övervakningSäkerhet med Wazuh

Bevaka dina servrar mot attacker med Wazuh och Podman utan root

Wazuh 4.14 på Debian 13, systemet med öppen källkod för säkerhetsövervakning, med manager, indexer och dashboard i rootless Podman under en egen användare bakom Caddy, och en agent som rapporterar inloggningar, ändringar och attacker på dina servrar.

Testad på Wazuh 4.14.8 på Debian 13 (trixie) på en server hos Melonslab Uppdaterad 14 oktober 2026

Rekommenderad server för guiden

SSD RAID 1 · ECC DDR4 · 10 Gbit

VC-P Titanium · 4 vCPU · 16 GB Minne · 120 GB Lagring

Månadsvis, ingen bindningstid 7 dagars öppet köp

200 kr/mån

Beställ nu
På den här sidan

Det här sätter du upp

Wazuh bevakar dina servrar för att upptäcka attacker och svaga inställningar. Ett litet program på varje server, agenten, läser serverns loggar, märker när filer och användare ändras, listar installerad programvara och kontrollerar serverns inställningar mot CIS benchmark, en offentlig lista med säkerhetsrekommendationer. Allt skickas till Wazuh manager, som jämför det med tusentals regler och larmar vid misslyckade inloggningar, försök att gissa lösenord, nya användare, ändrade systemfiler med mera. Larmen hamnar i Wazuh indexer, en sökmotor, och du läser dem i Wazuh dashboard i webbläsaren.

Wazuh utvecklas av Wazuh, Inc., ett bolag i USA som säljer support och Wazuh som molntjänst. Det är öppen källkod: managern och agenten under GPLv2, och indexern och dashboarden, som bygger på OpenSearch, under Apache 2.0-licensen.

Här körs manager, indexer och dashboard i en pod under en egen användare som heter siem, från Wazuhs officiella avbilder, bakom Caddy från Podman-guiden. Agenten körs som root på servern den bevakar och installeras från Wazuhs paketförråd, eftersom den behöver läsa systemets loggar. I den här guiden hamnar den första agenten på samma server, och samma kommandon ansluter vilken annan server som helst.

Varje steg nedan har körts på en nyinstallerad Melonslab VC-P Titanium (4 vCPU, 16 GB) med Debian 13:

  • Wazuh 4.14.7 startade utan root, med egna lösenord i stället för de publicerade standardlösenorden innan den kom ut på nätet. Standardinloggningarna admin med SecretPassword och kibanaro med kibanaro nekades.
  • En agent på servern anslöt med lösenord över IPv6 och visades som aktiv med Debian GNU/Linux 13.
  • Misslyckade SSH-inloggningar med ett okänt användarnamn gav larmet "sshd: Attempt to login using a non-existent user", och åtta av dem "sshd: brute force trying to get access to the system", nivå 10. En ny användare gav "New user added to the system". CIS benchmark för Debian 13 kördes av sig självt.
  • En e-postkanal skickade ett testmeddelande över STARTTLS med lösenord, och en bevakning mejlade varje larm på nivå 10 eller högre inom fem minuter.
  • En uppdatering från Wazuh 4.14.7 till 4.14.8 behöll agenten, larmen och e-postbevakningen. Wazuh återställdes från en säkerhetskopia under en nyskapad användare, agenten anslöt igen av sig själv, och allt startade igen av sig självt efter en omstart av servern.

Podden använde omkring 2,2 GB minne: 1,6 GB för indexern, 400 MB för managern och 300 MB för dashboarden. På disken tar avbilderna 4,5 GB, och sårbarhetsdatabasen som managern laddar ner tar ytterligare 10 GB.

Wazuh kan också köras med root, vilket är så Wazuhs egna Docker-instruktioner kör den. Den fungerar utan root här utan ändringar i avbilderna, så den här guiden kör den utan root som de andra apparna.

Innan du börjar

Du behöver:

  • en server uppsatt som i Podman-guiden, med Caddy igång och minst 8 GB minne;
  • en A-post och en AAAA-post för wazuh.example.com som pekar på din server.

Exemplen använder wazuh.example.com för Wazuh och web1 som serverns namn i Wazuh. Byt ut dem genomgående.

Agenterna ansluter till servern på port 1514 och 1515. Om du använder ufw från säkerhetsguiden öppnar du dem som root:

ufw allow 1514,1515/tcp

1. Skapa användaren

Som root:

apt install -y curl
useradd -m -s /bin/bash siem
loginctl enable-linger siem
machinectl shell siem@

Allt fram till steg 7 körs som siem. Användaren heter inte wazuh, eftersom agenten i steg 9 skapar en systemanvändare med det namnet, och den ska hållas åtskild från den som kör containrarna.

2. Skapa certifikaten

Indexern, managern och dashboarden pratar med varandra över TLS, med certifikat från en egen liten certifikatutfärdare. Wazuhs certifikatverktyg skapar dem:

mkdir -p ~/wazuh/certs
cd ~/wazuh
cat > certs.yml <<'EOF'
nodes:
  indexer:
    - name: wazuh.indexer
      ip: wazuh.indexer
  server:
    - name: wazuh.manager
      ip: wazuh.manager
  dashboard:
    - name: wazuh.dashboard
      ip: wazuh.dashboard
EOF
podman run --rm -e CERT_TOOL_VERSION=4.14 -v ./certs.yml:/config/certs.yml -v ./certs:/certificates docker.io/wazuh/wazuh-certs-generator:0.0.4

Verktyget skriver ut find: command not found en gång, vilket inte gör något, och slutar med Setting UID for wazuh manager and worker. Certifikaten i ~/wazuh/certs tillhör nu användarna inne i containrarna, så ls fungerar på dem men inte cat. Certifikatutfärdarens nyckel, root-ca.key, ligger där också; steg 13 säkerhetskopierar den.

3. Skapa lösenorden

openssl rand -hex 16 | tr -d '\n' | podman secret create wazuh-admin-password -
openssl rand -hex 16 | tr -d '\n' | podman secret create wazuh-dashboard-password -
printf '%sAa1.' "$(openssl rand -hex 16)" | podman secret create wazuh-api-password -
openssl rand -hex 16 | tr -d '\n' | podman secret create wazuh-enrollment-password -

De är i tur och ordning: lösenordet för admin, som du loggar in i dashboarden med; dashboardens eget lösenord till indexern; lösenordet för wazuh-wui, användaren som dashboarden når managern med, som också måste innehålla en versal, en siffra och ett specialtecken, därav Aa1.; och lösenordet som agenter behöver för att ansluta. Wazuhs egna instruktioner levereras med fasta, publicerade lösenord för alla dessa; här är vart och ett slumpat och lagrat av Podman, inte i filerna nedan.

4. Skriv konfigurationen

Ladda ner indexerns och managerns konfiguration från Wazuhs förråd, för den version du kör:

mkdir -p ~/wazuh/config
cd ~/wazuh/config
base=https://raw.githubusercontent.com/wazuh/wazuh-docker/v4.14.8/single-node/config
curl -fsSLo wazuh.indexer.yml $base/wazuh_indexer/wazuh.indexer.yml
curl -fsSLo manager.conf $base/wazuh_cluster/wazuh_manager.conf
sed -i 's|<use_password>no</use_password>|<use_password>yes</use_password>|' manager.conf
sed -i 's|<port>151[45]</port>|&\n    <ipv6>yes</ipv6>|' manager.conf

De två sed-raderna ändrar managern på två sätt:

  • use_password gör att agenter måste ange anslutningslösenordet från steg 3. Utan det kan vem som helst som når port 1515 ansluta en agent.
  • ipv6 gör att managern lyssnar på IPv6 och inte bara IPv4. Utan det misslyckas agenter som når servern över IPv6, till exempel en på själva servern, med "Connection refused by the manager". Med Wazuhs egen uppsättning med root döljer Docker det, eftersom den skickar vidare IPv6-anslutningar över IPv4; rootless Podman skickar dem vidare som de är.

Indexern har sina användare i internal_users.yml, med varje lösenord lagrat som en hash. Skapa hasharna med indexerns eget verktyg, som läser lösenordet från hemligheten, och skriv filen:

hash() {
  podman run --rm --secret $1,type=env,target=PW -e JAVA_HOME=/usr/share/wazuh-indexer/jdk \
    docker.io/wazuh/wazuh-indexer:4.14.8 bash plugins/opensearch-security/tools/hash.sh -env PW | tail -1
}
cat > internal_users.yml <<EOF
_meta:
  type: "internalusers"
  config_version: 2
admin:
  hash: "$(hash wazuh-admin-password)"
  reserved: true
  backend_roles:
  - "admin"
kibanaserver:
  hash: "$(hash wazuh-dashboard-password)"
  reserved: true
EOF

Wazuhs egen fil har också fyra demoanvändare, bland dem kibanaro med lösenordet kibanaro, som kan läsa alla larm. De är borttagna här.

Till sist dashboardens inställningar, opensearch_dashboards.yml:

cat > opensearch_dashboards.yml <<'EOF'
server.host: 0.0.0.0
server.port: 5601
opensearch.hosts: https://wazuh.indexer:9200
opensearch.ssl.verificationMode: certificate
opensearch.ssl.certificateAuthorities: ["/usr/share/wazuh-dashboard/certs/root-ca.pem"]
opensearch.requestHeadersAllowlist: ["securitytenant","Authorization"]
opensearch_security.multitenancy.enabled: false
opensearch_security.readonly_mode.roles: ["kibana_read_only"]
opensearch_security.cookie.secure: true
uiSettings.overrides.defaultRoute: /app/wz-home
EOF

Dashboarden svarar med vanlig HTTP inne i podden, och Caddy ger den HTTPS. cookie.secure gör att webbläsaren bara skickar inloggningskakan över HTTPS.

5. Definiera podden

mkdir -p ~/.config/containers/systemd
cd ~/.config/containers/systemd

Skapa wazuh.pod:

[Pod]
PodName=wazuh
# Only Caddy, on this server, can reach the dashboard: the port is not open to the internet.
PublishPort=127.0.0.1:8130:5601
# Agents connect here: 1514 for their events, 1515 to enroll
PublishPort=1514:1514
PublishPort=1515:1515
# The names in the certificates all point at the pod itself
AddHost=wazuh.indexer:127.0.0.1
AddHost=wazuh.manager:127.0.0.1

[Install]
WantedBy=default.target

Skapa wazuh-indexer.container:

[Container]
ContainerName=wazuh-indexer
Image=docker.io/wazuh/wazuh-indexer:4.14.8
Pod=wazuh.pod
Environment="OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g"
Ulimit=nofile=65536:65536
Volume=wazuh-indexer:/var/lib/wazuh-indexer
Volume=%h/wazuh/config/wazuh.indexer.yml:/usr/share/wazuh-indexer/config/opensearch.yml:ro
Volume=%h/wazuh/config/internal_users.yml:/usr/share/wazuh-indexer/config/opensearch-security/internal_users.yml:ro
Volume=%h/wazuh/certs/root-ca.pem:/usr/share/wazuh-indexer/config/certs/root-ca.pem:ro
Volume=%h/wazuh/certs/wazuh.indexer.pem:/usr/share/wazuh-indexer/config/certs/wazuh.indexer.pem:ro
Volume=%h/wazuh/certs/wazuh.indexer-key.pem:/usr/share/wazuh-indexer/config/certs/wazuh.indexer.key:ro
Volume=%h/wazuh/certs/admin.pem:/usr/share/wazuh-indexer/config/certs/admin.pem:ro
Volume=%h/wazuh/certs/admin-key.pem:/usr/share/wazuh-indexer/config/certs/admin-key.pem:ro
HealthCmd=curl -sk -o /dev/null https://127.0.0.1:9200
HealthInterval=10s
HealthStartPeriod=2m
Notify=healthy

[Service]
Restart=always
TimeoutStartSec=300

Skapa wazuh-manager.container:

[Unit]
Requires=wazuh-indexer.service
After=wazuh-indexer.service

[Container]
ContainerName=wazuh-manager
Image=docker.io/wazuh/wazuh-manager:4.14.8
Pod=wazuh.pod
Environment=INDEXER_URL=https://wazuh.indexer:9200 INDEXER_USERNAME=admin
Environment=FILEBEAT_SSL_VERIFICATION_MODE=full SSL_CERTIFICATE_AUTHORITIES=/etc/ssl/root-ca.pem
Environment=SSL_CERTIFICATE=/etc/ssl/filebeat.pem SSL_KEY=/etc/ssl/filebeat.key
Environment=API_USERNAME=wazuh-wui
Secret=wazuh-admin-password,type=env,target=INDEXER_PASSWORD
Secret=wazuh-api-password,type=env,target=API_PASSWORD
Secret=wazuh-enrollment-password,type=mount,target=/var/ossec/etc/authd.pass,uid=0,gid=999,mode=0640
Volume=wazuh-manager-etc:/var/ossec/etc
Volume=wazuh-manager-queue:/var/ossec/queue
Volume=wazuh-manager-logs:/var/ossec/logs
Volume=wazuh-manager-api:/var/ossec/api/configuration
Volume=wazuh-manager-multigroups:/var/ossec/var/multigroups
Volume=wazuh-manager-filebeat:/var/lib/filebeat
Volume=%h/wazuh/config/manager.conf:/wazuh-config-mount/etc/ossec.conf:ro
Volume=%h/wazuh/certs/root-ca-manager.pem:/etc/ssl/root-ca.pem:ro
Volume=%h/wazuh/certs/wazuh.manager.pem:/etc/ssl/filebeat.pem:ro
Volume=%h/wazuh/certs/wazuh.manager-key.pem:/etc/ssl/filebeat.key:ro

[Service]
Restart=always

Och wazuh-dashboard.container:

[Unit]
Requires=wazuh-indexer.service
After=wazuh-indexer.service wazuh-manager.service

[Container]
ContainerName=wazuh-dashboard
Image=docker.io/wazuh/wazuh-dashboard:4.14.8
Pod=wazuh.pod
Environment=WAZUH_API_URL=https://wazuh.manager API_USERNAME=wazuh-wui DASHBOARD_USERNAME=kibanaserver
Secret=wazuh-api-password,type=env,target=API_PASSWORD
Secret=wazuh-dashboard-password,type=env,target=DASHBOARD_PASSWORD
Volume=wazuh-dashboard:/usr/share/wazuh-dashboard/data/wazuh/config
Volume=%h/wazuh/config/opensearch_dashboards.yml:/usr/share/wazuh-dashboard/config/opensearch_dashboards.yml:ro
Volume=%h/wazuh/certs/root-ca.pem:/usr/share/wazuh-dashboard/certs/root-ca.pem:ro

[Service]
Restart=always

Vad inställningarna gör:

  • De tre containrarna delar poddens nätverk och når varandra på 127.0.0.1. Raderna AddHost ger den adressen namnen i certifikaten, som managern kontrollerar när den skickar larm till indexern.
  • Notify=healthy gör att systemd väntar tills indexern svarar innan den startar managern och dashboarden.
  • Indexern får 1 GB minne till sin Java-heap, vilket räcker för en handfull agenter. Höj båda talen för fler.
  • Managerns inställningar, agenternas nycklar och reglerna ligger i wazuh-manager-etc, och larmen som filer i wazuh-manager-logs. Managern kopierar manager.conf över sin ossec.conf varje gång den startar, så ändra filen i ~/wazuh/config, inte inne i containern.
  • Anslutningslösenordet monteras som den fil managern läser det från, läsbar bara för dess grupp wazuh, som har nummer 999 i avbilden.
  • Versionen är låst. Manager, indexer och dashboard måste ha samma version, och agenter får inte vara nyare än managern, så du uppdaterar dem tillsammans (steg 14) i stället för med podman auto-update.

6. Starta den

systemctl --user daemon-reload
systemctl --user start wazuh-pod

Vid första starten laddas omkring 4,5 GB avbilder ner, och dashboarden är klar en minut eller två efter det. Den är klar när det här skriver ut 200:

curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8130/app/login

Under den första timmen laddar managern också ner sin sårbarhetsdatabas, omkring 10 GB på disken när den är uppackad.

7. Sätt Caddy framför

Gå tillbaka till root med exit, byt till machinectl shell caddy@ och lägg till det här blocket sist i ~/Caddyfile:

wazuh.example.com {
    reverse_proxy 127.0.0.1:8130
}

Starta om Caddy med systemctl --user restart caddy.

8. Logga in

Som siem visar du admin-lösenordet:

podman secret inspect --showsecret --format '{{.SecretData}}' wazuh-admin-password; echo

Öppna https://wazuh.example.com och logga in som admin med det lösenordet. Spara det i din lösenordshanterare. Startsidan, Overview, visar agenterna och larmen från de senaste 24 timmarna och länkar till varje del av Wazuh: Configuration Assessment, File Integrity Monitoring, Threat Hunting, Vulnerability Detection med flera.

En agent finns redan från början, wazuh (server). Det är managern som bevakar sig själv, inne i sin container. För att bevaka servern behövs en egen agent.

Dashboarden är på engelska. Den har ingen svensk översättning.

9. Anslut en agent

Som siem visar du anslutningslösenordet:

podman secret inspect --showsecret --format '{{.SecretData}}' wazuh-enrollment-password; echo

Som root på servern du vill bevaka, den här eller en annan, lägger du sedan till Wazuhs paketförråd och installerar agenten, med lösenordet i stället för ENROLLMENT_PASSWORD:

curl -fsSLo /usr/share/keyrings/wazuh.asc https://packages.wazuh.com/key/GPG-KEY-WAZUH
echo "deb [signed-by=/usr/share/keyrings/wazuh.asc] https://packages.wazuh.com/4.x/apt/ stable main" > /etc/apt/sources.list.d/wazuh.list
apt update
WAZUH_MANAGER=wazuh.example.com WAZUH_REGISTRATION_PASSWORD='ENROLLMENT_PASSWORD' WAZUH_AGENT_NAME=web1 apt install -y wazuh-agent=4.14.8-1
apt-mark hold wazuh-agent
systemctl daemon-reload
systemctl enable --now wazuh-agent

Variablerna hamnar i agentens konfiguration när paketet installeras: managerns adress, lösenordet, som sparas i /var/ossec/etc/authd.pass, och namnet servern får i Wazuh. apt-mark hold hindrar apt upgrade från att installera en agent som är nyare än din manager, eftersom managern inte skulle ta emot den.

Agenten ansluter på port 1515 och skickar sedan sina händelser på port 1514, krypterade med nyckeln den fick. Inom en minut visar Agents management, Summary i dashboardens meny web1 som active, med dess operativsystem. På servern säger agentens logg samma sak:

grep agentd /var/ossec/logs/ossec.log | tail -3

Den slutar med Connected to the server ([wazuh.example.com]:1514/tcp). För fler servrar kör du samma kommandon på var och en, med ett eget namn.

10. Se larmen

För att se ett larm komma in försöker du logga in över SSH på servern med en användare som inte finns, från valfri dator:

ssh nosuchuser@wazuh.example.com

Varje försök ger larmet "sshd: Attempt to login using a non-existent user", nivå 5, och åtta försök i rad ger "sshd: brute force trying to get access to the system. Non existent user.", nivå 10. Wazuhs nivåer går från 0 till 15, och dashboarden räknar 7 till 11 som medel, 12 till 14 som hög och 15 som kritisk.

Öppna Threat Hunting och Events. Varje larm visar agenten, regeln, nivån och regelns ID, och öppnas med alla detaljer, till exempel adressen inloggningarna kom från. Sökrutan tar frågor som rule.level >= 10.

Under de första minuterna kör agenten också CIS benchmark för Debian 13. Configuration Assessment listar varje kontroll som gick igenom eller inte, med orsaken och hur du åtgärdar den. En nyinstallerad Debian 13 får omkring 45 %, mest för loggningsregler som inte är uppsatta från början.

Det här bevakar agenten också från början:

  • inloggningar, sudo och nya eller borttagna användare och grupper, från systemets journal;
  • ändringar av filer i /etc, /bin, /sbin, /boot, /usr/bin och /usr/sbin, kontrollerade var 12:e timme, under File Integrity Monitoring;
  • installerade paket, öppna portar och körande processer, en gång i timmen, som Vulnerability Detection jämför med kända säkerhetshål.

11. E-post

Wazuh behöver inte e-post för att fungera: utan den läser du larmen i dashboarden. Managerns egna e-postlarm kan inte logga in på en mailserver, så de fungerar bara via ett lokalt e-postrelä, som den här guiden inte sätter upp. Indexerns larmfunktion kan i stället mejla dig, och den loggar in med lösenord över STARTTLS på port 587 eller TLS på port 465.

Som siem sparar du SMTP-lösenordet som en hemlighet och lägger det, med användarnamnet, i indexerns keystore, en fil där indexern förvarar hemliga inställningar. mail är namnet på avsändaren du skapar nedan, och alerts@example.com ditt konto hos din e-postleverantör:

printf %s 'the-smtp-password' | podman secret create wazuh-smtp-password -
podman run --rm --user 0 --secret wazuh-smtp-password,type=env,target=PW \
  -v ~/wazuh/config:/conf -e OPENSEARCH_PATH_CONF=/conf --entrypoint bash \
  docker.io/wazuh/wazuh-indexer:4.14.8 -c '
    bin/opensearch-keystore create
    echo alerts@example.com | bin/opensearch-keystore add --stdin opensearch.notifications.core.email.mail.username
    printf %s "$PW" | bin/opensearch-keystore add --stdin opensearch.notifications.core.email.mail.password
    chown 1000:1000 /conf/opensearch.keystore'

Lägg till den här raden i wazuh-indexer.container, under de andra Volume-raderna, och starta om podden:

Volume=%h/wazuh/config/opensearch.keystore:/usr/share/wazuh-indexer/config/opensearch.keystore

systemctl --user daemon-reload
systemctl --user restart wazuh-pod

Öppna sedan menyn i dashboarden, Explore, Notifications:

  1. Under Email senders väljer du Create SMTP sender. Ange mail som Sender name, din adress som Email address, din leverantörs SMTP-server som Host och 587 som Port, och välj STARTTLS som Encryption method, eller SSL/TLS för port 465. Välj Create.
  2. Under Channels väljer du Create channel. Ge kanalen ett Name, till exempel Security alerts, välj Email som Channel type, mail som SMTP sender och din egen adress under Default recipients. Send test message skickar ett testmejl. Välj Create.

Kanalen gör ingenting förrän något använder den. För att få ett mejl för varje larm på nivå 10 eller högre skapar du en bevakning som söker efter dem var femte minut. Som siem tar du reda på kanalens ID, config_id för kanalen du namngav:

podman exec wazuh-indexer curl -sk --cert config/certs/admin.pem --key config/certs/admin-key.pem \
  'https://127.0.0.1:9200/_plugins/_notifications/configs?config_type=email'; echo

Spara det här som ~/wazuh/monitor.json, med ID:t i stället för CHANNEL_ID:

{
  "type": "monitor",
  "monitor_type": "query_level_monitor",
  "name": "Wazuh alerts of level 10 or higher",
  "enabled": true,
  "schedule": { "period": { "interval": 5, "unit": "MINUTES" } },
  "inputs": [{ "search": {
    "indices": ["wazuh-alerts-*"],
    "query": {
      "size": 10,
      "_source": ["agent.name", "rule.level", "rule.description"],
      "query": { "bool": { "filter": [
        { "range": { "rule.level": { "gte": 10 } } },
        { "range": { "timestamp": { "gte": "{{period_end}}||-5m", "lte": "{{period_end}}", "format": "epoch_millis" } } }
      ] } }
    }
  } }],
  "triggers": [{ "query_level_trigger": {
    "name": "Level 10 or higher",
    "severity": "1",
    "condition": { "script": { "source": "ctx.results[0].hits.total.value > 0", "lang": "painless" } },
    "actions": [{
      "name": "Email",
      "destination_id": "CHANNEL_ID",
      "subject_template": { "source": "Wazuh: {{ctx.results.0.hits.total.value}} alerts of level 10 or higher" },
      "message_template": { "source": "{{#ctx.results.0.hits.hits}}{{_source.agent.name}}: {{_source.rule.description}} (level {{_source.rule.level}})\n{{/ctx.results.0.hits.hits}}" }
    }]
  } }]
}

Och skapa bevakningen:

podman exec -i wazuh-indexer curl -sk --cert config/certs/admin.pem --key config/certs/admin-key.pem \
  -H 'Content-Type: application/json' -X POST https://127.0.0.1:9200/_plugins/_alerting/monitors --data-binary @- < ~/wazuh/monitor.json; echo

Admin-certifikatet från steg 2 släpper in de här kommandona utan lösenord. Bevakningen syns under Explore, Alerting, där du kan ändra den. Efter åtta misslyckade SSH-inloggningar, som i steg 10, kom ett mejl inom fem minuter med ämnet "Wazuh: 1 alerts of level 10 or higher" och raden web1: sshd: brute force trying to get access to the system. Non existent user. (level 10). Vi testade med en testmailserver på samma server, inte med en e-postleverantör.

12. Externa anslutningar

I våra tester gjorde servern två slags externa anslutningar, båda från managern:

  • till cti.wazuh.com, Wazuhs tjänst för hotinformation, för sårbarhetsdatabasen och för besked om nya Wazuh-versioner, som dashboarden visar;
  • till cdn.amazonlinux.com, direkt efter att sårbarhetsskannern startat. Managerns avbild bygger på Amazon Linux.

Agenterna ansluter bara till din manager.

13. Säkerhetskopiera

Som siem:

umask 077
mkdir -p ~/backup
systemctl --user stop wazuh-pod
cd ~/.local/share/containers/storage/volumes
podman unshare tar -cf ~/backup/wazuh-volumes.tar --exclude='*/_data/vd' --exclude='*/_data/vd_updater' wazuh-*
systemctl --user start wazuh-pod
podman unshare tar -C ~ -cf ~/backup/wazuh-files.tar wazuh .config/containers/systemd
for s in $(podman secret ls --format '{{.Name}}' | grep '^wazuh-'); do
  echo "$s $(podman secret inspect --showsecret --format '{{.SecretData}}' $s)"
done > ~/backup/secrets.txt

Det sparar alla volymer, som innehåller agenternas nycklar, larmen, inställningarna och e-postbevakningen; certifikaten, konfigurationen och unit-filerna; och lösenorden. Sårbarhetsdatabasen hoppas över, eftersom managern laddar ner den igen. Wazuh är stoppad i ungefär en minut medan volymerna kopieras; agenterna sparar sina händelser under tiden och skickar dem när den är tillbaka. podman unshare låter dig läsa filer som tillhör användarna inne i containrarna, och tar listar de sockets den hoppar över, som Wazuh skapar igen när den startar. Kopiera ~/backup till en annan maskin, till exempel med restic, och förvara den säkert: den innehåller alla lösenord, certifikatutfärdarens nyckel och dina servrars historik.

För att återställa, som siem, med säkerhetskopian i ~/backup:

systemctl --user stop wazuh-pod
podman volume rm $(podman volume ls -q | grep '^wazuh-')
cd ~/.local/share/containers/storage/volumes
for v in $(tar -tf ~/backup/wazuh-volumes.tar | cut -d/ -f1 | sort -u); do podman volume create $v; done
podman unshare tar -xpf ~/backup/wazuh-volumes.tar
systemctl --user start wazuh-pod

På en ny server skapar du först användaren som i steg 1 och tar sedan, som siem, tillbaka lösenorden och filerna:

while read -r name value; do printf %s "$value" | podman secret create "$name" -; done < ~/backup/secrets.txt
podman unshare tar -C ~ -xpf ~/backup/wazuh-files.tar
systemctl --user daemon-reload

Kör sedan återställningskommandona ovan från raden med cd, eftersom det inte finns några volymer att stoppa eller ta bort än. Agenterna fortsätter att fungera med den återställda managern, eftersom deras nycklar finns i säkerhetskopian.

14. Uppdatera

Wazuh meddelar nya versioner på sin blogg och i dashboarden. Läs versionsinformationen, säkerhetskopiera som i steg 13 och byt version i de tre filerna, här från 4.14.8 till 4.14.9. Som siem:

cd ~/.config/containers/systemd
sed -i 's/:4\.14\.8$/:4.14.9/' wazuh-indexer.container wazuh-manager.container wazuh-dashboard.container
systemctl --user daemon-reload
systemctl --user restart wazuh-pod

Uppdatera sedan agenten på varje server, som root:

apt-mark unhold wazuh-agent
apt update
apt install -y wazuh-agent=4.14.9-1
apt-mark hold wazuh-agent

När en ny huvudversion som 5.0 kommer läser du först dess uppgraderingsguide: den kan ändra konfigurationsfilerna från steg 4.

Felsökning

Agentens logg säger "Connection refused by the manager". Raderna <ipv6>yes</ipv6> från steg 4 saknas i manager.conf, och agenten når servern över IPv6. Lägg till dem och starta om med systemctl --user restart wazuh-manager.

Agentens logg säger "Invalid password" eller anslutningen misslyckas. Lösenordet i WAZUH_REGISTRATION_PASSWORD skiljer sig från hemligheten. Skriv in det rätta i /var/ossec/etc/authd.pass på agenten och kör systemctl restart wazuh-agent.

https://wazuh.example.com svarar med en tom sida och fel 502. Dashboarden körs inte. Managern och dashboarden behöver indexern, så de stoppas när den stoppas eller kraschar. Kontrollera med systemctl --user status wazuh-indexer, läs journalctl --user -u wazuh-indexer, åtgärda orsaken och kör systemctl --user reset-failed och systemctl --user restart wazuh-pod.

Indexern startar inte efter steg 11, med AccessDeniedException för opensearch.keystore. chown i slutet av keystore-kommandot saknas. Kör podman unshare chown 1000:1000 ~/wazuh/config/opensearch.keystore.

cat eller cp säger "Permission denied" för filerna i ~/wazuh/certs. De tillhör användarna inne i containrarna. Sätt podman unshare framför kommandot.

Kör det på din egen server

SSD RAID 1 · ECC DDR4 · 10 Gbit

VC-P Titanium

200 kr/mån

vCPU
4
Minne
16 GB
Lagring
120 GB
Trafik
15 TB
Performance
SSD · RAID 1
  • Full root-åtkomst
  • Nativt /64 IPv6
  • RAID-skyddad lagring
  • Malmö, Sverige
  • Månadsvis, ingen bindningstid
  • 7 dagars öppet köp
Beställ nu Jämför alla paket

Mer i Företag och övervakning

Visa alla 58 i Företag och övervakning
Alla guider