265 lines
13 KiB
Python
265 lines
13 KiB
Python
"""Windows DPAPI protects local CHSI cookies; passwords are never stored."""
|
|
import ctypes
|
|
import json
|
|
import os
|
|
import platform
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
from bs4 import BeautifulSoup
|
|
from studio.connectors import CatalogClient, LoginRequired
|
|
from studio.domain import now
|
|
from studio.network import ProxyUnavailable, RemoteUnavailable, RateLimited
|
|
|
|
LOGIN_URL = "https://account.chsi.com.cn/passport/login?entrytype=yzgr&service=https%3A%2F%2Fyz.chsi.com.cn%2Fj_spring_cas_security_check"
|
|
CATALOG_ENTRY = "https://yz.chsi.com.cn/zsml/a/dw.do"
|
|
|
|
|
|
class Blob(ctypes.Structure):
|
|
_fields_ = [("size", ctypes.c_ulong), ("data", ctypes.POINTER(ctypes.c_ubyte))]
|
|
|
|
|
|
def protect(payload, decrypt=False):
|
|
if os.name != "nt":
|
|
raise RuntimeError("凭据加密存储需要 Windows DPAPI")
|
|
memory = ctypes.create_string_buffer(payload)
|
|
source = Blob(len(payload), ctypes.cast(memory, ctypes.POINTER(ctypes.c_ubyte)))
|
|
result = Blob()
|
|
crypt = ctypes.windll.crypt32
|
|
fn = crypt.CryptUnprotectData if decrypt else crypt.CryptProtectData
|
|
# UI_FORBIDDEN prevents a modal system prompt in a background job.
|
|
if not fn(ctypes.byref(source), None, None, None, None, 1, ctypes.byref(result)):
|
|
raise RuntimeError("Windows 凭据加密失败,请使用当前 Windows 用户重新登录")
|
|
try:
|
|
return ctypes.string_at(result.data, result.size)
|
|
finally:
|
|
ctypes.windll.kernel32.LocalFree(result.data)
|
|
|
|
|
|
class CookieVault:
|
|
def __init__(self, directory):
|
|
self.path = Path(directory) / "chsi-cookie.enc"
|
|
self.path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
def _cipher(self):
|
|
from cryptography.fernet import Fernet
|
|
key_path = self.path.parent / "cookie.key"
|
|
if not key_path.exists():
|
|
try:
|
|
descriptor = os.open(key_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
except FileExistsError:
|
|
pass
|
|
else:
|
|
with os.fdopen(descriptor, "wb") as stream:
|
|
stream.write(Fernet.generate_key())
|
|
return Fernet(key_path.read_bytes())
|
|
|
|
def save(self, cookies):
|
|
temporary = self.path.with_suffix(".tmp")
|
|
payload = json.dumps(cookies, ensure_ascii=False).encode()
|
|
encrypted = protect(payload) if platform.system() == "Windows" else self._cipher().encrypt(payload)
|
|
descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
|
|
with os.fdopen(descriptor, "wb") as stream:
|
|
stream.write(encrypted)
|
|
temporary.replace(self.path)
|
|
|
|
def load(self):
|
|
if not self.path.exists():
|
|
return {}
|
|
payload = self.path.read_bytes()
|
|
if platform.system() == "Windows":
|
|
payload = protect(payload, decrypt=True)
|
|
else:
|
|
from cryptography.fernet import InvalidToken
|
|
try:
|
|
payload = self._cipher().decrypt(payload)
|
|
except InvalidToken:
|
|
raise ValueError("保存的 Cookie 无法解密,请重新登录") from None
|
|
return json.loads(payload)
|
|
|
|
def clear(self):
|
|
self.path.unlink(missing_ok=True)
|
|
|
|
|
|
class AuthService:
|
|
def __init__(self, transport, vault):
|
|
self.transport, self.vault = transport, vault
|
|
self.message = "尚未验证登录状态"
|
|
self.valid = False
|
|
self.state = "unverified"
|
|
self.checked_at = None
|
|
self.verified_route = None
|
|
self.revision = 0
|
|
self.state_lock = threading.RLock()
|
|
self.check_lock = threading.RLock()
|
|
self.browser_state = "idle"
|
|
self.browser_message = ""
|
|
self.browser_thread = None
|
|
self.browser_cancel = None
|
|
try:
|
|
self._load(self.vault.load())
|
|
except (RuntimeError, OSError, ValueError):
|
|
self.message = "保存的 Cookie 无法解密,请重新登录"
|
|
|
|
def _load(self, cookies):
|
|
if isinstance(cookies, dict):
|
|
cookies = [{"name": name, "value": value, "domain": ".chsi.com.cn", "path": "/"} for name, value in cookies.items()]
|
|
with self.transport.lock:
|
|
self.transport.session.cookies.clear()
|
|
for cookie in cookies:
|
|
domain = str(cookie.get("domain", ".chsi.com.cn"))
|
|
if domain.lstrip(".") != "chsi.com.cn" and not domain.endswith(".chsi.com.cn"):
|
|
continue
|
|
expires = cookie.get("expires")
|
|
self.transport.session.cookies.set(cookie["name"], cookie["value"], domain=domain, path=cookie.get("path", "/"), secure=bool(cookie.get("secure")), expires=int(expires) if expires and expires > 0 else None)
|
|
|
|
def _snapshot(self):
|
|
with self.transport.lock:
|
|
return [{"name": c.name, "value": c.value, "domain": c.domain, "path": c.path, "secure": c.secure, "expires": c.expires} for c in self.transport.session.cookies]
|
|
|
|
def status(self):
|
|
with self.state_lock:
|
|
if self.valid and self.verified_route != self.transport.router.status()["route"]:
|
|
self.invalidate("网络出口已变化,请验证目录访问后继续采集", state="unverified")
|
|
return {"saved": self.vault.path.exists(), "valid": self.valid, "state": self.state, "message": self.message, "checked_at": self.checked_at, "browser_state": self.browser_state, "browser_message": self.browser_message, "browser_supported": platform.system() == "Windows"}
|
|
|
|
def invalidate(self, message, state="login_required"):
|
|
with self.state_lock:
|
|
self.revision += 1
|
|
self.valid = False
|
|
self.state, self.message = state, message
|
|
self.verified_route = None
|
|
if self.browser_state == "completed":
|
|
self.browser_state, self.browser_message = "idle", ""
|
|
|
|
def cookie(self, text):
|
|
if not text.strip() or "\n" in text or "\r" in text:
|
|
raise ValueError("请粘贴单行 Cookie 请求头")
|
|
text = text.removeprefix("Cookie:").strip()
|
|
cookies = {}
|
|
for token in text.split(";"):
|
|
if "=" in token:
|
|
name, value = token.strip().split("=", 1)
|
|
if name and value:
|
|
cookies[name] = value
|
|
if not cookies:
|
|
raise ValueError("未识别到 Cookie 键值")
|
|
if self.browser_cancel:
|
|
self.browser_cancel.set()
|
|
with self.check_lock:
|
|
self._load(cookies)
|
|
self.vault.save(cookies)
|
|
self.invalidate("Cookie 已加密保存,点击验证确认目录访问权限", state="unverified")
|
|
self.checked_at = None
|
|
self.browser_state, self.browser_message = "idle", ""
|
|
return self.status()
|
|
|
|
def check(self):
|
|
with self.check_lock, self.transport.router.hold_route():
|
|
with self.state_lock:
|
|
self.invalidate("正在同步研招目录会话并验证访问权限", state="unverified")
|
|
revision = self.revision
|
|
try:
|
|
# The first ten rows are available anonymously, even for directions.
|
|
# Enter the CAS-protected page to bind cookies, then prove page-two access.
|
|
self.transport.request("GET", CATALOG_ENTRY)
|
|
CatalogClient(self.transport).fetch_page("yjfxs", {"dwdm": "10001", "zydm": "081200", "zymc": "计算机科学与技术", "curPage": 2, "start": 10, "pageSize": 10, "dwlxs[0]": "all"})
|
|
proof_route = self.transport.local.response_route
|
|
self.vault.save(self._snapshot())
|
|
except LoginRequired as exc:
|
|
self.invalidate(str(exc), state="captcha_required" if exc.reason == "captcha" else "login_required")
|
|
except (ProxyUnavailable, RemoteUnavailable, RateLimited):
|
|
self.invalidate("暂时无法验证研招目录,请检查网络或稍后重试;已保存的 Cookie 保留", state="unverified")
|
|
raise
|
|
else:
|
|
with self.state_lock:
|
|
# A later crawler login/captcha failure supersedes this older proof.
|
|
if self.revision == revision:
|
|
self.valid, self.state = True, "verified"
|
|
self.message = "研招目录登录会话已同步,第二页访问验证成功"
|
|
self.verified_route = proof_route
|
|
finally:
|
|
self.checked_at = now()
|
|
return self.status()
|
|
|
|
def login(self, username, password):
|
|
if not username or not password:
|
|
raise ValueError("请输入学信网账号和密码")
|
|
if self.browser_cancel:
|
|
self.browser_cancel.set()
|
|
with self.check_lock, self.transport.router.hold_route():
|
|
response = self.transport.request("GET", LOGIN_URL)
|
|
soup = BeautifulSoup(response.text, "html.parser")
|
|
form = {node.get("name"): node.get("value", "") for node in soup.select("input[type=hidden][name]")}
|
|
if "lt" not in form or "execution" not in form:
|
|
raise ValueError("登录页面需要人工验证,请使用浏览器登录")
|
|
form.update(username=username, password=password, _eventId="submit")
|
|
self.transport.request("POST", LOGIN_URL, data=form)
|
|
return self.check()
|
|
|
|
def clear(self):
|
|
if self.browser_cancel:
|
|
self.browser_cancel.set()
|
|
with self.check_lock:
|
|
self._load({})
|
|
self.vault.clear()
|
|
self.invalidate("已清除本项目保存的登录凭据", state="unverified")
|
|
self.checked_at = None
|
|
self.browser_state, self.browser_message = "idle", ""
|
|
return self.status()
|
|
|
|
def browser(self):
|
|
if platform.system() != "Windows":
|
|
self.browser_state = "unsupported"
|
|
self.browser_message = "服务器无桌面环境:请在自己电脑的浏览器完成学信网登录,再粘贴研招网 Cookie 并验证目录访问"
|
|
return self.status()
|
|
if self.browser_thread and self.browser_thread.is_alive() and not self.browser_cancel.is_set():
|
|
return self.status()
|
|
proxy = self.transport.router.resolve()
|
|
cancelled = threading.Event()
|
|
self.browser_cancel = cancelled
|
|
self.browser_state = "opening"
|
|
self.browser_message = "正在打开独立 Edge 登录窗口,完成登录后可关闭窗口"
|
|
|
|
def run():
|
|
from playwright.sync_api import sync_playwright
|
|
try:
|
|
with sync_playwright() as playwright:
|
|
browser = playwright.chromium.launch(channel="msedge", headless=False, proxy={"server": proxy} if proxy else None)
|
|
context = browser.new_context()
|
|
page = context.new_page()
|
|
page.goto(LOGIN_URL, wait_until="domcontentloaded", timeout=60000)
|
|
if cancelled.is_set():
|
|
browser.close()
|
|
return
|
|
self.browser_state = "waiting"
|
|
self.browser_message = "请在 Edge 完成学信网登录和验证码;窗口保持打开,工作台自动检测"
|
|
deadline = time.monotonic() + 300
|
|
while time.monotonic() < deadline and not cancelled.is_set():
|
|
page.wait_for_timeout(2000)
|
|
if "yz.chsi.com.cn" in page.url:
|
|
cookies = [c for c in context.cookies() if c["domain"].lstrip(".") == "chsi.com.cn" or c["domain"].endswith(".chsi.com.cn")]
|
|
if cookies:
|
|
with self.check_lock:
|
|
if cancelled.is_set():
|
|
break
|
|
self._load(cookies)
|
|
if self.check()["valid"] and not cancelled.is_set():
|
|
self.browser_state = "completed"
|
|
self.browser_message = "已获取登录 Cookie,目录接口验证成功"
|
|
browser.close()
|
|
return
|
|
browser.close()
|
|
if cancelled.is_set():
|
|
return
|
|
self.browser_state = "expired"
|
|
self.browser_message = "登录等待超时,可再次打开浏览器"
|
|
except Exception:
|
|
if cancelled.is_set():
|
|
return
|
|
self.browser_state = "failed"
|
|
self.browser_message = "登录窗口已关闭或连接失败,可重试或粘贴 Cookie"
|
|
self.browser_thread = threading.Thread(target=run, daemon=True, name="browser-login")
|
|
self.browser_thread.start()
|
|
return self.status()
|