PowerShell Pro Obfuscator Dokumentacja API

Zautomatyzuj obfuskację i wirtualizację kodów źródłowych skryptów PowerShell przez elastyczny interfejs Web API dla programistów.

Opis

Możesz skorzystać ze wszystkich opcji PowerShell Pro Obfuscatora poprzez interfejs Web API. Web API bazuje na prostym zapytaniu POST i odpowiedzi zakodowanej w postaci JSON.

Instalacja

W celu szybszego wdrożenia paczki instalacyjne interfejsu Web API PowerShell Pro Obfuscatora zostały wgrane na popularne repozytoria (PowerShell Gallery, Packagist, PyPI, npm, crates.io, NuGet). Kody źródłowe zostały dodatkowo opublikowane na GitHubie:

Język	Instalacja	Paczka	Źródła
PowerShell	Uruchom komendę: `Install-Module -Name PowerShellProObfuscator` lub: `Install-PSResource -Name PowerShellProObfuscator`	PowerShell Gallery	GitHub
PHP	Uruchom komendę: `php composer.phar require --prefer-dist pelock/powershell-pro-obfuscator ""` lub dodaj do sekcji `require` w pliku konfiguracyjnym `composer.json` wpis: `"pelock/powershell-pro-obfuscator": ""`	Packagist	GitHub
Python	`pip install powershell-pro-obfuscator`	PyPI	GitHub
JavaScript	Uruchom komendę: `npm install powershell-pro-obfuscator` lub dodaj do sekcji `dependencies` w pliku `package.json` wpis: `"powershell-pro-obfuscator": "^1.0.0"`	npm	GitHub
Rust	Uruchom komendę: `cargo add powershell-pro-obfuscator` lub dodaj do sekcji `[dependencies]` w pliku `Cargo.toml` wpis: `powershell-pro-obfuscator = "1.0.0"`	Crates	GitHub
C#	Uruchom komendę: `dotnet add package PELock.PowerShellProObfuscator` lub dodaj do pliku `.csproj`: `<PackageReference Include="PELock.PowerShellProObfuscator" Version="1.0.0" />`	NuGet	GitHub

Przykłady użycia

Obfuskacja z domyślnymi ustawieniami

PowerShell
PHP
Python
JavaScript
Rust
C#

###############################################################################
#
# PowerShell Pro Obfuscator WebApi interface usage example.
#
# In this example we will obfuscate sample source with default options.
#
# Version        : v1.0.0
# Language       : PowerShell
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

# install once:
# Install-Module -Name PowerShellProObfuscator -Scope CurrentUser
# or:
# Install-PSResource -Name PowerShellProObfuscator -Scope CurrentUser

Import-Module PowerShellProObfuscator

#
# source code in PowerShell format
#
$scriptSourceCode = @'
function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"
'@

#
# with an activation code and no strategy switches, all obfuscation options are enabled
#
try
{
    $output = Invoke-PowerShellProObfuscate `
        -Source $scriptSourceCode `
        -ActivationCode 'ABCD-ABCD-ABCD-ABCD'

    #
    # it's also possible to pass a PowerShell script file path instead of a string e.g.
    #
    # Invoke-PowerShellProObfuscate `
    #     -InputFilePath  'C:\path\to\project\script.ps1' `
    #     -OutputFilePath 'C:\path\to\project\script.obfuscated.ps1' `
    #     -ActivationCode 'ABCD-ABCD-ABCD-ABCD'

    Write-Host $output
}
catch
{
    throw "An error occurred while trying to obfuscate the code: $_"
}

<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Version        : v1.0
 * Language       : PHP
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

//
// załącz klasę PowerShell Pro Obfuscator
//
use PELock\PowerShellProObfuscator;

//
// jeśli nie chcesz użyć Composera wykorzystaj include_once
//
//include_once "PowerShellProObfuscator.php";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
$myPowerShellProObfuscator = new PELock\PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie PowerShell
//
$scriptSourceCode = 'function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"';

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
$result = $myPowerShellProObfuscator->ObfuscateScriptSource($scriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// $result = $myPowerShellProObfuscator->ObfuscateScriptFile("/path/to/project/script.ps1");

//
// tablica $result[] zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// $result["error"]         - kod błędu
// $result["output"]        - zobfuskowany kod
// $result["demo"]          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// $result["credits_left"]  - pozostałe kredyty użycia po tej operacji
// $result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
// $result["expired"]       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if ($result !== false)
{
	// wyświetl zobfuskowany kod
	if ($result["error"] === \PELock\PowerShellProObfuscator::ERROR_SUCCESS)
	{
		// sformatuj kod wyjściowy do wyświetlenia w HTML
		echo "<pre>" . htmlentities($result["output"]) . "</pre>";
	}
	else
	{
		die("An error occurred, error code: " . $result["error"]);
	}
}
else
{
	die("Something unexpected happen while trying to obfuscate the code.");
}

?>

#!/usr/bin/env python

###############################################################################
#
# Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
#
# W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
#
# Version        : v1.0.0
# Language       : Python
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

#
# załącz moduł PowerShell Pro Obfuscator
#
from powershellproobfuscator import PowerShellProObfuscator

#
# jeśli nie chcesz użyć modułu Pythona, możesz zaimportować klasę bezpośrednio z pliku
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

#
# kod źródłowy w formacie PowerShell
#
scriptSourceCode = """function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator\""""

#
# domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać
#
result = myPowerShellProObfuscator.obfuscate_script_source(scriptSourceCode)

#
# można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha ze źródłem, np.
#
# result = myPowerShellProObfuscator.obfuscate_script_file("/path/to/project/script.ps1")

#
# tablica result[] zawiera wyniki obfuskacji oraz dodatkowe informacje
#
# result["error"]         - kod błędu
# result["output"]        - zobfuskowany kod
# result["demo"]          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
# result["credits_left"]  - pozostałe kredyty użycia po tej operacji
# result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
# result["expired"]       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na True
#
if result and "error" in result:

    # wyświetl zobfuskowany kod
    if result["error"] == PowerShellProObfuscator.ERROR_SUCCESS:

        # sformatuj kod wyjściowy do wyświetlenia w HTML
        print(result["output"])

    else:
        print(f'An error occurred, error code: {result["error"]}')

else:
    print("Something unexpected happen while trying to obfuscate the code.")

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Version        : v1.0.0
 * Language       : JavaScript
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

import PowerShellProObfuscator from "powershell-pro-obfuscator";

//
// załącz klasę PowerShell Pro Obfuscator
//

//
// podczas pracy z klonem repozytorium bez instalacji paczki użyj:
//
// import PowerShellProObfuscator from "../src/powershell-pro-obfuscator.js";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
const myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie PowerShell
//
const scriptSourceCode = `function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"`;

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
const result = await myPowerShellProObfuscator.obfuscateScriptSource(scriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// const result = await myPowerShellProObfuscator.obfuscateScriptFile("/path/to/project/script.ps1");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result.error         - kod błędu
// result.output        - zobfuskowany kod
// result.demo          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result.credits_left  - pozostałe kredyty użycia po tej operacji
// result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result.expired       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if (result !== null) {
  //
  // wyświetl zobfuskowany kod
  //
  if (result.error === PowerShellProObfuscator.ERROR_SUCCESS) {
    console.log(result.output);
  } else {
    throw new Error("An error occurred, error code: " + result.error);
  }
} else {
  throw new Error("Something unexpected happen while trying to obfuscate the code.");
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * 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>> {
    //
    // załącz klasę PowerShell Pro Obfuscator
    //

    //
    // podczas pracy z klonem repozytorium bez instalacji paczki użyj:
    //
    // use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse};
    // (zależność ścieżkowa w Cargo.toml wskazująca na ten crate)

    //
    // utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
    //
    let my_powershell_pro_obfuscator =
        PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // kod źródłowy w formacie PowerShell
    //
    let script_source_code = r#"function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator""#;

    //
    // domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
    //
    let result = my_powershell_pro_obfuscator
        .obfuscate_script_source(script_source_code, true)
        .await;

    //
    // można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
    //
    // let result = my_powershell_pro_obfuscator
    //     .obfuscate_script_file(std::path::Path::new("/path/to/project/script.ps1"), true)
    //     .await;

    //
    // obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
    //
    // result.error         - kod błędu
    // result.output        - zobfuskowany kod
    // result.demo          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
    // result.credits_left  - pozostałe kredyty użycia po tej operacji
    // result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
    // result.expired       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
    //
    match result {
        Some(PowerShellProObfuscatorResponse::Object(obj)) => {
            //
            // wyświetl zobfuskowany kod
            //
            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(())
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Version        : v1.0.0
 * Language       : C#
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

using PELock.PowerShellProObfuscator;

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
var myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie PowerShell
//
const string ScriptSourceCode =
    """
    function Get-Greeting {
        param([string]$Name)
        Write-Host "Hello World from $Name!"
    }
    Get-Greeting "PowerShell Pro Obfuscator"
    """;

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
var result = await myPowerShellProObfuscator.ObfuscateScriptSourceAsync(ScriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// var result = await myPowerShellProObfuscator.ObfuscateScriptFileAsync("/path/to/project/script.ps1");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result?.Error           - kod błędu (zob. PowerShellProObfuscator.Error*)
// result?.Output          - zobfuskowany kod
// result?.Demo             - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.CreditsLeft      - pozostałe kredyty użycia po tej operacji
// result?.CreditsTotal     - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result?.Expired          - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if (result is not null)
{
    //
    // wyświetl zobfuskowany kod
    //
    if (result.Error == PowerShellProObfuscator.ErrorSuccess && result.Output is not null)
        Console.WriteLine(result.Output);
    else
        throw new InvalidOperationException("An error occurred, error code: " + result.Error);
}
else
{
    throw new InvalidOperationException("Something unexpected happen while trying to obfuscate the code.");
}

Obfuskacja z własnymi ustawieniami

PowerShell
PHP
Python
JavaScript
Rust
C#

###############################################################################
#
# PowerShell Pro Obfuscator WebApi interface usage example.
#
# In this example we will obfuscate sample source with custom options.
#
# Version        : v1.0.0
# Language       : PowerShell
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

# install once:
# Install-Module -Name PowerShellProObfuscator -Scope CurrentUser

Import-Module PowerShellProObfuscator

#
# source code in PowerShell format
#
$scriptSourceCode = @'
function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"
'@

#
# select obfuscation strategies explicitly (only listed switches are enabled)
#
try
{
    $output = Invoke-PowerShellProObfuscate `
        -Source $scriptSourceCode `
        -ActivationCode 'ABCD-ABCD-ABCD-ABCD' `
        -EnableCompression:$false `
        -SelfDefending `
        -ProtectionLinker `
        -RenameVariables `
        -RenameParameters `
        -RenameFunctions `
        -ShuffleFunctions `
        -ControlFlowFlatten `
        -StateMachine `
        -VmStrategy `
        -EncryptIntegers `
        -SplitStrings `
        -EncryptStrings `
        -IntegersToArrays `
        -FloatsToArrays `
        -InsertDeadCode `
        -ComplexifyBooleans `
        -IntegersToFloating `
        -EncryptFloating `
        -DecoyFunctions `
        -DetectDebugger `
        -FakeDotSourceMarkers `
        -OpaqueBranches `
        -ScriptblockDecoys `
        -LiteralPadding `
        -ReflectInvokeCommands `
        -StringCharArrayVault `
        -TryFinallyNoise `
        -AffineIntegerMask `
        -EventStub `
        -RemoveComments

    Write-Host $output
}
catch
{
    throw "An error occurred while trying to obfuscate the code: $_"
}

<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Version        : v1.0
 * Language       : PHP
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

//
// załącz klasę PowerShell Pro Obfuscator
//
use PELock\PowerShellProObfuscator;

//
// jeśli nie chcesz użyć Composera wykorzystaj include_once
//
//include_once "PowerShellProObfuscator.php";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
$myPowerShellProObfuscator = new PELock\PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// czy kod źródłowy ma być kompresowany (wejście i wyjście)
//
$myPowerShellProObfuscator->enableCompression = false;

//
// globalne opcje obfuskacji
//
// możesz globalnie wyłączyć konkretną strategię obfuskacji, jeśli
// zawodzi albo nie chcesz jej używać bez modyfikacji kodów źródłowych
//
// domyślnie wszystkie strategie obfuskacji są włączone
//

//
// ochrona przed ingerencją w chroniony kod (weryfikacja integralności)
//
$myPowerShellProObfuscator->selfDefending = true;

//
// protection linker (fałszywy graf wywołań)
//
$myPowerShellProObfuscator->protectionLinker = true;

//
// zmiana nazw zmiennych na losowe łańcuchy
//
$myPowerShellProObfuscator->renameVariables = true;

//
// zmiana nazw parametrów na losowe łańcuchy
//
$myPowerShellProObfuscator->renameParameters = true;

//
// zmiana nazw funkcji na losowe łańcuchy
//
$myPowerShellProObfuscator->renameFunctions = true;

//
// losowa kolejność funkcji w kodzie wynikowym
//
$myPowerShellProObfuscator->shuffleFunctions = true;

//
// zmiana liniowego przepływu wykonania przez spłaszczenie przepływu sterowania
//
$myPowerShellProObfuscator->controlFlowFlatten = true;

//
// przepisanie bloków instrukcji na automaty skończone (obfuskacja automatem stanów)
//
$myPowerShellProObfuscator->stateMachine = true;

//
// przeniesienie wybranych instrukcji do silnika VM (wirtualizacja instrukcji)
//
$myPowerShellProObfuscator->vmStrategy = true;

//
// szyfrowanie liczb całkowitych
//
$myPowerShellProObfuscator->encryptIntegers = true;

//
// dzielenie łańcuchów na sklejane fragmenty
//
$myPowerShellProObfuscator->splitStrings = true;

//
// szyfrowanie łańcuchów losowo generowanymi polimorficznymi algorytmami
//
$myPowerShellProObfuscator->encryptStrings = true;

//
// przenoszenie liczb całkowitych do tablic
//
$myPowerShellProObfuscator->integersToArrays = true;

//
// przenoszenie liczb zmiennoprzecinkowych do tablic
//
$myPowerShellProObfuscator->floatsToArrays = true;

//
// wstawianie martwego kodu
//
$myPowerShellProObfuscator->insertDeadCode = true;

//
// zastępowanie warunków logicznych równoważnymi złożonymi wyrażeniami
//
$myPowerShellProObfuscator->complexifyBooleans = true;

//
// reprezentacja liczb całkowitych przez operacje zmiennoprzecinkowe
//
$myPowerShellProObfuscator->integersToFloating = true;

//
// szyfrowanie liczb zmiennoprzecinkowych
//
$myPowerShellProObfuscator->encryptFloating = true;

//
// wstawianie funkcji-przynęt
//
$myPowerShellProObfuscator->decoyFunctions = true;

//
// wstawianie detekcji antydebug
//
$myPowerShellProObfuscator->detectDebugger = true;

//
// wstawianie fałszywych komentarzy dot-source
//
$myPowerShellProObfuscator->fakeDotSourceMarkers = true;

//
// wstawianie nieprzezroczystych gałęzi predykatów
//
$myPowerShellProObfuscator->opaqueBranches = true;

//
// wstawianie przynęt ScriptBlock
//
$myPowerShellProObfuscator->scriptblockDecoys = true;

//
// wstawianie wypełnienia here-stringiem
//
$myPowerShellProObfuscator->literalPadding = true;

//
// pośrednie wywoływanie poleceń
//
$myPowerShellProObfuscator->reflectInvokeCommands = true;

//
// przechowywanie fragmentów łańcuchów w skarbcach tablic kodów znaków
//
$myPowerShellProObfuscator->stringCharArrayVault = true;

//
// owijanie kodu w bloki try/finally z martwym szumem
//
$myPowerShellProObfuscator->tryFinallyNoise = true;

//
// stosowanie redundantnych masek xor / afinicznych na liczbach
//
$myPowerShellProObfuscator->affineIntegerMask = true;

//
// wstawianie martwych stubów zdarzeń/timerów
//
$myPowerShellProObfuscator->eventStub = true;

//
// usuwanie komentarzy z kodu wynikowego
//
$myPowerShellProObfuscator->removeComments = true;

//
// kod źródłowy w formacie PowerShell
//
$scriptSourceCode = 'function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"';

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
$result = $myPowerShellProObfuscator->ObfuscateScriptSource($scriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// $result = $myPowerShellProObfuscator->ObfuscateScriptFile("/path/to/project/script.ps1");

//
// tablica $result[] zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// $result["error"]         - kod błędu
// $result["output"]        - zobfuskowany kod
// $result["demo"]          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// $result["credits_left"]  - pozostałe kredyty użycia po tej operacji
// $result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
// $result["expired"]       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if ($result !== false)
{
	// wyświetl zobfuskowany kod
	if ($result["error"] === \PELock\PowerShellProObfuscator::ERROR_SUCCESS)
	{
		// sformatuj kod wyjściowy do wyświetlenia w HTML
		echo "<pre>" . htmlentities($result["output"]) . "</pre>";
	}
	else
	{
		die("An error occurred, error code: " . $result["error"]);
	}
}
else
{
	die("Something unexpected happen while trying to obfuscate the code.");
}

?>

#!/usr/bin/env python

###############################################################################
#
# Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
#
# W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
#
# Version        : v1.0.0
# Language       : Python
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

#
# załącz moduł PowerShell Pro Obfuscator
#
from powershellproobfuscator import PowerShellProObfuscator

#
# jeśli nie chcesz użyć modułu Pythona, możesz zaimportować klasę bezpośrednio z pliku
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

#
# czy kod źródłowy ma być kompresowany (wejście i wyjście)
#
myPowerShellProObfuscator.enableCompression = False

#
# globalne opcje obfuskacji
#
# możesz globalnie wyłączyć konkretną strategię obfuskacji, jeśli
# zawodzi albo nie chcesz jej używać bez modyfikacji kodów źródłowych
#
# domyślnie wszystkie strategie obfuskacji są włączone
#

#
# ochrona przed ingerencją w chroniony kod (weryfikacja integralności)
#
myPowerShellProObfuscator.selfDefending = True

#
# protection linker (fałszywy graf wywołań)
#
myPowerShellProObfuscator.protectionLinker = True

#
# zmiana nazw zmiennych na losowe łańcuchy
#
myPowerShellProObfuscator.renameVariables = True

#
# zmiana nazw parametrów na losowe łańcuchy
#
myPowerShellProObfuscator.renameParameters = True

#
# zmiana nazw funkcji na losowe łańcuchy
#
myPowerShellProObfuscator.renameFunctions = True

#
# losowa kolejność funkcji w kodzie wynikowym
#
myPowerShellProObfuscator.shuffleFunctions = True

#
# zmiana liniowego przepływu wykonania przez spłaszczenie przepływu sterowania
#
myPowerShellProObfuscator.controlFlowFlatten = True

#
# przepisanie bloków instrukcji na automaty skończone (obfuskacja automatem stanów)
#
myPowerShellProObfuscator.stateMachine = True

#
# przeniesienie wybranych instrukcji do silnika VM (wirtualizacja instrukcji)
#
myPowerShellProObfuscator.vmStrategy = True

#
# szyfrowanie liczb całkowitych
#
myPowerShellProObfuscator.encryptIntegers = True

#
# dzielenie łańcuchów na sklejane fragmenty
#
myPowerShellProObfuscator.splitStrings = True

#
# szyfrowanie łańcuchów losowo generowanymi polimorficznymi algorytmami
#
myPowerShellProObfuscator.encryptStrings = True

#
# przenoszenie liczb całkowitych do tablic
#
myPowerShellProObfuscator.integersToArrays = True

#
# przenoszenie liczb zmiennoprzecinkowych do tablic
#
myPowerShellProObfuscator.floatsToArrays = True

#
# wstawianie martwego kodu
#
myPowerShellProObfuscator.insertDeadCode = True

#
# zastępowanie warunków logicznych równoważnymi złożonymi wyrażeniami
#
myPowerShellProObfuscator.complexifyBooleans = True

#
# reprezentacja liczb całkowitych przez operacje zmiennoprzecinkowe
#
myPowerShellProObfuscator.integersToFloating = True

#
# szyfrowanie liczb zmiennoprzecinkowych
#
myPowerShellProObfuscator.encryptFloating = True

#
# wstawianie funkcji-przynęt
#
myPowerShellProObfuscator.decoyFunctions = True

#
# wstawianie detekcji antydebug
#
myPowerShellProObfuscator.detectDebugger = True

#
# wstawianie fałszywych komentarzy dot-source
#
myPowerShellProObfuscator.fakeDotSourceMarkers = True

#
# wstawianie nieprzezroczystych gałęzi predykatów
#
myPowerShellProObfuscator.opaqueBranches = True

#
# wstawianie przynęt ScriptBlock
#
myPowerShellProObfuscator.scriptblockDecoys = True

#
# wstawianie wypełnienia here-stringiem
#
myPowerShellProObfuscator.literalPadding = True

#
# pośrednie wywoływanie poleceń
#
myPowerShellProObfuscator.reflectInvokeCommands = True

#
# przechowywanie fragmentów łańcuchów w skarbcach tablic kodów znaków
#
myPowerShellProObfuscator.stringCharArrayVault = True

#
# owijanie kodu w bloki try/finally z martwym szumem
#
myPowerShellProObfuscator.tryFinallyNoise = True

#
# stosowanie redundantnych masek xor / afinicznych na liczbach
#
myPowerShellProObfuscator.affineIntegerMask = True

#
# wstawianie martwych stubów zdarzeń/timerów
#
myPowerShellProObfuscator.eventStub = True

#
# usuwanie komentarzy z kodu wynikowego
#
myPowerShellProObfuscator.removeComments = True

#
# kod źródłowy w formacie PowerShell
#
scriptSourceCode = """function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator\""""

#
# domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać
#
result = myPowerShellProObfuscator.obfuscate_script_source(scriptSourceCode)

#
# można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha ze źródłem, np.
#
# result = myPowerShellProObfuscator.obfuscate_script_file("/path/to/project/script.ps1")

#
# tablica result[] zawiera wyniki obfuskacji oraz dodatkowe informacje
#
# result["error"]         - kod błędu
# result["output"]        - zobfuskowany kod
# result["demo"]          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
# result["credits_left"]  - pozostałe kredyty użycia po tej operacji
# result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
# result["expired"]       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na True
#
if result and "error" in result:

    # wyświetl zobfuskowany kod
    if result["error"] == PowerShellProObfuscator.ERROR_SUCCESS:

        # sformatuj kod wyjściowy do wyświetlenia w HTML
        print(result["output"])

    else:
        print(f'An error occurred, error code: {result["error"]}')

else:
    print("Something unexpected happen while trying to obfuscate the code.")

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Version        : v1.0.0
 * Language       : JavaScript
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

import PowerShellProObfuscator from "powershell-pro-obfuscator";

//
// załącz klasę PowerShell Pro Obfuscator
//

//
// podczas pracy z klonem repozytorium bez instalacji paczki użyj:
//
// import PowerShellProObfuscator from "../src/powershell-pro-obfuscator.js";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
const myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// czy kod źródłowy ma być kompresowany (wejście i wyjście)
//
myPowerShellProObfuscator.enableCompression = false;

//
// globalne opcje obfuskacji
//
// możesz globalnie wyłączyć konkretną strategię obfuskacji, jeśli
// zawodzi albo nie chcesz jej używać bez modyfikacji kodów źródłowych
//
// domyślnie wszystkie strategie obfuskacji są włączone
//

//
// ochrona przed ingerencją w chroniony kod (weryfikacja integralności)
//
myPowerShellProObfuscator.selfDefending = true;

//
// protection linker (fałszywy graf wywołań)
//
myPowerShellProObfuscator.protectionLinker = true;

//
// zmiana nazw zmiennych na losowe łańcuchy
//
myPowerShellProObfuscator.renameVariables = true;

//
// zmiana nazw parametrów na losowe łańcuchy
//
myPowerShellProObfuscator.renameParameters = true;

//
// zmiana nazw funkcji na losowe łańcuchy
//
myPowerShellProObfuscator.renameFunctions = true;

//
// losowa kolejność funkcji w kodzie wynikowym
//
myPowerShellProObfuscator.shuffleFunctions = true;

//
// zmiana liniowego przepływu wykonania przez spłaszczenie przepływu sterowania
//
myPowerShellProObfuscator.controlFlowFlatten = true;

//
// przepisanie bloków instrukcji na automaty skończone (obfuskacja automatem stanów)
//
myPowerShellProObfuscator.stateMachine = true;

//
// przeniesienie wybranych instrukcji do silnika VM (wirtualizacja instrukcji)
//
myPowerShellProObfuscator.vmStrategy = true;

//
// szyfrowanie liczb całkowitych
//
myPowerShellProObfuscator.encryptIntegers = true;

//
// dzielenie łańcuchów na sklejane fragmenty
//
myPowerShellProObfuscator.splitStrings = true;

//
// szyfrowanie łańcuchów losowo generowanymi polimorficznymi algorytmami
//
myPowerShellProObfuscator.encryptStrings = true;

//
// przenoszenie liczb całkowitych do tablic
//
myPowerShellProObfuscator.integersToArrays = true;

//
// przenoszenie liczb zmiennoprzecinkowych do tablic
//
myPowerShellProObfuscator.floatsToArrays = true;

//
// wstawianie martwego kodu
//
myPowerShellProObfuscator.insertDeadCode = true;

//
// zastępowanie warunków logicznych równoważnymi złożonymi wyrażeniami
//
myPowerShellProObfuscator.complexifyBooleans = true;

//
// reprezentacja liczb całkowitych przez operacje zmiennoprzecinkowe
//
myPowerShellProObfuscator.integersToFloating = true;

//
// szyfrowanie liczb zmiennoprzecinkowych
//
myPowerShellProObfuscator.encryptFloating = true;

//
// wstawianie funkcji-przynęt
//
myPowerShellProObfuscator.decoyFunctions = true;

//
// wstawianie detekcji antydebug
//
myPowerShellProObfuscator.detectDebugger = true;

//
// wstawianie fałszywych komentarzy dot-source
//
myPowerShellProObfuscator.fakeDotSourceMarkers = true;

//
// wstawianie nieprzezroczystych gałęzi predykatów
//
myPowerShellProObfuscator.opaqueBranches = true;

//
// wstawianie przynęt ScriptBlock
//
myPowerShellProObfuscator.scriptblockDecoys = true;

//
// wstawianie wypełnienia here-stringiem
//
myPowerShellProObfuscator.literalPadding = true;

//
// pośrednie wywoływanie poleceń
//
myPowerShellProObfuscator.reflectInvokeCommands = true;

//
// przechowywanie fragmentów łańcuchów w skarbcach tablic kodów znaków
//
myPowerShellProObfuscator.stringCharArrayVault = true;

//
// owijanie kodu w bloki try/finally z martwym szumem
//
myPowerShellProObfuscator.tryFinallyNoise = true;

//
// stosowanie redundantnych masek xor / afinicznych na liczbach
//
myPowerShellProObfuscator.affineIntegerMask = true;

//
// wstawianie martwych stubów zdarzeń/timerów
//
myPowerShellProObfuscator.eventStub = true;

//
// usuwanie komentarzy z kodu wynikowego
//
myPowerShellProObfuscator.removeComments = true;

//
// kod źródłowy w formacie PowerShell
//
const scriptSourceCode = `function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"`;

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
const result = await myPowerShellProObfuscator.obfuscateScriptSource(scriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// const result = await myPowerShellProObfuscator.obfuscateScriptFile("/path/to/project/script.ps1");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result.error         - kod błędu
// result.output        - zobfuskowany kod
// result.demo          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result.credits_left  - pozostałe kredyty użycia po tej operacji
// result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result.expired       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if (result !== null) {
  //
  // wyświetl zobfuskowany kod
  //
  if (result.error === PowerShellProObfuscator.ERROR_SUCCESS) {
    console.log(result.output);
  } else {
    throw new Error("An error occurred, error code: " + result.error);
  }
} else {
  throw new Error("Something unexpected happen while trying to obfuscate the code.");
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * 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>> {
    //
    // załącz klasę PowerShell Pro Obfuscator
    //

    //
    // podczas pracy z klonem repozytorium bez instalacji paczki użyj:
    //
    // use powershell_pro_obfuscator::{PowerShellProObfuscator, PowerShellProObfuscatorResponse};
    // (zależność ścieżkowa w Cargo.toml wskazująca na ten crate)

    //
    // utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
    //
    let mut my_powershell_pro_obfuscator =
        PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // czy kod źródłowy ma być kompresowany (wejście i wyjście)
    //
    my_powershell_pro_obfuscator.enable_compression = false;

    //
    // globalne opcje obfuskacji
    //
    // możesz globalnie wyłączyć konkretną strategię obfuskacji, jeśli
    // zawodzi albo nie chcesz jej używać bez modyfikacji kodów źródłowych
    //
    // domyślnie wszystkie strategie obfuskacji są włączone
    //

    //
    // ochrona przed ingerencją w chroniony kod (weryfikacja integralności)
    //
    my_powershell_pro_obfuscator.self_defending = true;

    //
    // protection linker (fałszywy graf wywołań)
    //
    my_powershell_pro_obfuscator.protection_linker = true;

    //
    // zmiana nazw zmiennych na losowe łańcuchy
    //
    my_powershell_pro_obfuscator.rename_variables = true;

    //
    // zmiana nazw parametrów na losowe łańcuchy
    //
    my_powershell_pro_obfuscator.rename_parameters = true;

    //
    // zmiana nazw funkcji na losowe łańcuchy
    //
    my_powershell_pro_obfuscator.rename_functions = true;

    //
    // losowa kolejność funkcji w kodzie wynikowym
    //
    my_powershell_pro_obfuscator.shuffle_functions = true;

    //
    // zmiana liniowego przepływu wykonania przez spłaszczenie przepływu sterowania
    //
    my_powershell_pro_obfuscator.control_flow_flatten = true;

    //
    // przepisanie bloków instrukcji na automaty skończone (obfuskacja automatem stanów)
    //
    my_powershell_pro_obfuscator.state_machine = true;

    //
    // przeniesienie wybranych instrukcji do silnika VM (wirtualizacja instrukcji)
    //
    my_powershell_pro_obfuscator.vm_strategy = true;

    //
    // szyfrowanie liczb całkowitych
    //
    my_powershell_pro_obfuscator.encrypt_integers = true;

    //
    // dzielenie łańcuchów na sklejane fragmenty
    //
    my_powershell_pro_obfuscator.split_strings = true;

    //
    // szyfrowanie łańcuchów losowo generowanymi polimorficznymi algorytmami
    //
    my_powershell_pro_obfuscator.encrypt_strings = true;

    //
    // przenoszenie liczb całkowitych do tablic
    //
    my_powershell_pro_obfuscator.integers_to_arrays = true;

    //
    // przenoszenie liczb zmiennoprzecinkowych do tablic
    //
    my_powershell_pro_obfuscator.floats_to_arrays = true;

    //
    // wstawianie martwego kodu
    //
    my_powershell_pro_obfuscator.insert_dead_code = true;

    //
    // zastępowanie warunków logicznych równoważnymi złożonymi wyrażeniami
    //
    my_powershell_pro_obfuscator.complexify_booleans = true;

    //
    // reprezentacja liczb całkowitych przez operacje zmiennoprzecinkowe
    //
    my_powershell_pro_obfuscator.integers_to_floating = true;

    //
    // szyfrowanie liczb zmiennoprzecinkowych
    //
    my_powershell_pro_obfuscator.encrypt_floating = true;

    //
    // wstawianie funkcji-przynęt
    //
    my_powershell_pro_obfuscator.decoy_functions = true;

    //
    // wstawianie detekcji antydebug
    //
    my_powershell_pro_obfuscator.detect_debugger = true;

    //
    // wstawianie fałszywych komentarzy dot-source
    //
    my_powershell_pro_obfuscator.fake_dot_source_markers = true;

    //
    // wstawianie nieprzezroczystych gałęzi predykatów
    //
    my_powershell_pro_obfuscator.opaque_branches = true;

    //
    // wstawianie przynęt ScriptBlock
    //
    my_powershell_pro_obfuscator.scriptblock_decoys = true;

    //
    // wstawianie wypełnienia here-stringiem
    //
    my_powershell_pro_obfuscator.literal_padding = true;

    //
    // pośrednie wywoływanie poleceń
    //
    my_powershell_pro_obfuscator.reflect_invoke_commands = true;

    //
    // przechowywanie fragmentów łańcuchów w skarbcach tablic kodów znaków
    //
    my_powershell_pro_obfuscator.string_char_array_vault = true;

    //
    // owijanie kodu w bloki try/finally z martwym szumem
    //
    my_powershell_pro_obfuscator.try_finally_noise = true;

    //
    // stosowanie redundantnych masek xor / afinicznych na liczbach
    //
    my_powershell_pro_obfuscator.affine_integer_mask = true;

    //
    // wstawianie martwych stubów zdarzeń/timerów
    //
    my_powershell_pro_obfuscator.event_stub = true;

    //
    // usuwanie komentarzy z kodu wynikowego
    //
    my_powershell_pro_obfuscator.remove_comments = true;

    //
    // kod źródłowy w formacie PowerShell
    //
    let script_source_code = r#"function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator""#;

    //
    // domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
    //
    let result = my_powershell_pro_obfuscator
        .obfuscate_script_source(script_source_code, true)
        .await;

    //
    // można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
    //
    // let result = my_powershell_pro_obfuscator
    //     .obfuscate_script_file(std::path::Path::new("/path/to/project/script.ps1"), true)
    //     .await;

    //
    // obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
    //
    // result.error         - kod błędu
    // result.output        - zobfuskowany kod
    // result.demo          - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
    // result.credits_left  - pozostałe kredyty użycia po tej operacji
    // result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
    // result.expired       - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
    //
    match result {
        Some(PowerShellProObfuscatorResponse::Object(obj)) => {
            //
            // wyświetl zobfuskowany kod
            //
            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(())
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Version        : v1.0.0
 * Language       : C#
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

using PELock.PowerShellProObfuscator;

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
var myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// czy kod źródłowy ma być kompresowany (wejście i wyjście)
//
myPowerShellProObfuscator.EnableCompression = false;

//
// globalne opcje obfuskacji
//
// możesz globalnie wyłączyć konkretną strategię obfuskacji, jeśli
// zawodzi albo nie chcesz jej używać bez modyfikacji kodów źródłowych
//
// domyślnie wszystkie strategie obfuskacji są włączone
//

//
// ochrona przed ingerencją w chroniony kod (weryfikacja integralności)
//
myPowerShellProObfuscator.SelfDefending = true;

//
// protection linker (fałszywy graf wywołań)
//
myPowerShellProObfuscator.ProtectionLinker = true;

//
// zmiana nazw zmiennych na losowe łańcuchy
//
myPowerShellProObfuscator.RenameVariables = true;

//
// zmiana nazw parametrów na losowe łańcuchy
//
myPowerShellProObfuscator.RenameParameters = true;

//
// zmiana nazw funkcji na losowe łańcuchy
//
myPowerShellProObfuscator.RenameFunctions = true;

//
// losowa kolejność funkcji w kodzie wynikowym
//
myPowerShellProObfuscator.ShuffleFunctions = true;

//
// zmiana liniowego przepływu wykonania przez spłaszczenie przepływu sterowania
//
myPowerShellProObfuscator.ControlFlowFlatten = true;

//
// przepisanie bloków instrukcji na automaty skończone (obfuskacja automatem stanów)
//
myPowerShellProObfuscator.StateMachine = true;

//
// przeniesienie wybranych instrukcji do silnika VM (wirtualizacja instrukcji)
//
myPowerShellProObfuscator.VmStrategy = true;

//
// szyfrowanie liczb całkowitych
//
myPowerShellProObfuscator.EncryptIntegers = true;

//
// dzielenie łańcuchów na sklejane fragmenty
//
myPowerShellProObfuscator.SplitStrings = true;

//
// szyfrowanie łańcuchów losowo generowanymi polimorficznymi algorytmami
//
myPowerShellProObfuscator.EncryptStrings = true;

//
// przenoszenie liczb całkowitych do tablic
//
myPowerShellProObfuscator.IntegersToArrays = true;

//
// przenoszenie liczb zmiennoprzecinkowych do tablic
//
myPowerShellProObfuscator.FloatsToArrays = true;

//
// wstawianie martwego kodu
//
myPowerShellProObfuscator.InsertDeadCode = true;

//
// zastępowanie warunków logicznych równoważnymi złożonymi wyrażeniami
//
myPowerShellProObfuscator.ComplexifyBooleans = true;

//
// reprezentacja liczb całkowitych przez operacje zmiennoprzecinkowe
//
myPowerShellProObfuscator.IntegersToFloating = true;

//
// szyfrowanie liczb zmiennoprzecinkowych
//
myPowerShellProObfuscator.EncryptFloating = true;

//
// wstawianie funkcji-przynęt
//
myPowerShellProObfuscator.DecoyFunctions = true;

//
// wstawianie detekcji antydebug
//
myPowerShellProObfuscator.DetectDebugger = true;

//
// wstawianie fałszywych komentarzy dot-source
//
myPowerShellProObfuscator.FakeDotSourceMarkers = true;

//
// wstawianie nieprzezroczystych gałęzi predykatów
//
myPowerShellProObfuscator.OpaqueBranches = true;

//
// wstawianie przynęt ScriptBlock
//
myPowerShellProObfuscator.ScriptblockDecoys = true;

//
// wstawianie wypełnienia here-stringiem
//
myPowerShellProObfuscator.LiteralPadding = true;

//
// pośrednie wywoływanie poleceń
//
myPowerShellProObfuscator.ReflectInvokeCommands = true;

//
// przechowywanie fragmentów łańcuchów w skarbcach tablic kodów znaków
//
myPowerShellProObfuscator.StringCharArrayVault = true;

//
// owijanie kodu w bloki try/finally z martwym szumem
//
myPowerShellProObfuscator.TryFinallyNoise = true;

//
// stosowanie redundantnych masek xor / afinicznych na liczbach
//
myPowerShellProObfuscator.AffineIntegerMask = true;

//
// wstawianie martwych stubów zdarzeń/timerów
//
myPowerShellProObfuscator.EventStub = true;

//
// usuwanie komentarzy z kodu wynikowego
//
myPowerShellProObfuscator.RemoveComments = true;

//
// kod źródłowy w formacie PowerShell
//
const string ScriptSourceCode =
    """
    function Get-Greeting {
        param([string]$Name)
        Write-Host "Hello World from $Name!"
    }
    Get-Greeting "PowerShell Pro Obfuscator"
    """;

//
// domyślnie wszystkie opcje obfuskacji są włączone, więc wystarczy wywołać:
//
var result = await myPowerShellProObfuscator.ObfuscateScriptSourceAsync(ScriptSourceCode);

//
// można też podać ścieżkę do pliku skryptu PowerShell zamiast łańcucha, np.
//
// var result = await myPowerShellProObfuscator.ObfuscateScriptFileAsync("/path/to/project/script.ps1");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result?.Error           - kod błędu (zob. PowerShellProObfuscator.Error*)
// result?.Output          - zobfuskowany kod
// result?.Demo             - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.CreditsLeft      - pozostałe kredyty użycia po tej operacji
// result?.CreditsTotal     - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result?.Expired          - jeśli to był ostatni kredyt użycia klucza, wartość zostanie ustawiona na true
//
if (result is not null)
{
    //
    // wyświetl zobfuskowany kod
    //
    if (result.Error == PowerShellProObfuscator.ErrorSuccess && result.Output is not null)
        Console.WriteLine(result.Output);
    else
        throw new InvalidOperationException("An error occurred, error code: " + result.Error);
}
else
{
    throw new InvalidOperationException("Something unexpected happen while trying to obfuscate the code.");
}

Sprawdzanie klucza aktywacyjnego

PowerShell
PHP
Python
JavaScript
Rust
C#

###############################################################################
#
# PowerShell Pro Obfuscator WebApi interface usage example.
#
# In this example we will verify our activation key status.
#
# Version        : v1.0.0
# Language       : PowerShell
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

# install once:
# Install-Module -Name PowerShellProObfuscator -Scope CurrentUser

Import-Module PowerShellProObfuscator

#
# login to the service
#
try
{
    $result = Connect-PowerShellProObfuscator -ActivationCode 'ABCD-ABCD-ABCD-ABCD'

    #
    # $result 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)
    #
    Write-Host ("Demo version status - {0}" -f $result.demo)
    Write-Host ("Usage credits left - {0}" -f $result.credits_left)
    Write-Host ("Total usage credits - {0}" -f $result.credits_total)
    Write-Host ("Max. source code size - {0}" -f $result.string_limit)
}
catch
{
    throw "Something unexpected happen while trying to login to the service: $_"
}

<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Version        : v1.0
 * Language       : PHP
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

//
// załącz klasę PowerShell Pro Obfuscator
//
use PELock\PowerShellProObfuscator;

//
// jeśli nie chcesz użyć Composera wykorzystaj include_once
//
//include_once "PowerShellProObfuscator.php";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
$myPowerShellProObfuscator = new PELock\PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// zaloguj się do usługi
//
$result = $myPowerShellProObfuscator->Login();

//
// tablica $result[] zawiera informacje o licencji
//
// $result["demo"]          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// $result["credits_left"]  - pozostałe kredyty użycia po tej operacji
// $result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
// $result["string_limit"]  - maks. dozwolony rozmiar kodu źródłowego (dla trybu demo to 1000 bajtów)
//
if ($result !== false)
{
	echo "Demo version status - " . ($result["demo"] ? "true" : "false") . "<br>";
	echo "Usage credits left - " . $result["credits_left"] . "<br>";
	echo "Total usage credits - " . $result["credits_total"] . "<br>";
	echo "Max. source code size - " . $result["string_limit"] . "<br>";
}
else
{
	die("Something unexpected happen while trying to login to the service.");
}

?>

#!/usr/bin/env python

###############################################################################
#
# Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
#
# W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
#
# Version        : v1.0.0
# Language       : Python
# Author         : Bartosz Wójcik
# Web page       : https://www.pelock.com
#
###############################################################################

#
# załącz moduł PowerShell Pro Obfuscator
#
from powershellproobfuscator import PowerShellProObfuscator

#
# jeśli nie chcesz użyć modułu Pythona, możesz zaimportować klasę bezpośrednio z pliku
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

#
# zaloguj się do usługi
#
result = myPowerShellProObfuscator.login()

#
# tablica result[] zawiera informacje o licencji
#
# result["demo"]          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# result["credits_left"]  - pozostałe kredyty użycia po tej operacji
# result["credits_total"] - całkowita liczba kredytów dla tego kodu aktywacyjnego
# result["string_limit"]  - maks. dozwolony rozmiar kodu źródłowego (dla trybu demo to 1000 bajtów)
#
if result:

    print(f'Demo version status - {"True" if result["demo"] else "False"}')
    print(f'Usage credits left - {result["credits_left"]}')
    print(f'Total usage credits - {result["credits_total"]}')
    print(f'Max. source code size - {result["string_limit"]}')

else:
    print("Something unexpected happen while trying to login to the service.")

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Version        : v1.0.0
 * Language       : JavaScript
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

import PowerShellProObfuscator from "powershell-pro-obfuscator";

//
// załącz klasę PowerShell Pro Obfuscator
//

//
// podczas pracy z klonem repozytorium bez instalacji paczki użyj:
//
// import PowerShellProObfuscator from "../src/powershell-pro-obfuscator.js";

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
const myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// zaloguj się do usługi
//
const result = await myPowerShellProObfuscator.login();

//
// obiekt result zawiera informacje o licencji
//
// result.demo          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result.credits_left  - pozostałe kredyty użycia po tej operacji
// result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result.string_limit  - maks. dozwolony rozmiar kodu źródłowego (dla trybu demo to 1000 bajtów)
//
if (result !== null) {
  console.log("Demo version status - " + (result.demo ? "true" : "false"));
  console.log("Usage credits left - " + result.credits_left);
  console.log("Total usage credits - " + result.credits_total);
  console.log("Max. source code size - " + result.string_limit);
} else {
  throw new Error("Something unexpected happen while trying to login to the service.");
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * 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>> {
    //
    // załącz klasę PowerShell Pro Obfuscator
    //

    //
    // jeśli nie chcesz używać crates.io, dodaj zależność ścieżkową do tego crate'a
    //
    // [dependencies]
    // powershell-pro-obfuscator = { path = ".." }

    //
    // utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
    //
    let my_powershell_pro_obfuscator =
        PowerShellProObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // zaloguj się do usługi
    //
    let result = my_powershell_pro_obfuscator.login(true).await;

    //
    // obiekt result zawiera informacje o licencji
    //
    // result.demo          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
    // result.credits_left  - pozostałe kredyty użycia po tej operacji
    // result.credits_total - całkowita liczba kredytów dla tego kodu aktywacyjnego
    // result.string_limit  - maks. dozwolony rozmiar kodu źródłowego (dla trybu demo to 1000 bajtów)
    //
    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(())
}

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Version        : v1.0.0
 * Language       : C#
 * Author         : Bartosz Wójcik
 * Web page       : https://www.pelock.com
 *
 *****************************************************************************/

using PELock.PowerShellProObfuscator;

//
// utwórz instancję klasy PowerShell Pro Obfuscator (do inicjalizacji wykorzystamy nasz klucz aktywacyjny)
//
var myPowerShellProObfuscator = new PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// zaloguj się do usługi
//
var result = await myPowerShellProObfuscator.LoginAsync();

//
// obiekt result zawiera informacje o licencji
//
// result?.Demo           - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.CreditsLeft    - pozostałe kredyty użycia po tej operacji
// result?.CreditsTotal    - całkowita liczba kredytów dla tego kodu aktywacyjnego
// result?.StringLimit     - maks. dozwolony rozmiar kodu źródłowego (dla trybu demo to 1000 bajtów)
//
if (result is not null)
{
    Console.WriteLine("Demo version status - " + (result.Demo == true ? "true" : "false"));
    Console.WriteLine("Usage credits left - " + result.CreditsLeft);
    Console.WriteLine("Total usage credits - " + result.CreditsTotal);
    Console.WriteLine("Max. source code size - " + result.StringLimit);
}
else
{
    throw new InvalidOperationException("Something unexpected happen while trying to login to the service.");
}

Pola żądania obfuskacji (`command=obfuscate`)

Oprócz key i source możesz wysłać compression (wartość logiczna). Poza trybem demo każda strategia to osobne pole POST (domyślnie false, chyba że klient wyśle true/1/yes):

Pola strategii
`self_defending` (CLI `--self-defending`)	`protection_linker` (CLI `--protection-linker`)
`rename_variables`	`rename_parameters`
`rename_functions`	`shuffle_functions`
`control_flow_flatten`	`state_machine` (CLI `--state-machine`)
`vm_strategy`	`encrypt_integers`
`split_strings`	`encrypt_strings`
`integers_to_arrays`	`floats_to_arrays`
`insert_dead_code`	`complexify_booleans`
`integers_to_floating`	`encrypt_floating`
`decoy_functions`	`detect_debugger` (CLI `--detect-debugger`)
`fake_dot_source_markers`	`opaque_branches`
`scriptblock_decoys`	`literal_padding`
`reflect_invoke_commands`	`string_char_array_vault`
`try_finally_noise`	`affine_integer_mask`
`event_stub`	`remove_comments` (przekazuje `--remove-comments` do CLI, gdy aktywna jest co najmniej jedna strategia)

Serwer dodaje --remove-comments tylko wtedy, gdy włączono co najmniej jedną strategię oraz remove_comments jest true. Aktualne CLI nie udostępnia przełącznika zachowującego komentarze; API nie oferuje osobnego pola w tym celu.

Zwracane wartości

$result["error"] [wyj]: Kod błędu. Jeden z poniższych:
$result["output"] [wyj, opcjonalnie]: Wyjściowy kod źródłowy poddany obfuskacji.
$result["demo"] [wyj]: Flaga oznaczająca czy to wersja pełna czy demo.
$result["credits_left"] [wyj]: Pozostała ilość kredytów użycia dla przypisanego kodu aktywacyjnego.
$result["credits_total"] [wyj]: Całkowita ilość kredytów dla przypisanego kodu aktywacyjnego.
$result["expired"] [wyj, opcjonalnie]: Jeśli ustawiona na true oznacza to, że kod aktywacyjny wygasł (było to jego ostatnie wykorzystanie).
$result["string_limit"] [wyj, opcjonalnie]: Maksymalny dozwolony rozmiar wejściowego kodu źródłowego dla wersji pełnej i demo.

Nazwa	Wartość	Opis
ERROR_SUCCESS	`0`	Wszystko się udało.
ERROR_INPUT_SIZE	`1`	Kod źródłowy jest zbyt duży. Najczęściej zwracana wartość w przypadku działania w trybie demo (limit 1000 znaków).
ERROR_INPUT	`2`	Uszkodzony wejściowy kod źródłowy, sprawdź składnię.
ERROR_PARSING	`3`	Błąd parsowania kodu źródłowego PowerShell.
ERROR_OBFUSCATION	`4`	Błąd obfuskacji sparsowanego już kodu źródłowego PowerShell.
ERROR_OUTPUT	`5`	Błąd podczas generowania zobfuskowanego kodu wyjściowego PowerShell.

Wymagania

Moduł PowerShell	PowerShellProObfuscator
Biblioteka PHP	PowerShellProObfuscator
Moduł dla Pythona 3	PowerShellProObfuscator
Moduł JavaScript	PowerShellProObfuscator
Crate dla Rusta	PowerShellProObfuscator
Biblioteka C# / .NET	PELock.PowerShellProObfuscator

Masz pytania?

Jeśli chcesz zapytać o PowerShell Pro Obfuscator albo coś jest niejasne, napisz do nas. Chętnie odpowiemy na Twoje pytania.

PELock

.netshrink

JObfuscator

PowerShell Pro Obfuscator

AutoIt Obfuscator

Obfuscator

Silnik Polimorficzny Poly

Social Media Bot

String Encrypt

Dekoder AZTec

Kalkulator Kodów Radiowych API i SDK

Renault i Dacia Kalkulator Kodu Radia

Ford Kod Do Radia M Seria Kalkulator

Ford Kod Do Radia V Seria Kalkulator

Ford TravelPilot EX, FX i NX Generator

Toyota ERC Kalkulator

Jeep Cherokee Kod Do Radia

Chrysler Panasonic Kalkulator Kodu Radia

Kod do radia Chrysler Dodge Ram

Fiat Stilo & Bravo Kalkulator Kodu Radia

Fiat DAIICHI Kalkulator Kodu Radiowego

Continental Fiat 250 i 500 VP1/VP2

Kalkulator Kodu Eclipse ESN

Kod Do Radia Jaguar Alpine

Nissan Kalkulator PIN Kodu

Hash Kalkulator

Steganografia Kodek Online

Konwerter Unixowego Czasu

Dekoder haseł Total Commander

PUBG Mobile Kodek i Dekoder

Dekoder haseł GG

Inżynieria wsteczna

Projektowanie Reklam i UI/UX

Artykuły

Źródła

Domeny

Opinie Klientów

Kontakt