Delphos Lantern scores #1 on BinaryAudit backdoor detection: by mean, peak, floor, and reproducibilityLearn more
Delphos LabsDelphos Labs
Use CasesReportsBlogAbout UsSign InRequest Access
Use CasesReportsBlogAbout UsSign InRequest Access
  1. Threat Analysis
  2. Unattributed

ClearFake Go proxy analysis: controller-directed access to internal services

C2 / beaconing

A Windows proxy impersonates Chrome, suppresses its own tunnel logs, and can relay traffic to internal services; no live controller session was observed.

PE · Nov 19, 2026

Verdict:Malicious
Confidence:High

Executive Summary

Cisco Talos’s ClearFake research identified this proxy, its controller, and its place in the infection chain. This report builds on that work with a deep analysis of code we recovered from the binary, covering the proxy’s protocol, routing, and transport settings.
The submitted Go proxy bot is configured to connect to a fixed remote controller, identify its host, and let the controller route network traffic through that host. Browser impersonation, suppressed operational logging, and unattended GUI-subsystem execution support covert deployment rather than an owner-facing proxy application. The executable’s SHA-256 matches the unpacked proxy identified in the supplied Talos article.
The most significant differential findings are:
  • CLARIFIES: Stream requests contain net and addr: a network selector and a destination address. The compiled code shows the first field selects the network type rather than a source address.
  • EXTENDS: The controller’s network selector reaches the general Go dialer. TCP is the default, not an application-enforced restriction. The handler contains no destination allowlist.
  • EXTENDS: Registration uses length-prefixed JSON, includes OS and version fields, and parses additional acknowledgement fields that this executable does not use.
  • NEW: The bot impersonates Chrome, discards Yamux logs, retries indefinitely with exponential backoff and jitter, and contains precise transport limits and timing settings absent from the article.
  • EXTENDS: TLS certificate and hostname verification are enabled in the submitted build. A compiled verification-bypass branch exists but is disabled.
Containment should account for access to internal and loopback services through the proxy, not merely outbound contact with the controller. The Go proxy bot does not independently establish the credential theft, clipboard manipulation, driver abuse, or NetSupport installation attributed to other components of the article’s infection chains.

Verdict Rationale

The Go proxy bot’s reachable application path implements host registration followed by controller-directed network relaying. Its fixed endpoint is the controller named for this exact hash in the Talos report. Its HTTP identity claims to be Chrome rather than Go, while Yamux operational output is redirected to a discard writer. These features combine remote network control with concealment of the program’s nature and activity.
A legitimate reverse-tunnel codebase is a credible explanation for the underlying implementation: the package names honestly describe a proxy panel, the networking libraries are ordinary, and TLS verification is implemented correctly by default. That alternative does not adequately explain the shipped combination of browser impersonation, discarded logs, fixed campaign-associated controller, and absence of an owner-facing configuration path in the reviewed application code.
The malicious verdict concerns the configured proxy bot, not an assumption that every article-described payload is present. Static evidence directly establishes its capabilities. Emulation did not reach a successful controller session, so registration, routing, and protocol findings below are code-backed capabilities, not observed live tasking.

Artifacts Analyzed

Name
SHA-256 (First 12)
Type
Role
Parent
Go proxy bot
1819827e17f3
PE32 x86 Windows GUI executable; Go
Submitted unpacked reverse-proxy executable, identified by its hash-named upload
None submitted; upstream shellcode is described only in the article
Cisco Talos ClearFake report (reference)
503886ac7222
UTF-8 text
Reference: Talos, ClearFake WebDAV infection chain delivers Amatera stealer, ZigCryptoStealer, and NetSupport Manager, dated 2026-09-08
None; reference material, not executable content
Full Go proxy bot SHA-256: 1819827e17f31e72d456158b6b9c90af25a65945f6f05d04a060da9f24179b25.
No additional behavior-bearing executable was recovered from the Go proxy bot. Analysis notes and execution telemetry are evidence products, not additional payload stages.

Scope and Coverage

The complete Talos report was read before sample analysis. Differential labels refer to the supplied article text, including its defanged indicators; details available only through external links or absent figures were not assumed to be part of that text.
The Go proxy bot was examined through PE structure and signature inspection, Go build and type metadata, original-byte disassembly, focused decompilation, initialization and API-reference analysis, hidden-string recovery attempts, and isolated Windows emulation. All 31 custom application functions in main and internal/tunnel were covered, together with relevant networking, TLS, file, registry, runtime, and dependency initialization paths.
Automatic function analysis reported 97% code-section coverage, leaving 56,550 bytes in 1,127 unattributed regions, with 6 unresolved indirect branches. Independent parsing of the original Go function table identified 5,748 function intervals and decoded those intervals without an undecoded interval. This improved the instruction/reference inventory but is not equivalent to complete semantic analysis of every library function or resolution of every indirect call.
Hidden-string examination included data-layout inspection and a filtered XOR-loop search. The custom candidates were WebSocket frame masking routines: readFrame at 0x6a7270, with one inbound direct call site, and writeFrameLocked at 0x6a7ac0, with two. Their operands are network/caller buffers and frame masks, not static encrypted configuration. A Go-specific candidate-emulation pass reported 0 decryptors and 0 recovered strings. No additional decoded configuration population was produced.
Baseline Windows x86 emulation entered at 0x47bfd0 and exited through ExitProcess(2) before application startup. Captured diagnostics identified NtCreateWaitCompletionPacket failure in the Go runtime. Treating that optional API as unavailable selected a legacy path but exhausted the API budget in scheduler waits. A separate thread-scheduling workaround ended with stoplockedm: not runnable. These are execution-environment limits, not evidence that the networking code is inactive on Windows. No successful C2 exchange, server certificate, or operator-selected destination was observed.

Artifact Relationships and Behavioral Sequence

The Talos report identifies the Go proxy bot’s exact hash as the executable unpacked from a separate shellcode blob. That parent-child relationship is article evidence; the parent shellcode was not submitted and its decoding sequence cannot be independently reconstructed from the Go proxy bot alone.
The Go proxy bot’s own code establishes this sequence:
  1. Go runtime and linked package initialization execute. The custom tunnel initializer reads a logging-related environment variable.
  1. main.machineGUID reads the machine identifier; main.main obtains the hostname and constructs the registration object.
  1. main.connectAndServe opens a direct TLS connection and performs a custom HTTP WebSocket upgrade to the compiled controller.
  1. A length-prefixed JSON greeting is sent over the WebSocket byte-stream adapter. A framed JSON acknowledgement must report success.
  1. A Yamux server session is constructed over that connection.
  1. Each accepted Yamux stream starts with a framed JSON network/destination request. The bot dials the destination and starts two opposing byte-copy operations.
  1. When the connection attempt or session returns, the main loop sleeps with backoff and jitter, then retries. There is no terminal retry count.

Methods

Method
Purpose
Artifacts
Full-text reference comparison
Separate existing article claims from additions and corrections; account for defanging and quotation artifacts
Talos report, Go proxy bot
Hashing, PE layout, and signature inspection
Verify identity, executable format, resources, embedded containers, overlay, and signing status
Go proxy bot
Go metadata and type reconstruction
Recover compiler/dependencies, application boundaries, JSON tags, and structure layouts
Go proxy bot
Original-byte disassembly and focused decompilation
Establish registration, routing, timing, transport checks, and reachable side effects
Go proxy bot
Initialization and API-reference audit
Distinguish application behavior from runtime operations and unused lazy API declarations
Go proxy bot
Encoded-data inspection and candidate emulation
Test for hidden strings/configuration and explain XOR-loop candidates
Go proxy bot
Isolated Windows emulation with diagnostic hooks
Attempt runtime observation and identify startup blockers
Go proxy bot

Key Findings

A. CLARIFIES: Stream requests carry a network selector and a destination

Article passage: “Each logical stream supplies a source and destination address.” (Talos report, Go proxy section)
The Go proxy bot’s tunnel.StreamReq type at 0x6e5940 contains only two strings:
JSON Field
Meaning Established by Use
net
Network argument supplied to the Go dialer
addr
Destination address supplied to the Go dialer
main.handleStream reads this object at 0x6aa82d, substitutes tcp only when net is empty, and passes both strings to net.DialTimeout at 0x6aa87b. There is no source-address field or source-binding operation in this handler. The operating system selects the local endpoint through ordinary dialing behavior.
This changes the interpretation of captured tasking: net is not a source address, and the controller does not select a source address through this request structure.

B. EXTENDS: Host registration has precise registry, framing, and acknowledgement semantics

Article passage: “The proxy reads the Windows MachineGuid and hostname, then sends them over WebSocket Secure (wss) protocol.” (Talos report)
The Go proxy bot adds the following details:
  • main.machineGUID, 0x6a9c60, opens HKLM, key SOFTWARE\Microsoft\Cryptography, and reads MachineGuid. Access 0x101 combines query access with the 64-bit registry view, despite the executable being x86. The open and value-read calls are at 0x6a9cc6 and 0x6a9d0b.
  • Failure of the registry helper leads to os.Exit(1) at 0x6a9e2a. This is an operational prerequisite, not an identified VM or sandbox test.
  • The hostname helper’s error is not checked by main.main before constructing the greeting.
  • tunnel.HelloMsg, type metadata 0x6f05c0, serializes machine_guid, hostname, os, and version. The compiled OS value is windows 386; the version field remains an empty string. The registration fields are populated at 0x6a9e51–0x6a9e73.
The application framing is not described in the article. WriteFrame, 0x6a68e0, JSON-marshals the object and prefixes it with a two-byte big-endian JSON length. The length prefix is stored at 0x6a696a; the JSON bytes are copied into the outgoing buffer at 0x6a6984, before the write at 0x6a69ab. JSON length is limited to 32,768 bytes. ReadFrame, 0x6a6a50, reads the exact declared length, rejects zero or excessive lengths, and JSON-unmarshals it.
The acknowledgement type, 0x6f5260, recognizes ok, error, bot_id, proxy_user, and proxy_pass. The caller consumes only ok and error: a false result returns the supplied error or server rejected hello. The remaining fields are parsed but do not configure this bot’s subsequent routing or authentication. Their names are not evidence of local password theft.
Inside TLS, these objects are ordinary JSON with length framing; WebSocket XOR masking is not an additional application-encryption scheme.

C. EXTENDS: Routing is not restricted to TCP, and target access is unrestricted by the handler

Article passage: “The client connects to the requested destination and relays bytes in both directions.” (Talos report); the section is titled “Go payload turns the host into a reverse TCP proxy.”
The Go proxy bot passes the controller’s nonempty net value through without an application-level TCP restriction. The reachable Go dispatch includes TCP, UDP, raw-IP, and Unix-socket dial branches, visible in net.(*sysDialer).dialSingle at 0x4f97d8, 0x4f9846, 0x4f98b0, and 0x4f993e. Actual success depends on the selector, Windows support, destination, and privileges.
The handler has no destination allowlist, private-address exclusion, loopback exclusion, or per-stream credential check between parsing the request and dialing it. Consequently, the bot can provide controller-directed access to services reachable from the infected host, including internal or loopback services. That is a network-pivot capability, not evidence of autonomous exploitation or propagation.
The relay implementation is also more specific than the article:
  • After the framed request, the remainder of the Yamux stream is relayed as bytes.
  • Copy closures at 0x6aaa40 and 0x6aaaf0 run in opposing directions through io.copyBuffer.
  • The first copy completion causes both endpoints to be closed at 0x6aa9c3 and 0x6aa9cc, after which the handler waits for the other copy. It does not preserve a TCP half-close for continued one-way delivery.
  • Parse and dial errors close the stream; the handler sends no application-level success/error response before relaying.
There is no separate UDP datagram envelope in this generic byte-copy handler. The reachable UDP dial branch therefore does not establish transparent preservation of arbitrary UDP packet boundaries.

D. NEW: The bot impersonates Chrome and suppresses its own tunnel logs

The Go proxy bot sends this compiled User-Agent, stored at VA 0x72b032, file offset 0x32a232:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36
The value is inserted into the HTTP upgrade headers by main.connectAndServe. It presents a Chrome browser identity even though the executable is a Go x86 application. The claimed x64 browser platform does not change the actual executable architecture.
Yamux logging is explicitly redirected to io.discard: the writer interface at 0x971148 is copied into the session configuration at 0x6aa4b5. The GUI subsystem avoids automatic creation of a console window. These are network-identity and application-observability measures, not proof of process hiding or Windows security-log tampering.
The tunnel initializer at 0x6a6890 reads PANEL_TUNNEL_LOG, tests whether it equals 1, and stores a Boolean at 0x99ed20. The original-code reference inventory found that write but no consumer of the Boolean. The variable is a useful code-lineage/configuration lead; functioning debug logging cannot be inferred from its name.

E. EXTENDS: WSS uses a custom adapter with verification enabled and distinctive limits

Article passages: “It includes HashiCorp Yamux network multiplexing library” and “then sends them over WebSocket Secure (wss) protocol.” (Talos report)
The Go proxy bot implements its own WebSocket adapter in internal/tunnel, rather than merely invoking a linked third-party WebSocket client.
Connection and TLS: DialWS, 0x6a7e40, uses a locally initialized Go dialer for a direct TCP connection. The compiled application path does not use HTTP proxy discovery or CONNECT tunneling. The controller, User-Agent, and TLS-switch globals have reads but no application configuration-write path in the original instruction inventory.
The TLS-switch string at 0x9710b8 is 0. Only the exact string 1 selects the branch that sets InsecureSkipVerify at 0x6aa055. In this submitted build:
  • Certificate-chain and hostname verification are enabled, using the system trust path when custom roots are absent.
  • TLS ServerName/SNI and HTTP Host derive from the endpoint hostname, update.dubbedmuch.cc. There is no separate decoy hostname on this path.
  • The compiled caller supplies no custom roots, certificate pin, or client certificate.
  • Default client versions are TLS 1.2–1.3; an actual negotiated version or cipher was not observed.
  • Failure returns an error; generic ws support in DialWS is not an automatic plaintext fallback.
Opening handshake: The request is HTTP/1.1 GET /, with WebSocket version 13 and a Base64 key generated from 16 random bytes. The response must parse, have status 101, contain the required Upgrade/Connection values, and return the exact expected Sec-WebSocket-Accept. These checks occur at 0x6a90e6, 0x6a912e, 0x6a9185, and 0x6a9208. wsAccept, 0x6a9840, implements the standard SHA-1/Base64 WebSocket construction; that construction is not application authentication.
Frame behavior:
Property
Go Proxy Bot Behavior
Data channel
Binary frames adapted into a byte stream
Maximum incoming/outgoing data frame
1,048,576 bytes (0x100000)
Client masking
Fresh four-byte cryptographic mask per frame
Server masking
Masked server frames rejected
Fragmentation
FIN=0 rejected; fragmented messages unsupported
Text frames
Rejected
Reserved bits
Rejected; compression is not enabled
Ping/pong
Ping payload echoed in pong; pong ignored
Close
Empty close response and EOF; close status/reason not interpreted
The frame parser is at 0x6a7270. The output routine at 0x6a7ac0 loads caller bytes at 0x6a7dff, stores their masked form at 0x6a7de8, and writes that buffer at 0x6a7dd1. Its bounded XOR loop is WebSocket framing, not a payload/configuration decryptor.
No subprotocol or extension is offered. Unsolicited selections in the response are not rejected, but no extension implementation is activated and later reserved bits still fail. Nonminimal extended data-length encodings and unvalidated close reasons are additional interoperability/validation limitations.

F. NEW: Retry timing and Yamux configuration are recoverable exactly

The Go proxy bot’s main retry loop at 0x6a9df0 has no final retry limit. The backoff base begins at 1 second, doubles after each iteration, and caps at 30 seconds. The sleep is the current base plus math/rand.Int63n(base), called at 0x6a9f14, followed by time.Sleep at 0x6a9f4b. Thus, at the cap, the sleep is at least 30 but less than 60 seconds, excluding time spent connecting or serving traffic.
The backoff resets when registration has been accepted and the elapsed attempt time is at least 10 seconds. The timer starts before the connection attempt, at 0x6a9e8e; this is not strictly a measurement of an established session’s duration.
Setting
Compiled Value and Evidence
Outer connection context
20 seconds, 0x6a9fff
TCP/TLS/WebSocket setup
15-second child timeout in DialWS
Greeting/acknowledgement phase
Fresh 15-second socket deadline at 0x6aa2ac, cleared after acceptance at 0x6aa428
Destination dial
15 seconds, 0x6aa87b
Yamux accept backlog
256
Yamux keepalive
Enabled; interval 30 seconds
Yamux connection write timeout
30 seconds, explicitly overriding the initially populated value
Yamux maximum stream window
262,144 bytes / 256 KiB
Yamux stream-open timeout
75 seconds
Yamux stream-close timeout
300 seconds
The Yamux configuration is populated at 0x6aa43d–0x6aa4f5 and passed to the server constructor at 0x6aa537. The frame/window limits are not an aggregate transfer quota or an application-level cap on all accepted stream handlers.

G. NEW: Build identity and linked-library residue refine detection and prevent capability misattribution

The Go proxy bot is 5,889,536 bytes, unsigned, with exact compiler string go1.25.0 in build information at file offset 0x50dc21. The module metadata records Yamux v0.1.2, -trimpath=true, CGO_ENABLED=0, GOARCH=386, GOOS=windows, and GO386=sse2.
The PE timestamp is zero. There is no resource directory, export directory, PE TLS-callback directory, Authenticode certificate table, or overlay. A header-validated embedded-PE search found only the executable at offset zero; the ZIP local-header search found none. These structural checks are supplemented by the application loading-path review, rather than treated as proof against every possible encoding.
PostgreSQL/password-file and MaxMind dependencies in the build metadata do not establish additional collection behavior. Their retained code is initialization residue: examples include pgpassfile.init at 0x69d5b0, pgx/v5.init at 0x69ffc0, and MaxMind initialization at 0x6a6670. Those paths construct regular expressions, errors, maps, and other in-memory state, not an application password-file or geolocation operation.
Likewise, dangerous Windows API names are often unused lazy declarations. For example, CryptUnprotectData, WriteProcessMemory, CreateProcessW, and RegSetValueExW descriptors have initialization writes but no non-initializer references in the original instruction/reference inventory. The static thread-context and allocation imports have identifiable Go runtime users. They must not be attributed to the article’s separate shellcode or NativeAOT loader.

Indicators Added or Refined

Label
Indicator or Observable
Source, Role, and Significance
NEW
SHA-1 d0e04c703db5c90d2908535f3d4650cfd19c58d5
Computed over the original Go proxy bot; alternate exact-file lookup hash
NEW
MD5 59ab0d09116da8fc762d31745c10712c
Computed over the original Go proxy bot; legacy exact-file lookup hash
EXTENDS
wss://update.dubbedmuch.cc/
Already in the article; original literal at file 0x31bad6, used by main.connectAndServe. Added detail: direct TLS connection, root request path, matching SNI/Host, and default verification
NEW
Chrome/150 User-Agent quoted above
Original literal at file 0x32a232; network fingerprint of this build, not a real browser identity
NEW
PANEL_TUNNEL_LOG
Literal at file 0x315e16; retained initializer setting with no identified flag consumer
EXTENDS
HKLM key SOFTWARE\Microsoft\Cryptography, value MachineGuid
Read-only host identity source, explicitly using the 64-bit registry view. A common Windows location, not a malicious indicator by itself
EXTENDS
github.com/acr/proxy-panel/cmd/bot
Already in the article; build identity/provenance marker, not a GitHub C2 destination or actor attribution
NEW
machine_guid, hostname, os, version; acknowledgement fields ok, error, bot_id, proxy_user, proxy_pass; stream fields net, addr
Sample-backed protocol schema useful for decrypted traffic and memory inspection; generic fields are not reliable standalone signatures
No additional controller domain or IP was established from the reviewed application configuration. No application-specific dropped-file path or named mutex was identified in that code. No signer certificate exists for the submitted PE; the controller’s TLS certificate remains unobserved.

Security Weaknesses

A. NEW: Handshake resource limits and close behavior have conditional availability risks
The Go proxy bot’s 4,096-byte buffered reader is not a handshake-size cap. The HTTP response parser receives effectively unbounded status-line/header budgets at 0x65bb57 and 0x65be0b. A peer that has passed the TLS checks can send substantial response text within the connection deadline, creating memory pressure before rejection. The response body is closed before status validation at 0x6a90dd; rejection bodies can also be drained without a small application-specific byte budget.
wsConn.Close marks the adapter closed, attempts to acquire the write mutex without waiting, and, if successful, performs a synchronous close-frame write before closing the raw socket. Calls at 0x6a70d8, 0x6a710a, and 0x6a712b establish that sequence. No close-specific deadline is installed. An acquired idle mutex therefore does not guarantee prompt completion if the peer stops receiving and no existing deadline bounds the write. Synchronous pong handling has a related dependency on write progress.
These are code-backed conditional risks, not demonstrated memory exhaustion, an observed hang, or a certificate-validation bypass. The operational response to this malicious deployment is removal and containment. Reuse of the transport code would require explicit HTTP byte/header limits and bounded close/control-frame writes.

Checked and Not Found

The following NEW, sample-scoped negative findings supplement the article. They concern the reviewed Go proxy bot application, initialization paths, original instruction references, and recovered configuration; not all possible behavior of other infection stages. Emulation silence was not used to establish them.
Capability
Search and Result
Self-installation, autostart, or named application mutex
Custom entrypoint/initializer review found no installer, scheduled-task, service-installation, startup-file, or named-mutex path. Registry write/service/mutex API declarations had no non-initializer use; the application registry helper is query-only. Persistent operation through retries is not reboot persistence.
Privilege escalation, process injection, or further-code execution
No such operation or command/payload handler was identified in the custom application sequence. Process/token/memory-writing lazy API leads were traced; no os/exec functions were retained. Thread context, thread creation, exception handling, and allocation imports were attributed to Go runtime paths, including runtime.preemptM at 0x43e8c3–0x43ea3d.
Direct credential theft or keystroke, clipboard, screen, audio, or video capture
The application’s host-data collection is the registry identifier and hostname. Custom-code, recovered-function, data-layout, string-recovery, and lazy-API-reference checks did not identify capture or credential-store access. The DPAPI declaration is unused; password-file dependency initialization does not read a password file. This does not limit data obtainable by interacting with reachable services through the proxy.
Autonomous spread or exploitation
The stream handler performs dialing and byte relay, not host scanning, exploit selection, self-copying, or remote installation. Network pivoting is present; an autonomous propagation mechanism was not identified in the reviewed paths.
Security-tool termination or custom anti-analysis gates
Custom application paths contain no identified debugger/VM gate, EDR termination loop, AMSI patch, or ETW tampering. Relevant API strings were checked against use sites. Runtime error-dialog/WER settings and exception handling are not independent evidence of those behaviors. Browser disguise and discarded application logs are present and are reported above.
Filesystem destruction or ransomware
No application file-traversal, destructive file-write, deletion, or file-encryption sink was identified. Relay bytes originate in peer/caller buffers; the copy loops end on stream completion/error, while frame allocations and masking loops are bounded by input lengths. No content-free disk-filling path was identified. TLS encryption is present and is not a filesystem-encryption finding.
A second packed payload or hidden application configuration
PE/resource/overlay and embedded-container checks, complete custom-code review, encoded-data inspection, and candidate emulation produced no additional payload or decoded configuration. The identified custom XOR loops implement WebSocket masks. This conclusion does not describe the absent parent shellcode, which the article says unpacked this executable.

Alternative Explanations and Contrary Evidence

A dual-use reverse proxy is the strongest materially different explanation. Supporting evidence includes honest proxy-related package names, ordinary networking libraries, proper default TLS verification, and the lack of an identified local stealer or persistence mechanism in the Go proxy bot.
Those facts constrain the capability assessment but do not establish authorized operation. The submitted configuration impersonates a browser, discards tunnel logs, runs without an automatic console, identifies the host to a fixed controller, and accepts controller-selected destinations without an application target policy. The exact executable hash and controller also match the article’s secondary-payload description. Together these support hostile configured deployment rather than a benign verdict based on the ordinary origin of the underlying libraries.
The Go proxy bot remains discoverable as a process with network connections; no rootkit-style invisibility is claimed. Its package path and the acr identifier do not establish an author, operator, nationality, or relationship to the article’s other payload authors.

Unknowns

  • Live controller state: Actual availability, DNS answers, certificate chain, negotiated TLS parameters, acknowledgement values, and selected destinations remain unverified. Emulation was attempted through the original entrypoint and targeted runtime workarounds, but runtime/scheduler failures prevented a completed application session. Missing evidence is a completed Windows execution trace or captured controller exchange.
  • Controller-side policy: The Go proxy bot parses but ignores the returned bot ID and proxy credentials. No server implementation or server trace was supplied, so their backend use and any server-side authorization policy cannot be determined from this client.
  • Environment-dependent transport success: TCP is the default and other dial branches are reachable, but actual UDP/raw-IP/Unix-socket tasking was not exercised. Static reachability does not establish platform permissions, packet-boundary fidelity, or successful use of those transports.
  • Upstream execution context: The article links this hash to shellcode and Amatera tasking, but those artifacts were not submitted. The Go proxy bot cannot establish its parent process, disk-versus-memory deployment, inherited privileges, or the other stages present on an affected host.
These limits restrict execution-history and chain-wide conclusions; they do not undermine the code-established proxy capability or the configured-deployment verdict.

Article Claims Confirmed and Not Verified

A. Confirmed by the submitted executable
  • The unpacked-file SHA-256 in the Talos report matches the Go proxy bot.
  • The Go proxy bot is a 32-bit Windows Go executable with main package github.com/acr/proxy-panel/cmd/bot.
  • The controller is hardcoded as wss://update.dubbedmuch.cc/, and HashiCorp Yamux is retained and used.
  • The reachable code reads MachineGuid and hostname, registers over WSS, constructs a Yamux server session after acceptance, dials requested destinations, and relays bytes in both directions.
  • The article’s “source and destination address” description is the exception: the actual stream request is network selector plus destination.
B. Not independently verifiable from the submitted executable
  • The article’s parent-shellcode XOR/LZNT1 unpacking and memory-loading sequence: the shellcode was not supplied.
  • Delivery through ClearFake/WebDAV, execution by Amatera secondary tasking, and the original parent process: the relevant delivery and loader artifacts were not supplied.
  • Co-deployment or execution of ZigCryptoStealer, a vulnerable driver, or NetSupport Manager: those components are separate article-described artifacts, not recovered children of the Go proxy bot.
  • A successful live C2 session, actual proxy use against particular destinations, victim telemetry, and actor attribution: none is established by the submitted executable and the runtime observations obtained here.

References

  • Cisco Talos, ClearFake WebDAV infection chain delivers Amatera stealer, ZigCryptoStealer, and NetSupport Manager, September 8, 2026.
  • Supplied Lantern behavioral analysis of the Go proxy bot, analyzed November 16, 2026.
 

About Delphos Labs Analysis

The Delphos platform analyzes compiled binaries directly and produces structured behavioral intelligence reports within minutes. This lets analysts understand what a binary does without manual analysis.

Request Access
Back to all reports
Share

Analyze your own artifacts

Request Access

File facts

File name

Go proxy bot

SHA-256

1819827e17f31e72d456158b6b9c90af25a65945f6f05d04a060da9f24179b25

Family

Unattributed

File format

PE

File size

5,889,536 bytes

Delphos LabsDelphos Labs

No source code required. No signatures. No blind spots.

Company
About UsReportsBlogSecurity Trust CenterBug Bounty ProgramVulnerability Research Policy
Account
Privacy PolicyTerms of Service
Help & Feedback
Contact SupportEmail Us
Social
LinkedInXGitHub
Copyright © 2026 Delphos Labs Inc.
Compliance & memberships
SOC 2 Type IINVIDIA Inception ProgramFS-ISAC Early Stage Affiliate