V2 In rust out )

Author: qweme32

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "bypass"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+walkdir = "2.3"
+rayon = "1.7"
+colored = "2"

Dockerfile

@@ -0,0 +1,24 @@
+# --- Stage 1: Build statically with MUSL
+FROM rust:1.87 AS builder
+
+# Install musl tools and add target
+RUN apt-get update && \
+    apt-get install -y musl-tools && \
+    rustup target add x86_64-unknown-linux-musl
+
+WORKDIR /usr/src/bypass
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+
+# Build for the MUSL target (static binary)
+RUN cargo build --release --target x86_64-unknown-linux-musl
+
+# --- Stage 2: Minimal runtime
+FROM scratch AS prod
+
+# Copy the static binary
+COPY --from=builder /usr/src/bypass/target/x86_64-unknown-linux-musl/release/bypass /usr/local/bin/bypass
+
+# Default mount point
+ENTRYPOINT ["/usr/local/bin/bypass"]
+CMD ["node_modules"]

README.md

@@ -1,32 +1,38 @@
-# Nuxt UI Pro Bypass
+# Nuxt UI Pro Bypass V2
 
-**The repository exists only to show the problem do not use this script in production !!!**
+> [!WARNING]  
+> TThis script is intended only for demonstrating the problem and should not be used in production.
+
+> [!CAUTION]
+> Never use this in production — it may be illegal. :)
+
+### Instructions
+1. Install Docker on your system.
+2. Build the bypass image:
 
-Instruction
-1. Place bypass.py into your repository with nuxt-ui-pro template
-    ```
-    Project structure
-    - .nuxt
-    - app
-    - content
-    - node_modules
-    - public
-    - server
-    .env
-    bypass.py <---
-    and other files...
-    ```
-2. Install packages via npm
     ```
-    npm i
+    docker build https://github.com/qweme32/nuxt-ui-pro-license-bypass.git#main -t nuxt-pro-ui-bypass
     ```
-3. Create .env file with content
+3. In your Nuxt project, create a `.env` file with the following content:
+
     ```
     # Production license for @nuxt/ui-pro, get one at https://ui.nuxt.com/pro/purchase
-    NUXT_UI_PRO_LICENSE=any-string
+    NUXT_UI_PRO_LICENSE=XD_BYPASSED
     ```
-4. Run python script
+4. Run the bypass:
+
     ```
-    python3 bypass.py
+    docker run --rm -v "$(pwd)/node_modules:/node_modules" nuxt-pro-ui-bypass
     ```
+
+### Change log
+- `Aug 21, 2024`
+
+    First bypass written as a small Python script.
+- `June 10, 2025`
+
+    Nuxt rewrote some build logic and added chunks. Second bypass rewritten in Rust and dockerized for easy use.
     
+---
+
+> Enjoy 😉

bypass.py

@@ -0,0 +1,93 @@
+use walkdir::WalkDir;
+use rayon::prelude::*;
+use colored::*;
+use std::{fs, io, path::{Path, PathBuf}, time::Instant};
+
+const HEADER_PART_1: &str = r#"
+    _   __           __     __  ______
+   / | / /_  ___  __/ /_   / / / /  _/
+  /  |/ / / / / |/_/ __/  / / / // /  
+ / /|  / /_/ />  </ /_   / /_/ // /   
+/_/ |_/\__,_/_/|_|\__/   \____/___/              
+"#;
+
+const HEADER_PART_2: &str = r#"
+    ____                ____                             
+   / __ \_________     / __ )__  ______  ____ ___________
+  / /_/ / ___/ __ \   / __  / / / / __ \/ __ `/ ___/ ___/
+ / ____/ /  / /_/ /  / /_/ / /_/ / /_/ / /_/ (__  |__  ) 
+/_/   /_/   \____/  /_____/\__, / .___/\__,_/____/____/  
+                          /____/_/                      
+"#;
+
+const VERIFY_URL: &str = "https://api.nuxtlabs.com/ui-pro/verify";
+const BYPASS_URL: &str = "https://httpbin.org/status/200";
+const TARGET: &str = "node_modules/@nuxt";
+
+fn main() -> io::Result<()> {
+    control::set_override(true);
+    
+    let start = Instant::now();
+
+    print!("{}", HEADER_PART_1.bright_blue());
+    println!("{}", HEADER_PART_2.bright_green());
+    println!("{} {}", "[i]".bright_yellow(), "This script is intended only for showing the problem".bright_black());
+    println!("{} {}", "[!]".bright_red(), "Never use it in production it is illegal xd!!!)".bright_black());
+    println!("{} {}", "[@]".bright_cyan(), "By qweme32 ( https://github.com/qweme32 )".bright_black());
+
+    let root = Path::new(TARGET);
+
+    if !root.exists() || !root.is_dir() {
+        println!("{} {}", "[X]".bright_red(), format!("Dir {} does not exist or is not accessible.", TARGET));
+        
+        return Ok(());
+    }
+
+    println!("{} {} {}", "[?]", "Scanning dir:".bright_black(), TARGET.bright_black());
+
+    // Collect paths
+    let paths: Vec<PathBuf> = WalkDir::new(&root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|entry| {
+            entry.file_type().is_file()
+            && matches!(
+                entry.path().extension().and_then(|e| e.to_str()),
+                Some("js") | Some("mjs") | Some("ts") | Some("mts")
+            )
+        })
+        .filter(|entry| {
+            fs::read_to_string(entry.path())
+                .map(|content| content.contains(VERIFY_URL))
+                .unwrap_or(false)
+        })
+        .map(|entry| entry.into_path())
+        .collect();
+
+    // Zero paths check
+    if paths.len() == 0 {
+        println!("{} {}", "[X]".bright_red(), "It looks like you have already bypassed the check or the script is outdated");
+        return Ok(());
+    }
+
+    // Rewrite for bypass
+    paths.par_iter().for_each(|path| {
+        match fs::read_to_string(path) {
+            Ok(content) => {
+                let new_content = content.replace(VERIFY_URL, BYPASS_URL);
+                match fs::write(path, new_content) {
+                    Ok(_) => println!("{} {} {}", "[+]".green(), "Bypassed", path.as_path().to_str().unwrap().bright_black()),
+                    Err(err) => eprintln!("{} {} {}", "[X]".bright_red(), "Rewrite failed", err),
+                }
+            }
+            Err(err) => eprintln!("{} {} {}", "[X]".bright_red(), "Rewrite failed", err),
+        }
+    });
+
+    // Finish
+    let dur = start.elapsed().as_millis();
+    println!("\n{} {}", "[T]".bright_magenta(), format!("{}ms elapsed", dur.to_string()).bright_black());
+
+    Ok(())
+}
+