const TARGET = "BV1HA3o6oEJJ";
|
const CANONICAL_URL = "https://www.bilibili.com/video/BV1HA3o6oEJJ";
|
const TARGET_PATH = "/video/BV1HA3o6oEJJ";
|
const HOST = "com.project_info.bili_auth_ingress";
|
const SCHEMA = 2;
|
const EXTENSION_BUILD = "project-info-bili-auth-ingress/1.0.0+20260805.v002";
|
const HOST_BUILD = "project-info-bili-auth-native-host/1.0.0+20260805.v002";
|
const SIDEPANEL_URL = chrome.runtime.getURL("sidepanel.html");
|
const EXPECTED_DURATION_MS = 3133950;
|
const DURATION_TOLERANCE_MS = 3134;
|
|
let currentProof = null;
|
let currentTabId = null;
|
let currentTaskNonce = null;
|
let nativePort = null;
|
let nativeReady = false;
|
let nativeRevision = 0;
|
let lastNativeType = null;
|
let preparedTaskNonce = null;
|
let preparedLeaseId = null;
|
let activeStartLease = null;
|
const prepareResponses = new Map();
|
let safeState = {
|
phase: "IDLE",
|
progress: 0,
|
error_code: null,
|
formal_filename: null,
|
mapping_filename: null
|
};
|
|
chrome.runtime.onInstalled.addListener(() => {
|
chrome.sidePanel.setPanelBehavior({openPanelOnActionClick: true});
|
});
|
|
function randomNonce() {
|
const bytes = new Uint8Array(16);
|
crypto.getRandomValues(bytes);
|
return Array.from(bytes, value => value.toString(16).padStart(2, "0")).join("");
|
}
|
|
function fixedError(code) {
|
const error = new Error(code);
|
error.code = code;
|
return error;
|
}
|
|
async function activeTargetTab() {
|
const tabs = await chrome.tabs.query({active: true, currentWindow: true});
|
if (tabs.length !== 1 || !Number.isInteger(tabs[0].id)) {
|
throw fixedError("E_PAGE_PROOF");
|
}
|
const parsed = new URL(tabs[0].url || "about:blank");
|
if (parsed.protocol !== "https:" || parsed.hostname !== "www.bilibili.com" || parsed.pathname !== TARGET_PATH) {
|
throw fixedError("E_PAGE_PROOF");
|
}
|
return tabs[0];
|
}
|
|
async function observePage(tab, nonce) {
|
const results = await chrome.scripting.executeScript({
|
target: {tabId: tab.id},
|
world: "ISOLATED",
|
args: [TARGET, CANONICAL_URL, nonce],
|
func: (target, canonicalUrl, taskNonce) => {
|
const videos = Array.from(document.querySelectorAll("video")).filter(video =>
|
video.readyState >= 1 && video.videoWidth > 0 && video.videoHeight > 0
|
);
|
if (location.hostname !== "www.bilibili.com" || location.pathname !== `/video/${target}` || videos.length !== 1) {
|
return null;
|
}
|
const video = videos[0];
|
return {
|
target,
|
canonical_url: canonicalUrl,
|
task_nonce: taskNonce,
|
observed_at_unix_ms: Date.now(),
|
observed_duration_ms: Math.round(video.duration * 1000),
|
video_width: video.videoWidth,
|
video_height: video.videoHeight,
|
ready_state: video.readyState,
|
eme_present: video.mediaKeys !== null
|
};
|
}
|
});
|
if (results.length !== 1 || !results[0].result) {
|
throw fixedError("E_PAGE_PROOF");
|
}
|
const proof = results[0].result;
|
const now = Date.now();
|
const exactKeys = [
|
"canonical_url", "eme_present", "observed_at_unix_ms", "observed_duration_ms",
|
"ready_state", "target", "task_nonce", "video_height", "video_width"
|
];
|
if (Object.keys(proof).sort().join("|") !== exactKeys.sort().join("|") ||
|
proof.target !== TARGET || proof.canonical_url !== CANONICAL_URL ||
|
proof.task_nonce !== nonce || proof.eme_present !== false ||
|
!Number.isSafeInteger(proof.observed_at_unix_ms) ||
|
proof.observed_at_unix_ms < now - 60000 || proof.observed_at_unix_ms > now + 5000 ||
|
!Number.isSafeInteger(proof.observed_duration_ms) ||
|
Math.abs(proof.observed_duration_ms - EXPECTED_DURATION_MS) > DURATION_TOLERANCE_MS ||
|
!Number.isInteger(proof.video_width) || proof.video_width < 1 || proof.video_width > 7680 ||
|
!Number.isInteger(proof.video_height) || proof.video_height < 1 || proof.video_height > 4320 ||
|
!Number.isInteger(proof.ready_state) || proof.ready_state < 1 || proof.ready_state > 4) {
|
throw fixedError(proof.eme_present ? "E_DRM" : "E_PAGE_PROOF");
|
}
|
return proof;
|
}
|
|
async function validateCurrentPage({leaseId = null} = {}) {
|
if (activeStartLease !== null && activeStartLease !== leaseId) {
|
throw fixedError("E_BUSY");
|
}
|
const tab = await activeTargetTab();
|
const nonce = randomNonce();
|
const proof = await observePage(tab, nonce);
|
currentProof = proof;
|
currentTabId = tab.id;
|
if (nativePort) {
|
const previousPort = nativePort;
|
nativePort = null;
|
nativeReady = false;
|
preparedTaskNonce = null;
|
preparedLeaseId = null;
|
prepareResponses.clear();
|
previousPort.disconnect();
|
}
|
await awaitNativeReady();
|
safeState = {...safeState, phase: "READY", error_code: null};
|
return safeState;
|
}
|
|
function connectNative() {
|
if (nativePort) {
|
return;
|
}
|
nativeReady = false;
|
preparedTaskNonce = null;
|
preparedLeaseId = null;
|
prepareResponses.clear();
|
const port = chrome.runtime.connectNative(HOST);
|
nativePort = port;
|
port.onMessage.addListener(message => {
|
const safeKeys = new Set([
|
"schema", "type", "host_build", "target", "phase", "progress", "error_code",
|
"formal_filename", "mapping_filename", "prepare_id"
|
]);
|
const basename = value => value === null || (typeof value === "string" && value.length > 0 && !/[\\/]/.test(value));
|
const prepareIdValid = message?.prepare_id === null ||
|
(typeof message?.prepare_id === "string" && /^[0-9a-f]{32}$/.test(message.prepare_id));
|
if (!message || Object.keys(message).some(key => !safeKeys.has(key)) ||
|
message.schema !== SCHEMA || message.host_build !== HOST_BUILD || message.target !== TARGET ||
|
!["IDLE", "READY", "CHECKING", "DOWNLOADING", "MERGING", "VALIDATING", "PUBLISHING", "COMPLETE", "FAILED", "CANCELED"].includes(message.phase) ||
|
!Number.isInteger(message.progress) || message.progress < 0 || message.progress > 100 ||
|
!basename(message.formal_filename) || !basename(message.mapping_filename) || !prepareIdValid ||
|
(message.type === "prepare" ? message.prepare_id === null : message.prepare_id !== null)) {
|
safeState = {...safeState, phase: "FAILED", error_code: "E_PROTOCOL"};
|
return;
|
}
|
nativeReady = nativeReady || (message.type === "hello" && message.phase === "READY");
|
lastNativeType = message.type;
|
if (message.type === "prepare") {
|
prepareResponses.set(message.prepare_id, {
|
phase: message.phase,
|
error_code: message.error_code
|
});
|
}
|
safeState = {
|
phase: message.phase,
|
progress: message.progress,
|
error_code: message.error_code,
|
formal_filename: message.formal_filename,
|
mapping_filename: message.mapping_filename
|
};
|
nativeRevision += 1;
|
});
|
port.onDisconnect.addListener(() => {
|
if (nativePort === port) {
|
nativePort = null;
|
nativeReady = false;
|
preparedTaskNonce = null;
|
preparedLeaseId = null;
|
prepareResponses.clear();
|
if (!["COMPLETE", "FAILED", "CANCELED"].includes(safeState.phase)) {
|
safeState = {...safeState, phase: "FAILED", error_code: "E_NATIVE_DISCONNECT"};
|
}
|
}
|
});
|
port.postMessage({
|
schema: SCHEMA,
|
type: "hello",
|
extension_build: EXTENSION_BUILD,
|
target: TARGET
|
});
|
}
|
|
async function freshNativeStatus() {
|
const prior = nativeRevision;
|
nativePort.postMessage({schema: SCHEMA, type: "status", target: TARGET});
|
const deadline = Date.now() + 5000;
|
while (nativeRevision === prior && Date.now() < deadline) {
|
await new Promise(resolve => setTimeout(resolve, 25));
|
}
|
if (nativeRevision === prior) {
|
throw fixedError("E_NATIVE_CONNECT");
|
}
|
return safeState;
|
}
|
|
async function awaitNativeReady() {
|
connectNative();
|
const deadline = Date.now() + 5000;
|
while (!nativeReady && Date.now() < deadline) {
|
if (safeState.error_code) {
|
throw fixedError(safeState.error_code);
|
}
|
await new Promise(resolve => setTimeout(resolve, 25));
|
}
|
if (!nativeReady) {
|
throw fixedError("E_NATIVE_CONNECT");
|
}
|
}
|
|
async function freshNativePrepare(proof, leaseId) {
|
await awaitNativeReady();
|
if (activeStartLease !== leaseId) {
|
throw fixedError("E_BUSY");
|
}
|
preparedTaskNonce = null;
|
preparedLeaseId = null;
|
const prepareId = randomNonce();
|
prepareResponses.delete(prepareId);
|
nativePort.postMessage({
|
schema: SCHEMA,
|
type: "prepare",
|
extension_build: EXTENSION_BUILD,
|
target: TARGET,
|
prepare_id: prepareId,
|
page_proof: proof
|
});
|
const deadline = Date.now() + 120000;
|
while (!prepareResponses.has(prepareId) && Date.now() < deadline) {
|
await new Promise(resolve => setTimeout(resolve, 25));
|
}
|
const response = prepareResponses.get(prepareId);
|
prepareResponses.delete(prepareId);
|
if (!response || response.phase !== "READY" || response.error_code) {
|
throw fixedError(response?.error_code || "E_PREPARE");
|
}
|
preparedTaskNonce = proof.task_nonce;
|
preparedLeaseId = leaseId;
|
return prepareId;
|
}
|
|
async function currentCookieStore(tabId) {
|
const stores = await chrome.cookies.getAllCookieStores();
|
const matches = stores.filter(store => Array.isArray(store.tabIds) && store.tabIds.includes(tabId));
|
if (matches.length !== 1 || !/^[0-9]{1,8}$/.test(matches[0].id)) {
|
throw fixedError("E_SECRET_INPUT");
|
}
|
return matches[0].id;
|
}
|
|
function projectCookie(cookie, storeId) {
|
if (cookie.partitionKey !== undefined) {
|
throw fixedError("E_SECRET_INPUT");
|
}
|
if (!cookie.name || !cookie.value) {
|
return null;
|
}
|
const session = Boolean(cookie.session);
|
const expiration = session ? null : Math.floor(cookie.expirationDate);
|
if (!session && (!Number.isSafeInteger(expiration) || expiration <= 0)) {
|
throw fixedError("E_SECRET_INPUT");
|
}
|
return {
|
name: String(cookie.name),
|
value: String(cookie.value),
|
domain: String(cookie.domain),
|
host_only: Boolean(cookie.hostOnly),
|
path: String(cookie.path),
|
secure: Boolean(cookie.secure),
|
http_only: Boolean(cookie.httpOnly),
|
same_site: String(cookie.sameSite || "unspecified"),
|
session,
|
expiration_unix: expiration,
|
store_id: storeId,
|
partition_key: null
|
};
|
}
|
|
async function startExactTask({retry = false} = {}) {
|
if (activeStartLease !== null) {
|
throw fixedError("E_BUSY");
|
}
|
const leaseId = randomNonce();
|
activeStartLease = leaseId;
|
try {
|
if (retry) {
|
await validateCurrentPage({leaseId});
|
}
|
const tab = await activeTargetTab();
|
if (!currentProof || currentTabId !== tab.id || Date.now() - currentProof.observed_at_unix_ms > 60000) {
|
throw fixedError("E_PAGE_PROOF");
|
}
|
const proof = currentProof;
|
const prepareId = await freshNativePrepare(proof, leaseId);
|
if (activeStartLease !== leaseId || preparedLeaseId !== leaseId || preparedTaskNonce !== proof.task_nonce) {
|
throw fixedError("E_PREPARE");
|
}
|
const storeId = await currentCookieStore(tab.id);
|
const rawCookies = await chrome.cookies.getAll({url: "https://www.bilibili.com/", storeId});
|
let records = [];
|
try {
|
records = rawCookies.map(cookie => projectCookie(cookie, storeId)).filter(Boolean);
|
if (records.length < 1 || records.length > 128) {
|
throw fixedError("E_SECRET_INPUT");
|
}
|
nativePort.postMessage({
|
schema: SCHEMA,
|
type: "start",
|
extension_build: EXTENSION_BUILD,
|
target: TARGET,
|
canonical_url: CANONICAL_URL,
|
cookie_store_id: storeId,
|
prepare_id: prepareId,
|
page_proof: proof,
|
cookies: records
|
});
|
currentTaskNonce = proof.task_nonce;
|
preparedTaskNonce = null;
|
preparedLeaseId = null;
|
safeState = {...safeState, phase: "CHECKING", progress: 0, error_code: null};
|
currentProof = null;
|
currentTabId = null;
|
return safeState;
|
} finally {
|
for (const record of records) {
|
if (record) {
|
record.name = "";
|
record.value = "";
|
}
|
}
|
records.fill(null);
|
rawCookies.fill(null);
|
}
|
} finally {
|
if (activeStartLease === leaseId) {
|
activeStartLease = null;
|
}
|
}
|
}
|
|
async function requestStatus() {
|
await awaitNativeReady();
|
return freshNativeStatus();
|
}
|
|
async function cancelTask() {
|
if (!currentTaskNonce) {
|
throw fixedError("E_CANCEL");
|
}
|
await awaitNativeReady();
|
nativePort.postMessage({schema: SCHEMA, type: "cancel", target: TARGET, task_nonce: currentTaskNonce});
|
return safeState;
|
}
|
|
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
|
if (sender.id !== chrome.runtime.id || sender.url !== SIDEPANEL_URL || !message || typeof message.action !== "string") {
|
return false;
|
}
|
const actions = {
|
validate: () => validateCurrentPage(),
|
start: () => startExactTask(),
|
retry: () => startExactTask({retry: true}),
|
status: () => requestStatus(),
|
cancel: () => cancelTask()
|
};
|
const action = actions[message.action];
|
if (!action) {
|
sendResponse({ok: false, error_code: "E_PROTOCOL"});
|
return false;
|
}
|
action().then(
|
state => sendResponse({ok: true, state}),
|
error => sendResponse({ok: false, error_code: error.code || "E_EXTENSION"})
|
);
|
return true;
|
});
|
