"""网易云音乐二维码登录会话。""" from __future__ import annotations import asyncio import base64 import http.cookiejar import http.cookies import io import json import logging import secrets import string import time import urllib.parse import urllib.request from typing import Any, Callable from Crypto.Cipher import AES try: from .netease_resolver import NeteaseResolver except ImportError: from netease_resolver import NeteaseResolver _USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" _WEAPI_NONCE = b"0CoJUm6Qyw8W8jud" _WEAPI_IV = b"0102030405060708" _WEAPI_PUBLIC_EXPONENT = 0x10001 _WEAPI_MODULUS = int( "00e0b509f6259df8642dbc35662901477df22677ec152b5ff68ace615bb7b725" "152b3ab17a876aea8a5aa76d2e417629ec4ee341f56135fccf695280104e0312" "ecbda92557c93870114af6c9d05c4f7f0c3685b7a46bee255932575cce10b424" "d813cfe4875d3e82047b97ddef52741d546b8e289dc6935b3ece0462db0a22b8" "e7", 16, ) _SECRET_ALPHABET = string.ascii_letters + string.digits def _aes_encrypt_base64(content: bytes, key: bytes) -> bytes: padding = AES.block_size - (len(content) % AES.block_size) padded = content + bytes([padding]) * padding encrypted = AES.new(key, AES.MODE_CBC, _WEAPI_IV).encrypt(padded) return base64.b64encode(encrypted) def _weapi_form(data: dict[str, Any], *, secret_key: str | None = None) -> dict[str, str]: secret = secret_key or "".join(secrets.choice(_SECRET_ALPHABET) for _ in range(16)) if len(secret.encode("ascii")) != 16: raise ValueError("weapi secret key must be 16 ASCII bytes") serialized = json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode("utf-8") first_pass = _aes_encrypt_base64(serialized, _WEAPI_NONCE) params = _aes_encrypt_base64(first_pass, secret.encode("ascii")).decode("ascii") reversed_secret = int.from_bytes(secret[::-1].encode("ascii"), "big") enc_sec_key = format( pow(reversed_secret, _WEAPI_PUBLIC_EXPONENT, _WEAPI_MODULUS), "x", ).zfill(256) return {"params": params, "encSecKey": enc_sec_key} def _render_qr_png(content: str) -> bytes: try: import qrcode from qrcode.constants import ERROR_CORRECT_M except ImportError as exc: raise RuntimeError("缺少 qrcode 依赖，请重新安装 requirements.txt") from exc qr = qrcode.QRCode( version=None, error_correction=ERROR_CORRECT_M, box_size=8, border=3, ) qr.add_data(content) qr.make(fit=True) image = qr.make_image(fill_color="black", back_color="white") output = io.BytesIO() image.save(output, format="PNG") return output.getvalue() def _request_json( url: str, *, opener: urllib.request.OpenerDirector | None = None, data: dict[str, Any] | None = None, ) -> tuple[dict[str, Any], Any]: encoded_data = None if data is not None: encoded_data = urllib.parse.urlencode(data).encode("utf-8") request = urllib.request.Request( url, data=encoded_data, headers={ "User-Agent": _USER_AGENT, "Referer": "https://music.163.com/", "Content-Type": "application/x-www-form-urlencoded", }, ) response = (opener or urllib.request.build_opener()).open(request, timeout=15) payload = json.loads(response.read().decode("utf-8", errors="replace")) if not isinstance(payload, dict): raise RuntimeError("网易云登录接口返回格式无效") return payload, response def _request_weapi_json( url: str, data: dict[str, Any], *, opener: urllib.request.OpenerDirector, secret_key: str | None = None, ) -> tuple[dict[str, Any], Any]: return _request_json( url, opener=opener, data=_weapi_form(data, secret_key=secret_key), ) def _cookie_values(jar: http.cookiejar.CookieJar, response: Any, payload: dict[str, Any]) -> dict[str, str]: values = {cookie.name: cookie.value for cookie in jar} headers = getattr(response, "headers", None) raw_headers = headers.get_all("Set-Cookie", []) if headers and hasattr(headers, "get_all") else [] for raw_header in raw_headers: parsed = http.cookies.SimpleCookie() try: parsed.load(raw_header) except http.cookies.CookieError: continue values.update({name: morsel.value for name, morsel in parsed.items()}) for raw_cookie in ( payload.get("cookie"), (payload.get("data") or {}).get("cookie") if isinstance(payload.get("data"), dict) else None, ): if not raw_cookie: continue parsed = http.cookies.SimpleCookie() try: parsed.load(str(raw_cookie)) except http.cookies.CookieError: continue values.update({name: morsel.value for name, morsel in parsed.items()}) return values class NeteaseQrLogin: """服务端保存二维码 key，登录成功后只把 MUSIC_U 交给保存回调。""" _STATUS_MESSAGES = { "idle": "尚未开始扫码登录", "awaiting_scan": "请使用网易云音乐客户端扫码", "awaiting_confirm": "已扫码，请在手机上确认登录", "completed": "登录成功，MUSIC_U 已自动保存", "expired": "二维码已过期，请重新生成", "failed": "网易云扫码登录失败", } def __init__( self, *, api_base: Callable[[], str], get_saved_music_u: Callable[[], str], save_music_u: Callable[[str, dict[str, Any]], Any], logger: logging.Logger, account_checker: Callable[[str, str], Any] | None = None, ttl_seconds: int = 180, ) -> None: self.api_base = api_base self.get_saved_music_u = get_saved_music_u self.save_music_u = save_music_u self.logger = logger self.account_checker = account_checker self.ttl_seconds = max(60, int(ttl_seconds)) self._lock = asyncio.Lock() self._session: dict[str, Any] | None = None def _base_url(self) -> str: return str(self.api_base() or "https://music.163.com").rstrip("/") def snapshot(self) -> dict[str, Any]: session = self._session or {} state = str(session.get("state") or "idle") expires_at = float(session.get("expires_at") or 0) expires_in = max(0, int(expires_at - time.time())) if expires_at else 0 return { "success": True, "state": state, "message": str(session.get("message") or self._STATUS_MESSAGES.get(state, "")), "expires_in": expires_in, "has_qr_image": state in {"awaiting_scan", "awaiting_confirm"} and expires_in > 0, "credential_configured": bool(str(self.get_saved_music_u() or "").strip()), "account": session.get("account"), } def _start_sync(self) -> dict[str, Any]: jar = http.cookiejar.CookieJar() opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar)) payload, _ = _request_weapi_json( f"{self._base_url()}/weapi/login/qrcode/unikey", {"type": 1, "csrf_token": ""}, opener=opener, ) key = str(payload.get("unikey") or (payload.get("data") or {}).get("unikey") or "").strip() if int(payload.get("code") or 0) != 200 or not key: raise RuntimeError(f"网易云二维码申请失败 code={payload.get('code')}") now = time.time() return { "state": "awaiting_scan", "message": self._STATUS_MESSAGES["awaiting_scan"], "created_at": now, "expires_at": now + self.ttl_seconds, "key": key, # The NetEase client currently accepts the exact HTTP URL emitted by # the official web login page. Using HTTPS shows an unsupported-login warning. "qr_url": f"http://music.163.com/login?codekey={key}", "jar": jar, "opener": opener, "account": None, } async def start(self) -> dict[str, Any]: async with self._lock: try: self._session = await asyncio.to_thread(self._start_sync) except Exception as exc: self._session = { "state": "failed", "message": str(exc) or type(exc).__name__, "expires_at": 0, } self.logger.warning("[网易云扫码登录] 二维码申请失败: %s", type(exc).__name__) return self.snapshot() self.logger.info("[网易云扫码登录] 二维码已生成，等待扫码") return self.snapshot() def _poll_sync(self, session: dict[str, Any]) -> dict[str, Any]: url = f"{self._base_url()}/weapi/login/qrcode/client/login" payload, response = _request_weapi_json( url, {"key": session["key"], "type": 1, "csrf_token": ""}, opener=session["opener"], ) code = int(payload.get("code") or 0) if code == 801: return {"state": "awaiting_scan", "message": self._STATUS_MESSAGES["awaiting_scan"]} if code == 802: return {"state": "awaiting_confirm", "message": self._STATUS_MESSAGES["awaiting_confirm"]} if code == 800: return {"state": "expired", "message": self._STATUS_MESSAGES["expired"]} if code != 803: return { "state": "failed", "message": str(payload.get("message") or f"网易云扫码状态异常 code={code}"), } music_u = str(_cookie_values(session["jar"], response, payload).get("MUSIC_U") or "").strip() if not music_u: return {"state": "failed", "message": "扫码成功但响应中缺少 MUSIC_U"} return {"state": "authenticated", "music_u": music_u} async def _check_account(self, music_u: str) -> dict[str, Any]: if self.account_checker: result = self.account_checker(self._base_url(), music_u) return await result if asyncio.iscoroutine(result) else result resolver = NeteaseResolver(self.logger, api_base=self._base_url(), music_u=music_u) return await resolver.account_status() async def poll(self) -> dict[str, Any]: async with self._lock: if not self._session: return self.snapshot() state = str(self._session.get("state") or "idle") if state in {"completed", "expired", "failed"}: return self.snapshot() if time.time() >= float(self._session.get("expires_at") or 0): self._session.update(state="expired", message=self._STATUS_MESSAGES["expired"]) return self.snapshot() try: result = await asyncio.to_thread(self._poll_sync, self._session) if result.get("state") != "authenticated": self._session.update(result) return self.snapshot() music_u = str(result.get("music_u") or "") account = await self._check_account(music_u) if not account.get("authenticated"): self._session.update(state="failed", message="扫码 Cookie 登录验证失败") return self.snapshot() callback_result = self.save_music_u(music_u, account) if asyncio.iscoroutine(callback_result): await callback_result self._session.update( state="completed", message=self._STATUS_MESSAGES["completed"], account={ "user_id": str(account.get("user_id") or ""), "nickname": str(account.get("nickname") or "网易云用户"), "vip_type": int(account.get("vip_type") or 0), }, ) self.logger.info("[网易云扫码登录] 登录成功，MUSIC_U 已自动保存") return self.snapshot() except Exception as exc: self._session.update( state="failed", message=str(exc) or f"扫码状态查询异常: {type(exc).__name__}", ) self.logger.warning("[网易云扫码登录] 状态查询或保存失败: %s", type(exc).__name__) return self.snapshot() async def qr_png(self) -> bytes: async with self._lock: if not self._session or self._session.get("state") not in {"awaiting_scan", "awaiting_confirm"}: raise RuntimeError("当前没有可用的网易云登录二维码") if time.time() >= float(self._session.get("expires_at") or 0): self._session.update(state="expired", message=self._STATUS_MESSAGES["expired"]) raise RuntimeError("网易云登录二维码已过期") content = str(self._session.get("qr_url") or "") return await asyncio.to_thread(_render_qr_png, content)