#!/usr/bin/env python3 """ 闲鱼扫码登录工具 基于API接口实现二维码生成和Cookie获取（参照myfish-main项目） """ import asyncio import time import uuid import json import re from random import random from typing import Optional, Dict, Any import httpx import qrcode import qrcode.constants from loguru import logger import hashlib from urllib.parse import urlparse from utils.image_utils import image_manager def generate_headers(): """生成请求头""" return { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36', 'Accept': 'application/json, text/plain, */*', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Connection': 'keep-alive', 'Sec-Fetch-Dest': 'empty', 'Sec-Fetch-Mode': 'cors', 'Sec-Fetch-Site': 'same-origin', 'Referer': 'https://passport.goofish.com/', 'Origin': 'https://passport.goofish.com', } class GetLoginParamsError(Exception): """获取登录参数错误""" class GetLoginQRCodeError(Exception): """获取登录二维码失败""" class NotLoginError(Exception): """未登录错误""" class QRLoginSession: """二维码登录会话""" def __init__(self, session_id: str): self.session_id = session_id self.status = 'waiting' # waiting, scanned, success, expired, cancelled, verification_required self.qr_code_url = None self.qr_content = None self.cookies = {} self.unb = None self.created_time = time.time() self.expire_time = 300 # 5分钟过期 self.params = {} # 存储登录参数 self.verification_url = None # 风控验证URL self.screenshot_path = None # 风控验证截图 self.verification_task = None # 风控验证页面保持任务 self.success_source = None # 登录成功来源: api/browser def is_expired(self) -> bool: """检查是否过期""" return time.time() - self.created_time > self.expire_time def to_dict(self) -> Dict[str, Any]: """转换为字典""" return { 'session_id': self.session_id, 'status': self.status, 'qr_code_url': self.qr_code_url, 'created_time': self.created_time, 'is_expired': self.is_expired() } class QRLoginManager: """二维码登录管理器""" def __init__(self): self.sessions: Dict[str, QRLoginSession] = {} self.headers = generate_headers() self.host = "https://passport.goofish.com" self.api_mini_login = f"{self.host}/mini_login.htm" self.api_generate_qr = f"{self.host}/newlogin/qrcode/generate.do" self.api_scan_status = f"{self.host}/newlogin/qrcode/query.do" self.api_h5_tk = "https://h5api.m.goofish.com/h5/mtop.gaia.nodejs.gaia.idle.data.gw.v2.index.get/1.0/" # 配置代理（如果需要的话，取消注释并修改代理地址） # self.proxy = "http://127.0.0.1:7890" self.proxy = None # 配置超时时间 self.timeout = httpx.Timeout(connect=30.0, read=60.0, write=30.0, pool=60.0) def _cookie_marshal(self, cookies: dict) -> str: """将Cookie字典转换为字符串""" return "; ".join([f"{k}={v}" for k, v in cookies.items()]) def _create_async_client(self, **kwargs) -> httpx.AsyncClient: """创建兼容不同 httpx 版本代理参数的 AsyncClient。""" client_kwargs = dict(kwargs) if self.proxy: try: return httpx.AsyncClient(proxy=self.proxy, **client_kwargs) except TypeError as exc: if "unexpected keyword argument 'proxy'" in str(exc): return httpx.AsyncClient(proxies=self.proxy, **client_kwargs) raise return httpx.AsyncClient(**client_kwargs) def _build_browser_cookies(self, target_url: str, cookies: Dict[str, str]) -> list[Dict[str, Any]]: """将API会话中的Cookie转换为Playwright可用格式""" browser_cookies = [] parsed = urlparse(target_url or self.host) target_origin = f"{parsed.scheme or 'https'}://{parsed.netloc or 'passport.goofish.com'}" for name, value in (cookies or {}).items(): if not name or value is None: continue browser_cookies.append({ 'name': name, 'value': str(value), 'url': target_origin, 'path': '/', }) return browser_cookies def _normalize_cookie_dict(self, cookies: Any) -> Dict[str, str]: """将不同形式的Cookie数据统一转换为字典""" if isinstance(cookies, dict) or hasattr(cookies, 'items'): return { str(name): str(value) for name, value in cookies.items() if name and value is not None } normalized = {} for cookie in cookies or []: if not isinstance(cookie, dict): continue name = cookie.get('name') value = cookie.get('value') if name and value is not None: normalized[str(name)] = str(value) return normalized def _merge_session_cookies(self, session: QRLoginSession, cookies: Any): """合并Cookie到会话中""" cookie_dict = self._normalize_cookie_dict(cookies) if not cookie_dict: return session.cookies.update(cookie_dict) if cookie_dict.get('unb'): session.unb = cookie_dict['unb'] def _has_completed_login_cookies(self, cookie_dict: Dict[str, str]) -> bool: """基于关键Cookie判断是否已经完成登录""" if not cookie_dict.get('unb'): return False companion_keys = ('cookie2', 'havana_lgc2_77', '_tb_token_', 'sgcookie') return any(cookie_dict.get(key) for key in companion_keys) def _is_logged_in_url(self, url: str) -> bool: """判断URL是否已经跳转到登录后的页面""" current_url = str(url or '') if not current_url: return False if 'www.goofish.com/im' in current_url: return True return ( 'goofish.com' in current_url and 'passport.goofish.com' not in current_url and 'mini_login' not in current_url and '/iv/' not in current_url ) def _mark_session_success( self, session: QRLoginSession, cookies: Any, source: str, require_complete_cookies: bool = False ) -> bool: """统一的会话成功收口，避免多条链路重复覆盖状态""" if not session: return False self._merge_session_cookies(session, cookies) has_success_cookie = bool(session.cookies.get('unb')) has_complete_cookies = self._has_completed_login_cookies(session.cookies) if not has_success_cookie: return False if require_complete_cookies and not has_complete_cookies: return False was_success = session.status == 'success' session.status = 'success' session.success_source = session.success_source or source if not was_success: logger.info( f"扫码登录成功（来源: {source}）: {session.session_id}, " f"UNB: {session.unb}" ) return True async def _context_cookie_dict(self, context) -> Dict[str, str]: """提取浏览器上下文中的Cookie字典""" cookies = await context.cookies() return self._normalize_cookie_dict(cookies) async def _probe_browser_login_success(self, session: QRLoginSession, page, context) -> bool: """在浏览器侧兜底判断验证是否已经完成""" current_url = page.url cookie_dict = await self._context_cookie_dict(context) cookies_ready = self._has_completed_login_cookies(cookie_dict) url_ready = self._is_logged_in_url(current_url) if cookies_ready and url_ready: logger.info( f"扫码登录浏览器侧检测成功（当前页）: {session.session_id}, URL: {current_url}" ) return self._mark_session_success(session, cookie_dict, 'browser', require_complete_cookies=True) if not cookies_ready: return False probe_page = None try: probe_page = await context.new_page() await probe_page.goto('https://www.goofish.com/im', wait_until='domcontentloaded', timeout=30000) await probe_page.wait_for_timeout(1500) probe_url = probe_page.url probe_cookie_dict = await self._context_cookie_dict(context) im_root = await probe_page.query_selector('.rc-virtual-list-holder-inner') has_im_root = im_root is not None if self._is_logged_in_url(probe_url): logger.info( f"扫码登录浏览器侧探测成功: {session.session_id}, " f"probe_url: {probe_url}, has_im_root: {has_im_root}" ) return self._mark_session_success(session, probe_cookie_dict, 'browser', require_complete_cookies=True) except Exception as e: logger.debug(f"扫码登录浏览器侧探测未确认成功: {session.session_id}, 错误: {e}") finally: if probe_page: try: await probe_page.close() except Exception: pass return False async def _launch_verification_page(self, session_id: str): """在服务端打开验证页面并截取二维码，保持原始会话存活""" session = self.sessions.get(session_id) if not session or not session.verification_url: return playwright = None browser = None context = None page = None try: from playwright.async_api import async_playwright logger.info(f"开始打开扫码登录验证页面: {session_id}") playwright = await async_playwright().start() browser = await playwright.chromium.launch( headless=True, args=[ '--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-gpu', '--lang=zh-CN', ] ) context = await browser.new_context( viewport={'width': 540, 'height': 960}, locale='zh-CN', user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36', ignore_https_errors=True, extra_http_headers={ 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8' } ) browser_cookies = self._build_browser_cookies(session.verification_url, session.cookies) if browser_cookies: await context.add_cookies(browser_cookies) page = await context.new_page() await page.goto(session.verification_url, wait_until='domcontentloaded', timeout=60000) await page.wait_for_timeout(2500) screenshot_bytes = await page.screenshot(full_page=True) if screenshot_bytes: screenshot_path = image_manager.save_image(screenshot_bytes) if screenshot_path: if session.screenshot_path and session.screenshot_path != screenshot_path: image_manager.delete_image(session.screenshot_path) session.screenshot_path = screenshot_path logger.info(f"扫码登录验证截图已保存: {session_id}, 路径: {screenshot_path}") else: logger.warning(f"扫码登录验证截图保存失败: {session_id}") else: logger.warning(f"扫码登录验证截图为空: {session_id}") while True: current_session = self.sessions.get(session_id) if not current_session: break if current_session.status == 'success': logger.info(f"扫码登录验证页检测到会话已成功: {session_id}") break if current_session.status not in {'verification_required', 'scanned', 'waiting', 'processing'}: break if await self._probe_browser_login_success(current_session, page, context): break await page.wait_for_timeout(3000) except asyncio.CancelledError: logger.info(f"扫码登录验证页面任务已取消: {session_id}") raise except Exception as e: logger.error(f"打开扫码登录验证页面失败: {session_id}, 错误: {e}") finally: try: if page: await page.close() except Exception: pass try: if context: await context.close() except Exception: pass try: if browser: await browser.close() except Exception: pass try: if playwright: await playwright.stop() except Exception: pass latest_session = self.sessions.get(session_id) if latest_session: latest_session.verification_task = None logger.info(f"扫码登录验证页面已关闭: {session_id}") def _ensure_verification_task(self, session: QRLoginSession): """确保风控验证页面任务只启动一次""" task = session.verification_task if task and not task.done(): return session.verification_task = asyncio.create_task(self._launch_verification_page(session.session_id)) def _cleanup_session_assets(self, session: QRLoginSession): """清理会话关联的截图和后台任务""" task = session.verification_task if task and not task.done(): task.cancel() session.verification_task = None if session.screenshot_path: image_manager.delete_image(session.screenshot_path) session.screenshot_path = None async def _get_mh5tk(self, session: QRLoginSession) -> dict: """获取m_h5_tk和m_h5_tk_enc""" data = {"bizScene": "home"} data_str = json.dumps(data, separators=(',', ':')) t = str(int(time.time() * 1000)) app_key = "34839810" # 先发一次 GET 请求，获取 cookie 中的 m_h5_tk async with self._create_async_client(timeout=self.timeout, follow_redirects=True) as client: try: resp = await client.get(self.api_h5_tk, headers=self.headers) cookies = {k: v for k, v in resp.cookies.items()} session.cookies.update(cookies) m_h5_tk = cookies.get("m_h5_tk", "") token = m_h5_tk.split("_")[0] if "_" in m_h5_tk else "" # 生成签名 sign_input = f"{token}&{t}&{app_key}&{data_str}" sign = hashlib.md5(sign_input.encode()).hexdigest() # 构造最终请求参数 params = { "jsv": "2.7.2", "appKey": app_key, "t": t, "sign": sign, "v": "1.0", "type": "originaljson", "dataType": "json", "timeout": 20000, "api": "mtop.gaia.nodejs.gaia.idle.data.gw.v2.index.get", "data": data_str, } # 发请求正式获取数据，确保 token 有效 await client.post(self.api_h5_tk, params=params, headers=self.headers, cookies=session.cookies) return cookies except httpx.ConnectTimeout: logger.error("获取m_h5_tk时连接超时") raise except httpx.ReadTimeout: logger.error("获取m_h5_tk时读取超时") raise except httpx.ConnectError: logger.error("获取m_h5_tk时连接错误") raise async def _get_login_params(self, session: QRLoginSession) -> dict: """获取二维码登录时需要的表单参数""" params = { "lang": "zh_cn", "appName": "xianyu", "appEntrance": "web", "styleType": "vertical", "bizParams": "", "notLoadSsoView": False, "notKeepLogin": False, "isMobile": False, "qrCodeFirst": False, "stie": 77, "rnd": random(), } async with self._create_async_client(follow_redirects=True, timeout=self.timeout) as client: try: resp = await client.get( self.api_mini_login, params=params, cookies=session.cookies, headers=self.headers, ) # 正则匹配需要的json数据 pattern = r"window\.viewData\s*=\s*(\{.*?\});" match = re.search(pattern, resp.text) if match: json_string = match.group(1) view_data = json.loads(json_string) data = view_data.get("loginFormData") if data: data["umidTag"] = "SERVER" session.params.update(data) return data else: raise GetLoginParamsError("未找到loginFormData") else: raise GetLoginParamsError("获取登录参数失败") except httpx.ConnectTimeout: logger.error("获取登录参数时连接超时") raise except httpx.ReadTimeout: logger.error("获取登录参数时读取超时") raise except httpx.ConnectError: logger.error("获取登录参数时连接错误") raise async def generate_qr_code(self) -> Dict[str, Any]: """生成二维码""" try: # 创建新的会话 session_id = str(uuid.uuid4()) session = QRLoginSession(session_id) # 1. 获取m_h5_tk await self._get_mh5tk(session) logger.info(f"获取m_h5_tk成功: {session_id}") # 2. 获取登录参数 login_params = await self._get_login_params(session) logger.info(f"获取登录参数成功: {session_id}") # 3. 生成二维码 async with self._create_async_client(follow_redirects=True, timeout=self.timeout) as client: resp = await client.get( self.api_generate_qr, params=login_params, headers=self.headers ) logger.debug(f"[调试] 获取二维码接口原始响应: {resp.text}") try: results = resp.json() logger.debug(f"[调试] 获取二维码接口解析后: {json.dumps(results, ensure_ascii=False)}") except Exception as e: logger.exception("二维码接口返回不是JSON") raise GetLoginQRCodeError(f"二维码接口返回异常: {resp.text}") if results.get("content", {}).get("success") == True: # 更新会话参数 session.params.update({ "t": results["content"]["data"]["t"], "ck": results["content"]["data"]["ck"], }) # 获取二维码内容 qr_content = results["content"]["data"]["codeContent"] session.qr_content = qr_content # 生成二维码图片（base64格式） qr = qrcode.QRCode( version=5, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=2, ) qr.add_data(qr_content) qr.make() # 将二维码转换为base64 from io import BytesIO import base64 qr_img = qr.make_image() buffer = BytesIO() qr_img.save(buffer, format='PNG') qr_base64 = base64.b64encode(buffer.getvalue()).decode() qr_data_url = f"data:image/png;base64,{qr_base64}" session.qr_code_url = qr_data_url session.status = 'waiting' # 保存会话 self.sessions[session_id] = session # 启动状态检查任务 asyncio.create_task(self._monitor_qr_status(session_id)) logger.info(f"二维码生成成功: {session_id}") return { 'success': True, 'session_id': session_id, 'qr_code_url': qr_data_url } else: raise GetLoginQRCodeError("获取登录二维码失败") except httpx.ConnectTimeout as e: logger.error(f"连接超时: {e}") return {'success': False, 'message': f'连接超时，请检查网络或尝试使用代理'} except httpx.ReadTimeout as e: logger.error(f"读取超时: {e}") return {'success': False, 'message': f'读取超时，服务器响应过慢'} except httpx.ConnectError as e: logger.error(f"连接错误: {e}") return {'success': False, 'message': f'连接错误，请检查网络或代理设置'} except Exception as e: logger.exception("二维码生成过程中发生异常") return {'success': False, 'message': f'生成二维码失败: {str(e)}'} async def _poll_qrcode_status(self, session: QRLoginSession) -> httpx.Response: """获取二维码扫描状态""" async with self._create_async_client(follow_redirects=True, timeout=self.timeout) as client: resp = await client.post( self.api_scan_status, data=session.params, cookies=session.cookies, headers=self.headers, ) return resp async def _monitor_qr_status(self, session_id: str): """监控二维码状态""" try: session = self.sessions.get(session_id) if not session: return logger.info(f"开始监控二维码状态: {session_id}") # 监控登录状态 max_wait_time = 300 # 5分钟 start_time = time.time() while time.time() - start_time < max_wait_time: try: # 检查会话是否还存在 if session_id not in self.sessions: break if session.status == 'success': logger.info(f"扫码登录API轮询检测到会话已成功: {session_id}") break # 轮询二维码状态 resp = await self._poll_qrcode_status(session) if session.status == 'success': logger.info(f"扫码登录API轮询响应返回前，会话已由其他链路成功: {session_id}") break qrcode_status = ( resp.json() .get("content", {}) .get("data", {}) .get("qrCodeStatus") ) if qrcode_status == "CONFIRMED": # 登录确认 if ( resp.json() .get("content", {}) .get("data", {}) .get("iframeRedirect") is True ): # 账号被风控，需要手机验证 session.status = 'verification_required' iframe_url = ( resp.json() .get("content", {}) .get("data", {}) .get("iframeRedirectUrl") ) session.verification_url = iframe_url session.expire_time = max(session.expire_time, 600) self._merge_session_cookies(session, resp.cookies) self._ensure_verification_task(session) logger.warning(f"账号被风控，需要手机验证: {session_id}, URL: {iframe_url}") await asyncio.sleep(0.8) continue else: # 登录成功 if self._mark_session_success(session, resp.cookies, 'api'): break logger.warning(f"扫码登录API返回成功状态，但关键Cookie不足: {session_id}") elif qrcode_status == "NEW": # 二维码未被扫描，继续轮询 continue elif qrcode_status == "EXPIRED": # 二维码已过期 if session.status == 'verification_required': logger.info(f"二维码已过期，但会话已进入验证流程，继续等待: {session_id}") else: session.status = 'expired' logger.info(f"二维码已过期: {session_id}") break elif qrcode_status == "SCANED": # 二维码已被扫描，等待确认 if session.status == 'waiting': session.status = 'scanned' logger.info(f"二维码已扫描，等待确认: {session_id}") else: # 用户取消确认 if session.status == 'verification_required': logger.info(f"扫码状态 {qrcode_status}，但验证流程仍在进行，继续等待: {session_id}") else: session.status = 'cancelled' logger.info(f"用户取消登录: {session_id}") break await asyncio.sleep(0.8) # 每0.8秒检查一次 except Exception as e: logger.error(f"监控二维码状态异常: {e}") await asyncio.sleep(2) # 超时处理 if session.status not in ['success', 'expired', 'cancelled', 'verification_required']: session.status = 'expired' logger.info(f"二维码监控超时，标记为过期: {session_id}") except Exception as e: logger.error(f"监控二维码状态失败: {e}") if session_id in self.sessions: self.sessions[session_id].status = 'expired' def get_session_status(self, session_id: str) -> Dict[str, Any]: """获取会话状态""" session = self.sessions.get(session_id) if not session: return {'status': 'not_found'} if session.is_expired() and session.status != 'success': session.status = 'expired' result = { 'status': session.status, 'session_id': session_id } logger.info(f"获取会话状态: {result}") # 如果需要验证，返回验证URL if session.status == 'verification_required': result['verification_url'] = session.verification_url result['screenshot_path'] = session.screenshot_path result['message'] = '账号被风控，需要扫码验证' if session.screenshot_path else '账号被风控，正在准备验证二维码' # 如果登录成功，返回Cookie信息 if session.status == 'success' and session.cookies and session.unb: result['cookies'] = self._cookie_marshal(session.cookies) result['unb'] = session.unb return result def cleanup_expired_sessions(self): """清理过期会话""" expired_sessions = [] for session_id, session in self.sessions.items(): if session.is_expired(): expired_sessions.append(session_id) for session_id in expired_sessions: self._cleanup_session_assets(self.sessions[session_id]) del self.sessions[session_id] logger.info(f"清理过期会话: {session_id}") def get_session_cookies(self, session_id: str) -> Optional[Dict[str, str]]: """获取会话Cookie""" session = self.sessions.get(session_id) if session and session.status == 'success': return { 'cookies': self._cookie_marshal(session.cookies), 'unb': session.unb } return None # 全局二维码登录管理器实例 qr_login_manager = QRLoginManager()