pc简易连点器

import tkinter as tk
from tkinter import ttk
import time
import autoit
import threading
from tkinter import messagebox
from pynput import keyboard
import sys
 
# 增大迭代限制
sys.setrecursionlimit(1000000000)
 
class App:
    def __init__(self, master):
        self.master = master
        master.title("简易连点器-小锋学长生活大爆炸(ESC键停止)")
        # 设置连点的时间间隔,单位为毫秒
        self.interval = 0.5
        # 连点计数器
        self.click_count = 0
        self.click_total = 10
        # 创建输入框
        self.x_label = tk.Label(master, text="X坐标:", width=15)
        self.x_label.grid(row=0, column=0, padx=5, pady=10)
        self.x_entry = tk.Entry(master, width=10)
        self.x_entry.insert(tk.END, "100")
        self.x_entry.grid(row=0, column=1, padx=5, pady=10)
        self.y_label = tk.Label(master, text="Y坐标:", width=15)
        self.y_label.grid(row=1, column=0, padx=5, pady=10)
        self.y_entry = tk.Entry(master, width=10)
        self.y_entry.insert(tk.END, "100")
        self.y_entry.grid(row=1, column=1, padx=5, pady=10)
        # 增加self.click_total的输入框
        self.total_label = tk.Label(master, text="点击总数(0为无限):", width=15)
        self.total_label.grid(row=2, column=0, padx=5, pady=10)
        self.total_entry = tk.Entry(master, width=10)
        self.total_entry.insert(tk.END, "10")
        self.total_entry.grid(row=2, column=1, padx=5, pady=10)
        # 增加self.interval的输入框
        self.interval_label = tk.Label(master, text="点击间隔(ms):", width=15)
        self.interval_label.grid(row=3, column=0, padx=5, pady=10)
        self.interval_entry = tk.Entry(master, width=10)
        self.interval_entry.insert(tk.END, "500")
        self.interval_entry.grid(row=3, column=1, padx=5, pady=10)
        # 创建进度条和标签
        self.progress_bar = ttk.Progressbar(master, orient="horizontal", mode="determinate")
        self.progress_bar.grid(row=4, column=0, padx=5, pady=10)
        self.progress_label = tk.Label(master, text="0 / {}".format(self.click_total), width=5)
        self.progress_label.grid(row=4, column=1, padx=5, pady=10)
        # 创建启动和停止按钮
        self.start_button = tk.Button(master, text="启动", command=self.start_click, width=5)
        self.start_button.grid(row=5, column=0, padx=5, pady=10)
        self.stop_button = tk.Button(master, text="停止", command=self.stop_click, width=5)
        self.stop_button.grid(row=5, column=1, padx=5, pady=10)
         
        # 创建一个标志，表示是否按下了ESC键
        self.esc_pressed = False
    def start_click(self):
        # 启动连点器
        self.x = int(self.x_entry.get())
        self.y = int(self.y_entry.get())
        self.click_count = 0
        self.running = True
        self.click_total = int(self.total_entry.get()) or 1e9
        self.interval = int(self.interval_entry.get()) / 1000
        self.progress_bar["maximum"] = self.click_total
        self.progress_bar["value"] = 0
         # 创建一个子线程，用于监听键盘是否按下ESC键
        self.listener_thread = threading.Thread(target=self.listener_start)
        self.listener_thread.start()
        while self.running and self.click_count < self.click_total:
            self.click_count += 1
            # 鼠标左键点击
            autoit.mouse_click("left", self.x, self.y)
            # 等待interval毫秒
            time.sleep(self.interval)
            # 更新进度条和标签
            self.progress_bar["value"] = self.click_count
            self.progress_label["text"] = "{} / {}".format(self.click_count, self.click_total)
            self.master.update()
             # 如果按下了ESC键，则停止连点器
            if self.esc_pressed:
                self.stop_click()
                break
        # 点击结束后，停止子线程
        self.listener_thread.join()
        messagebox.showinfo("提示", "连点器已停止")
    def stop_click(self):
        # 停止连点器
        self.running = False
        self.esc_pressed = False
    def listener_on_press(self, key):
        try:
            if key.char == keyboard.Key.esc:
                print("ESC is pressed")
        except AttributeError:
            pass
    def listener_on_release(self, key):
        if key == keyboard.Key.esc:
            return False
    def listener_start(self):
        # 监听键盘是否按下ESC键
        while self.running:
            # 启动键盘监听器
            with keyboard.Listener(on_press=self.listener_on_press, on_release=self.listener_on_release) as listener:
                listener.join()
                self.esc_pressed = True
                break
root = tk.Tk()
app = App(root)
# 设置窗口置顶
root.wm_attributes("-topmost", True)
root.mainloop()

自己瞎写了一个非常简易的连点器。
代码量也不大，能实现基本的点点点和esc按键中止功能就行。
关于x和y坐标的选取，用微信截图就行了，会显示POS坐标，拿过来用。

7.Ghidra还可以对数据，区段，函数进行管理，例如这里可以直接查看DOS头文件，不需要借助其他工具。

1.哪个工具简单好用就用哪个，目前对小菜鸟而言，还是IDA香，主要是用得久，知道的功能多，也熟悉。

  2.Ghidra作为开源工具，功能丰富，也有一定的优点，加载速度好像没用IDA快，可能是读取的内容太多了。

  3.至于为什么自己写了那样一段代码，还不是前天10进制转16进制用c没写出来，当时用java操作的，这次就当巩固C知识了。

伯克利包过滤器（Berkeley Packet Filter）是一个 Linux kernel 中用以对来自于链路层的数据包进行过滤的架构，其位于内核中的架构如下图所示：

相比起传统的数据包过滤器而言，BPF 在内核中实现了一个新的虚拟机设计，通过即时编译（Just-In-Time compilation）技术将 BPF 指令翻译为 BPF 虚拟机的字节码，可以高效地工作在基于寄存器结构的 CPU 上

Linux kernel 自 3.18 版本起提供了扩展伯克利包过滤器（extended BPF，即 eBPF），其应用范围更广，能够被应用于更多的场景，原来的 BPF 被称为 classic BPF（cBPF），且目前基本上已经被废弃，Linux 会将 cBPF 字节码转化为 eBPF 字节码再执行

作为一个位于内核层面的虚拟机，eBPF 无疑为攻击者提供了一个相当大的新攻击面，因此也成为近几年内核利用中的“大热门”

一、eBPF 的运行过程

Linux 下 eBPF 的整体架构如下图所示：

• 用户进程首先在用户空间编写相应的 BPF 字节码程序，传入内核
• 内核通过 verifier 对字节码程序进行安全性检查，通过检查后便通过 JIT 编译运行，eBPF 程序主要分为如下类型：
  • kprobes ：内核中的动态跟踪，可以跟踪至内核中的函数入口或返回点
  • uprobes ：用户空间中的动态跟踪，与 kprobes 不同的是跟踪的函数位于用户程序中
  • tracepoints ：内核中的静态跟踪
  • perf_events ：定时采样与 PMC
• 映射（map）作为用以保存数据的通用结构，可以在不同的 eBPF 程序之间或是用户进程与内核间共享数据

• 二、eBPF verifier

  在 eBPF 字节码被传入到内核空间后，其首先需要经过 verifier 的安全检查，之后才能进行 JIT 编译，verifier 主要检查以下几点：

• 没有回向边（back edge）、环路（loop）、不可达（unreachable）指令
• 不能在指针之间进行比较，指针只能与标量进行加减（eBPF 中的标量值为不从指针派生的值），verifier 会追踪哪些寄存器包含指针、哪些寄存器包含标量值
• 指针运算不能离开一个 map 的“安全”边界，这意味着程序不能访问预定义的 map 外的内存，verifier 通过追踪每个寄存器值的上界与下界
• 不能将指针存储在 map 中或作为返回值，以避免将内核地址泄露到用户空间