Controlling access at the document and field level

Serverless Stack

You can control access to data within a data stream or index by adding field and document level security permissions to a role.

Field level security restricts the fields that users have read access to. In particular, it restricts which fields can be accessed from document-based read APIs.

Document level security restricts the documents that users have read access to. In particular, it restricts which documents can be accessed from document-based read APIs.

A role can define both field and document level permissions on a per-index basis. A role that doesn’t specify field-level permissions grants access to ALL fields. Similarly, a role that doesn’t specify document level permissions grants access to ALL documents in the index.

On this page, you'll learn how to implement document level security and field level security.

You'll also learn the following:

• How multiple roles with document and field level security interact.
• Considerations for using document and field level security when searching across clusters using cross-cluster API keys.

You can use an API to manage roles:

• In an Elastic Stack deployment, use the security API.
• In Elastic Cloud Serverless, use the security API.

The examples on this page include API requests and equivalent Kibana steps where applicable.

In Elastic Cloud Serverless, you can manage document and field level security using the Elastic Cloud console or the API. Learn more about Serverless custom roles.

In Elastic Cloud on Kubernetes and self-managed deployments, you can also manage custom roles using local files. Although this option is not described on this page, document-level security is still managed using queries, and you can use the queries on this page as a guideline.

You can use a query to specify the documents that each role can access. The document query is associated with a particular data stream, index, or wildcard (*) pattern and operates in conjunction with the privileges specified for the data streams and indices.

The specified document query:

• Expects the same format as if it was defined in the search request
• Supports templating a role query that can access the details of the currently authenticated user
• Accepts queries written as either string values or nested JSON
• Supports the majority of the Elasticsearch Query DSL, with some limitations for field and document level security

				POST /_security/role/click_role
					{
  "indices": [
    {
      "names": [ "events-*" ],
      "privileges": [ "read" ],
      "query": "{\"match\": {\"category\": \"click\"}}"
    }
  ]
}
		

				POST _security/role/click_role
					{
  "indices": [
    {
      "names": [ "events-*" ],
      "privileges": [ "read" ],
      "query": {
        "match": {
          "category": "click"
        }
      }
    }
  ]
}
		

				POST /_security/role/dept_role
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "query": {
        "term": { "department_id": 12 }
      }
    }
  ]
}
		

When you create a role, you can specify a query that defines the document level security permissions. You can optionally use Mustache templates in the role query to insert the username of the current authenticated user into the role. Like other places in Elasticsearch that support templating or scripting, you can specify inline, stored, or file-based templates and define custom parameters. You access the details for the current authenticated user through the _user parameter.

For example, the following role query uses a template to insert the username of the current authenticated user.

				POST /_security/role/example1
					{
  "indices" : [
    {
      "names": [ "my-index-000001" ],
      "privileges": [ "read" ],
      "query": {
        "template": {
          "source": {
            "term": { "acl.username": "{{_user.username}}" }
          }
        }
      }
    }
  ]
}
		

You can access the following information through the _user variable:

You can also access custom user metadata. For example, if you maintain a group_id in your user metadata, you can apply document level security based on the group.id field in your documents:

				POST /_security/role/example2
					{
  "indices": [
    {
      "names": [ "my-index-000001" ],
      "privileges": [ "read" ],
      "query": {
        "template": {
          "source": {
            "term": { "group.id": "{{_user.metadata.group_id}}" }
          }
        }
      }
    }
  ]
}
		

{
  "template": {
    "source": {
      "term": { "group.id": "{{_user.metadata.group_id}}" }
    }
  }
}
		

If your metadata field contains an object or array, you can access it using the {{#toJson}}parameter{{/toJson}} function.

				POST /_security/role/example3
					{
  "indices": [
    {
      "names": [ "my-index-000001" ],
      "privileges": [ "read" ],
      "query": {
        "template": {
          "source": "{ \"terms\": { \"group.statuses\": {{#toJson}}_user.metadata.statuses{{/toJson}} }}"
        }
      }
    }
  ]
}
		

{
  "template": {
    "source": {
      "terms": { "group.statuses": {{#toJson}}_user.metadata.statuses{{/toJson}} }
    }
  }
}
		

To guarantee that a user reads only their own documents, it makes sense to set up document level security. In this scenario, each document must have the username or role name associated with it, so that this information can be used by the role query for document level security. This is a situation where the set security user processor ingest processor can help.

The set security user processor attaches user-related details (such as username, roles, email, full_name and metadata ) from the current authenticated user to the current document by pre-processing the ingest. When you index data with an ingest pipeline, user details are automatically attached to the document. If the authenticating credential is an API key, the API key id, name and metadata (if it exists and is non-empty) are also attached to the document.

For more information, see Ingest pipelines and Set security user.

To enable field level security, specify the fields that each role can access as part of the indices permissions in a role definition. Field level security is thus bound to a well-defined set of data streams or indices (and potentially a set of documents).

				POST /_security/role/test_role1
					{
  "indices": [
    {
      "names": [ "events-*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "category", "@timestamp", "message" ]
      }
    }
  ]
}
		

Access to the following metadata fields is always allowed: _id, _type, _parent, _routing, _timestamp, _ttl, _size and _index. If you specify an empty list of fields, only these metadata fields are accessible.

You can also specify field expressions. For example, the following example grants read access to all fields that start with an event_ prefix:

				POST /_security/role/test_role2
					{
  "indices" : [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "event_*" ]
      }
    }
  ]
}
		

Use the dot notations to refer to nested fields in more complex documents. For example, assuming the following document:

{
  "customer": {
    "handle": "Jim",
    "email": "jim@mycompany.com",
    "phone": "555-555-5555"
  }
}
		

The following role definition enables read access only to the customer.handle field:

				POST /_security/role/test_role3
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "customer.handle" ]
      }
    }
  ]
}
		

You can also use wildcards. For example, use customer.* to enable read access to the customer data:

				POST /_security/role/test_role4
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "customer.*" ]
      }
    }
  ]
}
		

You can deny permission to access the customer.handle field, while allowing access to all other fields (*) with the following syntax:

				POST /_security/role/test_role5
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "*"],
        "except": [ "customer.handle" ]
      }
    }
  ]
}
		

The following rules apply:

• The absence of field_security in a role is equivalent to * access.
• If permission has been granted explicitly to some fields, you can specify denied fields. The denied fields must be a subset of the fields to which permissions were granted.
• Defining denied and granted fields implies access to all granted fields except those which match the pattern in the denied fields.

For more granular access, you can allow access to all customer.* fields (which is a subset of * all possible fields) except customer.handle:

				POST /_security/role/test_role6
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "except": [ "customer.handle" ],
        "grant": [ "customer.*" ]
      }
    }
  ]
}
		

When you specify an empty array for grant (for example, "grant" : []) in your API request, no access is granted to any fields.

When a user has several roles that specify field level permissions, the resulting field level permissions per data stream or index are the union of the individual role permissions. For example, if these two roles are merged:

				POST /_security/role/test_role7
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "a.*" ],
        "except": [ "a.b*" ]
      }
    }
  ]
}
		

				POST /_security/role/test_role8
					{
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "a.b*" ],
        "except": [ "a.b.c*" ]
      }
    }
  ]
}
		

The resulting permission amounts to granted access to all a.* fields except the a.b.c* fields.

{
  // role 1 + role 2
  ...
  "indices": [
    {
      "names": [ "*" ],
      "privileges": [ "read" ],
      "field_security": {
        "grant": [ "a.*" ],
        "except": [ "a.b.c*" ]
      }
    }
  ]
}
		

A user can have many roles and each role can define different permissions on the same data stream or index. When assigning users multiple roles, be careful that you don’t inadvertently grant wider access than intended.

Document level security takes into account each role held by the user and combines each document level security query for a given data stream or index with an "OR". This means that only one of the role queries must match for a document to be returned. For example, if a role grants access to an index without document level security and another grants access with document level security, document level security is not applied; the user with both roles has access to all of the documents in the index.

Field level security takes into account each role the user has and combines all of the fields listed into a single set for each data stream or index. For example, if a role grants access to an index without field level security and another grants access with field level security, field level security is not applied for that index; the user with both roles has access to all of the fields in the index.

For example, let’s say role_a grants access to only the address field of the documents in index1; it doesn’t specify any document restrictions. Conversely, role_b limits access to a subset of the documents in index1; it doesn’t specify any field restrictions. If you assign a user both roles, role_a gives the user access to all documents and role_b gives the user access to all fields.

Serverless Unavailable

Cross-cluster API keys can be used to authenticate requests to a remote cluster. The search parameter defines permissions for cross-cluster search. The replication parameter defines permissions for cross-cluster replication.

replication does not support any field or document level security. search supports field and document level security.

For reasons similar to those described in Multiple roles with document and field level security, you can’t create a single cross-cluster API key with both the search and replication parameters if the search parameter has document or field level security defined.

If you need to use both of these parameters, and you need to define document or field level security for the search parameter, create two separate cross-cluster API keys, one using the search parameter, and one using the replication parameter. You will also need to set up two different remote connections to the same cluster, with each named connection using the appropriate cross-cluster API key.

Field and document security is subject to the following limitations:

When a user’s role enables document level security for a data stream or index:

• Document level security doesn’t affect global index statistics that relevancy scoring uses. This means that scores are computed without taking the role query into account. Documents that don’t match the role query are never returned.

• The has_child and has_parent queries aren’t supported as query parameters in the role definition. The has_child and has_parent queries can be used in the search API with document level security enabled.

• Date math expressions cannot contain now in range queries with date fields.

• Any query that makes remote calls to fetch query data isn’t supported, including the following queries:

  • terms query with terms lookup
  • geo_shape query with indexed shapes
  • percolate query

• If suggesters are specified and document level security is enabled, the specified suggesters are ignored.

• A search request cannot be profiled if document level security is enabled.

• The terms enum API does not return terms if document level security is enabled.

• The multi_match query does not support specifying fields using wildcards.

When a user’s role enables document or field level security for a data stream or index:

• The user cannot perform write operations:

  • The update API isn’t supported.
  • Update requests included in bulk requests aren’t supported.

• The user cannot perform operations that effectively make contents accessible under another name, including actions from the following APIs:

  • Clone index API
  • Shrink index API
  • Split index API
  • Aliases API

• The request cache is disabled for search requests if either of the following are true:

  • The role query that defines document level security is templated using a stored script.
  • The target indices are a mix of local and remote indices.