antidbg
A stealthy, fully syscalled C/C++ userland anti-debugging library for Windows, designed to protect software from reverse engineering
- 356
- Assembly
- MIT
- 2 mo ago
Automate PowerShell script source code obfuscation & virtualization with a flexible Web API for Rust (Cargo package).
Repo PELock/PowerShell-Pro-Obfuscator-Rust, read from GitHub 1 min ago. PELock has not joined Take My Repo.
PELock/PowerShell-Pro-Obfuscator-Rust is a public repo on GitHub by PELock. Automate PowerShell script source code obfuscation & virtualization with a flexible Web API for Rust (Cargo package). It declares the Apache-2.0 license on GitHub. It is written mainly in Rust, has 4 stars and last changed on 2026-07-28. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
PowerShell Pro Obfuscator protects proprietary .ps1 scripts with renaming, polymorphic string and integer encryption, control-flow flattening, finite-state automata (FSA), a VM engine, self-defending integrity checks, a protection linker, and anti-debugging probes.
Obfuscate, virtualize & protect PowerShell .ps1 scripts with polymorphic string encryption, VM engine, finite-state automata transforms, self-integrity & anti-debugging checks — via GUI, CLI, online tool, or API.
More technical details, downloads, documentation available at:
https://www.pelock.com/products/powershell-pro-obfuscator
It's available for Windows & Linux:
Multiple programming APIs available:
An online obfuscator interface:
Scripts are typically distributed as plain .ps1 files or embedded in modules. That convenience means anyone with file access can read the full logic, hunt for credentials or API keys in strings, and steal your algorithms unless you take extra steps to hide intent.
PowerShell is a cross-platform shell and scripting language built on .NET. It is widely used for automation, configuration, DevOps pipelines, and endpoint management on Windows and Linux.
PowerShell Pro Obfuscator comes with many advanced obfuscation, virtualization & protection strategies. You can easily tune protection versus size and performance.
PowerShell Pro Obfuscator uses state-of-the-art obfuscation strategies such as polymorphic string encryption, integers & floats encryption, and decoy noise. The result conceals literals and structure while preserving tested runtime behaviour.
Selected statements are lifted into a random generated VM engine opcodes with shuffled switch cases, decoy opcodes, and an obfuscated dispatcher loop. Analysts must interpret the virtual machine instead of reading plain PowerShell.
Finite-state automata (FSA) obfuscation rewrites linear PowerShell statement blocks into dual-state automata with opaque schedulers and shuffled dispatch handlers. Instead of reading code top to bottom, analysts must follow numeric states, transition tables, and decoy paths to reconstruct the original order.
Anti-debugging protection inserts polymorphic probes that detect attached debuggers, PowerShell breakpoints, debug preference and tracing modes, and related host signals. When a check fires, the obfuscated script exits silently instead of revealing protected logic under interactive analysis.
A bootstrap probe verifies on-disk script shape (function counts and integrity tokens) and sets a tamper key when the file no longer matches the obfuscated build. String decryptors consume that key, so patched scripts return garbage instead of plaintext. This self-defending layer raises the cost of casual deobfuscation and file edits.
A late pass wires honeypot resolvers, bogus helper calls with random arguments, and shallow-stack tripwires that stay active only before bootstrap completes. Extracted snippets keep noisy call surfaces that look real under static review. Normal execution after a successful integrity check remains unchanged.
Look at this example — the same script becomes harder to read at a glance after obfuscation.
function Get-Greeting { param([string]$Name) Write-Host "Hello World from $Name!" } Get-Greeting "PowerShell Pro Obfuscator"
$script:_HnJTskg = 0 $jwNTQ = 297 * 400 + 36 $x4e8bfda = [Math]::Abs($jwNTQ - 8074) $_EvKocNn = [Math]::Max($jwNTQ, $x4e8bfda) - [Math]::Min($jwNTQ, $x4e8bfda) [void]$_EvKocNn $script:_jUoXkBYh = 0 function gnJjzMCN3V8P { param([int]$slot, [int]$salt, [int]$guard) if (-not ((Get-Variable -Name _HnJTskg -Scope Script -ErrorAction SilentlyContinue).Value)) { return '' } @('JFE', 'm0ao', 'R8Ysw') | ForEach-Object { $_.ToUpper() } | Out-Null if ((((($slot * 31) + $salt) -band 65535) -ne $guard)) { return '' } $tk = (Get-Variable -Name _jUoXkBYh -Scope Script -ErrorAction SilentlyContinue).Value $IEm39CSpDOEFp = @{ 'Ouj1' = 455; 'vjzO' = 170; 'IQNV' = 291 } $IEm39CSpDOEFp['R5LrM'] = $IEm39CSpDOEFp['Ouj1'] + $IEm39CSpDOEFp['vjzO'] $YWxSO = ($IEm39CSpDOEFp.Values | Measure-Object -Sum).Sum [void]$YWxSO if ($null -eq $tk) { [long]$tk = 0 } $v93a130f2e4 = 508 switch ($v93a130f2e4) { 524 { $_GYF7IA14Go = 'H1Vph' } 561 { $_GYF7IA14Go = 'HAWoB' } default { $_GYF7IA14Go = $v93a130f2e4 * 2 } } [void]$_GYF7IA14Go $dk = (Get-Variable -Name vb6a18ffee4 -Scope Script -ErrorAction SilentlyContinue).Value try { $xgLN5KZyEusFo7 = [Math]::Sqrt(850) } finally { [void]$xgLN5KZyEusFo7 } if ($null -eq $dk) { [long]$dk = 0 } $d = @(46866, 46865) if ((((-not 113))-and(([int](272 -ne 272) -eq 21)))-and(([Math]::Sign(-12) -eq 4))) { $w4iTzi2hooy1GW = @(711, 562, 665); $w4iTzi2hooy1GW = ($w4iTzi2hooy1GW | Measure-Object -Sum).Sum } $r = '' for ($s9qOSpiZzufQlVyV = 0; $s9qOSpiZzufQlVyV -lt $d.Length; $s9qOSpiZzufQlVyV++) { [long]$v = [long]$d[$s9qOSpiZzufQlVyV] for ($jL9gL7PEtQeIS = 2; $jL9gL7PEtQeIS -ge 0; $jL9gL7PEtQeIS--) { for ($PsbomDHxAy = 2; $PsbomDHxAy -ge 0; $PsbomDHxAy--) { [long]$v = [long]$v + ([long](230)) } } for ($zhH33vzxjIzegl9 = 0; $zhH33vzxjIzegl9 -ge 0; $zhH33vzxjIzegl9--) { [long]$v = [long]$v + ([long]([int]((((((236 + (-3 * $s9qOSpiZzufQlVyV) + (3 * $zhH33vzxjIzegl9))) % 256) + 256) % 256)))) [long]$v = [long]$v -bxor ([long](53766)) } [long]$v = [long]$v - ([long]($salt + $slot + $tk + $dk + 0)) if ([long]$v -ge 0 -and [long]$v -le 0xFFFF) { $r += [char][int][long]$v } elseif ([long]$v -ge 0x10000 -and [long]$v -le 0x10FFFF) { $r += [System.Char]::ConvertFromUtf32([int][long]$v) } } return $r } and more...
Would you still recognise the original intent if you only had the obfuscated text and no prior copy of the script?
The engine parses PowerShell source into an AST tree, then applies selectable transforms: identifier renaming, control-flow flattening, finite-state automata (FSA), VM virtualization, polymorphic string and integer encryption, noise and decoy insertion, self-defending integrity probes, the protection linker, and anti-debugging checks. Many techniques are specific to this product; some ideas are shared with our other protection tools.
When all passes finish, the engine emits a new .ps1. Edge cases in the PowerShell grammar and hosting environments mean you should always test the output in your target runtime.
Take no chances, use PowerShell Pro Obfuscator to obfuscate, virtualize and protect your PowerShell scripts and algorithms.
Our company has a long history in obfuscation technologies and code obfuscators (see our x86 Assembly, AutoIt & Java obfuscators).
We actively bugfix, research and develop new obfuscation strategies for our tools.
You can count on our expertise and support in this field.
The preferred way of WebApi interface installation is via crates.io.
Run:
cargo add powershell-pro-obfuscator
Or add this entry directly to your Cargo.toml in [dependencies]:
powershell-pro-obfuscator = "1.0.0"
The crate is available at https://crates.io/crates/powershell-pro-obfuscator
From a checkout of this repository you can run the included examples, for example:
cargo run --example powershell-pro-obfuscator-example-simple
/****************************************************************************** * PowerShell Pro Obfuscator WebApi interface usage example. * * In this example we will obfuscate sample source with default options. * * Version : v1.0.0 * Language : Rust * Author : Bartosz Wójcik * Web page : https://www.pelock.com * *****************************************************************************/ use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { // // include PowerShell Pro Obfuscator class // // // when developing from a repository clone without installing the package use: // // use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse}; // (path dependency in Cargo.toml pointing to this crate) // // create PowerShell Pro Obfuscator class instance (we are using our activation key) // let my_powershell_pro_obfuscator = PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string())); // // source code in PowerShell format // let script_source_code = r#"function Get-Greeting { param([string]$Name) Write-Host "Hello World from $Name!" } Get-Greeting "PowerShell Pro Obfuscator""#; // // by default all obfuscation options are enabled, so we can just simply call: // let result = my_powershell_pro_obfuscator .obfuscate_script_source(script_source_code, true) .await; // // it's also possible to pass a PowerShell script file path instead of a string e.g. // // let result = my_powershell_pro_obfuscator // .obfuscate_script_file(std::path::Path::new("/path/to/project/script.ps1"), true) // .await; // // result object holds the obfuscation results as well as other information // // result.error - error code // result.output - obfuscated code // result.demo - was it used in demo mode (invalid or empty activation key was used) // result.credits_left - usage credits left after this operation // result.credits_total - total number of credits for this activation code // result.expired - if this was the last usage credit for the activation key it will be set to true // match result { Some(PowerShellProObfuscatorResponse::Object(obj)) => { // // display obfuscated code // if obj.error == PowerShellProObfuscator::ERROR_SUCCESS { println!("{}", obj.output.unwrap_or_default()); } else { return Err( format!("An error occurred, error code: {}", obj.error).into(), ); } } Some(PowerShellProObfuscatorResponse::Json(_)) => {} None => { return Err("Something unexpected happen while trying to obfuscate the code.".into()); } } Ok(()) }
/****************************************************************************** * PowerShell Pro Obfuscator WebApi interface usage example. * * In this example we will obfuscate sample source with custom options. * * Version : v1.0.0 * Language : Rust * Author : Bartosz Wójcik * Web page : https://www.pelock.com * *****************************************************************************/ use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { // // include PowerShell Pro Obfuscator class // // // when developing from a repository clone without installing the package use: // // use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse}; // (path dependency in Cargo.toml pointing to this crate) // // create PowerShell Pro Obfuscator class instance (we are using our activation key) // let mut my_powershell_pro_obfuscator = PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string())); // // should the source code be compressed (both input & compressed) // my_powershell_pro_obfuscator.enable_compression = false; // // global obfuscation options // // you can disable a particular obfuscation strategy globally if it // fails or you don't want to use it without modifying the source codes // // by default all obfuscation strategies are enabled // // // protection against tampering with protected code (integrity verification) // my_powershell_pro_obfuscator.self_defending = true; // // protection linker (decoy call graph) // my_powershell_pro_obfuscator.protection_linker = true; // // rename variable names to random string values // my_powershell_pro_obfuscator.rename_variables = true; // // rename parameter names to random string values // my_powershell_pro_obfuscator.rename_parameters = true; // // rename function names to random string values // my_powershell_pro_obfuscator.rename_functions = true; // // shuffle function order in the output source // my_powershell_pro_obfuscator.shuffle_functions = true; // // change linear code execution flow via control-flow flattening // my_powershell_pro_obfuscator.control_flow_flatten = true; // // rewrite statement blocks into finite-state automata (state-machine obfuscation) // my_powershell_pro_obfuscator.state_machine = true; // // lift selected statements into a VM engine (virtualized statements) // my_powershell_pro_obfuscator.vm_strategy = true; // // encrypt integers // my_powershell_pro_obfuscator.encrypt_integers = true; // // split strings into concatenated chunks // my_powershell_pro_obfuscator.split_strings = true; // // encrypt strings using randomly generated polymorphic encryption algorithms // my_powershell_pro_obfuscator.encrypt_strings = true; // // move integers to arrays // my_powershell_pro_obfuscator.integers_to_arrays = true; // // move floats to arrays // my_powershell_pro_obfuscator.floats_to_arrays = true; // // insert dead code // my_powershell_pro_obfuscator.insert_dead_code = true; // // replace boolean conditions with equivalent complex expressions // my_powershell_pro_obfuscator.complexify_booleans = true; // // represent integers via floating-point math // my_powershell_pro_obfuscator.integers_to_floating = true; // // encrypt floating point numbers // my_powershell_pro_obfuscator.encrypt_floating = true; // // insert decoy functions // my_powershell_pro_obfuscator.decoy_functions = true; // // insert anti-debugging detections // my_powershell_pro_obfuscator.detect_debugger = true; // // insert fake dot-source comment markers // my_powershell_pro_obfuscator.fake_dot_source_markers = true; // // insert opaque predicate branches // my_powershell_pro_obfuscator.opaque_branches = true; // // insert scriptblock decoys // my_powershell_pro_obfuscator.scriptblock_decoys = true; // // insert here-string padding // my_powershell_pro_obfuscator.literal_padding = true; // // use indirect command invocation // my_powershell_pro_obfuscator.reflect_invoke_commands = true; // // store string fragments in char-code array vaults // my_powershell_pro_obfuscator.string_char_array_vault = true; // // wrap code in try/finally blocks with dead noise // my_powershell_pro_obfuscator.try_finally_noise = true; // // apply redundant xor / affine integer masks // my_powershell_pro_obfuscator.affine_integer_mask = true; // // insert dead event/timer stubs // my_powershell_pro_obfuscator.event_stub = true; // // strip comments from the output source // my_powershell_pro_obfuscator.remove_comments = true; // // source code in PowerShell format // let script_source_code = r#"function Get-Greeting { param([string]$Name) Write-Host "Hello World from $Name!" } Get-Greeting "PowerShell Pro Obfuscator""#; // // by default all obfuscation options are enabled, so we can just simply call: // let result = my_powershell_pro_obfuscator .obfuscate_script_source(script_source_code, true) .await; // // it's also possible to pass a PowerShell script file path instead of a string e.g. // // let result = my_powershell_pro_obfuscator // .obfuscate_script_file(std::path::Path::new("/path/to/project/script.ps1"), true) // .await; // // result object holds the obfuscation results as well as other information // // result.error - error code // result.output - obfuscated code // result.demo - was it used in demo mode (invalid or empty activation key was used) // result.credits_left - usage credits left after this operation // result.credits_total - total number of credits for this activation code // result.expired - if this was the last usage credit for the activation key it will be set to true // match result { Some(PowerShellProObfuscatorResponse::Object(obj)) => { // // display obfuscated code // if obj.error == PowerShellProObfuscator::ERROR_SUCCESS { println!("{}", obj.output.unwrap_or_default()); } else { return Err( format!("An error occurred, error code: {}", obj.error).into(), ); } } Some(PowerShellProObfuscatorResponse::Json(_)) => {} None => { return Err("Something unexpected happen while trying to obfuscate the code.".into()); } } Ok(()) }
/****************************************************************************** * PowerShell Pro Obfuscator WebApi interface usage example. * * In this example we will verify our activation key status. * * Version : v1.0.0 * Language : Rust * Author : Bartosz Wójcik * Web page : https://www.pelock.com * *****************************************************************************/ use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { // // include PowerShell Pro Obfuscator class // // // if you don't want to use crates.io use a path dependency to this crate // // [dependencies] // powershell-pro-obfuscator = { path = ".." } // // create PowerShell Pro Obfuscator class instance (we are using our activation key) // let my_powershell_pro_obfuscator = PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string())); // // login to the service // let result = my_powershell_pro_obfuscator.login(true).await; // // result object holds the information about the license // // result.demo - is it a demo mode (invalid or empty activation key was used) // result.credits_left - usage credits left after this operation // result.credits_total - total number of credits for this activation code // result.string_limit - max. source code size allowed (it's 1000 bytes for demo mode) // match result { Some(PowerShellProObfuscatorResponse::Object(obj)) => { println!( "Demo version status - {}", if obj.demo.unwrap_or(false) { "true" } else { "false" } ); println!( "Usage credits left - {}", obj.credits_left.unwrap_or(0) ); println!( "Total usage credits - {}", obj.credits_total.unwrap_or(0) ); println!( "Max. source code size - {}", obj.string_limit.unwrap_or(0) ); } Some(PowerShellProObfuscatorResponse::Json(_)) => {} None => { return Err("Something unexpected happen while trying to login to the service.".into()); } } Ok(()) }
Online interface for PowerShell Pro Obfuscator is available at:
https://www.pelock.com/powershell-pro-obfuscator/
You can download it at:
https://www.pelock.com/products/powershell-pro-obfuscator/download
Installation package contains an additional command line interface:
PowerShell Pro Obfuscator ships with a command-line interface for Windows and Linux automation.
Use it to integrate obfuscation into build servers, CI jobs, or batch packaging.
Bartosz Wójcik
PELock/PowerShell-Pro-Obfuscator-Rust is a public repo on GitHub by PELock. Automate PowerShell script source code obfuscation & virtualization with a flexible Web API for Rust (Cargo package).
It declares the Apache-2.0 license on GitHub.
Its maker tagged it for Windows. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-07-28. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
A powerful obfuscator for JavaScript and Node.js
:man_technologist: Simple and effective Obfuscator PHP class (this is not a stupid base64 encoding script, but a real and effective obfuscation script)
.Net Framweork and .Net Core Anti Debugging to stop multiple malicious tools and hooks on your software.
A tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.

Software copy protection against cracking & reverse engineering with anti-cracking & anti-debugging techniques. Software license key system with time trial options.

JObfuscator is a source code obfuscator for the Java language. Protect Java source code & algorithms from hacking, cracking, reverse engineering, decompilation & technology theft. PHP package for the composer.
AutoIt Obfuscator lets you protect AutoIt script source code against analysis, reverse engineering & decompilation using advanced obfuscation techniques and polymorphic encryption.
How to write a CrackMe for a CTF competition. Source code, technical explanation, anti-debugging and anti reverse-engineering tricks.

Willy is a monospaced font created a long ago by my demoscene friend Willy, it's perfect for displaying ascii-art.

String Encryption and File Encryption for C/C++, C#, Visual Basic .NET, Delphi/Pascal/Object Pascal, Java, JavaScript, Python, Ruby, AutoIt, PowerShell, Haskell, MASM, FASM programming languages.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/PELock/PowerShell-Pro-Obfuscator-RustTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.
