My Bearer Token leaked! What should I do?

What is a Bearer Token and how it is used?

A Bearer Token is a type of access token that is used to authenticate and authorize API requests. It is typically included in the authorization header of HTTP requests and grants access to specific resources based on the permissions associated with the token.

Here are the main use cases for Bearer Tokens:

Authentication: Bearer Tokens are commonly used for authentication purposes. When a user logs in, they receive a Bearer Token which is then sent with each subsequent request to authenticate the user.
Authorization: Bearer Tokens are also used to determine what actions a user can perform within an application. By including the Bearer Token in the request, the server can verify the user's permissions and grant access accordingly.
API Access: Bearer Tokens are often used to access APIs. Developers can include the Bearer Token in API requests to authenticate and authorize the user, allowing them to interact with the API's resources.

1. Code snippets to prevent Bearer Token hardcoding using environment variables

Using environment variables for storing Bearer Tokens in code is considered a secure practice because:

Environment variables are not hard-coded in the codebase, reducing the risk of exposing sensitive information.
Environment variables are stored outside of the code repository, making it less likely for unauthorized users to access them.
Environment variables can be easily managed and rotated without changing the code, enhancing security and compliance.

How to secure your secrets using environment variables

Language:
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Copy code
import os

bearer_token_apikey = os.getenv('BEARER_TOKEN_APIKEY')

2. Code snippet to prevent Bearer Token hardcoding using AWS Secrets Manager

Using AWS Secrets Manager to manage Bearer Tokens is a secure way to handle sensitive data. Here are code snippets in five different programming languages that demonstrate how to retrieve the Bearer Token from AWS Secrets Manager.

Language:
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Copy code
import botocore 
import botocore.session 
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig 

client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)

bearertoken = cache.get_secret_string('BEARERTOKEN')

3. Code snippet to prevent Bearer Token hardcoding using HashiCorp Vault

Using HashiCorp Vault for managing Bearer Tokens is a great way to enhance security. Here are code snippets in five different programming languages for securely handling a Bearer Token using HashiCorp Vault.

Remember to replace the VAULT_ADDR and VAULT_TOKEN with your Vault server address and authentication token. The snippets assume that the Bearer Token is stored under the api_key field within Vault. The specifics of the Vault path and field names should be adjusted to match your Vault setup.

Language:
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Copy code
import hvac
import os

# Get the Vault URL and token from environment variables
VAULT_URL = os.getenv('VAULT_URL')
VAULT_TOKEN = os.getenv('VAULT_TOKEN')
VAULT_PATH = os.getenv('VAULT_PATH')

# Create connection
client = hvac.Client(url=VAULT_URL, token=VAULT_TOKEN)

# Read the secret
BEARER_TOKEN = client.secrets.kv.v2.read_secret_version(path=VAULT_PATH)['data']['data']['BEARER_TOKEN']

4. Code snippet to prevent Bearer Token hardcoding using CyberArk Conjur

Using CyberArk Conjur to manage Bearer Token is a secure way to handle sensitive data. Here are code snippets in five different programming languages that demonstrate how to retrieve the Bearer Token from CyberArk Conjur.

Language:
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Copy code
import requests
import os


# CyberArk credentials
ID_TENANT_URL = os.getenv("ID_TENANT_URL")
PRIVATE_CLOUD_URL = os.getenv("PRIVATE_CLOUD_URL")
PAM_USER = os.getenv("PAM_USER")
PAM_PASS = os.getenv("PAM_PASS")


def get_auth_token() -> tuple[str, str]:
    url = f"{ID_TENANT_URL}/oauth2/platformtoken"
    response = requests.post(
        url,
        data={
            "grant_type": "client_credentials",
            "client_id": PAM_USER,
            "client_secret": PAM_PASS,
        },
    )  # Use verify=True in production
    if response.status_code == 200:
        data = response.json()
        return data["token_type"], data["access_token"]
    else:
        raise Exception(
            f"Failed to authenticate: {response.status_code} {response.text}"
        )


def get_account_id(account_name: str) -> str:
    token_type, access_token = get_auth_token()
    url = f"{PRIVATE_CLOUD_URL}/PasswordVault/API/Accounts"
    headers = {"Authorization": f"{token_type} {access_token}"}
    response = requests.get(url, params={"search": account_name}, headers=headers)
    if response.status_code == 200:
        accounts = response.json()["value"]
        return accounts[0]["id"]
    else:
        raise Exception(
            f"Failed to get account: {response.status_code} {response.text}"
        )


def get_secret(secret_name: str) -> str:
    token_type, access_token = get_auth_token()
    account_id = get_account_id(secret_name)
    url = (
        f"{PRIVATE_CLOUD_URL}/PasswordVault/API/Accounts/{account_id}/Password/Retrieve"
    )
    headers = {"Authorization": f"{token_type} {access_token}"}
    response = requests.post(
        url, json={"reason": "automatic retrieval"}, headers=headers
    )
    if response.status_code == 200:
        return response.text
    else:
        raise Exception(f"Failed to get secret: {response.status_code} {response.text}")


BEARER_TOKEN = get_secret("BEARER_TOKEN")

How to generate a Bearer Token?

Generating a Bearer Token involves the following steps:

Authenticate the user and obtain their credentials.
Generate a unique token for the user, typically using a secure hashing algorithm.
Associate the token with the user's account in the database.
Include the token in the Authorization header of API requests as "Bearer [token]".

My Bearer Token leaked, what are the possible reasons?

There are several reasons why a Bearer Token might have been leaked:

Weak or insecure storage: If the Bearer Token is stored in an insecure location, such as in plain text in a configuration file or database, it can be easily accessed by unauthorized parties.
Improper handling: Developers may inadvertently expose Bearer Tokens in logs, error messages, or other public-facing outputs, making them vulnerable to leakage.
Third-party services: Bearer Tokens used to authenticate with third-party services may be leaked if those services have security vulnerabilities or if the tokens are not properly secured during transmission.
Phishing attacks: Hackers may use phishing techniques to trick users into revealing their Bearer Tokens, allowing them to access sensitive information.

What are the risks of leaking a Bearer Token

When it comes to secret management, the risks of leaking a Bearer Token can be significant. A Bearer Token is a type of access token that is used to authenticate and authorize requests to a server. If a Bearer Token is leaked, it can lead to various security vulnerabilities and risks, including:

Unauthorized access: An attacker who obtains a Bearer Token can use it to impersonate the legitimate user and gain unauthorized access to sensitive data or perform malicious actions.
Data breaches: Leaking a Bearer Token can result in a data breach, where confidential information stored on the server is exposed to unauthorized parties.
Identity theft: With a Bearer Token, an attacker can potentially steal the identity of a legitimate user and carry out fraudulent activities in their name.
Compromised system integrity: If a Bearer Token is leaked, it can be used to compromise the integrity of the system, leading to further exploitation and security incidents.

Therefore, it is crucial for developers to understand the importance of securely managing and protecting Bearer Tokens to prevent these risks and safeguard the confidentiality and integrity of their applications and data.

Bearer Token security best practices

Avoid embedding the secret directly in your code. Instead, use environment variables or secrets managers‍
Secure storage: store the Bearer Token in a secure location, such as a password manager or a secrets management service.
Regular rotation: periodically rotate the API key to minimize the risk of long-term exposure.
Restrict permissions: apply the principle of least privilege by only granting the key the minimum necessary permissions.
Monitor usage: regularly check the usage logs for any unusual activity or unauthorized access attempts.
Implement access controls: limit the number of users who have access to the secret and enforce strong authentication measures.
Use a secrets manager: utilize secret management tools like CyberArk or AWS Secrets Manager for enhanced security.

By adhering to the best practices, you can significantly reduce the risk associated with Bearer Token usage and improve the overall security of your Bearer Token implementations.

Exposing secrets on GitHub: What to do after leaking Credential and API keys

Bearer Token leak remediation: what to do

What to do if you expose a secret: How to stay calm and respond to an incident [cheat sheet included]

How to check if Bearer Token was used by malicious actors

Review Access Logs: Check the access logs of your Bearer Token account for any unauthorized access or unusual activity. Pay particular attention to access from unfamiliar IP addresses (if you haven’t set up a specific allow list) or at odd hours.
Monitor Usage Patterns: Look for anomalies in the usage patterns, such as unexpected spikes in data access or transfer.
Check Active Connections and Operations: Review the list of active connections and recent operations on your database. Unusual or unauthorized operations might indicate malicious use.
Audit API Usage: If possible, audit the usage of your API key through any logging or monitoring services you have integrated with Bearer Token. This can give insights into any unauthorized use of your key.

Steps to revoke the Bearer Token

Generate a new Bearer Token:

Log into your Bearer Token account.
Navigate to the API section and generate a new API key.

Update Services with the new key:

Replace the compromised key with the new key in all your services that use this API key.
Ensure all your applications and services are updated with the new key before deactivating the old one.

Deactivate the old Bearer Token:

Once the new key is in place and everything is functioning correctly, deactivate the old API key.
This can typically be done from the same section where you generated the new key.

Monitor after key rotation:

After deactivating the old key, monitor your systems closely to ensure that all services are running smoothly and that there are no unauthorized access attempts.

How to understand which services will stop working

Inventory of services: keep an inventory of all services and applications that utilize your Bearer Token.
Communication and documentation: Ensure that your team is aware of which services are dependent on the key. Maintain documentation for quick reference.
Testing: before deactivating the old key, test your services with the new key in a staging environment. This helps in identifying any services that might face issues post rotation.
Fallback strategies: Have a fallback or emergency plan in case a critical service fails after the key rotation. This might include temporary measures or quick rollback procedures.

In summary, the remediation process involves identifying potential misuse, carefully rotating the key, and ensuring minimal disruption to services. Being proactive and having a well-documented process can greatly reduce the risks associated with a compromised API key.

What about other secrets?

GitGuardian helps developers keep 350+ types of secrets out of source code. GitGuardian’s automated secrets detection and remediation solution secure every step of the development lifecycle, from code to cloud:

On developer workstations with git hooks (pre-commit and pre-push);
On code sharing platforms like GitHub, GitLab, and Bitbucket;
In CI environments (Circle CI, Travis CI, Jenkins CI, GitHub Actions, and many more);
In Docker images.

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents

Table of Contents