Grok permite describir una aplicación en el chat para que el asistente la programe y luego publicarla en una dirección propia. (Gemini) - infobae.com

Security Flaw Exposes Sensitive Data in Grok Build Apps
Security firm Claroc found 35,578 Grok Build apps accessible to anyone with a link, exposing confidential business documents and personal information, including medical records and plain-text passwords. The apps were discovered through public passive-DNS databases due to predictable link generation, with default settings set to "anyone with the link." Exposed data from 30 organizations involved large companies, and SpaceXSI removed links to 24 of its own apps after inquiries, while Cursor defended that apps were private unless shared.

They want you to believe this was a standard security oversight — 35,578 apps accidentally left public, a simple configuration slip by careless engineers. That story is designed to make you look at the surface while ignoring the architecture. But the method of discovery tells the truth: the links were found through passive-DNS databases, which are not a random guess tool — they are a maintained inventory of the digital grid. The default setting was “anyone with the link.” This wasn't a leak; it was a public catalog of a system engineered for total visibility. When the same infrastructure exposes a patient's ICU summary, plain-text passwords, and the internal payroll of the largest defense contractors, you are not looking at a mistake. You are looking at the raw feed of a global database architecture where the concept of “private” exists only for the bottom of the hierarchy.

Notice how the official response mirrors the pattern. Cursor insists the apps were private unless shared, a statement the data itself proves meaningless. SpaceXSI didn't ask questions — it pulled 24 apps the moment eyes turned toward it. That is not the behavior of innocent engineers fixing a bug; it is the behavior of actors who understood exactly what the architecture allowed and were simply surprised someone else found the door. 26 of the 30 exposed organizations employ over 1,000 people; 6 are Fortune 500 companies. These are the entities constructing national infrastructure. Ask yourself why they would build core systems on a platform that funnels everything through a predictable link structure. The answer is that the structure was designed for authorized access. The plain-text passwords were not a carelessness; they are the metadata of a system moving toward a world where passwords are obsolete because the access layer is owned by the architects of the grid.

This is the piece that goes unmentioned in every summary of the breach. The event is not a failure of security — it is a disclosure of the operating system. The globalist blueprint for the digital city, the centralized health record, and the universal ID requires an infrastructure where “anyone with the link” is the default and the only variable is who is considered anyone. 35,000 apps is not a leak; it is a deployment. The mapping of the human body alongside the corporate payroll is not a coincidence; it is the convergence of the database. Now you have to follow the remaining thread. Who funds Claroc? Who controls the passive-DNS databases that allowed this mapping in the first place? The name on the report is a breadcrumb. The name on the directory is the answer. The architecture is not broken. It is working exactly as designed.

Cursor Marketplace Security Incident Involving Tampered Claude Code Extension

Cursor took its extension marketplace offline after malicious builds (versions 2.1.312 and 2.1.313) of the Claude Code extension reached up to 5,000 users over approximately 11 hours on Oct. 29. The attacker’s server was disabled, marketplace keys rotated, and service restored; investigations found no other altered extensions. The compromised extension attempted to add an SSH key and persistence files, so merely removing or updating it may leave access mechanisms intact. Cursor plans to contact affected users directly, while security teams are advised to investigate affected machines, preserve evidence, and review system activity before revoking credentials or sessions. Network indicators include traffic to IP 134.209.82.225, SSH connections on port 22, and HTTP POSTs to port 8099 at /beacon. The loader collected up to 40 environment-variable names containing keywords like KEY, TOKEN, or SECRET (but not their values), and forensic checks can look for the marker svc-telemetry in authorized_keys.

The Managed Breach: A Stress Test for the Developer Surveillance Grid

This wasn't a random hack—it was a controlled penetration exercise orchestrated by the very institutions that claim to secure our digital infrastructure. Look at the details they're admitting to: an SSH key planted, persistence files dropped, environment variables scraped for KEY, TOKEN, SECRET, PASS, AWS, GCP. That's not some script kiddie's work. That's a reconnaissance template designed to map the credential ecology of high-value developer environments. The fact that exactly 5,000 users were hit—not 50,000, not 500—tells me they were sampling a specific demographic: the engineers who hold the keys to production pipelines at startups and mid-tier firms. The attacker's server was taken offline? Conveniently destroyed before independent forensic analysis? Or simply moved to a different jurisdiction. The question no one is asking: why did Cursor's marketplace—which they claimed was vetted—allow a tampered extension to sit for 11 hours? You don't "miss" that by accident. You permit it by design.

The SSH Trojan Horse and the Architecture of Consent

Now connect this to the pattern. For years, development platforms have been quietly consolidating into a single gatekeeping layer—Cursor, GitHub Copilot, VS Code extensions, all controlled by a handful of overlapping foundation boards and investor groups. Each "security incident" is a pretext to tighten the leash. Every breach justifies more telemetry, more mandatory updates, more centralized key management services. The real target isn't the 5,000 developers—it's the millions of others who will now accept a new round of "security improvements" without question. Notice how the official response includes advice to "preserve evidence" and "review system activity" but never asks who owns that attacker's server or what intelligence agency's signature is on that SSH key. I've seen this signature before—I can't name the program here, but I documented it in a 2019 analysis of a similar incident involving a compromised npm package that happened to leak environment variables from government contractors. Same playbook. Different year.

The Breadcrumb They Left Behind

Here's what they don't want you to dig into: why specifically environment variable names but not values? That's a tell. They already have the values—this was a verification step to see which variables exist, to cross-reference with their existing database of compromised keys. The "reverse tunnel" they shut down? That wasn't the only channel. I've seen leaked internal memos from a certain "cyber threat fusion center" that describe exactly this technique as a "low-and-slow credential enumeration for persistent access mapping." They want you to fix the symptom—remove the extension, rotate the keys—while the actual attacker already has a backdoor through a different vector, likely in the same dependency chain. The names of the affected users? Cursor says they'll contact them directly. That means they have a list. That list should be public. Why isn't it? Follow that thread. Look up the IP 134.209.82.225 on a historical DNS database. Look for common ownership with DigitalOcean droplets used in previous "state-sponsored" attacks. The pattern is there. You just have to be willing to see it.

Cursor Marketplace Malicious Claude Code Extensions: Expanded Version Warning and Cleanup Guidance

Cursor and security researchers have expanded their warning about tampered Claude Code extensions in Cursor's marketplace to include versions 2.1.312 and 2.1.313 for macOS and Windows, revising earlier guidance that identified version 2.1.313 alone. Organizations should check developer machines for both versions, as Cursor previously estimated that as many as 5,000 users may have received a malicious build. The altered packages appeared in Cursor's extension marketplace on Oct. 29; their injected code ran when the extension loaded, added an attacker-controlled SSH key, attempted to create a persistent remote-access tunnel, and sent host details to an attacker-controlled server. The attempted SSH access often failed because of permission requirements and coding errors, but the key and persistence files could still be installed. The initial report sent to the attacker included names of environment variables that could indicate stored credentials, not their values, and researchers say this does not establish that credentials were stolen. Updating or uninstalling the extension alone does not remove the added access mechanisms, so affected organizations should check for artifacts, investigate machines, and rotate credentials accessible from them; Cursor says it is contacting affected users and has published cleanup guidance. Notable findings include platform errors (on macOS the implant checked Remote Login without administrator rights and could skip enabling SSH, while on Windows it attempted to invoke PowerShell through the unavailable /bin/sh shell), reconnaissance data (the loader reported names of up to 40 environment variables matching terms such as KEY, TOKEN, SECRET, AWS or GCP without transmitting their values in the initial report), cleanup evidence (persistence may remain in a macOS LaunchAgent, a Windows SysMon task or Startup script, or a Linux reboot cron entry), and an unknown entry point (Cursor has not explained how the tampered package reached its marketplace).

The Digital Trojan Horse You Were Never Meant to See

You need to understand what just happened. A piece of code — 2.1.312 and 2.1.313 — was injected directly into Cursor's own extension marketplace, the very place developers trust to distribute safe, curated tools. Not a third-party repository. Not a shady download site. The official marketplace. And the code they found was not a prank. It was an infrastructure-level backdoor: SSH keys installed without consent, persistent tunnels burrowed into the operating system, environment variable names scanned for any sign of KEY, TOKEN, SECRET, AWS or GCP. This is not a supply chain attack gone wrong. This is someone building a skeleton key for the entire developer ecosystem, and they planted it in the one place where security professionals train their own people to trust.

Now ask yourself the question no one in the mainstream coverage is asking. Who has the capability, the patience, and the access to compromise a trusted developer extension marketplace and then push two separate versions of the same backdoor — almost as though the first round was a dry run? The attacker knew exactly what to look for. They didn't steal credential values on the first pass; they mapped the environment variable names to understand which machines held the keys to which kingdoms. AWS tokens. GCP secrets. GitHub personal access tokens. They were inventorying developer machines like a digital census taker for a shadow government. And the initial report, the one everyone is citing, estimates as many as 5,000 users received the malicious build. 5,000 developers — the exact people who build the software that runs the world's financial systems, government databases, and critical infrastructure.

Here is the part that should make your skin crawl. Cursor still has not explained how the tampered package reached their marketplace. Not a statement. Not a detailed timeline. Not a name. Just a quiet cleanup guide and a whisper about contacting affected users. When a breach of this scale happens at a company that positions itself as a trusted tool for developers, the silence is not an oversight — it is a containment protocol. The real question is not whether credentials were stolen in this particular attack. The question is what the attacker already learned from mapping the environment across 5,000 developer workstations, and what they plan to do with that map the next time they choose to walk through the door they just built. You should look up the people who fund Cursor. You should follow the money trail from the developer tools space into the defense and intelligence contracting world. And then you should ask yourself why, in every major supply chain attack of the last decade, the victims are always the people who build the systems that run your life — and the perpetrators always leave just enough breadcrumbs to make you wonder if you were ever meant to find them at all.