PowerShell Pro Obfuscator — Обфускация и виртуализация PowerShell-кода

PowerShell Pro Obfuscator защищает проприетарные .ps1-скрипты с помощью переименования, полиморфного шифрования строк и целых чисел, выравнивания потока управления, конечных автоматов (FSA), VM-движка, самозащитных проверок целостности, protection linker и анти-отладочных проверок.

Обфусцируйте, виртуализируйте и защищайте PowerShell .ps1-скрипты с помощью полиморфного шифрования строк, VM-движка, преобразований конечных автоматов, проверок самозащиты и анти-отладки — через GUI, CLI, онлайн-инструмент или API.

Более подробные технические детали, загрузки и документация доступны по адресу:

https://www.pelock.com/products/powershell-pro-obfuscator

PowerShell Pro Obfuscator Windows Client

Доступен для Windows и Linux:

https://www.pelock.com/products/powershell-pro-obfuscator/download

Доступно несколько программных API:

https://www.pelock.com/products/powershell-pro-obfuscator/api

Онлайн-интерфейс обфускатора:

https://www.pelock.com/powershell-pro-obfuscator/

Зачем PowerShell-скриптам нужна обфускация?

Скрипты обычно распространяются как обычные .ps1-файлы или встраиваются в модули. Это удобство означает, что любой, у кого есть доступ к файлу, может прочитать всю логику, найти учётные данные или ключи API в строках и украсть ваши алгоритмы, если вы не предпримете дополнительных мер для скрытия намерений.

PowerShell — это кроссплатформенная оболочка и язык сценариев, построенный на .NET. Он широко используется для автоматизации, конфигурации, DevOps-конвейеров и управления конечными точками в Windows и Linux.

Стратегии обфускации

PowerShell Pro Obfuscator включает множество продвинутых стратегий обфускации, виртуализации и защиты. Вы можете легко настраивать баланс между защитой, размером и производительностью.

PowerShell Obfuscation options

Мощная обфускация

PowerShell Pro Obfuscator использует передовые стратегии обфускации, такие как полиморфное шифрование строк, шифрование целых чисел и чисел с плавающей запятой, а также шумовые вставки-приманки. Результат скрывает литералы и структуру, сохраняя проверенное поведение во время выполнения.

Виртуализация кода

Выбранные операторы поднимаются в опкоды случайно сгенерированного VM-движка с перемешанными case-ветками, опкодами-приманками и обфусцированным циклом диспетчера. Аналитикам приходится интерпретировать виртуальную машину вместо чтения обычного PowerShell.

Конечные автоматы (FSA)

Обфускация конечными автоматами (FSA) переписывает линейные блоки операторов PowerShell в двухсостоянийные автоматы с непрозрачными планировщиками и перемешанными обработчиками диспетчеризации. Вместо чтения кода сверху вниз аналитикам приходится отслеживать числовые состояния, таблицы переходов и пути-приманки, чтобы восстановить исходный порядок.

Анти-отладка

Защита от анти-отладки вставляет полиморфные проверки, которые обнаруживают подключённые отладчики, точки останова PowerShell, режимы отладки и трассировки, а также связанные сигналы хоста. Когда проверка срабатывает, обфусцированный скрипт молча завершается, вместо того чтобы раскрывать защищённую логику при интерактивном анализе.

Проверки самозащиты

Загрузочная проверка сверяет форму скрипта на диске (количество функций и токены целостности) и устанавливает ключ подделки, когда файл больше не соответствует обфусцированной сборке. Дешифраторы строк используют этот ключ, поэтому пропатченные скрипты возвращают мусор вместо открытого текста. Этот самозащитный слой повышает стоимость небрежной деобфускации и правок файлов.

Protection linker

Финальный проход подключает резолверы-ловушки, фиктивные вызовы помощников со случайными аргументами и триггеры мелкого стека, которые остаются активными только до завершения загрузки. Извлечённые фрагменты сохраняют шумные поверхности вызовов, которые выглядят реально при статическом анализе. Нормальное выполнение после успешной проверки целостности остаётся неизменным.

До и после обфускации

Посмотрите на этот пример — тот же скрипт становится сложнее прочитать с первого взгляда после обфускации.

Пример PowerShell-скрипта до обфускации

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

После обфускации

$script:_HnJTskg = 0
$jwNTQ = 297 * 400 + 36
$x4e8bfda = [Math]::Abs($jwNTQ - 8074)
$_EvKocNn = [Math]::Max($jwNTQ, $x4e8bfda) - [Math]::Min($jwNTQ, $x4e8bfda)
[void]$_EvKocNn
$script:_jUoXkBYh = 0
function gnJjzMCN3V8P {
    param([int]$slot, [int]$salt, [int]$guard)
    if (-not ((Get-Variable -Name _HnJTskg -Scope Script -ErrorAction SilentlyContinue).Value)) { return '' }
    @('JFE', 'm0ao', 'R8Ysw') | ForEach-Object { $_.ToUpper() } | Out-Null
if ((((($slot * 31) + $salt) -band 65535) -ne $guard)) { return '' }
    $tk = (Get-Variable -Name _jUoXkBYh -Scope Script -ErrorAction SilentlyContinue).Value
    $IEm39CSpDOEFp = @{ 'Ouj1' = 455; 'vjzO' = 170; 'IQNV' = 291 }
$IEm39CSpDOEFp['R5LrM'] = $IEm39CSpDOEFp['Ouj1'] + $IEm39CSpDOEFp['vjzO']
$YWxSO = ($IEm39CSpDOEFp.Values | Measure-Object -Sum).Sum
[void]$YWxSO
if ($null -eq $tk) { [long]$tk = 0 }
    $v93a130f2e4 = 508
switch ($v93a130f2e4) {
    524 { $_GYF7IA14Go = 'H1Vph' }
    561 { $_GYF7IA14Go = 'HAWoB' }
    default { $_GYF7IA14Go = $v93a130f2e4 * 2 }
}
[void]$_GYF7IA14Go
$dk = (Get-Variable -Name vb6a18ffee4 -Scope Script -ErrorAction SilentlyContinue).Value
    try { $xgLN5KZyEusFo7 = [Math]::Sqrt(850) } finally { [void]$xgLN5KZyEusFo7 }
if ($null -eq $dk) { [long]$dk = 0 }
    $d = @(46866, 46865)
    if ((((-not 113))-and(([int](272 -ne 272) -eq 21)))-and(([Math]::Sign(-12) -eq 4))) { $w4iTzi2hooy1GW = @(711, 562, 665); $w4iTzi2hooy1GW = ($w4iTzi2hooy1GW | Measure-Object -Sum).Sum }
$r = ''
    for ($s9qOSpiZzufQlVyV = 0; $s9qOSpiZzufQlVyV -lt $d.Length; $s9qOSpiZzufQlVyV++) {
        [long]$v = [long]$d[$s9qOSpiZzufQlVyV]
        for ($jL9gL7PEtQeIS = 2; $jL9gL7PEtQeIS -ge 0; $jL9gL7PEtQeIS--) {
            for ($PsbomDHxAy = 2; $PsbomDHxAy -ge 0; $PsbomDHxAy--) {
                    [long]$v = [long]$v + ([long](https://github.com/pelock/powershell-pro-obfuscator-python/blob/HEAD/230))
            }
        }
        for ($zhH33vzxjIzegl9 = 0; $zhH33vzxjIzegl9 -ge 0; $zhH33vzxjIzegl9--) {
                [long]$v = [long]$v + ([long]([int]((((((236 + (-3 * $s9qOSpiZzufQlVyV) + (3 * $zhH33vzxjIzegl9))) % 256) + 256) % 256))))
                [long]$v = [long]$v -bxor ([long](https://github.com/pelock/powershell-pro-obfuscator-python/blob/HEAD/53766))
        }
        [long]$v = [long]$v - ([long]($salt + $slot + $tk + $dk + 0))
        if ([long]$v -ge 0 -and [long]$v -le 0xFFFF) { $r += [char][int][long]$v }
        elseif ([long]$v -ge 0x10000 -and [long]$v -le 0x10FFFF) { $r += [System.Char]::ConvertFromUtf32([int][long]$v) }
    }
    return $r
}
and more...

Узнали бы вы исходное намерение, если бы у вас был только обфусцированный текст и не было копии скрипта до обфускации?

Obfuscated PowerShell script

Как работает PowerShell Pro Obfuscator?

Движок разбирает исходный код PowerShell в AST-дерево, а затем применяет выбираемые преобразования: переименование идентификаторов, выравнивание потока управления, конечные автоматы (FSA), VM-виртуализацию, полиморфное шифрование строк и целых чисел, вставку шума и приманок, самозащитные проверки целостности, protection linker и анти-отладочные проверки. Многие техники уникальны для этого продукта; некоторые идеи используются и в наших других инструментах защиты.

PowerShell Pro Obfuscator Pipeline

Когда все проходы завершены, движок генерирует новый .ps1. Крайние случаи в грамматике PowerShell и средах размещения означают, что вы всегда должны тестировать вывод в целевой среде выполнения.

Защитите свои PowerShell-скрипты и алгоритмы

Не рискуйте — используйте PowerShell Pro Obfuscator для обфускации, виртуализации и защиты ваших PowerShell-скриптов и алгоритмов.

Наша компания имеет долгую историю в технологиях обфускации и обфускаторах кода (см. наши обфускаторы для x86 Assembly, AutoIt и Java).

Мы активно исправляем ошибки, исследуем и разрабатываем новые стратегии обфускации для наших инструментов.

Вы можете рассчитывать на наш опыт и поддержку в этой области.

Установка

Предпочтительный способ установки интерфейса WebApi — через pip.

Выполните:

pip install powershell-pro-obfuscator

или

python3 -m pip install powershell-pro-obfuscator

Затем добавьте этот импорт в ваш исходный код:


from powershellproobfuscator import PowerShellProObfuscator

Пакет установки доступен по адресу https://pypi.org/project/powershell-pro-obfuscator/

Пример обфускации исходного кода PowerShell-скрипта с параметрами по умолчанию


#!/usr/bin/env python

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

#
# include PowerShell Pro Obfuscator module
#
from powershellproobfuscator import PowerShellProObfuscator

#
# if you don't want to use Python module, you can import directly from the file
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# create PowerShell Pro Obfuscator class instance (we are using our activation key)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

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

#
# by default all obfuscation options are enabled, so we can just simply call
#
result = myPowerShellProObfuscator.obfuscate_script_source(scriptSourceCode)

#
# it's also possible to pass a PowerShell script file path instead of a string with the source e.g.
#
# result = myPowerShellProObfuscator.obfuscate_script_file("/path/to/project/script.ps1")

#
# result[] array holds the obfuscation results as well as other information
#
# result["error"]         - error code
# result["output"]        - obfuscated code
# result["demo"]          - was it used in demo mode (invalid or empty activation key was used)
# result["credits_left"]  - usage credits left after this operation
# result["credits_total"] - total number of credits for this activation code
# result["expired"]       - if this was the last usage credit for the activation key it will be set to True
#
if result and "error" in result:

    # display obfuscated code
    if result["error"] == PowerShellProObfuscator.ERROR_SUCCESS:

        # format output code for HTML display
        print(result["output"])

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

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

Пример обфускации исходного кода PowerShell-скрипта с настраиваемыми стратегиями обфускации

#!/usr/bin/env python

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

#
# include PowerShell Pro Obfuscator module
#
from powershellproobfuscator import PowerShellProObfuscator

#
# if you don't want to use Python module, you can import directly from the file
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# create PowerShell Pro Obfuscator class instance (we are using our activation key)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

#
# should the source code be compressed (both input & compressed)
#
myPowerShellProObfuscator.enableCompression = False

#
# global obfuscation options
#
# you can disable a particular obfuscation strategy globally if it
# fails or you don't want to use it without modifying the source codes
#
# by default all obfuscation strategies are enabled
#

#
# protection against tampering with protected code (integrity verification)
#
myPowerShellProObfuscator.selfDefending = True

#
# protection linker (decoy call graph)
#
myPowerShellProObfuscator.protectionLinker = True

#
# rename variable names to random string values
#
myPowerShellProObfuscator.renameVariables = True

#
# rename parameter names to random string values
#
myPowerShellProObfuscator.renameParameters = True

#
# rename function names to random string values
#
myPowerShellProObfuscator.renameFunctions = True

#
# shuffle function order in the output source
#
myPowerShellProObfuscator.shuffleFunctions = True

#
# change linear code execution flow via control-flow flattening
#
myPowerShellProObfuscator.controlFlowFlatten = True

#
# rewrite statement blocks into finite-state automata (state-machine obfuscation)
#
myPowerShellProObfuscator.stateMachine = True

#
# lift selected statements into a VM engine (virtualized statements)
#
myPowerShellProObfuscator.vmStrategy = True

#
# encrypt integers
#
myPowerShellProObfuscator.encryptIntegers = True

#
# split strings into concatenated chunks
#
myPowerShellProObfuscator.splitStrings = True

#
# encrypt strings using randomly generated polymorphic encryption algorithms
#
myPowerShellProObfuscator.encryptStrings = True

#
# move integers to arrays
#
myPowerShellProObfuscator.integersToArrays = True

#
# move floats to arrays
#
myPowerShellProObfuscator.floatsToArrays = True

#
# insert dead code
#
myPowerShellProObfuscator.insertDeadCode = True

#
# replace boolean conditions with equivalent complex expressions
#
myPowerShellProObfuscator.complexifyBooleans = True

#
# represent integers via floating-point math
#
myPowerShellProObfuscator.integersToFloating = True

#
# encrypt floating point numbers
#
myPowerShellProObfuscator.encryptFloating = True

#
# insert decoy functions
#
myPowerShellProObfuscator.decoyFunctions = True

#
# insert anti-debugging detections
#
myPowerShellProObfuscator.detectDebugger = True

#
# insert fake dot-source comment markers
#
myPowerShellProObfuscator.fakeDotSourceMarkers = True

#
# insert opaque predicate branches
#
myPowerShellProObfuscator.opaqueBranches = True

#
# insert scriptblock decoys
#
myPowerShellProObfuscator.scriptblockDecoys = True

#
# insert here-string padding
#
myPowerShellProObfuscator.literalPadding = True

#
# use indirect command invocation
#
myPowerShellProObfuscator.reflectInvokeCommands = True

#
# store string fragments in char-code array vaults
#
myPowerShellProObfuscator.stringCharArrayVault = True

#
# wrap code in try/finally blocks with dead noise
#
myPowerShellProObfuscator.tryFinallyNoise = True

#
# apply redundant xor / affine integer masks
#
myPowerShellProObfuscator.affineIntegerMask = True

#
# insert dead event/timer stubs
#
myPowerShellProObfuscator.eventStub = True

#
# strip comments from the output source
#
myPowerShellProObfuscator.removeComments = True

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

#
# by default all obfuscation options are enabled, so we can just simply call
#
result = myPowerShellProObfuscator.obfuscate_script_source(scriptSourceCode)

#
# it's also possible to pass a PowerShell script file path instead of a string with the source e.g.
#
# result = myPowerShellProObfuscator.obfuscate_script_file("/path/to/project/script.ps1")

#
# result[] array holds the obfuscation results as well as other information
#
# result["error"]         - error code
# result["output"]        - obfuscated code
# result["demo"]          - was it used in demo mode (invalid or empty activation key was used)
# result["credits_left"]  - usage credits left after this operation
# result["credits_total"] - total number of credits for this activation code
# result["expired"]       - if this was the last usage credit for the activation key it will be set to True
#
if result and "error" in result:

    # display obfuscated code
    if result["error"] == PowerShellProObfuscator.ERROR_SUCCESS:

        # format output code for HTML display
        print(result["output"])

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

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

Проверка статуса ключа активации

#!/usr/bin/env python

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

#
# include PowerShell Pro Obfuscator module
#
from powershellproobfuscator import PowerShellProObfuscator

#
# if you don't want to use Python module, you can import directly from the file
#
#from pelock.powershellproobfuscator import PowerShellProObfuscator

#
# create PowerShell Pro Obfuscator class instance (we are using our activation key)
#
myPowerShellProObfuscator = PowerShellProObfuscator("ABCD-ABCD-ABCD-ABCD")

#
# login to the service
#
result = myPowerShellProObfuscator.login()

#
# result[] array holds the information about the license
#
# result["demo"]          - is it a demo mode (invalid or empty activation key was used)
# result["credits_left"]  - usage credits left after this operation
# result["credits_total"] - total number of credits for this activation code
# result["string_limit"]  - max. source code size allowed (it's 1000 bytes for demo mode)
#
if result:

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

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