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.

Te same funkcje są dostępne także przez interfejs REST. GET /api/powershell-pro-obfuscator/v1/license sprawdza klucz aktywacyjny. POST /api/powershell-pro-obfuscator/v1/obfuscate obfuskuje skrypt. Klucz przekaż w nagłówku Authorization: Bearer albo X-Api-Key. Skrypt wyślij jako część multipart o nazwie file, a opcje tymi samymi nazwami pól co w API POST. Udane wywołanie zwraca bajty skryptu jako obfuscated.ps1. Status i dane licencji są w nagłówku X-PELock-Result. REST nie przyjmuje compression ani pola source.

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, pkg.go.dev, RubyGems). Kody źródłowe zostały dodatkowo opublikowane na GitHubie:

Repozytorium Język Instalacja Paczka Źródła
PowerShell Gallery PowerShell

Uruchom komendę:

Install-Module -Name PowerShellProObfuscator

lub:

Install-PSResource -Name PowerShellProObfuscator

 PowerShell Gallery GitHub
Repozytorium Packagist dla PHP i Composera 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
Repozytorium PyPI dla Pythona i pip Python pip install powershell-pro-obfuscator PyPI GitHub
Repozytorium npm dla JavaScript 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
Repozytorium crates.io dla Rusta 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
Repozytorium NuGet C#

Uruchom komendę:

dotnet add package PELock.PowerShellProObfuscator

lub dodaj do pliku .csproj:

<PackageReference Include="PELock.PowerShellProObfuscator" Version="1.0.0" />
 NuGet GitHub
Pakiety modułów Go Go

Uruchom:

go get github.com/PELock/PowerShell-Pro-Obfuscator-Go

lub dodaj poniższy wpis do pliku go.mod

require github.com/PELock/PowerShell-Pro-Obfuscator-Go v1.0.0
 Go GitHub
Repozytorium RubyGems Ruby

Uruchom:

gem install powershell-pro-obfuscator

lub dodaj poniższy wpis do pliku Gemfile

gem "powershell-pro-obfuscator"
 RubyGems GitHub

Przykłady użycia

Obfuskacja z domyślnymi ustawieniami

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie obfuskujemy przykładowy kod z domyślnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

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

Import-Module PowerShellProObfuscator

#
# 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"
'@

#
# przy kodzie aktywacyjnym i bez przełączników strategii wszystkie opcje obfuskacji są włączone
#
try
{
    $output = Invoke-PowerShellProObfuscate `
        -Source $scriptSourceCode `
        -ActivationCode 'ABCD-ABCD-ABCD-ABCD'

    #
    # można też podać ścieżkę do skryptu PowerShell zamiast ciągu, np.
    #
    # 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 "Wystąpił błąd podczas obfuskacji kodu: $_"
}
<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Wersja        : v1.0
 * Język       : PHP
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " . $result["error"]);
	}
}
else
{
	die("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}

?>
#!/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.
#
# Wersja        : v1.0.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Strona       : 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'Wystąpił błąd, kod błędu: {result["error"]}')

else:
    print("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.")
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Wersja        : v1.0.0
 * Język       : JavaScript
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " + result.error);
  }
} else {
  throw new Error("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z domyślnymi ustawieniami.
 *
 * Wersja        : v1.0.0
 * Język       : Rust
 * Autor         : Bartosz Wójcik
 * Strona       : 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!("Wystąpił błąd, kod błędu: {}", obj.error).into(),
                );
            }
        }
        Some(PowerShellProObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.".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.
 *
 * Wersja        : v1.0.0
 * Język       : C#
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " + result.Error);
}
else
{
    throw new InvalidOperationException("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie obfuskujemy przykładowy kod z domyślnymi opcjami.
 *
 * Wersja        : v1.0.0
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	powershellproobfuscator "github.com/PELock/PowerShell-Pro-Obfuscator-Go"
)

func main() {
	client := powershellproobfuscator.New("ABCD-ABCD-ABCD-ABCD")

	source := `function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"`

	result, err := client.ObfuscateScriptSource(context.Background(), source)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if result.Error != powershellproobfuscator.ErrorSuccess {
		fmt.Fprintf(os.Stderr, "Wystąpił błąd, kod błędu: %d\n", result.Error)
		os.Exit(1)
	}
	fmt.Println(result.Output)
}

# frozen_string_literal: true

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie obfuskujemy przykładowy kod z domyślnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
require "powershell-pro-obfuscator"

client = PowerShellProObfuscator.new("ABCD-ABCD-ABCD-ABCD")

source = <<~PS
  function Get-Greeting {
      param([string]$Name)
      Write-Host "Hello World from $Name!"
  }
  Get-Greeting "PowerShell Pro Obfuscator"
PS

result = client.obfuscate_script_source(source)
if result && result["error"] == PowerShellProObfuscator::ERROR_SUCCESS
  puts result["output"]
else
  warn "Wystąpił błąd, kod błędu: #{result && result['error']}"
end

#!/usr/bin/env bash

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu REST.
#
# W tym przykładzie obfuskujemy przykładowy kod z domyślnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# plik źródłowy
#
cat > script.ps1 << 'SRC'
function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"
SRC

#
# domyślnie klient włącza każdą strategię obfuskacji, w tym
# samoochronę i linker ochrony. Kompresja pozostaje wyłączona.
# Serwer zostawia strategię wyłączoną, dopóki pole nie ma wartości 1.
# REST nie przyjmuje compression ani ciągu source. Skrypt jest
# multipart part named file.

#
# response body    - obfuscated script
# X-PELock-Result  - status JSON obok skryptu:
#
# error          - kod błędu (0 = sukces)
# demo           - tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# credits_left   - pozostałe kredyty użycia po tej operacji
# credits_total  - całkowita liczba kredytów dla tego kodu aktywacyjnego
# expired        - true, gdy to wywołanie zużyło ostatni kredyt
#
# nieudana obfuskacja to HTTP 422 i treść JSON zamiast skryptu
curl -sS -D - -o obfuscated.ps1 \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@script.ps1" \
  -F "self_defending=1" \
  -F "protection_linker=1" \
  -F "rename_variables=1" \
  -F "rename_parameters=1" \
  -F "rename_functions=1" \
  -F "shuffle_functions=1" \
  -F "control_flow_flatten=1" \
  -F "state_machine=1" \
  -F "vm_strategy=1" \
  -F "encrypt_integers=1" \
  -F "split_strings=1" \
  -F "encrypt_strings=1" \
  -F "integers_to_arrays=1" \
  -F "floats_to_arrays=1" \
  -F "insert_dead_code=1" \
  -F "complexify_booleans=1" \
  -F "integers_to_floating=1" \
  -F "encrypt_floating=1" \
  -F "decoy_functions=1" \
  -F "detect_debugger=1" \
  -F "fake_dot_source_markers=1" \
  -F "opaque_branches=1" \
  -F "scriptblock_decoys=1" \
  -F "literal_padding=1" \
  -F "reflect_invoke_commands=1" \
  -F "string_char_array_vault=1" \
  -F "try_finally_noise=1" \
  -F "affine_integer_mask=1" \
  -F "event_stub=1" \
  -F "remove_comments=1" \
  "https://www.pelock.com/api/powershell-pro-obfuscator/v1/obfuscate"

Obfuskacja z własnymi ustawieniami

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie obfuskujemy przykładowy kod z własnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

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

Import-Module PowerShellProObfuscator

#
# 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"
'@

#
# wybierz strategie obfuskacji jawnie (włączone są tylko wymienione przełączniki)
#
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 "Wystąpił błąd podczas obfuskacji kodu: $_"
}
<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Wersja        : v1.0
 * Język       : PHP
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " . $result["error"]);
	}
}
else
{
	die("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}

?>
#!/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.
#
# Wersja        : v1.0.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Strona       : 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'Wystąpił błąd, kod błędu: {result["error"]}')

else:
    print("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.")
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Wersja        : v1.0.0
 * Język       : JavaScript
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " + result.error);
  }
} else {
  throw new Error("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie kod PowerShell poddany zostanie obfuskacji z własnymi ustawieniami.
 *
 * Wersja        : v1.0.0
 * Język       : Rust
 * Autor         : Bartosz Wójcik
 * Strona       : 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!("Wystąpił błąd, kod błędu: {}", obj.error).into(),
                );
            }
        }
        Some(PowerShellProObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.".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.
 *
 * Wersja        : v1.0.0
 * Język       : C#
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Wystąpił błąd, kod błędu: " + result.Error);
}
else
{
    throw new InvalidOperationException("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie obfuskujemy przykładowy kod z własnymi opcjami.
 *
 * Wersja        : v1.0.0
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	powershellproobfuscator "github.com/PELock/PowerShell-Pro-Obfuscator-Go"
)

func main() {
	client := powershellproobfuscator.New("ABCD-ABCD-ABCD-ABCD")

	// czy kompresować kod źródłowy (zarówno wejście, jak i wyjście)
	client.EnableCompression = false

	//
	// globalne opcje obfuskacji
	//
	// wybraną strategię obfuskacji możesz wyłączyć globalnie, jeśli
	// zawiedzie albo nie chcesz go używać bez zmian w kodzie źródłowym
	//
	// domyślnie wszystkie strategie obfuskacji są włączone
	//

	// ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
	client.SelfDefending = true

	// linker ochrony (wabikowy graf wywołań)
	client.ProtectionLinker = true

	// zmieniaj nazwy zmiennych na losowe ciągi znaków
	client.RenameVariables = true

	// zmieniaj nazwy parametrów na losowe ciągi znaków
	client.RenameParameters = true

	// zmieniaj nazwy funkcji na losowe ciągi znaków
	client.RenameFunctions = true

	// wymieszaj kolejność funkcji w wyjściowym kodzie
	client.ShuffleFunctions = true

	// zamień liniowy przepływ wykonania przez spłaszczenie przepływu sterowania
	client.ControlFlowFlatten = true

	// rewrite statement blocks into finite-state automata (state-machine obfuscation)
	client.StateMachine = true

	// lift selected statements into a VM engine (virtualized statements)
	client.VMStrategy = true

	// szyfruj liczby całkowite
	client.EncryptIntegers = true

	// split strings into concatenated chunks
	client.SplitStrings = true

	// szyfruj ciągi znaków losowo generowanymi polimorficznymi algorytmami
	client.EncryptStrings = true

	// move integers to arrays
	client.IntegersToArrays = true

	// move floats to arrays
	client.FloatsToArrays = true

	// wstaw martwy kod
	client.InsertDeadCode = true

	// zastąp warunki logiczne równoważnymi złożonymi wyrażeniami
	client.ComplexifyBooleans = true

	// represent integers via floating-point math
	client.IntegersToFloating = true

	// szyfruj liczby zmiennoprzecinkowe
	client.EncryptFloating = true

	// wstaw funkcje-wabiki
	client.DecoyFunctions = true

	// wstaw wykrywanie debuggera
	client.DetectDebugger = true

	// wstaw fałszywe znaczniki komentarzy dot-source
	client.FakeDotSourceMarkers = true

	// wstaw gałęzie z nieprzezroczystymi predykatami
	client.OpaqueBranches = true

	// wstaw wabiki bloków skryptu
	client.ScriptblockDecoys = true

	// wstaw wypełnienie here-string
	client.LiteralPadding = true

	// use indirect command invocation
	client.ReflectInvokeCommands = true

	// przechowuj fragmenty ciągów w sejfach tablic kodów znaków
	client.StringCharArrayVault = true

	// opakuj kod w bloki try/finally z martwym szumem
	client.TryFinallyNoise = true

	// apply redundant xor / affine integer masks
	client.AffineIntegerMask = true

	// wstaw martwe zaślepki zdarzeń i timerów
	client.EventStub = true

	// usuń komentarze z wyjściowego kodu
	client.RemoveComments = true

	source := `function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"`

	result, err := client.ObfuscateScriptSource(context.Background(), source)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if result.Error != powershellproobfuscator.ErrorSuccess {
		fmt.Fprintf(os.Stderr, "Wystąpił błąd, kod błędu: %d\n", result.Error)
		os.Exit(1)
	}
	fmt.Println(result.Output)
}

# frozen_string_literal: true

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie obfuskujemy przykładowy kod z własnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
require "powershell-pro-obfuscator"

client = PowerShellProObfuscator.new("ABCD-ABCD-ABCD-ABCD")

# czy kompresować kod źródłowy (zarówno wejście, jak i wyjście)
client.enable_compression = false

#
# globalne opcje obfuskacji
#
# wybraną strategię obfuskacji możesz wyłączyć globalnie, jeśli
# zawiedzie albo nie chcesz go używać bez zmian w kodzie źródłowym
#
# domyślnie wszystkie strategie obfuskacji są włączone
#

# ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
client.self_defending = true

# linker ochrony (wabikowy graf wywołań)
client.protection_linker = true

# zmieniaj nazwy zmiennych na losowe ciągi znaków
client.rename_variables = true

# zmieniaj nazwy parametrów na losowe ciągi znaków
client.rename_parameters = true

# zmieniaj nazwy funkcji na losowe ciągi znaków
client.rename_functions = true

# wymieszaj kolejność funkcji w wyjściowym kodzie
client.shuffle_functions = true

# zamień liniowy przepływ wykonania przez spłaszczenie przepływu sterowania
client.control_flow_flatten = true

# rewrite statement blocks into finite-state automata (state-machine obfuscation)
client.state_machine = true

# lift selected statements into a VM engine (virtualized statements)
client.vm_strategy = true

# szyfruj liczby całkowite
client.encrypt_integers = true

# split strings into concatenated chunks
client.split_strings = true

# szyfruj ciągi znaków losowo generowanymi polimorficznymi algorytmami
client.encrypt_strings = true

# move integers to arrays
client.integers_to_arrays = true

# move floats to arrays
client.floats_to_arrays = true

# wstaw martwy kod
client.insert_dead_code = true

# zastąp warunki logiczne równoważnymi złożonymi wyrażeniami
client.complexify_booleans = true

# represent integers via floating-point math
client.integers_to_floating = true

# szyfruj liczby zmiennoprzecinkowe
client.encrypt_floating = true

# wstaw funkcje-wabiki
client.decoy_functions = true

# wstaw wykrywanie debuggera
client.detect_debugger = true

# wstaw fałszywe znaczniki komentarzy dot-source
client.fake_dot_source_markers = true

# wstaw gałęzie z nieprzezroczystymi predykatami
client.opaque_branches = true

# wstaw wabiki bloków skryptu
client.scriptblock_decoys = true

# wstaw wypełnienie here-string
client.literal_padding = true

# use indirect command invocation
client.reflect_invoke_commands = true

# przechowuj fragmenty ciągów w sejfach tablic kodów znaków
client.string_char_array_vault = true

# opakuj kod w bloki try/finally z martwym szumem
client.try_finally_noise = true

# apply redundant xor / affine integer masks
client.affine_integer_mask = true

# wstaw martwe zaślepki zdarzeń i timerów
client.event_stub = true

# usuń komentarze z wyjściowego kodu
client.remove_comments = true

source = <<~PS
  function Get-Greeting {
      param([string]$Name)
      Write-Host "Hello World from $Name!"
  }
  Get-Greeting "PowerShell Pro Obfuscator"
PS

result = client.obfuscate_script_source(source)
if result && result["error"] == PowerShellProObfuscator::ERROR_SUCCESS
  puts result["output"]
else
  warn "Wystąpił błąd, kod błędu: #{result && result['error']}"
end

#!/usr/bin/env bash

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu REST.
#
# W tym przykładzie obfuskujemy przykładowy kod z własnymi opcjami.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# plik źródłowy
#
cat > script.ps1 << 'SRC'
function Get-Greeting {
    param([string]$Name)
    Write-Host "Hello World from $Name!"
}
Get-Greeting "PowerShell Pro Obfuscator"
SRC

#
# domyślnie klient włącza każdą strategię obfuskacji, w tym
# samoochronę i linker ochrony. Kompresja pozostaje wyłączona.
# Serwer zostawia strategię wyłączoną, dopóki pole nie ma wartości 1.
# REST nie przyjmuje compression ani ciągu source. Skrypt jest
# multipart part named file.

#
# response body    - obfuscated script
# X-PELock-Result  - status JSON obok skryptu:
#
# error          - kod błędu (0 = sukces)
# demo           - tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# credits_left   - pozostałe kredyty użycia po tej operacji
# credits_total  - całkowita liczba kredytów dla tego kodu aktywacyjnego
# expired        - true, gdy to wywołanie zużyło ostatni kredyt
#
# nieudana obfuskacja to HTTP 422 i treść JSON zamiast skryptu
curl -sS -D - -o obfuscated.ps1 \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@script.ps1" \
  -F "self_defending=1" \
  -F "protection_linker=1" \
  -F "rename_variables=1" \
  -F "rename_parameters=1" \
  -F "rename_functions=1" \
  -F "shuffle_functions=1" \
  -F "control_flow_flatten=1" \
  -F "state_machine=1" \
  -F "vm_strategy=1" \
  -F "encrypt_integers=1" \
  -F "split_strings=1" \
  -F "encrypt_strings=1" \
  -F "integers_to_arrays=1" \
  -F "floats_to_arrays=1" \
  -F "insert_dead_code=1" \
  -F "complexify_booleans=1" \
  -F "integers_to_floating=1" \
  -F "encrypt_floating=1" \
  -F "decoy_functions=1" \
  -F "detect_debugger=1" \
  -F "fake_dot_source_markers=1" \
  -F "opaque_branches=1" \
  -F "scriptblock_decoys=1" \
  -F "literal_padding=1" \
  -F "reflect_invoke_commands=1" \
  -F "string_char_array_vault=1" \
  -F "try_finally_noise=1" \
  -F "affine_integer_mask=1" \
  -F "event_stub=1" \
  -F "remove_comments=1" \
  "https://www.pelock.com/api/powershell-pro-obfuscator/v1/obfuscate"

Sprawdzanie klucza aktywacyjnego

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

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

Import-Module PowerShellProObfuscator

#
# logowanie do usługi
#
try
{
    $result = Connect-PowerShellProObfuscator -ActivationCode 'ABCD-ABCD-ABCD-ABCD'

    #
    # $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 (w trybie demo to 1000 bajtów)
    #
    Write-Host ("Status wersji demonstracyjnej - {0}" -f $result.demo)
    Write-Host ("Pozostałe kredyty użycia - {0}" -f $result.credits_left)
    Write-Host ("Łączna liczba kredytów użycia - {0}" -f $result.credits_total)
    Write-Host ("Maks. rozmiar kodu źródłowego - {0}" -f $result.string_limit)
}
catch
{
    throw "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego: $_"
}
<?php

/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Wersja        : v1.0
 * Język       : PHP
 * Autor         : Bartosz Wójcik
 * Strona       : 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 "Status wersji demonstracyjnej - " . ($result["demo"] ? "true" : "false") . "<br>";
	echo "Pozostałe kredyty użycia - " . $result["credits_left"] . "<br>";
	echo "Łączna liczba kredytów użycia - " . $result["credits_total"] . "<br>";
	echo "Maks. rozmiar kodu źródłowego - " . $result["string_limit"] . "<br>";
}
else
{
	die("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
}

?>
#!/usr/bin/env python

###############################################################################
#
# Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
#
# W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
#
# Wersja        : v1.0.0
# Język       : Python
# Autor         : Bartosz Wójcik
# Strona       : 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'Status wersji demonstracyjnej - {"True" if result["demo"] else "False"}')
    print(f'Pozostałe kredyty użycia - {result["credits_left"]}')
    print(f'Łączna liczba kredytów użycia - {result["credits_total"]}')
    print(f'Maks. rozmiar kodu źródłowego - {result["string_limit"]}')

else:
    print("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.")
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Wersja        : v1.0.0
 * Język       : JavaScript
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Status wersji demonstracyjnej - " + (result.demo ? "true" : "false"));
  console.log("Pozostałe kredyty użycia - " + result.credits_left);
  console.log("Łączna liczba kredytów użycia - " + result.credits_total);
  console.log("Maks. rozmiar kodu źródłowego - " + result.string_limit);
} else {
  throw new Error("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Wersja        : v1.0.0
 * Język       : Rust
 * Autor         : Bartosz Wójcik
 * Strona       : 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!(
                "Status wersji demonstracyjnej - {}",
                if obj.demo.unwrap_or(false) {
                    "true"
                } else {
                    "false"
                }
            );
            println!(
                "Pozostałe kredyty użycia - {}",
                obj.credits_left.unwrap_or(0)
            );
            println!(
                "Łączna liczba kredytów użycia - {}",
                obj.credits_total.unwrap_or(0)
            );
            println!(
                "Maks. rozmiar kodu źródłowego - {}",
                obj.string_limit.unwrap_or(0)
            );
        }
        Some(PowerShellProObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.".into());
        }
    }

    Ok(())
}
/******************************************************************************
 * Przykład użycia PowerShell Pro Obfuscatora poprzez interfejs WebApi.
 *
 * W tym przykładzie sprawdzimy status naszego klucza aktywacyjnego.
 *
 * Wersja        : v1.0.0
 * Język       : C#
 * Autor         : Bartosz Wójcik
 * Strona       : 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("Status wersji demonstracyjnej - " + (result.Demo == true ? "true" : "false"));
    Console.WriteLine("Pozostałe kredyty użycia - " + result.CreditsLeft);
    Console.WriteLine("Łączna liczba kredytów użycia - " + result.CreditsTotal);
    Console.WriteLine("Maks. rozmiar kodu źródłowego - " + result.StringLimit);
}
else
{
    throw new InvalidOperationException("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
}
/******************************************************************************
 * PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja        : v1.0.0
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	powershellproobfuscator "github.com/PELock/PowerShell-Pro-Obfuscator-Go"
)

func main() {
	client := powershellproobfuscator.New("ABCD-ABCD-ABCD-ABCD")
	result, err := client.Login(context.Background())
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	fmt.Printf("Status wersji demonstracyjnej - %v\n", result.Demo)
	fmt.Printf("Pozostałe kredyty użycia - %d\n", result.CreditsLeft)
	fmt.Printf("Łączna liczba kredytów użycia - %d\n", result.CreditsTotal)
	fmt.Printf("Maks. rozmiar kodu źródłowego - %d\n", result.StringLimit)
}

# frozen_string_literal: true

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
require "powershell-pro-obfuscator"

result = PowerShellProObfuscator.new("ABCD-ABCD-ABCD-ABCD").login
if result
  puts "Status wersji demonstracyjnej - #{result['demo']}"
  puts "Pozostałe kredyty użycia - #{result['credits_left']}"
  puts "Łączna liczba kredytów użycia - #{result['credits_total']}"
  puts "Maks. rozmiar kodu źródłowego - #{result['string_limit']}"
else
  warn "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego."
end

#!/usr/bin/env bash

###############################################################################
#
# PowerShell Pro Obfuscator — przykład użycia interfejsu REST.
#
# W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# logowanie do usługi
#
# Treść JSON:
#
# demo           - tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# credits_left   - pozostałe kredyty użycia
# credits_total  - całkowita liczba kredytów dla tego kodu aktywacyjnego
# string_limit   - maks. rozmiar kodu źródłowego
# expired        - false on a login check

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/powershell-pro-obfuscator/v1/license"

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_variablesrename_parameters
rename_functionsshuffle_functions
control_flow_flattenstate_machine (CLI --state-machine)
vm_strategyencrypt_integers
split_stringsencrypt_strings
integers_to_arraysfloats_to_arrays
insert_dead_codecomplexify_booleans
integers_to_floatingencrypt_floating
decoy_functionsdetect_debugger (CLI --detect-debugger)
fake_dot_source_markersopaque_branches
scriptblock_decoysliteral_padding
reflect_invoke_commandsstring_char_array_vault
try_finally_noiseaffine_integer_mask
event_stubremove_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:
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.
$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.

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.