When Identity and Access Management (IAM) permissions are not sufficiently isolated using the structure provided by the Google Cloud Platform (GCP), the results could be disastrous. Ideally, if you must provide a service account with permissions at a Folder or Organization level, the service account should be created in its own project, which is well insulated from external traffic and contains multiple layers of protection.
For example, a GCP project that contains externally exposed workloads and also has a service account with permissions at the Organization level is something that should never occur in your environment. This situation could allow an attacker to tear down security controls, establish persistence, and expose data. This post will go into more detail about how someone could effectively exploit this type of configuration, specifically looking at GCP’s Compute Engine.
The content in this post is based upon a presentation I did at DEFCON 27. For more information about a specific scenario that eliminated a service perimeter and exposed data, refer to the slides from my DEFCON talk available here.
Assigning Permissions in GCP
Identity types in GCP include users, groups, domains, and service accounts. They are all assigned permissions in GCP the same way, by assigning them roles at various levels of the GCP Organization structure. When permissions are assigned to an identity, it’s called an IAM binding. As you can see in the diagram below (from Google’s documentation), bindings can be applied at every point of the hierarchy, and the permissions are inherited down:
The roles are actually just a collection of permitted API calls. The roles in the diagram above are called predefined roles, which are provided by Google. The predefined roles are based on certain job functions. Google also supplies primitive roles by default, which are not recommended for use. The primitive roles are fairly permissive, they are the following:
- Viewer – read-only permissions to view resources or data
- Editor – permissions to modify existing resources (as well as create / delete in most services)
- Owner – permissions to modify resources, as well as manage permissions and billing
Once these primitive roles are assigned at the project level, the identity has the permissions for all the resources in that project. Keep the Project Editor role in mind, as we will come back to it.
Service Accounts and Impersonation
A service account in GCP is an identity that is provided to allow applications to authenticate and make calls to the GCP APIs. It does not use passwords, but uses RSA keys to authenticate. If you are familiar with IAM roles in AWS, this is the same concept for GCP. When you assign a service account to a resource, Google automatically rotates the keys for you. This is better than having to store static credentials in your code.
One important concept to keep in mind for GCP is that a service account must be created in a project. However, a service account could be given bindings at a level higher than a project, such as permissions at the Folder or even Organization levels. I will refer to these types of permissions as “elevated bindings.” These are dangerous, because the permissions at higher levels could give you access to other security controls, and all the projects under that structure will inherit the permissions.
Resources, applications, users, and even service accounts can all impersonate a service account. Impersonating a service account means that you are able to authenticate as the service account, and now have whatever permissions were granted to it. Logs will show any actions as being performed by the service account. It’s important to understand impersonation, because it could be used in unexpected ways in your environment to escalate privileges.
The Default Service Account
When you first enable the Google Compute Engine, it automatically creates a “Default Service Account.” If you don’t make any custom changes while launching a new virtual machine, it will automatically use the default service account. This means that your virtual machine will authenticate as the service account, so it can make any GCP API calls as that service account. If a user were to SSH into the virtual machine and start running “gcloud” commands, it would utilize those service account credentials to interact with GCP.
Google recommends that you immediately remove the default service account. They recommend that instead you create your own service account and assign it only the permissions required. Why would that be the case? Well, the default service account contains a lot of permissions.
The default service account from Compute Engine is automatically given the Project Editor role. This role contains more than 1890 permitted API calls at the time that this post was written, including permissions to impersonate other service accounts. If your virtual machine is compromised and running the default service account, that could open you up to privilege escalation and further compromise.
The only thing stopping the default service account from being able to utilize all of its permissions are the “access scopes” assigned to the virtual machine. This is a control that dictates which APIs the service account is able to access. So, if the service account is granted access to the Storage API in the IAM policy, the account still cannot access the Storage API if the access scopes do not include the Storage API. Here is an example the access scope options available in the GCP console:
If you have “Allow full access to all Cloud APIs” selected, then the service account can use all of its permitted API calls. This is configured per virtual machine, so your environment could have varied levels of access for its virtual machines.
If one of your workloads has been compromised while running the default service account and it also has full scopes enabled, then it could easily enumerate other service accounts in the same project, and even impersonate those service accounts. This is because the default service account has project editor permissions. Those permissions include the ability to impersonate other service accounts in that project.
If the same project contains service accounts with elevated bindings (permissions at the Folder or Organization levels), then that service account can be easily impersonated by the compromised workload. Once the workload is used to impersonate it, that account is now only limited by the permissions granted to the service account with elevated bindings. This could include adding new users, tearing down VPC Service Controls (or other security controls), and launching its own workloads.
Due to the dangerous nature of the default service account running with full scopes assigned, we recommend doing the following in your GCP environment:
- Designate a project that will be used for any accounts that require elevated bindings. Keep that project as secure as possible and do not populate it with any public workloads.
- Keep track of who or what can impersonate service accounts. If you lose track of this, privilege escalation becomes a much larger risk.
- Don’t use the default service accounts for your workloads. If your workload does not need to access GCP APIs, then remove the service account all together.
- Don’t create bindings that include primitive roles whenever possible. These are broad, and permissions should be more granular.