For Elasticsearch
Overview: The ReadonlyREST Suite
ReadonlyREST is a light weight Elasticsearch plugin that adds encryption, authentication, authorization and access control capabilities to Elasticsearch embedded REST API. The core of this plugin is an ACL engine that checks each incoming request through a sequence of rules a bit like a firewall. There are a dozen rules that can be grouped in sequences of blocks and form a powerful representation of a logic chain.
The Elasticsearch plugin known as ReadonlyREST Free is released under the GPLv3 license, or alternatively a commercial license (see ReadonlyREST Embedded) and lays the technological foundations for the companion Kibana plugin which is released in two versions: ReadonlyREST PRO and ReadonlyREST Enterprise.
Unlike the Elasticsearch plugin, the Kibana plugins are commercial only. But rely on the Elasticsearch plugin in order to work.
For a description of the Kibana plugins, skip to the dedicated documentation page instead.
ReadonlyREST Free plugin for Elasticsearch
In this document we are going to describe how to operate the Elasticsearch plugin in all its features. Once installed, this plugin will greatly extend the Elasticsearch HTTP API (port 9200), adding numerous extra capabilities:
Encryption: transform the Elasticsearch API from HTTP to HTTPS
Authentication: require credentials
Authorization: declare groups of users, permissions and partial access to indices.
Access control: complex logic can be modeled using an ACL (access control list) written in YAML.
Audit events: a trace of the access requests can be logged to file or index (or both).
Flow of a Search Request
The following diagram models an instance of Elasticsearch with the ReadonlyREST plugin installed, and configured with SSL encryption and an ACL with at least one "allow" type ACL block.
The User Agent (i.e. cURL, Kibana) sends a search request to Elasticsearch using the port 9200 and the HTTPS URL schema.
The HTTPS filter in ReadonlyREST plugin unwraps the SSL layer and hands over the request to Elasticsearch HTTP stack
The HTTP stack in Elasticsearch parses the HTTP request
The HTTP handler in Elasticsearch extracts the indices, action, request type and creates a
SearchRequest(internal Elasticsearch format).The SearchRequest goes through the ACL (access control list), external systems like LDAP can be asynchronously queried, and an exit result is eventually produced.
The exit result is used by the audit event serializer, to write a record to index and/or Elasticsearch log file
If no ACL block was matched, or if a
type: forbidblock was matched, ReadonlyREST does not forward the search request to the search engine, and creates an "unauthorized" HTTP response.In case the ACL matched an
type: allowblock, the request is forwarded to the search engineThe Elasticsearch code creates a search response containing the results of the query
10.The search response is converted to an HTTP response by the Elasticsearch code
The HTTP response flows back to ReadonlyREST's HTTPS filter and to the User agent
Installing the plugin
To install ReadonlyREST plugin for Elasticsearch:
1. Obtain the build
From the official download page. Select your Elasticsearch version and send yourself a link to the compatible ReadonlyREST zip file.
2. Install the build
Notice how we need to type in the format file:// + absolute path (yes, with three slashes).
When prompted about additional permissions, answer y.
3. Patch Elasticsearch
If you are using Elasticsearch 6.5.x or newer, you need an extra post-installation step. Depending on the Elasticsearch version, this command might tweak the main Elasticsearch installation files and/or copy some jars to plugins/readonlyrest directory.
⚠️IMPORTANT: for Elasticsearch 8.3.x or newer, the patching operation requires root user privileges.
You can verify if Elasticsearch was correctly patched using command verify:
Please note that the tool assumes that you run it from the root of your ES installation directory or the default installation directory is /usr/share/elasticsearch. But if you want or need, you can instruct it where your Elasticsearch is installed by executing one of tool's command with --es-path parameter:
or
NB: In case of any problems with the ror-tools, please call:
4.Create settings file
Create and edit the readonlyrest.yml settings file in the same directory where elasticsearch.yml is found:
Now write some basic settings, just to get started. In this example we are going to tell ReadonlyREST to require HTTP Basic Authentication for all the HTTP requests, and return 401 Unauthorized otherwise.
5. Disable X-Pack security module
(applies to ES 6.4.0 or greater)
ReadonlyREST and X-Pack security module can't run together, so the latter needs to be disabled.
Edit elasticsearch.yml and append xpack.security.enabled: false.
6. Start Elasticsearch
or:
Depending on your environment.
Now you should be able to see the logs and ReadonlyREST related lines like the one below:
7. Test everything is working
The following command should succeed, and the response should show a status code 200.
The following command should not succeed, and the response should show a status code 401
Upgrading the plugin
To upgrade ReadonlyREST for Elasticsearch:
1. Stop Elasticsearch.
Either kill the process manually, or use:
depending on your environment.
2. Unpatch Elasticsearch
If you are using Elasticsearch 6.5.x or newer, you need an extra pre-uninstallation step. This will remove all previously copied jars from ROR's installation directory.
You can verify if Elasticsearch was correctly unpatched using command verify:
NB: In case of any problems with the ror-tools, please call:
3. Uninstall ReadonlyREST
4. Install the new version of ReadonlyREST into Elasticsearch.
e.g.
5. Patch Elasticsearch
If you are using Elasticsearch 6.5.x or newer, you need an extra post-installation step. Depending on the Elasticsearch version, this command might tweak the main Elasticsearch installation files and/or copy some jars to plugins/readonlyrest directory.
⚠️IMPORTANT: for Elasticsearch 8.3.x or newer, the patching operation requires root user privileges.
You can verify if Elasticsearch was correctly patched using the command verify:
NB: In case of any problems with the ror-tools, please call:
6. Restart Elasticsearch.
or:
Depending on your environment.
Now you should be able to see the logs and ReadonlyREST related lines like the one below:
Removing the plugin
1. Stop Elasticsearch.
Either kill the process manually, or use:
depending on your environment.
2. Unpatch Elasticsearch
If you are using Elasticsearch 6.5.x or newer, you need an extra pre-uninstallation step. This will remove all previously copied jars from ROR's installation directory.
You can verify if Elasticsearch was correctly unpatched using the command verify:
NB: In case of any problems with the ror-tools, please call:
3. Uninstall ReadonlyREST from Elasticsearch:
4. Start Elasticsearch.
or:
Depending on your environment.
Deploying ReadonlyREST in a stable production cluster
Unless some advanced features are being used (see below), this Elasticsearch plugin operates like a lightweight, stateless filter glued in front of Elasticsearch HTTP API. Therefore it's sufficient to install the plugin only in the nodes that expose the HTTP interface (port 9200).
Installing ReadonlyREST in a dedicated node has numerous advantages:
No need to restart all nodes, only the one you have installed the plugin into.
No need to restart all nodes for updating the security settings
No need to restart all nodes when a security update is out
Less complexity on the actual cluster nodes.
For example, if we want to move to HTTPS all the traffic coming from Logstash into a 9 nodes Elasticsearch cluster which has been running stable in production for a while, it's not necessary to install ReadonlyREST plugin in all the nodes.
Creating a dedicated, lightweight ES node where to install ReadonlyREST:
(Optional) disable the HTTP interface from all the existing nodes
Create a new, lightweight, dedicated node without shards, nor master eligibility.
Configure ReadonlyREST with SSL encryption in the new node
Configure Logstash to connect to the new node directly in HTTPS.
An exception
⚠️IMPORTANT By default when the fields rule is used, it's required to install ReadonlyREST plugin in all the data nodes.
ACL basics
The core of this plugin is an ACL (access control list). A logic structure very similar to the one found in firewalls. The ACL is part of the plugin configuration, and it's written in YAML.
The ACL is composed of an ordered sequence of named blocks
Each block contains some rules, and a policy (forbid or allow)
HTTP requests run through the blocks, starting from the first,
The first block that satisfies all the rules decides if to forbid or allow the request (according to its policy).
If none of the block match, the request is rejected
⚠️IMPORTANT: The ACL blocks are evaluated sequentially, therefore the ordering of the ACL blocks is crucial. The order of the rules inside an ACL block instead, is irrelevant.
An Example of Access Control List (ACL) made of 2 blocks.
The YAML snippet above, like all of this plugin's settings should be saved inside the readonlyrest.yml file. Create this file on the same path where elasticsearch.yml is found.
TIP: If you are a subscriber of the PRO or Enterprise Kibana plugin, you can edit and refresh the settings through a GUI. For more on this, see the documentation for ReadonlyREST plugin for Kibana.
Encryption
An SSL encrypted connection is a prerequisite for secure exchange of credentials and data over the network. To make use of it you need to have certificate and private key. Letsencrypt certificates work just fine (see tutorial below). Before ReadonlyREST 1.44.0 both files, certificate and private key, had to be placed inside PKCS#12 or JKS keystore. See the tutorial at the end of this section. ReadonlyREST 1.44.0 or newer supports using PEM files directly, without the need to use a keystore.
ReadonlyREST can be configured to encrypt network traffic on two independent levels:
HTTP (port 9200)
Internode communication - transport module (port 9300)
An Elasticsearch node with ReadonlyREST can join an existing cluster based on native SSL from
xpack.securitymodule. This configuration is useful to deploy ReadonlyREST Enterprise for Kibana to an existing large production cluster without disrupting any configuration. More on this in the dedicated paragraph of this section.
External REST API
It wraps connection between client and exposed REST API in SSL context, hence making it encrypted and secure. ⚠️IMPORTANT: To enable SSL for REST API, open elasticsearch.yml and append this one line:
Now in readonlyrest.yml add the following settings:
The keystore should be stored in the same directory with elasticsearch.yml and readonlyrest.yml.
Internode communication - transport module
This option encrypts communication between nodes forming Elasticsearch cluster.
⚠️IMPORTANT: To enable SSL for internode communication open elasticsearch.yml and append this one line:
In readonlyrest.yml following settings must be added (it's just example configuration presenting most important properties):
Similar to ssl for HTTP, the keystore should be stored in the same directory with elasticsearch.yml and readonlyrest.yml. This config must be added to all nodes taking part in encrypted communication within cluster.
Internode communication with XPack nodes
It is possible to set up internode SSL between ROR and XPack nodes. It works only for ES above 6.3.
To set up cluster in such configuration you have to generate certificate for ROR node according to this description https://www.elastic.co/guide/en/elasticsearch/reference/current/security-basic-setup.html#generate-certificates.
Generated elastic-certificates.p12 could be then used in ROR node with such configuration
Certificate verification
By default the certificate verification is disabled. It means that certificate is not validated in any way, so all certificates are accepted. It is useful on local/test environment, where security is not the most important concern. On production environment it is advised to enable this option. It can be done by means of:
under ssl_internode section. This option is applicable only for internode SSL.
Hostname verification
By default the hostname verification is disabled. This means that hostname or IP address is not verified to match the names in the certificate. To enable hostname verification add the following lines in the ssl_internode section:
Client authentication
By default the client authentication is disabled. When enabled, the server asks the client about its certificate, so ES is able to verify the client's identity. It can be enabled by means of:
under ssl section. This option is applicable for REST API external SSL and internode SSL.
Restrict SSL protocols and ciphers
Optionally, it's possible to specify a list allowed SSL protocols and SSL ciphers. Connections from clients that don't support the listed protocols or ciphers will be dropped.
ReadonlyREST will log a list of available ciphers and protocols supported by the current JVM at startup.
Custom truststore
ReadonlyREST allows using custom truststore, replacing (provided by JRE) default one. Custom truststore can be set with:
under ssl or ssl_internode section. This option is applicable for both ssl modes - external ssl and internode ssl. The truststore should be stored in the same directory with elasticsearch.yml and readonlyrest.yml (like keystore). When not specified, ReadonlyREST uses default truststore.
PEM files instead of a keystore and/or truststore
If you are using ReadonlyREST 1.44.0 or newer then you are able to use PEM files directly without the need of placing them inside a keystore or truststore.
To use PEM files instead of keystore file, use such configuration instead of keystore_file, keystore_pass, key_pass fields:
To use PEM file instead of truststore file, use such configuration instead of truststore_file, truststore_pass fields:
Using Let's encrypt
We are going to show how to first add all the certificates and private key into PKCS#12 keystore, and then (optionally) converting it to JKS keystore. ReadonlyREST supports both formats.
⚠️IMPORTANT: if you are using ReadonlyREST in version above 1.44.0 then you don't have to create a keystore. You are able to use PEM files directly using the description above.
This tutorial can be a useful example on how to use certificates from other providers.
1. Create keys
Now change to the directory (probably /etc/letsencrypt/live/DOMAIN.tld) where the certificates were created.
2. Create a PKCS12 keystore with the full chain and private key
3. Convert PKCS12 to JKS Keystore (Optional)
The STORE_PASS is the password which was entered in step 2) as a password for the pkcs12 file.
If you happen to get a java.io.IOException: failed to decrypt safe contents entry: javax.crypto.BadPaddingException: Given final block not properly padded, you have probably forgotten to enter the correct password from step 2.
(Credits for the original JKS tutorial to Maximilian Boehm)
Request handling during ES startup
Each incoming request to the Elasticsearch node passes to the installed plugin. During Elasticsearch node startup, the plugin rejects incoming requests until it starts. The plugin rejects such requests with the 403 forbidden responses by default. To overwrite this behavior, append to elasticsearch.yml
readonlyrest.not_started_response_code - HTTP code returned when the plugin does not start yet. Possible values are 403(default) and 503.
readonlyrest.failed_to_start_response_code - HTTP code returned when the plugin failed to start (e.g. by malformed ACL). Possible values are 403(default) and 503.
Blocks of rules
Every block must have at least the name field, and optionally a type field valued either "allow" or "forbid". If you omit the type, your block will be treated as type: allow by default.
Keep in mind that ReadonlyREST ACL is a white list, so by default all request are blocked, unless you specify a block of rules that allows all or some requests.
namewill appear in logs, so keep it short and distinctive.typecan be eitheralloworforbid. Can be omitted, default isallow.
Example: the simplest example of an allow block.
⚠️IMPORTANT: if no blocks are configured, ReadonlyREST rejects all requests.
Rules
ReadonlyREST access control rules can be divided into the following categories:
Authentication & Authorization rules
Elasticsearch level rules
Kibana-related rules
HTTP level rules
Network level rules
Please refrain from using HTTP level rules to protect certain indices or limit what people can do to an index. The level of control at this level is really coarse, especially because Elasticsearch REST API does not always respect RESTful principles. This makes of HTTP a bad abstraction level to write ACLs in Elasticsearch all together.
The only clean and exhaustive way to implement access control is to reason about requests AFTER ElasticSearch has parsed them. Only then, the list of affected indices and the action will be known for sure. See Elasticsearch level rules.
Authentication & Authorization rules
This section contains description of rules that can be used to authenticate and/or authorize users. Most of the following rules use HTTP Basic Auth, so the credentials are passed with the Authorization header and they can be easily decoded when the request is intercepted by a malicious third party. Please note that this authentication method is secure only if SSL is enabled.
auth_key
auth_keyauth_key: sales:p455wd
It's an authentication rule that accepts HTTP Basic Auth. Configure this value in clear text. Clients will need to provide the header e.g. Authorization: Basic c2FsZXM6cDQ1NXdk where "c2FsZXM6cDQ1NXdk" is Base64 for "sales:p455wd".
⚠️IMPORTANT: this rule is handy just for tests, replace it with another rule that hashes credentials, like: auth_key_sha512, or auth_key_unix.
Impersonation is supported by this rule without an extra configuration.
auth_key_sha512
auth_key_sha512auth_key_sha512: 280ac6f...94bf9
The authentication rule that accepts HTTP Basic Auth. The value is a string like username:password hashed in SHA512. Clients will need to provide the usual Authorization header.
There are also available other rules with less secure SHA algorithms auth_key_sha256 and auth_key_sha1.
The rules support also alternative syntax, where only password is hashed, eg:
auth_key_sha512: "admin:280ac6f...94bf9"
In the example below admin is the username and 280ac6f...94bf9 is the hashed secret.
Impersonation is supported by these rules by default.
auth_key_pbkdf2
auth_key_pbkdf2auth_key_pbkdf2: "KhIxF5EEYkH5GPX51zTRIR4cHqhpRVALSmTaWE18mZEL2KqCkRMeMU4GR848mGq4SDtNvsybtJ/sZBuX6oFaSg==" # logstash:logstash
auth_key_pbkdf2: "logstash:JltDNAoXNtc7MIBs2FYlW0o1f815ucj+bel3drdAk2yOufg2PNfQ51qr0EQ6RSkojw/DzrDLFDeXONumzwKjOA==" # logstash:logstash
The authentication rule that accepts HTTP Basic Auth. The value is hashed in the same way as it's done in auth_key_sha512 rule, but it uses PBKDF2 key derivation function. At the moment there is no way to configure it, so during the hash generation, the user has to take into consideration the following PBKDF2 input parameters values:
| Input parameter | Value | Comment |
|---|---|---|
Pseudorandom function | HmacSHA512 | |
Salt | use hashed value as a salt | eg. hashed value = |
Iterations count | 10000 | |
Derived key length | 512 | bits |
The hash can be calculated using this calculator (notice that the salt has to base Base64 encoded).
Impersonation is supported by this rule without an extra configuration.
auth_key_unix
auth_key_unixauth_key_unix: test:$6$rounds=65535$d07dnv4N$QeErsDT9Mz.ZoEPXW3dwQGL7tzwRz.eOrTBepIwfGEwdUAYSy/NirGoOaNyPx8lqiR6DYRSsDzVvVbhP4Y9wf0 # Hashed for "test:test"
⚠️IMPORTANT this hashing algorithm is very CPU intensive, so we implemented a caching mechanism around it. However, this will not protect Elasticsearch from a DoS attack with a high number of requests with random credentials.
This is authentication rule that is based on /etc/shadow file syntax.
If you configured sha512 encryption with 65535 rounds on your system the hash in /etc/shadow for the account test:test will be test:$6$rounds=65535$d07dnv4N$QeErsDT9Mz.ZoEPXW3dwQGL7tzwRz.eOrTBepIwfGEwdUAYSy/NirGoOaNyPx8lqiR6DYRSsDzVvVbhP4Y9wf0
You can generate the hash with mkpasswd Linux command, you need whois package apt-get install whois (or equivalent)
mkpasswd -m sha-512 -R 65534
Also you can generate the hash with a python script (works on Linux):
Finally you have to put your username at the beginning of the hash with ":" separator test:$6$rounds=65535$d07dnv4N$QeErsDT9Mz.ZoEPXW3dwQGL7tzwRz.eOrTBepIwfGEwdUAYSy/NirGoOaNyPx8lqiR6DYRSsDzVvVbhP4Y9wf0
For example, test is the username and $6$rounds=65535$d07dnv4N$QeErsDT9Mz.ZoEPXW3dwQGL7tzwRz.eOrTBepIwfGEwdUAYSy/NirGoOaNyPx8lqiR6DYRSsDzVvVbhP4Y9wf0 is the hash for test (the password is identical to the username in this example).
Impersonation is supported by this rule without an extra configuration.
token_authentication
token_authenticationThe authentication rule that accepts token sent in the HTTP header (the Authorization header is the default if no custom header name is configured in the token_authentication.header field).
For the HTTP header in the format Authorization: Bearer AAEAAWVsYXN0aWMva2liYW5hL3Rva2Vu, the Bearer AAEAAWVsYXN0aWMva2liYW5hL3Rva2Vu is the token value set in the token field.
Impersonation is supported by this rule without an extra configuration.
proxy_auth: "*"
proxy_auth: "*"proxy_auth: "*"
Delegated authentication. Trust that a reverse proxy has taken care of authenticating the request and has written the resolved user name into the X-Forwarded-User header. The value "*" in the example, will let this rule match any username value contained in the X-Forwarded-User header.
If you are using this technique for authentication using our Kibana plugins, don't forget to add this snippet to conf/kibana.yml:
readonlyrest_kbn.proxy_auth_passthrough: true
So that Kibana will forward the necessary headers to Elasticsearch.
Impersonation is supported by this rule without an extra configuration.
groups_or (or groups)
groups_or (or groups)groups_or: ["group1", "group2"]
The ACL block will match when the user belongs to any of the specified groups. The information about what users belong to what groups is defined in the users section, typically situated after the ACL, further down in the YAML.
In the users section, each entry tells us that:
A given user with a username matching one of patterns in the
usernamearray ...belongs to the local groups listed in the
groupsarray (example 1 & 2 below) OR belongs to local groups that are result of "detailed group mapping" between local group ID and external groups (example 3 below).when they can be authenticated and (if authorization rule is present) authorized by the present rule(s).
In general it looks like this:
For details see User management.
Impersonation support depends on authentication and authorization rules used in users section.
For more information on the ROR's authorization rules, see Authorization rules details
groups_and
groups_andgroups_and: ["group1", "group2"]
This rule is identical to the above defined groups rule, but this time ALL the groups listed in the array are required (boolean AND logic), as opposed to at least one (boolean OR logic) of the groups rule.
ldap_authentication
ldap_authenticationsimple version: ldap_authentication: ldap1
extended version:
It handles LDAP authentication only using the configured LDAP connector (here ldap1). Check the LDAP connector section to see how to configure the connector.
ldap_authorization
ldap_authorizationIt handles LDAP authorization only using the configured LDAP connector (here ldap1). It matches when previously authenticated user has groups in LDAP and when he belongs to at least one of the configured groups (OR logic). Alternatively, groups_and can be used to require users belong to all the listed groups (AND logic). Check the LDAP connector section to see how to configure the connector.
ldap_auth
ldap_authShorthand rule that combines ldap_authentication and ldap_authorization rules together. It handles both authentication and authorization using the configured LDAP connector (here ldap1).
The same functionality can be achieved using the two rules described below:
In both ldap_authand ldap_authorization, the groups clause can be replaced by group_and to require the valid LDAP user must belong to all the listed groups:
Or equivalently:
See the dedicated LDAP section
Impersonation support by LDAP rules requires to add an extra configuration.
For more information on the ROR's authorization rules, see Authorization rules details
jwt_auth
jwt_authSee below, the dedicated JSON Web Tokens section. It's an authentication and authorization rule at the same time.
Impersonation is not currently supported by this rule.
external_authentication
external_authenticationUsed to delegate authentication to another server that supports HTTP Basic Auth. See below, the dedicated External BASIC Auth section
Impersonation support by this rule requires to add an extra configuration.
For more information on the ROR's authorization rules, see Authorization rules details
groups_provider_authorization
groups_provider_authorizationUsed to delegate groups resolution for a user to a JSON microservice. See below, the dedicated Groups Provider Authorization section
Impersonation support by this rule requires to add an extra configuration.
For more information on the ROR's authorization rules, see Authorization rules details
ror_kbn_auth
ror_kbn_authFor Enterprise customers only, required for SAML authentication. From ROR's perspective it authenticates and authorize users.
This authentication and authorization connector represents the secure channel (based on JWT tokens) of signed messages necessary for our Enterprise Kibana plugin to securely pass back to ES the username and groups information coming from browser-driven authentication protocols like SAML
Continue reading about this in the kibana plugin documentation, in the dedicated SAML section
Impersonation is currently not supported by this rule.
For more information on the ROR's authorization rules, see Authorization rules details
users
usersusers: ["root", "*@mydomain.com"]
It's NOT an authentication rule, but it can be used to limit access to of specific users whose username is contained or matches the patterns in the array. This rule is independent from the authentication method chosen, so it will work well in conjunction LDAP, JWT, proxy_auth, and all others. The rule won't be matched if there won't be an authenticated user by some other authentication rule (it means that to make sense, it should always be used in conjunction with some authentication rule).
For example:
Kibana-related rules
kibana
kibanaThe kibana rule underpins all ROR Kibana-related settings that may be needed to provide great user experience.
The rule consists of several sub-rules:
access
Enables the minimum set of Elasticsearch actions necessary for browsers to sustain a Kibana session, and rejects any other unrelated actions.
This "macro" rule allows the minimum set of actions necessary for a browser to use Kibana. It allows a set of actions towards the designated kibana index (see kibana.index), plus a stricter subset of read-only actions towards other indices, which are considered "data indices".
The idea is that with one single sub-rule we allow the bare minimum set of index+action combinations necessary to support a Kibana browsing session.
Possible access levels:
ro_strict: the browser has a read-only view on Kibana dashboards and settings and all other indices.ro: some write requests can go through to thekibana_indexindex so that the UI state in "Discover" can be saved and new short urls can be created.rw: some more requests will be allowed towards thekibana_indexindex only, so Kibana dashboards and settings can be modified.admin: likerw, but has additional permissions to save security settings in the ReadonlyREST PRO/Enterprise appapi_only: only Kibana REST API actions are allowed, login via browser is always denied.unrestricted: no action is restricted.
NB: The admin access level does not mean the user will be allowed to access all indices/actions. It's just like "rw" with settings changes privileges. If you truly require unrestricted access for your Kibana user, including ReadonlyREST PRO/Enterprise app, set kibana.access: unrestricted. You can use this rule with the users rule to restrict access to selected admins.
This sub-rule is often used with the indices rule, to limit the data a user is able to see represented on the dashboards. In that case do not forget to allow the custom kibana index in the indices rule!
index
Default value is .kibana
Specify to what index we expect Kibana to attempt to read/write its settings (use this together with kibana.index setting in the kibana.yml file)
This value directly affects how kibana.access works because at all the access levels (yes, even admin), kibana.access sub-rule will NOT match any write request in indices that are not the designated kibana index.
If used in conjunction with ReadonlyREST Enterprise, this rule enables multi tenancy, because in ReadonlyREST, a tenancy is identified with a set of Kibana configurations, which are by design collected inside a kibana index (default: .kibana).
It supports dynamic variables.
⚠️IMPORTANT When you use the kibana rule together with the indices rule in the same block, you don't have to explicitly allow the Kibana-related indices in the list of allowed indices of the indices rule. ROR will do it for you automatically.
Example:
template_index
Used to pre-populate tenancies with default kibana objects, like dashboards and visualizations. Thus providing a starting point for new tenants that will avoid the bad user experience of logging for the first time and finding a completely empty Kibana.
It supports dynamic variables.
hide_apps
Specify which Kibana apps and menu items should be hidden. This feature will work in ReadonlyREST PRO and Enterprise.
For more information on the ROR's Kibana Hide Apps feature, see Hiding Kibana Apps.
allowed_api_paths
Used to define which parts of Kibana REST API can be used. The sub-rule requires to define a list of regular expressions which describes the API paths. Additionally, when you would like to restrict only specific HTTP methods of the API, you can use the extended format of the sub-rule:
metadata
User to define the Custom ROR Kibana Metadata which can be used in Custom middleware. The kibana.metadata in ReadonlyREST settings is an unstructured YAML object.
It supports dynamic variables.
Sample usage:
alert_message Metadata can be used on the Kibana side to display information to the user on login to the Kibana.
Declare custom Kibana JS file readonlyrest_kbn.kibana_custom_js_inject_file: '/path/to/custom_kibana.js'. it's injected at the end of the HTML Body tag of the Kibana UI frontend code.
kibana_access
kibana_accesskibana_access: ro
⚠️Deprecated: it's equivalent of kibana.access. Should no longer be used.
kibana_index
kibana_indexkibana_index: .kibana-user1
⚠️Deprecated: it's equivalent of kibana.index. Should no longer be used.
kibana_template_index
kibana_template_indexkibana_template_index: .kibana_template
⚠️Deprecated: it's equivalent of kibana.template_index. Should no longer be used.
kibana_hide_apps
kibana_hide_appskibana_hide_apps: [ "Security", "Enterprise Search"]
⚠️Deprecated: it's equivalent of kibana.hide_apps. Should no longer be used.
Elasticsearch level rules
indices
indicesindices: ["sales", "logstash-*"]
Matches if the request involves a set of indices (or aliases, or data streams) whose name is "sales", or starts with the string "logstash-", or a combination of both.
If a request involves a wildcard (i.e. "logstash-*", "*"), this is first expanded to the list of available indices, and then treated normally as follows:
Requests that do not involve any indices (cluster admin, etc) result in a "match".
Requests that involve only allowed indices result in a "match".
Requests that involve a mix of allowed and not-allowed indices, are rewritten to only involve allowed indices, and result in a "match".
Requests that involve only not-allowed indices result in a "no match". And the ACL evaluation moves on to the next block.
The rejection message and HTTP status code returned to the requester are chosen carefully with the main intent to simulate not-allowed indices do not exist at all.
The rule has also an extended version:
The definition above has the same meaning as the shortest version shown at the beginning of this section. By default the rule will be matched when a request doesn't involve indices (eg. /_cat/nodes request). But we can change the behaviour by configuring must_involve_indices: true - in this case the request above will be rejected by the rule.
In detail, with examples
In ReadonlyREST we roughly classify requests as:
"read": the request will not change the data or the configuration of the cluster
"write": when allowed, the request changes the internal state of the cluster or the data.
If a read request involves some indices they have permissions for and some indices that they do NOT have permission for, the request is rewritten to involve only the subset of indices they have permission for. This is behaviour is very useful in Kibana: different users can see the same dashboards, but they are filled with a different, overlapping, or identical data set (according to the indices permissions).
When the subset of indices is empty, it means that user are not allowed to access requested indices. In multitenancy environment we should consider two options:
requested indices don't exist
requested indices exist but the current user is not authorized to access them
For both of these cases ROR is going to return HTTP 404 or HTTP 200 with an empty response. The same behaviour will be observed for ES with ROR disabled (for nonexistent index). If an index does exist, but a user is not authorized to access it, ROR is going to pretend that the index doesn't exist and a response will be the same like the index actually did not exist. See detailed example.
It's also worth mentioning, that when prompt_for_basic_auth is set to true (that is, the default value), ROR is going to return 401 instead of 404 HTTP status code. It is relevant for users who don't use ROR Kibana's plugin and who would like to take advantage of default Kibana's behaviour which shows the native browser basic auth dialog, when it receives HTTP 401 response.
If a write request wants to write to indices they don't have permission for, the write request is rejected.
Requests related to templates
Templates are also connected with indices, but rather indirectly. An index template has index patterns and could also have aliases. During an index template creation or modification, ROR checks if index patterns and aliases, defined in a request body, are allowed. When a user tries to remove or get template by name, ROR checks if the template can be considered as allowed for the user, and based on that information, it allows/forbids to remove or see it. See details.
actions
actionsactions: ["indices:data/read/*"]
Match if the request action starts with "indices:data/read/".
In Elasticsearch, each request carries only one action. We extracted from Elasticsearch source code the full list of valid action strings as of all Elasticsearch versions. Please see the dedicated section to find the actions list of your specific Elasticsearch version.
Example actions (see above for the full list):
snapshots
snapshotssnapshots: ["snap_@{user}_*"]
Restrict what snapshots names can be saved or restored
repositories
repositoriesrepositories: ["repo_@{user}_*"]
Restrict what repositories can snapshots be saved into
data_streams
data_streamsdata_streams: ["ds_@{user}_*"]
Restrict what data stream names can be created, deleted, or modified
filter
filterfilter: '{"query_string":{"query":"user:@{user}"}}'
This rule enables Document Level Security (DLS). That is: return only the documents that satisfy the boolean query provided as an argument.
This rule lets you filter the results of a read request using a boolean query. You can use dynamic variables i.e. @{user} (see dedicated paragraph) to inject a user name or some header values in the query, or even environmental variables.
Example: per-user index segmentation
In the index "test-dls", each user can only search documents whose field "user" matches their user name. I.e. A user with username "paul" requesting all documents in "test-dls" index, won't see returned a document containing a field "user": "jeff" .
Example 2: Prevent search of "classified" documents.
In this example, we want to avoid that users belonging to group "press" can see any document that has a field "access_level" with the value "CLASSIFIED". And this policy is applied to all indices (no indices rule is specified).
⚠️IMPORTANT The filterand fields rules will only affect "read" requests, therefore "write" requests will not match because otherwise it would implicitly allow clients to "write" without the filtering restriction. For reference, this behaviour is identical to x-pack and search guard.
⚠️IMPORTANT Beginning with version 1.27.0 all ROR internal requests from kibana will not match blocks containing filter and/or fields rules. There requests are used to perform kibana login and dynamic config reload.
If you want to allow write requests (i.e. for Kibana sessions), just duplicate the ACL block, have the first one with filter and/or fields rule, and the second one without.
fields
fieldsThis rule enables Field Level Security (FLS). That is:
for responses where fields with values are returned (e.g. Search/Get API) - filter and show only allowed fields
make not allowed fields unsearchable - used in QueryDSL requests (e.g. Search/MSearch API) do not have impact on search result.
In other words: FLS protects from usage some not allowed fields for a certain user. From user's perspective it seems like such fields are nonexistent.
Definition
Field rule definition consists of two parts:
A non empty list of fields (blacklisted or whitelisted) names. Supports wildcards and user runtime variables.
The FLS engine definition (global setting, optional). See: engine details.
⚠️IMPORTANT With default FLS engine it's required to install ReadonlyREST plugin in all the data nodes. Different configurations allowing to avoid such requirement are described in engine details.
Field names
Fields can be defined using two access modes: blacklist and whitelist.
Blacklist mode (recommended)
Specifies which fields should not be allowed prefixed with ~ (other fields from mapping become allowed implicitly). Example:
fields: ["~excluded_fields_prefix_*", "~excluded_field", "~another_excluded_field.nested_field"]
Return documents but deprived of the fields that:
start with
excluded_fields_prefix_are equal to
excluded_fieldare equal to
another_excluded_field.nested_field
Whitelist mode
Specifies which fields should be allowed explicitly (other fields from mapping become not allowed implicitly). Example:
fields: ["allowed_fields_prefix_*", "_*", "allowed_field.nested_field.text"]
Return documents deprived of all the fields, except the ones that:
start with
allowed_fields_prefix_start with underscore
are equal to
allowed_field.nested_field.text
NB: You can only provide a full black list or white list. Grey lists (i.e. ["~a", "b"]) are invalid settings and ROR will refuse to boot up if this condition is detected.
Example: hide prices from catalogue indices
⚠️IMPORTANT Any metadata fields e.g. _id or _index can not be used in fields rule.
⚠️IMPORTANT The filterand fields rules will only affect "read" requests, therefore "write" requests will not match because otherwise it would implicitly allow clients to "write" without the filtering restriction. For reference, this behaviour is identical to x-pack and search guard.
⚠️IMPORTANT Beginning with version 1.27.0 all ROR internal requests from kibana will not match blocks containing filter and/or fields rules. There requests are used to perform kibana login and dynamic config reload.
If you want to allow write requests (i.e. for Kibana sessions), just duplicate the ACL block, have the first one with filter and/or fields rule, and the second one without.
Configuring an ACL with filter/fields rules when using Kibana
A normal Kibana session interacts with Elasticsearch using a mix of actions which we can roughly group in two macro categories of "read" and "write" actions. However the fields and filter rules will only match read requests. They will also block ROR internal request used to log in to kibana and reload config. This means that a complete Kibana session cannot anymore be entirely matched by a single ACL block like it normally would.
For example, this ACL block would perfectly support a complete Kibana session. That is, 100% of the actions (browser HTTP requests) would be allowed by this ACL block.
However, when we introduce a filter (or fields) rule, this block will be able to match only some of the actions (only the "read" ones).
The solution is to duplicate the block. The first one will intercept (and filter!) the read requests. The second one will intercept the remaining actions. Both ACL blocks together will entirely support a whole Kibana session.
NB: Look at how we make sure that the requests to ".kibana" won't get filtered by specifying an indices rule in the first block.
Here is another example, a bit more complex. Look at how we can duplicate the "PERSONAL_GRP" ACL block so that the read requests to the "r*" indices can be filtered, and all the other requests can be intercepted by the second rule (which is identical to the one we had before the duplication).
Before adding the filter rule:
After adding the filter rule (using the block duplication strategy).
response_fields
response_fieldsThis rule allows filtering Elasticsearch responses using a list of fields. It works in very similar way to fields rule. In contrast to fields rule, which filters out document fields, this rule filters out response fields. It doesn't make use of Field Level Security (FLS) and can be applied to every response returned by Elasticsearch.
It can be configured in two modes:
whitelist allowing only the defined fields from the response object
blacklist filtering out (removing) only the defined fields from the response object
Blacklist mode
Specifies which fields should be filtered out by adding the ~ prefix to the field name. Other fields in the response will be implicitly allowed. For example:
response_fields: ["~excluded_fields_prefix_*", "~excluded_field", "~another_excluded_field.nested_field"]
The above will return the usual response object, but deprived (if found) of the fields that:
start with
excluded_fields_prefix_are equal to
excluded_fieldare equal to
another_excluded_field.nested_field
Wildcard across nested fields It's possible to use the * character to intercept nested fields. Imagine having this document:
You can write this fields rule containing a pattern that uses the * right after the ~:
Now the search response will omit the string field credit_card_confidential, and the whole object resp.raw_text.phone_number_confidential, or any other field whose name ends in "_confidential", regardless of their type or if and how deeply it's nested.
Whitelist mode
In this mode rule is configured to filter out each field that isn't defined in the rule.
response_fields: ["allowed_fields_prefix_*", "_*", "allowed_field.nested_field.text"]
Return response deprived of all the fields, except the ones that:
start with
allowed_fields_prefix_start with underscore
are equal to
allowed_field.nested_field.text
NB: You can only provide a full black list or white list. Grey lists (i.e. ["~a", "b"]) are invalid settings and ROR will refuse to boot up if this condition is detected.
Example: allow only cluster_name and status field in cluster health response:
Without any filtering response from /_cluster/health looks more or less like:
but after configuring such rule:
response from above will look like:
NB: Any response field can be filtered using this rule.
HTTP Level rules
x_forwarded_for
x_forwarded_forx_forwarded_for: ["192.168.1.0/24"]
Behaves exactly like hosts, but gets the source IP address (a.k.a. origin address, OA in logs) inside the X-Forwarded-For header only (useful replacement to hostsrule when requests come through a load balancer like AWS ELB)
Load balancers
This is a nice tip if your Elasticsearch is behind a load balancer. If you want to match all the requests that come through the load balancer, use x_forwarded_for: ["0.0.0.0/0"]. This will match the requests with a valid IP address as a value of the X-Forwarded-For header.
DNS lookup caching
It's worth to note that resolutions of DNS are going to be cached by JVM. By default successfully resolved IPs will be cached forever (until Elasticsearch is restarted) for security reasons. However, this may not always be the desired behaviour, and it can be changed by adding the following JVM options either in the jvm.options file or declaring the ES_JAVA_OPTS environment variable: sun.net.inetaddr.ttl=TTL_VALUE (or/and sun.net.inetaddr.negative.ttl=TTL_VALUE). More details about the problem can be found here.
methods
methodsmethods: [GET, DELETE]
Match requests with HTTP methods specified in the list. N.B. Elasticsearch HTTP stack does not make any difference between HEAD and GET, so all the HEAD request will appear as GET.
headers_and (or headers)
headers_and (or headers)headers: ["h1:x*y","~h2:*xy"]
Match if all the HTTP headers in the request match the defined patterns in headers rule. This is useful in conjunction with proxy_auth, to carry authorization information (i.e. headers: x-usr-group: admins).
The ~ sign is a pattern negation, so eg. ~h2:*xy means: match if h2 header's value does not match the pattern *xy, or h2 is not present at all.
headers_or
headers_orheaders_or: ["x-myheader:val*","~header2:*xy"]
Match if at least one the specified HTTP headers key:value pairs is matched.
uri_re
uri_reuri_re: ["^/secret-index/.*", "^/some-index/.*"]
☠️HACKY (try to use indices/actions rule instead)
Match if at least one specified regular expression matches requested URI.
maxBodyLength
maxBodyLengthmaxBodyLength: 0
Match requests having a request body length less or equal to an integer. Use 0 to match only requests without body.
NB: Elasticsearch HTTP API breaks the specifications, nad GET requests might have a body length greater than zero.
api_keys
api_keysapi_keys: [123456, abcdefg]
A list of api keys expected in the header X-Api-Key
session_max_idle
session_max_idlesession_max_idle: 1h
⚠️DEPRECATED Browser session timeout (via cookie). Example values 1w (one week), 10s (10 seconds), 7d (7 days), etc. NB: not available for Elasticsearch 2.x.
Transport level rules
These are the most basic rules. It is possible to allow/forbid requests originating from a list of IP addresses, host names or IP networks (in slash notation).
hosts
hostshosts: ["10.0.0.0/24"] Match a request whose origin IP address (also called origin address, or OA in logs) matches one of the specified IP addresses or subnets.
accept_x-forwarded-for_header
accept_x-forwarded-for_headeraccept_x-forwarded-for_header: false
⚠️DEPRECATED (use x_forwarded_for instead) A modifier for hosts rule: if the origin IP won't match, fallback to check the X-Forwarded-For header
hosts_local
hosts_localhosts_local: ["127.0.0.1", "127.0.0.2"] Match a request whose destination IP address (called DA in logs) matches one of the specified IP addresses or subnets. This finds application when Elasticsearch HTTP API is bound to multiple IP addresses.
Ancillary block settings
verbosity
verbosityverbosity: error
Don't spam elasticsearch log file printing log lines for requests that match this block. Defaults to info.
Audit & Troubleshooting
The main issues seen in support cases:
Bad ordering or ACL blocks. Remember that the ACL is evaluated sequentially, block by block. And the first block whose rules all match is accepted.
Users don't know how to read the
HISfield in the logs, which instead is crucial because it contains a trace of the evaluation of rules and blocks.LDAP configuration: LDAP is tricky to configure in any system. Configure ES root logger to
DEBUGediting$ES_PATH_CONF/config/log4j2.propertiesto see a trace of the LDAP messages.
Interpreting logs
ReadonlyREST prints a log line for each incoming request (this can be selectively avoided on ACL block level using the verbosity rule).
Allowed requests
This is an example of a request that matched an ACL block (allowed) and has been let through to Elasticsearch.
ALLOWED by { name: '::PERSONAL_GRP::', policy: ALLOW} req={ ID:1667655475--1038482600#1312339, TYP:SearchRequest, CGR:N/A, USR:simone, BRS:true, ACT:indices:data/read/search, OA:127.0.0.1, IDX:, MET:GET, PTH:/_search, CNT:<N/A>, HDR:Accept,Authorization,content-length,Content-Type,Host,User-Agent,X-Forwarded-For, HIS:[::PERSONAL_GRP::->[kibana_access->true, kibana_hide_apps->true, auth_key->true, kibana_index->true]], [::Kafka::->[auth_key->false]], [::KIBANA-SRV::->[auth_key->false]], [guest lol->[auth_key->false]], [::LOGSTASH::->[auth_key->false]] }
Explanation
The log line immediately states that this request has been allowed by an ACL block called "::PERSONAL_GRP::". Immediately follows a summary of the requests' anatomy. The format is semi-structured, and it's intended for humans to read quickly, it's not JSON, or anything else.
Similar information gets logged in JSON format via audit events feature described later.
Here is a glossary:
ID: ReadonlyREST-level request idTYP: String, the name of the Java class that internally represent the request type (very useful for debug)CGR: String, the request carries a "current group" header (used for multi-tenancy).USR: String, the user name ReadonlyREST was able to extract from Basic Auth, JWT, LDAP, or other methods as specified in the ACL.BRS: Boolean, an heuristic attempt to tell if the request comes from a browser.ACT: String, the elasticsearch level action associated with the request. For a list of actions, see our actions rule docs.OA: IP Address, originating address (source address) of the TCP connection underlying the http session.IDX: Strings array: the list of indices affected by this request.MET: String, HTTP MethodCNT: String, HTTP body content. Comes as a summary of its length, full body of the request is available in debug mode.HDR: String array, list of HTTP headers, headers' content is available in debug mode.HIS: Chronologically ordered history of the ACL blocks and their rules being evaluated, This is super useful for knowing what ACL block/rule is forbidding/allowing this request.
In the example, the block ::PERSONAL_GRP:: is allowing the request because all the rules in this block evaluate to true.
Forbidden requests
This is an example of a request that gets forbidden by ReadonlyREST ACL.
The above rule gets forbidden "by default". This means that no ACL block has matched the request, so ReadonlyREST's default policy of rejection takes effect.
Requests finished with INDEX NOT FOUND
This is an example of such request:
The state above is only possible for read-only ES requests (ES requests which don't change ES cluster state) for a block containing an indices rule. If all other rules within the block are matched, but only the indices rule is mismatched, the final state of the block is forbidden due to an index not found.
Audit
ReadonlyREST can gather audit events that contain information regarding a request and its processing by the system, which can then be forwarded to predefined outputs. You can use the available information from the audit events to construct interesting visual representations, such as Kibana dashboards or any other visualization tool. For details see Audit configuration.
Troubleshooting
Follow these approaches until you find the solution to your problem
Scenario: you can't understand why your requests are being forbidden by ReadonlyREST (or viceversa)
Step 1: see what block/rule is matching Take the Elasticsearch log file, and grep the logs for ACT:. This will show you the whole request context (including the action and indices fields) of the blocked requests. You can now tweak your ACL blocks to include that action.
Step 2: enable debug logs
Logs are good for auditing the activity on the REST API. You can configure them by editing $ES_PATH_CONF/config/logging.yml (Elasticsearch 2.x) or $ES_PATH_CONF/config/log4j2.properties file (Elasticsearch 5.x)
For example, you can enable the debug log globally by setting the rootLoggerto debug.
This is really useful especially to debug the activity of LDAP and other external connectors.
Trick: log requests to different files
Here is a log4j2.properties snippet for ES 5.x that logs all the received requests as a new line in a separate file:
Users and Groups
Sometimes we want to make allow/forbid decisions according to the username associated to a HTTP request. The extraction of the user identity (username) can be done via HTTP Basic Auth (Authorization header) or delegated to a reverse proxy (see proxy_auth rule).
The validation of the said credentials can be carried on locally with hard coded credential hashes (see auth_key_sha256 rule), via one or more LDAP server, or we can forward the Authorization header to an external web server and examine the HTTP status code (see external_authentication).
Optionally we can introduce the notion of groups (see them as bags of users). The aim of having groups is to write a very specific block once, and being able to allow multiple usernames that satisfy the block.
Groups can be declared and associated to users statically in the readonlyrest.yml file. Alternatively, groups for a given username can be retrieved from an LDAP server or from a LDAP server, or a custom JSON/XML service.
You can mix and match the techniques to satisfy your requirements. For example, you can configure ReadonlyREST to:
Extract the username from X-Forwarded-User
Resolve groups associated to said user through a JSON microservice
Another example:
Extract the username from Authorization header (HTTP Basic Auth)
Validate said username's password via LDAP server
resolve groups associated to the user from groups defined in readonlyrest.yml
More examples are shown below together with a sample configuration.
Local users and groups
The groups rule accepts a list of group IDs. This rule will match if the resolved username (i.e. via auth_key) is associated with the given groups.
In this example, usernames alice and claire are statically associated with group IDs.
The username bob is statically associated with structered groups(a special syntax for defining groups, which may be helpful in the case of the Enterprise Kibana plugin)
Example: rules are associated to groups (instead of users) and users-group association is declared separately later under users:
Group mapping
Sometimes we'd like to take advantage of groups (roles) existing in external systems (like LDAP). We can do that in users section too. It's possible to map external groups to local ones. For details see External to local groups mapping .
Username case sensitivity
ReadonlyREST can cooperate with services, that operates in case-insensitive way. For this case ROR has toggleable username case sensitivity option username_case_sensitivity.
By default, usernames are case-sensitive username_case_sensitivity: case_sensitive. By setting username_case_sensitivity: case_insensitive username comparison will be case-insensitive in any rule.
Static variables
Anywhere in readonlyrest.yml you can use the expression ${env:MY_ENV_VAR} to replace in place the environmental variables. This is very useful for injecting credentials like LDAP bind passwords, especially in Docker.
For example, here we declare an environment variable, and we write ${env:LDAP_PASSWORD} in our settings:
And ReadonlyREST ES will load "S3cr3tP4ss" as bind_password.
Dynamic variables
One of the neatest features in ReadonlyREST is that you can use dynamic variables inside most values of the following rules: data_streams, indices, users, groups_or, groups_and, fields, filter, repositories, hosts, hosts_local, snapshots, response_fields, uri_re, x_forwarded_for, hosts_local, hosts, kibana.index, kibana.template_index, kibana.metadata. The variables are related to different contexts:
acl- the context of data collected in authentication and authorization rules of the current block:@{acl:user}gets replaced with the username of the successfully authenticated user. Using this variable is allowed only in blocks where one of the rules is an authentication rule of course it must be a rule different from the one containing the given variable.@{acl:current_group}is the group ID explicitly requested by the tenancy selector in ReadonlyREST Enterprise plugin when using multi-tenancy.@{acl:available_groups}gets replaced with available group IDs found in the authorization rule (because by default dynamic variables are resolved to a string, the variable resolved value will contain groups surrounded with double quotes and joined with a comma)
header- the context of ES HTTP request headers@{header:<header_name>}gets replaced with the value of the HTTP header with name<header_name>included in the incoming request (useful when reverse proxies handle authentication)
jwt- the context of JWT header value@{jwt:<json_path>}get replaced with value (or values) found in the JWT claim under the given JSON path
Dynamic variables exploding
A value resolved from a dynamic variable is a string. Some rules, like indices one, have multivalue context (you can configure several indices names in it).
Let's assume we have a request with the header: APPS: app1,app2,app3. Doing something like this:
We should expect it to be resolved to:
for this particular request. No, it wouldn't be helpful at all. But there is an explode function for dynamic variables. Doing:
we should get:
which looks more useful!
So, as we've seen, the explode attribute of a dynamic variable rule can be used to split a string with comma-separated values into an array of strings. But it can only be used in a rule with multi value context.
Usage examples
Indices from user name
You can let users authenticate externally, i.e. via LDAP, and use their user name string inside the indices rule.
Indices from available groups
You can let users authorize externally, i.e. via LDAP, and use their group strings inside the indices rule.
Filter from available groups
You can let users authorize externally, i.e. via LDAP, and use their group strings inside the filter rule.
Uri regex matching user's current group
You can let users authorize externally, i.e. via LDAP, and use their group inside the uri_re rule.
Kibana index from headers
Imagine that we delegate authentication to a reverse proxy, so we know that only authenticated users will ever reach Elasticsearch. We can tell the reverse proxy (i.e. Nginx) to inject a header called x-nginx-user containing the username.
Dynamic variables from JWT claims
The JWT token is an authentication string passed generally as a header or a query parameter to the web browser. If you squint, you can see it's a concatenation of three base64 encoded strings. If you base64 decode the middle string, you can see the "claims object". That is the object containing the current user's metadata.
Here is an example of JWT claims object.
Here follow some examples of how to use JWT claims as dynamic variables in ReadonlyREST ACL blocks, notice the "jwt:" prefix:
Variables functions
A value resolved from a variable may not be valid in some contexts. Sometimes, the value from the variable needs some preprocessing before usage. For example, a HTTP header value containing the uppercase characters is a wrong candidate for the index name because it has to be a lowercase string. We introduced variable functions to overcome these limitations. They allow modification of the variable values during the variable resolution (both, static and dynamic variables are supported).
With their help, you can use the HTTP header X-Forwarded-User: James containing uppercase characters in the indices rule:
which resolves to:
Syntax
In general, functions syntax is as follows:
function_name("arg1","arg2")
function_name- a function that you want to apply(...)- function call parentheses (they may be omitted when the function has no args)arg1,arg2- arguments passed to function. They should be surrounded by". If your argument contains a special character ("or}), you can escape it with a\, e.g. (function_a("\}"))
You can chain functions with the . operator (functions are applied in order from left to right):
function_a("arg1").function_b.function_c("arg1")
To apply functions to the variable, you need to use the # operator and enter your code in { } braces:
Supported functions
Currently, we support functions like this:
replace_all(regex,replacement)- Replaces each substring of the variable string that matches the given regular expression with the given replacement.Params:
regex- the regular expression to which the variable string is to be matchedreplacement- the string to be substituted for each match
Usage:
replace_first(regex,replacement)- Replaces the first substring of the variable string that matches the given regular expression with the given replacement.Params:
regex- the regular expression to which the variable string is to be matchedreplacement- the string to be substituted for each match
Usage example:
to_lowercase- Converts all characters in the variable string to lower caseUsage example:
to_uppercase- Converts all characters in the variable string to upper case Usage example:
💡 Didn't find the function you are looking for?
We can easily extend the function list. If you need any new function/mechanism that cannot be obtained using the supported functions, let us know about it in our forum. We will consider adding the proper implementation.
Variable function aliases
Sometimes, the function chain may be very complex or occur multiple times in ACL. In this case, you can use a function aliases to simplify configuration management. The function alias allows you to export your function chain outside the ACL. Then you can substitute your function via alias func(alias_name).
Let's assume that we have the following configuration, and we want to introduce some function aliases:
You can define function aliases in the readonlyrest.variables_function_aliases section and substitute functions code with func(alias):
LDAP connector
The authentication and authorization rules for LDAP (ldap_auth, ldap_authentication, ldap_authorization) defined in the rules section, always need to contain a reference by name to one LDAP connector. One or more LDAP connectors need to be defined in the section "ldaps" of the ACL.
Configuration notes
If you would like to experiment with LDAP and need a development server, you can stand up an OpenLDAP server configuring it using our schema file, which can be found in our tests).
Technical configuration
There are also plenty of technical settings which can be useful:
an LDAP server address:
single host:
host(String, required) - LDAP server addressport(Integer, optional, default:389) - LDAP server portssl_enabled(Boolean, optional, default:true) - enables or disables SSL for LDAP connection
several hosts:
hosts(List, required) - list of LDAP server addresses. The address should look like thisldap://[HOST]:[PORT]or/andldaps://[HOST]:[PORT]ha(enum: [FAILOVER,ROUND_ROBIN], optional, default:FAILOVER) - provides high availability strategy for LDAP
auto-discovery:
server_discovery(Boolean|YAML object, optional, default:false) - for details see LDAP server discovery section
connection_pool_size(Integer, optional, default:30) - indicates how many connections LDAP connector should create to LDAP serverconnection_timeout(Duration, optional, default:10 sec) - instructs connector how long it should wait for the connection to LDAP serverrequest_timeout(Duration, optional, default:10 sec) - instructs connector how long it should wait for receiving a whole response from LDAP serverssl_trust_all_certs(Boolean, optional, default:false) - if it is set totrue, untrusted certificates will be acceptedignore_ldap_connectivity_problems(Boolean, optional, default:false) - when it is set totrue, it allows ROR to function even when LDAP server is unreachable. Rules using unreachable LDAP servers won't match. By default, ROR starts only after it's able to connect to each servercache_ttl(Duration, optional, default:0 sec) - tells how long LDAP connector should cache queries results (for default see caching section)circuit_breaker(YAML object, optional, default:max_retries: 10,reset_duration: 10 sec) - for details see circuit breaker section
Query configuration
Usually, we would like to configure three main things for defining the way LDAP users and groups are queried:
a way to authenticate client (LDAP binding; used by all LDAP rules):
bind_dn(string, optional, default: [not present]) - a username used to connect to the LDAP service. We can skip this setting when our LDAP service allows for anonymous bindingbind_password(string, optional, default: [not present]) - a password used to connect to the LDAP service. We can skip this setting when our LDAP service allows for anonymous binding
a way to search users. In ROR it can be done using the following YAML keys (under the
userssection) (used by all LDAP rules):search_user_base_DN(string, required) - should refer to the base Distinguished Name of the users to be authenticateduser_id_attribute(string, optional, default:uid) - should refer to a unique ID for the user within the base DNskip_user_search(boolean, optional, default:false) - when you set