#!/bin/bash
#验证版本1.0.2更新时间2025/9/5更新心跳验证11月23发布使用
#官方网站b6w.cn
#云更新m.b6w.cn
#shell卡密验证云更新系统对接
#请使用MT管理器终端扩展包环境执行无需root只需MT管理器终端扩展包执行
#云更新策略是只要后台没有勾选强制更新就会让用户选择是否更新
#勾选了就会系统强制自动更新.不给用户选择是否选择更新版本号不一致会强制更新
#覆盖原有的内容为新版本下载链接里面的内容
#后台更新的链接可以填写sh后缀的还有zip后缀的
#远程文件是sh则是直接替换当前文件的内容为新版本
#远程文件是zip压缩包则是下载需手动移动出来执行
#因为有些人说他们是执行so要更新so所以用户的意见添加了新版本
#这样只需把sh和so放在压缩包里面做下载下来会手动移动出来执行新版本
# ===================== 开发者配置选项 =====================
#APP ID 也就是apikey
API_KEY="6194a4117a4c034acd7aaac459fd7556"
#版本号判断更新使用
CURRENT_VERSION="2.7.1"
#新版本更新后是否自动重启脚本执行
#  - 填1：更新替换文件内容后，自动重启脚本执行
#  - 填0：更新替换文件内容后，退出脚本，需用户手动重新执行
AUTO_EXEC_AFTER_UPDATE="1"
#心跳验证时间5分钟，也就是300秒（当前配置为300秒，可按需修改）
#不可低于30秒-否则系统检测到异常会封禁
HEARTBEAT_INTERVAL=300
#服务器无响应-无网络尝试次数(不用管)
HEARTBEAT_RETRY=3

# ======================开发者配置完成-下方代码无需修改======================

API_URL_UPDATE=$(echo "aHR0cHM6Ly9tLmI2dy5jbi9hcGkvYjZ3YXBpeWd4LnBocA==" | base64 -d)
API_URL_VERIFY=$(echo "aHR0cHM6Ly9tLmI2dy5jbi9hcGkvYjZ3YXBpa2V5LnBocA==" | base64 -d)
REPORT_URL=$(echo "aHR0cHM6Ly9tLmI2dy5jbi9hcGkvc2IucGhw" | base64 -d)
SIGN_KEY="必6网.免费的云更新验证系统官方网站部分浏览器显示有风险可以换个浏览器-浏览器搜索b6w.cn"
DEVICE_FILE="/data/local/tmp/.device_code.txt"
BACKUP_DEVICE_FILE="./.device_code.txt"
CARD_KEY_MAIN_FILE="/data/local/tmp/.saved_card_key.txt"
CARD_KEY_BACKUP_FILE="./.saved_card_key.txt"
RETRY_INTERVAL=3
get_device_code() {
    local hardware_id=""
    if [ -z "$hardware_id" ] && [ -f "/sys/class/android_usb/android0/iSerial" ]; then
        hardware_id=$(cat /sys/class/android_usb/android0/iSerial 2>/dev/null | tr -d ' \n\r')
    fi
    if [ -z "$hardware_id" ] && [ -f "/proc/cpuinfo" ]; then
        hardware_id=$(grep -i 'serial' /proc/cpuinfo 2>/dev/null | head -n1 | awk -F: '{print $2}' | tr -d ' \n\r')
    fi
    if [ -z "$hardware_id" ] && command -v getprop &>/dev/null; then
        hardware_id=$(getprop ro.serialno 2>/dev/null | tr -d ' \n\r')
        if [ -z "$hardware_id" ]; then
            hardware_id=$(getprop ro.boot.serialno 2>/dev/null | tr -d ' \n\r')
        fi
    fi
    if [ -z "$hardware_id" ] && [ -f "/sys/class/bluetooth/hci0/address" ]; then
        hardware_id=$(cat /sys/class/bluetooth/hci0/address 2>/dev/null | tr -d ':\n\r')
    fi
    if [ -z "$hardware_id" ] && [ -f "/sys/class/net/wlan0/address" ]; then
        hardware_id=$(cat /sys/class/net/wlan0/address 2>/dev/null | tr -d ':\n\r')
    fi
    if [ -z "$hardware_id" ]; then
        if [ -f "$BACKUP_DEVICE_FILE" ]; then
            hardware_id=$(cat "$BACKUP_DEVICE_FILE" 2>/dev/null | tr -d ' \n\r')
        elif [ -f "$DEVICE_FILE" ]; then
            hardware_id=$(cat "$DEVICE_FILE" 2>/dev/null | tr -d ' \n\r')
        else
            hardware_id=$(date +%s | md5sum | head -c 16)
        fi
    fi
    local fixed_code="$hardware_id"
    if [ ${#fixed_code} -gt 32 ]; then
        fixed_code="${fixed_code:0:32}"
    elif [ ${#fixed_code} -lt 32 ]; then
        fixed_code=$(printf "%-32s" "$fixed_code" | tr ' ' '0')
    fi
    if ! echo "$fixed_code" > "$BACKUP_DEVICE_FILE" 2>/dev/null; then
        if echo "$fixed_code" > "$DEVICE_FILE" 2>/dev/null; then
            DEVICE_FILE="$DEVICE_FILE"
        else
            echo "[警告] 设备码文件写入失败，临时生效" >&2
        fi
    else
        DEVICE_FILE="$BACKUP_DEVICE_FILE"
    fi
    chmod 600 "$DEVICE_FILE" 2>/dev/null

    echo "$fixed_code"
}
DEVICE_CODE=$(get_device_code)
[ -z "$DEVICE_CODE" ] && { echo "设备码生成失败" >&2; exit 1; }

request_with_retry() {
    local url="$1"
    local data="$2"
    local retry_count=1

    while true; do
        local response=$(curl -s --connect-timeout 10 -X POST "$url" \
            -H "Content-Type: application/json" \
            -d "$data")

        if [ $? -eq 0 ] && [ -n "$response" ]; then
            echo "$response"
            return 0
        else
            echo "[重试] 接口请求失败（第$retry_count次），$RETRY_INTERVAL秒后重试..."
            sleep $RETRY_INTERVAL
            retry_count=$((retry_count + 1))
        fi
    done
}

extract_field() {
    local key="$1"
    local json="$2"
    echo "$json" | grep -o "\"$key\":\"[^\"]*\"" | sed "s/\"$key\":\"//;s/\"//;s/^[[:space:]]*//;s/[[:space:]]*$//"
}

extract_boolean() {
    local key="$1"
    local json="$2"
    echo "$json" | sed -n "s/.*\"$key\"\s*:\s*\(\(true\)\|\(false\)\).*/\1/p"
}

check_update() {
    echo "===== 开始云更新检查 ====="

    local verify_data='{"action":"verify_api_key", "api_key":"'$API_KEY'"}'
    local verify_response=$(request_with_retry "$API_URL_UPDATE" "$verify_data")
    local app_id=$(extract_field "app_id" "$verify_response")

    if [ -z "$app_id" ]; then
        local error_msg=$(extract_field "error" "$verify_response")
        echo "[错误] 更新验证失败：$error_msg"
        return 1
    fi
    echo "[成功] 应用ID：$app_id"

    local config_data='{"action":"get_config", "app_id":"'$app_id'"}'
    local config_response=$(request_with_retry "$API_URL_UPDATE" "$config_data")

    local announcement=$(extract_field "announcement" "$config_response")
    local latest_version=$(extract_field "latest_version" "$config_response")
    local update_url=$(extract_field "update_url" "$config_response")
    local force_update=$(extract_boolean "force_update" "$config_response")

    local force_update_cn="否"
    [ "$force_update" = "true" ] && force_update_cn="是"

    echo -e "\n[配置信息]:"
    echo -n "  公告内容："
    if [ -n "$announcement" ]; then
        echo -e "$announcement"
    else
        echo "无公告"
    fi
    echo "  当前版本：$CURRENT_VERSION（本地）"
    echo "  最新版本：$latest_version（云端）"
    echo "  是否强制更新：$force_update_cn"
    echo "  开发者更新配置-更新后自动执行：$( [ "$AUTO_EXEC_AFTER_UPDATE" = "1" ] && echo "是" || echo "否" )"

    update_url=$(echo "$update_url" | sed 's/\\\//\//g')

    if [ "$latest_version" != "$CURRENT_VERSION" ] && [ -n "$update_url" ] && [ "$latest_version" != "" ]; then
        echo -e "\n[发现新版本] $latest_version"
        
        if ! command -v curl &> /dev/null; then
            echo "[错误] 缺少curl工具，请安装后重试"
            exit 1
        fi

        if [ "$force_update" = "true" ]; then
            echo "[强制更新] 必须更新才能继续使用！"
            update_action=1
        else
            echo "[非强制更新] 发现新版本，是否更新？（1=更新，0=不更新，默认0）"
            read -p "请输入选择（1/0）：" user_choice
            if [ -z "$user_choice" ]; then
                user_choice=0
            fi
            if [ "$user_choice" -eq 1 ]; then
                echo "正在更新..."
                update_action=1
            else
                echo "推荐更新新版本体验最佳"
                update_action=0
                rm -f "$new_file_path" 2>/dev/null
                return 0
            fi
        fi

        if [ $update_action -eq 1 ]; then
            local script_path=$(cd "$(dirname "$0")" || exit; pwd)
            local script_name=$(basename "$0")
            local new_file_path="${script_path}/temp_update_file"

            while true; do
                if curl -fL "$update_url" -o "$new_file_path" &> /dev/null; then
                    break
                else
                    echo "[重试] 更新文件下载失败，$RETRY_INTERVAL秒后重试..."
                    sleep $RETRY_INTERVAL
                fi
            done

            local file_ext=$(echo "$update_url" | awk -F. '{print $NF}' | tr 'A-Z' 'a-z' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
            echo "[更新文件信息] 后缀：$file_ext"

            if [ "$file_ext" = "zip" ]; then
                echo "[更新处理] 识别ZIP文件，生成唯一文件名（保留所有旧文件）"
                local random_str=$(date +%s%N | md5sum | head -c 8)
                local zip_file_name="${script_name%.sh}-${latest_version}-${random_str}.zip"
                local zip_file_path="${script_path}/${zip_file_name}"
            
                if [ -f "$zip_file_path" ]; then
                    echo "[提示] 极端情况：文件名已存在，重新生成随机字符..."
                    random_str=$(date +%s%N | md5sum | head -c 8)
                    zip_file_name="${script_name%.sh}-${latest_version}-${random_str}.zip"
                    zip_file_path="${script_path}/${zip_file_name}"
                fi

                if cat "$new_file_path" > "$0"; then
                    mv -f "$0" "$zip_file_path"
                    echo "[成功] ZIP更新完成：$zip_file_path"
                    echo "[提示] 所有旧版本ZIP文件已完整保留，新文件通过版本号+随机字符区分"
                    echo "[提示] ZIP文件无法自动执行，已退出"
                    rm -f "$new_file_path"
                    exit 0
                else
                    echo "[错误] ZIP文件内容替换失败"
                    rm -f "$new_file_path"
                    exit 1
                fi
            else
                echo "[更新处理] 识别非ZIP文件，覆盖更新并准备自动执行"
                local backup_script_path="${script_path}/${script_name}.bak"
                cp -f "$0" "$backup_script_path" 2>/dev/null
                if cat "$new_file_path" > "$0"; then
                    chmod +x "$0"
                    echo "[成功] 脚本更新至 $latest_version（旧脚本已备份为 ${script_name}.bak）"
                    rm -f "$new_file_path"
                    if [ "$AUTO_EXEC_AFTER_UPDATE" = "1" ]; then
                        echo "按配置：立即自动执行更新后的脚本..."
                        exec bash "$0"
                        echo "[警告] 自动执行触发失败，请手动运行 $0"
                        exit 1
                    else
                        echo "按配置：不自动执行，请手动重启 $0"
                        exit 0
                    fi
                else
                    echo "[错误] 非ZIP文件更新失败，恢复旧脚本..."
                    cp -f "$backup_script_path" "$0" 2>/dev/null
                    rm -f "$new_file_path" "$backup_script_path"
                    exit 1
                fi
            fi

        fi

    else
        if [ "$latest_version" = "$CURRENT_VERSION" ]; then
            echo -e "\n[状态] 本地版本（$CURRENT_VERSION）与云端版本（$latest_version）一致，无需更新"
        elif [ -z "$update_url" ]; then
            echo -e "\n[状态] 虽有新版本（$latest_version），但云端未配置更新链接，无法更新"
        else
            echo -e "\n[状态] 当前已是最新版本"
        fi
    fi

    echo -e "\n===== 更新检查完成 ====="
}

decode_unicode() {
    local str="$1"
    awk -v str="$str" 'BEGIN {
        while (match(str, /\\u([0-9a-fA-F]{4})/, arr)) {
            c = sprintf("%c", strtonum("0x" arr[1]))
            gsub(/\\u[0-9a-fA-F]{4}/, c, str)
        }
        print str
    }'
}

generate_sign() {
    local data="$1"
    local salt="$2"
    local timestamp="$3"
    echo -n "${data}${salt}${timestamp}${SIGN_KEY}" | md5sum | awk '{print $1}'
}

report_tampering() {
    local request_params="$1"
    local tampered_response="$2"
    local timestamp="$3"
    local client_ip=$(curl -s --connect-timeout 5 http://icanhazip.com 2>/dev/null || \
                      curl -s --connect-timeout 5 http://ip.cn/ip 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' || \
                      echo "未知IP")
    client_ip=$(echo "$client_ip" | tr -d '\n\r')

    req_escaped=$(echo "$request_params" | sed 's/\\/\\\\/g')
    resp_escaped=$(echo "$tampered_response" | sed 's/\\/\\\\/g')
    req_escaped=$(echo "$req_escaped" | sed 's/"/\\"/g')
    resp_escaped=$(echo "$resp_escaped" | sed 's/"/\\"/g')
    req_escaped=$(echo "$req_escaped" | sed ':a;N;$!ba;s/\n/\\n/g')
    resp_escaped=$(echo "$resp_escaped" | sed ':a;N;$!ba;s/\n/\\n/g')
    req_escaped=$(echo "$req_escaped" | sed 's/\r/\\r/g; s/\t/\\t/g')
    resp_escaped=$(echo "$resp_escaped" | sed 's/\r/\\r/g; s/\t/\\t/g')

    report_data="{\"ip\":\"$client_ip\",\"timestamp\":\"$timestamp\",\"request_params\":\"$req_escaped\",\"tampered_response\":\"$resp_escaped\"}"
    report_result=$(curl -s --connect-timeout 10 -X POST "$REPORT_URL" \
        -H "Content-Type: application/json" -d "$report_data")
    result_msg=$(echo "$report_result" | sed -n 's/.*"message":"\([^"]*\)".*/\1/p' | decode_unicode)
    echo "数据已记录上传结果：${result_msg:-篡改数据已上传}"
}

verify_card_key() {
    echo -e "\n===== 开始卡密验证 ====="

    local CARD_KEY=""
    # 修复：先读当前目录备份文件（优先级高），再读主路径文件
    if [ -f "$CARD_KEY_BACKUP_FILE" ]; then
        CARD_KEY=$(cat "$CARD_KEY_BACKUP_FILE" 2>/dev/null | tr -d ' \n\r')
        if [ -n "$CARD_KEY" ]; then
            echo "[自动登录] 从当前目录读取到卡密，自动验证..."
            goto_verify=true
        else
            rm -f "$CARD_KEY_BACKUP_FILE"
            CARD_KEY=""
        fi
    fi

    # 若当前目录无有效卡密，再读主路径文件
    if [ -z "$CARD_KEY" ] && [ -f "$CARD_KEY_MAIN_FILE" ]; then
        CARD_KEY=$(cat "$CARD_KEY_MAIN_FILE" 2>/dev/null | tr -d ' \n\r')
        if [ -n "$CARD_KEY" ]; then
            echo "[自动登录] 从主路径读取到卡密，自动验证..."
        else
            rm -f "$CARD_KEY_MAIN_FILE"
            CARD_KEY=""
        fi
    fi

    while true; do
        if [ -z "$CARD_KEY" ]; then
            read -p "请输入卡密：" CARD_KEY
            if [ -z "$CARD_KEY" ]; then
                echo "卡密不能为空，请重新输入"
                continue
            fi
        fi

        TIMESTAMP=$(date +%s)
        REQUEST_PARAMS=$(printf '{"api_key":"%s","key":"%s","device_code":"%s","timestamp":"%s"}' \
            "$API_KEY" "$CARD_KEY" "$DEVICE_CODE" "$TIMESTAMP")

        RESPONSE=$(request_with_retry "$API_URL_VERIFY" "$REQUEST_PARAMS")

        CODE=$(echo "$RESPONSE" | sed -n 's/.*"code":[[:space:]]*\([0-9]*\).*/\1/p; s/.*"code"[[:space:]]*:[[:space:]]*\([0-9]*\),.*/\1/p' | head -n1)
        MESSAGE_RAW=$(echo "$RESPONSE" | sed -n 's/.*"message":[[:space:]]*"\([^"]*\)".*/\1/p; s/.*"message":[[:space:]]*"\([^"]*\)",.*/\1/p' | head -n1)
        MESSAGE=$(decode_unicode "$MESSAGE_RAW")
        DATA=$(echo "$RESPONSE" | sed -n 's/.*"data":[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
        SALT=$(echo "$RESPONSE" | sed -n 's/.*"salt":[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
        SERVER_SIGN=$(echo "$RESPONSE" | sed -n 's/.*"sign":[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)

        if [ "$CODE" -eq 200 ] && [ -n "$DATA" ] && [ -n "$SALT" ] && [ -n "$SERVER_SIGN" ]; then
            CLIENT_SIGN=$(generate_sign "$DATA" "$SALT" "$TIMESTAMP")
            if [ "$CLIENT_SIGN" != "$SERVER_SIGN" ]; then
                echo "验证失败：数据被篡改.请勿非法破解.严重的提交至公安机关处理"
                report_tampering "$REQUEST_PARAMS" "$RESPONSE" "$TIMESTAMP"
                CARD_KEY=""
                continue
            fi

            RAW_DATA=$(echo -n "$DATA" | base64 -d 2>/dev/null)
            EXPIRES_AT=$(echo "$RAW_DATA" | sed -n 's/.*"expires_at":[[:space:]]*"\([^"]*\)".*/\1/p; s/.*"expires_at":"\([^"]*\)".*/\1/p' | head -n1 | tr -d ' \n\r}')
            USED_DEVICES=$(echo "$RAW_DATA" | sed -n 's/.*"used_devices":[[:space:]]*\([0-9]*\).*/\1/p; s/.*"used_devices":\([0-9]*\).*/\1/p' | head -n1 | tr -d ' \n\r,}')
            MAX_DEVICES=$(echo "$RAW_DATA" | sed -n 's/.*"max_devices":[[:space:]]*\([0-9]*\).*/\1/p; s/.*"max_devices":\([0-9]*\).*/\1/p' | head -n1 | tr -d ' \n\r,}')

            if [ -n "$EXPIRES_AT" ] && [ -n "$USED_DEVICES" ] && [ -n "$MAX_DEVICES" ]; then
                # 保存卡密：优先当前目录（无需root），失败再试主路径
                if echo "$CARD_KEY" > "$CARD_KEY_BACKUP_FILE" 2>/dev/null; then
                    chmod 600 "$CARD_KEY_BACKUP_FILE"
                    echo "[自动登录] 卡密已保存到当前目录（$CARD_KEY_BACKUP_FILE），下次自动验证"
                elif echo "$CARD_KEY" > "$CARD_KEY_MAIN_FILE" 2>/dev/null; then
                    chmod 600 "$CARD_KEY_MAIN_FILE"
                    echo "[自动登录] 卡密已保存到主路径（$CARD_KEY_MAIN_FILE），下次自动验证"
                else
                    echo "[警告] 卡密保存失败，下次需重新输入" >&2
                fi
                export GLOBAL_CARD_KEY="$CARD_KEY"
                export GLOBAL_EXPIRES_AT="$EXPIRES_AT"
                export GLOBAL_USED_DEVICES="$USED_DEVICES"
                export GLOBAL_MAX_DEVICES="$MAX_DEVICES"
                break
            else
                echo "验证失败：数据不完整，请重新输入"
                CARD_KEY=""
            fi
        else
            [ -z "$MESSAGE" ] && MESSAGE="未知错误"
            echo "验证失败：$MESSAGE，请重新输入"
            CARD_KEY=""
            # 清除无效卡密文件
            [ -f "$CARD_KEY_MAIN_FILE" ] && rm -f "$CARD_KEY_MAIN_FILE"
            [ -f "$CARD_KEY_BACKUP_FILE" ] && rm -f "$CARD_KEY_BACKUP_FILE"
        fi
    done
}

heartbeat_verify() {
    echo -e "\n===== 心跳验证已启动（间隔$HEARTBEAT_INTERVAL秒） ====="
    while true; do
        sleep $HEARTBEAT_INTERVAL
        echo -e "\n[心跳] （$(date "+%Y-%m-%d %H:%M:%S")）"

        local card_key="$GLOBAL_CARD_KEY"
        local device_code="$DEVICE_CODE"

        if [ -z "$card_key" ] || [ -z "$device_code" ]; then
            echo "[心跳] 卡密/设备码缺失，强制中断脚本"
            exit 1
        fi

        local TIMESTAMP=$(date +%s)
        local REQUEST_PARAMS=$(printf '{"api_key":"%s","key":"%s","device_code":"%s","timestamp":"%s"}' \
            "$API_KEY" "$card_key" "$device_code" "$TIMESTAMP")

        local retry_count=1
        local RESPONSE=""
        while [ $retry_count -le $HEARTBEAT_RETRY ]; do
            RESPONSE=$(curl -s --connect-timeout 10 -X POST "$API_URL_VERIFY" \
                -H "Content-Type: application/json" -d "$REQUEST_PARAMS")
            if [ $? -eq 0 ] && [ -n "$RESPONSE" ]; then
                break
            else
                echo "[心跳重试] 请求失败（第$retry_count次），$RETRY_INTERVAL秒后重试..."
                sleep $RETRY_INTERVAL
                retry_count=$((retry_count + 1))
            fi
        done

        if [ -z "$RESPONSE" ]; then
            echo "[心跳] 服务器无响应，本次跳过，下次继续验证(注此提示不影响你正常的源代码脚本执行)"
            continue
        fi

        local CODE=$(echo "$RESPONSE" | sed -n 's/.*"code":[[:space:]]*\([0-9]*\).*/\1/p; s/.*"code"[[:space:]]*:[[:space:]]*\([0-9]*\),.*/\1/p' | head -n1)
        local MESSAGE_RAW=$(echo "$RESPONSE" | sed -n 's/.*"message":[[:space:]]*"\([^"]*\)".*/\1/p; s/.*"message":[[:space:]]*"\([^"]*\)",.*/\1/p' | head -n1)
        local MESSAGE=$(decode_unicode "$MESSAGE_RAW")

        if [ "$CODE" -eq 200 ]; then
            echo "[心跳] 验证成功(注此提示不影响你正常的源代码脚本执行)"
        else
            echo "[心跳] 卡密验证失败：$MESSAGE"
            echo "[心跳] 强制中断脚本运行"
            exit 1
        fi
    done
}

start_heartbeat_in_background() {
    heartbeat_verify &
    # 记录心跳进程ID，确保脚本退出时心跳也退出
    HEARTBEAT_PID=$!
    trap 'kill $HEARTBEAT_PID 2>/dev/null' EXIT
}

check_update
verify_card_key
echo -e "\n卡密验证成功"
echo "到期时间：$GLOBAL_EXPIRES_AT"
echo "设备限制：已用$GLOBAL_USED_DEVICES台，共$GLOBAL_MAX_DEVICES台"

# 启动后台心跳验证
start_heartbeat_in_background
sleep 3
# ===================== 你的源代码填写区域 =====================
#卡密验证之后则会执行你的源代码


#注：源代码执行期间，心跳会在后台每隔$HEARTBEAT_INTERVAL秒自动验证














#by.小宝

         # 检查是否为root用户
         if [ `id -u` -ne 0 ]; then
	echo -e "\033[31m用Root权限执行\033[0m"
	exit
         fi
                  
         #设置当前时间定义
now_time=$(date '+%Y-%m-%d %H:%M:%S')


         
         #颜色
         red_start="\033[31m"
         red_last="\033[0m"

         
#设置清理ano函数*****************************  
   kill_ano(){
   echo -e "适用于王者，和平，CF，使命召唤等游戏"
   sleep 1
    iptables -F
    iptables -X 
    iptables -Z
    iptables -t nat -F 
    echo -e "本地缓存数据处理成功"
#清除iptables规则
    iptables -F
    echo -e "iptables规则清除成功"
    ip6tables=/system/bin/ip6tables
    iptables=/system/bin/iptables
#和平清除down****************************************

    rm -rf /data/data/com.tencent.tmgp.pubgmhd/files/ano_tmp
    rm -rf /data/user/0/com.tencent.tmgp.pubgmhd/files/ano_tmp
#PUBG清除down
    rm -rf /data/data/com.tencent.ig/files/ano_tmp
    rm -rf /data/user/0/com.tencent.ig/files/ano_tmp
#使命清除down
    rm -rf /data/data/com.tencent.tmgp.cod/files/ano_tmp
    rm -rf /data/user/0/com.tencent.tmgp.cod/files/ano_tmp
#王者清除down
    rm -rf /data/data/com.tencent.tmgp.sgame/files/ano_tmp
    rm -rf /data/user/0/com.tencent.tmgp.sgame/files/ano_tmp
#CFM清除down
    rm -rf /data/data/com.tencent.tmgp.cf/files/ano_tmp
    rm -rf /data/user/0/com.tencent.tmgp.cf/files/ano_tmp
#高能清除down
    rm -rf /data/data/com.tencent.tmgp.gnyx/files/ano_tmp
    rm -rf /data/user/0/com.tencent.tmgp.gnyx/files/ano_tmp
#修复第三方环境异常
    echo -e 16384 > /proc/sys/fs/inotify/max_queued_events
    echo -e 128 > /proc/sys/fs/inotify/max_user_instances
    echo -e 8192 > /proc/sys/fs/inotify/max_user_watches
#清除王者荣耀日志
    echo -e "缓存数据清理完成"
    name=$(tr -dc '1-9' < /dev/urandom | head -c 8)
    while echo -e "$name" | grep -q "'"; do
        name=$(tr -dc '1-9' < /dev/urandom | head -c 8)
    done 
    resetprop ro.serialno $name
    echo -e "\033[32mSuccess_JG|随机序列号:$name\033[0m"
    echo -e "$red_start清除成功！$red_last"
    sleep 1    
    }
#定义终止进程函数*************************************
    
    kill_app(){
    echo -e "\033[43m为了游戏方便所制作的此脚本"
            echo -e "终止除游戏外的所有进程，保证CPU无其他负担导致手机发烫严重"
            echo -e "为了确保进程完全终止，请重复执行3~5次！！\033[0m"
            sleep 2
            #终止微信进程
            echo -e "开始终止微信程序，请等待"
            sleep 0.1
            WeChat_name=com.tencent.mm
            WeChatID=$(pgrep com.tencent.mm)
            if [ -z "$WeChatID"  ]; then
                echo -e "\033[31m未检测到微信程序，开始终止下一个...\033[0m"
            else
                if killall $WeChat_name; then
                    echo -e "\033[31m终止成功！进程ID为$WeChatID\033[0m"
                else
                    echo -e "\033[31m终止微信进程失败！进程ID为$WeChatID\033[0m"
                fi
            fi
            echo -e "_____________________________________________________"
            sleep 0.1
            #终止快手进程
            echo -e "开始终止快手程序，请等待..."
            sleep 0.1
            KuaiShou=$(ps -ef | grep com.smile.gifmaker | grep -v grep | awk '{print $2}')
            
            if [ -z "$KuaiShou"  ]; then
                echo -e "\033[31m未检测到快手程序，开始终止下一个\033[0m"
            else
                for pid in $KuaiShou; do
                    if kill -9 $pid; then
                        echo -e "\033[31m终止成功！进程ID为$pid\033[0m"
                    else
                        echo -e "\033[31m终止快手进程失败！进程ID为$pid\033[0m"
                    fi
                done
            fi
            echo -e "_____________________________________________________"
            #终止Telegram程序
            echo -e "开始终止TG程序，请等待..."
            sleep 0.1
            TGID=$(ps -ef | grep org.telegram.messenger | grep -v grep | awk '{print $2}')
            if [ -z "$TGID"  ]; then
                echo -e "\033[31m未检测到TG程序，开始终止下一个...\033[0m"
            else
                for pid in $TGID; do
                    if kill -9 $pid; then
                        echo -e "\033[31m终止成功！进程ID为$pid\033[0m"
                    else
                        echo -e "\033[31m终止TG进程失败！进程ID为$pid\033[0m"
                    fi
                done
            fi
            echo -e "_____________________________________________________"
           
            #终止QQ程序
            echo -e "开始终止QQ进程，请等待..."
            sleep 0.1
            QQID=$(ps -ef | grep com.tencent.mobileqq | grep -v grep | awk '{print $2}')
            if [ -z "$QQID"  ]; then
                echo -e "\033[31m未检测到QQ程序，终止完毕\033[0m"
            else
                for pid in $QQID; do
                    if kill -9 $QQID;then
                         echo -e "\033[31m终止成功！进程ID为$pid\033[0m"
                    else
                         echo -e "\033[31m终止QQ进程失败！进程ID为$pid\033[0m"
                    fi
                done
            fi             
            sleep 1
            clear  
             "脚本启动时间为$now_time"     
          }
 #自定义备份文件函数************************
         backup(){
         clear
         echo -e "请输入你要备份的文件目录"
            read package_name
            #定义需备份文件目录
            needbackup_dir="$package_name"
            backup_dir="/storage/emulated/0/Download/" 
            #备份之后的文件目录
            date=$(date +%Y年%m月%d日%H时%M分%S秒) 
            #显示时间
            backup_file="backup_$date.tar.gz"
            mkdir -p "needpackup_dir" 
            #检查文件是否存在 不存在则创建
            clear
            tar -czf "${backup_dir}/${backup_file}" "$needbackup_dir" 
            #备份
         if [ $? -eq 0 ]; then
            echo -e "备份成功！文件为:${backup_dir}${backup_file}"
        clear
        else
        clear
           echo -e "艹你妈输入文件目录啊傻逼！"
        
           sleep 1
           echo -e "臭傻逼 不会用别用了\n你妈在\033[31m$now_time\033[0m死了！！！"        
           sleep 1       
           
           exit
        fi
           }
#定义重启系统函数*****************************************
          reboot_system()
          {
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"
             echo -e "\033[31m已被张豪全防入侵 手机等着黑砖吧傻子 看你还乱执行sh文件\033[0m"

             sleep 3
             reboot
             exit     
          }
#PUBG过300秒函数*************************************
          kill_game()
          {
          clear
                      echo -e "选择你需要去300秒的服:\n全球:com.pubg.krmobile\n日韩:com.pubg.krmobile\n台湾:com.rekoo.pubgm\n越南:com.vng.pubgmobile国体:com.tencent.igce"
            read package_name
            while true;do
         
            case "$package_name" in
"com.tencent.ig"|"com.pubg.krmobile"|"com.rekoo.pubgm"|"com.vng.pubgmobile"|"com.tencent.igce")
            sleep 0.5
            killall $package_name
            echo -e "SUCCESS"
            rm -rf /storage/emulated/0/Android/data/$package_name/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Saved/SaveGames/loginInfoFile.json
rm -rf /storage/emulated/0/Android/data/$package_name/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Saved/SaveGames/eLoginData.json
            echo -e "\033[31mSUCCESS\033[0m"
            sleep 1
            exit
            clear 
            echo -e "脚本启动时间为$now_time"   
            ;;
            *)
            echo -e "输入错误！\n不会用就别用，眼睛捐了算了傻逼东西\n你妈在$red_start$now_time$red_last死了！"
            
            sleep 1
            clear
            break
            ;;            
            esac
            done
            
         }       
            
#定义自定义终止进程函数*************************************
            diy_kill(){
                        #自定义终止进程
            echo -e "自动终止常用APP，接下来请输入你自己所需终止的的应用包名\n\033[31m警告⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️！\n警告⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️！\n警告⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️！\n请勿输入数字！！！不然会误终止系统进程导致手机死机或重启\033[0m"
            read package_name
            DIYID=$(ps -ef | grep "$package_name" | grep -v grep | awk '{print $2}')
            if [ -z "$DIYID"  ]; then
                echo -e "未找到该应用进程，或许你并没有打开此APP"
            else
                for pid in $DIYID; do
                    if kill -9 $pid; then
                        echo -e "\033[31m终止成功！进程ID为$pid\033[0m"
                    else
                        echo -e "\033[31m终止进程失败！进程ID为$pid\033[0m"
                    fi
                done
            fi
            sleep 1
            clear
            echo -e "脚本启动时间为$now_time"
            }           

#PUBG自动清理函数********************************
pubg_clear(){
clear
# 配置路径
NeiBu="/storage/emulated/0/Android/data/"
User="/data/user/0/"
Data="/data/data/"

#定义ANSI转义码
ESC_SEQ="\x1b["
RESET_SEQ="${ESC_SEQ}0m"
COLOR_SEQ="${ESC_SEQ}38;5;"

# 定义颜色代码
COLOR_RED="${COLOR_SEQ}9m"
COLOR_GREEN="${COLOR_SEQ}10m"
COLOR_YELLOW="${COLOR_SEQ}11m"
COLOR_BLUE="${COLOR_SEQ}12m"

#模式选择
VAR="true"
#将双引号里改为false则为强制删除
#将双引号里改为true则为普通删除
#默认则使用普通删除



# 获取用户提供包名
    
    if [ "$VAR" = "true" ]; then
        echo -e "${COLOR_GREEN}\n当前为普通模式。${RESET_SEQ}"
else
    echo -e "${COLOR_RED}\n当前为强制模式！${RESET_SEQ}"
fi
    echo -e "${COLOR_YELLOW}游戏包名:${RESET_SEQ}"
read B



#错误处理
if [ -z "$B" ]; then
#请勿删除,删除导致乱删文件,后果自负
    exit 1
fi





# 查找 Cache 路径
C=$(find "${NeiBu}${B}" "${User}${B}" "${Data}${B}" -iname '*Cache*')

# 查找 log 路径
D=$(find "${NeiBu}${B}" "${User}${B}" "${Data}${B}" -iname '*log*')

# 查找 tmp 路径
E=$(find "${NeiBu}${B}" "${User}${B}" "${Data}${B}" -iname '*tmp*')

# 查找 temp 路径
F=$(find "${NeiBu}${B}" "${User}${B}" "${Data}${B}" -iname '*temp*')


# 写入清理日志
new_name="清理日志$(date +"%Y-%m-%d %H:%M:%S").txt"
echo -e "Cache 路径：\n$C\n\nlog 路径：\n$D\n\ntmp 路径: \n$E\n\ntemp 路径:
 \n$F" > "$new_name"
    
#模式判断
if [ "$VAR" = "true" ]; then
    rm -f ${C} ${D} ${E} ${F}
else
    sudo rm -rf ${C} ${D} ${E} ${F}
fi
clear
    echo -e "${COLOR_GREEN}success！${RESET_SEQ}"
 }                        
#脚本等待时间************************************

new_game(){
    clear    
    echo -e "请输入你要刷新游客的服务器\n$red_start不要输入数字！请输入完整包名$red_last"
    echo -e "1.com.tencent.ig\n2.com.pubg.krmobile\n3.com.rekoo.pubgm\n4.com.vng.pubgmobile\n5.com.tencent.igce"
   
    read choice
    
    case $choice in
    "com.tencent.ig"|"com.pubg.krmobile"|"com.rekoo.pubgm"|"com.vng.pubgmobile"|"com.tencent.igce")    
      
      
      
      echo -e "\033[36;1m"
clear

if [ "$(id -u)" -ne 0 ]; then
    echo "请使用Root权限运行"
    echo "步骤:\n1.点击文件并找到'使用 Root 权限运行'\n2.勾选并执行"
    exit 0
fi

timezone=$( (timedatectl show --property=Timezone --value 2>/dev/null || date +%Z) | tr -d '\n' )
if [ "$timezone" = "CST" ] || [ "$timezone" = "Asia/Shanghai" ]; then
    echo "请更改时区"
    echo "步骤:\n1.打开设置\n2.找到'设置时间'里面有个设置时区\n3.修改并设置成香港即可"
    exit
fi

rm -rf /data/user/0/$choice/shared_prefs /storage/emulated/0/Documents/
mkdir /data/user/0/$choice/shared_prefs
chmod 777 /data/user/0/$choice/shared_prefs
rm -rf /data/user/0/$choice/files

GUEST="/data/user/0/$choice/shared_prefs/device_id.xml"
rm -rf $GUEST
echo "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
    <string name=\"random\"></string>
    <string name=\"install\"></string>
    <string name=\"uuid\">$RANDOM$RANDOM-$RANDOM-$RANDOM-$RANDOM-$RANDOM$RANDOM$RANDOM</string>
</map>" > $GUEST

rm -rf /data/user/0/$choice/databases
rm -rf /data/media/0/Android/data/$choice/files/login-identifier.txt
rm -rf /data/media/0/Android/data/$choice/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Intermediate
touch /data/media/0/Android/data/$choice/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Intermediate
rm -rf /data/media/0/Android/data/$choice/files/TGPA
touch /data/media/0/Android/data/$choice/files/TGPA
rm -rf /data/media/0/Android/data/$choice/files/ProgramBinaryCache
touch /data/media/0/Android/data/$choice/files/ProgramBinaryCache
iptables -I OUTPUT -d cloud.vmp.onezapp.com -j REJECT
iptables -I INPUT -s cloud.vmp.onezapp.com -j REJECT

rm -rf /storage/emulated/0/Android/data/$choice/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Saved/MMKV
rm -rf /data/app/*/$choice-*/lib/arm64/libtgpa.so
rm -rf /storage/emulated/0/Android/data/$choice/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Saved/SaveGames/loginInfoFile.json
rm -rf /storage/emulated/0/Android/data/$choice/files/UE4Game/ShadowTrackerExtra/ShadowTrackerExtra/Saved/SaveGames/eLoginData.json

echo "程序运行完成"
       esac
           
             
}
shell(){
#!/system/bin/sh
set -e

# 适配MT管理器：自动获取当前脚本所在目录
SCRIPT_DIR=$(cd "$(dirname "$0")" || exit; pwd)

# 步骤1：让用户选择待加密的脚本文件（MT管理器中直接选当前目录文件）
echo "请输入当前目录下待加密的脚本文件名（比如：test.sh）："
read -r INPUT_FILE
INPUT_PATH="${SCRIPT_DIR}/${INPUT_FILE}"

# 检查文件是否存在
if [ ! -f "$INPUT_PATH" ]; then
    echo "错误：当前目录下找不到 ${INPUT_FILE}！"    
    exit 1
fi

# 步骤2：设置加密密码
echo "请设置加密密码（后续运行加密文件需要输入）："
read -r PASSWORD

# 步骤3：设置输出文件名
echo "请输入加密后的输出文件名（比如：encrypted.sh）："
read -r OUTPUT_FILE
OUTPUT_PATH="${SCRIPT_DIR}/${OUTPUT_FILE}"

# 生成随机盐值（AES加密必需）
SALT=$(openssl rand -hex 4)

# 核心：生成自解密的加密文件
cat > "$OUTPUT_PATH" <<EOF
#!/system/bin/sh
set -e

# 自解密配置
TARGET_SALT="${SALT}"
echo "请输入解密密码："
read -r DEC_PASS

# 解密并执行原脚本
echo "\$(cat <<'ENCRYPTED_BODY'
$(openssl enc -aes-256-cbc -salt -S "${SALT}" -pbkdf2 -iter 10000 -in "${INPUT_PATH}" -out - -k "${PASSWORD}" 2>/dev/null | base64 -w 0)
ENCRYPTED_BODY
)" | base64 -d | openssl enc -aes-256-cbc -d -salt -S "\${TARGET_SALT}" -pbkdf2 -iter 10000 -k "\${DEC_PASS}" 2>/dev/null | sh

EOF

# 给加密文件添加执行权限（MT管理器中需确保权限生效）
chmod 755 "$OUTPUT_PATH"

# 提示完成
echo "加密成功！"
echo "原文件：${INPUT_PATH}"
echo "加密文件：${OUTPUT_PATH}"
echo "运行 ${OUTPUT_FILE} 即可自动解密并执行原脚本"
sleep 1

}
#更新日志函数**********************************************
Log(){
clear
echo "正在加载更新日志 请等待...."
sleep 1
clear
cat "/storage/emulated/0/Download/Shell/更新日志.txt"
#打开文本
}
Android(){
 echo   "设备信息加载中......"
sleep 1
echo "[+]设备型号: $(getprop ro.product.model)"
echo "[+]设备厂商: $(getprop ro.product.manufacturer)"
echo "[+]设备品牌: $(getprop ro.product.brand)"
echo "[+]Android版本: $(getprop ro.build.version.release)"
echo "[+]Android ID:$(settings get secure android_id)"
echo "[+]设备序列号:$(getprop ro.serialno)"
echo "[+]API级别: $(getprop ro.build.version.sdk)"
echo "[+]安全补丁: $(getprop ro.build.version.security_patch)"
echo "[+]内核版本: $(cat /proc/version 2>/dev/null | cut -d' ' -f3)"
echo "[-]等待5秒自动返回"
sleep 5
}

clear_cache(){
# 检查是否为root用户
         if [ `id -u` -ne 0 ]; then
	echo -e "\033[31m扫描data目录需要使用root权限执行\033[0m"
	exit
         fi
echo -e "此脚本为为豆包Ai联合制作的清理缓存工具"
echo -e "使用Mt扩展环境执行效果更佳"
echo -e "准备读取data数据目录"
sleep 3

DATA_DIR="/storage/emulated"
total_clean=0

echo "===== 读取${DATA_DIR}目录内容（含大小） ====="
[ ! -d "${DATA_DIR}" ] && echo "错误：${DATA_DIR}不存在！" && exit 1
ls -lh "${DATA_DIR}"
sleep 3
clear
echo "开始清理开始清理开始清理开始清理开始清理开始清理开始开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理开始清理"
sleep 1
clear
echo -e "\n===== 清理cache文件夹（排除软链接） ====="
# -type d 确保是真实文件夹，排除软链接；-print0 兼容特殊文件名
find "${DATA_DIR}" -type d -name "cache" -print0 | while IFS= read -r -d '' cache_dir; do
  # 统计清理前真实大小（仅内容，不含文件夹本身）
  pre_size=$(du -sb "${cache_dir}/" 2>/dev/null | awk '{print $1}')
  pre_size=${pre_size:-0}
  if [ "$pre_size" -eq 0 ]; then
    echo "跳过空文件夹：${cache_dir}"
    continue
  fi
  # 强制删除所有内容（含隐藏文件/子文件夹），忽略权限提示
  rm -rf "${cache_dir}/"* "${cache_dir}/".* 2>/dev/null
  # 统计清理后剩余大小
  post_size=$(du -sb "${cache_dir}/" 2>/dev/null | awk '{print $1}')
  post_size=${post_size:-0}
  # 计算实际释放大小
  release=$((pre_size - post_size))
  total_clean=$((total_clean + release))
  # 格式化显示
  pre_fmt=$(numfmt --to=iec --suffix=B $pre_size)
  rel_fmt=$(numfmt --to=iec --suffix=B $release)
  echo "清理：${cache_dir} | 原大小：${pre_fmt} | 实际释放：${rel_fmt}"
done

# 最终统计
fmt_total=$(numfmt --to=iec --suffix=B $total_clean)
echo -e "\n===== 清理完成！感谢使用！====="

}






#脚本头***********************************************






        
         clear
         
          
         sleep 1
    while true; do
    echo -e "脚本启动时间为$now_time"
    echo -e "\033[45m此脚本为综合功能脚本，编写此脚本纯娱乐\n只是想锻炼一下自己的技术，学习更多的shell脚本知识\n编写者为纯纯纯新手小白\n仅供娱乐使用\n因为学业 加上不知道想更新什么 更新频率会降低\033[0m" 
    echo -e "当前版本v2.7\n更新时间:26.2.5"
    sleep 2
      
    echo -e "\033[33m请根据你的需要自行输入一下数字\033[0m"
    echo -e "1.敬请期待\n2.自动终止\n3.手动终止\n4.重启当前设备\n5.PUBG过300秒\n6.自定义备份文件\n7.清理游戏ano(自动执行)\n8.全游戏脑残一键清理\n9.四服游客\n10.shell加密\n11.更新日志\n12.设备信息\n13.清理设备缓存\n100.退出"
    sleep 1
    
    read choice

    case $choice in
        2)
        kill_app  #调用kill_app函数
            ;;
        3)
        diy_kill #调用自定义终止程序函数
            ;;
        4)
        reboot_system #调用重启系统函数
            ;;
        5)           
        kill_game #调用清除PUBG300秒
            ;;
        6)  
        backup #调用备份函数
            ;;  

        7)
        echo -e "$red_start调用函数成功！即将开始执行$red_last"
        sleep 1
        kill_ano #运行清理ano函数
        clear
        echo -e "脚本执行时间:$now_time"       
        sleep 1
            ;; 
        8) 
        clear 
        echo -e "$red_start正在启动一键清理..........$red_last"
        sleep 1
        pubg_clear #PUBG一键清理函数     
        clear          
        ;;
        9)
        clear
        new_game
        sleep 1
        clear
        ;;
        
        10)
        clear
       
        
        shell
        
        ;;
        11)
        Log        
        echo "\n[-]等待5秒自动返回"
        sleep 5
        clear
        ;;
        12)
        clear
        Android
        clear
        ;;
        
        13)
        clear_cache
        ;;
        
        
        100)
        clear        
        echo -e "[+]脚本已退出..."
        exit
        
        ;;
        *)
         clear
         echo -e "臭傻子看不懂人话？让你输入序号你输入的啥破逼玩意\n用不明白这么简单的shell脚本的话你可以重开了\n你妈在\033[31m$now_time\033[0m死了！！"
            sleep 1
            exit
        ;;
    esac
done            

# ===================== 上方填写你的源代码 =====================

# 等待用户源代码执行完成（若用户代码是持续运行的，此句可省略）
wait