标题:自动提交 Bootloader 解锁应用程序
注意：教程来源于用户上传，互联网收集，其中真实性注意斟酌，操作可能存在风险，请践行时注意保存资料防止丢失，如果本教程侵犯您的个人或者集体利益，请邮件fiimecn@163.com下架处理，非常感谢！
自动提交 Bootloader 解锁应用程序
• 请勿使用 VPN（ping 计算将不正确）。在运行脚本后（或运行期间），立即尝试在“开发者选项”菜单中将设备链接到您的帐户，无论结果如何。
1. 退出设备上的帐户并重新登录。
2. 下载 Cookie-Editor 浏览器扩展程序（授予扩展程序访问所有网站的权限）。
3. 转到 http://new.c.mi.com/global 并登录。如果页面上没有令牌，请尝试在 http://mi.com 上登录。
4. 单击扩展程序（在网站上），找到并复制“new_bbs_serviceToken”字符串的值。
5. 从官方网站下载并安装 Python。
6. 下载附加的 mipy 文件。
# FiimeROM汉化脚本
import subprocess
import sys
import os
# 服务器数组
ntp_servers = [
"ntp0.ntp-servers.net", "ntp1.ntp-servers.net", "ntp2.ntp-servers.net",
"ntp3.ntp-servers.net", "ntp4.ntp-servers.net", "ntp5.ntp-servers.net",
"ntp6.ntp-servers.net"
]
MI_SERVERS = ['sgp-api.buy.mi.com', '20.157.18.26']
# 安装依赖包
def install_package(package):
subprocess.check_call([sys.executable, "-m", "pip", "install", package])
required_packages = ["requests", "ntplib", "pytz", "urllib3", "icmplib"]
for package in required_packages:
try:
__import__(package)
except ImportError:
print(f"正在安装包 {package}...")
install_package(package)
os.system('cls' if os.name == 'nt' else 'clear')
import hashlib
import random
import time
from datetime import datetime, timezone, timedelta
import ntplib
import pytz
import urllib3
import json
import statistics
from icmplib import ping
# 返回平均响应时间
def debug_ping(host):
try:
result = ping(host, count=1, interval=0.5, timeout=2)
return result.avg_rtt if result.is_alive else None
except Exception as e:
print(f"Ping 错误: {e}")
return None
# 计算平均 ping
def get_average_ping():
all_pings = []
print("开始计算 ping...")
def ping_server(server):
pings = []
for attempt in range(3):
result = debug_ping(server)
if result is not None:
pings.append(result)
time.sleep(0.2)
return statistics.mean(pings) if pings else None
for server in MI_SERVERS:
try:
ping_time = ping_server(server)
if ping_time is not None:
all_pings.append(ping_time)
else:
print(f"\n无法获取服务器 {server} 的 ping")
except Exception as e:
print(f"\nPing 服务器 {server} 时出错: {str(e)}")
if not all_pings:
print("\n无法获取任何服务器的 ping！")
print("使用默认值: 300 ms")
return 300
avg_ping = statistics.mean(all_pings)
print(f"平均 ping: {avg_ping:.2f} ms")
return avg_ping
# 生成唯一设备标识符
def generate_device_id():
random_data = f"{random.random()}-{time.time()}"
device_id = hashlib.sha1(random_data.encode('utf-8')).hexdigest().upper()
print(f"生成的 deviceId: {device_id}")
return device_id
# 通过 NTP 获取当前北京时间
def get_initial_beijing_time():
client = ntplib.NTPClient()
beijing_tz = pytz.timezone("Asia/Shanghai")
for server in ntp_servers:
try:
print(f"尝试连接 NTP 服务器: {server}")
response = client.request(server, version=3)
ntp_time = datetime.fromtimestamp(response.tx_time, timezone.utc)
beijing_time = ntp_time.astimezone(beijing_tz)
print(f"从服务器 {server} 接收到的北京时间: {beijing_time.strftime('%Y-%m-%d %H:%M:%S.%f')}")
return beijing_time
except Exception as e:
print(f"无法连接到 {server}: {e}")
print("无法连接到任何 NTP 服务器。")
return None
# 同步北京时间
def get_synchronized_beijing_time(start_beijing_time, start_timestamp):
elapsed = time.time() - start_timestamp
current_time = start_beijing_time + timedelta(seconds=elapsed)
return current_time
# 考虑 ping 等待指定时间
def wait_until_target_time(start_beijing_time, start_timestamp, ping_delay):
next_day = start_beijing_time + timedelta(days=1)
network_delay = ping_delay / 2
server_processing_time = 30
total_delay = (network_delay - server_processing_time) / 1000.0
target_time = next_day.replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(seconds=total_delay)
print(f"等待直到 {target_time.strftime('%Y-%m-%d %H:%M:%S.%f')} (考虑大约计算的网络延迟)。")
while True:
current_time = get_synchronized_beijing_time(start_beijing_time, start_timestamp)
time_diff = target_time - current_time
if time_diff.total_seconds() > 1:
time.sleep(min(1.0, time_diff.total_seconds() - 1))
elif current_time >= target_time:
print(f"时间已到: {current_time.strftime('%Y-%m-%d %H:%M:%S.%f')}. 开始发送请求...")
break
else:
time.sleep(0.0001)
# 检查通过 API 解锁账户的可能性
def check_unlock_status(session, cookie_value, device_id):
try:
url = "https://sgp-api.buy.mi.com/bbs/api/global/user/bl-switch/state"
headers = {
"Cookie": f"new_bbs_serviceToken={cookie_value};versionCode=500411;versionName=5.4.11;deviceId={device_id};"
}
response = session.make_request('GET', url, headers=headers)
if response is None:
print("[错误] 获取解锁状态失败。")
return False
response_data = json.loads(response.data.decode('utf-8'))
response.release_conn()
if response_data.get("code") == 100004:
print("[错误] Cookie 已过期，需要更新！")
input("按 Enter 键关闭...")
exit()
data = response_data.get("data", {})
is_pass = data.get("is_pass")
button_state = data.get("button_state")
deadline_format = data.get("deadline_format", "")
if is_pass == 4:
if button_state == 1:
print("[状态] 账户可以提交解锁请求。")
return True
elif button_state == 2:
print(f"[状态] 账户被阻止提交请求，直到 {deadline_format} (月/日)。")
input("按 Enter 键关闭...")
exit()
elif button_state == 3:
print("[状态] 账户未满 30 天。")
input("按 Enter 键关闭...")
exit()
elif is_pass == 1:
print(f"[状态] 请求已批准，解锁可用直到 {deadline_format}。")
input("按 Enter 键关闭...")
exit()
else:
print("[错误] 未知状态。")
input("按 Enter 键关闭...")
exit()
except Exception as e:
print(f"[状态检查错误] {e}")
return False
# 等待直到指定时间开始 ping 计算
def wait_until_ping_time(start_beijing_time, start_timestamp):
next_day = start_beijing_time + timedelta(days=0)
target_time = next_day.replace(hour=23, minute=59, second=30)
print(f"等待直到 {target_time.strftime('%Y-%m-%d %H:%M:%S')} 开始 ping 计算。")
while True:
current_time = get_synchronized_beijing_time(start_beijing_time, start_timestamp)
time_diff = (target_time - current_time).total_seconds()
if time_diff <= 0:
print(f"时间已到: {current_time.strftime('%Y-%m-%d %H:%M:%S')}. 开始 ping 计算...")
avg_ping = get_average_ping()
return avg_ping
else:
time.sleep(min(1, time_diff))
# HTTP 请求的包装器
class HTTP11Session:
def __init__(self):
self.http = urllib3.PoolManager(
maxsize=10,
retries=True,
timeout=urllib3.Timeout(connect=1.0, read=4.0),
headers={}
)
def make_request(self, method, url, headers=None, body=None):
try:
request_headers = {}
if headers:
request_headers.update(headers)
request_headers['Content-Type'] = 'application/json; charset=utf-8'
if method == 'POST':
if body is None:
body = '{"is_retry":true}'.encode('utf-8')
request_headers['Content-Length'] = str(len(body))
request_headers['Accept-Encoding'] = 'gzip, deflate, br'
request_headers['User-Agent'] = 'okhttp/4.12.0'
request_headers['Connection'] = 'keep-alive'
response = self.http.request(
method,
url,
headers=request_headers,
body=body,
preload_content=False
)
return response
except Exception as e:
print(f"[网络错误] {e}")
return None
def main():
cookie_value = input("输入 'new_bbs_serviceToken' 的值: ")
device_id = generate_device_id()
session = HTTP11Session()
if check_unlock_status(session, cookie_value, device_id):
start_beijing_time = get_initial_beijing_time()
if start_beijing_time is None:
print("设置初始时间失败。按 Enter 键关闭...")
input()
exit()
start_timestamp = time.time()
avg_ping = wait_until_ping_time(start_beijing_time, start_timestamp)
if avg_ping is None:
print("使用默认 ping: 50 ms")
avg_ping = 50
wait_until_target_time(start_beijing_time, start_timestamp, avg_ping)
url = "https://sgp-api.buy.mi.com/bbs/api/global/apply/bl-auth"
headers = {
"Cookie": f"new_bbs_serviceToken={cookie_value};versionCode=500411;versionName=5.4.11;deviceId={device_id};"
}
try:
while True:
request_time = get_synchronized_beijing_time(start_beijing_time, start_timestamp)
print(f"\n[请求] 在 {request_time.strftime('%Y-%m-%d %H:%M:%S.%f')} (UTC+8) 发送请求")
response = session.make_request('POST', url, headers=headers)
if response is None:
continue
response_time = get_synchronized_beijing_time(start_beijing_time, start_timestamp)
print(f"[响应] 在 {response_time.strftime('%Y-%m-%d %H:%M:%S.%f')} (UTC+8) 收到响应")
try:
response_data = response.data
response.release_conn()
json_response = json.loads(response_data.decode('utf-8'))
code = json_response.get("code")
data = json_response.get("data", {})
if code == 0:
apply_result = data.get("apply_result")
if apply_result == 1:
print(f"[状态] 请求已批准，检查状态...")
check_unlock_status(session, cookie_value, device_id)
elif apply_result == 3:
deadline_format = data.get("deadline_format", "未指定")
print(f"[状态] 请求未提交，请求限制已达，尝试在 {deadline_format} (月/日) 再试。")
input("按 Enter 键关闭...")
exit()
elif apply_result == 4:
deadline_format = data.get("deadline_format", "未指定")
print(f"[状态] 请求未提交，阻止提交请求直到 {deadline_format} (月/日)。")
input("按 Enter 键关闭...")
exit()
elif code == 100001:
print(f"[状态] 请求被拒绝，请求错误。")
print(f"[完整服务器响应]: {json_response}")
elif code == 100003:
print("[状态] 请求可能已批准，检查状态...")
print(f"[完整服务器响应]: {json_response}")
check_unlock_status(session, cookie_value, device_id)
elif code is not None:
print(f"[状态] 未知请求状态: {code}")
print(f"[完整服务器响应]: {json_response}")
else:
print("[错误] 响应不包含所需的代码。")
print(f"[完整服务器响应]: {json_response}")
except json.JSONDecodeError:
print("[错误] 解码 JSON 响应失败。")
print(f"服务器响应: {response_data}")
except Exception as e:
print(f"[响应处理错误] {e}")
continue
except Exception as e:
print(f"[请求错误] {e}")
input("按 Enter 键关闭...")
exit()
if __name__ == "__main__":
main()7. 运行它。出现提示时，粘贴之前复制的 cookie 并按 Enter。
8. 等待所需的时间，脚本将为您处理其余部分。
注意：不能保证 100% 的成功率。您可能会收到 5/10/30 天的提交阻止，但这也可以手动发生。该脚本只是尽可能地自动化和简化流程
信用：
• 原始帖子/作者（https://4pda.to/forum/index.php?showtopic=721838&view=findpost&p=133301054）
讨论区(0)
没有评论数据