Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
All full reports
Full reportRecon workbenchesMonograph 39 / 5520 min read

Exposed Recon Queues and Maven Files: Inside an Open HTTP Workbench

How an exposed HTTP workbench combines unattended agent queues, scope polling, staged Java coordinates, and 42 credential findings

By
Odin by Brandefense
Published
19 November 2026
Reading time
20 min read
Edition
Version 1.1 · TLP:CLEAR
Scope
Prepared November 2026
Exposed Recon Queues and Maven Files: Inside an Open HTTP Workbench

1. Executive Summary

In short

Odin by Brandefense examined directory records dated 3 to 16 August 2026 from an open HTTP server in France. It exposed 843 reported files across 12 directory slices (599 sampled unique entries). The server co-located 220 agent task outputs across nine session folders, Go scope-polling files, a staged Maven directory (coordinate and filenames withheld), and 42 credential findings. Pin Maven and Gradle builds to internal HTTPS proxies, enforce artifact checksums, and audit cloud tokens.

Autonomous coding agents let operators and security researchers run reconnaissance queues overnight without sitting at a keyboard. On this host, reconnaissance queues, scope-polling files, and a staged Java package directory sit on the same open HTTP port. We inspected directory metadata and file structures without running any code, replaying any credential, or contacting any third-party target.

1

Unattended agent queues pair overnight reconnaissance summaries with nine session trees.

Two exposed agent workspace folders sit next to three root files: an overnight summary, an API response file, and a setup log (exact host paths withheld). Across 220 itemized task outputs in nine anonymized session folders, 113 symbolic links track delegated subagents and 107 regular files hold background shell logs. Seventy-two sized logs total 7.59 MB, and 12 carry credential or exploit tags.

2

Go scope-polling files sit beside a staged Maven repository.

On the same HTTP root, a Go scope-polling directory lists files for polling, sitemap handling, storage, and Cloudflare Compose (project name and paths withheld). Next to it, a staged Maven directory lists a Java source file, a JAR, and a POM (coordinate, filenames, and paths withheld). Unpinned Maven or Gradle builds and cluster library loaders induced to query that HTTP repository could pull the staged JAR.

3

Open HTTP directory exposure leaks forty-two cloud, analytics, and database credentials.

Automated secret checks across the host found 42 credential records without publishing any raw secret value. AWS IAM keys account for 71.4% of those records (29 access key IDs and one secret key), alongside seven cloud analytics workspace tokens and five database connection strings. An open directory listener can expose credentials stored within its served directory tree, while the host-level summary does not identify which files held all 42 findings.

Three Decisions for Leaders

  1. Pin every Java build to an internal HTTPS artifact proxy. Block direct developer and CI runner access to external HTTP Maven repositories, enforce mirror settings, and require SHA-256 and PGP checks on every dependency.
  2. Audit cloud IAM and analytics workspace tokens for unattended agent abuse. Rotate exposed AWS access keys, bind analytics workspace tokens to IP allowlists, and alert on burst API enumeration from unapproved networks.
  3. Govern internal red-team and bug-bounty servers like production systems. Ban unauthenticated HTTP directory listeners, isolate offensive agent sandboxes, and purge task transcripts that hold live credentials.

The Study in Numbers

NumberWhat it is
843 / 599Reported exposed files across 12 directory slices, with 599 sampled unique entries on the open HTTP server
220Itemized agent task output files across nine anonymized session folders (113 symlinks and 107 shell files)
7.59 MBTotal volume across 72 sized task output files (ranging from 33,043 to 261,889 bytes)
3Staged Maven directory files: a Java source file, a JAR, and a POM (coordinate and filenames withheld)
42Exposed host credential records: 29 AWS keys, 7 analytics tokens, 5 database strings, and 1 AWS secret
0Published IP addresses or file SHA-256 hashes, withheld because researcher ownership remains plausible
12 / 15Published generic Maven layout, task-glob, CLI, and build-config patterns in Chapter 8 (coordinates, filenames, project name, port, and 15 host paths withheld)

How to use this report.

Security leaders should start with Chapters 1, 5, and 6. DevSecOps, Java build, and cloud IAM engineers should read Chapters 4, 5, and 6. SOC analysts and detection engineers should focus on Chapters 7 and 8. CTI analysts will find the workspace and session breakdown in Chapters 2 and 3.

2. What Was Found on the Open HTTP Server: Four Layers and 843 Reported Files

In short

One unauthenticated HTTP server in France exposed 843 reported files across 12 directory slices. Four co-hosted layers join autonomous agent queues, Go scope-polling files, a staged Maven repository, and 42 leaked credentials. Audit open HTTP ports and lock build proxies.

Manual reconnaissance usually leaves isolated tool output on an analyst workstation. Autonomous CLI coding agents work differently. Operators pair scope-polling utilities with multi-session agent loops that enumerate APIs, test endpoints, and write summary Markdown reports overnight (T1595.002). When that workspace also serves a Maven package tree over cleartext HTTP, reconnaissance and dependency staging share one directory root (T1195.001).

The exposed HTTP server sits in France. Its IP address, port, and scope-poller project name are withheld because open-source scope polling and textbook Java test names can belong to a security researcher. A bug-bounty hunter may have left an automation host open by mistake. Directory index records on the server carry file listing dates of 3 to 16 August 2026. We model the host as a four-layer research workbench rather than attributing it to a named threat actor.

Figure 1: Four co-hosted layers unite unattended recon queues and staged Maven files
Figure 1: Four co-hosted layers unite unattended recon queues and staged Maven files

How the 843 reported files break down

Twenty-five directory index records across 12 directory slices on the server reported 843 total files. Removing duplicates across those listings left 599 sampled unique entries and 244 un-sampled reported paths that were never opened.

Within the 599 sampled entries, 220 itemized .output records sit inside nine anonymized session folders in the cloud-analytics workspace tree. The remaining 379 sampled entries cover a second agent workspace tree, three root coordination files, the Go scope-poller tree, and the staged Maven directory (project name and paths withheld). No third-party company or bug-bounty target is named anywhere in this report.

Dataset slice on exposed hostCountShare or scopeWhat it represents
Reported exposed files843100.0% across 12 slicesTotal files reported across 25 directory index listings
Sampled unique entries59971.1% of 843Unique file paths across agent queues, Go scope poller, root, and Maven tree
Un-sampled directory entries24428.9% of 843Sub-paths reported in directory counts but not opened
Itemized agent .output files22036.7% of 599Task output logs across nine anonymized session folders in the analytics tree
Other sampled workbench entries37963.3% of 599Second agent workspace, root status files, Go scope poller, and Maven files
Host credential findings424 credential typesExposed AWS, analytics workspace, and database credentials (values withheld)

Four operational layers on one filesystem

Sorting the 599 sampled paths by function reveals four distinct layers living side by side on the server. Their co-location supports a workbench model. The listings do not establish a transfer from scope polling to agent tasks or any downstream Java loading.

Figure 2: Behavioral network and CI controls catch unapproved Maven pulls without IP blocks
Figure 2: Behavioral network and CI controls catch unapproved Maven pulls without IP blocks
Workbench layerArtifacts observed on hostMain countDefensive focus
1. Agent recon queuesTwo exposed agent workspace trees and three root summary files (paths withheld)220 .output files in 9 sessionsHunt unattended API enumeration and exposed agent logs
2. Go scope-polling stackGo storage files, three web-service modules, and Cloudflare Compose file (project name and paths withheld)5 core Go and Compose modulesMonitor unapproved scope pollers and open management ports
3. Staged Maven repositoryA Java source file, a JAR, and a POM in a versioned Maven layout (coordinate, filenames, and paths withheld)3 staged Java and Maven filesPin builds to HTTPS proxies and verify unapproved coordinates
4. Exposed host secretsHost-level credential summary across AWS IAM, analytics workspace, and database categories (per-file locations unverified)42 secret findingsRotate exposed IAM keys and restrict workspace token IPs

Because a single cloud VPS IP address changes quickly and may belong to a dual-use researcher, cyber threat intelligence can support review before blocking. Defenders get durable protection by verifying unapproved Maven coordinates, locking build tools to internal HTTPS repositories, and finding exposed workspaces through external attack surface management.

3. Unattended Agent Recon Queues and Nine Session Folders

In short

Nine anonymized session folders hold 220 task .output logs beside an overnight summary file (exact host paths withheld). Every task file follows one of two agent naming patterns: 113 subagent symlinks and 107 background shell logs. Purge agent task transcripts and ban open HTTP listeners on research VMs.

CLI coding agents store session state in predictable folder structures. When an operator starts an agent inside a project directory, the runtime flattens path slashes into hyphens and writes per-session UUID subdirectories. Serving the parent folder over an unauthenticated HTTP server turns every subagent transcript and background shell log into a public web page (T1552.001).

Figure 4: Single unauthenticated HTTP listener exposes recon, Maven, and credential layers
Figure 4: Single unauthenticated HTTP listener exposes recon, Maven, and credential layers

Every one of the 220 itemized files sits inside a per-session tasks/ directory. Exact host paths and session UUIDs are withheld, and every file matches one of two naming patterns without exception.

Task file patternCountShare of 220Listing extensionSized files and byte rangeWhat creates it
a<16hex>.output (17-char ID)11351.4%output@ (POSIX symlink)10 sized (91,392 to 254,783 B); 103 unsizedDelegated subagent runs linked to JSONL transcripts
b<8alnum>.output (9-char ID)10748.6%output (regular file)62 sized (33,043 to 261,889 B); 45 unsizedBackground shell commands capturing stdout and stderr

The split between output@ and output shows how the agent divides work. Reasoning tasks spawn subagents symlinked as a<16hex>.output (113 files), while background shell pipelines write to regular b<8alnum>.output files (107 files).

Across the 72 sized files (10 output@ symlinks and 62 regular output files), log volume totals 7,585,435 bytes (7.59 MB). File sizes range from 33,043 to 261,889 bytes (median 88,382 bytes), while 148 entries remain unsized stubs.

Overnight coordination files at the web root

Three coordination files in the HTTP root sit beside the agent workspace directories (exact host filenames withheld):

  • Overnight summary file. Listed as an overnight summary; contents uninspected.
  • Structured API response file. Listed as an API response file; contents uninspected.
  • Setup log file. Listed as a setup log; contents uninspected.

All 220 .output entries have an initial listing timestamp of 4 August 2026 (07:45:35Z). Their last listing timestamps fall on 15 August: 81 at 22:34:01Z and 139 at 22:36:04Z. These are directory listing timestamps, not execution times.

Concentration across the nine anonymized session queues

Activity is heavily concentrated. Three anonymized sessions hold 181 of 220 files (82.3%). One holds 4,808,890 bytes (63.4% of 7.59 MB).

The source inventory marks 12 .output files across 13 tag instances. Nine carry cloud-credentials tags (one in Session 3 also carries exposed-secrets), and three carry exploit-code tags. Hashes are withheld on 123 files, and 97 carry no hash.

Session rank and labelFilesShareoutput@ / outputSized files (total bytes)Content tags
1 · Session 1 (UUID withheld)8438.2%84 / 00 (0 B)1 cloud-credentials
2 · Session 2 (UUID withheld)5424.5%16 / 380 (0 B)None
3 · Session 3 (UUID withheld)4319.5%9 / 3440 (4,808,890 B)4 cloud-credentials, 1 exposed-secrets
4 · Session 4 (UUID withheld)115.0%3 / 86 (881,632 B)3 cloud-credentials, 2 exploit-code
5 · Session 5 (UUID withheld)104.5%0 / 1010 (871,033 B)1 cloud-credentials
6 · Session 6 (UUID withheld)104.5%1 / 99 (520,877 B)1 exploit-code
7 · Session 7 (UUID withheld)62.7%0 / 66 (451,172 B)None
8 · Session 8 (UUID withheld)10.5%0 / 11 (51,831 B)None
9 · Session 9 (UUID withheld)10.5%0 / 10 (0 B)None

4. Go Scope-Polling Files and the Staged Maven Repository

In short

Beside the agent queues, a Go project directory lists scope-polling and Cloudflare Compose files (project name and paths withheld). A staged Maven directory lists a Java source file, a JAR, and a POM (coordinate, filenames, and host paths withheld). Nothing confirms any external build pulled the JAR, yet unpinned HTTP repositories remain a build-pipeline risk. Lock Java builds to internal HTTPS proxies.

Scope-polling files and a custom Maven directory sit side by side on the same server. The Go scope-polling project is built to track public attack surface. Alongside it, the Maven directory follows the layout that Java build tools and cloud clusters use for HTTP dependency lookups. Figure 3 maps the co-located artifact layers and defender controls.

Figure 3: Scope-polling files beside staged Maven artifacts
Figure 3: Scope-polling files beside staged Maven artifacts

Target-scope polling files in the Go project directory

The exposed directory lists Go storage files, three web-service modules, and a Compose configuration. Their exact host paths and project name are withheld.

The directory listing shows files named for polling, sitemap handling, storage, and Cloudflare Compose. The listings do not establish that those modules ran or that a tunnel was active.

Inside the staged Maven directory layout

Next to the Go project tree, the staged Maven directory follows the standard Apache Maven 2 repository layout (/<groupId-path>/<artifactId>/<version>/<artifactId>-<version>.<ext>). Its coordinate, filenames, and host paths are withheld. Maven and Gradle clients resolve a coordinate by converting dots in the group ID into slashes, then requesting the POM and JAR paths over HTTP or HTTPS (T1195.001).

Staged artifact on exposed hostArtifact roleHow Java tools use itPrimary defender control
Staged Java source file (filename and root path withheld)Staged Java source fileListed at the repository root alongside the versioned coordinate directoryUse SID 9539002 as a hunt signal and scan with YARA
Staged Maven POM file (coordinate, filename, and path withheld)Maven POM metadata fileIts listed path suggests a Maven coordinate; its contents and dependencies were not inspectedForce <mirrorOf>*</mirrorOf> in settings.xml to an internal HTTPS proxy
Staged Maven JAR file (coordinate, filename, and path withheld)JAR file (contents uninspected)Could be fetched into build-runner caches or cluster nodes if a client resolves its coordinateRequire SHA-256 and PGP verification in Gradle and Maven (SID 9539001)

We did not download or decompile the staged JAR, POM, or Java source file, and no offensive code is reproduced here. Nothing in the directory records shows whether any external build runner or target server ever requested the staged files.

How Java builds and cloud clusters become exposed to external HTTP repositories

Apache Maven 3.8.1 and newer include a built-in maven-default-http-blocker mirror rule that refuses cleartext HTTP repositories declared in pom.xml files. Even so, three common enterprise gaps reopen that door:

  1. Developer and CI overrides. Teams can override maven-default-http-blocker in settings.xml or set allowInsecureProtocol = true in Gradle, while -Dmaven.wagon.http.ssl.insecure=true relaxes HTTPS certificate checks. Once HTTP is enabled, a <repositories> block can pull JARs from an external HTTP server.
  2. Cloud analytics cluster library installation. Cloud analytics platforms often let token holders attach Maven coordinates from custom repository URLs onto compute clusters. Storing analytics_workspace_token secrets beside the staged Maven files co-locates cluster credentials with a JAR directory.
  3. SSRF and remote class-loading tests. Researchers also stage custom Java source and JAR files to test server-side request forgery (SSRF), URLClassLoader sinks, or deserialization gadgets over plain HTTP.

Closing these gaps does not require the operator's IP address. When build runners and clusters talk only to nexus.corp[.]internal or artifactory.corp[.]internal over HTTPS, external HTTP Maven servers become unreachable.

5. Forty-Two Exposed Credentials and Other Ways to Read the Evidence

In short

Passive secret checks across the exposed HTTP host recorded 42 credentials, led by 29 AWS access keys and seven analytics workspace tokens. Textbook Java test naming fits a security researcher, yet open HTTP exposure puts credentials in the served directory tree at risk. Rotate exposed IAM keys and bind workspace tokens to IP allowlists.

Autonomous agents read credentials from environment files, pass tokens on command lines, and save verbose API replies into .output logs. An open HTTP listener can expose credentials inside its served directory tree (T1552.001). The host-level credential summary records 42 findings without identifying which specific files held each credential.

Figure 5: Three anonymized sessions hold 82% of task outputs alongside 29 AWS keys
Figure 5: Three anonymized sessions hold 82% of task outputs alongside 29 AWS keys

Breakdown of the 42 credential findings on the host

Forty-two credential records were identified on the French HTTP workbench across four secret types. No secret values or partial key prefixes are published.

Secret or task-tag categoryCountShareWhere it sitsWhat defenders should do
aws_access_key2969.0% of 42Host secret summaryCheck key use in AWS CloudTrail, remove unused keys, and move to short-lived roles
analytics_workspace_token716.7% of 42Host secret summaryReplace long-lived personal tokens with short-lived OAuth tokens and IP allowlists
db_connection511.9% of 42Host secret summaryRestrict database ports to private networks and rotate passwords
aws_secret_key12.4% of 42Host secret summaryRevoke the paired AWS key immediately and review IAM Access Analyzer findings
cloud-credentials task logs94.1% of 220Sessions 3 (4), 4 (3), 1 (1), 5 (1)Scrub agent .output logs and never serve agent session folders over HTTP
exploit-code task logs31.4% of 220Sessions 4 (2) and 6 (1)Separate exploit reproduction labs from live cloud keys

AWS IAM credentials make up 30 of the 42 findings (71.4%: 29 access key IDs and one secret key). A standalone key ID reveals the AWS account via sts:GetAccessKeyInfo. The paired secret key allows direct API calls unless source-IP or MFA policies block it.

The seven analytics_workspace_token findings match the cloud-analytics workspace queue (220 .output files). Two of the nine cloud-credentials logs carry measured sizes (33,043 and 45,400 bytes; 78,443 bytes combined). Seventy untagged logs hold the remaining 7,506,992 measured bytes (10 output@ symlinks and 60 regular output files). The other 138 untagged entries are unsized stubs (99 output@ and 39 output).

Three ways to read this workbench

  1. An offensive security researcher or bug-bounty hunter. Co-hosting an open-source scope poller with agent task queues and textbook Java test names fits a bug-bounty researcher testing custom Maven URLs. We therefore withhold the host IP, port, project name, exact host paths, Maven coordinate and filenames, session UUIDs, and all file hashes.
  2. Secondary compromise of exposed research infrastructure. Even on a well-intentioned research machine, an open HTTP listener exposes served directory listings, task logs, and staged Maven files to internet-wide directory scrapers.
  3. Unattended agent sprawl inside enterprise teams. Running python3 -m http.server on a cloud VM to download an overnight summary file can expose credentials and .output transcripts inside the served directory tree.

6. What Defenders Should Do

Java build and CI/CD teams

  • Force every Maven and Gradle build through an internal HTTPS proxy (nexus.corp[.]internal or artifactory.corp[.]internal) via <mirrorOf>*</mirrorOf> in settings.xml and Gradle init.gradle. Allow upstream proxy fetches only from repo.maven.apache[.]org and plugins.gradle[.]org over HTTPS.
  • Fail CI builds declaring <repositories> blocks in pom.xml, allowInsecureProtocol = true in Gradle, or -Dmaven.wagon.http.ssl.insecure=true.
  • Enable Gradle dependency verification (SHA-256 and PGP). For Maven, use strict checksum checking (-C) and an approved HTTPS repository; verify context before blocking.

Cloud analytics and IAM teams

  • Restrict cluster library attachment in cloud analytics workspaces to approved internal repositories, blocking external HTTP Maven URLs.
  • Audit AWS IAM keys with IAM Access Analyzer, revoke stale user-managed keys, and adopt short-lived OIDC roles.
  • Replace long-lived personal analytics tokens with short-lived OAuth tokens bound to corporate IP allowlists, and isolate database ports on private networks.

Security research, red-team, and SOC teams

  • Ban unauthenticated HTTP file servers (python3 -m http.server) on developer and red-team VMs, and purge CLI agent .output logs after engagements.
  • Deploy the Suricata, Sentinel KQL, Sigma, and YARA rules in Chapter 7 across CI/CD proxies, build runners, and cloud sandboxes.

7. Detection Rules

The full rules are in the Detection rules tab. Suricata formatting passed static linting (0 problems); live Suricata, Sentinel, Sigma, and YARA engines were not run here, and rules were not replayed on live traffic. Test and tune them before production blocking.

Rule fileWhat it catches
odin_agent_queues_scope_poller_and_staged_maven.rulesSuricata 7: eight signatures for versioned Maven coordinate JAR/POM requests, top-level .java source fetches, HTTP Maven/Gradle client pulls, open Maven, agent task, and Go/Compose directory listings, .output downloads, and recon summary Markdown requests
sentinel_staged_maven_and_autonomous_recon_hunt.kqlMicrosoft Sentinel and Defender XDR: Maven, Gradle, or Java processes using HTTP repository overrides or TLS verification flags joined with artifact, task, and Go source URI network events
sigma_unapproved_maven_pull_and_agent_recon_loop.ymlSigma (3 Linux rules): HTTP repository overrides or TLS verification flags; unattended agent task queues or open HTTP directory servers; and outbound Java, Maven, or Gradle connections outside approved artifact hosts
odin_maven_and_agent_workspace_structural_hunt.yarYARA (4 rules): staged HTTP Maven POM descriptors or Java process-execution sources, insecure HTTP Maven/Gradle repository configs, exposed agent task directory listings, and open HTTP directory listings with Go source and Compose manifests

How the Suricata signatures work

SIDLooks forWhy
9539001Request URI matching a versioned Maven 2 coordinate directory path for a .jar or .pomHunt signal: surfaces build tools, clusters, or SSRF sinks pulling unapproved Maven coordinates over HTTP
9539002HTTP GET for a top-level /*.java source fileHunt signal: surfaces retrieval of staged Java source files over HTTP
9539003Outbound request for .jar or .pom with Apache-Maven, Gradle, or Java/ User-AgentHunt rule: surfaces build clients pulling packages over cleartext HTTP
9539004HTTP 200 body containing Directory listing for / and .java, .jar, or .pom entriesFlags an open HTTP directory listing staged Maven or Java artifacts
9539005HTTP 200 body containing Directory listing for / and tasks/ or .output filenamesFlags an exposed autonomous agent task directory
9539006HTTP GET under /tasks/ matching a<16hex>.output or b<8alnum>.outputCatches downloads of subagent or shell task transcripts
9539007HTTP GET for recon or session summary .md files (*_FINDINGS.md, recon_summary.md, or session_summary.md)Catches access to exposed reconnaissance summary reports
9539008HTTP 200 body containing Directory listing for / and .go or .yml entriesHunt rule: flags open HTTP directories listing Go scope-poller or Compose files

Use SIDs 9539001 and 9539002 as hunt signals. Enforce the approved-repository policy at egress, and verify context before blocking a coordinate or filename. Keep SIDs 9539003 and 9539008 as hunt rules to surface legacy HTTP Maven clients and open Go scope-poller directories.

How the KQL, Sigma, and YARA rules work

The Sentinel KQL query looks back 7 days across Linux build runners, analytics nodes, and workstations. It checks DeviceProcessEvents for mvn, gradle, or java using HTTP repository overrides, allowInsecureProtocol, or maven.wagon.http.ssl.insecure=true. It also checks command lines for /tasks/a, /tasks/b, .output, or http.server.

Those process events are inner-joined by process ID within five minutes to DeviceNetworkEvents matching artifact, task, or Go source URI patterns. Exact runner and repository hostnames sit in explicit allowlists (ApprovedCicdRunners, ApprovedAsmRunners, and ApprovedArtifactHosts) without wildcards.

The three Linux Sigma rules cover auditd and eBPF logs. Rule 1 flags Maven, Gradle, or Java command lines using HTTP repository overrides, maven-default-http-blocker, allowInsecureProtocol, or maven.wagon.http.ssl.insecure=true. It excludes exact runner hostnames and /opt/nexus-sync/bin/mirror-verify.

Rule 2 flags /tasks/a, /tasks/b, .output, or http.server outside /opt/asm-poller/bin/approved-scope-sync. Rule 3 flags outbound connections from /usr/bin/java, /usr/bin/mvn, /usr/local/bin/mvn, /usr/bin/gradle, or /usr/local/bin/gradle outside exact DestinationHostname allowlists.

YARA ruleFires when
ODIN_HTTP_Maven_POM_or_Java_Process_Execution_SourceFile under 256 KB has a <project> POM declaring <groupId>, <artifactId>, and <url>http://, or pairs a Java class header with Runtime.getRuntime().exec or ProcessBuilder
ODIN_Insecure_Maven_or_Gradle_HTTP_Repo_ConfigFile under 512 KB contains http:// plus a <repositories> or maven { block alongside allowInsecureProtocol, maven-default-http-blocker, or wagon.http.ssl.insecure
ODIN_Exposed_Agent_Overnight_WorkspaceFile under 512 KB contains Directory listing for / plus tasks/ and .output@ or .output
ODIN_Exposed_Go_Scope_Poller_or_Compose_ListingFile under 512 KB contains Directory listing for / plus .go source and .yml or .yaml Compose entries

MITRE ATT&CK mapping

TacticTechniqueHow it appears on the workbenchDetection coverage
Initial AccessT1195.001 Compromise Software Dependencies and Development ToolsStaged Maven directory listing a Java source file, JAR, and POM over HTTP (coordinate and filenames withheld)SIDs 9539001 to 9539004; KQL; Sigma rules 1 and 3; YARA rules 1 and 2
ReconnaissanceT1595.002 Active Scanning: Vulnerability ScanningUnattended agent recon task queues and Go scope-polling filesSIDs 9539005, 9539007, 9539008; KQL; Sigma rule 2; YARA rules 3 and 4
Credential AccessT1552.001 Unsecured Credentials: Credentials In Files42 cloud, analytics, and DB secrets alongside exposed .output transcriptsSID 9539006; KQL; Sigma rule 2

8. Indicators

The Indicators tab holds 0 published indicators: 0 network addresses and 0 file hashes. Both are withheld because the single French HTTP host may belong to a security researcher and its task logs hold sensitive tokens. Twelve generic Maven layout, task-glob, CLI, and build-configuration patterns appear in the tables below. Exact Maven coordinates, filenames, project name, port, and 15 host paths from the 27 v1.0 items are withheld.

Indicator categoryPublished in tabPublished patterns belowWithheld host pathsWhere to use it
Network addresses (IPv4)001 (host IP)Not published under dual-use rules
File hashes (SHA-256)00123 (97 unhashed)Withheld (123 sensitive/unestablished, 97 unhashed)
Staged Maven layout and artifact patterns061 (repo root path; coordinate and filenames withheld)Nexus/Artifactory firewalls, egress proxies, and build caches
Agent queue globs and root exposure types039 (workspace/root paths)Perimeter HTTP hunting and internal sandbox audits
Scope-poller CLI pattern and Go exposure types015 (Go/Compose paths)Endpoint process monitoring and perimeter audits
Insecure Maven/Gradle config and CLI flags020CI/CD SAST linters and build-runner logs

Staged Maven layout and artifact patterns (6 generic patterns, 1 withheld root path; coordinate and filenames withheld)

PatternTypeRecommended action
<groupId>:<artifactId>:<version> (coordinate withheld)Maven coordinate patternEnforce approved-repository policy; verify context before blocking
<groupId>.<artifactId> (namespace withheld)Java package namespace patternReview unapproved external namespaces in repository firewalls
/<groupId-path>/<artifactId>/<version>/<artifactId>-<version>.jar (URI withheld)Maven JAR URI path patternUse as a hunt signal at egress proxies (SID 9539001)
/<groupId-path>/<artifactId>/<version>/<artifactId>-<version>.pom (URI withheld)Maven POM URI path patternUse as a hunt signal at egress proxies (SID 9539001)
/<ClassName>.java (filename withheld)Staged Java source URI patternUse as a hunt signal at egress proxies (SID 9539002) and scan with YARA
<artifactId>-<version>.jar (filename withheld)Cached JAR filename patternHunt unverified HTTP JARs inside ~/.m2/repository/ and ~/.gradle/caches/
Staged Maven repository root (path withheld)Exposure typeBlock external HTTP Maven repositories at egress proxies

Agent queue globs, scope-poller CLI, build flags, and withheld host exposures (6 published patterns, 14 withheld paths)

PatternTypeRecommended action
tasks/a[0-9a-f]{16}.outputSubagent symlink globAudit CLI agent session logs for cleartext secrets
tasks/b[a-z0-9]{8}.outputShell task log globAudit CLI agent session logs for cleartext secrets
Directory listing for /HTTP response stringAlert on open http.server directory listings
<scope-poller> poll (project name withheld)Scope-poller CLI patternWatchlist outside approved attack-surface hosts
allowInsecureProtocol = trueGradle DSL flagFail in CI build.gradle checks
-Dmaven.wagon.http.ssl.insecure=trueMaven CLI flagAlert on relaxed HTTPS certificate checks in build-runner logs
Agent recon workspace trees (2 paths withheld)Exposure typeAudit internal cloud VMs and open HTTP servers
Agent session task path globs (2 paths withheld)Exposure typeAudit internal agent sandboxes
Overnight summary file (path withheld)Exposure typeAudit unauthenticated agent directories
API response file (path withheld)Exposure typeAudit unauthenticated agent directories
Setup log file (path withheld)Exposure typeAudit unauthenticated agent directories
Open directory listing banners (2 paths withheld)Exposure typeAlert on open agent and Maven directories
Go scope-poller and Compose files (5 paths withheld)Exposure typeAudit unapproved scope-polling hosts

Withheld from this public edition are the French server's IPv4 address, port, project name, 15 exact host paths, staged Maven coordinate and filenames, and nine session UUIDs. All 42 raw credential values, all third-party target names, and all file hashes on the host are also withheld.

9. Scope and Limits

  • Dataset timestamps. Analysis covers directory listing records dated 3 to 16 August 2026 and prepared in November 2026. Those dates are directory listing timestamps recorded on the server, not task execution times.
  • Staged files, not downstream execution. We inspected directory listings and metadata only. We ran no binaries or Java classes and replayed no credentials. Nothing in the listings confirms that any external CI pipeline or analytics cluster fetched the staged JAR.
  • Dual-use researcher ownership is plausible. Open-source scope-polling files and textbook Java test filenames fit an offensive security researcher or bug-bounty hunter whose HTTP server was left open. The host IP, port, project name, exact host paths, Maven coordinate and filenames, session UUIDs, and task hashes are withheld.
  • Workbench model. Grouping the host into four layers is an analytical model of co-hosted files on one server, not attribution to a threat group.
  • Rule validation. Published Suricata signatures passed static syntax linting (0 problems), and KQL, Sigma, and YARA rules were checked structurally against test fixtures. Live engines were not run, and the rules were not tested on production traffic.

10. Sources

  1. Apache Maven Project. Introduction to Repositories. https://maven.apache.org/guides/introduction/introduction-to-repositories.html (verified 21 November 2026)
  2. Apache Maven Project. Settings Reference (Mirrors and HTTP Blockers). https://maven.apache.org/settings.html (verified 21 November 2026)
  3. Gradle Inc. Verifying Dependencies (SHA-256 and PGP Signatures). https://docs.gradle.org/current/userguide/dependency_verification.html (verified 21 November 2026)
  4. Amazon Web Services. IAM Best Practices: Manage Access Keys. https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html (verified 21 November 2026)
  5. OWASP Cheat Sheet Series. CI/CD Security Cheat Sheet. https://cheatsheetseries.owasp.org/cheatsheets/CI_CD_Security_Cheat_Sheet.html (verified 21 November 2026)
  6. MITRE ATT&CK. T1195.001 Supply Chain Compromise: Compromise Software Dependencies and Development Tools. https://attack.mitre.org/techniques/T1195/001/ (verified 21 November 2026)
  7. MITRE ATT&CK. T1595.002 Active Scanning: Vulnerability Scanning. https://attack.mitre.org/techniques/T1595/002/ (verified 21 November 2026)
  8. MITRE ATT&CK. T1552.001 Unsecured Credentials: Credentials In Files. https://attack.mitre.org/techniques/T1552/001/ (verified 21 November 2026)

Frequently asked questions

What was sitting on the exposed HTTP server?

Twenty-five directory index records on the server reported 843 files. Deduplicating those listings left 599 unique sampled paths (71.1%) and 244 un-sampled entries (28.9%). Directory listings on the server carry file dates of 3 to 16 August 2026. We inspected directory metadata and path structures only, ran no code, and contacted no target systems.

How do the unattended agent queues and scope poller work?

Modern CLI coding agents let an operator hand off reconnaissance loops that run all night; defenders can investigate these with a cyber threat intelligence platform. While the Go poller tracks public bounty programs for new domains or APIs, the agent queues store delegated subagent and shell outputs beside an overnight summary file.

Why does a staged Maven repository on an open HTTP server matter?

Next to the Go project tree, the staged Maven directory follows the standard layout that Maven and Gradle expect when resolving a versioned coordinate. Nothing we observed confirms that any external CI runner or cluster ever downloaded the staged JAR. Even so, the setup highlights three software supply chain security risks.

Why are 42 leaked credentials a warning for security teams too?

AWS IAM credentials make up 30 of the 42 secret findings on the host (71.4%). That total includes 29 access key IDs (69.0%) and one secret key (2.4%). Seven analytics workspace tokens (16.7%) and five database connection strings (11.9%) account for the rest.

Defender kit

Indicators of compromise

Verified adversary infrastructure and tool hashes from this study. Every value below is also discussed in the report.

No network or file indicators are published for this study

The hosts in this report are exposed or unattributed systems rather than confirmed adversary infrastructure, so they stay anonymous. Use the detection rules below to find the same exposure in your own estate.

28 records from this study are not published in this table: candidate, suspected and dual-use hosts, victim-related values, and hashes of exposed secrets or files.

Defender kit

Detection rules

The rule files exactly as printed in the report. Test them in your own engine before deployment.

Suricata odin_agent_queues_scope_poller_and_staged_maven.rules 22 lines
Download
YARA odin_maven_and_agent_workspace_structural_hunt.yar 80 lines
Download
Sentinel KQL sentinel_staged_maven_and_autonomous_recon_hunt.kql 39 lines
Download
Sigma sigma_unapproved_maven_pull_and_agent_recon_loop.yml 100 lines
Download