PowerShell Pro Obfuscator — Obfusquez et virtualisez du code PowerShell

PowerShell Pro Obfuscator protège vos scripts .ps1 propriétaires grâce au renommage, au chiffrement polymorphe des chaînes et des entiers, à l'aplatissement du flux de contrôle, aux automates finis (FSA), à un moteur de machine virtuelle, à des contrôles d'intégrité auto-défensifs, à un linker de protection et à des sondes anti-débogage.

Obfusquez, virtualisez et protégez vos scripts PowerShell .ps1 grâce au chiffrement polymorphe des chaînes, au moteur de machine virtuelle, aux transformations par automates finis, aux contrôles d'intégrité et anti-débogage — via interface graphique, CLI, outil en ligne ou API.

Plus de détails techniques, téléchargements et documentation disponibles sur :

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

PowerShell Pro Obfuscator Windows Client

Il est disponible pour Windows et Linux :

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

Plusieurs API de programmation disponibles :

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

Une interface d'obfuscation en ligne :

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

Pourquoi les scripts PowerShell ont-ils besoin d'obfuscation ?

Les scripts sont généralement distribués sous forme de fichiers .ps1 en clair ou intégrés dans des modules. Cette commodité signifie que toute personne ayant accès aux fichiers peut lire toute la logique, chercher des identifiants ou des clés API dans les chaînes, et voler vos algorithmes, à moins que vous ne preniez des mesures supplémentaires pour masquer l'intention.

PowerShell est un shell et un langage de script multiplateforme basé sur .NET. Il est largement utilisé pour l'automatisation, la configuration, les pipelines DevOps et la gestion des postes de travail sous Windows et Linux.

Stratégies d'obfuscation

PowerShell Pro Obfuscator propose de nombreuses stratégies avancées d'obfuscation, de virtualisation et de protection. Vous pouvez facilement ajuster la protection par rapport à la taille et aux performances.

PowerShell Obfuscation options

Obfuscation puissante

PowerShell Pro Obfuscator utilise des stratégies d'obfuscation de pointe telles que le chiffrement polymorphe des chaînes, le chiffrement des entiers et des flottants, et l'insertion de bruit leurre. Le résultat masque les littéraux et la structure tout en préservant le comportement d'exécution testé.

Virtualisation du code

Certaines instructions sélectionnées sont élevées dans un moteur de machine virtuelle généré aléatoirement avec des opcodes, des cas de switch mélangés, des opcodes leurres et une boucle de répartition obfusquée. Les analystes doivent interpréter la machine virtuelle au lieu de lire du PowerShell en clair.

Automates finis (FSA)

L'obfuscation par automates finis (FSA) réécrit les blocs d'instructions PowerShell linéaires en automates à double état avec des planificateurs opaques et des gestionnaires de répartition mélangés. Au lieu de lire le code de haut en bas, les analystes doivent suivre les états numériques, les tables de transition et les chemins leurres pour reconstruire l'ordre d'origine.

Anti-débogage

La protection anti-débogage insère des sondes polymorphes qui détectent les débogueurs attachés, les points d'arrêt PowerShell, les modes de préférence de débogage et de traçage, ainsi que les signaux hôtes associés. Lorsqu'un contrôle se déclenche, le script obfusqué se termine silencieusement au lieu de révéler la logique protégée lors d'une analyse interactive.

Contrôles d'intégrité

Une sonde d'amorçage vérifie la forme du script sur disque (nombre de fonctions et jetons d'intégrité) et définit une clé de falsification lorsque le fichier ne correspond plus à la version obfusquée. Les déchiffreurs de chaînes consomment cette clé, de sorte que les scripts modifiés renvoient des données inutilisables au lieu du texte en clair. Cette couche auto-défensive augmente le coût d'une désobfuscation et de modifications de fichiers occasionnelles.

Linker de protection

Une passe tardive câble des résolveurs honeypot, des appels d'aide factices avec des arguments aléatoires et des pièges de pile peu profonds qui restent actifs uniquement avant la fin de l'amorçage. Les extraits extraits conservent des surfaces d'appel bruyantes qui semblent réelles lors d'une revue statique. L'exécution normale après un contrôle d'intégrité réussi reste inchangée.

Avant et après l'obfuscation

Regardez cet exemple — le même script devient plus difficile à lire d'un coup d'œil après l'obfuscation.

Exemple de script PowerShell avant obfuscation

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

Après obfuscation

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

Reconnaîtriez-vous encore l'intention d'origine si vous n'aviez que le texte obfusqué et aucune copie préalable du script ?

Obfuscated PowerShell script

Comment fonctionne PowerShell Pro Obfuscator ?

Le moteur analyse le code source PowerShell en un arbre AST, puis applique des transformations sélectionnables : renommage des identifiants, aplatissement du flux de contrôle, automates finis (FSA), virtualisation par machine virtuelle, chiffrement polymorphe des chaînes et des entiers, insertion de bruit et de leurres, sondes d'intégrité auto-défensives, linker de protection et contrôles anti-débogage. De nombreuses techniques sont spécifiques à ce produit ; certaines idées sont partagées avec nos autres outils de protection.

PowerShell Pro Obfuscator Pipeline

Lorsque toutes les passes sont terminées, le moteur émet un nouveau fichier .ps1. Les cas limites de la grammaire PowerShell et des environnements d'hébergement signifient que vous devez toujours tester la sortie dans votre environnement d'exécution cible.

Protégez vos scripts et algorithmes PowerShell

Ne prenez aucun risque, utilisez PowerShell Pro Obfuscator pour obfusquer, virtualiser et protéger vos scripts et algorithmes PowerShell.

Notre entreprise a une longue histoire dans les technologies d'obfuscation et les obfuscateurs de code (voir nos obfuscateurs x86 Assembly, AutoIt et Java).

Nous corrigeons activement les bogues, recherchons et développons de nouvelles stratégies d'obfuscation pour nos outils.

Vous pouvez compter sur notre expertise et notre support dans ce domaine.

Installation

La méthode privilégiée d'installation de l'interface WebApi est via pip.

Exécutez :

pip install powershell-pro-obfuscator

python3 -m pip install powershell-pro-obfuscator

Puis ajoutez cet import à votre code source :


from powershellproobfuscator import PowerShellProObfuscator

Le paquet d'installation est disponible sur https://pypi.org/project/powershell-pro-obfuscator/

Exemple d'obfuscation du code source d'un script PowerShell avec les options par défaut


#!/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 exemple d'obfuscation du code source d'un script PowerShell avec des stratégies d'obfuscation personnalisées

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

Vérifier le statut de la clé d'activation

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

Utilisez PowerShell Pro Obfuscator en ligne

L'interface en ligne de PowerShell Pro Obfuscator est disponible sur :

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

Client GUI Windows et version en ligne de commande

PowerShell Pro Obfuscator est également fourni avec une version GUI complète pour Windows :

PowerShell Pro Obfuscator Windows Client

Options d'obfuscation :

PowerShell Obfuscation options

Script PowerShell obfusqué :

Obfuscated PowerShell script

Téléchargement

Vous pouvez le télécharger sur :

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

Le paquet d'installation contient une interface en ligne de commande supplémentaire :

PowerShell Pro Obfuscator command-line interface

PowerShell Pro Obfuscator est fourni avec une interface en ligne de commande pour l'automatisation sous Windows et Linux.

Utilisez-la pour intégrer l'obfuscation dans les serveurs de build, les tâches CI ou le packaging par lots.

Bartosz Wójcik

Visitez mon site sur — https://www.pelock.com
X — https://x.com/PELock
GitHub — https://github.com/PELock

PowerShell-Pro-Obfuscator-Python

Populaires