Back to Intelligence

Rackspace Spot Breach: Hackers Deployed Unauthorized Workloads and Accessed Customer Kubernetes Secrets — Detection and Response Guide

SA
Security Arsenal Team
November 21, 2026
12 min read

Rackspace has disclosed a security incident affecting its Rackspace Spot cloud platform in which attackers used compromised credentials to breach the service, deploy unauthorized workloads inside customer environments, and access Kubernetes secrets stored in customer clusters. This is not a theoretical exposure — it is a confirmed intrusion with direct impact on customer infrastructure.

If you run workloads on Rackspace Spot, treat this as an active incident: assume the secrets in affected clusters are compromised, assume workload inventory may include attacker-deployed pods or containers, and assume credentials used to authenticate to the platform are burned. The blast radius here is significant because Kubernetes secrets frequently contain cloud provider keys, database credentials, TLS private keys, registry pull secrets, and service account tokens — exactly the material an attacker needs to pivot from a hosting platform into your broader estate.

The attack pattern — valid credential abuse against a cloud control plane, followed by workload deployment and secrets harvesting — maps cleanly to MITRE ATT&CK techniques T1078 (Valid Accounts), T1611 (Escape to Host / container deployment abuse), and T1552.007 (Unsecured Credentials: Container API). Defenders need to hunt for all three stages, not just the initial access.

Technical Analysis

Affected Platform

  • Product: Rackspace Spot (Rackspace's cloud compute / Kubernetes-based hosting platform)
  • Impacted assets: Customer Kubernetes clusters hosted on or managed through Rackspace Spot
  • Access vector: Compromised credentials — not a software vulnerability, not an unpatched CVE. This was valid-account abuse against the platform.

No CVE is associated with this incident, and no CVSS score applies. The root cause is credential compromise, which is precisely why detection content below focuses on behavioral indicators rather than version checks.

Attack Chain (Defender's View)

Based on what Rackspace has disclosed, the intrusion followed a classic cloud-control-plane abuse pattern:

  1. Initial access via valid credentials. The attackers authenticated to Rackspace Spot using compromised credentials. From a detection standpoint, this is the hardest stage to catch — the authentication itself looks legitimate. The signal is in the context: unusual source IP/ASN, impossible travel, off-hours activity, or first-time-seen user agents.
  2. Unauthorized workload deployment. With platform access, the attackers deployed their own workloads into customer environments. In Kubernetes terms, this means new Deployments, DaemonSets, Pods, or Jobs appearing in clusters — frequently in system namespaces to blend in, frequently running cryptominers, proxy/tunneling tools, or credential-harvesting sidecars.
  3. Kubernetes secrets access. The attackers accessed secrets in customer clusters. This happens through the Kubernetes API — kubectl get secrets, API calls against /api/v1/namespaces/*/secrets, or by mounting secrets into attacker-controlled pods via environment variables or volumes. Once exfiltrated, those secrets enable downstream compromise: cloud IAM keys, database passwords, registry credentials, and service account tokens.

Why This Is Dangerous

Kubernetes secrets are base64-encoded, not encrypted at rest by default unless a KMS-based encryption provider is configured. An attacker with API read access to the secrets resource effectively holds plaintext credentials for everything the cluster touches. Compounding this, service account tokens mounted into pods are valid bearer credentials against the API server — stealing one secret often yields the access needed to steal all of them.

Exploitation Status

  • Confirmed active exploitation: Yes — this is a disclosed breach, not a proof of concept.
  • CISA KEV: Not applicable (no CVE).
  • Public PoC: Not applicable — the technique (valid credential abuse against Kubernetes APIs) is well documented and requires no novel exploit code.

Detection & Response

The detections below target the three observable stages: anomalous secret access via the Kubernetes API, unauthorized workload creation, and post-compromise endpoint artifacts. Tune namespace and account allowlists to your environment before production deployment.

Sigma Rules

These rules are written against Kubernetes audit logs (product: kubernetes), which you should be shipping from your API servers to your SIEM regardless of this incident.

YAML
---
title: Kubernetes Bulk Secret Enumeration via API
id: 3f8c1a90-2b7d-4e51-9c6a-7d2e5f8a1b3c
status: experimental
description: Detects get/list/watch requests against Kubernetes secrets across all or multiple namespaces, consistent with secrets harvesting following control-plane compromise such as the Rackspace Spot breach.
references:
  - https://www.bleepingcomputer.com/news/security/rackspace-spot-breach-let-hackers-access-customer-kubernetes-secrets/
  - https://attack.mitre.org/techniques/T1552/007/
author: Security Arsenal
date: 2026/02/09
tags:
  - attack.credential_access
  - attack.t1552.007
logsource:
  product: kubernetes
  service: audit
detection:
  selection:
    objectRef.resource: 'secrets'
    verb:
      - 'list'
      - 'watch'
  selection_clusterwide:
    objectRef.resource: 'secrets'
    verb: 'get'
    objectRef.namespace: ''
  filter_known_controllers:
    user.username|startswith:
      - 'system:serviceaccount:kube-system:'
      - 'system:kube-controller-manager'
      - 'system:kube-scheduler'
  condition: (selection or selection_clusterwide) and not filter_known_controllers
falsepositives:
  - GitOps controllers (ArgoCD, Flux) listing secrets during reconciliation
  - External secrets operators syncing to external vaults
  - Legitimate cluster administrators performing audits
level: high
---
title: Unauthorized Workload Creation in Kubernetes Cluster
id: 9b2e4d71-5a3c-4f80-b1d2-8e6c3a9f5d27
status: experimental
description: Detects creation of Deployments, DaemonSets, Pods, or Jobs by non-system identities, consistent with attackers deploying unauthorized workloads after gaining platform access as seen in the Rackspace Spot intrusion.
references:
  - https://www.bleepingcomputer.com/news/security/rackspace-spot-breach-let-hackers-access-customer-kubernetes-secrets/
  - https://attack.mitre.org/techniques/T1611/
  - https://attack.mitre.org/techniques/T1078/
author: Security Arsenal
date: 2026/02/09
tags:
  - attack.privilege_escalation
  - attack.t1611
  - attack.initial_access
  - attack.t1078
logsource:
  product: kubernetes
  service: audit
detection:
  selection:
    verb: 'create'
    objectRef.resource:
      - 'deployments'
      - 'daemonsets'
      - 'pods'
      - 'jobs'
      - 'cronjobs'
  filter_system:
    user.username|startswith:
      - 'system:'
      - 'eks:'
      - 'aks:'
      - 'gke:'
  condition: selection and not filter_system
falsepositives:
  - CI/CD pipelines deploying applications (tune by service account and source IP)
  - Autoscalers and platform operators
level: medium
---
title: Kubernetes Secret Mounted into Newly Created Pod
id: c7a1f5e3-4d8b-4c92-a6e1-2f9b7d3e8a45
status: experimental
description: Detects pod creation requests that reference secret volumes or secretEnv sources, a technique attackers use to exfiltrate Kubernetes secrets by mounting them into attacker-controlled containers.
references:
  - https://www.bleepingcomputer.com/news/security/rackspace-spot-breach-let-hackers-access-customer-kubernetes-secrets/
  - https://attack.mitre.org/techniques/T1552/007/
author: Security Arsenal
date: 2026/02/09
tags:
  - attack.credential_access
  - attack.t1552.007
  - attack.collection
detection:
  selection:
    verb: 'create'
    objectRef.resource: 'pods'
    requestObject|contains:
      - 'secretName'
      - 'secretKeyRef'
      - 'secretRef'
  filter_system_namespaces:
    objectRef.namespace:
      - 'kube-system'
      - 'kube-public'
      - 'kube-node-lease'
  condition: selection and not filter_system_namespaces
falsepositives:
  - Normal application deployments that legitimately consume secrets (tune by namespace and service account)
level: medium

KQL — Microsoft Sentinel Hunt

This query hunts Kubernetes audit events ingested into Sentinel (via the KubeAuditLogs table from AKS diagnostics, or CommonSecurityLog/Syslog if you forward audit logs via CEF/syslog from self-managed clusters). It surfaces secret reads and workload creation by non-system identities, correlated per user to spotlight accounts behaving like the Rackspace Spot attackers.

KQL — Microsoft Sentinel / Defender
// Hunt: Kubernetes secret access + workload creation by non-system identities
// Scope to clusters hosted on Rackspace Spot; adjust table to your ingestion path.
let timeframe = 14d;
let SystemUsers = dynamic(["system:", "eks:", "aks:", "gke:", "kubernetes-admin"]);
union isfuzzy=true
    (CommonSecurityLog
     | where TimeGenerated > ago(timeframe)
     | where DeviceProduct has "kubernetes" or AdditionalExtensions has "audit"
     | extend Parsed = todynamic(AdditionalExtensions)
     | extend Verb = tostring(Parsed.verb),
            Resource = tostring(Parsed.objectRef.resource),
            K8sNamespace = tostring(Parsed.objectRef.namespace),
            K8sUser = tostring(Parsed.user.username),
            SourceAddr = SourceIP
     | where isnotempty(Resource)),
    (Syslog
     | where TimeGenerated > ago(timeframe)
     | where SyslogMessage has "\"objectRef\"" and SyslogMessage has "\"resource\":\"secrets\""
     | extend K8sUser = extract(@'"username":"([^"]+)"', 1, SyslogMessage),
            Resource = "secrets",
            Verb = extract(@'"verb":"([^"]+)"', 1, SyslogMessage),
            SourceAddr = extract(@'"sourceIPs":\["([^"]+)"', 1, SyslogMessage))
| where not(K8sUser startswith "system:")
| where Resource =~ "secrets" or (Verb =~ "create" and Resource in ("deployments","daemonsets","pods","jobs","cronjobs"))
| summarize
    SecretReads = countif(Resource =~ "secrets"),
    WorkloadsCreated = countif(Verb =~ "create"),
    Namespaces = make_set(K8sNamespace, 20),
    SourceIPs = make_set(SourceAddr, 10)
    by K8sUser, bin(TimeGenerated, 1h)
| where SecretReads > 10 or WorkloadsCreated > 0
| sort by SecretReads desc

If you also stream Rackspace Spot control-plane authentication logs into Sentinel, join the resulting suspicious accounts against sign-in telemetry and flag first-time-seen source ASNs and user agents — valid-credential intrusions rarely look anomalous until you examine the source context.

Velociraptor VQL — Endpoint Hunt

Attackers who harvested secrets from your clusters will use them from operator workstations, bastion hosts, or CI runners. This artifact hunts for kubectl execution performing secrets operations and for recently created or modified kubeconfig files that could indicate an attacker staging cluster access.

VQL — Velociraptor
-- Hunt: kubectl secrets abuse and suspicious kubeconfig staging on endpoints
-- Deploy against admin workstations, jump hosts, and CI/CD runners.
LET proc_hunt = SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)kubectl'
  AND CommandLine =~ '(?i)(secret|config use-context|config set-credentials|--token=)'

LET kubeconfig_hunt = SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=['C:/Users/*/.kube/config', 'C:/Users/*/.kube/config.*',
                 '/home/*/.kube/config', '/root/.kube/config',
                 '/home/*/.kube/config.*', '/tmp/**/.kube/**'])
WHERE Mtime > (now() - 1209600)  -- modified in last 14 days

SELECT * FROM proc_hunt
UNION ALL
SELECT NULL AS Pid, NULL AS Ppid, 'kubeconfig_artifact' AS Name,
       FullPath AS CommandLine, NULL AS Exe, NULL AS Username,
       Mtime AS CreateTime
FROM kubeconfig_hunt

Remediation / Hardening Script (Bash)

Run this against each Rackspace Spot-hosted cluster with an administrative kubeconfig. It inventories recently created workloads, identifies pods mounting secrets, lists RBAC bindings that could enable cluster-wide secret reads, and generates a rotation checklist. It makes no changes — review output before acting.

Bash / Shell
#!/usr/bin/env bash
# Rackspace Spot post-breach Kubernetes audit script
# Usage: ./spot_breach_audit.sh  (requires kubectl context pointed at target cluster)
set -euo pipefail
OUT="spot_audit_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUT"

echo "[*] Verifying cluster context..."
kubectl config current-context | tee "$OUT/context.txt"

echo "[*] 1. Workloads created in the last 14 days (potential attacker deployments)"
kubectl get deployments,daemonsets,statefulsets,jobs,cronjobs,pods --all-namespaces \
  -o json | jq -r '.items[]
    | select(.metadata.creationTimestamp > (now - 1209600 | strftime("%Y-%m-%dT%H:%M:%SZ")))
    | [.metadata.creationTimestamp, .metadata.namespace, .kind, .metadata.name] | @tsv' \
  | sort -r | tee "$OUT/recent_workloads.tsv"

echo "[*] 2. Pods with unusual images (not from approved registries)"
kubectl get pods --all-namespaces -o json | jq -r '.items[]
  | .metadata.namespace as $ns | .metadata.name as $name
  | .spec.containers[]
  | [$ns, $name, .image] | @tsv' | tee "$OUT/all_images.tsv"
echo "    -> Review $OUT/all_images.tsv against your approved registry list"

echo "[*] 3. Pods mounting secrets as volumes or env vars"
kubectl get pods --all-namespaces -o json | jq -r '.items[]
  | select((.spec.volumes[]?.secret != null)
        or (.spec.containers[]?.envFrom[]?.secretRef != null)
        or (.spec.containers[]?.env[]?.valueFrom.secretKeyRef != null))
  | [.metadata.namespace, .metadata.name, .spec.serviceAccountName] | @tsv' \
  | tee "$OUT/pods_mounting_secrets.tsv"

echo "[*] 4. RBAC: identities with cluster-wide secret read (secrets exfil path)"
kubectl get clusterrolebindings -o json | jq -r '.items[]
  | .metadata.name as $b | .roleRef.name as $r | .subjects[]?
  | [$b, $r, .kind, .name] | @tsv' | tee "$OUT/clusterrolebindings.tsv"
kubectl get clusterroles -o json | jq -r '.items[]
  | select(.rules[]? | (.resources[]? == "secrets" or .resources[]? == "*")
           and (.verbs[]? | test("get|list|watch|\\*")))
  | .metadata.name' | tee "$OUT/secret_reader_clusterroles.txt"

echo "[*] 5. All secrets inventory (rotation checklist)"
kubectl get secrets --all-namespaces \
  --field-selector type!=kubernetes.io/service-account-token \
  -o custom-columns='NAMESPACE:.metadata.namespace,NAME:.metadata.name,TYPE:.type,AGE:.metadata.creationTimestamp' \
  | tee "$OUT/secrets_rotation_checklist.txt"

echo "[*] 6. Service accounts with automounted tokens (reduce token exposure)"
kubectl get serviceaccounts --all-namespaces -o json | jq -r '.items[]
  | select(.automountServiceAccountToken != false)
  | [.metadata.namespace, .metadata.name] | @tsv' | tee "$OUT/automount_sas.tsv"

echo "[+] Audit complete. Review the files in $OUT/ before rotating secrets or deleting workloads."
echo "[+] ROTATE every secret in secrets_rotation_checklist.txt for affected clusters — assume compromise."

Remediation

Immediate (today):

  1. Read the Rackspace advisory and any customer-specific notification. Confirm whether your clusters/tenancy are in scope. Source: https://www.bleepingcomputer.com/news/security/rackspace-spot-breach-let-hackers-access-customer-kubernetes-secrets/ — follow the linked official Rackspace communication for authoritative scoping.
  2. Rotate all credentials used with Rackspace Spot — platform accounts, API keys, and any federated identities. Enforce MFA on the Rackspace control plane if not already mandatory; this breach started with compromised credentials.
  3. Rotate every Kubernetes secret in affected clusters. This is non-negotiable. Base64 is encoding, not encryption — assume everything readable via the API was read. Priority order: cloud IAM keys, database credentials, TLS private keys, container registry pull secrets, then application secrets. Remember to revoke the old values at the source (e.g., disable the old AWS access key in IAM), not just update the Kubernetes object.
  4. Inventory workloads using the script above. Delete any Deployment, DaemonSet, Job, CronJob, or Pod you cannot attribute to a legitimate change ticket or CI/CD run. Cross-reference creation timestamps against Rackspace's disclosed intrusion window.

Short term (this week):

  1. Audit RBAC. Remove any ClusterRole granting get/list/watch on secrets that isn't strictly required. Replace broad bindings with namespace-scoped RoleBindings. Set automountServiceAccountToken: false on service accounts that don't call the Kubernetes API.
  2. Enable encryption at rest for secrets with a KMS provider if not already configured, and confirm etcd access is restricted.
  3. Verify Kubernetes audit logging is enabled and shipped off-cluster to your SIEM with retention covering at least the intrusion window plus 90 days. If you weren't auditing before, you have a forensics gap — document it for the post-incident review.
  4. Hunt downstream. Secrets stolen from clusters were stolen for a reason. Review cloud provider CloudTrail/audit logs, database access logs, and registry pull logs for use of the rotated credentials during and after the intrusion window.

Long term:

  1. Move high-value secrets out of native Kubernetes Secrets entirely — use an external secrets store (HashiCorp Vault, AWS Secrets Manager via External Secrets Operator) so API read access to the cluster does not yield plaintext credentials.
  2. Apply CIS Kubernetes Benchmark controls and map ongoing coverage to NIST CSF: control-plane credential hygiene falls under PR.AA (Identity Management), and audit-log monitoring under DE.CM (Continuous Monitoring).
  3. Add Kubernetes audit-anomaly detection (the Sigma/KQL above) to your standing SOC content — the Rackspace Spot tradecraft (valid creds → workload deployment → secrets harvesting) will be reused against every managed Kubernetes platform, not just this one.

Executive Takeaways

  • This was credential abuse, not a software flaw. Patching will not save you from the next one — MFA, credential hygiene, and behavioral detection will.
  • Secrets rotation is the containment action. An unreadable audit trail doesn't change the obligation: if attackers had API access to the cluster, every secret in it is compromised until rotated.
  • Managed platform ≠ managed detection. Rackspace operated the platform; detecting unauthorized workloads in your clusters was and remains your visibility problem.
  • Expect copycats. Compromised-credential intrusions against cloud hosting and Kubernetes control planes are low-cost, high-yield, and increasingly the default initial-access vector against cloud-native environments.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.