0.0

快手so2.py

@@ -1,281 +0,0 @@
-import urllib3
-import sys
-import os
-import requests
-import platform
-import re
-
-# 禁用SSL证书验证警告
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-# 版本文件名称
-VERSION_FILE = "so_version.txt"
-# 服务器版本号获取地址
-VERSION_CHECK_URL = "http://43.143.175.165:8888/down/sZeEcKNcJRhe.txt"  # 服务器应返回简单版本号如"1.2"
-# 首次运行的初始版本
-INITIAL_VERSION = "1.1"
-# 本地备用Python文件名称
-LOCAL_BACKUP_FILE = "kuaishou_so.py"
-
-
-def check_python_version():
-    """检查Python版本是否符合 3.10.x ~ 3.11.x 要求"""
-    version = sys.version_info
-    if not (version >= (3, 10) and version < (3, 12)):
-        current_version = f"{version.major}.{version.minor}.{version.micro}"
-        print(f"\n【❌ Python版本检查失败】")
-        print(f"当前版本：{current_version}")
-        print(f"必须版本：3.10.x ~ 3.11.x")
-        sys.exit(1)
-    print(f"【✅ Python版本检查通过】当前版本：{version.major}.{version.minor}.{version.micro}")
-
-
-def check_system_architecture():
-    """检查系统架构是否为支持的 x86_64 或 arm64"""
-    system = platform.system().lower()
-    machine = platform.machine().lower()
-    supported_arch = ["x86_64", "amd64", "arm64", "aarch64"]
-    arch_map = {"amd64": "x86_64", "aarch64": "arm64"}
-    arch = arch_map.get(machine, machine)
-
-    if machine not in supported_arch:
-        print(f"\n【❌ 系统架构检查失败】")
-        print(f"当前环境：{system.capitalize()} 系统 | 架构：{machine}（映射后：{arch}）")
-        print(f"支持架构：x86_64（含amd64）、arm64（含aarch64）")
-        sys.exit(1)
-
-    print(f"\n【✅ 系统架构检查通过】")
-    print(f"操作系统：{platform.system()} {platform.release()}")
-    print(f"CPU架构：{machine}（标准映射：{arch}）")
-    return arch
-
-
-def get_local_version():
-    """获取本地so文件版本"""
-    if not os.path.exists(VERSION_FILE):
-        # 首次运行，设置初始版本
-        with open(VERSION_FILE, "w") as f:
-            f.write(INITIAL_VERSION)
-        return INITIAL_VERSION
-    
-    try:
-        with open(VERSION_FILE, "r") as f:
-            version = f.read().strip()
-            # 简单验证版本格式
-            if re.match(r"^\d+\.\d+$", version):
-                return version
-            # 格式不正确，使用初始版本
-            return INITIAL_VERSION
-    except Exception:
-        return INITIAL_VERSION
-
-
-def get_server_version():
-    """从服务器获取最新版本号"""
-    try:
-        response = requests.get(
-            VERSION_CHECK_URL,
-            timeout=10,
-            verify=False,
-            headers={"User-Agent": "Mozilla/5.0"}
-        )
-        response.raise_for_status()
-        
-        version = response.text.strip()
-        # 验证版本格式
-        if re.match(r"^\d+\.\d+$", version):
-            return version
-        else:
-            print(f"【⚠️ 服务器版本格式不正确：{version}】")
-            return None
-    except Exception as e:
-        print(f"【⚠️ 获取服务器版本失败：{str(e)}】")
-        return None
-
-
-def version_needs_update(local_ver, server_ver):
-    """比较版本号，判断是否需要更新"""
-    if not server_ver:
-        return False
-        
-    try:
-        local_parts = list(map(int, local_ver.split('.')))
-        server_parts = list(map(int, server_ver.split('.')))
-        
-        # 比较主版本号
-        if server_parts[0] > local_parts[0]:
-            return True
-        # 主版本号相同，比较次版本号
-        if server_parts[0] == local_parts[0] and server_parts[1] > local_parts[1]:
-            return True
-            
-        return False
-    except Exception:
-        return False
-
-
-def update_local_version(new_version):
-    """更新本地版本记录"""
-    try:
-        with open(VERSION_FILE, "w") as f:
-            f.write(new_version)
-        return True
-    except Exception as e:
-        print(f"【⚠️ 更新本地版本记录失败：{str(e)}】")
-        return False
-
-
-def download_so_file(url, target_path):
-    """从指定URL下载so文件，支持进度显示与失败清理"""
-    try:
-        print(f"\n【📥 开始下载so文件】")
-        print(f"源地址：{url}")
-        print(f"保存路径：{os.path.abspath(target_path)}")
-
-        response = requests.get(
-            url,
-            stream=True,
-            timeout=60,
-            verify=False,
-            headers={"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"}
-        )
-        response.raise_for_status()
-
-        total_size = int(response.headers.get("Content-Length", 0))
-        downloaded_size = 0
-        chunk_size = 8192
-
-        with open(target_path, "wb") as f:
-            for chunk in response.iter_content(chunk_size=chunk_size):
-                if chunk:
-                    f.write(chunk)
-                    downloaded_size += len(chunk)
-                    if total_size > 0:
-                        progress = (downloaded_size / total_size) * 100
-                        print(f"下载进度：{progress:.1f}% | {downloaded_size}/{total_size} 字节", end="\r")
-
-        if total_size > 0:
-            print(f"下载进度：100.0% | {downloaded_size}/{total_size} 字节")
-        print(f"【✅ so文件下载完成】已保存为：{target_path}")
-        return True
-
-    except Exception as e:
-        # 捕获所有异常，准备使用本地备份
-        error_msg = str(e)
-        if isinstance(e, requests.exceptions.HTTPError):
-            error_msg = f"HTTP错误：{e.response.status_code} {e.response.reason}"
-            if e.response.status_code == 403:
-                error_msg += "（可能是链接权限不足）"
-            elif e.response.status_code == 404:
-                error_msg += "（文件不存在，链接可能已失效）"
-        elif isinstance(e, requests.exceptions.ConnectionError):
-            error_msg = "网络连接失败"
-        elif isinstance(e, requests.exceptions.Timeout):
-            error_msg = "下载超时"
-
-        print(f"\n【❌ so文件下载失败】")
-        print(f"错误详情：{error_msg}")
-        
-        # 清理可能的不完整文件
-        if os.path.exists(target_path):
-            os.remove(target_path)
-            
-        # 检查本地备份是否存在
-        if os.path.exists(LOCAL_BACKUP_FILE):
-            print(f"【ℹ️ 发现本地备用文件 {LOCAL_BACKUP_FILE}，将使用该文件执行任务】")
-            return False
-        else:
-            print(f"【❌ 未找到本地备用文件 {LOCAL_BACKUP_FILE}，无法继续执行】")
-            print(f"请加群获取帮助：https://t.me/+pGksv96SJjVjZTQ1")
-            sys.exit(1)
-
-
-def main():
-    # 终端颜色配置
-    GREEN = "\033[32m"
-    RED = "\033[31m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    RESET = "\033[0m"
-
-    # 1. 打印加群提示
-    print(f"{GREEN}="*50)
-    print(f"        加群获取白嫖卡密 | 问题反馈")
-    print(f"{BLUE}        交流群链接：https://t.me/+pGksv96SJjVjZTQ1")
-    print(f"{GREEN}="*50 + RESET)
-
-    # 2. 执行环境检查
-    print(f"\n{YELLOW}【🔍 开始环境兼容性检查】{RESET}")
-    check_python_version()
-    check_system_architecture()
-    print(f"\n{YELLOW}【✅ 所有环境检查通过】{RESET}")
-
-    # 3. 版本检查与更新逻辑
-    target_so_name = "kuaishou_task.so"
-    remote_so_url = "http://43.143.175.165:8888/down/REJLjrxQI1zg.so"
-    
-    local_version = get_local_version()
-    
-    server_version = get_server_version()
-    download_success = True  # 标记下载是否成功
-    
-    # 处理版本比较结果
-    if not server_version:
-        print("【⚠️ 无法获取服务器版本，将使用本地版本（如存在）】")
-        if not os.path.exists(target_so_name):
-            print("【ℹ️ 未发现本地so文件，将进行下载】")
-            download_success = download_so_file(remote_so_url, target_so_name)
-            if download_success:  # 只有下载成功才更新版本
-                update_local_version(local_version)
-    else:
-        if version_needs_update(local_version, server_version):
-            print(f"【🔄 发现新版本 {server_version}，正在更新...】")
-            # 下载并替换文件
-            if os.path.exists(target_so_name):
-                os.remove(target_so_name)
-            download_success = download_so_file(remote_so_url, target_so_name)
-            # 只有下载成功才更新版本
-            if download_success:
-                update_local_version(server_version)
-        else:
-            print(f"【✅ 本地版本 {local_version} 已是最新，无需更新】")
-            # 如果本地文件不存在，即使版本相同也下载
-            if not os.path.exists(target_so_name):
-                print("【ℹ️ 未发现本地so文件，将下载当前版本】")
-                download_success = download_so_file(remote_so_url, target_so_name)
-
-    # 4. 导入并执行快手任务（优先使用so文件，失败则使用本地Python文件）
-    try:
-        print(f"\n{YELLOW}【🚀 开始执行快手任务】{RESET}")
-        
-        # 根据下载情况选择导入方式
-        if download_success and os.path.exists(target_so_name):
-            print(f"【ℹ️ 使用so文件执行任务】")
-            import kuaishou_task
-            result = kuaishou_task.run_main()
-        else:
-            print(f"【ℹ️ 使用本地备用文件 {LOCAL_BACKUP_FILE} 执行任务】")
-            import kuaishou_so
-            result = kuaishou_so.run_main()
-
-        print(f"\n{GREEN}【🎉 任务执行完成】{RESET}")
-        print(f"任务执行结果：{result}")
-
-    except ImportError as e:
-        print(f"\n{RED}【❌ 模块导入失败】{RESET}")
-        print(f"错误详情：{str(e)}")
-        print("可能原因及解决方案：")
-        print(f"  1. {target_so_name}与系统架构不兼容")
-        print(f"  2. {LOCAL_BACKUP_FILE}文件不存在或有语法错误")
-        print(f"  3. 尝试重新运行脚本或获取最新版本")
-        sys.exit(1)
-
-    except Exception as e:
-        print(f"\n{RED}【❌ 执行快手任务失败】{RESET}")
-        print(f"错误详情：{str(e)}")
-        print("建议：加群反馈错误信息，获取技术支持")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

快手极速版_ENC.py

@@ -1,245 +0,0 @@
-
-#   入口: 快手极速版App 一机一号一个实名 只限安卓机器 （无需root） 最好一号一ip
-#   需抓取数据: 
-#   * 开抓包点福利后 搜索 earn/overview/tasks 找到此请求的cookie 同时找到此请求下的请求头的user-agent的值
-#   * 登录时搜索 api_client_salt 找到5kb左右的链接 在响应里最下面找到你的salt
-#   * 如果一个青龙跑两号及以上 则就需要填写socket5代理防止黑ip,注意一号一代理,不允许多号共用 第一个号不使用代理则不填 @代理ip|端口|代理用户名|代理密码
-#   * 变量: LinDong_ksjsb 填写上面获取的数据 格式为 备注@cookie@salt@user-agent [@代理ip|端口|代理用户名|代理密码](可选) 多号换行或新建同名变量
-#   * 变量: lindong_ksCard 卡密变量
-#   * 可选变量(可不填): lindong_ks_thread     最大线程数       默认 1
-#   * 可选变量(可不填): lindong_ks_maxgold    最大金币数       默认 50w (跑多了第二天可能1金币 有此需求请勿兑换金币)
-#   * 可选变量(可不填): lindong_ks_run_task   额外执行任务     默认 无 多个额外执行的任务用,分割
-#   * 可选的是 0:签到 | 1.宝箱 | 2.宝箱广告(需要运行宝箱广告必须开宝箱) | 3.饭补广告
-#   * 可选变量(可不填): lindong_ks_skipTaskAd 是否跳过任务广告 默认否 填1跳过
-#   * 需要安装依赖: py的 requests[socks]
-#   * 多号方式 [ 换行 | 新建同名变量 | & 分割 ]
-#   * tg群组:https://t.me/+1BVEpYhydgplYWY9
-#   ========================================================================================
-import os
-import sys
-import platform
-import subprocess
-import importlib
-import json
-import logging
-import glob
-try:
-    import requests
-except ImportError:
-    print("请安装依赖: pip install requests")
-    sys.exit(1)
-
-
-MODULE_NAME = 'ksjsb'
-API_BASE_URL = 'http://pyenc.lindong.xyz'
-
-MAX_RETRY = 3
-logging.basicConfig(level=logging.INFO, format='[%(levelname)s] ===> %(message)s')
-log = logging.getLogger(__name__)
-
-class SoManager:
-    def __init__(self, module_name, api_base_url):
-        self.module_name = module_name
-        self.api_base_url = api_base_url.rstrip('/')
-        self.api_url = f"{self.api_base_url}/api.php"
-        self.version_file = f"{module_name}.version"
-        self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
-        self.arch = self._get_arch()
-        self.platform_key = f"{self.arch}_py{self.python_version.replace('.', '')}"
-        
-
-    
-    def _get_arch(self):
-        machine = platform.machine().lower()
-        if machine in ['x86_64', 'amd64', 'x64']:
-            return 'x64'
-        elif machine in ['aarch64', 'arm64']:
-            return 'aarch64'
-        else:
-            log.warning(f"未知架构 {machine}，默认使用 x64")
-            return 'x64'
-    
-    def _check_system_compatibility(self):
-        if sys.version_info.major != 3 or sys.version_info.minor not in [10, 11]:
-            log.error(f"不支持的Python版本 {sys.version}，请使用Python 3.10或3.11")
-            return False
-        if platform.system() != 'Linux':
-            log.error(f"不支持的操作系统 {platform.system()}，请使用Linux系统")
-            return False
-        log.info(f"系统检测通过 [Python {sys.version}] [{platform.system()} {platform.machine()}]")
-        return True
-    
-    def _get_local_version(self):
-        try:
-            if os.path.exists(self.version_file):
-                with open(self.version_file, 'r') as f:
-                    return f.read().strip()
-        except Exception as e:
-            log.warning(f"读取本地版本失败: {e}")
-        return None
-    
-    def _save_local_version(self, version):
-        try:
-            with open(self.version_file, 'w') as f:
-                f.write(str(version))
-        except Exception as e:
-            log.error(f"保存版本号失败: {e}")
-    
-    def _get_remote_latest(self):
-        try:
-            payload = {
-                "action": "get_latest",
-                "module_name": self.module_name
-            }
-            
-            response = requests.post(
-                self.api_url,
-                json=payload,
-                timeout=30,
-                headers={'Content-Type': 'application/json'}
-            )
-            
-            if response.status_code != 200:
-                log.error(f"API请求失败: HTTP {response.status_code}")
-                return None
-            
-            data = response.json()
-            if not data.get('success'):
-                log.error(f"API返回错误: {data.get('message', '未知错误')}")
-                return None
-            
-            return data
-            
-        except requests.exceptions.RequestException as e:
-            log.error(f"网络请求失败: {e}")
-            return None
-        except json.JSONDecodeError as e:
-            log.error(f"JSON解析失败: {e}")
-            return None
-        except Exception as e:
-            log.error(f"获取远程版本失败: {e}")
-            return None
-    
-    def _download_file(self, download_url):
-        """下载.so文件"""
-        temp_file = f"{self.so_filename}.tmp"
-        
-        for attempt in range(MAX_RETRY):
-            try:
-                log.info(f"开始下载 (尝试 {attempt + 1}/{MAX_RETRY}): {download_url}")
-                
-                response = requests.get(download_url, timeout=180, stream=True)
-                if response.status_code != 200:
-                    log.error(f"下载失败: HTTP {response.status_code}")
-                    continue
-                with open(temp_file, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        if chunk:
-                            f.write(chunk)
-                if os.path.getsize(temp_file) == 0:
-                    log.error("下载的文件为空")
-                    os.remove(temp_file)
-                    continue
-                if os.path.exists(self.so_filename):
-                    os.remove(self.so_filename)
-                os.rename(temp_file, self.so_filename)
-                
-                log.info(f"文件下载成功: {self.so_filename}")
-                return True
-                
-            except Exception as e:
-                log.error(f"下载失败: {e}")
-                if os.path.exists(temp_file):
-                    os.remove(temp_file)
-        
-        log.error(f"下载失败，已尝试 {MAX_RETRY} 次")
-        return False
-    
-    def _execute_module(self):
-        """执行模块"""
-        try:
-            if not os.path.exists(self.so_filename):
-                log.error(f".so文件不存在: {self.so_filename}")
-                return False
-            
-            print('=' * 50)
-            module_obj = importlib.import_module(self.so_moudel)
-            if hasattr(module_obj, 'main'):
-                module_obj.main()
-            else:
-                log.warning("模块中没有找到main函数")
-            
-            return True
-            
-        except ImportError as e:
-            log.error(f"模块导入失败: {e}")
-            return False
-        except AttributeError as e:
-            log.error(f"模块执行失败: {e}")
-            return False
-        except Exception as e:
-            log.error(f"执行异常: {e}")
-            return False
-    
-    def check_and_update(self):
-        remote_info = self._get_remote_latest()
-        if not remote_info:
-            log.error("无法获取远程版本信息")
-            return False
-        remote_version = str(remote_info['latest_version'])
-        self.so_filename = f"{self.module_name}_{remote_version}.so"
-        self.so_moudel = f"{self.module_name}_{remote_version}"
-        local_version = self._get_local_version()
-        vlocal_version = 'v' + local_version if local_version else '无'
-        
-        log.info(f"本地版本: {vlocal_version} | 远程最新版本: v{remote_version}")
-        need_download = False
-        if not os.path.exists(self.so_filename):
-            log.info("本地文件不存在，需要下载")
-            need_download = True
-        elif local_version != remote_version:
-            log.info("版本不一致，需要更新")
-            need_download = True
-        else:
-            log.info("版本已是最新，无需下载")
-
-        if need_download:
-            files = remote_info.get('files', {})
-            download_url = files.get(self.platform_key)
-            
-            if not download_url:
-                log.error(f"没有找到适合平台 {self.platform_key} 的下载链接")
-                available_platforms = list(files.keys())
-                log.error(f"可用平台: {available_platforms}")
-                return False
-            
-            if self._download_file(download_url):
-                self._save_local_version(remote_version)
-            else:
-                log.error("文件下载失败")
-                return False
-        
-        return True
-    
-    def run(self):
-        if not self._check_system_compatibility():
-            return False
-        if not self.check_and_update():
-            return False
-        return self._execute_module()
-
-def main():
-    try:
-        manager = SoManager(MODULE_NAME, API_BASE_URL)
-        manager.run()
-
-            
-    except KeyboardInterrupt:
-        log.info("用户中断执行")
-        sys.exit(1)
-    except Exception as e:
-        log.error(f"未知错误: {e}")
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

砍手普通版.py

@@ -0,0 +1,159 @@
+
+import os
+import urllib.request
+import sys
+import time
+import platform
+
+
+class SystemChecker:
+    @staticmethod
+    def is_arm_architecture():
+        """检测是否为ARM架构"""
+        machine = platform.machine().lower()
+        arm_patterns = [
+            'arm', 'aarch', 'arm64', 'aarch64',
+            'armv7', 'armv8', 'armhf'
+        ]
+        return any(pattern in machine for pattern in arm_patterns)
+
+    @staticmethod
+    def is_amd_architecture():
+        """检测是否为AMD/x86架构"""
+        machine = platform.machine().lower()
+        amd_patterns = [
+            'x86_64', 'amd64', 'x86', 'i386', 'i686',
+            'amd', 'intel', 'x64'
+        ]
+        return any(pattern in machine for pattern in amd_patterns)
+
+    @staticmethod
+    def is_supported_architecture():
+        """检测是否支持ARM或AMD架构"""
+        return SystemChecker.is_arm_architecture() or SystemChecker.is_amd_architecture()
+
+    @staticmethod
+    def is_linux_supported():
+        """检测是否为Linux且支持ARM或AMD架构"""
+        return SystemChecker.is_supported_architecture()
+
+    @staticmethod
+    def get_architecture_type():
+        """获取具体的架构类型"""
+        if SystemChecker.is_arm_architecture():
+            return 'arm'
+        elif SystemChecker.is_amd_architecture():
+            return 'amd'
+        else:
+            return 'unknown'
+
+    @staticmethod
+    def get_detailed_info():
+        return {
+            'os': platform.system(),
+            'architecture': platform.machine(),
+            'arch_type': SystemChecker.get_architecture_type()
+        }
+
+
+checker = SystemChecker()
+
+if checker.is_linux_supported():
+    pass
+else:
+    info = checker.get_detailed_info()
+    print(f'当前系统不支持,当前系统类型: {info["os"]},系统架构: {info["architecture"]}')
+    exit(1)
+
+def get_architecture():
+    """获取系统架构"""
+    arch = platform.machine().lower()
+    if 'arm' in arch or 'aarch' in arch:
+        return 'arm'
+    elif 'x86' in arch or 'amd' in arch or 'i386' in arch or 'i686' in arch:
+        return 'amd'
+    else:
+        return arch
+
+current_arch = get_architecture()
+
+####################使用教程区####################
+
+#广告类型：1为普通广告， 2为200广(已单独剔出)，3为宝箱广告，其他值为以上全部执行,默认全部执行
+# 抓包 ck和salt
+# 格式1：备注#Cookie#salt#广告类型(备注#Cookie#salt#1,3)
+# 格式2：备注#Cookie#salt#广告类型#sock5
+#广告类型为列表模式，使用英文逗号隔开，填什么就指定跑什么
+# socks5存在则使用代理，反之
+# socks代理选择参数，可填可不填 格式：ip|port|username|password
+# ck变量：ksck, 填写上面两种格式ck均可，多号新建变量即可
+# 并发变量：KSP_BF, 设置为False为关闭并发，默认开启
+# 卡密变量：KSP_Card 填写购买的卡密即可
+# 金币自动兑换变量：KSP_JBDH 默认关闭，True开启
+# 运行延迟变量：KSP_YC 默认30,45，格式为【最低,最高】，中间英文逗号隔开
+# 运行次数变量：KSP_YXCS 默认200
+# 金币控制变量：KSP_JBMAX 默认500000
+# 广告模式变量：KSP_ADMS 默认为1(正常广告)，设置2为追加(理论默认即可)
+# 自动更换did变量：KSP_DID 默认关闭，True开启(实测不好用)
+# 自动更换did金币数量变量：KSP_JBSU 低于多少尝试更换did，默认1000，自动更换开启生效
+
+
+def GET_SO():
+    PythonV = sys.version_info
+    if PythonV.major == 3 and PythonV.minor == 10:
+        PythonV = '10'
+        print('当前Python版本为3.10 开始安装...')
+    elif PythonV.major == 3 and PythonV.minor == 11:
+        PythonV = '11'
+        print('当前Python版本为3.11 开始安装...')
+    else:
+        return False, f'不支持的Python版本：{sys.version}'
+
+    try:
+        mirrors = [
+            f'https://raw.bgithub.xyz/BIGOSTK/pyso/refs/heads/main/ksadp_{current_arch}_{PythonV}.so',
+            f'https://gh-proxy.com/https://raw.githubusercontent.com/BIGOSTK/pyso/main/ksadp_{current_arch}_{PythonV}.so',
+            f'https://raw.githubusercontent.com/BIGOSTK/pyso/main/ksadp_{current_arch}_{PythonV}.so',
+            f'https://raw.bgithub.xyz/BIGOSTK/pyso/main/ksadp_{current_arch}_{PythonV}.so'
+        ]
+
+        last_error = None
+        for url in mirrors:
+            try:
+                print(f'尝试从 {url} 下载...')
+                with urllib.request.urlopen(url, timeout=15) as response:
+                    if response.status == 200:
+                        with open('./ksadp.so', 'wb') as out_file:
+                            out_file.write(response.read())
+                        print('下载成功')
+                        return True, None
+            except Exception as e:
+                last_error = e
+                print(f'下载失败: {e}')
+                time.sleep(1)
+
+        return False, f'所有镜像尝试失败: {last_error}'
+
+    except Exception as e:
+        return False, e
+
+
+def main():
+    if not os.path.exists('./ksadp.so'):
+        success, error = GET_SO()
+        if not success:
+            print(f'无法获取ksadp.so: {error}')
+            return
+
+    try:
+        import ksadp
+        ksadp.main()
+    except ImportError as e:
+        print(f'导入ksadp模块失败: {e}')
+    except Exception as e:
+        print(f'执行ksadp.main()时出错: {e}')
+
+
+if __name__ == '__main__':
+    main()
+

砍手极速版.py

@@ -0,0 +1,158 @@
+import os
+import urllib.request
+import sys
+import time
+import platform
+
+
+class SystemChecker:
+    @staticmethod
+    def is_arm_architecture():
+        """检测是否为ARM架构"""
+        machine = platform.machine().lower()
+        arm_patterns = [
+            'arm', 'aarch', 'arm64', 'aarch64',
+            'armv7', 'armv8', 'armhf'
+        ]
+        return any(pattern in machine for pattern in arm_patterns)
+
+    @staticmethod
+    def is_amd_architecture():
+        """检测是否为AMD/x86架构"""
+        machine = platform.machine().lower()
+        amd_patterns = [
+            'x86_64', 'amd64', 'x86', 'i386', 'i686',
+            'amd', 'intel', 'x64'
+        ]
+        return any(pattern in machine for pattern in amd_patterns)
+
+    @staticmethod
+    def is_supported_architecture():
+        """检测是否支持ARM或AMD架构"""
+        return SystemChecker.is_arm_architecture() or SystemChecker.is_amd_architecture()
+
+    @staticmethod
+    def is_linux_supported():
+        """检测是否为Linux且支持ARM或AMD架构"""
+        return SystemChecker.is_supported_architecture()
+
+    @staticmethod
+    def get_architecture_type():
+        """获取具体的架构类型"""
+        if SystemChecker.is_arm_architecture():
+            return 'arm'
+        elif SystemChecker.is_amd_architecture():
+            return 'amd'
+        else:
+            return 'unknown'
+
+    @staticmethod
+    def get_detailed_info():
+        return {
+            'os': platform.system(),
+            'architecture': platform.machine(),
+            'arch_type': SystemChecker.get_architecture_type()
+        }
+
+
+checker = SystemChecker()
+
+if checker.is_linux_supported():
+    pass
+else:
+    info = checker.get_detailed_info()
+    print(f'当前系统不支持,当前系统类型: {info["os"]},系统架构: {info["architecture"]}')
+    exit(1)
+
+def get_architecture():
+    """获取系统架构"""
+    arch = platform.machine().lower()
+    if 'arm' in arch or 'aarch' in arch:
+        return 'arm'
+    elif 'x86' in arch or 'amd' in arch or 'i386' in arch or 'i686' in arch:
+        return 'amd'
+    else:
+        return arch
+
+current_arch = get_architecture()
+
+####################使用教程区####################
+
+#广告类型：1为饭补， 2为看广告，3为宝箱广告，4为200广(已单独剔出)，其他值为以上全部执行,默认全部执行
+# 抓包 ck和salt
+# 格式1：备注#Cookie#salt#广告类型(备注#Cookie#salt#1,2)
+# 格式2：备注#Cookie#salt#广告类型#sock5
+#广告类型为列表模式，使用英文逗号隔开，填什么就指定跑什么
+# socks5存在则使用代理，反之
+# socks代理选择参数，可填可不填 格式：ip|port|username|password
+# ck变量：ksjsbck, 填写上面两种格式ck均可，多号新建变量即可
+# 并发变量：KS_BF, 设置为False为关闭并发，默认开启
+# 卡密变量：KS_Card 填写购买的卡密即可
+# 金币自动兑换变量：KS_JBDH 默认关闭，True开启
+# 自动提现变量：KS_TX 默认关闭，True开启
+# 运行延迟变量：KS_YC 默认30,45，格式为【最低,最高】，中间英文逗号隔开
+# 运行次数变量：KS_YXCS 默认999
+# 金币控制变量：KS_JBMAX 默认500000
+# 广告模式变量：KS_ADMS 默认为1(正常广告)，设置2为追加(理论默认即可)
+# 自动更换did变量：KS_DID 默认关闭，True开启(实测不好用)
+# 自动更换did金币数量变量：KS_JBSU 低于多少尝试更换did，默认900，自动更换开启生效
+
+
+def GET_SO():
+    PythonV = sys.version_info
+    if PythonV.major == 3 and PythonV.minor == 10:
+        PythonV = '10'
+        print('当前Python版本为3.10 开始安装...')
+    elif PythonV.major == 3 and PythonV.minor == 11:
+        PythonV = '11'
+        print('当前Python版本为3.11 开始安装...')
+    else:
+        return False, f'不支持的Python版本：{sys.version}'
+
+    try:
+        mirrors = [
+            f'https://raw.bgithub.xyz/BIGOSTK/pyso/refs/heads/main/ksad_{current_arch}_{PythonV}.so',
+            f'https://gh-proxy.com/https://raw.githubusercontent.com/BIGOSTK/pyso/main/ksad_{current_arch}_{PythonV}.so',
+            f'https://raw.githubusercontent.com/BIGOSTK/pyso/main/ksad_{current_arch}_{PythonV}.so',
+            f'https://raw.bgithub.xyz/BIGOSTK/pyso/main/ksad_{current_arch}_{PythonV}.so'
+        ]
+
+        last_error = None
+        for url in mirrors:
+            try:
+                print(f'尝试从 {url} 下载...')
+                with urllib.request.urlopen(url, timeout=15) as response:
+                    if response.status == 200:
+                        with open('./ksad.so', 'wb') as out_file:
+                            out_file.write(response.read())
+                        print('下载成功')
+                        return True, None
+            except Exception as e:
+                last_error = e
+                print(f'下载失败: {e}')
+                time.sleep(1)
+
+        return False, f'所有镜像尝试失败: {last_error}'
+
+    except Exception as e:
+        return False, e
+
+
+def main():
+    if not os.path.exists('./ksad.so'):
+        success, error = GET_SO()
+        if not success:
+            print(f'无法获取ksad.so: {error}')
+            return
+
+    try:
+        import ksad
+        ksad.main()
+    except ImportError as e:
+        print(f'导入ksad模块失败: {e}')
+    except Exception as e:
+        print(f'执行ksad.main()时出错: {e}')
+
+
+if __name__ == '__main__':
+    main()