PowerShell Pro Obfuscator — Ofusca y virtualiza código PowerShell

PowerShell Pro Obfuscator protege scripts .ps1 propietarios con renombrado, cifrado polimórfico de cadenas y enteros, aplanamiento de flujo de control, autómatas finitos (FSA), un motor de VM, comprobaciones de integridad autodefensivas, un enlazador de protección y sondas anti-depuración.

Ofusca, virtualiza y protege scripts .ps1 de PowerShell con cifrado polimórfico de cadenas, motor de VM, transformaciones de autómatas finitos, comprobaciones de auto-integridad y anti-depuración — mediante GUI, CLI, herramienta en línea o API.

Más detalles técnicos, descargas y documentación disponibles en:

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

PowerShell Pro Obfuscator Windows Client

Está disponible para Windows y Linux:

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

Múltiples APIs de programación disponibles:

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

Una interfaz de ofuscación en línea:

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

¿Por qué los scripts de PowerShell necesitan ofuscación?

Los scripts normalmente se distribuyen como archivos .ps1 en texto plano o incrustados en módulos. Esa conveniencia significa que cualquiera con acceso al archivo puede leer toda la lógica, buscar credenciales o claves API en las cadenas y robar tus algoritmos a menos que tomes medidas adicionales para ocultar la intención.

PowerShell es un shell multiplataforma y lenguaje de scripting basado en .NET. Se usa ampliamente para automatización, configuración, pipelines de DevOps y gestión de endpoints en Windows y Linux.

Estrategias de ofuscación

PowerShell Pro Obfuscator incluye muchas estrategias avanzadas de ofuscación, virtualización y protección. Puedes ajustar fácilmente la protección frente al tamaño y el rendimiento.

PowerShell Obfuscation options

Ofuscación potente

PowerShell Pro Obfuscator utiliza estrategias de ofuscación de última generación como cifrado polimórfico de cadenas, cifrado de enteros y flotantes, y ruido señuelo. El resultado oculta literales y estructura mientras preserva el comportamiento de ejecución probado.

Virtualización de código

Las sentencias seleccionadas se elevan a opcodes de un motor de VM generado aleatoriamente con casos de switch barajados, opcodes señuelo y un bucle de despacho ofuscado. Los analistas deben interpretar la máquina virtual en lugar de leer PowerShell en texto plano.

Autómatas finitos (FSA)

La ofuscación con autómatas finitos (FSA) reescribe bloques lineales de sentencias de PowerShell en autómatas de doble estado con planificadores opacos y manejadores de despacho barajados. En lugar de leer el código de arriba a abajo, los analistas deben seguir estados numéricos, tablas de transición y rutas señuelo para reconstruir el orden original.

Anti-depuración

La protección anti-depuración inserta sondas polimórficas que detectan depuradores adjuntos, puntos de interrupción de PowerShell, modos de preferencia de depuración y rastreo, y señales relacionadas del host. Cuando una comprobación se activa, el script ofuscado sale silenciosamente en lugar de revelar lógica protegida bajo análisis interactivo.

Comprobaciones de auto-integridad

Una sonda de arranque verifica la forma del script en disco (conteos de funciones y tokens de integridad) y establece una clave de manipulación cuando el archivo ya no coincide con la compilación ofuscada. Los descifradores de cadenas consumen esa clave, por lo que los scripts parcheados devuelven basura en lugar de texto plano. Esta capa autodefensiva eleva el coste de la desofuscación casual y las ediciones de archivos.

Enlazador de protección

Una pasada tardía conecta resolutores honeypot, llamadas auxiliares falsas con argumentos aleatorios y trampas de pila superficial que permanecen activas solo antes de que se complete el arranque. Los fragmentos extraídos mantienen superficies de llamada ruidosas que parecen reales bajo revisión estática. La ejecución normal después de una comprobación de integridad exitosa permanece sin cambios.

Antes y después de la ofuscación

Mira este ejemplo: el mismo script se vuelve más difícil de leer de un vistazo después de la ofuscación.

Script de PowerShell de muestra antes de la ofuscación

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

Después de la ofuscación

$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...

¿Reconocerías aún la intención original si solo tuvieras el texto ofuscado y ninguna copia previa del script?

Obfuscated PowerShell script

¿Cómo funciona PowerShell Pro Obfuscator?

El motor analiza el código fuente de PowerShell en un árbol AST y luego aplica transformaciones seleccionables: renombrado de identificadores, aplanamiento de flujo de control, autómatas finitos (FSA), virtualización de VM, cifrado polimórfico de cadenas y enteros, inserción de ruido y señuelos, sondas de integridad autodefensivas, el enlazador de protección y comprobaciones anti-depuración. Muchas técnicas son específicas de este producto; algunas ideas se comparten con nuestras otras herramientas de protección.

PowerShell Pro Obfuscator Pipeline

Cuando todas las pasadas terminan, el motor emite un nuevo .ps1. Los casos límite en la gramática de PowerShell y los entornos de alojamiento significan que siempre debes probar la salida en tu entorno de ejecución objetivo.

Protege tus scripts y algoritmos de PowerShell

No te arriesgues, usa PowerShell Pro Obfuscator para ofuscar, virtualizar y proteger tus scripts y algoritmos de PowerShell.

Nuestra empresa tiene una larga trayectoria en tecnologías de ofuscación y ofuscadores de código (consulta nuestros ofuscadores de ensamblador x86, AutoIt y Java).

Corregimos errores activamente, investigamos y desarrollamos nuevas estrategias de ofuscación para nuestras herramientas.

Puedes contar con nuestra experiencia y soporte en este campo.

Instalación

La forma preferida de instalación de la interfaz WebApi es mediante pip.

Ejecuta:

pip install powershell-pro-obfuscator

python3 -m pip install powershell-pro-obfuscator

Y luego añade este import a tu código fuente:


from powershellproobfuscator import PowerShellProObfuscator

El paquete de instalación está disponible en https://pypi.org/project/powershell-pro-obfuscator/

Ejemplo de ofuscación de código fuente de script PowerShell usando opciones predeterminadas


#!/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.")

Un ejemplo de ofuscación de código fuente de script PowerShell con estrategias de ofuscación personalizadas

#!/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.")

Comprobar el estado de la clave de activación

#!/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.")

Usa PowerShell Pro Obfuscator en línea

La interfaz en línea de PowerShell Pro Obfuscator está disponible en:

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

Cliente GUI de Windows y versión de línea de comandos

PowerShell Pro Obfuscator incluye también una versión GUI completa para Windows:

PowerShell Pro Obfuscator Windows Client

Opciones de ofuscación:

PowerShell Obfuscation options

Script de PowerShell ofuscado:

Obfuscated PowerShell script

Descarga

Puedes descargarlo en:

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

El paquete de instalación contiene una interfaz de línea de comandos adicional:

PowerShell Pro Obfuscator command-line interface

PowerShell Pro Obfuscator incluye una interfaz de línea de comandos para automatización en Windows y Linux.

Úsala para integrar la ofuscación en servidores de compilación, trabajos de CI o empaquetado por lotes.

Bartosz Wójcik

Visita mi sitio en — https://www.pelock.com
X — https://x.com/PELock
GitHub — https://github.com/PELock

PowerShell-Pro-Obfuscator-Python

Más Populares