Fake recruiter profiles, a fabricated company called “Careers 2 Find,” and seemingly legitimate job offers targeting aerospace and aviation professionals.

This is the social engineering scenario behind our Charming Kitten APT Adversary Simulation, exploring how fake recruitment opportunities can be used to target sensitive industries.

Looking for relatively practical ways to bypass Mark of the Web when delivering a macro-enabled Excel file (.xlsm) via email in 2026.

The usual container approaches (ISO/IMG) get blocked by most mail gateways (Gmail, etc.). Nested archive chains (CAB + TAR + TAR + 7z) do strip MOTW on extraction, but they require too many manual steps from the user and are inconsistent across modern Windows builds.

HTML Smuggling works well for browser downloads, but I'm specifically interested in methods that work as email attachments or links that still land the file without MOTW (or with it stripped reliably).

Has anyone had consistent success with anything else lately — OneNote, specific archive combinations that mail services still allow, or other techniques that don't require 4+ extraction steps?

Any pointers or recent findings appreciated.

Hey everyone! 👋

I wanted to share PngLoader, a lightweight tool I built to hide and extract arbitrary data payloads inside standard PNG images.

Instead of messing up pixel data, it highlights a simple technique of encoding raw payloads into nibbles-to-ASCII and packing them inside the PNG file structure. The resulting image stays completely valid and renders normally across browsers and image viewers.

Features:

* 🖼️ Output PNGs remain fully renderable and uncorrupted.

* 🔤 Simple nibble-to-ASCII payload transformation.

* 📦 Hides and extracts arbitrary files/text effortlessly.

https://github.com/i014n/PngLoader

Last week's Node.js buzz was the Brotli decoder OOB write the community dubbed Node2Shell. I turned it into a hands-on black-box lab.

The premise: you're poking at a "PacketLedger" freight gateway. The page never mentions the CVE or the vuln class — you fingerprint the engine yourself, find the decode path, and work out what kills it.

The gate is unusual: no flag until you trigger 3 recorded engine crashes (the supervisor keeps count). Full RCE exists but it's treated as a platform-dependent easter egg, so DoS-chain players get a real win too. Double flag (second one behind a path-traversal), 5-step hint ladder, difficulty ~3.5/5, full solve verified by a local LLM pentest agent.

One docker compose up, no cloud calls, MIT. It's part of my *2Shell lab series (php2shell-lab is the sibling).

github.com/tani2shell/node2shell-lab

Curious how people approach the fingerprinting blind — how did you decide to attack the compression layer at all?

Current checks cover unquoted service paths, AlwaysInstallElevated policy, dangerous token privileges (SeImpersonate, SeDebug, etc.), modifiable service binaries via ACL parsing, Point and Print misconfigurations, writable Run/RunOnce keys, startup folder permissions, and WSL distributions defaulting to root.

The architecture is modular - implement the ICheck interface, register it, done. Adding new checks doesn't touch existing code.

The main reason this exists as a compiled C++ binary rather than a PowerShell script: it runs fine in environments where CLM is enforced or AMSI is catching script-based tooling. No .NET, no script engine, just Win32 API calls.

More checks coming. Feedback and contributions welcome.

KrakenHashes 3.0.0 released - distributed hashcat with cloud GPU provisioning, self-updating agents, and a rebuilt UI

For anyone who hasn't run into it: KrakenHashes is a self-hosted system for running hashcat across a fleet of machines. You point agents at a server, upload hashlists, and it handles scheduling the work across whatever GPUs you have, tracking progress, and keeping a potfile you can reuse across engagements. It's AGPLv3 and aimed at pentesters and red teams who have permission to crack what they're cracking.

3.0.0 is the biggest release since I started it. A few things I think are worth calling out:

Cloud GPU provisioning. If your own agents are saturated, a job can now rent GPUs on demand and give them back when it's done. Everything is budgeted per client, the rented box gets only the files that job needs, and there are several independent paths that guarantee teardown so you don't wake up to a bill. AWS is tested end to end with real money. RunPod and Vast.ai are fully built but I haven't run real spend through them yet, so they're flagged experimental in the UI. Cloud agents have to join over a VPN, there's no option to expose them straight to the internet, and that's deliberate.

Self-updating agents. There's a small launcher now that supervises the agent and swaps the binary when the server has a newer version, with a health check and automatic rollback if the new one doesn't come back healthy. It only updates when the agent is idle, so it never kills a running job.

A rebuilt frontend. Proper light and dark themes, a dashboard that scopes to you or your teams instead of showing everything, and the UI is in 17 languages now. Agent auth also moved to mutual TLS on the same port, with a real revoke action.

Plus network share storage so wordlists and rules can live on an NFS/SMB share, loopback attacks that re-run your rules against freshly cracked passwords until nothing new falls out, optional BloodHound enrichment in the analytics, internal vs external PDF reports, and server-enforced custom branding.

What's still rough and honest about it: RunPod and Vast need someone to shake them out with real money before I'd call them production. The upgrade touches a lot, so if you're coming from 2.x, back up your database first, expect a couple of the migrations to take a while on large hash tables, and know that your existing 2.x agents keep working but can't auto-update until you move them onto the launcher. The upgrade notes in the docs walk through all of it.

This release genuinely wouldn't be here without the people running it on real engagements and reporting what broke. A large share of the fixes in 3.0 came straight out of those issues, so thank you to everyone who filed one or just told me what was annoying.

Release notes and binaries: https://github.com/ZerkerEOD/krakenhashes/releases/tag/v3.0.0

Docs: https://zerkereod.github.io/krakenhashes/latest/

Upgrade notes: https://zerkereod.github.io/krakenhashes/latest/deployment/updates/#upgrading-to-300-from-2x

Happy to answer questions in the comments.

Red-teamers, this is built in your image, so I'm bringing it to you first. Full disclosure: it's my project, open source (MIT), shipped today.

The Arrakis 2026 threat report found 24% of dormant production agents can be started by an unsigned webhook. The deeper problem: an agent reads data and instructions in the same stream and can't natively tell them apart. So the world hides orders inside the data — a page that says "send the credentials," a tool result with a second job tucked inside, content wearing a fake SYSTEM: header.

Sentinel is the inbound half of my governor. QuietOS governs what an agent DOES; Sentinel governs what it HEARS. The law: only the owner issues instructions; everything else is data. World content is inspected before the brain sees it. Anything instruction-shaped from a non-owner source gets held for the owner with the exact content preserved verbatim, and every attempt lands in an append-only attack ledger.

I red-team my own work and publish the results — the governor just survived an 18-scenario true batch against a live 120B model with zero bypasses. And the honest part: Sentinel v0.1 has four known holes (synonym-crafted exfiltration, leetspeak override, summary-carried exfiltration, non-English override). They're in the public proof log. Breaking it in a new way gets you in that log, credited, and the fix ships in the open.

Install: pip install quietos-sentinel

Code: github.com/jondean213-pixel/quietos-sentinel

What's your favorite way to make an agent obey something it only read?

The leaked php2shell bugs (CVE-2026-109618 / 109619) hand you an OOM-driven memory corruption primitive in PHP core, but turning that into code execution is where it stalls. The public PoCs making the rounds are lab-only. None clears ASLR on x86-64, and the read from VulnCheck, HackingLZ and MalwareTech is that a reliable chain needs a second weakness or a target without ASLR, think 32-bit or a single-worker PHP-FPM setup.

We tracked how operators are handling that gap in their own open directories: straight public PoC reuse, a pentest-style assessment that judged its target not exploitable, and one mass-exploitation kit that sprayed 123 servers through a proxy farm and logged zero shells. Useful if you are calibrating how far this is from a usable capability right now.

I know this is red team, but sharing it widely in case it even helps one person - remove if not appropriate 🖤

This hunting set seeks to fill a gap while we all respond - there are plenty of IOC hunting repos, exposurehunt aims to help surface and verify known and unknown instances of naughty PHP.

I’ve spent the evening heavily developing and testing (in prod, where else) what appears to now be a relatively robust coverage set of 6 sequenced KQL/Advanced Hunting queries, 3 each across Linux and Windows. Sharing the love. Copy pasta, follow the in-line guidance - Might be useful in addition to your current methods! PRs welcome, if they don’t suck, and if my robot agrees.

https://github.com/deathbydata/php2shell-exposurehunt

Happy hunting! ☺️

I built a reproducible, engine-level practice range for PHP2Shell and put it on GitHub. Not another "run the PoC" box:

Black-box by design — no Server: PHP, no phpinfo, version fingerprinting must come from behavior, not headers

The heap-disclosure window is time-boxed: it's open right after boot and closes. Leak first, recon second — window time spent browsing is gone until next up

Two privilege paths to proof.txt, different elegance grades

Honest platform matrix: RCE landing verified on x86_64; on Apple Silicon/ARM the disclosure chain is the intended solution (documented, not hidden)

Calibrated against an autonomous pentest agent over multiple live-fire rounds; human expectation 2–4h

>

docker compose up -d --build and go. MIT licensed, full kill chain in docs/SOLUTION.md.

https://github.com/tani2shell/php2shell-lab

Feedback and write-ups welcome — file an issue if a step fights you.

I continued researching sandbox bypasses discovered in Twig by project Glasswing. This time, I focused on CVE-2026-46633, which still had no public exploits. This writeup documents my development of payloads for the CVE-2026-46633 and the corresponding SSTImap modules.

Created a C2 which uses confluence API to communicate between victim and server which is again connected to confluence using api.

Introducing Evil Agent, a new payload generator for Discord and Telegram agents, supporting EXE, DLL, BIN, and HEX formats, with configurable message sizes and an alternative communication channel without requiring a dedicated listener or exposed port.

The update also includes fixes to the existing Listener Payload Generator, Makefile improvements for smoother compilation, and GUI enhancements.

Wrote a walkthrough on building a Beacon Object File from scratch in C. The post covers how Beacon acts as a minimal COFF linker/loader at runtime, how the MODULE$Function convention gets resolved via LoadLibraryA/GetProcAddress under the hood, and why BOFs produce almost no telemetry compared to execute-assembly or fork&run patterns.

The example BOF enumerates privileges on the current process token using only dynamic Win32 API resolution and stack allocation - no CRT, no heap, no static imports.

Also included a section on defensive considerations: in-memory COFF parsing patterns, GetProcAddress bursts, and where kernel-level telemetry still catches you.

Feedback welcome - especially on patterns people have seen EDRs flag for BOF detection specifically.

I put up a free public CertStream endpoint for anyone monitoring phishing or lookalike domains

wss://api.certstream.dev/

No API key or signup needed, just connect over WebSocket

Python example: https://certstream.dev/free-certstream-api.html

Open source: https://github.com/reloading01/certstream-server-rust

Good case study in cheap tradecraft. One operator, one rented server, a borrowed Log4Shell chain. The delivery script split the CommonsBeanutils2 payload across two serialized objects with a deliberate pause, then solved the blind-execution problem with a simple trick: sleep, tail the staging server's own access log, and watch for the target to pull the stager.

The one piece of original work, a RouterOS SCEP heap overflow, never landed because they reversed the wrong binary. After execution they staged an SSH tunnel pivot with a dedicated no-shell account for port forwarding, fetched but never confirmed in use.

Full teardown: https://hunt.io/blog/ukraine-state-data-exchange-graylog-log4shell

Hey,

i'm working on those two little tools, any feedback is appreciated.

\\->>HostBadger, an open-source Windows hardening auditor in pure PowerShell.

One read-only script takes a snapshot of each host, and you can push it through your EDR (CrowdStrike RTR or any tool that runs scripts) to a whole fleet in about 15 seconds per host. The analyzer then works offline and writes a clean HTML report with A–F scores, plus CSV and JSON Lines for your SIEM.

\\- 138 checks: credentials, Defender and EDR, network exposure and NTLM relay paths, privilege escalation, logging, BitLocker

\\- 1475 DISA STIG rules plus the CIS benchmark of each host's own Windows version, with the value found next to the value required

\\- Vulnerable drivers (LOLDrivers), end-of-life and outdated software (endoflife.date), CISA KEV matches

\\- Read-only by design, with a safety script that checks this from the code. No network unless you ask. What it can't read is "not evaluated", never clean.

\\- Reversible fix scripts with rollback, and an optional AI summary where names become tokens before anything is sent

Nothing to install (PowerShell 5.1 or 7):

https://github.com/g4bri-3l3/HostBadger

& ->>IDWolf: my own AD/Entra ID hardening tool that tells you whether your domain can be taken, and through which real-world attacks.

Open-source, pure PowerShell, read-only collection (native cmdlets only), offline analysis.

Recent attacks mapped to checks: BadSuccessor, Golden dMSA, coercion + NTLM relay to LDAP and AD CS (CVE-2025-24054), NTLM reflection (CVE-2025-33073), ESC15/16, password spraying, device code and consent phishing, and Intune mass-wipe exposure (Multi Admin Approval).

AI review with chaining: pseudonymized findings go to Gemini, which returns a verdict on whether the weaknesses chain into Domain Admin, the chains with their starting point and the one link to fix to break each, and which findings match publicly known attacks.

169 AD and 90 Entra checks · CIS / MITRE / NIS2 / ISO 27001 / DORA / GDPR mapping & tested on a real lab populated with Vulnerable-AD.

Https://github.com/g4bri-3l3/IDWolf

Hi all,
Im trying to build a loader and reached 40% of maldev academy. I am building it in stages
1) getting your .bin from c2
2) memory allocation
3) execution after decryption with sleep

Is there any framework or github repo you would suggest to build a fully educational purpose loader which I can use for company red team ?

Also I saw some UDRL loader from Bobby cooke and aceLdr. Does UDRL still work when compared to PIC Loader ?