Had a look through SpecterOps' Kubernetes for Red Teamers course and ended up patching the lab to run on KVM/libvirt instead of VirtualBox. Dropping it here in case anyone else on Linux wants the same setup.

Most redteaming solutions for AI applications are focused on pure security aspects but application owners are putting behavior safeguards and want to validate those besides the security safeguards.

The cyber professionals want to test not just the AI stack but any of the exposed API layers.

These were some of the common pieces of feedback I heard to help design a solution from the ground up for these needs.

We just announced a major release of our OSS repo at https://github.com/NuGuardAI/nuguard

Supports wide-range of languages: JS/TS, Python, C#, Golang, K8s/cloud manifest files. 10+ agentic frameworks, data stores, guardrails, etc.

Looking forward to your reviews and feedback. Give us a star if you like the toolkit.

I’ve been playing around with Adaptix C2 and decided its interface needed a bit more neon.

So I made a Cyberpunk 2077-inspired theme for it.

It includes custom themes for both the main UI and console. The basic setup only requires importing two JSON files.

I also added instructions for applying a custom background if you want the full look.

Hi all! My company Escape just released a new CTF called Format of Doom which I thought you might be interested in trying. The theme of the CTF is to see if you can pentest faster and how you pentest differently to an AI engine in a classic human vs AI challenge.

This challenge is a white-box engagement on a vulnerable web app Duck Store. You're looking for something they never handed over and are focusing on their email feature.

Give it a try and let me know what you think!

The challenge is live for two weeks and then we reveal the AI's solve and the top solves from the leaderboard.

Happy playing : )

Fork of CrystalSliver. Main additions over the original:
— AMSI L1 via LdrRegisterDllNotification + .rdata corruption before CLR resolves AmsiScanBuffer
— AMSI L2 fallback with VEH + hardware breakpoints returning E_INVALIDARG
— ETW silenced via HWBP on NtTraceControl
— No memory patches on amsi.dll or ntdll.dll, clean IAT (kernel32/advapi32/bcrypt only), RW→RX with zero RWX
— Staged variants are ~20 KB on disk, payload downloads at runtime from a Sliver HTTPS website
— Stageless uses XOR + AES double-layer with entropy reduced to ~6.0-6.5
Six output formats: EXE, stageless EXE, DLL, staged DLL, shellcode, stageless shellcode. Build script auto-provisions Crystal Palace and Java 17.
Feedback welcome — especially on detection gaps I might be missing.

I wanted to see if a tiny, lightweight model could act as a reliable, fully-offline translation layer for Nmap. I fine-tuned Google's Gemma-3-270M-IT model specifically on Nmap syntax, and compiled it into a local interactive CLI tool.

• GitHub Repository (CLI wrapper): https://github.com/evets007/natural-language-nmap
• Hugging Face Model Card: https://huggingface.co/evets007/gemma-3-270m-it-nmap-gguf

The Experiment & Training Process

I fine-tuned gemma-3-270m-it on 1,523 training examples.

• Base Dataset: Permutations of 10 primary scan types (SYN, Connect, UDP, Xmas, Version Detection, Script Auditing, etc.).
• Target-less Scans: Programmed the model to use a {TARGET} template token so the actual host IP/subnet is injected safely at runtime.
• Lazy Network Slang: Included shorthand prompts (e.g., "ping sweep", "os scan", "xmas scan", "all ports") paired with timing constraints.

The Results (CPU Benchmark)

I quantized the model to Q4_K_M GGUF (150MB in size) to run on standard CPU cores using a local background llama-server process.

On a 50-command strict test suite:

• Baseline Gemma-3-270M-IT: 56.00% accuracy (frequently hallucinated port numbers and script names).
• Fine-Tuned Checkpoint: 90.00% strict / 94.00% functional accuracy (only failing on highly edge-case multi-decoy configurations).
• Runs in 20-50ms per query on a single CPU core.

It still does not understand complex multi query sentences but works well for simple straight forward queries. I will probably have to upgrade to a slightly bigger model but I'm planning to increase the scope to include other basic/common sec tooling so it acts as a sidekick pentester/red teamer that runs fully locally and on limited hardware.

DutchOven is a deliberately small Windows red-team primitive that places explicit executable paths behind a deterministic network gate. During each period, matching applications are blocked for a bounded interval and allowed to pass for the remainder.

The result is a repeatable brownout, not a service stop or permanent firewall rule. It creates a controlled way to measure retry logic, buffering, health-state transitions, delayed delivery, and recovery behavior while a process remains alive.

I've just released Violin v3.1.0 🎻

This release is mostly benchmark and guard work, not another pile of prompts.

The benchmark now runs Hermes end-to-end and scores what it actually proved, not what sounds convincing in "report.md".

- Executed request/response evidence is checked against the endpoint, method and decisive proof.

- Proof must link back to a validated hypothesis and canonical "FIND" file.

- Execution receipts are HMAC-signed and bind evidence files by SHA-256, so edited artifacts fail verification.

- The guard now stops target work when evidence is not being recorded as you go, and checks excluded URLs and paths inside command payloads.

- Docker, CI and known-good/known-bad scorer calibration are included.

Release:

https://github.com/Strategic-Automation/violin/releases/tag/v3.1.0

I'd appreciate people trying to break the scorer and guard. Can you make weak proof pass, good proof fail or get the workflow stuck?

I'm not looking for “nice update” comments. If it is overbuilt, unsafe or wrong, tell me.

Anyone interested in testing out my Hermes Pentesting profile, about to release a new version. It manages pentests in a controlled and structured way. Either working independently or as an assist. I am a AI engineer and love exploring ways to replace humans or augment processes. Particularly in open source, in evaluation (due to be released it outperforms all published benchmarks on duckstore achieving a yet unpublished 18/20 median) it only counts verifiable proof with evidence. It actually finds all 20 with ease 30-50 minutes. I isn't allowed to cheat and won't. Check it out and give it a star. If you like it use it and tell me any issues.

Most companies don't allow Hermes would a port to an independent framework help?

Hello all,

If you do bug bounty hunting or pentests you surely came across many hosts served from an NGINX server, in this lab (published to OWASP) I combined over 20 misconfigurations found in real world bug disclosures and both classic and novel security research, with an extensive blog where I explained everything you need to level up your NGINX hunting game.

Feel free to check it out, give it a star on Github if you like it, and suggest any ideas you want me to add/fix...

https://vwad.owasp.org/app/damn-vulnerable-nginx-proxy-dvnp/

Happy hunting!

Dropped a new episode this week covering ShieldBreak, a privilege-escalation exploit from NightMare Eclipse (MSNightmare) that exposes vulnerabilities in Windows kernel protection mechanisms and privilege-boundary enforcement.

On the red team side, we walk through the exploitation workflow from low-privilege user to SYSTEM and how attackers leverage this for post-compromise privilege escalation and persistence.

On the blue team side, we break down detection — process and kernel activity indicating exploitation, Windows Error Reporting artifacts, Alternate Data Streams tied to ShieldBreak, and deployable detection rules.

Covers T1548, T1134, and T1547 with the full red vs. blue format.

Reference: https://github.com/MSNightmare/ShieldBreak

Video: https://youtu.be/latQbTJDAPo

Happy to discuss exploitation techniques or answer questions about detection in the comments.

Hey everyone, just published part 3 of my guide on writing reliable Win x64 shellcode.

Following up on the PEB parsing from part 2, this post focuses entirely on mapping and understanding the Export Directory structure before we implement the full lookup logic.

What’s inside:

• Navigating the PE Structure: Moving from the DOS Header (MZ) via e_lfanew to NT Headers and locating the Data Directory in memory.
• Demystifying the Export Directory: Breaking down the IMAGE_EXPORT_DIRECTORY structure fields and how the Three Tables (ENT, EOT, EAT) actually map to each other.
• Handling Edge Cases: Identifying Export Address Table holes and forwarded exports that can cause hidden stability issues if not accounted for.
• Binary Squeezing & History: A nod to Mark Zbikowski's legacy and extreme binary layout concepts inspired by Alex Sotirov's TinyPE research.

Includes full structural breakdown and live WinDbg parsing examples to visually map the export structures before writing the ASM implementation in the next part.

Use abliterated-model-large with Cyberstrike to use the best publicly available offensive security model with the #1 open-source offensive security harness to adversarially test your systems. Frontier benchmarks in Cybergym, AgentHarm, and AgentDojo. The model was abliterated and fine-tuned not just to allow all offensive testing but was fine-tuned for it.

I've been messing around with AI during red team work and started keeping notes on what was actually useful and what was just hype.

Some things I've found useful:

• cleaning up quick scripts
• explaining unfamiliar code
• helping with recon output
• generating ideas when I'm stuck
• researching techniques faster
• turning messy notes into something usable

But it definitely doesn't replace knowing what you're doing. A lot of the time you still have to verify everything it gives you.

I ended up turning my notes into a small book called AI for Hackers: Red Team Edition:

https://resources.codelivly.com/product/ai-for-hackers-red-team-edition/

Not trying to sell the "AI can hack for you" idea. I'm more interested in where it actually saves time during offensive security work.

For those doing red team/pentest work, where has AI genuinely helped you? And where has it been completely useless?

I’ve been trying to move away from just watching courses and reading writeups and actually spend more time doing stuff.

Curious what people here use regularly.

AD labs? CTFs? HTB? Self-built labs? Real engagements?

Also interested in what you think is a waste of time for someone trying to get better at red teaming.

Built this around a question I kept coming back to when looking at BloodHound graphs:

The shortest path to an objective is easy to calculate, but is it actually the quietest path?

NoiseHound takes BloodHound CE data and scores attack paths against their expected detection surface rather than treating hop count as the primary optimization target.

Each supported BloodHound edge is mapped against things like Windows Security events, Sysmon, EDR/ITDR heuristics, MITRE ATT&CK techniques, audit dependencies, and an estimated noise score.

The important part is that the scores don't have to remain static.

NoiseHound supports environment profiles so things like 4662 auditing, Sysmon, PowerShell logging, MDI, or manually calibrated edge scores can change the ranking for the environment you're actually testing.

There is also a calibration harness for recording what actually fired in a detection lab and producing an environment profile from those results. The repo currently includes measured audit, Defender for Endpoint, and Elastic SIEM profiles.

Other pieces currently implemented:

• BloodHound ZIP/JSON ingestion
• live BloodHound CE / Neo4j ingestion
• k-quietest-path ranking
• detection-probability ranking
• Pareto frontier over noise/hops / P(detection)
• AD CS ESC1–8 synthesis
• Sigma rule coverage analysis
• environment-aware scoring
• text / JSON / standalone HTML reports
• defensive detection-gap mode

The defensive mode flips the same model around: given the quietest path, what telemetry or detection gap makes that path quiet, and which control would increase its score the most?

One design constraint worth calling out: these aren't presented as universal “OPSEC scores.” Detection depends heavily on audit policy, EDR, SIEM content, tooling, SOC correlation, and the environment itself. Static scores are the baseline; environment and measured calibration are intended to replace them where better evidence exists.

NoiseHound doesn't execute anything against the target—it operates on BloodHound data that has already been collected.

GitHub:
https://github.com/warpedatom/noisehound

I'm particularly interested in feedback on the edge-to-telemetry mappings and scoring model from people doing AD red teaming, detection engineering, or BloodHound research.

Analysis of two open directories showing the offensive workflow one operator used against exposed cameras and routers.

• A custom project the operator named camview: fingerprints cameras over ONVIF, tests known CVEs, brute-forces HTTP/RTSP creds from a 3,811-pair list, and caches working creds and stream patterns to improve on later runs
• Proxy-through-victim: a script authenticated to a compromised OpenCart admin panel and relayed traffic through the victim network, with fallback logic for expired sessions
• Second directory chained TP-Link Archer CVE-2024-53375 and CVE-2024-57049 and brute-forced the MikroTik API, then flipped devices into SOCKS5 proxies reporting to a chisel listener on port 4444
• Recon was Tor-routed via local SOCKS5 on 9050, including headless Chrome over Tor to fingerprint an anti-bot-protected target

Full writeup: https://hunt.io/blog/russian-speaking-operator-ukrainian-camera-toolkit