Skip to content

Security and data handling

This page is for the people who approve software before it goes on a production search head: security architects, risk and procurement teams, and the Splunk platform owner. It says what runs where, what leaves your network and when, what is stored, who can read it, and how to turn each part off. Every statement here is checked by the tests that ship with the product (tools/test_trust.py and the browser suite), and the last section lists what is not covered.

What runs where

Part Where it runs What it does
The Vyrux app Your search head, inside Splunk The screens, the Vyrux service (a Splunk REST handler), the background scan, and the API collector input
The screens Each person's browser Read Splunk through Splunk Web, with that person's own session
The Vyrux service splunkd on the search head Checks who is asking, hands each person the records their roles allow, checks and stamps every write, masks and sends AI requests
The background scan splunkd, started by Splunk's scheduler every 15 minutes Checks logs, rules and forwarders with nobody signed in, opens and closes issues, sends alerts
API collectors The search head or a heavy forwarder Read the REST APIs a Vyrux admin set up
The Vyrux AI and licence service Outside your network, at the address shown under Admin, AI Answers AI requests, issues and checks licences, takes payment through Stripe

Nothing is installed on indexers or universal forwarders.

What leaves your network, and when

Vyrux makes five kinds of outbound connection. Each one is HTTPS on port 443 with the certificate checked, through your proxy if you set one.

What When What is sent How to turn it off
An AI request Only when a person asks Chuka for something: a button such as Explain, Fix, Draft, Identify this log with Chuka, or a question in Ask Chuka. Never when a page opens, and never from the background scan The task, the rule text or question, field names, and, if sample events are on, a few events. Secrets in every shape listed below are removed first. User names, emails, IP addresses and host names are replaced with placeholders unless an admin turned that off. This server's ID and the activation code go in the request headers Admin, AI, Use AI. Or do not add an activation code
The licence check Once an hour from the background scan, and when an admin opens Admin, Licence or Admin, AI. Only when an activation code is present The activation code, the ID the licence is tied to (the Splunk server GUID of the first search head Vyrux ran on) and this search head's own GUID. Nothing about your data, logs, rules or people Remove the activation code. Vyrux then runs as a trial or as expired, with no outbound call
Buying a plan When an admin starts a purchase under Admin, Licence The email the admin types and the server ID. Card details go from the admin's browser to Stripe and never pass through Splunk Do not buy in the product; ask for an activation code instead
A problem report or a feature request Only when a person fills in the form under the menu, reads what will be sent and selects Send report What the person typed (type, title, description, steps, how much it matters, an optional contact email, whether Vyrux may reply), and seven details shown before sending: the page as a route, the Vyrux build and version, the Splunk version, the kind of deployment, the browser, and the licence as plan, state and a fingerprint of the activation code. The Splunk server ID goes in a request header. No event, search result or field value. Values that look like secrets are removed from the text first Do not send one. Nothing is sent unless a person does
Connectors and API collectors When an alert is due, when a person creates a ticket, and when a collector runs To Jira, ServiceNow, Teams, Slack: the alert title and one line of text. To a collector's source: the request the collector spec describes Admin, Integrations and API Studio. None is set up by default

Email alerts go through Splunk's own mail settings and are sent by Splunk.

Nothing else leaves. A search head with no route to the internet runs everything except Chuka and online purchase.

What is removed from an AI request

Always, whatever the settings:

  • The value of any key whose name contains secret, passw, pwd, pass, token, apikey, api_key, access_key, private_key, credential, auth (not authentication), session, cookie, ssn, iban, passport, national_id, routing or account_number, or the password word in another language (kennwort, passwort, senha, contraseña, mot_de_passe, wachtwoord, parola, salasana, hasło, lösenord, heslo, jelszó, şifre, пароль, 密码, パスワード, 비밀번호), or is pin, otp, psk, key, pw, mdp, clave or community as a whole word (wifi_psk, sms.otp, db_pw), written as key=value, key: value, in JSON (including values with spaces, and JSON inside a JSON text), as an XML element or attribute, or in a URL query string, URL-encoded (password%3D...) included. A value runs to the next field, so a password that holds &, ; or , is removed whole. A setting written as a name and a value (<add key="DbPassword" value="..."/>, {"Name": "db_password", "Value": "..."}) and a secret key followed by a space and a token with a digit (dd_api_key 9f8e...) count too.
  • The whole value of an Authorization, Proxy-Authorization, Cookie or Set-Cookie header, whatever the scheme.
  • The user name and password in an address such as https://user:password@host.
  • Tokens that are secrets wherever they stand: AWS access key IDs (AKIA, ASIA) and 40 character secret keys, Slack xox tokens, GitHub ghp_, gho_, ghs_, ghu_, ghr_ and github_pat_ tokens, GitLab glpat- tokens, Stripe sk_ and rk_ keys, live and test, sk- keys, Google AIza keys, JSON Web Tokens, private key blocks of any kind (PEM, OpenSSH, PGP and PuTTY key files, and a block cut off before its end), password hashes (pwdump and secretsdump lines, NetNTLM responses, /etc/shadow crypt hashes, Kerberos roasting output), Slack, Teams, Discord and Zapier webhook addresses, any other run of 20 to 64 letters and digits that reads as a random key (capitals, small letters and digits mixed through it; a hash in hex, a GUID or a word is left), and Azure AccountKey, SharedAccessKey and signature values.
  • Every value of a field with such a name when field values are sent as a list, as the Validator and field fixes send them ({"name": "password", "values": [...]}): a bare value has no shape to know it by, so the field's name decides.
  • A CEF custom string whose label names a secret (cs1=... cs1Label=Password), and a password written in words (password is ..., password changed to ...).
  • Payment card numbers of 13 to 19 digits that have a valid card prefix and pass the check digit test, international bank account numbers that pass their check, US social security numbers, and Canadian social insurance numbers that pass their check digit.
  • A number under a secret key in JSON ("pin": 4321). The JSON stays valid.
  • Passwords on command lines: after any switch that names one (--password, --password=, -pw, -pass, --passwd, --token, --api-key, --client-secret, /pass:, /RP, -Password), -P (sqlcmd, osql, bcp), -p in the tools that use it for a password (psexec and the other Impacket tools, sshpass, mongo, hydra, crackmapexec, evil-winrm, rdesktop and others), redis-cli -a, ldapsearch -w, smbclient -U name%password, net user name password, net use \\server\share password, curl -u name:password, mysql -ppassword, ConvertTo-SecureString "password". A short number after -p or -P is a port and stays.
  • The whole rest of the line after Password:, pwd:, pw: or the word in another language, and a quoted value after the word (with password 'x').
  • Bank account and routing numbers named as such (acct 000123456789, routing 021000021, sort code 12-34-56).

On unless a Vyrux admin turns it off under Admin, AI:

  • Email addresses, telephone numbers, IPv4 and IPv6 addresses (the short fe80::1 form included) and MAC addresses.
  • Host names with a common ending (db1.bank.local), the host in a syslog header (Nov 16 10:00:01 fw-core-01 sshd[1]:, RFC 5424 too), and the value after a key that names a machine: host, hostname, ComputerName, Workstation Name, identHostName, dvc, shost, dhost and any key ending in host. After src, dest, client and server, a value is masked when it reads as a machine (WS-0042, DC01); an address there is masked as an address.
  • Windows DOMAIN\name accounts in any case, the user in an AWS ARN (user/alice, an assumed-role session), the user in an sshd or PAM line (Failed password for jsmith), and the value after a key that names a person: any key that holds user or usr (not user_agent), and uid, login, logon, account, acct, principal, actor, upn, samaccountname, owner, requester, initiator, displayName, full_name, first_name, last_name, surname. A value in quotes is masked whole, spaces included (user="John Smith").
  • CEF and LEEF extensions, each value judged by its key: suser=John Smith is masked whole, and usrName and identHostName in LEEF.
  • JSON, whole or after a header, each value judged by its key and the key above it: {"user": {"name": "alice"}}, {"host": {"name": "WS-7"}}, Okta actor.displayName, and JSON inside a JSON text. The JSON keeps its layout.
  • Shapes that read as a person or a machine wherever they stand in log text or a question: first.last names (emily.sun), service accounts (svc_deploy14, sa_backup), and machine names with a digit (TELLER-05, fw-core-01, DC01). These are not read in a search, a regular expression or a field setting, and they leave ATT&CK ids (TA0001, T1059), CVE ids, hash names (SHA256), field names (event.action) and file names (config.json) alone.
  • Delimited logs with no field names (pipe, comma, tab, semicolon): when one value in a column reads as a person or a machine, every value in that column of the sample is masked, so jsmith beside emily.sun is masked too.
  • Every value of a field with a person or machine name (user, user.name, dest, src, ComputerName) sent as a list or as a map of values to counts, and a Windows XML <Data Name="TargetUserName"> element.

This is on for a new install and for an install that never chose.

Not recognised: a person's full name in a sentence with no key in front of it (approved by Jane Doe), a one-word user name such as jsmith on its own line with no key, column or shape to know it by, and a key in hex (32 or 64 characters) with no key name in front of it, which reads exactly like a file hash that an investigation needs. To send no event text at all, turn off Send sample events.

Each removed value becomes a placeholder such as VYRUX_SECRET_1. The real value stays on your server and is put back in the reply. One path sends to the AI service, in bin/vyrux_ai_handler.py, and the masker is on it.

Not removed: ordinary words, field names, sourcetype and index names, and the names of CIM data models in front of a field (Authentication.action). A value after a key that merely contains one of the words above is removed even when it is harmless, for example eval is_auth=1. That is deliberate: Vyrux removes too much sooner than too little.

Limits: masking reads keys, formats and shapes. A secret in a shape nobody has described, such as a password in free text with no key or phrase in front of it, is not recognised, nor are the names listed under Not recognised above. To send no event text at all, turn off Send sample events.

The full text of every AI request, as it left Splunk, is kept and can be read under Admin, AI by the person who made it and by Vyrux admins.

What the AI service keeps

The Vyrux AI service runs the request on a third-party AI model provider under contract with Vyrux, and returns the answer. Ask your Vyrux contact for the provider and its data terms. The service keeps credit counts for each licence. It does not keep request or reply text, and it asks the model it uses not to keep them either. When Chuka speaks of itself it says it runs on the Vyrux AI service: a sentence that names the model or the company behind it is replaced, by the service and again by the Vyrux service on your search head before the reply is stored. A sentence about your data, a search or a code span is left alone, so a rule that looks for traffic to an AI company keeps working.

What a problem report holds, and where it is kept

The form is under the menu at the top right. The Vyrux service builds the report on your server, removes secrets from the free text with the same masker AI requests pass through (always-on kinds only: passwords, keys, tokens, cookies, card numbers), and shows the person the exact text before anything leaves. The page they were on is reduced to its route, so the name of a rule, a log or a host in the address is not sent. The activation code is never sent, only the first 16 characters of its SHA-256.

The report goes to the Vyrux AI and licence service, which stores it in its database and emails it to support@vyruxcorp.com. Vyrux support reads it there. It is kept until Vyrux removes it; ask support@vyruxcorp.com to delete a report, quoting its reference. In Splunk, the Vyrux service keeps one line for each report in vyrux_secure: the reference, who sent it, when, the type, the title, and whether it was sent. Members cannot list those lines. One person can send five reports an hour and twenty a day.

When the service cannot be reached, nothing is sent. The person is given the same text to copy and an email link, and sending it is then their own choice.

Whose permissions Vyrux uses

A person's own searches. Everything a person sees on a page that comes from a search is searched with that person's own Splunk session. Splunk applies their roles as it does in the Search app.

The Vyrux roles add no access to events. vyrux_user imports no other role and names no index. Its capabilities (search, get_metadata, get_typeahead, list_all_objects, rest_apps_view, rest_properties_get, rest_access_server_endpoints, change_own_password) are all in Splunk's own built-in user role, so it gives nothing a standard Splunk user lacks. vyrux_admin adds _audit and _internal and nothing else. A person searches only what their other roles allow. (Builds before 77 imported Splunk's user role into vyrux_user. Where user is set to search every index, as on many deployments, that gave every index to anyone with vyrux_user. It no longer does. After upgrading, a person who held only vyrux_user searches no index until one of their own roles names one.)

The background scan runs as the Splunk system, because it must run with nobody signed in, and so it reads every index. Three rules keep what it reads from reaching a person whose roles could not have read it:

  1. It keeps no event values. Host figures are host names, counts and times, read with tstats, which never opens an event. Field coverage is field names and counts; the values column is dropped inside the search. A rule proof keeps stage counts and field names, and when a value never matches it keeps how many values the field takes, not the values.
  2. Everything it stores is in KV store collections that only the Vyrux service and Splunk admins can read. No member reads them through Splunk's KV REST API.
  3. The service hands each person only records from indexes they can search. It works that out with the caller's own session (the indexes Splunk lists for them with | eventcount summarize=false index=* index=_*, limited to the ones their roles name) and keeps the answer for five minutes. A record about a log needs that log's index. A record about a rule needs every index the rule reads; when that cannot be told for certain (a wildcard, a data model, no index named) it needs every index on the deployment. If Splunk cannot say which indexes a person searches, they are treated as searching none.

Hosts. Host names come from every index, so they follow the same three rules. The scan keeps, for each silent host, its name, the log, when it was last seen and how long it may be quiet; for each log and index, counts; and a record of silences (host, log, when it stopped, when that was found, when it came back). At most 5,000 silent host rows, 500 new host rows and 3,000 silences are kept. A member gets the rows for indexes they can search. Totals for the whole estate, the 30 day trend and the day lines go only to people who search every index; anyone else's totals are read with their own session by the same search and kept for 15 minutes. A host issue names only the rules that person may see whole. Find a host and the Hosts tab of a log are the person's own searches. A maintenance window for a host can be planned only by someone whose own session finds that host in an index they can search.

One deliberate exception, which you can turn off. Run and alert counts for rules, forwarder and collector health, and HTTP Event Collector token names come from _internal, _audit and _introspection. Most analysts cannot search those. The service reads a fixed list of counting searches for them (bin/vyrux_history.json): names, counts and times, never an event, and nothing the person types is searched. Ingest volume by index and parsing warnings by sourcetype are narrowed to the indexes the person can search. Turn the whole exception off under Admin, Access: members then see no run or alert history unless their own roles can search those indexes.

Read-only checks

Vyrux runs searches it did not write: a rule's own search to prove it can fire, a dry run, a Tuning Lab replay, a draft or repair from Chuka, the breakdown on a rule's Firing tab, and the Validator's reads. The background scan runs rule proofs as the Splunk system.

Such a search is run only when every command in it is on an allow list of commands that read, filter and count. The list is one file, bin/vyrux_readonly.json, shown under Admin, Calibration. The check reads the search the way Splunk does:

  • Comments are taken out. Every macro is replaced by its definition, with its arguments filled in, until none is left.
  • The result is split at every pipe outside quoted text, and each part must start with a command on the list.
  • The same is done inside every pair of square brackets: subsearches, append, join, appendpipe, foreach, union, however deep.
  • When a search uses a macro, Splunk's own parser is also asked to read it, in the rule's own app, and the commands Splunk names go through the same list. Splunk's reading wins.

Anything the check cannot be sure of stops the search, and the person is told why in words:

  • A command that is not on the list. That includes every command that writes or sends (collect, outputlookup, outputcsv, delete, sendemail, sendalert, script, run, tscollect, mcollect, meventcollect, dump), every command that leaves Splunk or runs another search (rest, map, savedsearch, dbxquery, from savedsearch:), and every custom command from an app, until a Vyrux admin confirms it only reads.
  • A macro that is not defined, that Vyrux cannot read, that is built by an eval expression, that has different definitions in different apps, or that nests more than 12 deep. The search is then not run at all.
  • A quote or a bracket that never closes.

A rule that ends in a writing stage is still proven up to that stage, and a stage that only writes what it is given (collect, outputlookup, sendemail and the like) is left out of a count, because the count is the same without it.

Limits: lookup and inputlookup are on the list. A lookup that is defined as an external script runs that script, which is your own configuration. A Vyrux admin who adds a custom command to the list is vouching for it.

What is stored, and who can read and write it

Everything is in the KV store on your search head, in five collections. Members never read or write them through Splunk's KV REST API; they go through the Vyrux service, which checks every request.

Collection Holds Read directly Written directly
vyrux_store Issues, rule proofs (counts), field coverage (names and counts), host figures (host names, counts and times), test records, maintenance windows, daily readings, onboarding requests, the background scan state Splunk admins Splunk admins
vyrux_secure Settings, access rules, approvals, AI log lines (who, when, task, credits; no text), the record history, one line for each problem report sent (reference, who, when, title; no text) Splunk admins Nobody; the service only
vyrux_private The scan kept for each set of roles, the full text of AI requests, which indexes each rule reads Splunk admins Splunk admins
vyrux_changes The change log Vyrux members Nobody; the service only
vyrux_collector_state Where each API collector has read up to Vyrux admins Splunk admins

Secrets (the activation code, connector and collector credentials, a proxy password) are in Splunk's password store, never in a collection or a conf file.

What a member can change, and how it is recorded:

  • Issues: owner, due date, status, ticket, comments, and a suppression with a reason. One action at a time; the service applies it to the stored issue and writes the person's name and the time. What the scan found (title, what it covers, first seen) cannot be set from a browser. With a second approver on, a suppression needs an approved request from someone else.
  • Test records: written once, with the name and time taken on the server. They cannot be changed. The author or a Vyrux admin can remove one.
  • Maintenance windows: the planner or a Vyrux admin can change or remove one, and only for a log whose index the planner can search.
  • Rule proofs and field coverage from a person's own page: kept under that person's name and read only by them, so one member cannot change what another sees. Only the background scan, and a Vyrux admin whose roles search every index, write the shared copy.
  • Daily readings and the list of known logs: the background scan, or a Vyrux admin whose roles search every index. A day that is over is never rewritten.
  • Opening and closing issues: the background scan, or a full scan from the page of a Vyrux admin whose roles search every index. Each is stamped with who sent it.
  • The kept scan: a person can replace only the scan kept for the exact set of roles they hold. The record says who kept it and when.

Every change a person makes to an issue, a test record, a maintenance window or an approval adds a line to the record history: who, when, which record, what changed. A removed record stays in the history. Lines are only added; no role can edit or remove one through Vyrux. Reporting, Evidence shows it.

Retention: closed issues, AI usage lines and validation runs 400 days; test records two years; daily readings three years. The change log, approvals and the record history are not pruned.

Changes to Splunk, approvals and the change log

Vyrux changes Splunk only when a person applies a rule change or deploys parser settings. The write is made from that person's browser with their own Splunk session.

Splunk's own permissions are the hard control on who can write to Splunk. A person who can edit a rule in Splunk can edit it with or without Vyrux. Vyrux's second approver gates and records the changes made through Vyrux:

  • Only a Vyrux admin (vyrux_admin, admin or sc_admin) approves or sends back a change, and never their own. An analyst can ask for approval and withdraw their own request. The Approve changes limit and the named approvers can narrow which admins decide; they cannot widen it to analysts.
  • An approval carries a fingerprint (SHA-256) of the exact content asked for: the search, or the props, transforms, event types and tags to deploy. The approver cannot alter the request.
  • A change is recorded as approved only when the Vyrux service finds an approval that was really given, by someone other than the author, for that request, and the content of the change gives the same fingerprint. Anything else is refused.
  • With a second approver required, a change made without one is still recorded, marked "No approval", so it cannot pass unseen.
  • A Vyrux admin decides only a request whose indexes their own Splunk roles search: a parser request needs its log's index, a rule change every index the rule reads, a new rule every index.
  • Maintenance windows are capped: 30 days, and 24 hours for a member when a second approver is required. Windows placed end to end on the same log count as one.
  • The change log is append-only. A rollback is a new entry, written by the service after it has read the rule or the parser settings in Splunk and found the change gone. Only the person who made the change, or a Vyrux admin, can roll it back. The entry that was rolled back is never altered.

Limit: the write is made from the browser, so the second approver is a control on changes made through Vyrux, not on Splunk itself. When a change is recorded the service reads back the parser settings in the Vyrux app, or the saved search, and the entry says whether Splunk holds them; it verifies a rollback against Splunk and the content against the approval, but it does not itself perform the write.

Connectors and API collectors

  • HTTPS only, certificate checked, redirects followed only on the same host. Credentials go only to the host they were entered for.
  • Loopback, private, link-local, carrier-grade NAT and cloud metadata addresses are refused: 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 169.254.0.0/16, 100.64.0.0/10, ::1, fc00::/7, fe80::/10, and any name that resolves to one. The address actually connected to is checked again before a request is sent.
  • To reach a tool you host yourself, a Splunk admin names its host under Admin, Integrations ([network] internal_hosts in vyrux.conf). A Vyrux admin who is not a Splunk admin cannot.

Limit: when a company proxy is set, the proxy resolves the name, so Vyrux checks only what this server can resolve.

The licence

The licence is a signed code, checked on your server with no network call. A trial runs 30 days from first use.

When a licence ends, or the Vyrux service stops it (after a refund or a payment dispute, found at the hourly check):

  • Everything can still be read.
  • Alerts keep going. Silent logs, silent forwarders, failing collectors, new root causes and waiting approvals are sent exactly as before. Alerts never depend on the licence.
  • Changes through Vyrux, Chuka, and the scheduled report emails are off until a plan is renewed or a code is added.

First-time setup

On a new install nothing is read until a Vyrux admin or a Splunk admin has gone through the first-run screens, which state what is on this page in short, and has started the first scan. The background scan does not run before that. A member who arrives earlier sees a note that setup is not finished.

Load on the search head

What Vyrux asks of Splunk, measured on a Splunk Enterprise 10.6 lab with 384 logs, 163 enabled rules and about 270 MB a day, build 80:

What Searches Time
Opening Vyrux with a kept scan 10 minutes old 3 (one to list the indexes the person can search, two to prove one quiet rule) The page is usable at once; no scan runs
A full scan (the first scan, Scan again, or a visit when the kept scan is older than the set age) 54 search jobs, at most 3 at a time, 153 seconds of search time in total About 2 to 3 minutes
The background scan, every 15 minutes Proves up to 8 rules and reads field coverage for up to 20 logs each run, and stops proving after 4 minutes 150 to 210 seconds on this lab. Over 24 hours on build 100, read from Vyrux's own log: 96 runs, 102 seconds on average and 343 seconds at most
The host read inside the background scan (build 82) One tstats search over 7 days by index, sourcetype, host and time span, with the counting done inside the search. Two more once a day: new hosts and hosts a day, 30 days 11,064 hosts and 30,244 host and log pairs: 22 seconds with one hour spans, 11 to 13 seconds with four hour spans, which is what this lab now uses. The two daily searches take about 16 seconds each. The whole background scan took 77 to 103 seconds with the host read in it. Made once an hour when it takes over 20 seconds
Find a host, and the Hosts tab of a log One tstats search over 7 days for that host or that log, with the person's own session A few seconds on this lab

A full scan from the page ran once for every visit with a kept scan older than 15 minutes in build 76. From build 77 a visit opens the kept scan and scans again only when it is older than the age an admin sets (60 minutes unless changed), so ten analysts opening Vyrux in an hour cause at most one full scan for each set of roles.

The scale test in the source tree (10,000 sourcetypes, 5,000 saved searches) answers every search at once, so it measures Vyrux's own work, not search cost. These are figures from one small lab. They are not a sizing guide for a large Enterprise Security search head; measure on your own before production. Admin, System health lists every read Vyrux made and how long it took.

Turning each part off

To stop Do this
All AI Admin, AI, Use AI off
Event text in AI requests Admin, AI, Send sample events off
The hourly licence call Remove the activation code under Admin, Licence
The background scan Admin, System health, Background scan off
The host read Admin, System health, Host read off
Alerts about silent hosts Admin, Integrations: leave "Hosts go silent" off, which it is until you turn it on
Counts from Splunk's own indexes for members Admin, Access, the switch under Counts from Splunk's own indexes
A connector or a collector Admin, Integrations, or API Studio
Vyrux Disable or remove the app under Apps, Manage Apps. Its collections go with it

What this page does not cover

  • Vyrux Security has no SOC 2 report and no ISO 27001 certificate today. Ask your Vyrux contact for the current status, the data processing agreement and the list of sub-processors.
  • The tests run against a stand-in for Splunk and against one Splunk Enterprise 10.6 lab. Splunk Cloud, search head clusters and very large estates are covered by design and by the stand-in, and are not yet proven on a customer deployment.
  • Vyrux does not protect against a Splunk admin. A Splunk admin can read every collection and change any conf file.
  • What the vyrux_admin role can do in Splunk: its capabilities are all in Splunk's own user role (rest_properties_set and edit_own_objects included), and collect, mcollect and scheduled real-time searches are turned down. Its power is write access to the Vyrux app: the parser settings it deploys are exported to every app, so they apply to every search by everyone, and on an all-in-one server or a heavy forwarder props and transforms can also act when data is indexed. It sets API collectors, which write to the index their spec names, and the proxy and CA file the AI and licence calls use, through the Vyrux service. vyrux.conf itself (the AI service address, internal hosts, licence state) is writable only by Splunk admins, so a Vyrux admin cannot change it over Splunk's REST API around the service's checks. Give it as you would a Splunk power role.
  • The background scan proves rules with the scheduled search owner's session (the system user for rules owned by nobody). Only read-only commands run, but the read-only list includes lookup, inputlookup, inputcsv and loadjob, so a scripted external lookup a rule uses can run during a proof. Only counts are kept.
  • The scan kept for a set of roles is written by a person with those roles. The service checks its shape and age, not its figures, so a member could keep a misleading scan for colleagues with the same roles until the next scan replaces it. The background scan's issues and alerts do not depend on it.
  • The daily AI limit is checked before each call, so several calls at the same moment can pass it by their own cost.
  • The browser makes the deploy and then records it. If the browser closes between the two, the change is in Splunk and not in the change log; the Vyrux app's own settings, read back on the next recorded change, show it.
  • Masking reads keys, formats, shapes and common command lines (net user, curl -u, mysql -p, psexec -p, ConvertTo-SecureString, /pass:). A password in a shape not listed is not recognised; to send no event text at all, turn off Send sample events.