Five Common Mistakes in Kubernetes Secret Management and How to Fix Them
========================================================================

As teams scale their cloud-native apps, Kubernetes often becomes the go-to for managing containers. It's powerful and flexible, but when it comes to handling sensitive data like API keys, tokens, and credentials, things can get tricky fast.

[Red Hat's 2024 State of Kubernetes Security report](https://www.redhat.com/en/engage/state-kubernetes-security-report-2024) found that over half of Kubernetes security incidents came down to simple misconfigurations. Many of those involved secrets being stored or shared the wrong way, opening the door to data breaches, compliance headaches, and reputational damage.

[Kubernetes secret management](https://www.groundcover.com/blog/kubernetes-secret-management) isn't optional. It's a core part of keeping your systems secure. Still, it's easy to get wrong. In this article, we'll break down five common mistakes teams make when managing secrets in Kubernetes and how you can fix them before they become real problems.

Common Mistakes and How to Fix Them
===================================

Even the most experienced engineers can use patterns that compromise the way secrets are stored, accessed, or rotated. Below are common mistakes in managing secrets in Kubernetes, along with recommendations on how to address them.

1\. Storing Secrets as Plaintext in ConfigMap
---------------------------------------------

One critical mistake is using Kubernetes ConfigMap to store sensitive data, such as tokens, API keys, or even database credentials. Although ConfigMap and [Secret objects](https://kubernetes.io/docs/concepts/configuration/secret/) look similar, they are fundamentally different. While the Secret object is used to store sensitive data, the ConfigMap is used to store non-confidential configuration data without any form of encoding.

The use of ConfigMap to store sensitive data significantly increases the risk of unauthorized access to Kubernetes clusters and resources. For example, if you're deploying a MongoDB database in your cluster and mistakenly store the MongoDB secrets, such as MONGO_INITDB_ROOT_USERNAME and MONGO_INITDB_ROOT_PASSWORD, in the ConfigMap. Then, anyone with even the slightest privilege to the ConfigMap can retrieve the database credentials in plain text and compromise the database.

Generally, it's best practice to always store critical and sensitive information in a Kubernetes Secret configuration file. It features a security enhancement that can improve [Role-Based Access Control (RBAC)](https://www.techtarget.com/searchsecurity/definition/role-based-access-control-RBAC). When you store sensitive credentials in Secret, Kubernetes treats them differently at the API level and makes sure they are better protected during API access.

Additionally, for enhanced security, it's best practice to pair the Kubernetes Secret with external secret management solutions, such as Hashicorp Vault, AWS Secrets Manager, and Google Cloud Secret Manager.

#### Best Practices

- Always use **Kubernetes Secret objects** instead of ConfigMaps for sensitive data.

- Apply **RBAC restrictions** on Secrets to limit who can view them.

- Combine Kubernetes Secrets with **external secret managers** for added encryption and access control.

2\. Overly Permissive RBAC Policies
-----------------------------------

This is another common oversight in managing Kubernetes secrets. This involves granting excessive privileges to users, service accounts, or applications through Kubernetes Role-Based Access Control. For example, if a role lets someone read all secrets in a namespace, that's a problem. If that account is compromised, your secrets are exposed.

Additionally, if RBAC is not distributed correctly, a breach in a single pod within a Kubernetes cluster can lead to lateral movement across pods, services, and the exposure of sensitive data outside the initial scope of control.

The principle of least privilege should always be applied when configuring RBAC in secret. Access should only be given to users, services, or applications that explicitly require it, and strict restrictions should be imposed on the smallest namespace or scoped resources if possible. Also, instead of using ClusterRole and ClusterRoleBinding, use Role and RoleBinding unless otherwise. Also, regularly audit RBAC policies and secret access logs using commands like kubectl auth can-i and audit integrations.

#### Best Practices

- Follow the **principle of least privilege**; only grant access to Secrets if absolutely necessary.

- Use **Role/RoleBinding** instead of ClusterRole when possible.

- Periodically audit RBAC permissions with `kubectl auth can-i` and remove unused roles.

3\. Putting Secrets Directly in Manifests or Code
-------------------------------------------------

A common risk is including sensitive information, such as API keys, tokens, database credentials, and passwords, directly within Kubernetes manifest files or application code. Even if it might be convenient to write secrets directly in the manifest configuration, it bypasses secret management features and exposes critical data.

For example, directly hardcoding secrets in your Kubernetes deployment manifest file can expose your cluster to several risks, such as:

- Exposing the secrets in the GitHub repository if version control is implemented

- Access to secret keys if anyone has access to the cluster or deployment manifest

- Inability to rotate secrets since secrets will be baked into the container runtime environment\
However, a simple solution to mitigate these potential threats is to externalize all secrets in a Kubernetes Secret object or an external secret management solution and reference them in your Kubernetes manifest. This approach enhances security in the cluster by centralizing secret storage, improves fine-grained access control, and makes secret rotation much easier.

#### Best Practices

- Never hardcode credentials in manifests, Git repositories, or application code.

- Reference secrets in manifests via **environment variables** or **volume mounts**.

- Implement **code scans (e.g., TruffleHog, GitLeaks)** to detect accidental secret commits.

4\. Failure to Encrypt Secrets at Rest
--------------------------------------

Kubernetes stores Secrets in etcd by default. These Secrets in Kubernetes are encoded but not encrypted unless explicitly configured. So if you don't give proper access and a user has access to etcd, they can see sensitive data in plain text, which is a big security risk.

Most of the time, teams assume Kubernetes automatically encrypts secrets, which often leads to this issue. However, secrets at rest must be enabled manually through the Kubernetes API server configuration.

To fix this flaw, it's vital to enable [encryption at rest](https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/) in your Kubernetes clusters. This is made possible by configuring an encryption provider in the EncryptionConfiguration file alongside updating the encryption-provider-config flag in your API server. With this approach, secrets stored in the etcd are encrypted with the use of industry-standard methods such as Secretbox or AES-GCM.

Furthermore, it's also essential to make sure your secrets are tightly restricted and audit logging is enabled to track unauthorized access attempts. This approach keeps your sensitive data safe even if the etcd is compromised.

#### Best Practices

- Enable **Encryption at Rest** in etcd using Secretbox or AES-GCM.

- Rotate encryption keys regularly using Kubernetes' encryption provider.

- Restrict etcd access and enable **audit logging** for secret reads/writes.

5\. Static Secrets Without Rotation
-----------------------------------

This is another common mistake by engineers when managing Kubernetes secrets. This involves failing to implement secret rotation on a regular basis. Static and long-lived secrets such as tokens, database credentials, and passwords can pose a significant risk if exposed. This mistake makes it possible for users with access to the key to have indefinite access to the Kubernetes clusters, except these keys are revoked or rotated.

Many teams often view secrets as a set-and-forget value, which means hardcoding them once and not updating them on a regular basis. This creates a vulnerability that can result in unauthorized access to critical data and insider threats.

To fix this mistake, it's vital to implement a strategy that automatically rotates secrets. One of the most efficient ways to do this is with the use of an external secret management tool. These tools help in the automation of scheduled secret rotation without downtime.

In addition, you can use an automation pipeline that detects secret changes and triggers the redeployment of affected pods in the cluster. For example, in a Gitops workflow, when a database credential is changed for a Postgres database, it automatically redeploys the Postgres pods and implements the new secrets. This approach ensures secrets are up-to-date and reduces the attack surface if there is a breach.

#### Best Practices

- Implement **automatic secret rotation** using external secret managers.

- Design workflows to redeploy pods when secrets are updated.

- Rotate passwords, tokens, and keys at a **fixed interval** to reduce exposure.

Wrapping Up
===========

Managing Kubernetes secrets is a crucial component in cloud-native applications, but it's often not treated with high priority. Avoiding common mistakes like plaintext in ConfigMap, elevated RBAC permissions, hardcoded secrets, and non-rotation of secrets, teams can efficiently reduce risk in a Kubernetes cluster. Paying attention to secure, automated, and auditable secrets handling can both strengthen Kubernetes security posture and ensure compliance and operational resilience.