Configure Elasticsearch for OpenID Connect authenticationedit

The following is a summary of the configuration steps required in order to enable authentication using OpenID Connect in Elasticsearch:

Enable TLS for HTTPedit

If your Elasticsearch cluster is operating in production mode, then you must configure the HTTP interface to use SSL/TLS before you can enable OpenID Connect authentication.

For more information, see Encrypting HTTP Client Communications.

Enable the token serviceedit

The Elasticsearch OpenID Connect implementation makes use of the Elasticsearch Token Service. This service is automatically enabled if you configure TLS on the HTTP interface, and can be explicitly configured by including the following in your elasticsearch.yml file: true

Create an OpenID Connect realmedit

OpenID Connect based authentication is enabled by configuring the appropriate realm within the authentication chain for Elasticsearch.

This realm has a few mandatory settings, and a number of optional settings. The available settings are described in detail in the Security settings in Elasticsearch. This guide will explore the most common settings.

Create an OpenID Connect (the realm type is oidc) realm in your elasticsearch.yml file similar to what is shown below:


The values used below are meant to be an example and are not intended to apply to every use case. The details below the configuration snippet provide insights and suggestions to help you pick the proper values, depending on your OP configuration.
  order: 2
  rp.client_id: "the_client_id"
  rp.response_type: code
  rp.redirect_uri: ""
  op.issuer: ""
  op.authorization_endpoint: ""
  op.token_endpoint: ""
  op.jwkset_path: oidc/jwkset.json
  op.userinfo_endpoint: ""
  op.endsession_endpoint: ""
  rp.post_logout_redirect_uri: ""
  claims.principal: sub
  claims.groups: ""

The configuration values used in the example above are:
This defines a new oidc authentication realm named "oidc1". See Realms for more explanation of realms.
You should define a unique order on each realm in your authentication chain. It is recommended that the OpenID Connect realm be at the bottom of your authentication chain (that is, that it has the highest order).
This, usually opaque, arbitrary string, is the Client Identifier that was assigned to the Elastic Stack RP by the OP upon registration.

This is an identifier that controls which OpenID Connect authentication flow this RP supports and also which flow this RP requests the OP should follow. Supported values are

  • code, which means that the RP wants to use the Authorization Code flow. If your OP supports the Authorization Code flow, you should select this instead of the Implicit Flow.
  • id_token token which means that the RP wants to use the Implicit flow and we also request an oAuth2 access token from the OP, that we can potentially use for follow up requests ( UserInfo ). This should be selected if the OP offers a UserInfo endpoint in its configuration, or if you know that the claims you will need to use for role mapping are not available in the ID Token.
  • id_token which means that the RP wants to use the Implicit flow, but is not interested in getting an oAuth2 token too. Select this if you are certain that all necessary claims will be contained in the ID Token or if the OP doesn’t offer a User Info endpoint.
The redirect URI where the OP will redirect the browser after authentication. This needs to be exactly the same as the one configured with the OP upon registration and will typically be ${kibana-url}/api/security/v1/oidc where ${kibana-url} is the base URL for your Kibana instance
A verifiable Identifier for your OpenID Connect Provider. An Issuer Identifier is usually a case sensitive URL. The value for this setting should be provided by your OpenID Connect Provider.
The URL for the Authorization Endpoint in the OP. This is where the user’s browser will be redirected to start the authentication process. The value for this setting should be provided by your OpenID Connect Provider.
The URL for the Token Endpoint in the OpenID Connect Provider. This is the endpoint where Elasticsearch will send a request to exchange the code for an ID Token, in the case where the Authorization Code flow is used. The value for this setting should be provided by your OpenID Connect Provider.
The path to a file or a URL containing a JSON Web Key Set with the key material that the OpenID Connect Provider uses for signing tokens and claims responses. If a path is set, it is resolved relative to the Elasticsearch config directory. Elasticsearch will automatically monitor this file for changes and will reload the configuration whenever it is updated. Your OpenID Connect Provider should provide you with this file or a URL where it is available.
(Optional) The URL for the UserInfo Endpoint in the OpenID Connect Provider. This is the endpoint of the OP that can be queried to get further user information, if required. The value for this setting should be provided by your OpenID Connect Provider.
(Optional) The URL to the End Session Endpoint in the OpenID Connect Provider. This is the endpoint where the user’s browser will be redirected after local logout, if the realm is configured for RP initiated Single Logout and the OP supports it. The value for this setting should be provided by your OpenID Connect Provider.
(Optional) The Redirect URL where the OpenID Connect Provider should redirect the user after a successful Single Logout (assuming op.endsession_endpoint above is also set). This should be set to a value that will not trigger a new OpenID Connect Authentication, such as ${kibana-url}/logged_out where ${kibana-url} is the base URL for your Kibana instance.
See Claims mapping.
See Claims mapping.

A final piece of configuration of the OpenID Connect realm is to set the Client Secret that was assigned to the RP during registration in the OP. This is a secure setting and as such is not defined in the realm configuration in elasticsearch.yml but added to the elasticsearch keystore. For instance

bin/elasticsearch-keystore add

According to the OpenID Connect specification, the OP should also make their configuration available at a well known URL, which is the concatenation of their Issuer value with the .well-known/openid-configuration string. For example: That document should contain all the necessary information to configure the OpenID Connect realm in Elasticsearch.

Claims mappingedit

Claims and scopesedit

When authenticating to Kibana using OpenID Connect, the OP will provide information about the user in the form of OpenID Connect Claims, that can be included either in the ID Token, or be retrieved from the UserInfo endpoint of the OP. The claim is defined as a piece of information asserted by the OP for the authenticated user. Simply put, a claim is a name/value pair that contains information about the user. Related to claims, we also have the notion of OpenID Connect Scopes. Scopes are identifiers that are used to request access to specific lists of claims. The standard defines a set of scope identifiers that can be requested. The only mandatory one is openid, while commonly used ones are profile and email. The profile scope requests access to the name,family_name,given_name,middle_name,nickname, preferred_username,profile,picture,website,gender,birthdate,zoneinfo,locale, and updated_at claims. The email scope requests access to the email and email_verified claims. The process is that the RP requests specific scopes during the authentication request. If the OP Privacy Policy allows it and the authenticating user consents to it, the related claims are returned to the RP (either in the ID Token or as a UserInfo response).

The list of the supported claims will vary depending on the OP you are using, but you can expect the Standard Claims to be largely supported.

Mapping claims to user propertiesedit

The goal of claims mapping is to configure Elasticsearch in such a way as to be able to map the values of specified returned claims to one of the user properties that are supported by Elasticsearch. These user properties are then utilized to identify the user in the Kibana UI or the audit logs, and can also be used to create role mapping rules.

The recommended steps for configuring OpenID Claims mapping are as follows:

  1. Consult your OP configuration to see what claims it might support. Note that the list provided in the OP’s metadata or in the configuration page of the OP is a list of potentially supported claims. However, for privacy reasons it might not be a complete one, or not all supported claims will be available for all authenticated users.
  2. Read through the list of user properties that Elasticsearch supports, and decide which of them are useful to you, and can be provided by your OP in the form of claims. At a minimum, the principal user property is required.
  3. Configure your OP to "release" those claims to your Elastic Stack Relying party. This process greatly varies by provider. You can use a static configuration while others will support that the RP requests the scopes that correspond to the claims to be "released" on authentication time. See rp.requested_scopes for details about how to configure the scopes to request. To ensure interoperability and minimize the errors, you should only request scopes that the OP supports, and which you intend to map to Elasticsearch user properties.
  4. Configure the OpenID Connect realm in Elasticsearch to associate the Elasticsearch user properties (see the listing below), to the name of the claims that your OP will release. In the example above, we have configured the principal and groups user properties as follows:

    1. claims.principal: sub : This instructs Elasticsearch to look for the OpenID Connect claim named sub in the ID Token that the OP issued for the user ( or in the UserInfo response ) and assign the value of this claim to the principal user property. sub is a commonly used claim for the principal property as it is an identifier of the user in the OP and it is also a required claim of the ID Token, thus offering guarantees that it will be available. It is, however, only used as an example here, the OP may provide another claim that is a better fit for your needs.
    2. claims.groups: "" : Similarly, this instructs Elasticsearch to look for the claim with the name (note that this is a URI - an identifier, treated as a string and not a URL pointing to a location that will be retrieved) either in the ID Token or in the UserInfo response, and map the value(s) of it to the user property groups in Elasticsearch. There is no standard claim in the specification that is used for expressing roles or group memberships of the authenticated user in the OP, so the name of the claim that should be mapped here, will vary greatly between providers. Consult your OP documentation for more details.

Elasticsearch user propertiesedit

The Elasticsearch OpenID Connect realm can be configured to map OpenID Connect claims to the following properties on the authenticated user:

(Required) This is the username that will be applied to a user that authenticates against this realm. The principal appears in places such as the Elasticsearch audit logs.

If the principal property fails to be mapped from a claim, the authentication fails.

(Recommended) If you wish to use your OP’s concept of groups or roles as the basis for a user’s Elasticsearch privileges, you should map them with this property. The groups are passed directly to your role mapping rules.
(Optional) The user’s full name.
(Optional) The user’s email address.
(Optional) The user’s X.500 Distinguished Name.

Extracting partial values from OpenID Connect claimsedit

There are some occasions where the value of a claim may contain more information than you wish to use within Elasticsearch. A common example of this is one where the OP works exclusively with email addresses, but you would like the user’s principal to use the local-name part of the email address. For example if their email address was, then you would like their principal to simply be james.wong.

This can be achieved using the claim_patterns setting in the Elasticsearch realm, as demonstrated in the realm configuration below:
  order: 2
  rp.client_id: "the_client_id"
  rp.response_type: code
  rp.redirect_uri: ""
  op.authorization_endpoint: ""
  op.token_endpoint: ""
  op.userinfo_endpoint: ""
  op.endsession_endpoint: ""
  op.issuer: ""
  op.jwkset_path: oidc/jwkset.json
  claims.principal: email_verified
  claim_patterns.principal: "^([^@]+)@staff\\.example\\.com$"

In this case, the user’s principal is mapped from the email_verified claim, but a regular expression is applied to the value before it is assigned to the user. If the regular expression matches, then the result of the first group is used as the effective value. If the regular expression does not match then the claim mapping fails.

In this example, the email address must belong to the domain, and then the local-part (anything before the @) is used as the principal. Any users who try to login using a different email domain will fail because the regular expression will not match against their email address, and thus their principal user property - which is mandatory - will not be populated.


Small mistakes in these regular expressions can have significant security consequences. For example, if we accidentally left off the trailing $ from the example above, then we would match any email address where the domain starts with, and this would accept an email address such as It is important that you make sure your regular expressions are as precise as possible so that you do not inadvertently open an avenue for user impersonation attacks.

Third party initiated single sign-onedit

The Open ID Connect realm in Elasticsearch supports 3rd party initiated login as described in the relevant specification.

This allows the OP itself or another, third party other than the RP, to initiate the authentication process while requesting the OP to be used for the authentication. Please note that the Elastic Stack RP should already be configured for this OP, in order for this process to succeed.

OpenID Connect Logoutedit

The OpenID Connect realm in Elasticsearch supports RP-Initiated Logout Functionality as described in the relevant part of the specification

In this process, the OpenID Connect RP (the Elastic Stack in this case) will redirect the user’s browser to predefined URL of the OP after successfully completing a local logout. The OP can then logout the user also, depending on the configuration, and should finally redirect the user back to the RP. The op.endsession_endpoint in the realm configuration determines the URL in the OP that the browser will be redirected to. The rp.post_logout_redirect_uri setting determines the URL to redirect the user back to after the OP logs them out.

When configuring rp.post_logout_redirect_uri, care should be taken to not point this to a URL that will trigger re-authentication of the user. For instance, when using OpenID Connect to support single sign-on to Kibana, this could be set to ${kibana-url}/logged_out, which will show a user- friendly message to the user.

OpenID Connect Realm SSL Configurationedit

OpenID Connect depends on TLS to provide security properties such as encryption in transit and endpoint authentication. The RP is required to establish back-channel communication with the OP in order to exchange the code for an ID Token during the Authorization code grant flow and in order to get additional user information from the UserInfo endpoint. Furthermore, if you configure op.jwks_path as a URL, Elasticsearch will need to get the OP’s signing keys from the file hosted there. As such, it is important that Elasticsearch can validate and trust the server certificate that the OP uses for TLS. Since the system truststore is used for the client context of outgoing https connections, if your OP is using a certificate from a trusted CA, no additional configuration is needed.

However, if the issuer of your OP’s certificate is not trusted by the JVM on which Elasticsearch is running (e.g it uses a organization CA), then you must configure Elasticsearch to trust that CA. Assuming that you have the CA certificate that has signed the certificate that the OP uses for TLS stored in the /oidc/company-ca.pem` file stored in the configuration directory of Elasticsearch, you need to set the following property in the realm configuration:
  order: 1
  ssl.certificate_authorities: ["/oidc/company-ca.pem"]