Rackspace Says Leaked Credentials Let an Intruder Act as Legitimate Users in Some Spot Customer Organizations and Reach Their Kubernetes Secrets, a Platform9 Co-Founder Names a Breached Observability System as the Root Cause, and the Status Page Says Only “System Maintenance Operations”
Rackspace told Spot customers that an unauthorized party used leaked credentials on November 17 to act as legitimate users and reach Kubernetes Secrets; a Platform9 co-founder says an observability...
Rackspace has told customers of its Spot cloud that “an unauthorized party used leaked credentials to access parts of Rackspace Spot” on November 17. BleepingComputer reported the customer notice on November 21 at 22:59 UTC. Per that report, the intruder could act as legitimate users in some customer organizations, create pods in their Kubernetes clusters, read Kubernetes Secrets and list nodes and volumes. Rackspace says it has since revoked the affected tokens and sessions, removed the unauthorized pods and rotated keys.
Table Of Content
- What Rackspace told customers
- Three accounts, three levels of detail
- A timeline in UTC
- What Spot’s own documentation says about the credentials in play
- What the published indicators can and cannot tell you
- A search you can run
- What customers can do, in an order that makes sense
- What nobody has published yet
- Limits of this report
The notice is one of several public statements, and they carry different levels of detail. A co-founder of Platform9, which BleepingComputer says co-developed Spot with Rackspace, wrote on GitHub on November 20 that “an observability system was breached using a compromised credential.” Spot’s status page, which we read at 10:09 UTC on November 22, carries one pinned note about “system maintenance operations” and a pause on new sign-ups until November 25, and says nothing about an intrusion. A customer opened a GitHub issue at 04:25 UTC on November 22 saying that after rotating credentials as instructed, their cluster cannot run kubectl logs or kubectl exec. No source we could read says how many customers were affected.
We could not read the notice itself. BleepingComputer obtained it, and the Reddit threads where Spot staff answered customers block scripted readers (the update thread returns only an empty page shell), so every notice sentence below is as BleepingComputer relays it. What we could read first-hand is Spot’s GitHub discussion 510 and issue 511, the status page and the feed behind it, Spot’s documentation, the registration records for the published indicators, and the Kubernetes documentation for the behavior the notice relies on.
What Rackspace told customers
BleepingComputer’s report is the only place we found the notice. This table lists what the report relays, grouped by topic.
| Topic | As BleepingComputer relays it |
|---|---|
| Window | About 00:20 to 22:00 UTC on November 17, which is 21 h 40 min |
| Discovery | November 18, after a customer report; the recipient’s organization was confirmed affected the same day |
| Access | The intruder acted as legitimate users in some customer organizations, created pods, read Kubernetes Secrets and listed nodes and volumes |
| Exposure | Any Secret in an affected user’s clusters, plus any Spot API tokens or refresh tokens that user held |
| Rackspace’s response | Revoked affected tokens and sessions, removed the unauthorized pods, rotated keys, strengthened access controls and monitoring |
| Customer instructions | Reissue Spot API tokens, replace refresh tokens used in automation tools, download fresh Kubernetes configuration files, rotate credentials stored in cluster Secrets, and review logs back to November 17 |
| Indicators | IP address 23.224.79.106, IP range 23.224.0.0/15, and the object name prefixes i1, glm- and probe |
| Counts | None. BleepingComputer asked how many customers were affected and whether data was stolen, and had not received a response |
BleepingComputer adds that the breach “caused an extended outage of the Rackspace Spot administration console, temporarily preventing customers from managing their clusters and rotating potentially compromised credentials,” and that Rackspace announced service fully restored on November 21 after multiple delays.
Three accounts, three levels of detail
Besides the notice, two public statements describe the incident. Both are first-hand and checkable.
| Statement | Where and when | What it says | What it leaves out |
|---|---|---|---|
| Customer notice | As relayed by BleepingComputer, November 21 | “an unauthorized party used leaked credentials to access parts of Rackspace Spot”; the intruder could act as legitimate users in some customer organizations | Whose credentials, where they leaked, how many customers |
| Platform9 co-founder | GitHub discussion 510, November 20 at 19:01 UTC | “an observability system was breached using a compromised credential”; the long outage comes from “several intrusive changes to the underlying infrastructure clusters” | How a breached observability system led to access in customer organizations, and whose credential it was |
| Status page | Pinned note created November 21 at 17:15 UTC | “Following recent system maintenance operations, we’re prioritizing Spot capacity for existing customers”; new organization sign-ups paused until November 25 at 17:00 UTC | Any mention of an intrusion, credentials or the outage |
The GitHub comment comes from the account sirishkr, whose public profile name is Sirish Raghuram. That is the name BleepingComputer gives for the co-founder and Chief Growth Officer of Platform9, and BleepingComputer quotes him answering customers on Reddit and saying he was “instrumental in creating Spot.” The comment replies to customers who asked on November 20 for news of an outage one of them called “offline for 24 hours already.” It says the root cause “has been discussed on the subreddit and in emails to customers who reached out.” It names those two channels and no general notice.
Spot’s public wording for the outage is maintenance. The co-founder calls the recovery work “the maintenance activity,” and the status page speaks of “system maintenance operations”; when we read it, the page’s header said “All Systems Operational.” The explanation given to customers who asked is a breach. The notice and the co-founder’s sentence may describe one chain of events, but no source we could read connects an observability system to access inside customers’ organizations, or says whose credential it was.
A timeline in UTC
| When | What happened | Source |
|---|---|---|
| Nov 17, about 00:20 to 22:00 | Intrusion window | Notice, via BleepingComputer |
| Nov 17 and 18, 03:13 and 15:13 | The 12-hour control-plane monitor is green at all four beats | Status feed |
| Nov 18, no clock time | Rackspace learns of the intrusion after a customer report | Notice, via BleepingComputer |
| Nov 19, 03:13:50 | The 12-hour control-plane monitor first turns pending, then down at 03:43:50 | Status feed |
| Nov 20, 07:16 | A customer asks for an update on an outage “offline for 24 hours already” | GitHub discussion 510 |
| Nov 20, 19:01 | Co-founder names a breached observability system and a compromised credential, and hopes to restore service by the end of the day in California | GitHub discussion 510 |
| Nov 20, 23:15 | New estimate: full service by 9 a.m. Pacific on November 21, which is 17:00 UTC | GitHub discussion 510 |
| Nov 21, 02:41:35 | One customer’s cluster certificate authority shows this as its start of validity (notBefore) | GitHub issue 511 |
| Nov 21, 10:24 | Control-plane and node-availability monitors are green again | Status feed |
| Nov 21, 17:15:07 | Status note created: sign-ups restricted until November 25 at 17:00 UTC | Status page API |
| Nov 21, 22:59 | BleepingComputer reports the notice and says service was fully restored on November 21 | BleepingComputer |
| Nov 22, 04:25 | A customer opens issue 511: Konnectivity broken after the outage and credential rotation | GitHub issue 511 |
The status feed is the only machine-readable record of the outage. Spot’s status page documentation defines the long-term control-plane monitor as an average over 12 hours in which a green bar means more than 99 percent of Cloudspaces have a healthy control plane. A bar that is not green therefore says the share crossed that line, not how many clusters were down. The feed keeps only the last 50 beats per monitor, which is about three weeks for the 12-hour monitor and about a day for the 30-minute ones, so only the 12-hour monitor spans the outage. The script below reads a copy of the feed that we saved at about 10:10 UTC on November 22, or the live URL, and prints every beat that is not green.
"""kuma_beats.py: read the heartbeat feed behind the Rackspace Spot status page (a saved copy or the live URL),
print every beat that is not green, then do the arithmetic against the dates in the customer notice.
Usage: python kuma_beats.py kuma_heartbeat_snapshot.json
python kuma_beats.py https://status.spot.rackspace.com/api/status-page/heartbeat/uptime
The feed keeps only the last 50 beats per monitor, so the 12-hour monitor covers about three weeks.
"""
import json
import sys
from datetime import datetime, timezone
LABEL = {0: "DOWN", 1: "up", 2: "PENDING", 3: "MAINT"}
NAME = {"45": "control plane (30 min)", "49": "control plane, long term (12 h)",
"54": "node availability (30 min)", "66": "DBaaS (1 h)"}
src = sys.argv[1]
if src.startswith("http"):
import requests
data = requests.get(src, timeout=30).json()
else:
data = json.load(open(src, encoding="utf-8"))
def when(beat):
return datetime.strptime(beat["time"][:19], "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
def hm(delta):
secs = int(delta.total_seconds())
return f"{secs // 3600} h {secs % 3600 // 60:02d} min"
for monitor, beats in data["heartbeatList"].items():
bad = [b for b in beats if b["status"] != 1]
print(f"monitor {monitor} {NAME.get(monitor, '?')}: {len(beats)} beats, "
f"{beats[0]['time'][:16]} to {beats[-1]['time'][:16]} UTC, {len(bad)} not green")
for b in bad:
print(f" {b['time'][:19]} {LABEL.get(b['status'], b['status'])}")
beats = data["heartbeatList"]["49"]
bad = [b for b in beats if b["status"] != 1]
first_bad = when(bad[0])
first_down = when(next(b for b in beats if b["status"] == 0))
last_green_before = max(when(b) for b in beats if b["status"] == 1 and when(b) < first_bad)
first_green_after = min(when(b) for b in beats if b["status"] == 1 and when(b) > when(bad[-1]))
window_end = datetime(2026, 11, 17, 22, 0, tzinfo=timezone.utc) # notice: about 00:20 to 22:00 UTC on Nov 17
eta = datetime(2026, 11, 21, 17, 0, tzinfo=timezone.utc) # "9am PST 11/21" is 17:00 UTC
print()
print("intrusion window ends to first not-green beat :", hm(first_bad - window_end))
print("first not-green beat to first DOWN beat :", hm(first_down - first_bad))
print("first not-green beat to first green after :", hm(first_green_after - first_bad))
print("last green before to first green after (max) :", hm(first_green_after - last_green_before))
print("first green after, against the 17:00 UTC ETA :", hm(eta - first_green_after), "earlier")
On the saved copy it prints:
monitor 45 control plane (30 min): 50 beats, 2026-11-21 09:24 to 2026-11-22 09:54 UTC, 0 not green
monitor 49 control plane, long term (12 h): 50 beats, 2026-10-30 03:13 to 2026-11-21 22:24 UTC, 8 not green
2026-11-19 03:13:50 PENDING
2026-11-19 03:43:50 DOWN
2026-11-19 15:43:51 DOWN
2026-11-20 03:43:51 DOWN
2026-11-20 15:43:51 DOWN
2026-11-20 21:46:43 PENDING
2026-11-20 21:54:00 PENDING
2026-11-20 22:24:00 DOWN
monitor 54 node availability (30 min): 50 beats, 2026-11-21 09:24 to 2026-11-22 09:54 UTC, 2 not green
2026-11-21 09:24:07 DOWN
2026-11-21 09:54:07 DOWN
monitor 66 DBaaS (1 h): 50 beats, 2026-11-22 08:30 to 2026-11-22 10:08 UTC, 0 not green
intrusion window ends to first not-green beat : 29 h 13 min
first not-green beat to first DOWN beat : 0 h 30 min
first not-green beat to first green after : 55 h 10 min
last green before to first green after (max) : 67 h 10 min
first green after, against the 17:00 UTC ETA : 6 h 36 min earlier
The monitor was green at both beats on November 17 and both on November 18, so it shows nothing for the intrusion window itself. It first turned pending 29 h 13 min after the window closed, went down 30 minutes later, stayed down for four 12-hour beats, showed two pending beats and one more down beat on the evening of November 20, and was green at 10:24 UTC on November 21. That is between 55 h 10 min and 67 h 10 min of bars that were not green, depending on where in a 12-hour gap each change happened. Recovery came 6 h 36 min before the 17:00 UTC estimate, on the same beat that brought the node-availability monitor back. The sign-up note arrived 15 minutes after that estimate.
What Spot’s own documentation says about the credentials in play
Besides the contents of their Secrets, the notice tells customers to replace three Spot credentials: API tokens, refresh tokens in automation tools and kubeconfig files. Spot’s documentation shows how they relate.
| Credential | What the documentation says | Lifetime it gives |
|---|---|---|
| Refresh token | Generated in the console under API Access. The release notes call it the “same token used with the Terraform provider,” and spotctl reads it from SPOT_REFRESH_TOKEN. The Terraform page says such tokens “provide access to your account and must be stored securely.” |
The Terraform page, which calls it an Access Token, says it “doesn’t currently include a refresh mechanism”; the spotctl page says “Tokens can expire or be revoked.” No lifetime is given |
| Access token | A POST to /oauth/token with the grant type refresh_token returns an id_token that serves as the access token for later API calls (API reference) |
The example response shows an expires_in of 86400 seconds |
| Kubeconfig token | Downloaded from the console, or returned by the API’s generate-kubeconfig call, which takes an organization name, a Cloudspace name and a refresh token |
The kubectl page says the token in a console-downloaded kubeconfig “is valid for up to 72 hours”; the API reference gives no figure |
| OIDC context | The same kubeconfig carries a second context ending in -oidc for “longer term access” through the kubelogin plugin |
Not stated |
Two points explain why the notice reads as it does. The first is in the API reference, which describes the kubeconfig call this way: “It is unauthenticated api, so doesn’t require API token in headers when calling it.” Going by the documentation, then, a refresh token plus an organization name and a Cloudspace name is enough to produce a kubeconfig, with no other credential in the request, and the documentation does not say whether a refresh token is limited to one Cloudspace. A kubeconfig token minted at the very end of the intrusion window would, if the 72-hour figure holds for generated kubeconfigs, have lapsed by 22:00 UTC on November 20. The lasting credential is the refresh token, which matches the notice’s stress on replacing refresh tokens held in automation. The release notes say the kubeconfig call was built for “CI/CD pipelines and infrastructure automation workflows,” which is where such tokens tend to sit: in CI variables, .tfvars files and Secrets that automation mounts. That reading is ours.
The second point comes from Kubernetes rather than Spot. Its Secrets documentation warns that “anyone who is authorized to create a Pod in a namespace can use that access to read any Secret in that namespace; this includes indirect access such as the ability to create a Deployment.” The notice lists creating pods and reading Secrets as separate abilities, but in practice the first reaches the second: every Secret in each namespace where the intruder could create a pod should be treated as read. Our earlier look at Kubernetes Secret sprawl argues that the deeper problem is access control rather than YAML.
What the published indicators can and cannot tell you
- The address. The ARIN record puts 23.224.79.106 inside network DATA-CENTRE-LA, a direct allocation registered in 2013 to CloudRadium L.L.C of Los Angeles, and RIPEstat shows the address covered only by a /15 announcement from AS40065 (CNSERVERS LLC). A registration says who holds an address block, not who used one address on November 17. GreyNoise’s community API answered “IP not observed scanning the internet” at about 10:20 UTC on November 22, so a block list built from known scanners would not carry it.
- The range. 23.224.0.0/15 runs from 23.224.0.0 through 23.225.255.255, which is 131,072 addresses. We would use it as a search filter and not as a block list, because blocking it would cut a hosting provider’s whole allocation.
- The name prefixes.
i1is also how names such asi18n-webbegin, andprobeis a common word in monitoring setups, so prefix hits are leads, not findings. The notice does not say what the pods ran. Spot’s home page advertises NVIDIA H100 and A30 GPU flavors, so pods namedglm-could be a model deployment, but that is our guess and the notice gives no support for it. - The removed pods. Rackspace says it removed the unauthorized pods, so a scan of a live cluster may find only leftovers such as service accounts, role bindings, Secrets or config maps.
A search you can run
The first script below needs no cluster access. It prints the log lines that contain an address inside a network you give it, and it matches with the ipaddress module, so 23.225.1.5 counts as inside 23.224.0.0/15 while 123.224.79.106 does not. The sample log is made up.
"""cidr_lines.py: print the log lines that contain an IPv4 address inside any network given on the command line.
Usage: python cidr_lines.py 23.224.0.0/15 access.log other.log
some_command | python cidr_lines.py 23.224.79.106/32 23.224.0.0/15
Arguments that parse as a network are filters; everything else is a file name (no file names = read stdin).
Matching uses the ipaddress module, so 23.225.1.5 counts as inside 23.224.0.0/15 while 123.224.79.106 does not.
"""
import ipaddress
import re
import sys
# A dotted quad that is not glued to another digit or dot, so 123.224.79.106 is never read as 23.224.79.106.
IPV4 = re.compile(r"(?<![\d.])(?:\d{1,3}\.){3}\d{1,3}(?![\d.])")
networks, files = [], []
for arg in sys.argv[1:]:
try:
networks.append(ipaddress.ip_network(arg, strict=False))
except ValueError:
files.append(arg)
def matches(line):
found = []
for m in IPV4.finditer(line):
try:
ip = ipaddress.ip_address(m.group(0))
except ValueError: # 999.1.1.1 and friends
continue
if any(ip in net for net in networks):
found.append(str(ip))
return found
streams = [open(name, encoding="utf-8", errors="replace") for name in files] or [sys.stdin]
count = 0
for stream in streams:
for line in stream:
hit = matches(line)
if hit:
count += 1
print(f"{','.join(hit)}\t{line.rstrip()}")
sys.stdout.flush() # keep the summary after the matches when both streams go to one file
size = sum(n.num_addresses for n in ipaddress.collapse_addresses(n for n in networks if n.version == 4))
print(f"{count} matching lines; the filter covers {size:,} addresses", file=sys.stderr)
Sample log:
2026-11-17T01:12:44Z registry pull from 23.224.79.106 image=app:1.4 status=200
2026-11-17T03:40:02Z git clone from 23.225.200.9 repo=infra
2026-11-17T04:00:00Z login ok user=build from 198.51.100.7
2026-11-17T05:00:00Z login ok user=build from 123.224.79.106
2026-11-17T06:00:00Z s3 GetObject from ::ffff:23.224.79.106 key=backup.tar
2026-11-17T07:00:00Z login ok user=ci from 23.226.0.1
2026-11-17T08:00:00Z odd line with 999.224.79.106 and 23.224.79.106.5
Running python cidr_lines.py 23.224.79.106/32 23.224.0.0/15 sample.log prints:
23.224.79.106 2026-11-17T01:12:44Z registry pull from 23.224.79.106 image=app:1.4 status=200
23.225.200.9 2026-11-17T03:40:02Z git clone from 23.225.200.9 repo=infra
23.224.79.106 2026-11-17T06:00:00Z s3 GetObject from ::ffff:23.224.79.106 key=backup.tar
3 matching lines; the filter covers 131,072 addresses
For the cluster side, the shell loop below lists objects with their creation times. It uses only flags that the kubectl get reference documents (all namespaces, no headers and custom-columns output). It deliberately avoids JSON output, which would write every Secret value to disk. Per the Kubernetes API reference, the creation time is “represented in RFC3339 form and is in UTC,” so it compares directly with the notice’s window.
# Run against your own Cloudspace. It prints names and creation times only, never Secret values.
cols="NAMESPACE:.metadata.namespace,NAME:.metadata.name,CREATED:.metadata.creationTimestamp"
: > objects.txt
for kind in pods deployments daemonsets statefulsets jobs cronjobs serviceaccounts rolebindings secrets configmaps; do
echo "## $kind" >> objects.txt
kubectl get "$kind" --all-namespaces --no-headers -o custom-columns="$cols" >> objects.txt
done
echo "## clusterrolebindings" >> objects.txt
kubectl get clusterrolebindings --no-headers -o custom-columns="$cols" >> objects.txt
The second script reads that file. It flags objects created inside the notice’s window, or within an hour of it because the notice says “about,” and objects whose names start with the published prefixes. The input below is made up.
"""k8s_window.py: flag Kubernetes objects created inside (or near) the stated intrusion window, or named with the
published prefixes. Reads the plain-text listing that `kubectl get ... -o custom-columns=...` prints (see the loop in
the article), so no Secret values ever land in the file.
Input format: a line "## <kind>" starts a block, then one line per object: NAMESPACE NAME CREATED
Usage: python k8s_window.py objects.txt
"""
import sys
from datetime import datetime, timedelta, timezone
START = datetime(2026, 11, 17, 0, 20, tzinfo=timezone.utc) # "about 00:20" in the notice
END = datetime(2026, 11, 17, 22, 0, tzinfo=timezone.utc) # "22:00 UTC" in the notice
SLACK = timedelta(hours=1) # the notice says "about", so look a little wider
PREFIXES = ("i1", "glm-", "probe") # as published, no further detail
def parse(stamp):
return datetime.fromisoformat(stamp.replace("Z", "+00:00"))
kind = "?"
flagged = 0
print(f"{'KIND':<21}{'NAMESPACE':<11}{'NAME':<31}{'CREATED (UTC)':<22}REASON")
for line in open(sys.argv[1], encoding="utf-8"):
line = line.strip()
if not line:
continue
if line.startswith("## "):
kind = line[3:]
continue
namespace, name, created = line.split()[:3]
reasons = []
if created != "<none>":
when = parse(created)
if START <= when <= END:
reasons.append("created in window")
elif START - SLACK <= when <= END + SLACK:
reasons.append("created within 1 h of window")
prefix = next((p for p in PREFIXES if name.startswith(p)), None)
if prefix:
reasons.append(f"name starts with {prefix}")
if reasons:
flagged += 1
print(f"{kind:<21}{namespace:<11}{name:<31}{created:<22}{'; '.join(reasons)}")
print(f"{flagged} objects flagged")
Input:
## pods
kube-system coredns-7d9c5b6d8-abcde 2026-10-03T08:15:21Z
shop web-5f6c7d9b8-q2x7k 2026-11-12T14:02:11Z
shop i18n-web-6b7d8c9f5-m4k2p 2026-11-03T09:00:00Z
tools glm-serve-0 2026-11-17T09:41:07Z
tools probe-runner-7c9d 2026-11-17T21:59:59Z
tools nightly-report-29372640-x8k2d 2026-11-17T22:20:00Z
tools cleanup-29372700-9tq4v 2026-11-18T01:00:03Z
## secrets
shop db-credentials 2026-09-01T10:00:00Z
tools registry-auth 2026-11-17T09:40:12Z
## serviceaccounts
tools builder 2026-11-17T23:10:00Z
## clusterrolebindings
<none> tools-admin 2026-11-17T09:41:00Z
<none> system:basic-user 2026-10-03T08:14:00Z
It prints:
KIND NAMESPACE NAME CREATED (UTC) REASON
pods shop i18n-web-6b7d8c9f5-m4k2p 2026-11-03T09:00:00Z name starts with i1
pods tools glm-serve-0 2026-11-17T09:41:07Z created in window; name starts with glm-
pods tools probe-runner-7c9d 2026-11-17T21:59:59Z created in window; name starts with probe
pods tools nightly-report-29372640-x8k2d 2026-11-17T22:20:00Z created within 1 h of window
secrets tools registry-auth 2026-11-17T09:40:12Z created in window
clusterrolebindings <none> tools-admin 2026-11-17T09:41:00Z created in window
6 objects flagged
The made-up listing includes an i18n-web pod that matches the i1 prefix by accident, a pod created 20 minutes after the window and flagged by the one-hour margin, and objects created just past that margin that are correctly left out. A small test file, test_lab.py, asserts all of this and the status-feed arithmetic above, and it passed 3 of 3 checks. We could not run the kubectl loop because we have no Spot cluster, so the commands rest on the documentation and the scripts on made-up listings.
What customers can do, in an order that makes sense
These steps are ours, built from the notice as BleepingComputer relays it and from the documentation linked above. They are not Rackspace guidance.
- Replace the refresh token everywhere it lives. Look in CI variables,
.tfvarsfiles, environment variables such asSPOT_REFRESH_TOKEN,spotctlconfiguration and any Kubernetes Secret that automation mounts. The notice says Rackspace revoked the affected tokens; replacing yours means you do not depend on yours having been among them. - Download a fresh kubeconfig. The notice asks for it, and the documentation says the token in a console download lasts up to 72 hours, so any file saved more than 72 hours ago has already expired.
- Then rotate what the Secrets hold. Treat every Secret in an affected cluster as read, and start with credentials that open other systems: cloud keys, registry and Git tokens, database passwords. Doing this after step 1 matters, because a refresh token that still worked could read the new values. This is the posture Northflank asked of its customers in late October in a different incident, which we covered.
- Search the systems those credentials belong to, from 00:20 UTC on November 17. Use the address filter on registry, Git, storage and database logs. Only one address and one hosting range have been published, so a clean result clears that range and nothing more. Spot’s own record may not reach back that far: the July 2025 release note says its Events dashboard “currently displays events from the past 24 hours,” and none of the page titles in Spot’s documentation index mentions audit logs.
- Test the cluster after rotating. Run
kubectl logs,kubectl execandkubectl port-forwardagainst a pod on each node, and watch any admission webhook that calls an in-cluster service. The customer who opened issue 511 reports that all of these fail with “No agent available” after rotation, and diagnoses the Konnectivity server in the control plane. Kubernetes describes Konnectivity as “a TCP level proxy for the control plane to cluster communication.” At 10:27 UTC the issue was open with no replies, and it is one customer’s cluster and one customer’s diagnosis, not a Rackspace finding.
What nobody has published yet
- How many organizations and customers were affected, and in which regions. BleepingComputer asked and had no reply.
- Whose credential it was. The notice says “leaked credentials” and the co-founder says “a compromised credential”; neither says where it leaked.
- How a breached observability system produced access as customer users, and what that system held. Our report on the Cursor and Fireworks AI incident described a bucket of agent traces holding unredacted credentials, but nothing says Spot’s observability system holds credentials in that way.
- Whether anything beyond Secrets, tokens and listings of nodes and volumes was reached, and what the
glm-,i1andprobepods did, including whether any customer was billed for capacity the intruder used. - Whether organization-wide MFA, which the release notes describe for logins, applies to API calls made with a refresh token.
- Whether Rackspace will publish a root-cause analysis. A customer asked for one on GitHub, along with what service credits an outage of more than 24 hours earns.
- What “fully restored” covers, given issue 511.
Limits of this report
We did not read the customer notice, only BleepingComputer’s account of it, and we could not read the Reddit threads. The identification of the GitHub account sirishkr with Sirish Raghuram rests on its public profile name and on BleepingComputer’s use of that name. The status monitors measure what Spot’s documentation says they measure, and the 12-hour monitor’s beats are coarse. We did not call any Spot API with a token, did not run the kubectl loop and did not contact any address or range from the notice. Our requests to Spot were reads of public pages, its public status feed and its public GitHub repository. If Rackspace publishes the notice, a count of affected customers or a root-cause analysis, those facts should replace the gaps listed above.








No Comment! Be the first one.