{"id":4172,"date":"2024-09-30T16:42:56","date_gmt":"2024-09-30T20:42:56","guid":{"rendered":"https:\/\/www.indigoconsulting.ca\/?p=4172"},"modified":"2024-12-05T15:49:46","modified_gmt":"2024-12-05T20:49:46","slug":"authorization-demystified-your-gateway-to-secure-access","status":"publish","type":"post","link":"https:\/\/www.indigoconsulting.ca\/fr\/blog\/authorization-demystified-your-gateway-to-secure-access\/","title":{"rendered":"Authorization Demystified: Your Gateway to Secure Access"},"content":{"rendered":"
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

This article provides foundational knowledge about the authorization aspect of identity and access management (IAM). Its goal is to introduce access control models commonly used today, with a deeper exploration of the Attribute Based Access Control model (ABAC). This model is having traction in the industry, but is often misunderstood.<\/span><\/p>

Before we start, here are key concepts referenced throughout the article.<\/span><\/p>

Subject<\/b><\/p>

The entity that accesses an object. The subject can be, for instance, a user or an automatic process.<\/span><\/p>

Object<\/b><\/p>

The resource that is being accessed. Examples include a file in an operating system, a field in a person\u2019s record, an API, etc.<\/span><\/p>

Access control models<\/span><\/strong><\/h2>

\"\"<\/p>

This section covers the main access control models that can be encountered in authorization solutions.<\/span><\/p>

Access control list (ACL)<\/span><\/h3>

This access control model is one of the earliest introduced. The first implementation of this model dates back to 1965 with the Multics operating system.<\/span><\/p>

In this model, the owner of a resource maintains a list of which subject (such as users, or accounts) that can access its resource and what actions they are permitted to perform.<\/span><\/p>

This model is used in various contexts. For instance, in an operating system, a file is associated with a list of subjects that can read, modify or delete them. In an LDAP directory, an ACL defines how a subject can interact with objects in the directory.<\/span><\/p>

Role-based access control (RBAC)<\/span><\/h3>

This model, developed by NIST researchers in 1992, introduces a key distinction from the ACL model by breaking the direct relationship between subjects and objects.<\/span><\/p>

In the RBAC model, permissions are not directly assigned to subjects. Instead, subjects are assigned to roles, and these roles are granted permissions to access specific objects.<\/span><\/p>

These roles can represent many concepts like the subject\u2019s business function or its department. A role can be used to group subjects and privileges together, simplifying their management. However, in practice, most organizations face a \u201crole explosion\u201d situation where a multitude of distinct roles is created to account for every exception or nuance in privileges. This situation makes role management a complex task.<\/span><\/p>

Attribute based access control (ABAC)<\/span><\/h3>

ABAC can be considered as a more flexible generalization of the RBAC model. In RBAC, a subject\u2019s privileges over an object are determined by its assigned roles. In contrast, with the ABAC model, the privileges can depend on any of the subject\u2019s attributes, not only its role. Examples of such attributes can include the subject\u2019s business unit, its seniority level in an organization, its security clearance level, etc.<\/span><\/p>

The ABAC model also incorporates object’s attributes and contextual attributes. An object\u2019s attributes define the resources that can be accessed and contextual attributes define the context in which an authorization request is performed. These three levels of attributes allow for complex and flexible policy. For instance, such a policy could be:<\/span><\/p>

A bank employee working at the Montr\u00e9al branch can access a VIP client\u2019s bank accounts, only during office hours and only if the request is made from within North-America.<\/span><\/i><\/p>

Note that we consider ABAC and Policy-based access control (PBAC) as synonymous. PBAC is sometimes used as a more business friendly termmarketing term for solutions that effectively implement the ABAC model. Both ABAC and PBAC solutions implement a model which allows the creation of authorization policies based on subjects, objects and contextual attributes.<\/span><\/p>

Relationship based access control (ReBAC)<\/span><\/h3>

The idea of an authorization model based on relationships was first discussed in 2006 in the context of information sharing in social networks. An application for this model is to allow an individual to share various pieces of information to other individuals based on their relationship.<\/span><\/p>

The ReBAC model is similar to ABAC in that both can define complex and fine-grained authorization policies. The main difference in the two models lies in how the policies are designed and evaluated. In ABAC model, a subject\u2019s, object\u2019s and contextual attributes are evaluated. In the ReBAC model, what is evaluated is the relationship between the subject and the object.<\/span><\/p>

For instance, in the ReBAC model, a <\/span>document<\/span><\/i> object could have an <\/span>editor<\/span><\/i> relationship to a specific subject. If that subject attempts to edit the document, the ReBAC system validates that the <\/span>editor<\/span><\/i> relationship exists between the subject and the object. If no such relationship is found, the edit request is denied.<\/span><\/p>

ABAC model<\/span><\/h2>

This section focuses on the architecture and components of the ABAC model. \"\"<\/span><\/p>

ABAC architecture<\/span><\/h3>

The various components of an ABAC architecture were originally defined as part of the AAA Authorization Framework RFC (RFC 2904) published in 2000. This RFC established foundations of distributed policies which are now used in modern ABAC solutions.<\/span><\/p>

A flow for a request follows the following steps:<\/span><\/p>

  1. A request is made to a system for an object (resource), such as retrieving records in a database or calling an API. This request is intercepted by the Policy Enforcement Point (PEP) which is usually part of the system that returns the request\u2019s response. The PEP can take many forms: a database plugin, a sidecar to a service mesh, code integrated within the application, etc.<\/span><\/li>
  2. The PEP forwards the request to the Policy Decision Point (PDP). The PDP is responsible for making the authorization decision. The PEP may also provide additional relevant information that was not included in the original request. This additional information can be application specific or contextual information in which the request was performed. The PDP is a component that can easily be centralized and potentially deployed in the cloud. A valid deployment strategy is to have many PEPs deployed in on-premises business applications. All these PEPs can then reach out to a single PDP deployed in the cloud.<\/span><\/li>
  3. The PDP may rely on additional data sources to make an authorization decision. This is necessary when the PDP doesn\u2019t have enough information with the authorization request itself and additional information that is provided by the PEP. When the PDP needs additional information, it can query one or many Policy Information Point (PIP). A PIP is a component that connects to various data sources (databases, LDAP, etc.) in order to provide information to the PDP so that the PDP can perform the authorization decision. The information provided by a PIP can be related to the subject making the request or the object that the subject wants to access.<\/span><\/li>
  4. Once the PDP has all the necessary information, it evaluates relevant policies in order to perform an authorization decision.<\/span><\/li>
  5. The PDP then returns the authorization decision to the PEP. The PEP is in charge of enforcing that decision.\u00a0<\/span><\/li>
  6. The PEP enforces the authorization decision. This enforcement step is highly dependent on the implementation and the object that is being accessed by the subject. For instance, if a subject wants to do a GET on an API endpoint, the PEP could grant or deny the request. If a subject wants to do a SELECT SQL query on a database, the PEP could filter the rows and columns which the subject has access to.<\/span><\/li>
  7. If access is granted to the subject, the PEP returns the requested object.<\/span><\/li><\/ol>

    \u00a0<\/span><\/p>

    In parallel to the request made by subjects to objects, administration tasks are also performed in the system.<\/span><\/p>

    1. An administrator uses the Policy Administration Point (PAP) to manage the various policies in the system. Like the PDP, the PAP is a component that can easily be centralized. The PAP, PDP and the policies managed and read by these two components can be deployed in a central location.<\/span><\/li>
    2. The PAP updates the policies that are read by the PDP when the PDP performs its policy evaluation task.<\/span><\/li><\/ol>

      \u00a0<\/h2>

      ABAC access control policies and best practices <\/span><\/strong><\/h2>

      Policy format<\/span><\/h3>

      \"\"<\/span><\/strong><\/h2>

      Policies in the ABAC model follow the format:<\/p>

      Here is the breakdown of the various elements of a policy:<\/span><\/p>

      Who<\/b><\/p>

      The subject making a request. The subject can represent a user account, an employee, a client, a non human system, etc.<\/span><\/p>

      What<\/b><\/p>

      The object or resource being accessed. A resource can be an API endpoint endpoint, a column in a database, a microservice, etc. The <\/span>what<\/span><\/i> portion of a policy also describes the actions that can be done on the object. For instance, the <\/span>what <\/span><\/i>portion of the policy can specify that a given subject can perform a GET on an API endpoint to retrieve a document, but cannot perform a POST on that same API endpoint on that same document.<\/span><\/p>

      When<\/b><\/p>

      The context in which the request can be performed. Contextual factors can include the time and date at which the request is performed, the geolocation from where the request originates or any other contextual information that the PEP can provide to the PDP when requesting a policy evaluation.<\/span><\/p>

      Policy creation best practices<\/span><\/h3>

      At a high level, the process of creating an ABAC policy follows these steps:<\/span><\/p>

      1. Define assets and resources to protect. In the ABAC model, these would be the <\/span>objects<\/span><\/i> to protect and would represent the <\/span>what<\/span><\/i> of the policies that are being designed. It is a good practice to start by defining <\/span>objects<\/span><\/i> rather than <\/span>subjects<\/span><\/i>. Defining subjects first can lead to irrelevant or overlapping subjects definitions.<\/span><\/li>
      2. Identify the various objects\u2019 attributes that are relevant when performing an authorization decision. It is also important to identify the source of these attributes. The source could be in the request itself, it could come from a PEP or the attribute could be stored in a PIP.<\/span><\/li>
      3. Identify the actions and usage patterns for the various objects. This includes the design and implementation of authorization with user journey focus that considers authentication infrastructure and data dependencies inherent to the security ecosystem protecting access to objects.<\/span><\/li>
      4. Once the objects\u2019 actions and usage patterns are defined, define which subjects should be able to perform them.<\/span><\/li>
      5. Identify the subjects\u2019 attributes that can be used to properly identify them. Just like it was done for the objects\u2019 attributes, it is also important to determine the source of the subjects\u2019 attributes (the request, additional information by the PEP or PIP).<\/span><\/li>
      6. Identify any additional contextual attributes that should be taken into consideration when a subject performs an action on an object. Examples of additional contextual information could include: only during business hours, only when in North-America, etc.<\/span><\/li>
      7. After gathering all necessary data it is possible to put all of this together to design proper ABAC policies. To do that, identify control points between users and resources where context and attribute data intersect with sufficient information to make effective authorization decisions.<\/span><\/li><\/ol>

        Policy design principles<\/span><\/h3>

        Here are some design principles that should be taken into consideration when creating policies. Not all of these principles are applicable to every context, but it is a good practice to keep them in mind.<\/span><\/p>