Study guide
13.2 Role-Based Access Control, Feature Privileges & Index Security
Elastic Certified SIEM Analyst Exam
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & Study Strategy
1.1 Elastic Certified SIEM Analyst Exam Facts, Objectives & Study Plan
2 Chapter 2: Elastic Stack Architecture & SIEM Foundations
2.1 Elastic Stack Architecture for Security Operations 2.2 Telemetry Ingestion Architecture & Data Pipelines 2.3 Security Data Storage, Data Streams & ILM
3 Chapter 3: Elastic Common Schema (ECS) & Ingestion Normalization
3.1 ECS Structure, Core Principles & Essential Field Sets 3.2 Ingest Pipelines, Processors & Normalization Workflows 3.3 Fleet Server & Elastic Agent Integration Management
4 Chapter 4: Discover, Data Views & Security Query Languages
4.1 Kibana Discover, Security Data Views & Runtime Fields 4.2 Kibana Query Language (KQL) & Lucene for SecOps 4.3 ES|QL for Multi-Stage Security Analysis
5 Chapter 5: Security Visualizations & Threat Analytics
5.1 Metric, Aggregation & Histogram Visualizations for SOC 5.2 Data Tables, Heatmaps & Specialized Security Charts 5.3 Elastic Maps & Geospatial Telemetry Analysis
6 Chapter 6: Kibana Lens for Security Workflows
6.1 Lens Architecture & Multi-Layer Telemetry Visualizations 6.2 Lens Formulas, Ratios & Anomaly Baseline Metrics 6.3 Operationalizing Lens in SOC Triage & Drilldowns
7 Chapter 7: Security Dashboards & SOC Operations
7.1 Security Dashboard Architecture & SOC Layout Design 7.2 Interactive Controls, Time Sync & Cross-Filtering 7.3 Dashboard Exporting, Reporting & Spaces Sharing
8 Chapter 8: The Elastic Security App: Capabilities, Explore & Dashboards
8.1 Security App Capabilities & the Explore Pages (Hosts, Network, Users) 8.2 Monitoring with the Security App Dashboards
9 Chapter 9: Elastic Security Detection Engine & Core Rules
9.1 Detection Engine Architecture & Prebuilt Rule Management 9.2 Custom Query & Threshold Detection Rules 9.3 Event Correlation Rules with Event Query Language (EQL)
10 Chapter 10: Advanced Detection Rules, ML & Rule Tuning
10.1 Threat Intelligence & Indicator Match Rules 10.2 New Terms, ES|QL & Machine Learning Detection Rules 10.3 Detection Rule Tuning, Exceptions & Alert Suppression
11 Chapter 11: Alert Triage, Timelines & Investigation Workflows
11.1 Alert Triage Workflow & the Alert Details Flyout 11.2 Elastic Security Timeline & Timeline Templates 11.3 Visual Event Analyzer & Session View Forensics
12 Chapter 12: Case Management, Integrations & AI Assistant
12.1 Elastic Security Case Management & Triage Workflows 12.2 Case Connectors & External Incident Escalation 12.3 Elastic AI Assistant for Security & Attack Discovery
13 Chapter 13: Security Administration, RBAC & Kibana Spaces
13.1 Kibana Spaces for SOC Multitenancy & Segmentation 13.2 Role-Based Access Control, Feature Privileges & Index Security 13.3 Elastic Defend Administration & Endpoint Policy Controls
14 Chapter 14: End-to-End Threat Hunting & Incident Investigation Capstone
14.1 Hypothesis-Driven Threat Hunting & Baselining in Elastic 14.2 Investigating Lateral Movement & Credential Access Campaigns 14.3 Data Exfiltration, C2 Detection & Incident Reconstruction
13.2 Role-Based Access Control, Feature Privileges & Index Security
Key Takeaways Explain This Topic AI
Elastic Role-Based Access Control (RBAC) relies on dual-layer authorization: Kibana Feature Privileges govern UI access per space, while Elasticsearch Index Privileges enforce raw document and index read/write actions.
In 8.15, the Security feature privilege (All or Read) has sub-feature privileges only for Elastic Defend, such as Endpoint List, Trusted Applications, Event Filters, Host Isolation, and Process, File, Execute and Scan Operations.
Changing alert status (Open, Acknowledged, Closed) requires maintenance, write, read and view_index_metadata on .alerts-security.alerts-<space-id> in addition to the Kibana Security privilege.
Document-Level Security (DLS) restricts document visibility with a Query DSL query in the role definition, while Field-Level Security (FLS) hides sensitive fields such as credentials, hashes, or PII.
Adhering to least-privilege principles dictates distinct custom SOC roles, separating Tier 1 triage analysts (read telemetry, update alerts, create cases) from Detection Engineers (rule management) and Incident Responders (host isolation, terminal response actions).
Last updated: September 2026
Security operations teams operate under strict compliance and operational governance mandates. An outsourced Tier 1 analyst should never possess the authority to modify production detection rules, export unredacted employee credentials, or execute terminal commands on domain controllers. Conversely, detection engineers and incident responders require specialized privileges to tune correlation rules, access raw telemetry streams, and initiate host containment actions. In the Elastic Stack, Role-Based Access Control (RBAC) enforces these boundaries across two distinct layers: the Kibana Presentation Layer (Feature Privileges) and the Elasticsearch Data Layer (Index and Cluster Privileges) .
1. Dual-Layer Authorization: Presentation vs. Data Engine
A critical failure mode in SOC access design occurs when an administrator assigns privileges at one layer while omitting the other: +-------------------------------------------------------------------------+
- | Layer 1: Kibana Feature Privileges |
- | (Controls UI buttons, navigation, and spaces) |
- | - Security: All or Read (rules, alerts, Timelines); Cases separate |
- | - Elastic Defend sub-features (e.g. Host Isolation, Operations) |
- +------------------------------------+------------------------------------+
- |
- | User triggers an action in the UI
- v
- +-------------------------------------------------------------------------+
- | Layer 2: Elasticsearch Index Privileges |
- | (Controls raw Lucene storage read/write access) |
- | - logs-*-*: read, view_index_metadata |
- | - .alerts-security.alerts-<space>: read, write, maintenance |
- | - Document-Level Security (DLS) & Field-Level Security (FLS) |
- +-------------------------------------------------------------------------+
Scenario A (UI granted, Data denied): An analyst is assigned 'All' privileges on the Security app in Kibana, but their Elasticsearch role lacks read privileges on logs-* . The analyst logs in, opens the Security app, but every search query fails with an Elasticsearch security_exception (HTTP 403 Forbidden).
Scenario B (Data granted, UI denied): An analyst has full all index privileges on logs-* in Elasticsearch, but their Kibana role grants 'None' for the Security feature. The analyst cannot view the Elastic Security app in the Kibana navigation menu, though they could query the index directly via the Elasticsearch REST API.
To perform any operational action, a user's role must satisfy the requirements of both layers simultaneously.
2. Kibana Feature Privileges for Elastic Security (8.15)
Kibana feature privileges are assigned per space in Stack Management → Roles . In Elastic Stack 8.15, the Security app is governed mainly by one feature privilege, Security , set to All , Read or None :
Read gives read access to all of Elastic Security except Cases. With the right index privileges, users can view alerts, rules, Timelines and dashboards.
All allows creating and managing rules and exceptions, Timelines and other Security objects, again combined with the matching index privileges.
In 8.15 there are no separate sub-feature privileges for rules, alerts or Timelines . Rules versus alerts access is separated by index privileges on the system indices, described in the next section.
Related features are assigned separately:
Cases has its own feature privilege (All or Read). Pushing cases to external systems also needs Actions and Connectors privileges.
Elastic AI Assistant and Attack discovery are their own features.
Machine Learning , Dashboard , Discover and Maps apply to those apps (for example, the Network page map needs Maps privileges).
Elastic Defend Sub-Feature Privileges
The Security feature's only sub-feature privileges in 8.15 are for Elastic Defend. They must be assigned to all spaces . Selecting All for Security does not enable them: turn on Customize sub-feature privileges and grant each one (All, Read where available, or None):
Endpoint List : The Endpoints page and host integration details.
Trusted Applications , Host Isolation Exceptions , Blocklist and Event Filters : The pages that manage those endpoint artifacts.
Elastic Defend Policy Management : The Policies pages and Elastic Defend integration policies.
Response Actions History : The history of response actions.
Host Isolation : Isolating and releasing hosts.
Process Operations : The processes , kill-process and suspend-process response actions.
File Operations : File-related response actions in the response console (for example retrieving a file).
Execute Operations : Running shell commands and scripts. These run with the full privileges of the Elastic Defend service, so grant this very sparingly.
Scan Operations : Folder scan response actions.
3. Elasticsearch Index Privileges for SecOps Workflows
Elasticsearch index privileges decide what a role can do with each index or data stream. Elastic's detection requirements for 8.15 are:
Task Kibana privilege Index privileges
View Elastic Security data Security: Read read and view_index_metadata on the Security data indices (e.g. logs-* , filebeat-* , packetbeat-* , endgame-* )
Manage alerts (change status, tags, assignees; not rules) Security: Read maintenance , write , read , view_index_metadata on .alerts-security.alerts-<space-id> and .internal.alerts-security.alerts-<space-id>-*
Manage rules Security: All manage , write , read , view_index_metadata on .alerts-security.alerts-<space-id> , .lists-<space-id> , .items-<space-id>
Preview rules Security: All read on .preview.alerts-security.alerts-<space-id> and .internal.preview.alerts-security.alerts-<space-id>-*
Enable detections in a space (first visit creates system indices) Security: All manage cluster privilege, plus manage , write , read , view_index_metadata on the alerts, .lists and .items indices
Two consequences matter for exam questions:
An analyst with Security All but only read on the alerts index can view alerts but cannot change their status. The update fails with an authorization error until write access (with maintenance ) is granted.
Rules run in the background with an API key created from the privileges of the last user who edited the rule . If a user without the needed index privileges updates a rule, the rule stops working.
4. Advanced Data Security: Document-Level & Field-Level Security
Enterprise security policies often mandate that certain data within an index remain hidden based on user clearance or organizational tenancy.
Document-Level Security (DLS)
Document-Level Security restricts query visibility by embedding a query (written in Elasticsearch Query DSL) directly into the role definition. When a user queries an index, Elasticsearch silently appends the DLS query to the user's search criteria in filter context: {
- "names": ["logs-endpoint-*"],
- "privileges": ["read", "view_index_metadata"],
- "query": {
- "bool": {
- "must_not": [
- { "terms": { "host.name": ["ceo-laptop", "cfo-macbook", "domain-ctrl-01"] } }
- ]
- }
- }
- }
In this example, an outsourced Tier 1 analyst can query endpoint logs across all standard corporate workstations, but any event originating from executive or domain controller hosts is completely filtered out of their search results and aggregations.
Field-Level Security (FLS)
Field-Level Security controls which fields within a document are returned to the user. Administrators can define a whitelist of permitted fields or a blacklist of redacted fields: {
- "names": ["logs-*"],
- "privileges": ["read"],
- "field_security": {
- "grant": ["*"],
- "except": [
- "user.password_hash",
- "http.request.body.content",
- "customer.credit_card_number",
- "patient.ssn"
- ]
- }
- }
When a user assigned this role queries raw web proxy or application logs, the redacted fields do not exist from their perspective. Aggregations on those fields return zero hits, and document inspection tables display the fields as absent, preventing inadvertent privacy or credential violations.
- 5. Built-in Roles vs. Custom Least-Privilege SOC Roles
- Useful Built-in Roles
superuser : Full access to the whole stack. Avoid it for day-to-day analysts.
kibana_admin : Full access to all Kibana features and spaces. It does not grant access to data indices.
editor and viewer : All or read access across Kibana features, still requiring index privileges for the data being queried.
Elastic recommends replacing broad roles such as superuser with custom roles that grant only the feature and index privileges each job needs.
Example Least-Privilege SOC Role Matrix
Operational Persona Kibana Feature Privileges Elasticsearch Index Privileges DLS / FLS Constraints
Tier 1 SOC Triage Analyst Security: Read; Cases: All; Elastic Defend sub-features: Endpoint List (Read), Host Isolation (None), all Operations (None) read , view_index_metadata on Security data indices; read , write , maintenance , view_index_metadata on .alerts-security.alerts-<space-id> FLS to hide sensitive payload fields
Detection Engineer Security: All; Cases: Read; Actions and Connectors: Read or All; Event Filters (All) read on data and threat intel indices; manage , write , read , view_index_metadata on alerts, .lists and .items indices Usually none, for full field visibility when writing rules
Incident Responder (Tier 3) Security: All; Cases: All; Host Isolation (All); Process and File Operations (All); Execute Operations only if required Same data and alerts privileges as the triage analyst Usually none
6. Security Feature and Index Privilege Mapping
SecOps Functional Action Required Kibana Feature Privilege Required Elasticsearch Index Privileges Target Index Pattern
Search raw telemetry in Discover Discover: Read or All read , view_index_metadata logs-* and other data indices
Change alert status, tags, assignees Security: Read (or All) maintenance , write , read , view_index_metadata .alerts-security.alerts-<space-id>
Create or edit detection rules Security: All (plus Actions and Connectors for rule actions) manage , write , read , view_index_metadata Alerts, .lists-<space-id> , .items-<space-id>
Create and update cases Cases: All None on data indices for the case itself Stored by Kibana
Run response console commands Security → Process, File or Execute Operations: All Managed by Kibana and Fleet Endpoint action indices
Isolate a compromised host Security → Host Isolation: All (Platinum or higher) Managed by Kibana and Fleet Endpoint action indices