Upload 25 files

Dockerfile

@@ -1,23 +1,23 @@
-# 选择精简版的Python镜像
-FROM python:3.11-slim
-
-# 设置工作目录
-WORKDIR /app
-
-# 复制应用代码到工作目录
-COPY . /app
-
-# 设置环境变量
-ENV DEMO_SECRET=123
-
-# 安装项目依赖
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 创建应用程序所需的目录，并赋予必要权限
-RUN mkdir -p /app/data && chmod -R 777 /app/data
-
-# 暴露应用所使用的端口
-EXPOSE 5005
-
-# 启动应用
+# 选择精简版的Python镜像
+FROM python:3.11-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制应用代码到工作目录
+COPY . /app
+
+# 设置环境变量
+ENV DEMO_SECRET=123
+
+# 安装项目依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 创建应用程序所需的目录，并赋予必要权限
+RUN mkdir -p /app/data && chmod -R 777 /app/data
+
+# 暴露应用所使用的端口
+EXPOSE 5005
+
+# 启动应用
 CMD ["python", "app.py"]

chat2api.py

@@ -1,4 +1,5 @@
 import asyncio
+import time
 import types
 import warnings
 
@@ -10,13 +11,14 @@ from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.security import OAuth2PasswordBearer
 from fastapi.templating import Jinja2Templates
 from starlette.background import BackgroundTask
+from starlette.responses import RedirectResponse, Response
 
 from chatgpt.ChatService import ChatService
-from chatgpt.authorization import refresh_all_tokens
+from chatgpt.authorization import refresh_all_tokens, verify_token, get_req_token
 import chatgpt.globals as globals
 from chatgpt.reverseProxy import chatgpt_reverse_proxy
 from utils.Logger import logger
-from utils.config import api_prefix, scheduled_refresh
+from utils.config import api_prefix, scheduled_refresh, enable_gateway
 from utils.retry import async_retry
 
 warnings.filterwarnings("ignore")
@@ -38,7 +40,8 @@ app.add_middleware(
 @app.on_event("startup")
 async def app_start():
     if scheduled_refresh:
-        scheduler.add_job(id='refresh', func=refresh_all_tokens, trigger='cron', hour=3, minute=0, day='*/4', kwargs={'force_refresh': True})
+        scheduler.add_job(id='refresh', func=refresh_all_tokens, trigger='cron', hour=3, minute=0, day='*/4',
+                          kwargs={'force_refresh': True})
         scheduler.start()
         asyncio.get_event_loop().call_later(0, lambda: asyncio.create_task(refresh_all_tokens(force_refresh=False)))
 
@@ -128,6 +131,103 @@ async def error_tokens():
     return {"status": "success", "error_tokens": error_tokens_list}
 
 
-@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
-async def reverse_proxy(request: Request, path: str):
-    return await chatgpt_reverse_proxy(request, path)
+if enable_gateway:
+    @app.get("/", response_class=HTMLResponse)
+    async def chatgpt(request: Request):
+        seed_token = request.query_params.get("seed")
+        if not seed_token:
+            seed_token = request.cookies.get("seed_token")
+        if not seed_token:
+            seed_token = str(int(time.time()))
+        req_token = get_req_token(seed_token)
+        seed_token = await verify_token(req_token)
+
+        response = templates.TemplateResponse("chatgpt.html", {"request": request, "access_token": seed_token})
+        response.set_cookie("seed_token", value=seed_token)
+        return response
+
+
+    @app.get("/backend-api/gizmos/bootstrap")
+    async def get_gizmos_bootstrap():
+        return {"gizmos": []}
+
+
+    # @app.get("/backend-api/conversations")
+    # async def get_conversations():
+    #     return {"items": [], "total": 0, "limit": 28, "offset": 0, "has_missing_conversations": False}
+
+    # @app.patch("/backend-api/conversations")
+    # async def get_conversations():
+    #     return {"success": True, "message": None}
+
+
+    @app.get("/backend-api/me")
+    async def get_me():
+        created = int(time.time())
+        return {
+            "object": "user",
+            "id": "org-chatgpt",
+            "email": "chatgpt@openai.com",
+            "name": "ChatGPT",
+            "picture": "https://cdn.auth0.com/avatars/ai.png",
+            "created": created,
+            "phone_number": None,
+            "mfa_flag_enabled": False,
+            "amr": [],
+            "groups": [],
+            "orgs": {
+                "object": "list",
+                "data": [
+                    {
+                        "object": "organization",
+                        "id": "org-chatgpt",
+                        "created": 1715641300,
+                        "title": "Personal",
+                        "name": "user-chatgpt",
+                        "description": "Personal org for chatgpt@openai.com",
+                        "personal": True,
+                        "settings": {},
+                        "parent_org_id": None,
+                        "is_default": False,
+                        "role": "owner",
+                        "is_scale_tier_authorized_purchaser": None,
+                        "is_scim_managed": False,
+                        "projects": {
+                            "object": "list",
+                            "data": []
+                        },
+                        "groups": [],
+                        "geography": None
+                    }
+                ]
+            },
+            "has_payg_project_spend_limit": None
+        }
+
+
+    banned_paths = ["backend-api/accounts/logout_all", "backend-api/accounts/deactivate",
+                    "backend-api/user_system_messages"]
+    redirect_paths = ["auth/logout"]
+    chatgpt_paths = ["c/"]
+
+
+    @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+    async def reverse_proxy(request: Request, path: str):
+        for chatgpt_path in chatgpt_paths:
+            if chatgpt_path in path:
+                return await chatgpt(request)
+
+        for banned_path in banned_paths:
+            if banned_path in path:
+                return Response(status_code=404)
+
+        for redirect_path in redirect_paths:
+            if redirect_path in path:
+                redirect_url = str(request.base_url)
+                return RedirectResponse(url=f"{redirect_url}?seed={int(time.time())}", status_code=302)
+
+        return await chatgpt_reverse_proxy(request, path)
+else:
+    @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+    async def reverse_proxy():
+        raise HTTPException(status_code=404, detail="Gateway is disabled")

chatgpt/ChatService.py

@@ -8,27 +8,46 @@ from starlette.concurrency import run_in_threadpool
 
 from api.files import get_image_size, get_file_extension, determine_file_use_case
 from api.models import model_proxy
-from chatgpt.authorization import get_req_token, verify_token
+from chatgpt.authorization import get_req_token, verify_token, get_ua
 from chatgpt.chatFormat import api_messages_to_chat, stream_response, format_not_stream_response, head_process_response
 from chatgpt.chatLimit import check_is_limit, handle_request_limit
 from chatgpt.proofofWork import get_config, get_dpl, get_answer_token, get_requirements_token
 
 from utils.Client import Client
 from utils.Logger import logger
-from utils.config import proxy_url_list, chatgpt_base_url_list, ark0se_token_url_list, history_disabled, pow_difficulty, \
-    conversation_only, enable_limit, upload_by_url, check_model, auth_key, user_agents_list, turnstile_solver_url
+from utils.config import (
+    proxy_url_list,
+    chatgpt_base_url_list,
+    ark0se_token_url_list,
+    history_disabled,
+    pow_difficulty,
+    conversation_only,
+    enable_limit,
+    upload_by_url,
+    check_model,
+    auth_key,
+    user_agents_list,
+    turnstile_solver_url,
+)
 
 
 class ChatService:
     def __init__(self, origin_token=None):
-        self.user_agent = random.choice(user_agents_list) if user_agents_list else "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
+        # self.user_agent = random.choice(user_agents_list) if user_agents_list else "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
         self.req_token = get_req_token(origin_token)
+        self.ua = get_ua(self.req_token)
+        self.user_agent = self.ua.get(
+            "User-Agent",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+        )
         self.chat_token = "gAAAAAB"
         self.s = None
         self.ws = None
 
     async def set_dynamic_data(self, data):
         if self.req_token:
+            logger.info(f"Request impersonate: {self.ua.get('impersonate')}")
+            logger.info(f"Request ua:{self.user_agent}")
             logger.info(f"Request token: {self.req_token}")
             req_len = len(self.req_token.split(","))
             if req_len == 1:
@@ -64,7 +83,7 @@ class ChatService:
         self.host_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
         self.ark0se_token_url = random.choice(ark0se_token_url_list) if ark0se_token_url_list else None
 
-        self.s = Client(proxy=self.proxy_url)
+        self.s = Client(proxy=self.proxy_url, impersonate=self.ua.get("impersonate", "safari15_3"))
 
         self.oai_device_id = str(uuid.uuid4())
         self.persona = None
@@ -85,13 +104,13 @@ class ChatService:
             'Origin': self.host_url,
             'Priority': 'u=1, i',
             'Referer': f'{self.host_url}/',
-            'Sec-Ch-Ua': '"Chromium";v="124", "Microsoft Edge";v="124", "Not-A.Brand";v="99"',
-            'Sec-Ch-Ua-Mobile': '?0',
-            'Sec-Ch-Ua-Platform': '"Windows"',
+            'Sec-Ch-Ua': self.ua.get("Sec-Ch-Ua", '"Chromium";v="124", "Microsoft Edge";v="124", "Not-A.Brand";v="99"'),
+            'Sec-Ch-Ua-Mobile': self.ua.get("Sec-Ch-Ua-Mobile", "?0"),
+            'Sec-Ch-Ua-Platform': self.ua.get("Sec-Ch-Ua-Platform", '"Windows"'),
             'Sec-Fetch-Dest': 'empty',
             'Sec-Fetch-Mode': 'cors',
             'Sec-Fetch-Site': 'same-origin',
-            'User-Agent': self.user_agent
+            'User-Agent': self.user_agent,
         }
         if self.access_token:
             self.base_url = self.host_url + "/backend-api"
@@ -155,12 +174,15 @@ class ChatService:
                         models = r.json().get('models')
                         if not any(self.req_model in model.get("slug", "") for model in models):
                             logger.error(f"Model {self.req_model} not support.")
-                            raise HTTPException(status_code=404, detail={
-                                "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
-                                "type": "invalid_request_error",
-                                "param": None,
-                                "code": "model_not_found"
-                            })
+                            raise HTTPException(
+                                status_code=404,
+                                detail={
+                                    "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
+                                    "type": "invalid_request_error",
+                                    "param": None,
+                                    "code": "model_not_found",
+                                },
+                            )
                     else:
                         raise HTTPException(status_code=404, detail="Failed to get models")
                 else:
@@ -168,12 +190,15 @@ class ChatService:
                     if self.persona != "chatgpt-paid":
                         if self.req_model == "gpt-4":
                             logger.error(f"Model {self.resp_model} not support for {self.persona}")
-                            raise HTTPException(status_code=404, detail={
-                                "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
-                                "type": "invalid_request_error",
-                                "param": None,
-                                "code": "model_not_found"
-                            })
+                            raise HTTPException(
+                                status_code=404,
+                                detail={
+                                    "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
+                                    "type": "invalid_request_error",
+                                    "param": None,
+                                    "code": "model_not_found",
+                                },
+                            )
 
                 turnstile = resp.get('turnstile', {})
                 turnstile_required = turnstile.get('required')
@@ -181,7 +206,9 @@ class ChatService:
                     turnstile_dx = turnstile.get("dx")
                     try:
                         if turnstile_solver_url:
-                            res = await self.s.post(turnstile_solver_url, json={"url": "https://chatgpt.com", "p": p, "dx": turnstile_dx})
+                            res = await self.s.post(
+                                turnstile_solver_url, json={"url": "https://chatgpt.com", "p": p, "dx": turnstile_dx}
+                            )
                             self.turnstile_token = res.json().get("t")
                     except Exception as e:
                         logger.info(f"Turnstile ignored: {e}")
@@ -197,12 +224,10 @@ class ChatService:
                     if not self.ark0se_token_url:
                         raise HTTPException(status_code=403, detail="Ark0se service required")
                     ark0se_dx = ark0se.get("dx")
-                    ark0se_client = Client()
+                    ark0se_client = Client(impersonate=self.ua.get("impersonate", "safari15_3"))
                     try:
                         r2 = await ark0se_client.post(
-                            url=self.ark0se_token_url,
-                            json={"blob": ark0se_dx, "method": ark0se_method},
-                            timeout=15
+                            url=self.ark0se_token_url, json={"blob": ark0se_dx, "method": ark0se_method}, timeout=15
                         )
                         r2esp = r2.json()
                         logger.info(f"ark0se_token: {r2esp}")
@@ -220,11 +245,11 @@ class ChatService:
                 if proofofwork_required:
                     proofofwork_diff = proofofwork.get("difficulty")
                     if proofofwork_diff <= pow_difficulty:
-                        raise HTTPException(status_code=403,
-                                            detail=f"Proof of work difficulty too high: {proofofwork_diff}")
+                        raise HTTPException(status_code=403, detail=f"Proof of work difficulty too high: {proofofwork_diff}")
                     proofofwork_seed = proofofwork.get("seed")
-                    self.proof_token, solved = await run_in_threadpool(get_answer_token, proofofwork_seed,
-                                                                       proofofwork_diff, config)
+                    self.proof_token, solved = await run_in_threadpool(
+                        get_answer_token, proofofwork_seed, proofofwork_diff, config
+                    )
                     if not solved:
                         raise HTTPException(status_code=403, detail="Failed to solve proof of work")
 
@@ -254,11 +279,13 @@ class ChatService:
             logger.error(f"Failed to format messages: {str(e)}")
             raise HTTPException(status_code=400, detail="Failed to format messages.")
         self.chat_headers = self.base_headers.copy()
-        self.chat_headers.update({
-            'Accept': 'text/event-stream',
-            'Openai-Sentinel-Chat-Requirements-Token': self.chat_token,
-            'Openai-Sentinel-Proof-Token': self.proof_token,
-        })
+        self.chat_headers.update(
+            {
+                'Accept': 'text/event-stream',
+                'Openai-Sentinel-Chat-Requirements-Token': self.chat_token,
+                'Openai-Sentinel-Proof-Token': self.proof_token,
+            }
+        )
         if self.ark0se_token:
             self.chat_headers['Openai-Sentinel-Ark' + 'ose-Token'] = self.ark0se_token
 
@@ -294,7 +321,7 @@ class ChatService:
             "suggestions": [],
             "timezone_offset_min": -480,
             "variant_purpose": "comparison_implicit",
-            "websocket_request_id": f"{uuid.uuid4()}"
+            "websocket_request_id": f"{uuid.uuid4()}",
         }
         if self.conversation_id:
             self.chat_request['conversation_id'] = self.conversation_id
@@ -304,8 +331,7 @@ class ChatService:
         try:
             url = f'{self.base_url}/conversation'
             stream = self.data.get("stream", False)
-            r = await self.s.post_stream(url, headers=self.chat_headers, json=self.chat_request, timeout=10,
-                                         stream=True)
+            r = await self.s.post_stream(url, headers=self.chat_headers, json=self.chat_request, timeout=10, stream=True)
             if r.status_code != 200:
                 rtext = await r.atext()
                 if "application/json" == r.headers.get("Content-Type", ""):
@@ -327,13 +353,19 @@ class ChatService:
             if "text/event-stream" in content_type:
                 res, start = await head_process_response(r.aiter_lines())
                 if not start:
-                    raise HTTPException(status_code=403, detail="Our systems have detected unusual activity coming from your system. Please try again later.")
+                    raise HTTPException(
+                        status_code=403,
+                        detail="Our systems have detected unusual activity coming from your system. Please try again later.",
+                    )
                 if stream:
                     return stream_response(self, res, self.resp_model, self.max_tokens)
                 else:
                     return await format_not_stream_response(
-                        stream_response(self, res, self.resp_model, self.max_tokens), self.prompt_tokens,
-                        self.max_tokens, self.resp_model)
+                        stream_response(self, res, self.resp_model, self.max_tokens),
+                        self.prompt_tokens,
+                        self.max_tokens,
+                        self.resp_model,
+                    )
             elif "application/json" in content_type:
                 rtext = await r.atext()
                 resp = json.loads(rtext)
@@ -376,12 +408,12 @@ class ChatService:
         url = f'{self.base_url}/files'
         headers = self.base_headers.copy()
         try:
-            r = await self.s.post(url, headers=headers, json={
-                "file_name": file_name,
-                "file_size": file_size,
-                "timezone_offset_min": -480,
-                "use_case": use_case
-            }, timeout=5)
+            r = await self.s.post(
+                url,
+                headers=headers,
+                json={"file_name": file_name, "file_size": file_size, "timezone_offset_min": -480, "use_case": use_case},
+                timeout=5,
+            )
             if r.status_code == 200:
                 res = r.json()
                 file_id = res.get('file_id')
@@ -395,12 +427,14 @@ class ChatService:
 
     async def upload(self, upload_url, file_content, mime_type):
         headers = self.base_headers.copy()
-        headers.update({
-            'Accept': 'application/json, text/plain, */*',
-            'Content-Type': mime_type,
-            'X-Ms-Blob-Type': 'BlockBlob',
-            'X-Ms-Version': '2020-04-08'
-        })
+        headers.update(
+            {
+                'Accept': 'application/json, text/plain, */*',
+                'Content-Type': mime_type,
+                'X-Ms-Blob-Type': 'BlockBlob',
+                'X-Ms-Version': '2020-04-08',
+            }
+        )
         headers.pop('Authorization', None)
         try:
             r = await self.s.put(upload_url, headers=headers, data=file_content)
@@ -438,7 +472,7 @@ class ChatService:
                         "mime_type": mime_type,
                         "width": width,
                         "height": height,
-                        "use_case": use_case
+                        "use_case": use_case,
                     }
                     logger.info(f"File_meta: {file_meta}")
                     return file_meta
@@ -468,10 +502,7 @@ class ChatService:
     async def get_response_file_url(self, conversation_id, message_id, sandbox_path):
         try:
             url = f"{self.base_url}/conversation/{conversation_id}/interpreter/download"
-            params = {
-                "message_id": message_id,
-                "sandbox_path": sandbox_path
-            }
+            params = {"message_id": message_id, "sandbox_path": sandbox_path}
             headers = self.base_headers.copy()
             r = await self.s.get(url, headers=headers, params=params, timeout=10)
             if r.status_code == 200:

chatgpt/authorization.py

@@ -1,28 +1,59 @@
 import asyncio
+import os
+import random
 
+import ua_generator
 from fastapi import HTTPException
 
+import chatgpt.globals as globals
 from chatgpt.refreshToken import rt2ac
 from utils.Logger import logger
-from utils.config import authorization_list
-import chatgpt.globals as globals
+from utils.config import authorization_list, random_token
+
+os.environ['PYTHONHASHSEED'] = '0'
+random.seed(0)
+
 
+def get_req_token(req_token, seed=None):
+    available_token_list = list(set(globals.token_list) - set(globals.error_token_list))
+    length = len(available_token_list)
+    if seed and length > 0:
+        req_token = globals.token_list[hash(seed) % length]
+        while req_token in globals.error_token_list:
+            req_token = random.choice(globals.token_list)
+        return req_token
 
-def get_req_token(req_token):
     if req_token in authorization_list:
-        if len(globals.token_list) - len(globals.error_token_list) > 0:
-            globals.count += 1
-            globals.count %= len(globals.token_list)
-            while globals.token_list[globals.count] in globals.error_token_list:
+        if len(available_token_list) > 0:
+            if random_token:
+                req_token = random.choice(available_token_list)
+                return req_token
+            else:
                 globals.count += 1
-                globals.count %= len(globals.token_list)
-            return globals.token_list[globals.count]
+                globals.count %= length
+                return available_token_list[globals.count]
         else:
             return None
     else:
         return req_token
 
 
+def get_ua(req_token):
+    user_agent = globals.user_agent_map.get(req_token, "")
+    # token为空，免登录用户，则随机生成ua
+    if not user_agent:
+        ua = ua_generator.generate(device='desktop', browser=('chrome', 'edge'), platform=('windows', 'macos'))
+        return {
+            "User-Agent": ua.text,
+            "Sec-Ch-Ua-Platform": ua.platform,
+            "Sec-Ch-Ua": ua.ch.brands,
+            "Sec-Ch-Ua-Mobile": ua.ch.mobile,
+            "impersonate": random.choice(globals.impersonate_list),
+        }
+    else:
+        return user_agent
+
+
 async def verify_token(req_token):
     if not req_token:
         if authorization_list:
@@ -45,7 +76,7 @@ async def verify_token(req_token):
 
 
 async def refresh_all_tokens(force_refresh=False):
-    for token in globals.token_list:
+    for token in list(set(globals.token_list) - set(globals.error_token_list)):
         if len(token) == 45:
             try:
                 await asyncio.sleep(2)

chatgpt/globals.py

@@ -1,6 +1,9 @@
 import json
 import os
 
+import ua_generator
+import random
+
 from utils.Logger import logger
 
 DATA_FOLDER = "data"
@@ -8,13 +11,28 @@ TOKENS_FILE = os.path.join(DATA_FOLDER, "token.txt")
 REFRESH_MAP_FILE = os.path.join(DATA_FOLDER, "refresh_map.json")
 ERROR_TOKENS_FILE = os.path.join(DATA_FOLDER, "error_token.txt")
 WSS_MAP_FILE = os.path.join(DATA_FOLDER, "wss_map.json")
+USER_AGENTS_FILE = os.path.join(DATA_FOLDER, "user_agents.json")
 
 count = 0
 token_list = []
 error_token_list = []
 refresh_map = {}
 wss_map = {}
-
+user_agent_map = {}
+impersonate_list = [
+    "chrome99",
+    "chrome100",
+    "chrome101",
+    "chrome104",
+    "chrome107",
+    "chrome110",
+    "chrome116",
+    "chrome119",
+    "chrome120",
+    "chrome123",
+    "edge99",
+    "edge101",
+]
 
 if not os.path.exists(DATA_FOLDER):
     os.makedirs(DATA_FOLDER)
@@ -30,8 +48,8 @@ if os.path.exists(WSS_MAP_FILE):
         wss_map = json.load(file)
 else:
     wss_map = {}
-    
-    
+
+
 if os.path.exists(TOKENS_FILE):
     with open(TOKENS_FILE, "r", encoding="utf-8") as f:
         for line in f:
@@ -41,6 +59,7 @@ else:
     with open(TOKENS_FILE, "w", encoding="utf-8") as f:
         pass
 
+
 if os.path.exists(ERROR_TOKENS_FILE):
     with open(ERROR_TOKENS_FILE, "r", encoding="utf-8") as f:
         for line in f:
@@ -50,5 +69,37 @@ else:
     with open(ERROR_TOKENS_FILE, "w", encoding="utf-8") as f:
         pass
 
+if os.path.exists(USER_AGENTS_FILE):
+    with open(USER_AGENTS_FILE, "r", encoding="utf-8") as f:
+        user_agent_map = json.load(f)
+    # token数量变化时，更新ua
+    if len(user_agent_map.keys()) != len(token_list):
+        new_tokens = list(set(token_list) - user_agent_map.keys())
+        for token in new_tokens:
+            ua = ua_generator.generate(device='desktop', browser=('chrome', 'edge'), platform=('windows', 'macos'))
+            ua_dict = {
+                "User-Agent": ua.text,
+                "Sec-Ch-Ua-Platform": ua.platform,
+                "Sec-Ch-Ua": ua.ch.brands,
+                "Sec-Ch-Ua-Mobile": ua.ch.mobile,
+                "impersonate": random.choice(impersonate_list),
+            }
+            user_agent_map[token] = ua_dict
+        with open(USER_AGENTS_FILE, "w", encoding="utf-8") as f:
+            f.write(json.dumps(user_agent_map, indent=4))
+else:
+    for token in token_list:
+        ua = ua_generator.generate(device='desktop', browser=('chrome', 'edge'), platform=('windows', 'macos'))
+        ua_dict = {
+            "User-Agent": ua.text,
+            "Sec-Ch-Ua-Platform": ua.platform,
+            "Sec-Ch-Ua": ua.ch.brands,
+            "Sec-Ch-Ua-Mobile": ua.ch.mobile,
+            "impersonate": random.choice(impersonate_list),
+        }
+        user_agent_map[token] = ua_dict
+    with open(USER_AGENTS_FILE, "w", encoding="utf-8") as f:
+        f.write(json.dumps(user_agent_map, indent=4))
+
 if token_list:
-    logger.info(f"Token list count: {len(token_list)}, Error token list count: {len(error_token_list)}")
+    logger.info(f"Token list count: {len(token_list)}, Error token list count: {len(error_token_list)}")

chatgpt/refreshToken.py

@@ -45,11 +45,14 @@ async def chat_refresh(refresh_token):
             access_token = r.json()['access_token']
             return access_token
         else:
-            with open(globals.ERROR_TOKENS_FILE, "a", encoding="utf-8") as f:
-                f.write(refresh_token + "\n")
-            if refresh_token not in globals.error_token_list:
-                globals.error_token_list.append(refresh_token)
-            raise Exception(r.text[:100])
+            if "invalid_grant" in r.text or "access_denied" in r.text:
+                if refresh_token not in globals.error_token_list:
+                    globals.error_token_list.append(refresh_token)
+                    with open(globals.ERROR_TOKENS_FILE, "a", encoding="utf-8") as f:
+                        f.write(refresh_token + "\n")
+                raise Exception(r.text)
+            else:
+                raise Exception(r.text[:300])
     except Exception as e:
         logger.error(f"Failed to refresh access_token `{refresh_token}`: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Failed to refresh access_token.")

chatgpt/reverseProxy.py

@@ -1,9 +1,11 @@
+import json
 import random
 
 from fastapi import Request, HTTPException
 from fastapi.responses import StreamingResponse, Response
 from starlette.background import BackgroundTask
 
+from chatgpt.authorization import verify_token, get_req_token
 from utils.Client import Client
 from utils.config import chatgpt_base_url_list, proxy_url_list, enable_gateway
 
@@ -60,105 +62,94 @@ headers_reject_list = [
 
 
 async def chatgpt_reverse_proxy(request: Request, path: str):
-    if not enable_gateway:
-        raise HTTPException(status_code=404, detail="Gateway is disabled")
     try:
         origin_host = request.url.netloc
-        if ":" in origin_host:
-            petrol = "http"
-        else:
+        if request.url.is_secure:
             petrol = "https"
-        if path.startswith("v1/"):
-            base_url = "https://ab.chatgpt.com"
         else:
-            base_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
-        if "/assets" in path:
-            base_url = "https://cdn.oaistatic.com"
+            petrol = "http"
+        if "x-forwarded-proto" in request.headers:
+            petrol = request.headers["x-forwarded-proto"]
+        if "cf-visitor" in request.headers:
+            cf_visitor = json.loads(request.headers["cf-visitor"])
+            petrol = cf_visitor.get("scheme", petrol)
 
         params = dict(request.query_params)
+        request_cookies = dict(request.cookies)
+
         headers = {
             key: value for key, value in request.headers.items()
-            if (key.lower() not in ["host", "origin", "referer", "user-agent",
-                                    "authorization"] and key.lower() not in headers_reject_list)
+            if (key.lower() not in ["host", "origin", "referer"] and key.lower() not in headers_reject_list)
         }
-        request_cookies = dict(request.cookies)
 
+        base_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        if "assets/" in path:
+            base_url = "https://cdn.oaistatic.com"
+        if "file-" in path and "backend-api" not in path:
+            base_url = "https://files.oaiusercontent.com"
+
+        # req_token = request.cookies.get("req_token")
+        # ua = get_ua(req_token)
+        # headers.update(ua)
         headers.update({
-            "accept-Language": "en-US,en;q=0.9",
+            "accept-language": "en-US,en;q=0.9",
             "host": base_url.replace("https://", "").replace("http://", ""),
             "origin": base_url,
             "referer": f"{base_url}/",
-            "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Microsoft Edge";v="128"',
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": "\"Windows\"",
             "sec-fetch-dest": "empty",
             "sec-fetch-mode": "cors",
             "sec-fetch-site": "same-origin",
-            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0"
         })
 
-        if request.headers.get('Authorization'):
-            headers['Authorization'] = request.headers['Authorization']
-
-        if headers.get("Content-Type") == "application/json":
-            data = await request.json()
+        seed_token = headers.get("authorization", "").replace("Bearer ", "")
+        if seed_token:
+            req_token = get_req_token(seed_token)
+            access_token = await verify_token(req_token)
+            if access_token.startswith("eyJhbGciOi"):
+                headers.update({"authorization": access_token})
+            else:
+                req_token = get_req_token(None, seed_token)
+                access_token = await verify_token(req_token)
+                headers.update({"authorization": access_token})
         else:
-            data = await request.body()
+            headers.pop("authorization", None)
+
+        data = await request.body()
 
         client = Client(proxy=random.choice(proxy_url_list) if proxy_url_list else None)
         try:
             background = BackgroundTask(client.close)
             r = await client.request(request.method, f"{base_url}/{path}", params=params, headers=headers,
                                      cookies=request_cookies, data=data, stream=True, allow_redirects=False)
-            if r.status_code == 304:
-                return Response(status_code=304, background=background)
-            elif r.status_code == 307:
-                if "oai-dm=1" not in r.headers.get("Location"):
-                    return Response(status_code=307, headers={
-                        "Location": r.headers.get("Location").replace("chat.openai.com", origin_host)
-                                    .replace("chatgpt.com", origin_host)
-                                    .replace("https", petrol)}, background=background)
-                else:
-                    return Response(status_code=307, headers={"Location": r.headers.get("Location")},
-                                    background=background)
-            elif r.status_code == 302:
+
+            if r.status_code == 302:
                 return Response(status_code=302,
                                 headers={"Location": r.headers.get("Location").replace("chatgpt.com", origin_host)
-                                .replace("chat.openai.com", origin_host)
-                                .replace("ab.chatgpt.com", origin_host)
                                 .replace("cdn.oaistatic.com", origin_host)
                                 .replace("https", petrol)}, background=background)
             elif 'stream' in r.headers.get("content-type", ""):
                 return StreamingResponse(r.aiter_content(), media_type=r.headers.get("content-type", ""),
                                          background=background)
             else:
-                if "/conversation" in path or "/register-websocket" in path:
+                if "/backend-api/conversation" in path or "/register-websocket" in path:
                     response = Response(content=(await r.atext()), media_type=r.headers.get("content-type"),
                                         status_code=r.status_code, background=background)
                 else:
                     content = ((await r.atext()).replace("chatgpt.com", origin_host)
-                               .replace("chat.openai.com", origin_host)
-                               .replace("ab.chatgpt.com", origin_host)
                                .replace("cdn.oaistatic.com", origin_host)
+                               # .replace("files.oaiusercontent.com", origin_host)
                                .replace("https", petrol))
                     rheaders = dict(r.headers)
-                    cache_control = rheaders.get("cache-control", "")
                     content_type = rheaders.get("content-type", "")
+                    cache_control = rheaders.get("cache-control", "")
+                    expires = rheaders.get("expires", "")
                     rheaders = {
                         "cache-control": cache_control,
-                        "content-type": content_type
+                        "content-type": content_type,
+                        "expires": expires
                     }
                     response = Response(content=content, headers=rheaders,
                                         status_code=r.status_code, background=background)
-                for cookie_name in r.cookies:
-                    if cookie_name in request_cookies:
-                        continue
-                    for cookie_domain in [".chatgpt.com"]:
-                        cookie_value = r.cookies.get(name=cookie_name, domain=cookie_domain)
-                        if cookie_name.startswith("__"):
-                            response.set_cookie(key=cookie_name, value=cookie_value, secure=True, httponly=True)
-                        else:
-                            response.set_cookie(key=cookie_name, value=cookie_value)
                 return response
         except Exception:
             await client.close()

requirements.txt

@@ -8,4 +8,5 @@ websockets
 pillow
 pybase64
 jinja2
-APScheduler
+APScheduler
+ua-generator

utils/Client.py

@@ -4,44 +4,41 @@ from curl_cffi.requests import AsyncSession
 
 
 class Client:
-    def __init__(self, proxy=None, timeout=15, verify=True):
-        self.proxies = {
-            "http": proxy,
-            "https": proxy,
-        }
+    def __init__(self, proxy=None, timeout=15, verify=True, impersonate='safari15_3'):
+        self.proxies = {"http": proxy, "https": proxy}
         self.timeout = timeout
         self.verify = verify
 
-        self.impersonate = random.choice(['safari15_3'])
+        self.impersonate = impersonate
         # impersonate=self.impersonate
 
         # self.ja3 = ""
         # self.akamai = ""
         # ja3=self.ja3, akamai=self.akamai
-        self.session = AsyncSession(proxies=self.proxies, timeout=self.timeout, verify=self.verify)
-        self.session2 = AsyncSession(proxies=self.proxies, timeout=self.timeout, verify=self.verify)
+        self.session = AsyncSession(proxies=self.proxies, timeout=self.timeout, impersonate=self.impersonate, verify=self.verify)
+        self.session2 = AsyncSession(proxies=self.proxies, timeout=self.timeout, impersonate=self.impersonate, verify=self.verify)
 
     async def post(self, *args, **kwargs):
-        r = await self.session.post(*args, impersonate=self.impersonate, **kwargs)
+        r = await self.session.post(*args, **kwargs)
         return r
 
     async def post_stream(self, *args, headers=None, cookies=None, **kwargs):
         if self.session:
             headers = headers or self.session.headers
             cookies = cookies or self.session.cookies
-        r = await self.session2.post(*args, headers=headers, cookies=cookies, impersonate=self.impersonate, **kwargs)
+        r = await self.session2.post(*args, headers=headers, cookies=cookies, **kwargs)
         return r
 
     async def get(self, *args, **kwargs):
-        r = await self.session.get(*args, impersonate=self.impersonate, **kwargs)
+        r = await self.session.get(*args, **kwargs)
         return r
 
     async def request(self, *args, **kwargs):
-        r = await self.session.request(*args, impersonate=self.impersonate, **kwargs)
+        r = await self.session.request(*args, **kwargs)
         return r
 
     async def put(self, *args, **kwargs):
-        r = await self.session.put(*args, impersonate=self.impersonate, **kwargs)
+        r = await self.session.put(*args, **kwargs)
         return r
 
     async def close(self):

utils/config.py

@@ -24,6 +24,7 @@ authorization = os.getenv('AUTHORIZATION', '').replace(' ', '')
 chatgpt_base_url = os.getenv('CHATGPT_BASE_URL', 'https://chatgpt.com').replace(' ', '')
 auth_key = os.getenv('AUTH_KEY', None)
 user_agents = os.getenv('USER_AGENTS', '[]')
+random_token = is_true(os.getenv('RANDOM_TOKEN', True))
 
 ark0se_token_url = os.getenv('ARK' + 'OSE_TOKEN_URL', '').replace(' ', '')
 if not ark0se_token_url:
@@ -37,7 +38,7 @@ turnstile_solver_url = os.getenv('TURNSTILE_SOLVER_URL', None)
 history_disabled = is_true(os.getenv('HISTORY_DISABLED', True))
 pow_difficulty = os.getenv('POW_DIFFICULTY', '000032')
 retry_times = int(os.getenv('RETRY_TIMES', 3))
-enable_gateway = is_true(os.getenv('ENABLE_GATEWAY', True))
+enable_gateway = is_true(os.getenv('ENABLE_GATEWAY', False))
 conversation_only = is_true(os.getenv('CONVERSATION_ONLY', False))
 enable_limit = is_true(os.getenv('ENABLE_LIMIT', True))
 upload_by_url = is_true(os.getenv('UPLOAD_BY_URL', False))
@@ -51,7 +52,7 @@ proxy_url_list = proxy_url.split(',') if proxy_url else []
 user_agents_list = ast.literal_eval(user_agents)
 
 logger.info("-" * 60)
-logger.info("Chat2Api 1.4.16 | https://github.com/lanqian528/chat2api")
+logger.info("Chat2Api 1.5.6 | https://github.com/lanqian528/chat2api")
 logger.info("-" * 60)
 logger.info("Environment variables:")
 logger.info("API_PREFIX:        " + str(api_prefix))
@@ -71,4 +72,5 @@ logger.info("UPLOAD_BY_URL:     " + str(upload_by_url))
 logger.info("CHECK_MODEL:       " + str(check_model))
 logger.info("SCHEDULED_REFRESH: " + str(scheduled_refresh))
 logger.info("USER_AGENTS:       " + str(user_agents_list))
+logger.info("RANDOM_TOKEN:      " + str(random_token))
 logger.info("-" * 60)