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
netandaddr: 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:
- Go runtime and linked package initialization execute. The custom tunnel initializer reads a logging-related environment variable.
main.machineGUIDreads the machine identifier;main.mainobtains the hostname and constructs the registration object.
main.connectAndServeopens a direct TLS connection and performs a custom HTTP WebSocket upgrade to the compiled controller.
- A length-prefixed JSON greeting is sent over the WebSocket byte-stream adapter. A framed JSON acknowledgement must report success.
- A Yamux server session is constructed over that connection.
- Each accepted Yamux stream starts with a framed JSON network/destination request. The bot dials the destination and starts two opposing byte-copy operations.
- 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, keySOFTWARE\Microsoft\Cryptography, and readsMachineGuid. Access0x101combines query access with the 64-bit registry view, despite the executable being x86. The open and value-read calls are at0x6a9cc6and0x6a9d0b.
- Failure of the registry helper leads to
os.Exit(1)at0x6a9e2a. This is an operational prerequisite, not an identified VM or sandbox test.
- The hostname helper’s error is not checked by
main.mainbefore constructing the greeting.
tunnel.HelloMsg, type metadata0x6f05c0, serializesmachine_guid,hostname,os, andversion. The compiled OS value iswindows 386; the version field remains an empty string. The registration fields are populated at0x6a9e51–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
0x6aaa40and0x6aaaf0run in opposing directions throughio.copyBuffer.
- The first copy completion causes both endpoints to be closed at
0x6aa9c3and0x6aa9cc, 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.36The 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
wssupport inDialWSis 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