PowerShell Pro Obfuscator — Obfuskuj i wirtualizuj kod PowerShell

Obfuskuj, wirtualizuj i chroń skrypty PowerShell .ps1 dzięki polimorficznemu szyfrowaniu łańcuchów, silnikowi VM, transformacjom automatem stanów, kontroli integralności i antydebugowaniu — przez GUI, CLI, narzędzie online lub API.

Obfuskator, wirtualizer i protector skryptów PowerShell

PowerShell Pro Obfuscator chroni autorskie skrypty .ps1 dzięki zmianie nazw, polimorficznemu szyfrowaniu łańcuchów i liczb, spłaszczeniu przepływu sterowania, automatom stanów (FSA), silnikowi VM, samoobronie integralności, protection linkerowi oraz sondom antydebug.

PowerShell to wieloplatformowa powłoka i język skryptowy oparty o .NET. Jest szeroko używany do automatyzacji, konfiguracji, DevOps oraz zarządzania stacjami na Windows i Linux.

Opcje obfuskacji PowerShell

Dlaczego skrypty PowerShell wymagają obfuskacji?

Skrypty zwykle rozchodzą się jako zwykłe pliki .ps1 lub wbudowane w moduły. Ta wygoda oznacza, że każdy z dostępem do pliku może odczytać pełną logikę, wyszukać poświadczenia lub klucze API w łańcuchach i ukraść algorytmy — o ile nie podejmiesz dodatkowych kroków, by ukryć intencję.

Strategie obfuskacji

PowerShell Pro Obfuscator oferuje wiele zaawansowanych strategii obfuskacji, wirtualizacji i ochrony. Łatwo dopasujesz poziom ochrony do rozmiaru i wydajności.

Obfuskacja

Zaawansowana obfuskacja

PowerShell Pro Obfuscator stosuje nowoczesne strategie, takie jak polimorficzne szyfrowanie łańcuchów, szyfrowanie liczb całkowitych i zmiennoprzecinkowych oraz szum przynętowy. Wynik ukrywa literały i strukturę przy zachowaniu przetestowanego zachowania w runtime.

Procesor

Wirtualizacja kodu

Wybrane instrukcje są przenoszone do losowo generowanych opcode’ów silnika VM z przemieszanymi case’ami, fałszywymi opcode’ami i zaciemnioną pętlą dispatchera. Analityk musi interpretować maszynę wirtualną zamiast czytać zwykły PowerShell.

Węzeł

Automaty skończone (FSA)

Obfuskacja automatem stanów (FSA) przepisuje liniowe bloki instrukcji PowerShell na automaty dwustanowe z nieczytelnymi harmonogramami i przemieszanymi handlerami. Zamiast czytać kod od góry do dołu, analityk musi śledzić stany numeryczne, tabele przejść i ścieżki-przynęty, by odtworzyć pierwotną kolejność.

Błąd

Antydebugowanie

Ochrona antydebug wstawia polimorficzne sondy wykrywające podłączone debuggery, breakpointy PowerShell, tryby debug preference i tracing oraz powiązane sygnały hosta. Gdy sprawdzenie się uruchomi, zobfuskowany skrypt kończy działanie w milczeniu zamiast ujawniać chronioną logikę podczas interaktywnej analizy.

Monitor systemu

Kontrola integralności

Sonda bootstrap weryfikuje kształt skryptu na dysku (liczbę funkcji i tokeny integralności) oraz ustawia klucz sabotażu, gdy plik nie pasuje już do zobfuskowanej kompilacji. Deszyfratory łańcuchów korzystają z tego klucza, więc zpatchowany skrypt zwraca śmieci zamiast jawnego tekstu. Ta warstwa samoobrony podnosi koszt pobieżnej deobfuskacji i edycji pliku.

Łączenie cegieł

Protection linker

Późna faza łączy honeypotowe resolvery, fałszywe wywołania helperów z losowymi argumentami oraz pułapki na płytkim stosie aktywne tylko przed zakończeniem bootstrapa. Wyciągnięte fragmenty zachowują hałaśliwe powierzchnie wywołań wyglądające wiarygodnie przy przeglądzie statycznym. Normalne wykonanie po udanej kontroli integralności pozostaje bez zmian.

Przed i po obfuskacji

Spójrz na ten przykład i kliknij zakładkę "Po obfuskacji", aby zobaczyć, jak ten sam skrypt staje się trudniejszy do odczytania na pierwszy rzut oka:

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

Czy nadal rozpoznałbyś pierwotną intencję, mając tylko tekst po obfuskacji i bez wcześniejszej kopii skryptu?

Jak działa PowerShell Pro Obfuscator?

Silnik parsuje źródło PowerShell do drzewa AST, a następnie stosuje wybrane przekształcenia: zmianę nazw identyfikatorów, spłaszczenie przepływu sterowania, automaty stanów (FSA), wirtualizację VM, polimorficzne szyfrowanie łańcuchów i liczb, wstawianie szumu i przynęt, sondy samoobrony integralności, protection linker oraz sprawdzania antydebug. Wiele technik jest specyficznych dla tego produktu; część pomysłów współdzielimy z naszymi innymi narzędziami ochronnymi.

Potok PowerShell Pro Obfuscator — obfuskacja, wirtualizacja i ochrona

Po zakończeniu wszystkich przejść silnik emituje nowy plik .ps1. Ze względu na niuanse składni PowerShell i środowisk hostingu zawsze testuj wynik w docelowym runtime.

Wersja konsolowa

PowerShell Pro Obfuscator dostarcza interfejs wiersza poleceń do automatyzacji na Windows i Linux.

CLI PowerShell Pro Obfuscator do automatyzacji Windows i Linux

Użyj go do integracji obfuskacji z serwerami budowania, zadaniami CI lub pakowaniem wsadowym.

Masz pytania?

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