Python Obfuscator Dokumentacja API

<?php

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

//
// include Python Obfuscator class
//
use PELock\PythonObfuscator;

//
// jeśli nie chcesz używać Composera, użyj include_once
//
//include_once "PythonObfuscator.php";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
$myPythonObfuscator = new PELock\PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie Python
//
$scriptSourceCode = "label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
";

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

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// $result = $myPythonObfuscator->ObfuscateScriptFile("/path/to/project/script.py");

//
// 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["license_expiration"] - data końca licencji (Y-m-d), pusta jeśli brak
// $result["usages_total"]  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if ($result !== false)
{
	// wyświetl zobfuskowany kod
	if ($result["error"] === \PELock\PythonObfuscator::ERROR_SUCCESS)
	{
		// sformatuj wyjściowy kod 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.");
}

?>

/******************************************************************************
 * Python 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       : JavaScript
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import PythonObfuscator from "python-obfuscator";

//
// include Python Obfuscator class
//

//
// podczas pracy z klonem repozytorium, bez instalacji pakietu, użyj:
//
// import PythonObfuscator from "../src/python-obfuscator.js";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
const myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie Python
//
const scriptSourceCode = `label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
`;

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

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// const result = await myPythonObfuscator.obfuscateScriptFile("/path/to/project/script.py");

//
// 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.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
// result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if (result !== null) {
  //
  // wyświetl zobfuskowany kod
  //
  if (result.error === PythonObfuscator.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.");
}

/******************************************************************************
 * Python 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       : Rust
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

use python_obfuscator::{PythonObfuscator, PythonObfuscatorResponse};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    //
    // include Python Obfuscator class
    //

    //
    // podczas pracy z klonem repozytorium, bez instalacji pakietu, użyj:
    //
    // use python_obfuscator::{PythonObfuscator, PythonObfuscatorResponse};
    // (zależność ścieżki w Cargo.toml wskazująca na tę skrzynkę)

    //
    // utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
    //
    let my_python_obfuscator =
        PythonObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // kod źródłowy w formacie Python
    //
    let script_source_code = r#"label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)"#;

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

    //
    // można też podać ścieżkę do skryptu Python zamiast ciągu, np.
    //
    // let result = my_python_obfuscator
    //     .obfuscate_script_file(std::path::Path::new("/path/to/project/script.py"), 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.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
    // result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
    //
    match result {
        Some(PythonObfuscatorResponse::Object(obj)) => {
            //
            // wyświetl zobfuskowany kod
            //
            if obj.error == PythonObfuscator::ERROR_SUCCESS {
                println!("{}", obj.output.unwrap_or_default());
            } else {
                return Err(
                    format!("Wystąpił błąd, kod błędu: {}", obj.error).into(),
                );
            }
        }
        Some(PythonObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.".into());
        }
    }

    Ok(())
}

/******************************************************************************
 * Python 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       : C#
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

using PELock.PythonObfuscator;

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
var myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// kod źródłowy w formacie Python
//
const string ScriptSourceCode =
    """
    label = 'SecretKey'
    port = 443

    def get_sum(a, b):
        return a + b

    print(label, port)
    r = get_sum(11, 31)
    print(r)
    """;

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

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// var result = await myPythonObfuscator.ObfuscateScriptFileAsync("/path/to/project/script.py");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result?.Error           - kod błędu (zob. PythonObfuscator.Error*)
// result?.Output          - zobfuskowany kod
// result?.Demo             - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.LicenseExpiration - data końca licencji (Y-m-d), pusta jeśli brak
// result?.UsagesTotal     - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if (result is not null)
{
    //
    // wyświetl zobfuskowany kod
    //
    if (result.Error == PythonObfuscator.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.");
}

################################################################################
#
# Python 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
#
################################################################################

#
# dołącz moduł Python Obfuscator
#
using module PythonObfuscator

#
# utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
#
$myPythonObfuscator = [PythonObfuscator]::new('ABCD-ABCD-ABCD-ABCD')

#
# kod źródłowy w formacie Python
#
$scriptSourceCode = @'
label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
'@

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

#
# można też podać ścieżkę do skryptu Python zamiast ciągu ze źródłem, np.
#
# $result = $myPythonObfuscator.ObfuscateScriptFile('/path/to/project/script.py')

#
# $result zawiera wyniki obfuskacji oraz dodatkowe informacje
#
# $result.error              - kod błędu
# $result.output             - zobfuskowany kod
# $result.demo               - tryb demo (pusty lub nieprawidłowy klucz); flagi strategii są ignorowane; zawsze integers_to_arrays, mba_binops, encrypt_strings (bez wirtualizacji; limit 1000 znaków)
# $result.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
# $result.usages_total       - łączna liczba obfuskacji dla tego kodu aktywacyjnego
#
if ($result -and $null -ne $result.PSObject.Properties['error']) {

    # wyświetl zobfuskowany kod
    if ($result.error -eq [PythonObfuscator]::ERROR_SUCCESS) {

        Write-Host $result.output

    }
    else {
        Write-Host ("Wystąpił błąd, kod błędu: {0}" -f $result.error)
    }

}
else {
    Write-Host 'Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.'
}

/******************************************************************************
 * Python 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"

	pythonobfuscator "github.com/PELock/Python-Obfuscator-Go"
)

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

	source := `label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

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

/******************************************************************************
 * Python 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       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.pythonobfuscator.PythonObfuscator;
import com.pelock.pythonobfuscator.PythonObfuscatorResult;

public class PythonObfuscatorExampleSimple {

  public static void main(String[] args) throws Exception {
    PythonObfuscator client = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

    String scriptSourceCode =
        "label = 'SecretKey'\n"
            + "port = 443\n"
            + "\n"
            + "def get_sum(a, b):\n"
            + "    return a + b\n"
            + "\n"
            + "print(label, port)\n"
            + "r = get_sum(11, 31)\n"
            + "print(r)\n";

    PythonObfuscatorResult result = client.obfuscateScriptSource(scriptSourceCode);
    if (result != null && result.isSuccess() && result.getOutput() != null) {
      System.out.println(result.getOutput());
    } else {
      throw new IllegalStateException(
          "Wystąpił błąd, kod błędu: " + (result == null ? "null" : result.getError()));
    }
  }
}

# frozen_string_literal: true

###############################################################################
#
# Python Obfuscator — opcje domyślne
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "python-obfuscator"

client = PythonObfuscator.new("ABCD-ABCD-ABCD-ABCD")
source = <<~PY
  label = 'SecretKey'
  port = 443

  def get_sum(a, b):
      return a + b

  print(label, port)
  r = get_sum(11, 31)
  print(r)
PY

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

#!/usr/bin/env bash

###############################################################################
#
# Python 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"

#
# kod źródłowy w formacie Python
#
cat > script.py << 'PY'
label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
PY

#
# domyślnie klient włącza każdą strategię obfuskacji i VM
# wirtualizację. Serwer zostawia strategię wyłączoną, dopóki pole nie ma wartości 1.
# Protection flags stay off, so they are omitted.
#
# REST nie przyjmuje compression ani ciągu source. Skrypt jest
# multipart part named file.
#
# response body    - zobfuskowany skrypt, zapisany jako obfuscated.py
# X-PELock-Result  - status JSON obok skryptu:
#
# error               - kod błędu (0 = sukces)
# demo                - tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# license_expiration  - data końca licencji (Y-m-d), pusta jeśli brak
# usages_total        - łączna liczba obfuskacji dla tego kodu aktywacyjnego
#
# nieudana obfuskacja to HTTP 422 i treść JSON zamiast skryptu
#
curl -sS -D - -o obfuscated.py \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@script.py" \
  -F "code_virtualization=vm" \
  -F "rename_variables=1" \
  -F "rename_parameters=1" \
  -F "rename_functions=1" \
  -F "rename_function_calls=1" \
  -F "shuffle_functions=1" \
  -F "resolve_constants=1" \
  -F "split_strings=1" \
  -F "modify_strings=1" \
  -F "encrypt_strings=1" \
  -F "string_char_array_vault=1" \
  -F "encrypt_integers=1" \
  -F "encrypt_floating=1" \
  -F "mba_binops=1" \
  -F "integers_to_floating=1" \
  -F "integers_to_arrays=1" \
  -F "floats_to_arrays=1" \
  -F "affine_integer_mask=1" \
  -F "array_int_crypt=1" \
  -F "array_char_crypt=1" \
  -F "array_double_crypt=1" \
  -F "array_string_crypt=1" \
  -F "insert_random_value_bucket=1" \
  -F "random_bucket_integers=1" \
  -F "random_bucket_arrays=1" \
  -F "random_bucket_functions=1" \
  -F "random_bucket_characters=1" \
  -F "random_bucket_anti_regex=1" \
  -F "random_bucket_autostart=1" \
  -F "insert_ternary_operators=1" \
  -F "complexify_booleans=1" \
  -F "opaque_branches=1" \
  -F "opaque_mixer_chain=1" \
  -F "insert_dead_code=1" \
  -F "try_finally_noise=1" \
  -F "decoy_functions=1" \
  -F "lambda_decoys=1" \
  -F "literal_padding=1" \
  -F "fake_import_markers=1" \
  -F "dynamic_getattr_calls=1" \
  -F "obfuscate_imports=1" \
  -F "callback_registration_stubs=1" \
  -F "remove_comments=1" \
  "https://www.pelock.com/api/python-obfuscator/v1/obfuscate"

<?php

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

//
// include Python Obfuscator class
//
use PELock\PythonObfuscator;
use PELock\PythonObfuscator\CodeVirtualization;

//
// jeśli nie chcesz używać Composera, użyj include_once
//
//include_once "PythonObfuscator.php";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
$myPythonObfuscator = new PELock\PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// czy kompresować kod źródłowy (zarówno wejście, jak i wyjście)
//
$myPythonObfuscator->enableCompression = false;

//
// tryb wirtualizacji kodu (dokładnie jeden): VM, FSA albo FLAT
// pomiń albo ustaw null, aby pominąć wirtualizację
//
$myPythonObfuscator->codeVirtualization = CodeVirtualization::VM;


//
// 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
//

//
// stałe ziarno losowe dla powtarzalnego wyniku obfuskacji (opcjonalne)
//
$myPythonObfuscator->seed = null;

//
// randomization density / intensity (0-100)
//
$myPythonObfuscator->randomizationDensity = null;

//
// identifier renaming style: "il", "homoglyph" or "hex"
//
$myPythonObfuscator->renameStyle = null;

//
// ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
//
$myPythonObfuscator->selfDefending = false;

//
// linker ochrony (wabikowy graf wywołań)
//
$myPythonObfuscator->protectionLinker = false;

//
// zmieniaj nazwy zmiennych na losowe ciągi znaków
//
$myPythonObfuscator->renameVariables = true;

//
// zmieniaj nazwy parametrów na losowe ciągi znaków
//
$myPythonObfuscator->renameParameters = true;

//
// zmieniaj nazwy funkcji na losowe ciągi znaków
//
$myPythonObfuscator->renameFunctions = true;

//
// zmień odwołania do wywołań funkcji zgodnie ze zmienionymi nazwami funkcji
//
$myPythonObfuscator->renameFunctionCalls = true;

//
// wymieszaj kolejność funkcji w wyjściowym kodzie
//
$myPythonObfuscator->shuffleFunctions = true;

//
// fold/resolve constant expressions at obfuscation time
//
$myPythonObfuscator->resolveConstants = true;

//
//
// split strings into concatenated chunks
//
$myPythonObfuscator->splitStrings = true;

//
// zastosuj lekkie przekształcenia i mutacje literałów tekstowych
//
$myPythonObfuscator->modifyStrings = true;

//
// szyfruj ciągi znaków losowo generowanymi polimorficznymi algorytmami
//
$myPythonObfuscator->encryptStrings = true;

//
// przechowuj fragmenty ciągów w sejfach tablic kodów znaków
//
$myPythonObfuscator->stringCharArrayVault = true;

//
// szyfruj liczby całkowite
//
$myPythonObfuscator->encryptIntegers = true;

//
// szyfruj liczby zmiennoprzecinkowe
//
$myPythonObfuscator->encryptFloating = true;

//
// zastąp operatory binarne równoważnikami mieszanej arytmetyki boolowskiej (MBA)
//
$myPythonObfuscator->mbaBinops = true;

//
// represent integers via floating-point math
//
$myPythonObfuscator->integersToFloating = true;

//
// move integers to arrays
//
$myPythonObfuscator->integersToArrays = true;

//
// move floats to arrays
//
$myPythonObfuscator->floatsToArrays = true;

//
// apply redundant xor / affine integer masks
//
$myPythonObfuscator->affineIntegerMask = true;

//
// szyfruj literały tablic liczb całkowitych
//
$myPythonObfuscator->arrayIntCrypt = true;

//
// szyfruj literały tablic znaków
//
$myPythonObfuscator->arrayCharCrypt = true;

//
// szyfruj literały tablic zmiennoprzecinkowych
//
$myPythonObfuscator->arrayDoubleCrypt = true;

//
// szyfruj literały tablic ciągów znaków
//
$myPythonObfuscator->arrayStringCrypt = true;

//
// wstaw wspólny kubełek losowego szumu używany przez inne strategie
//
$myPythonObfuscator->insertRandomValueBucket = true;

//
// wypełnij kubełek losowych wartości liczbami-wabikami
//
$myPythonObfuscator->randomBucketIntegers = true;

//
// wypełnij kubełek losowych wartości tablicami-wabikami
//
$myPythonObfuscator->randomBucketArrays = true;

//
// wypełnij kubełek losowych wartości funkcjami-wabikami
//
$myPythonObfuscator->randomBucketFunctions = true;

//
// wypełnij kubełek losowych wartości znakami-wabikami
//
$myPythonObfuscator->randomBucketCharacters = true;

//
// wypełnij kubełek losowych wartości szumem antyregex
//
$myPythonObfuscator->randomBucketAntiRegex = true;

//
// wypełnij kubełek losowych wartości zaślepkami autostartu
//
$myPythonObfuscator->randomBucketAutostart = true;

//
// rewrite selected statements using ternary operators
//
$myPythonObfuscator->insertTernaryOperators = true;

//
// zastąp warunki logiczne równoważnymi złożonymi wyrażeniami
//
$myPythonObfuscator->complexifyBooleans = true;

//
// wstaw gałęzie z nieprzezroczystymi predykatami
//
$myPythonObfuscator->opaqueBranches = true;

//
// wstaw łańcuchy nieprzezroczystych mikserów do przepływu sterowania
//
$myPythonObfuscator->opaqueMixerChain = true;

//
// wstaw martwy kod
//
$myPythonObfuscator->insertDeadCode = true;

//
// opakuj kod w bloki try/finally z martwym szumem
//
$myPythonObfuscator->tryFinallyNoise = true;

//
// wstaw funkcje-wabiki
//
$myPythonObfuscator->decoyFunctions = true;

//
// wstaw wyrażenia lambda-wabiki
//
$myPythonObfuscator->lambdaDecoys = true;

//
// wstaw szum wypełniający literały
//
$myPythonObfuscator->literalPadding = true;

//
// wstaw fałszywe znaczniki instrukcji import
//
$myPythonObfuscator->fakeImportMarkers = true;

//
// use dynamic getattr()-based indirect calls
//
$myPythonObfuscator->dynamicGetattrCalls = true;

//
// rewrite absolute imports into __import__ / getattr
//
$myPythonObfuscator->obfuscateImports = true;

//
// wstaw martwe zaślepki rejestracji wywołań zwrotnych i zdarzeń
//
$myPythonObfuscator->callbackRegistrationStubs = true;

//
// wstaw wykrywanie debuggera
//
$myPythonObfuscator->detectDebugger = false;

//
// wstaw wykrywanie maszyn wirtualnych (anti-VM)
//
$myPythonObfuscator->antiVm = false;

//
// wstaw wykrywanie piaskownicy
//
$myPythonObfuscator->antiSandbox = false;

//
// wstaw wykrywanie emulatorów (CPU)
//
$myPythonObfuscator->antiEmulator = false;

//
// usuń komentarze z wyjściowego kodu
//
$myPythonObfuscator->removeComments = true;

//
// kod źródłowy w formacie Python
//
$scriptSourceCode = "label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
";

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

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// $result = $myPythonObfuscator->ObfuscateScriptFile("/path/to/project/script.py");

//
// 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["license_expiration"] - data końca licencji (Y-m-d), pusta jeśli brak
// $result["usages_total"]  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if ($result !== false)
{
	// wyświetl zobfuskowany kod
	if ($result["error"] === \PELock\PythonObfuscator::ERROR_SUCCESS)
	{
		// sformatuj wyjściowy kod 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.");
}

?>

/******************************************************************************
 * Python 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       : JavaScript
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import PythonObfuscator, { CodeVirtualization } from "python-obfuscator";

//
// include Python Obfuscator class
//

//
// podczas pracy z klonem repozytorium, bez instalacji pakietu, użyj:
//
// import PythonObfuscator from "../src/python-obfuscator.js";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
const myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

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

//
// tryb wirtualizacji kodu (dokładnie jeden): VM, FSA albo FLAT
// pomiń albo ustaw null, aby pominąć wirtualizację
//
myPythonObfuscator.codeVirtualization = CodeVirtualization.VM;


//
// 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
//

//
// stałe ziarno losowe dla powtarzalnego wyniku obfuskacji (opcjonalne)
//
myPythonObfuscator.seed = null;

//
// randomization density / intensity (0-100)
//
myPythonObfuscator.randomizationDensity = null;

//
// identifier renaming style: "il", "homoglyph" or "hex"
//
myPythonObfuscator.renameStyle = null;

//
// ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
//
myPythonObfuscator.selfDefending = false;

//
// linker ochrony (wabikowy graf wywołań)
//
myPythonObfuscator.protectionLinker = false;

//
// zmieniaj nazwy zmiennych na losowe ciągi znaków
//
myPythonObfuscator.renameVariables = true;

//
// zmieniaj nazwy parametrów na losowe ciągi znaków
//
myPythonObfuscator.renameParameters = true;

//
// zmieniaj nazwy funkcji na losowe ciągi znaków
//
myPythonObfuscator.renameFunctions = true;

//
// zmień odwołania do wywołań funkcji zgodnie ze zmienionymi nazwami funkcji
//
myPythonObfuscator.renameFunctionCalls = true;

//
// wymieszaj kolejność funkcji w wyjściowym kodzie
//
myPythonObfuscator.shuffleFunctions = true;

//
// fold/resolve constant expressions at obfuscation time
//
myPythonObfuscator.resolveConstants = true;

//
//
// split strings into concatenated chunks
//
myPythonObfuscator.splitStrings = true;

//
// zastosuj lekkie przekształcenia i mutacje literałów tekstowych
//
myPythonObfuscator.modifyStrings = true;

//
// szyfruj ciągi znaków losowo generowanymi polimorficznymi algorytmami
//
myPythonObfuscator.encryptStrings = true;

//
// przechowuj fragmenty ciągów w sejfach tablic kodów znaków
//
myPythonObfuscator.stringCharArrayVault = true;

//
// szyfruj liczby całkowite
//
myPythonObfuscator.encryptIntegers = true;

//
// szyfruj liczby zmiennoprzecinkowe
//
myPythonObfuscator.encryptFloating = true;

//
// zastąp operatory binarne równoważnikami mieszanej arytmetyki boolowskiej (MBA)
//
myPythonObfuscator.mbaBinops = true;

//
// represent integers via floating-point math
//
myPythonObfuscator.integersToFloating = true;

//
// move integers to arrays
//
myPythonObfuscator.integersToArrays = true;

//
// move floats to arrays
//
myPythonObfuscator.floatsToArrays = true;

//
// apply redundant xor / affine integer masks
//
myPythonObfuscator.affineIntegerMask = true;

//
// szyfruj literały tablic liczb całkowitych
//
myPythonObfuscator.arrayIntCrypt = true;

//
// szyfruj literały tablic znaków
//
myPythonObfuscator.arrayCharCrypt = true;

//
// szyfruj literały tablic zmiennoprzecinkowych
//
myPythonObfuscator.arrayDoubleCrypt = true;

//
// szyfruj literały tablic ciągów znaków
//
myPythonObfuscator.arrayStringCrypt = true;

//
// wstaw wspólny kubełek losowego szumu używany przez inne strategie
//
myPythonObfuscator.insertRandomValueBucket = true;

//
// wypełnij kubełek losowych wartości liczbami-wabikami
//
myPythonObfuscator.randomBucketIntegers = true;

//
// wypełnij kubełek losowych wartości tablicami-wabikami
//
myPythonObfuscator.randomBucketArrays = true;

//
// wypełnij kubełek losowych wartości funkcjami-wabikami
//
myPythonObfuscator.randomBucketFunctions = true;

//
// wypełnij kubełek losowych wartości znakami-wabikami
//
myPythonObfuscator.randomBucketCharacters = true;

//
// wypełnij kubełek losowych wartości szumem antyregex
//
myPythonObfuscator.randomBucketAntiRegex = true;

//
// wypełnij kubełek losowych wartości zaślepkami autostartu
//
myPythonObfuscator.randomBucketAutostart = true;

//
// rewrite selected statements using ternary operators
//
myPythonObfuscator.insertTernaryOperators = true;

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

//
// wstaw gałęzie z nieprzezroczystymi predykatami
//
myPythonObfuscator.opaqueBranches = true;

//
// wstaw łańcuchy nieprzezroczystych mikserów do przepływu sterowania
//
myPythonObfuscator.opaqueMixerChain = true;

//
// wstaw martwy kod
//
myPythonObfuscator.insertDeadCode = true;

//
// opakuj kod w bloki try/finally z martwym szumem
//
myPythonObfuscator.tryFinallyNoise = true;

//
// wstaw funkcje-wabiki
//
myPythonObfuscator.decoyFunctions = true;

//
// wstaw wyrażenia lambda-wabiki
//
myPythonObfuscator.lambdaDecoys = true;

//
// wstaw szum wypełniający literały
//
myPythonObfuscator.literalPadding = true;

//
// wstaw fałszywe znaczniki instrukcji import
//
myPythonObfuscator.fakeImportMarkers = true;

//
// use dynamic getattr()-based indirect calls
//
myPythonObfuscator.dynamicGetattrCalls = true;

//
// rewrite absolute imports into __import__ / getattr
//
myPythonObfuscator.obfuscateImports = true;

//
// wstaw martwe zaślepki rejestracji wywołań zwrotnych i zdarzeń
//
myPythonObfuscator.callbackRegistrationStubs = true;

//
// wstaw wykrywanie debuggera
//
myPythonObfuscator.detectDebugger = false;

//
// wstaw wykrywanie maszyn wirtualnych (anti-VM)
//
myPythonObfuscator.antiVm = false;

//
// wstaw wykrywanie piaskownicy
//
myPythonObfuscator.antiSandbox = false;

//
// wstaw wykrywanie emulatorów (CPU)
//
myPythonObfuscator.antiEmulator = false;

//
// usuń komentarze z wyjściowego kodu
//
myPythonObfuscator.removeComments = true;

//
// kod źródłowy w formacie Python
//
const scriptSourceCode = `label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
`;

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

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// const result = await myPythonObfuscator.obfuscateScriptFile("/path/to/project/script.py");

//
// 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.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
// result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if (result !== null) {
  //
  // wyświetl zobfuskowany kod
  //
  if (result.error === PythonObfuscator.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.");
}

/******************************************************************************
 * Python 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       : Rust
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

use python_obfuscator::{CodeVirtualization, PythonObfuscator, PythonObfuscatorResponse};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    //
    // include Python Obfuscator class
    //

    //
    // podczas pracy z klonem repozytorium, bez instalacji pakietu, użyj:
    //
    // use python_obfuscator::{PythonObfuscator, PythonObfuscatorResponse};
    // (zależność ścieżki w Cargo.toml wskazująca na tę skrzynkę)

    //
    // utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
    //
    let mut my_python_obfuscator =
        PythonObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

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

    //
    // tryb wirtualizacji kodu (dokładnie jeden): Vm, Fsa albo Flat
    // pomiń albo ustaw None, aby pominąć wirtualizację
    //
    my_python_obfuscator.code_virtualization = CodeVirtualization::Vm;


    //
    // 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
    //

    //
    // stałe ziarno losowe dla powtarzalnego wyniku obfuskacji (opcjonalne)
    //
    my_python_obfuscator.seed = None;

    //
    // randomization density / intensity (0-100)
    //
    my_python_obfuscator.randomization_density = None;

    //
    // identifier renaming style: "il", "homoglyph" or "hex"
    //
    my_python_obfuscator.rename_style = None;

    //
    // ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
    //
    my_python_obfuscator.self_defending = false;

    //
    // linker ochrony (wabikowy graf wywołań)
    //
    my_python_obfuscator.protection_linker = false;

    //
    // zmieniaj nazwy zmiennych na losowe ciągi znaków
    //
    my_python_obfuscator.rename_variables = true;

    //
    // zmieniaj nazwy parametrów na losowe ciągi znaków
    //
    my_python_obfuscator.rename_parameters = true;

    //
    // zmieniaj nazwy funkcji na losowe ciągi znaków
    //
    my_python_obfuscator.rename_functions = true;

    //
    // zmień odwołania do wywołań funkcji zgodnie ze zmienionymi nazwami funkcji
    //
    my_python_obfuscator.rename_function_calls = true;

    //
    // wymieszaj kolejność funkcji w wyjściowym kodzie
    //
    my_python_obfuscator.shuffle_functions = true;

    //
    // fold/resolve constant expressions at obfuscation time
    //
    my_python_obfuscator.resolve_constants = true;

    //
    //
    // split strings into concatenated chunks
    //
    my_python_obfuscator.split_strings = true;

    //
    // zastosuj lekkie przekształcenia i mutacje literałów tekstowych
    //
    my_python_obfuscator.modify_strings = true;

    //
    // szyfruj ciągi znaków losowo generowanymi polimorficznymi algorytmami
    //
    my_python_obfuscator.encrypt_strings = true;

    //
    // przechowuj fragmenty ciągów w sejfach tablic kodów znaków
    //
    my_python_obfuscator.string_char_array_vault = true;

    //
    // szyfruj liczby całkowite
    //
    my_python_obfuscator.encrypt_integers = true;

    //
    // szyfruj liczby zmiennoprzecinkowe
    //
    my_python_obfuscator.encrypt_floating = true;

    //
    // zastąp operatory binarne równoważnikami mieszanej arytmetyki boolowskiej (MBA)
    //
    my_python_obfuscator.mba_binops = true;

    //
    // represent integers via floating-point math
    //
    my_python_obfuscator.integers_to_floating = true;

    //
    // move integers to arrays
    //
    my_python_obfuscator.integers_to_arrays = true;

    //
    // move floats to arrays
    //
    my_python_obfuscator.floats_to_arrays = true;

    //
    // apply redundant xor / affine integer masks
    //
    my_python_obfuscator.affine_integer_mask = true;

    //
    // szyfruj literały tablic liczb całkowitych
    //
    my_python_obfuscator.array_int_crypt = true;

    //
    // szyfruj literały tablic znaków
    //
    my_python_obfuscator.array_char_crypt = true;

    //
    // szyfruj literały tablic zmiennoprzecinkowych
    //
    my_python_obfuscator.array_double_crypt = true;

    //
    // szyfruj literały tablic ciągów znaków
    //
    my_python_obfuscator.array_string_crypt = true;

    //
    // wstaw wspólny kubełek losowego szumu używany przez inne strategie
    //
    my_python_obfuscator.insert_random_value_bucket = true;

    //
    // wypełnij kubełek losowych wartości liczbami-wabikami
    //
    my_python_obfuscator.random_bucket_integers = true;

    //
    // wypełnij kubełek losowych wartości tablicami-wabikami
    //
    my_python_obfuscator.random_bucket_arrays = true;

    //
    // wypełnij kubełek losowych wartości funkcjami-wabikami
    //
    my_python_obfuscator.random_bucket_functions = true;

    //
    // wypełnij kubełek losowych wartości znakami-wabikami
    //
    my_python_obfuscator.random_bucket_characters = true;

    //
    // wypełnij kubełek losowych wartości szumem antyregex
    //
    my_python_obfuscator.random_bucket_anti_regex = true;

    //
    // wypełnij kubełek losowych wartości zaślepkami autostartu
    //
    my_python_obfuscator.random_bucket_autostart = true;

    //
    // rewrite selected statements using ternary operators
    //
    my_python_obfuscator.insert_ternary_operators = true;

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

    //
    // wstaw gałęzie z nieprzezroczystymi predykatami
    //
    my_python_obfuscator.opaque_branches = true;

    //
    // wstaw łańcuchy nieprzezroczystych mikserów do przepływu sterowania
    //
    my_python_obfuscator.opaque_mixer_chain = true;

    //
    // wstaw martwy kod
    //
    my_python_obfuscator.insert_dead_code = true;

    //
    // opakuj kod w bloki try/finally z martwym szumem
    //
    my_python_obfuscator.try_finally_noise = true;

    //
    // wstaw funkcje-wabiki
    //
    my_python_obfuscator.decoy_functions = true;

    //
    // wstaw wyrażenia lambda-wabiki
    //
    my_python_obfuscator.lambda_decoys = true;

    //
    // wstaw szum wypełniający literały
    //
    my_python_obfuscator.literal_padding = true;

    //
    // wstaw fałszywe znaczniki instrukcji import
    //
    my_python_obfuscator.fake_import_markers = true;

    //
    // use dynamic getattr()-based indirect calls
    //
    my_python_obfuscator.dynamic_getattr_calls = true;

    //
    // rewrite absolute imports into __import__ / getattr
    //
    my_python_obfuscator.obfuscate_imports = true;

    //
    // wstaw martwe zaślepki rejestracji wywołań zwrotnych i zdarzeń
    //
    my_python_obfuscator.callback_registration_stubs = true;

    //
    // wstaw wykrywanie debuggera
    //
    my_python_obfuscator.detect_debugger = false;

    //
    // wstaw wykrywanie maszyn wirtualnych (anti-VM)
    //
    my_python_obfuscator.anti_vm = false;

    //
    // wstaw wykrywanie piaskownicy
    //
    my_python_obfuscator.anti_sandbox = false;

    //
    // wstaw wykrywanie emulatorów (CPU)
    //
    my_python_obfuscator.anti_emulator = false;

    //
    // usuń komentarze z wyjściowego kodu
    //
    my_python_obfuscator.remove_comments = true;

    //
    // kod źródłowy w formacie Python
    //
    let script_source_code = r#"label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)"#;

    //
    // obfuskuj kod źródłowy z opcjami ustawionymi powyżej
    //
    let result = my_python_obfuscator
        .obfuscate_script_source(script_source_code, true)
        .await;

    //
    // można też podać ścieżkę do skryptu Python zamiast ciągu, np.
    //
    // let result = my_python_obfuscator
    //     .obfuscate_script_file(std::path::Path::new("/path/to/project/script.py"), 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.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
    // result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
    //
    match result {
        Some(PythonObfuscatorResponse::Object(obj)) => {
            //
            // wyświetl zobfuskowany kod
            //
            if obj.error == PythonObfuscator::ERROR_SUCCESS {
                println!("{}", obj.output.unwrap_or_default());
            } else {
                return Err(
                    format!("Wystąpił błąd, kod błędu: {}", obj.error).into(),
                );
            }
        }
        Some(PythonObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.".into());
        }
    }

    Ok(())
}

/******************************************************************************
 * Python 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       : C#
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

using PELock.PythonObfuscator;

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
var myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

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

//
// tryb wirtualizacji kodu (dokładnie jeden): VM, FSA albo FLAT
// pomiń albo ustaw null, aby pominąć wirtualizację
//
myPythonObfuscator.CodeVirtualization = CodeVirtualization.VM;


//
// 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
//

//
// stałe ziarno losowe dla powtarzalnego wyniku obfuskacji (opcjonalne)
//
myPythonObfuscator.Seed = null;

//
// randomization density / intensity (0-100)
//
myPythonObfuscator.RandomizationDensity = null;

//
// identifier renaming style: "il", "homoglyph" or "hex"
//
myPythonObfuscator.RenameStyle = null;

//
// ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
//
myPythonObfuscator.SelfDefending = false;

//
// linker ochrony (wabikowy graf wywołań)
//
myPythonObfuscator.ProtectionLinker = false;

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

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

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

//
// zmień odwołania do wywołań funkcji zgodnie ze zmienionymi nazwami funkcji
//
myPythonObfuscator.RenameFunctionCalls = true;

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

//
// fold/resolve constant expressions at obfuscation time
//
myPythonObfuscator.ResolveConstants = true;

//
//
// split strings into concatenated chunks
//
myPythonObfuscator.SplitStrings = true;

//
// zastosuj lekkie przekształcenia i mutacje literałów tekstowych
//
myPythonObfuscator.ModifyStrings = true;

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

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

//
// szyfruj liczby całkowite
//
myPythonObfuscator.EncryptIntegers = true;

//
// szyfruj liczby zmiennoprzecinkowe
//
myPythonObfuscator.EncryptFloating = true;

//
// zastąp operatory binarne równoważnikami mieszanej arytmetyki boolowskiej (MBA)
//
myPythonObfuscator.MbaBinops = true;

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

//
// move integers to arrays
//
myPythonObfuscator.IntegersToArrays = true;

//
// move floats to arrays
//
myPythonObfuscator.FloatsToArrays = true;

//
// apply redundant xor / affine integer masks
//
myPythonObfuscator.AffineIntegerMask = true;

//
// szyfruj literały tablic liczb całkowitych
//
myPythonObfuscator.ArrayIntCrypt = true;

//
// szyfruj literały tablic znaków
//
myPythonObfuscator.ArrayCharCrypt = true;

//
// szyfruj literały tablic zmiennoprzecinkowych
//
myPythonObfuscator.ArrayDoubleCrypt = true;

//
// szyfruj literały tablic ciągów znaków
//
myPythonObfuscator.ArrayStringCrypt = true;

//
// wstaw wspólny kubełek losowego szumu używany przez inne strategie
//
myPythonObfuscator.InsertRandomValueBucket = true;

//
// wypełnij kubełek losowych wartości liczbami-wabikami
//
myPythonObfuscator.RandomBucketIntegers = true;

//
// wypełnij kubełek losowych wartości tablicami-wabikami
//
myPythonObfuscator.RandomBucketArrays = true;

//
// wypełnij kubełek losowych wartości funkcjami-wabikami
//
myPythonObfuscator.RandomBucketFunctions = true;

//
// wypełnij kubełek losowych wartości znakami-wabikami
//
myPythonObfuscator.RandomBucketCharacters = true;

//
// wypełnij kubełek losowych wartości szumem antyregex
//
myPythonObfuscator.RandomBucketAntiRegex = true;

//
// wypełnij kubełek losowych wartości zaślepkami autostartu
//
myPythonObfuscator.RandomBucketAutostart = true;

//
// rewrite selected statements using ternary operators
//
myPythonObfuscator.InsertTernaryOperators = true;

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

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

//
// wstaw łańcuchy nieprzezroczystych mikserów do przepływu sterowania
//
myPythonObfuscator.OpaqueMixerChain = true;

//
// wstaw martwy kod
//
myPythonObfuscator.InsertDeadCode = true;

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

//
// wstaw funkcje-wabiki
//
myPythonObfuscator.DecoyFunctions = true;

//
// wstaw wyrażenia lambda-wabiki
//
myPythonObfuscator.LambdaDecoys = true;

//
// wstaw szum wypełniający literały
//
myPythonObfuscator.LiteralPadding = true;

//
// wstaw fałszywe znaczniki instrukcji import
//
myPythonObfuscator.FakeImportMarkers = true;

//
// use dynamic getattr()-based indirect calls
//
myPythonObfuscator.DynamicGetattrCalls = true;

//
// rewrite absolute imports into __import__ / getattr
//
myPythonObfuscator.ObfuscateImports = true;

//
// wstaw martwe zaślepki rejestracji wywołań zwrotnych i zdarzeń
//
myPythonObfuscator.CallbackRegistrationStubs = true;

//
// wstaw wykrywanie debuggera
//
myPythonObfuscator.DetectDebugger = false;

//
// wstaw wykrywanie maszyn wirtualnych (anti-VM)
//
myPythonObfuscator.AntiVm = false;

//
// wstaw wykrywanie piaskownicy
//
myPythonObfuscator.AntiSandbox = false;

//
// wstaw wykrywanie emulatorów (CPU)
//
myPythonObfuscator.AntiEmulator = false;

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

//
// kod źródłowy w formacie Python
//
const string ScriptSourceCode =
    """
    label = 'SecretKey'
    port = 443

    def get_sum(a, b):
        return a + b

    print(label, port)
    r = get_sum(11, 31)
    print(r)
    """;

//
// obfuskuj kod źródłowy z opcjami ustawionymi powyżej
//
var result = await myPythonObfuscator.ObfuscateScriptSourceAsync(ScriptSourceCode);

//
// można też podać ścieżkę do skryptu Python zamiast ciągu, np.
//
// var result = await myPythonObfuscator.ObfuscateScriptFileAsync("/path/to/project/script.py");

//
// obiekt result zawiera wyniki obfuskacji oraz dodatkowe informacje
//
// result?.Error           - kod błędu (zob. PythonObfuscator.Error*)
// result?.Output          - zobfuskowany kod
// result?.Demo             - czy użyto trybu demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.LicenseExpiration - data końca licencji (Y-m-d), pusta jeśli brak
// result?.UsagesTotal     - łączna liczba obfuskacji dla tego kodu aktywacyjnego
//
if (result is not null)
{
    //
    // wyświetl zobfuskowany kod
    //
    if (result.Error == PythonObfuscator.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.");
}

################################################################################
#
# Python Obfuscator — przykład użycia interfejsu Web API.
#
# W tym przykładzie obfuskujemy przykładowy kod ze wszystkimi publicznymi opcjami
# ustawiona, żeby widać było pełną powierzchnię klienta i dało się włączać oraz wyłączać flagi.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

#
# dołącz moduł Python Obfuscator
#
using module PythonObfuscator

#
# utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
#
$myPythonObfuscator = [PythonObfuscator]::new('ABCD-ABCD-ABCD-ABCD')

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

#
# globals
#
# stałe ziarno losowe dla powtarzalnego wyniku obfuskacji (opcjonalne)
#
$myPythonObfuscator.seed = $null

#
# randomization density / intensity (0-100)
#
$myPythonObfuscator.randomization_density = $null

#
# identifier renaming style: [RenameStyle]::il, o0, confusable, hex, homoglyph, or mangled
#
$myPythonObfuscator.rename_style = [RenameStyle]::il

#
# wirtualizacja kodu (dokładnie jedna): vm, fsa albo flat
# ustaw $null, aby pominąć wirtualizację
#
$myPythonObfuscator.code_virtualization = [CodeVirtualization]::vm

#
# ochrona (na usłudze włączana przy --all; tutaj pokazana jako włączona, żeby każda flaga była widoczna)
#
# ochrona przed modyfikacją zabezpieczonego kodu (weryfikacja integralności)
#
$myPythonObfuscator.self_defending = $true

#
# linker ochrony (wabikowy graf wywołań; wymaga self_defending)
#
$myPythonObfuscator.protection_linker = $true

#
# wstaw wykrywanie debuggera
#
$myPythonObfuscator.detect_debugger = $true

#
# wstaw wykrywanie maszyn wirtualnych (anti-VM)
#
$myPythonObfuscator.anti_vm = $true

#
# wstaw wykrywanie piaskownicy
#
$myPythonObfuscator.anti_sandbox = $true

#
# wstaw wykrywanie emulatorów (CPU)
#
$myPythonObfuscator.anti_emulator = $true

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

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

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

#
# zmień odwołania do wywołań funkcji zgodnie ze zmienionymi nazwami funkcji
#
$myPythonObfuscator.rename_function_calls = $true

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

#
# fold/resolve constant expressions at obfuscation time
#
$myPythonObfuscator.resolve_constants = $true

#
# strings
#
# split strings into concatenated chunks
#
$myPythonObfuscator.split_strings = $true

#
# zastosuj lekkie przekształcenia i mutacje literałów tekstowych
#
$myPythonObfuscator.modify_strings = $true

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

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

#
# numeric
#
# szyfruj liczby całkowite
#
$myPythonObfuscator.encrypt_integers = $true

#
# szyfruj liczby zmiennoprzecinkowe
#
$myPythonObfuscator.encrypt_floating = $true

#
# zastąp operatory binarne równoważnikami mieszanej arytmetyki boolowskiej (MBA)
#
$myPythonObfuscator.mba_binops = $true

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

#
# move integers to arrays
#
$myPythonObfuscator.integers_to_arrays = $true

#
# move floats to arrays
#
$myPythonObfuscator.floats_to_arrays = $true

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

#
# zaszyfrowane literały tablic
#
# szyfruj literały tablic liczb całkowitych
#
$myPythonObfuscator.array_int_crypt = $true

#
# szyfruj literały tablic znaków
#
$myPythonObfuscator.array_char_crypt = $true

#
# szyfruj literały tablic zmiennoprzecinkowych
#
$myPythonObfuscator.array_double_crypt = $true

#
# szyfruj literały tablic ciągów znaków
#
$myPythonObfuscator.array_string_crypt = $true

#
# decoy value pools
#
# wstaw wspólny kubełek losowego szumu używany przez inne strategie
#
$myPythonObfuscator.insert_random_value_bucket = $true

#
# wypełnij kubełek losowych wartości liczbami-wabikami
#
$myPythonObfuscator.random_bucket_integers = $true

#
# wypełnij kubełek losowych wartości tablicami-wabikami
#
$myPythonObfuscator.random_bucket_arrays = $true

#
# wypełnij kubełek losowych wartości funkcjami-wabikami
#
$myPythonObfuscator.random_bucket_functions = $true

#
# wypełnij kubełek losowych wartości znakami-wabikami
#
$myPythonObfuscator.random_bucket_characters = $true

#
# wypełnij kubełek losowych wartości szumem antyregex
#
$myPythonObfuscator.random_bucket_anti_regex = $true

#
# wypełnij kubełek losowych wartości zaślepkami autostartu
#
$myPythonObfuscator.random_bucket_autostart = $true

#
# opaque predicates & noise
#
# rewrite selected statements using ternary operators
#
$myPythonObfuscator.insert_ternary_operators = $true

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

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

#
# wstaw łańcuchy nieprzezroczystych mikserów do przepływu sterowania
#
$myPythonObfuscator.opaque_mixer_chain = $true

#
# wstaw martwy kod
#
$myPythonObfuscator.insert_dead_code = $true

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

#
# decoys
#
# wstaw funkcje-wabiki
#
$myPythonObfuscator.decoy_functions = $true

#
# wstaw wyrażenia lambda-wabiki
#
$myPythonObfuscator.lambda_decoys = $true

#
# wstaw szum wypełniający literały
#
$myPythonObfuscator.literal_padding = $true

#
# wstaw fałszywe znaczniki instrukcji import
#
$myPythonObfuscator.fake_import_markers = $true

#
# use dynamic getattr()-based indirect calls
#
$myPythonObfuscator.dynamic_getattr_calls = $true

#
# rewrite absolute imports into __import__ / getattr
#
$myPythonObfuscator.obfuscate_imports = $true

#
# wstaw martwe zaślepki rejestracji wywołań zwrotnych i zdarzeń
#
$myPythonObfuscator.callback_registration_stubs = $true

#
# other
#
# usuń komentarze z wyjściowego kodu
#
$myPythonObfuscator.remove_comments = $true

#
# kod źródłowy w formacie Python
#
$scriptSourceCode = @'
label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
'@

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

#
# można też podać ścieżkę do skryptu Python zamiast ciągu ze źródłem, np.
#
# $result = $myPythonObfuscator.ObfuscateScriptFile('/path/to/project/script.py')

#
# $result zawiera wyniki obfuskacji oraz dodatkowe informacje
#
# $result.error              - kod błędu
# $result.output             - zobfuskowany kod
# $result.demo               - tryb demo (pusty lub nieprawidłowy klucz); flagi strategii są ignorowane; zawsze integers_to_arrays, mba_binops, encrypt_strings (bez wirtualizacji; limit 1000 znaków)
# $result.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
# $result.usages_total       - łączna liczba obfuskacji dla tego kodu aktywacyjnego
#
if ($result -and $null -ne $result.PSObject.Properties['error']) {

    # wyświetl zobfuskowany kod
    if ($result.error -eq [PythonObfuscator]::ERROR_SUCCESS) {

        Write-Host $result.output

    }
    else {
        Write-Host ("Wystąpił błąd, kod błędu: {0}" -f $result.error)
    }

}
else {
    Write-Host 'Podczas obfuskacji kodu wydarzyło się coś nieoczekiwanego.'
}

/******************************************************************************
 * Python 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"

	pythonobfuscator "github.com/PELock/Python-Obfuscator-Go"
)

func main() {
	client := pythonobfuscator.New("ABCD-ABCD-ABCD-ABCD")
	client.EnableCompression = false
	client.CodeVirtualization = pythonobfuscator.CodeVirtualizationVM
	client.RenameStyle = pythonobfuscator.RenameStyleIL
	client.SelfDefending = false
	client.ProtectionLinker = false
	client.RenameVariables = true
	client.RenameParameters = true
	client.RenameFunctions = true
	client.RenameFunctionCalls = true
	client.ShuffleFunctions = true
	client.ResolveConstants = true
	client.SplitStrings = true
	client.ModifyStrings = true
	client.EncryptStrings = true
	client.StringCharArrayVault = true
	client.EncryptIntegers = true
	client.EncryptFloating = true
	client.MBABinops = true
	client.IntegersToFloating = true
	client.IntegersToArrays = true
	client.FloatsToArrays = true
	client.AffineIntegerMask = true
	client.ArrayIntCrypt = true
	client.ArrayCharCrypt = true
	client.ArrayDoubleCrypt = true
	client.ArrayStringCrypt = true
	client.InsertRandomValueBucket = true
	client.RandomBucketIntegers = true
	client.RandomBucketArrays = true
	client.RandomBucketFunctions = true
	client.RandomBucketCharacters = true
	client.RandomBucketAntiRegex = true
	client.RandomBucketAutostart = true
	client.InsertTernaryOperators = true
	client.ComplexifyBooleans = true
	client.OpaqueBranches = true
	client.OpaqueMixerChain = true
	client.InsertDeadCode = true
	client.TryFinallyNoise = true
	client.DecoyFunctions = true
	client.LambdaDecoys = true
	client.LiteralPadding = true
	client.FakeImportMarkers = true
	client.DynamicGetattrCalls = true
	client.ObfuscateImports = true
	client.CallbackRegistrationStubs = true
	client.DetectDebugger = false
	client.AntiVM = false
	client.AntiSandbox = false
	client.AntiEmulator = false
	client.RemoveComments = true

	source := `label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

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

/******************************************************************************
 * Python 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       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.pelock.pythonobfuscator.CodeVirtualization;
import com.pelock.pythonobfuscator.PythonObfuscator;
import com.pelock.pythonobfuscator.PythonObfuscatorResult;
import com.pelock.pythonobfuscator.RenameStyle;

public class PythonObfuscatorExample {

  public static void main(String[] args) throws Exception {
    PythonObfuscator client = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");
    client.enableCompression = false;
    client.codeVirtualization = CodeVirtualization.VM;
    client.renameStyle = RenameStyle.IL;
    client.selfDefending = false;
    client.protectionLinker = false;
    client.renameVariables = true;
    client.renameParameters = true;
    client.renameFunctions = true;
    client.renameFunctionCalls = true;
    client.shuffleFunctions = true;
    client.resolveConstants = true;
    client.splitStrings = true;
    client.modifyStrings = true;
    client.encryptStrings = true;
    client.stringCharArrayVault = true;
    client.encryptIntegers = true;
    client.encryptFloating = true;
    client.mbaBinops = true;
    client.integersToFloating = true;
    client.integersToArrays = true;
    client.floatsToArrays = true;
    client.affineIntegerMask = true;
    client.arrayIntCrypt = true;
    client.arrayCharCrypt = true;
    client.arrayDoubleCrypt = true;
    client.arrayStringCrypt = true;
    client.insertRandomValueBucket = true;
    client.randomBucketIntegers = true;
    client.randomBucketArrays = true;
    client.randomBucketFunctions = true;
    client.randomBucketCharacters = true;
    client.randomBucketAntiRegex = true;
    client.randomBucketAutostart = true;
    client.insertTernaryOperators = true;
    client.complexifyBooleans = true;
    client.opaqueBranches = true;
    client.opaqueMixerChain = true;
    client.insertDeadCode = true;
    client.tryFinallyNoise = true;
    client.decoyFunctions = true;
    client.lambdaDecoys = true;
    client.literalPadding = true;
    client.fakeImportMarkers = true;
    client.dynamicGetattrCalls = true;
    client.obfuscateImports = true;
    client.callbackRegistrationStubs = true;
    client.detectDebugger = false;
    client.antiVm = false;
    client.antiSandbox = false;
    client.antiEmulator = false;
    client.removeComments = true;

    String scriptSourceCode =
        "label = 'SecretKey'\n"
            + "port = 443\n"
            + "\n"
            + "def get_sum(a, b):\n"
            + "    return a + b\n"
            + "\n"
            + "print(label, port)\n"
            + "r = get_sum(11, 31)\n"
            + "print(r)\n";

    PythonObfuscatorResult result = client.obfuscateScriptSource(scriptSourceCode);
    if (result != null && result.isSuccess() && result.getOutput() != null) {
      System.out.println(result.getOutput());
    } else {
      throw new IllegalStateException(
          "Wystąpił błąd, kod błędu: " + (result == null ? "null" : result.getError()));
    }
  }
}

# frozen_string_literal: true

###############################################################################
#
# Python Obfuscator — własne opcje obfuskacji
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "python-obfuscator"

client = PythonObfuscator.new("ABCD-ABCD-ABCD-ABCD")
client.enable_compression = false
client.code_virtualization = PythonObfuscator::CodeVirtualization::VM
client.rename_style = PythonObfuscator::RenameStyle::IL
client.self_defending = false
client.protection_linker = false
client.rename_variables = true
client.rename_parameters = true
client.rename_functions = true
client.rename_function_calls = true
client.shuffle_functions = true
client.resolve_constants = true
client.split_strings = true
client.modify_strings = true
client.encrypt_strings = true
client.string_char_array_vault = true
client.encrypt_integers = true
client.encrypt_floating = true
client.mba_binops = true
client.integers_to_floating = true
client.integers_to_arrays = true
client.floats_to_arrays = true
client.affine_integer_mask = true
client.array_int_crypt = true
client.array_char_crypt = true
client.array_double_crypt = true
client.array_string_crypt = true
client.insert_random_value_bucket = true
client.random_bucket_integers = true
client.random_bucket_arrays = true
client.random_bucket_functions = true
client.random_bucket_characters = true
client.random_bucket_anti_regex = true
client.random_bucket_autostart = true
client.insert_ternary_operators = true
client.complexify_booleans = true
client.opaque_branches = true
client.opaque_mixer_chain = true
client.insert_dead_code = true
client.try_finally_noise = true
client.decoy_functions = true
client.lambda_decoys = true
client.literal_padding = true
client.fake_import_markers = true
client.dynamic_getattr_calls = true
client.obfuscate_imports = true
client.callback_registration_stubs = true
client.detect_debugger = false
client.anti_vm = false
client.anti_sandbox = false
client.anti_emulator = false
client.remove_comments = true

source = <<~PY
  label = 'SecretKey'
  port = 443

  def get_sum(a, b):
      return a + b

  print(label, port)
  r = get_sum(11, 31)
  print(r)
PY

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

#!/usr/bin/env bash

###############################################################################
#
# Python 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"

#
# kod źródłowy w formacie Python
#
cat > script.py << 'PY'
label = 'SecretKey'
port = 443

def get_sum(a, b):
    return a + b

print(label, port)
r = get_sum(11, 31)
print(r)
PY

#
# compression nie jest wysyłane: REST odrzuca to pole i zawsze wysyła
# bajty skryptu bez zmian. seed, randomization_density i rename_style są null
# w tym przykładzie, więc są pominięte.
#
# response body    - zobfuskowany skrypt, zapisany jako obfuscated.py
# X-PELock-Result  - status JSON obok skryptu:
#
# error               - kod błędu (0 = sukces)
# demo                - tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
# license_expiration  - data końca licencji (Y-m-d), pusta jeśli brak
# usages_total        - łączna liczba obfuskacji dla tego kodu aktywacyjnego
#
# nieudana obfuskacja to HTTP 422 i treść JSON zamiast skryptu
#
curl -sS -D - -o obfuscated.py \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@script.py" \
  -F "code_virtualization=vm" \
  -F "self_defending=0" \
  -F "protection_linker=0" \
  -F "rename_variables=1" \
  -F "rename_parameters=1" \
  -F "rename_functions=1" \
  -F "rename_function_calls=1" \
  -F "shuffle_functions=1" \
  -F "resolve_constants=1" \
  -F "split_strings=1" \
  -F "modify_strings=1" \
  -F "encrypt_strings=1" \
  -F "string_char_array_vault=1" \
  -F "encrypt_integers=1" \
  -F "encrypt_floating=1" \
  -F "mba_binops=1" \
  -F "integers_to_floating=1" \
  -F "integers_to_arrays=1" \
  -F "floats_to_arrays=1" \
  -F "affine_integer_mask=1" \
  -F "array_int_crypt=1" \
  -F "array_char_crypt=1" \
  -F "array_double_crypt=1" \
  -F "array_string_crypt=1" \
  -F "insert_random_value_bucket=1" \
  -F "random_bucket_integers=1" \
  -F "random_bucket_arrays=1" \
  -F "random_bucket_functions=1" \
  -F "random_bucket_characters=1" \
  -F "random_bucket_anti_regex=1" \
  -F "random_bucket_autostart=1" \
  -F "insert_ternary_operators=1" \
  -F "complexify_booleans=1" \
  -F "opaque_branches=1" \
  -F "opaque_mixer_chain=1" \
  -F "insert_dead_code=1" \
  -F "try_finally_noise=1" \
  -F "decoy_functions=1" \
  -F "lambda_decoys=1" \
  -F "literal_padding=1" \
  -F "fake_import_markers=1" \
  -F "dynamic_getattr_calls=1" \
  -F "obfuscate_imports=1" \
  -F "callback_registration_stubs=1" \
  -F "detect_debugger=0" \
  -F "anti_vm=0" \
  -F "anti_sandbox=0" \
  -F "anti_emulator=0" \
  -F "remove_comments=1" \
  "https://www.pelock.com/api/python-obfuscator/v1/obfuscate"

<?php

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

//
// include Python Obfuscator class
//
use PELock\PythonObfuscator;

//
// jeśli nie chcesz używać Composera, użyj include_once
//
//include_once "PythonObfuscator.php";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
$myPythonObfuscator = new PELock\PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// logowanie do usługi
//
$result = $myPythonObfuscator->Login();

//
// tablica $result[] zawiera informacje o licencji
//
// $result["demo"]          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// $result["license_expiration"] - data końca licencji (Y-m-d), pusta jeśli brak
// $result["usages_total"]  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
// $result["string_limit"]  - maks. dozwolony rozmiar kodu źródłowego (w trybie demo to 1000 bajtów)
//
if ($result !== false)
{
	echo "Status wersji demonstracyjnej - " . ($result["demo"] ? "true" : "false") . "<br>";
	echo "Data wygaśnięcia licencji - " . $result["license_expiration"] . "<br>";
	echo "Łączna liczba obfuskacji - " . $result["usages_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.");
}

?>

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

import PythonObfuscator from "python-obfuscator";

//
// include Python Obfuscator class
//

//
// podczas pracy z klonem repozytorium, bez instalacji pakietu, użyj:
//
// import PythonObfuscator from "../src/python-obfuscator.js";

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
const myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// logowanie do usługi
//
const result = await myPythonObfuscator.login();

//
// obiekt result zawiera informacje o licencji
//
// result.demo          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
// result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
// result.string_limit  - maks. dozwolony rozmiar kodu źródłowego (w trybie demo to 1000 bajtów)
//
if (result !== null) {
  console.log("Status wersji demonstracyjnej - " + (result.demo ? "true" : "false"));
  console.log("Data wygaśnięcia licencji - " + result.license_expiration);
  console.log("Łączna liczba obfuskacji - " + result.usages_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.");
}

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

use python_obfuscator::{PythonObfuscator, PythonObfuscatorResponse};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    //
    // include Python Obfuscator class
    //

    //
    // jeśli nie chcesz używać crates.io, użyj zależności ścieżki do tej skrzynki
    //
    // [dependencies]
    // python-obfuscator = { path = ".." }

    //
    // utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
    //
    let my_python_obfuscator =
        PythonObfuscator::new(Some("ABCD-ABCD-ABCD-ABCD".to_string()));

    //
    // logowanie do usługi
    //
    let result = my_python_obfuscator.login(true).await;

    //
    // obiekt result zawiera informacje o licencji
    //
    // result.demo          - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
    // result.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
    // result.usages_total  - łączna liczba obfuskacji dla tego kodu aktywacyjnego
    // result.string_limit  - maks. dozwolony rozmiar kodu źródłowego (w trybie demo to 1000 bajtów)
    //
    match result {
        Some(PythonObfuscatorResponse::Object(obj)) => {
            println!(
                "Status wersji demonstracyjnej - {}",
                if obj.demo.unwrap_or(false) {
                    "true"
                } else {
                    "false"
                }
            );
            println!(
                "Data wygaśnięcia licencji - {:?}",
                obj.license_expiration
            );
            println!(
                "Łączna liczba obfuskacji - {}",
                obj.usages_total.unwrap_or(0)
            );
            println!(
                "Maks. rozmiar kodu źródłowego - {}",
                obj.string_limit.unwrap_or(0)
            );
        }
        Some(PythonObfuscatorResponse::Json(_)) => {}
        None => {
            return Err("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.".into());
        }
    }

    Ok(())
}

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

using PELock.PythonObfuscator;

//
// utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
//
var myPythonObfuscator = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");

//
// logowanie do usługi
//
var result = await myPythonObfuscator.LoginAsync();

//
// obiekt result zawiera informacje o licencji
//
// result?.Demo           - czy to tryb demo (nieprawidłowy lub pusty klucz aktywacyjny)
// result?.LicenseExpiration - data końca licencji (Y-m-d), pusta jeśli brak
// result?.UsagesTotal     - łączna liczba obfuskacji dla tego kodu aktywacyjnego
// result?.StringLimit     - maks. dozwolony rozmiar kodu źródłowego (w trybie demo to 1000 bajtów)
//
if (result is not null)
{
    Console.WriteLine("Status wersji demonstracyjnej - " + (result.Demo == true ? "true" : "false"));
    Console.WriteLine("Data wygaśnięcia licencji - " + result.LicenseExpiration);
    Console.WriteLine("Łączna liczba obfuskacji - " + result.UsagesTotal);
    Console.WriteLine("Maks. rozmiar kodu źródłowego - " + result.StringLimit);
}
else
{
    throw new InvalidOperationException("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
}

################################################################################
#
# Python 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
#
################################################################################

#
# dołącz moduł Python Obfuscator
#
using module PythonObfuscator

#
# utwórz instancję klasy Python Obfuscator (używamy naszego klucza aktywacyjnego)
#
$myPythonObfuscator = [PythonObfuscator]::new('ABCD-ABCD-ABCD-ABCD')

#
# logowanie do usługi
#
$result = $myPythonObfuscator.Login()

#
# $result zawiera informacje o licencji
#
# $result.demo               - tryb demo (pusty lub nieprawidłowy klucz); flagi strategii są ignorowane; zawsze integers_to_arrays, mba_binops, encrypt_strings (bez wirtualizacji; limit 1000 znaków)
# $result.license_expiration - data końca licencji (Y-m-d), pusta jeśli brak
# $result.usages_total       - łączna liczba obfuskacji dla tego kodu aktywacyjnego
# $result.string_limit       - maks. dozwolony rozmiar kodu źródłowego (w trybie demo to 1000 bajtów)
#
if ($result) {

    $demoStatus = if ($result.demo) { 'True' } else { 'False' }
    Write-Host ("Status wersji demonstracyjnej - {0}" -f $demoStatus)
    Write-Host ("Data wygaśnięcia licencji - {0}" -f $result.license_expiration)
    Write-Host ("Łączna liczba obfuskacji - {0}" -f $result.usages_total)
    Write-Host ("Maks. rozmiar kodu źródłowego - {0}" -f $result.string_limit)

}
else {
    Write-Host 'Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.'
}

/******************************************************************************
 * Python 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"

	pythonobfuscator "github.com/PELock/Python-Obfuscator-Go"
)

func main() {
	client := pythonobfuscator.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("Data wygaśnięcia licencji - %s\n", result.LicenseExpiration)
	fmt.Printf("Łączna liczba obfuskacji - %d\n", result.UsagesTotal)
	fmt.Printf("Maks. rozmiar kodu źródłowego - %d\n", result.StringLimit)
}

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

import com.pelock.pythonobfuscator.PythonObfuscator;
import com.pelock.pythonobfuscator.PythonObfuscatorResult;

public class PythonObfuscatorExampleLogin {

  public static void main(String[] args) throws Exception {
    PythonObfuscator client = new PythonObfuscator("ABCD-ABCD-ABCD-ABCD");
    PythonObfuscatorResult result = client.login();

    if (result != null) {
      System.out.println("Status wersji demonstracyjnej - " + Boolean.TRUE.equals(result.getDemo()));
      System.out.println("Data wygaśnięcia licencji - " + result.getLicenseExpiration());
      System.out.println("Łączna liczba obfuskacji - " + result.getUsagesTotal());
      System.out.println("Maks. rozmiar kodu źródłowego - " + result.getStringLimit());
    } else {
      System.err.println("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
    }
  }
}

# frozen_string_literal: true

###############################################################################
#
# Python Obfuscator — login
#
# Wersja        : v1.0.0
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "python-obfuscator"

result = PythonObfuscator.new("ABCD-ABCD-ABCD-ABCD").login
if result
  puts "Status wersji demonstracyjnej - #{result["demo"] ? "True" : "False"}"
  puts "Data wygaśnięcia licencji - #{result["license_expiration"]}"
  puts "Łączna liczba obfuskacji - #{result["usages_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

###############################################################################
#
# Python 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)
# license_expiration  - data końca licencji (Y-m-d), pusta jeśli brak
# usages_total        - łączna liczba obfuskacji dla tego kodu aktywacyjnego
# string_limit        - maks. rozmiar kodu źródłowego (1000 bajtów w trybie demo)
#
curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/python-obfuscator/v1/license"

import obfuscator


@obfuscator.skip(obfuscator.ENCRYPT_STRINGS, obfuscator.CODE_VIRTUALIZATION)
def handshake(secret: str) -> str:
    """Pomiń wymienione strategie. Stałe odpowiadają nazwom strategii silnika."""
    return "plain:" + secret

import obfuscator


@obfuscator.skip("encrypt_strings", "rename_functions")
def handshake(secret: str) -> str:
    """Klucze tekstowe odpowiadają nazwom strategii silnika."""
    return "plain:" + secret

import obfuscator


@obfuscator.skip
def handshake(secret: str) -> str:
    """Sama forma, bez wywołania, pomija każdą strategię mutującą w tej funkcji."""
    return secret

import obfuscator as alias


@alias.skip(alias.ENCRYPT_STRINGS)
def handshake(secret: str) -> str:
    """Alias importu jest przyjmowany tak samo jak nazwa obfuskatora."""
    return "plain:" + secret

import obfuscator


@obfuscator.skip(obfuscator.ENCRYPT_STRINGS)
class LicenseCheck:
    """Pominięcie na poziomie klasy obejmuje klasę i każdą zagnieżdżoną metodę."""

    def verify(self) -> str:
        return "ok"