Wazuh

Connect a Wazuh deployment to Jutsu. Jutsu reads Wazuh's alerts from the indexer every minute and checks them with its own detection rules. It also lists your agents as machines, with their local accounts, vulnerabilities, and failed configuration checks, and runs compliance checks on them. Jutsu reads with two read-only users you create in Wazuh. Nothing gets installed on your manager or your agents.

TimeAbout 15 minutes
You need in JutsuThe Owner or Admin role in your Jutsu organization
You need in WazuhWazuh 4.8 to 4.14, or 5.0. A Wazuh API admin login (such as wazuh-wui on 4.x or wazuh on 5.0), the indexer admin login, and a shell with curl and python3 that can reach both
NetworkThe manager API (port 55000) and the indexer (port 9200) reachable from the internet over HTTPS
Collected by defaultAlerts, every minute. Agents, local accounts, vulnerabilities, and configuration checks, every 6 hours. Archives (4.x) or All events (5.0) can be switched on

Wazuh connects with two users and two addresses. Jutsu signs in to the manager API to read your agents and their inventory, and to the indexer to read alerts, events, and the state Wazuh keeps for each agent. You create both users with a few commands, give Jutsu the addresses, and confirm each certificate. Jutsu pulls from Wazuh; there is no forwarder to run and no integration block to add to Wazuh. One connection covers one Wazuh deployment and every agent that reports to it.

Before you start

Make Wazuh reachable from the internet

Jutsu reads Wazuh from the cloud, so both addresses have to answer on the internet over HTTPS.

  • Manager API: port 55000 by default, such as https://wazuh.example.com:55000.
  • Indexer: port 9200 by default, such as https://wazuh.example.com:9200.

Jutsu has no fixed address yet, so a firewall rule that only lets known addresses in can't name Jutsu. Expose the two ports with the read-only users below, or use Wazuh Cloud. Jutsu refuses private and reserved addresses, such as 10.x, 192.168.x, or 127.0.0.1, even when they would work from inside your network.

Is the indexer listening only on localhost? The all-in-one installer sets the indexer to 127.0.0.1, so the manager and the dashboard can reach it but nothing outside can. On the indexer, run ss -tlnp | grep 9200. If it shows 127.0.0.1:9200 (or [::ffff:127.0.0.1]:9200), change network.host in /etc/wazuh-indexer/opensearch.yml to an address the internet can reach, then restart the indexer with systemctl restart wazuh-indexer. Check that the dashboard and Filebeat still connect afterwards.

Figure 1. An all-in-one install: the indexer listens on 127.0.0.1 only, so Jutsu can't reach it yet.

Keep the admin passwords strong: Exposing the ports exposes the sign-in pages too. Jutsu only ever uses the read-only users you create below, but anyone can try a password on these ports. Change Wazuh's default passwords if you haven't, and keep the admin logins out of shared places.

Turn on what you want Jutsu to see

These are optional. Jutsu connects without them and tells you on the connection page which ones are off.

Wazuh featureWhat Jutsu does with itHow to turn it on
Vulnerability detectionLists each host's open vulnerabilities and runs the vulnerability compliance checksOn by default since Wazuh 4.8. If it's off, set <enabled>yes</enabled> in the <vulnerability-detection> block of /var/ossec/etc/ossec.conf on the manager, then restart the manager
Archives (4.x)Collects every event Wazuh sees, not only the ones its rules matchedOn the manager, set <logall_json>yes</logall_json> in the <global> block of ossec.conf and restart the manager. Then set archives: enabled: true in /etc/filebeat/filebeat.yml and restart Filebeat
Local accountsLists each agent's local accounts under PeopleNeeds Wazuh 4.14 or 5.0. Older 4.x versions don't report them

Set up Wazuh

Create two users in Wazuh that can read and nothing else. Run the commands below in a shell that can reach your manager and indexer, as someone who administers them. The Jutsu dialog shows the same commands with your addresses already filled in, on its Users step. You can start the dialog first (Connect it in Jutsu below) and copy them from there.

Each user needs a password of 12 to 64 characters, with upper- and lower-case letters, a number, and a symbol. Use one of . * + ? or - for the symbol. Other symbols can break the quoting in the commands. Don't build it from the user name: the indexer refuses a password that's similar to its user, such as one containing jutsu-reader.

Step 1 - Create the manager API read user

This creates jutsu-read and gives it Wazuh's built-in readonly role. It reads agents, their inventory, and the manager's information.

Replace each <…> first: your manager's address on the first line, an API admin and its password on the second, and the new user's password on the fourth.

WAZUH_API='https://wazuh.example.com:55000'
ADMIN_TOKEN=$(curl -sk -u '<an API admin, such as wazuh-wui on 4.x or wazuh on 5.0>:<its password>' -X POST "$WAZUH_API/security/user/authenticate?raw=true")
api() { curl -sk -H "Authorization: Bearer $ADMIN_TOKEN" -H 'Content-Type: application/json' "$@"; }
USER_ID=$(api -X POST "$WAZUH_API/security/users" -d '{"username":"jutsu-read","password":"<password for jutsu-read>"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["affected_items"][0]["id"])')
ROLE_ID=$(api "$WAZUH_API/security/roles?search=readonly&select=id,name" | python3 -c 'import sys,json; print([r["id"] for r in json.load(sys.stdin)["data"]["affected_items"] if r["name"]=="readonly"][0])')
api -X POST "$WAZUH_API/security/users/$USER_ID/roles?role_ids=$ROLE_ID"

The last command prints Wazuh's answer. "total_affected_items": 1 means the role was given.

Figure 2. The commands run on a Wazuh 4.14 manager. "total_affected_items": 1 means jutsu-read has the readonly role.

Step 2 - Create the indexer read user

This creates the jutsu_read role, the jutsu-reader user, and the mapping between them. The role reads Wazuh's own alert, event, and state indices and nothing else. It names the index patterns of both Wazuh 4.x and 5.0, so it keeps working after an upgrade.

Replace each <…> first: your indexer's address, the indexer admin and its password, and the new user's password.

WAZUH_INDEXER='https://wazuh.example.com:9200'
idx() { curl -sk -u '<indexer admin user>:<its password>' -H 'Content-Type: application/json' "$@"; }
idx -X PUT "$WAZUH_INDEXER/_plugins/_security/api/roles/jutsu_read" -d '{"cluster_permissions":["cluster_composite_ops_ro","cluster:monitor/main"],"index_permissions":[{"index_patterns":["wazuh-alerts-4.x-*","wazuh-archives-4.x-*","wazuh-states-*","wazuh-findings-v5-*","wazuh-events-v5-*",".ds-wazuh-findings-v5-*",".ds-wazuh-events-v5-*"],"allowed_actions":["read","indices:monitor/settings/get"]}]}'
idx -X PUT "$WAZUH_INDEXER/_plugins/_security/api/internalusers/jutsu-reader" -d '{"password":"<password for jutsu-reader>","backend_roles":[]}'
idx -X PUT "$WAZUH_INDEXER/_plugins/_security/api/rolesmapping/jutsu_read" -d '{"users":["jutsu-reader"]}'

Each command answers with "status":"CREATED" (or "OK" if you run it again). If the second one answers Password is similar to user name, choose a password that doesn't contain the user name and run that command again.

Figure 3. The three indexer commands, each answering "status":"CREATED".

Why curl -k? Wazuh signs its own certificates, so curl can't check them without -k. That only applies to these commands, which run against your own Wazuh. Jutsu itself never skips the certificate check. You confirm each certificate in the dialog.

Don't use an admin user instead: Jutsu refuses a manager API user that can manage Wazuh users, and an indexer user that holds an admin role, can write, or can read indices other than Wazuh's. A broader login stored in Jutsu would be a bigger risk than the connection needs.

Can't run the indexer commands? The indexer admin is usually admin. Its password is in wazuh-passwords.txt, inside the wazuh-install-files.tar the installer left on the server, unless someone changed it since. Run the commands on the indexer itself and use https://127.0.0.1:9200 as the address if port 9200 isn't reachable from your shell yet.

Check the users (optional)

You can see both users in the Wazuh dashboard. Under Server management → Security → Users, jutsu-read has the readonly role and can't run as another user.

Figure 4. The manager API's users: jutsu-read with Wazuh's readonly role.

Under Indexer management → Security → Internal users, search for jutsu-reader. Under Roles, open jutsu_read: its index permissions are read on Wazuh's own indices and nothing else.

Figure 5. The indexer's internal user jutsu-reader.

Figure 6. The jutsu_read role: read-only cluster permissions, and read on Wazuh's alert, archive and state indices.

Connect it in Jutsu

Step 1 - Open Integrations

Go to app.jutsu.ai and select Integrations in the left navigation. It sits under More. The Data Sources tab opens by default.

Figure 7. Open Integrations. Data Sources is selected.

Step 2 - Select the Wazuh card

In the Endpoint section, select the Wazuh card. The Connect Wazuh dialog opens, with seven numbered steps across the top: Addresses, Users, Logins, Certificates, Test, Collect, Done. The name of the step you're on shows beside its number. Nothing is stored until the last step.

Figure 8. Select the Wazuh card in the Endpoint section.

The card doesn't open? Adding integrations needs the Owner or Admin role in your Jutsu organization. For Analysts, Responders, and Viewers the catalog is read-only.

Step 3 - Addresses

Fill in the two addresses:

  • Manager API address: such as https://wazuh.example.com:55000.
  • Indexer address: such as https://wazuh.example.com:9200.

Each one is an https address with no path. Any port works. Select Continue.

Figure 9. Fill in both addresses, then select Continue.

Step 4 - Users

The dialog shows the commands from Set up Wazuh above, with your two addresses filled in. If you haven't created the users yet, copy the commands from here and run them. Then select Continue.

Figure 10. The commands that create the two read-only users, with your addresses filled in.

Step 5 - Logins

Fill in the form:

  • Connection name: something that identifies the deployment, such as Acme — Wazuh.
  • Manager API user: jutsu-read, already filled in.
  • Manager API password: the password you gave jutsu-read.
  • Indexer user: jutsu-reader, already filled in.
  • Indexer password: the password you gave jutsu-reader.

Jutsu stores the passwords encrypted and uses them only to read. Select Continue. Jutsu asks your Wazuh for its certificates.

Figure 11. Name the connection and fill in both passwords, then select Continue.

Step 6 - Certificates

Wazuh signs its own certificates, so Jutsu shows you each one and asks how to trust it. There is a panel for the Manager API certificate and one for the Indexer certificate. Each lists the certificate's Subject, Issuer, Valid until, Names, and SHA-256 fingerprint, and offers up to three choices:

ChoiceWhen to use it
Pin this certificateWazuh's own certificate, when the server sends a certificate that signs itself. Recommended. Jutsu trusts exactly this certificate and stops if it ever changes. Offered only when the certificate can be pinned, and then chosen by default
Trust Wazuh's root CAWazuh's own certificate, when the server sends it without the certificate that signed it. Jutsu accepts any certificate your root CA signs. You paste root-ca.pem
Normal verificationA certificate from a public authority, such as Let's Encrypt

On a default install the two panels usually differ:

  • Manager API: Wazuh's API certificate signs itself, so Pin this certificate is offered and chosen.
  • Indexer: the indexer sends its certificate without the root CA, so it can't be pinned. Pin this certificate isn't offered, and Trust Wazuh's root CA is chosen for you.

To pin a certificate, run the command the panel shows on a machine that reaches Wazuh the same way Jutsu does. It looks like this:

openssl s_client -connect wazuh.example.com:55000 -servername wazuh.example.com </dev/null 2>/dev/null | openssl x509 -noout -fingerprint -sha256

It must print the same fingerprint as the panel. You can paste what it printed into the box under the command, and Jutsu compares the two for you. Then tick The fingerprint is the one my command printed. Pin this certificate.

Figure 12. The manager API certificate, pinned. Tick the box once the fingerprints match.

Danger: If the fingerprints don't match, stop. Something may sit between Jutsu and your Wazuh, or the address isn't yours. Jutsu says so too, and won't continue with that fingerprint.

To trust the root CA, paste the contents of Wazuh's root-ca.pem into the box, including the -----BEGIN CERTIFICATE----- and -----END CERTIFICATE----- lines. On the indexer it is at /etc/wazuh-indexer/certs/root-ca.pem:

sudo cat /etc/wazuh-indexer/certs/root-ca.pem

If the certificate was made for a different name than the address you typed, a box appears: The names differ. This certificate lists …, not …. Wazuh makes its certificates for its node names, such as wazuh-indexer or 127.0.0.1, so this is normal for them. Tick it.

Select Test connection. Jutsu signs in to the manager API and the indexer. Nothing is stored yet.

Figure 13. The indexer certificate, trusted through your root CA, with the names-differ box ticked. Then select Test connection.

Step 7 - Test

Jutsu shows the version it found, such as Signed in to Wazuh 4.14.5., and one row for each thing it can read:

RowWhat a good result says
AlertsThe alerts index is readable. (on 5.0, Findings and events are readable.)
All eventsReadable. If it says Wazuh is not writing them, archives are off. That's fine unless you want them
VulnerabilitiesPer-host vulnerabilities are readable.
PeopleLocal accounts on each agent are readable. On 4.8 to 4.13 it says Local accounts need Wazuh 4.14.
Configuration checksRead through the manager API. (on 5.0, CIS benchmark results are readable.)
Read-onlyNeither user can change anything in Wazuh.

A row marked for attention says what to fix. A row that's off means Wazuh doesn't have that feature turned on. See Turn on what you want Jutsu to see above. Select Continue.

Figure 14. Every check passed. Select Continue.

Wazuh 5.0: Jutsu supports 5.0 as a release candidate and says so on this step. What it reads from 5.0 is checked again against Wazuh's final release.

Step 8 - Collect

Choose what to collect:

  • Alerts: always on. On 4.x, what Wazuh's rules matched. On 5.0, Wazuh's findings, and the logins and account changes it records as events.
  • Archives (4.x) or All events (5.0): every event Wazuh sees, not only what its rules matched. Off by default. You can only tick it if Wazuh writes them.
  • Lowest level to collect: keep All events (info), the default, so Jutsu sees everything Wazuh alerts on. You can choose Low and above, Medium and above, High and above, or Critical only instead. Logins and account changes are always collected, whatever you choose, because the detection rules need them.
  • Run compliance checks: keep it ticked. Jutsu checks your Wazuh agents every day for your compliance tasks, using the same read-only logins. It's offered on plans that include compliance.

Warning: Archives and All events can be many times the size of your alerts: every log line each agent sends is one event. They count towards your plan's daily ingest. Switch them on only if you need every event in Jutsu, and watch the 24-hour count afterwards.

Select Connect Wazuh. Jutsu runs the whole test again before it saves anything.

Figure 15. Keep Alerts ticked, the lowest level at All events (info), and Run compliance checks ticked, then select Connect Wazuh.

Step 9 - Done

Jutsu saves the connection and takes you to Connections. It reads alerts every minute, and lists your agents, their local accounts, and their vulnerabilities after the first scan.

If you started from the Connect button on the Connections page instead, the dialog stays open on Done, says Connected., and offers Open connection.

Find the connection

Jutsu adds the connection to Connections, under Custom.

Figure 16. The connection is listed under Custom.

Verify the connection

Open the connection. The badge beside its name shows its health, such as Healthy · Roles in place after a check that passed. Its Overview tab has three parts:

  • What Jutsu reads: one sentence, such as Wazuh is connected. 4 of 4 agents are active., and the time of the last check.
  • What Jutsu does with it: each part of the connection with its own status: Alerts, All events, Agents, accounts and configuration, Vulnerabilities, Compliance checks, and Response. Each one is Working, Needs attention, Not turned on in Wazuh, Paused, or Not set up. Not turned on in Wazuh is not an error. It means that Wazuh feature is off.
  • Operational snapshot: the Agents and how many report, the Version, how Collection is going, and the Last check.

Figure 17. A healthy connection: every agent active and every part working. All events is Paused because it's turned off in Settings.

Open Configure → Health for the details. Sign-in says whether Jutsu could sign in on the last check:

Sign-inMeaning
WorkingJutsu can sign in and read everything you chose
Needs attentionJutsu is connected, and something needs a look. The page says what
Cannot sign inJutsu couldn't sign in on the last check
CheckingThe first check is running
Not checked yetThe first check hasn't run. Select Check again to start it

The same tab shows how each Certificate is trusted, with Review certificates, how Collection is going, the reason for each Capability, and the Compliance checks switch.

Figure 18. Configure → Health. Turn off stops the compliance checks on this connection.

Open Configure → Settings for the technical facts: Version, the Manager API and Indexer addresses, the two users, how each certificate is trusted (such as Pinned to 3f9a51c07be2… or Your root CA (names differ)), the last and next check, and when you connected. Replace passwords and Review certificates are at the top.

Figure 19. Configure → Settings: the connection's facts, and what Jutsu collects.

Quiet is normal at first: On its first read Jutsu collects the last 24 hours of alerts, not your whole history. Agents, accounts, vulnerabilities, and configuration checks appear after the first scan, which starts when you connect and then runs every 6 hours. Jutsu checks the connection's health within about 10 minutes, then once a day. Select Check again to check it straight away after any change in Wazuh.

What healthy looks like

BadgeHealthy · Roles in place
SentenceWazuh is connected. N of N agents are active.
CollectionCollecting, last read a minute or so ago
AgentsN of N active, All reporting
AlertsWorking
Agents, accounts and configurationWorking
VulnerabilitiesWorking, or Not turned on in Wazuh if vulnerability detection is off
VersionThe version you run, such as Wazuh 4.14.5

What Jutsu does with your Wazuh data

Alerts and detections

Jutsu reads Wazuh's alerts every minute. Each Wazuh rule level becomes a Jutsu severity:

Wazuh rule levelJutsu severity
0 to 3Info
4 to 6Low
7 to 11Medium
12 to 14High
15 and 16Critical

Jutsu then checks the alerts with 16 Wazuh rules of its own. Wazuh alert (critical) and Wazuh alert (high) raise a Jutsu alert for each critical and high Wazuh alert. Wazuh alert (medium) is off by default. The rest look across your agents for patterns that one Wazuh alert doesn't show:

  • Failed logins, then a login from the same source.
  • A password spray from one source.
  • One source attacking many hosts.
  • A local account created, or an account added to an admin group.
  • A critical file changed.
  • A rootkit or trojan signal, or malware found.
  • Security logging stopped or cleared.
  • An agent that went silent.
  • An attack followed by an account change.
  • A critical vulnerability detected.
  • A web attack that succeeded.

The connection's Events tab shows what Jutsu collected.

Inventory

The connection's Inventory menu has four lists:

  • Agents: each Wazuh agent as a machine, with its status, system, CIS score and open vulnerabilities. Open one for its packages, ports, and processes, read live from Wazuh.
  • People: the local accounts on each agent (Wazuh 4.14 and 5.0).
  • Vulnerabilities: each host's open vulnerabilities.
  • Configuration checks: the CIS benchmark checks each host failed.

Figure 20. Inventory → Agents: each Wazuh agent with its system, CIS score and open vulnerabilities.

An empty list is not proof that the hosts are clean: It can also mean Wazuh hasn't scanned them yet, or the feature is off in Wazuh. The connection's capability rows say which.

Compliance checks

With Run compliance checks on, Jutsu checks your agents every day for your compliance tasks:

  • Every Wazuh agent is reporting.
  • No Wazuh agent has stayed never connected for 7 days.
  • Every Wazuh agent runs the manager's version.
  • Vulnerability detection is on in the Wazuh manager.
  • No critical vulnerability stays open on a host for more than 30 days.
  • No high vulnerability stays open on a host for more than 90 days.
  • Every host meets the configuration baseline score.
  • File integrity monitoring has scanned every host in the last 48 hours.
  • Every host is protected by an active agent that scans for rootkits.

There's nothing extra to set up. To turn the checks on or off later, use Compliance checks under the connection's Configure → Health.

Choose what to collect

Under Configure → Settings → Collection you can change what Jutsu collects. Changes apply from the next read, and nothing already collected is removed.

  • Pause collection stops reading Wazuh until you select Resume collection. What is already in Jutsu stays.
  • What to collect switches Archives (4.x) or All events (5.0) on or off. At least one stays on. To stop everything, pause collection.
  • Minimum severity sets the lowest severity Jutsu collects. Logins and account changes are always collected.

Response actions

Jutsu can act on a compromised host or account through Wazuh. Response uses a separate Wazuh API user, never the read-only one, so removing it never stops collection.

ActionWazuh 4.xWazuh 5.0
Block IP on the hostYesNot yet
Lock a local account (Linux)YesNot yet
Isolate the hostYes, with the jutsu-respond scriptNot yet
Restart the Wazuh agentYesYes
Rescan the hostYesYes

Step 1 - Create the response user

Open the connection, go to Configure → Settings → Response actions, and select Arm responses with a response user. The form lists the rights the user needs and prints the commands for the Wazuh version you run. On 4.x they look like this:

WAZUH_API='https://wazuh.example.com:55000'
ADMIN_TOKEN=$(curl -sk -u '<wazuh-wui or another API admin>:<its password>' -X POST "$WAZUH_API/security/user/authenticate?raw=true")
api() { curl -sk -H "Authorization: Bearer $ADMIN_TOKEN" -H 'Content-Type: application/json' "$@"; }
POLICY_ID=$(api -X POST "$WAZUH_API/security/policies" -d '{"name":"jutsu_respond","policy":{"actions":["active-response:command","agent:restart","syscheck:run","rootcheck:run","agent:read"],"resources":["agent:id:*"],"effect":"allow"}}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["affected_items"][0]["id"])')
ROLE_ID=$(api -X POST "$WAZUH_API/security/roles" -d '{"name":"jutsu_respond"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["affected_items"][0]["id"])')
api -X POST "$WAZUH_API/security/roles/$ROLE_ID/policies?policy_ids=$POLICY_ID"
USER_ID=$(api -X POST "$WAZUH_API/security/users" -d '{"username":"jutsu-respond","password":"<password for jutsu-respond>"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["affected_items"][0]["id"])')
api -X POST "$WAZUH_API/security/users/$USER_ID/roles?role_ids=$ROLE_ID"

On 5.0 the policy's actions are agent:restart, agent:scan_vulnerability, and agent:read. Copy the 5.0 commands from the connection page and don't change them: Wazuh 5.0 accepts a policy that names an action it doesn't know, then ignores the whole policy.

Limit it to some agents: The policy covers every agent (agent:id:*). To let Jutsu act only on one group, replace agent:id:* with agent:group:<group> before you run the commands.

Step 2 - Add it to the connection

Under the commands in the same form, fill in Response API user (jutsu-respond) and Response API password, then select Verify & save. Jutsu signs in as the user and reads its policies before it stores the password. It refuses a user with no rights.

Figure 21. Fill in the response user, then select Verify & save.

On 5.0 the form also has Indexer writer user (optional) and Indexer writer password (optional). Leave them empty. They're only needed when block, disable, and isolate arrive on 5.0.

Step 3 - Add the timed responses to the manager (4.x)

Block IP and Lock a local account use Wazuh's own active responses, which Wazuh ends after 24 hours. Open Timed responses on the manager in the same block. It shows these lines. Add them to /var/ossec/etc/ossec.conf on the manager, then restart the manager:

<ossec_config>
  <!-- Jutsu response: callable from the API only. Level 16 is never reached by stock rules. -->
  <active-response><command>firewall-drop</command><location>local</location><level>16</level><timeout>86400</timeout></active-response>
  <active-response><command>netsh</command><location>local</location><level>16</level><timeout>86400</timeout></active-response>
  <active-response><command>disable-account</command><location>local</location><level>16</level><timeout>86400</timeout></active-response>
</ossec_config>

They run only when Jutsu calls them. Level 16 is never reached by Wazuh's own rules.

To isolate a host, or to lift a block or a lock before the 24 hours are up, install The Jutsu response script (optional) on each agent where Jutsu should do that. Download it from the same block: jutsu-respond for Linux, and jutsu-respond.cmd with jutsu-respond.ps1 for Windows. On a Linux agent, install it as root:

install -o root -g wazuh -m 750 jutsu-respond /var/ossec/active-response/bin/jutsu-respond

On a Windows agent, copy both files from a Command Prompt run as administrator:

copy jutsu-respond.cmd jutsu-respond.ps1 "C:\Program Files (x86)\ossec-agent\active-response\bin\"

Without the script, Jutsu doesn't offer isolation, and a block or a lock lasts until Wazuh's timer ends it. The script never touches the host's other firewall rules.

Emergency release: If an isolated host can't be reached from Jutsu, run /var/ossec/active-response/bin/jutsu-respond release-all at the host's console (on Windows, jutsu-respond.cmd release-all in the same folder). It removes every rule Jutsu added, and on Linux unlocks every account Jutsu locked.

Step 4 - Allow the actions

Each action has to be turned on for your organization before anyone can use it. Go to Organization → Action policy and turn on the Wazuh actions you want. An Analyst proposes an action from an alert. A Responder or above approves it, and by default the approver can't be the person who proposed it.

Built-in safeguards: Jutsu never acts on the Wazuh manager itself. Block IP refuses private addresses, the manager's address, the agent's own address, and Jutsu's addresses. Lock a local account refuses root, wazuh, ossec, and any account with uid 0.

Troubleshooting

Message or symptomWhat to do
The Wazuh card doesn't openYou need the Owner or Admin role in the Jutsu organization.
An https address with no path, for example https://wazuh.example.com:55000.Type the address as https://, the host, and the port, with nothing after it.
Password is similar to user name (from the indexer, while you create jutsu-reader)The indexer refuses a password that resembles the user name. Choose one without the user name in it and run the internalusers command again.
Jutsu does not connect to that addressThe address is private, reserved, or not on the internet. Expose the manager API and the indexer on a public address, or use Wazuh Cloud.
Wazuh did not answerThe manager or the indexer is down, or a firewall is in the way. Check both addresses, and that ports 55000 and 9200 (or yours) are open to the internet. On an all-in-one install, check that the indexer doesn't listen on 127.0.0.1 only.
This certificate chain cannot be pinned. Give Wazuh's root-ca.pem instead.The server sends its certificate without the one that signed it. Choose Trust Wazuh's root CA and paste root-ca.pem.
The certificate is not for this address.Tick The names differ. Wazuh's certificates are made for node names.
The fingerprint you pasted is not the one Jutsu saw.Stop. Check the address, and run the command from a machine that reaches Wazuh the way Jutsu does. If they still differ, something is between Jutsu and Wazuh.
The manager API no longer accepts Jutsu's user or The indexer no longer accepts Jutsu's userThe password was changed or the user was removed. Use Replace passwords under Configure → Settings. Jutsu tries the new password before it saves it.
The manager API user can manage Wazuh users or The indexer user holds an administrator roleYou connected with an admin. Create the read-only users with the commands above and use Replace passwords.
The indexer user can write or The indexer user can read more than Wazuh's own dataThe indexer user's role is broader than jutsu_read. Map the user to jutsu_read only.
The manager API user is missing a right Jutsu needs or The manager API user has no rightsGive the user Wazuh's readonly role, or create it again with the commands above without changing them.
The indexer user cannot read Wazuh's alertsThe role doesn't cover the alert or event indices. Run the jutsu_read role command from Step 2 again.
The manager writes no archives.You ticked Archives, but Wazuh doesn't write them. Turn on logall_json and the archives index in Wazuh (see Turn on what you want Jutsu to see), or connect without archives.
Wazuh presents a different certificate than the one you confirmedThe certificate was renewed or replaced, and Jutsu stopped reading until you look at it. Select Review new certificate, check the fingerprint, and confirm it if it's yours.
This Wazuh is older than Jutsu supportsJutsu reads Wazuh 4.8 and newer. Upgrade Wazuh.
Wazuh is limiting how often Jutsu can readWazuh's API allows 300 requests a minute by default, shared with your own dashboard. Nothing needs changing. Jutsu reads again shortly.
This workspace has reached its plan's limit on connections.Archive a connection you no longer use, or upgrade the plan.
People is empty on Wazuh 4.8 to 4.13Wazuh reports local accounts from 4.14. Upgrade Wazuh to see them.
Connected, but no alertsCheck Minimum severity before you assume Wazuh was quiet, and that your agents report. The Agents count on the Overview shows how many are disconnected.

Security and access

  • Jutsu only reads with the two users you created. The manager API user has Wazuh's readonly role. The indexer user reads Wazuh's own indices and nothing else. Jutsu checks both on every test, and refuses a user that can do more.
  • The passwords are encrypted at rest and never shown again.
  • Jutsu never turns certificate checks off. A pinned certificate that changes stops collection until you confirm the new one.
  • Response actions use a separate user, limited to the actions above and, if you choose, to one agent group. Revoking it never affects collection.
  • Exposing the manager API and the indexer to the internet exposes their sign-in pages too. Keep Wazuh's admin passwords strong.

Remove the connection

Removing it takes two parts: archive the connection in Jutsu, then delete Jutsu's users in Wazuh. Archiving doesn't touch your Wazuh.

  1. In Jutsu, open the connection and go to Configure → Danger zone. Disable stops reading Wazuh until you enable it again. Archive integration stops Jutsu reading Wazuh and frees the plan slot. Events and alerts already collected stay. Delete asset removes the connection and what it collected, for good.
  2. In Wazuh, delete the users and roles Jutsu was given. When you select Archive integration, the confirmation shows the exact commands, and the connection shows them again once it's archived: the jutsu-read and jutsu-respond API users, the jutsu_respond role and policy, the jutsu-reader indexer user, and the jutsu_read role and its mapping. If you added the timed responses, remove those three <active-response> blocks from ossec.conf and restart the manager.

Figure 22. The connection's Danger zone.

Figure 23. Archiving shows the commands that remove Jutsu's users and roles from Wazuh, each with Copy commands.