Update index.js

index.js

@@ -18,7 +18,8 @@ const CONFIG = {
     BASE_URL: process.env.DENO_URL || "https://partyrock.aws/stream/getCompletion",//如果需要多号循环，需要设置你自己的denourl
     API_KEY: process.env.API_KEY || "sk-123456",//自定义你自己的认证密钥，记得修改
     RedisUrl: process.env.RedisUrl,
-    RedisToken: process.env.RedisToken
+    RedisToken: process.env.RedisToken,
+    CAPSOLVER_KEY: "CAP-D6D78FCBD7B944444E992346185BE6384287DEDDA5085490CA16E371A9D55660" // 新增Capsolver密钥
   },
   SERVER: {
     PORT: process.env.PORT || 3000,
@@ -85,109 +86,6 @@ var RedisClient = class {
     }
   }
 };
-
-// 添加 Capsolver 相关配置
-const CAPSOLVER_CONFIG = {
-  API_KEY: process.env.CAPSOLVER_KEY || "YOUR_CAPSOLVER_KEY",
-  API_URL: "https://api.capsolver.com"
-};
-
-class CapsolverClient {
-  constructor(apiKey) {
-    this.apiKey = apiKey;
-  }
-
-  async createTask(websiteURL, websiteKey, extraParams = {}) {
-    // 第一步：发送初始化请求获取验证码 - 改用 GET 请求
-    const initResponse = await fetch(`${extraParams.captchaUrl}/captcha`, {
-      method: 'GET',
-      headers: {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-        'sec-ch-ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
-        'sec-ch-ua-platform': '"Windows"',
-        'sec-ch-ua-mobile': '?0',
-        'Referer': 'https://partyrock.aws/',
-        'Origin': 'https://partyrock.aws'
-      }
-    });
-
-    if (!initResponse.ok) {
-      console.error('初始化验证码失败:', await initResponse.text());
-      throw new Error('初始化验证码失败');
-    }
-
-    const initData = await initResponse.json();
-    console.log('验证码初始化数据:', initData);
-
-    // 第二步：创建 Capsolver 任务
-    const requestBody = JSON.stringify({
-      clientKey: this.apiKey,
-      task: {
-        type: "AwsWafClassification",
-        websiteURL: websiteURL,
-        websiteKey: websiteKey,
-        metadata: {
-          images: initData.images || [],
-          question: initData.question || '',
-          context: extraParams.gokuProps.context,
-          iv: extraParams.gokuProps.iv,
-          key: extraParams.gokuProps.key
-        }
-      }
-    });
-
-    console.log('发送到Capsolver的数据:', requestBody);
-
-    const response = await fetch(`${CAPSOLVER_CONFIG.API_URL}/createTask`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: requestBody
-    });
-
-    if (!response.ok) {
-      console.error('Capsolver API 响应不成功:', response.status);
-      const errorText = await response.text();
-      console.error('错误响应内容:', errorText);
-      throw new Error(`Capsolver API 请求失败: ${response.status}`);
-    }
-
-    const result = await response.json();
-    console.log('Capsolver 返回结果:', result);
-
-    // 第三步：提交验证结果
-    if (result.solution) {
-      const verifyResponse = await fetch(extraParams.captchaUrl + '/verify', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-          'sec-ch-ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
-          'sec-ch-ua-platform': '"Windows"',
-          'sec-ch-ua-mobile': '?0',
-          'Referer': 'https://partyrock.aws/',
-          'Origin': 'https://partyrock.aws'
-        },
-        body: JSON.stringify({
-          solution: result.solution,
-          context: extraParams.gokuProps.context,
-          iv: extraParams.gokuProps.iv,
-          key: extraParams.gokuProps.key
-        })
-      });
-
-      if (!verifyResponse.ok) {
-        throw new Error('验证提交失败');
-      }
-
-      return await verifyResponse.json();
-    }
-
-    return result;
-  }
-}
-
 class TokenManager {
   async updateRedisTokens() {
     await redisClient.set(`tokens_${currentIndex}`, JSON.stringify(Tokens[currentIndex]));
@@ -205,167 +103,20 @@ class TokenManager {
     CONFIG.DEFAULT_HEADERS["request-id"] = `request-id-${Utils.uuidv4()}`;
   }
 
-  async extractChallengeInfo(html) {
-    console.log('开始提取验证码信息...');
-    try {
-      // 提取 gokuProps
-      const gokuPropsMatch = html.match(/window\.gokuProps\s*=\s*({[\s\S]*?});/);
-      if (!gokuPropsMatch) {
-        console.error('未找到 gokuProps');
-        return null;
-      }
-
-      // 提取验证码和challenge URL
-      const captchaUrlMatch = html.match(/src="(https:\/\/[^"]+\/captcha\.js)"/);
-      const challengeUrlMatch = html.match(/src="(https:\/\/[^"]+\/challenge\.js)"/);
-
-      if (!captchaUrlMatch || !challengeUrlMatch) {
-        console.error('未找到验证码或challenge URL');
-        return null;
-      }
-
-      const gokuProps = JSON.parse(gokuPropsMatch[1]);
-      const captchaUrl = captchaUrlMatch[1].replace('/captcha.js', '');
-      const challengeUrl = challengeUrlMatch[1].replace('/challenge.js', '');
-
-      console.log('提取的信息:', {
-        gokuProps,
-        captchaUrl,
-        challengeUrl
-      });
-
-      return {
-        gokuProps,
-        captchaUrl,
-        challengeUrl
-      };
-    } catch (error) {
-      console.error('提取验证码信息时出错:', error);
-      return null;
-    }
-  }
-
-  async solveCaptcha(challengeInfo) {
-    console.log('开始处理验证码...');
-    const capsolverClient = new CapsolverClient(CAPSOLVER_CONFIG.API_KEY);
-    
-    try {
-      const websiteKey = challengeInfo.captchaUrl.split('/')[2].split('.')[0];
-      console.log('提取的websiteKey:', websiteKey);
-
-      console.log('创建验证码任务...');
-      const createTaskResponse = await capsolverClient.createTask(
-        "partyrock.aws",
-        websiteKey,
-        {
-          gokuProps: challengeInfo.gokuProps,
-          captchaUrl: challengeInfo.captchaUrl,
-          challengeUrl: challengeInfo.challengeUrl
-        }
-      );
-
-      console.log('创建任务响应:', JSON.stringify(createTaskResponse, null, 2));
-
-      if (createTaskResponse.errorId > 0) {
-        throw new Error(`创建验证码任务失败: ${createTaskResponse.errorDescription}`);
-      }
-
-      console.log('等待验证码解决结果...');
-      let taskResult;
-      for (let i = 0; i < 30; i++) {
-        console.log(`第 ${i + 1} 次尝试获取结果...`);
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        taskResult = await capsolverClient.getTaskResult(createTaskResponse.taskId);
-        console.log('获取结果响应:', JSON.stringify(taskResult, null, 2));
-        
-        if (taskResult.status === 'ready') {
-          console.log('验证码已解决!');
-          break;
-        }
-      }
-
-      if (!taskResult || taskResult.status !== 'ready') {
-        console.error('验证码解决超时');
-        throw new Error('验证码解决超时');
-      }
-
-      console.log('验证码解决方案:', JSON.stringify(taskResult.solution, null, 2));
-      return taskResult.solution;
-      
-    } catch (error) {
-      console.error('验证码解决过程中出错:', error);
-      throw error;
-    }
-  }
-
   async updateTokens(response, isWaf = false) {
     if (isWaf) {
-      console.log('检测到WAF验证请求');
-      try {
-        console.log('Response headers:', JSON.stringify(Object.fromEntries([...response.headers]), null, 2));
-        
-        // 获取HTML内容
-        const html = await response.text();
-        console.log('收到HTML响应');
-        
-        // 提取验证码信息
-        const challengeInfo = await this.extractChallengeInfo(html);
-        if (!challengeInfo) {
-          throw new Error('无法提取验证码信息');
-        }
-
-        console.log('开始处理WAF验证码...');
-        const solution = await this.solveCaptcha(challengeInfo);
-        
-        console.log('提交验证码解决方案...');
-        const verifyResponse = await fetch(`${challengeInfo.captchaUrl}/verify`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'Referer': 'https://partyrock.aws/',
-            'Origin': 'https://partyrock.aws'
-          },
-          body: JSON.stringify(solution)
-        });
-
-        console.log('验证响应状态:', verifyResponse.status);
-        console.log('验证响应headers:', JSON.stringify(Object.fromEntries([...verifyResponse.headers]), null, 2));
-
-        if (verifyResponse.ok) {
-          const voucherResponse = await verifyResponse.json();
-          console.log('获取到voucher:', voucherResponse);
-
-          // 提交voucher
-          const submitResponse = await fetch(`${challengeInfo.challengeUrl}/voucher`, {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Referer': 'https://partyrock.aws/',
-              'Origin': 'https://partyrock.aws'
-            },
-            body: JSON.stringify({
-              voucher: voucherResponse.voucher
-            })
-          });
-
-          if (submitResponse.ok) {
-            console.log('验证成功，更新WAF token...');
-            const wafToken = await Utils.extractWaf();
-            if (wafToken) {
-              Tokens[currentIndex].aws_waf_token = wafToken;
-              await this.updateCacheTokens();
-              this.updateRedisTokens();
-              console.log("成功更新 aws-waf-token");
-            }
-          }
-        }
-      } catch (error) {
-        console.error('处理验证码过程中发生错误:', error);
-        console.error('错误堆栈:', error.stack);
+      var wafToken = await Utils.extractWaf();
+      if (wafToken) {
+        Tokens[currentIndex].aws_waf_token = wafToken;
+        await this.updateCacheTokens();
+        this.updateRedisTokens();
+        currentIndex = (currentIndex + 1) % Tokens.length;
+        console.log("���功提取 aws-waf-token");
+      } else {
+        currentIndex = (currentIndex + 1) % Tokens.length;
+        await this.updateCacheTokens();
+        console.log("提取aws-waf-token失败");
       }
-      
-      currentIndex = (currentIndex + 1) % Tokens.length;
-      
     } else {
       const newCsrfToken = response.headers.get('anti-csrftoken-a2z');
       const cookies = response.headers.get('set-cookie');
@@ -384,6 +135,7 @@ class TokenManager {
   }
 }
 
+
 class Utils {
   static async getRandomUserAgent() {
     try {
@@ -398,18 +150,42 @@ class Utils {
       return type[Math.floor(Math.random() * type.length)]
     }
   }
+  static async solveAwsWaf(images, questionType = 'aws:grid') {
+    try {
+      const response = await fetch('https://api.capsolver.com/createTask', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          clientKey: CONFIG.API.CAPSOLVER_KEY,
+          task: {
+            type: 'AwsWafClassification',
+            websiteURL: Tokens[currentIndex].refreshUrl,
+            images: images,
+            question: questionType
+          }
+        })
+      });
+
+      const data = await response.json();
+      if (data.errorId === 0 && data.status === 'ready') {
+        return data.solution;
+      }
+      return null;
+    } catch (error) {
+      console.error('Capsolver请求失败:', error);
+      return null;
+    }
+  }
   static async extractWaf() {
     puppeteer.use(StealthPlugin())
     const browser = await puppeteer.launch({
       headless: true,
-      args: [
-        '--no-sandbox',
-        '--disable-setuid-sandbox',
-        '--disable-dev-shm-usage',
-        '--disable-gpu'
-      ],
+      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
       executablePath: CONFIG.CHROME_PATH
     });
+
     try {
       const page = await browser.newPage();
       await page.setExtraHTTPHeaders({
@@ -418,32 +194,48 @@ class Utils {
       await page.setUserAgent(
         CONFIG.DEFAULT_HEADERS["User-Agent"]
       )
+
+      // 监听验证挑战
+      page.on('response', async (response) => {
+        if (response.url().includes('aws-waf-challenge')) {
+          const screenshots = [];
+          
+          // 截取验证图片
+          const challengeElements = await page.$$('.aws-waf-challenge');
+          for (const element of challengeElements) {
+            const screenshot = await element.screenshot({ encoding: 'base64' });
+            screenshots.push(`data:image/png;base64,${screenshot}`);
+          }
+
+          // 调用Capsolver
+          const solution = await this.solveAwsWaf(screenshots, 'aws:grid');
+          
+          if (solution?.objects) {
+            // 自动点击验证答案
+            await page.evaluate((objects) => {
+              document.querySelectorAll('.grid-item').forEach((el, index) => {
+                if (objects.includes(index)) el.click();
+              });
+            }, solution.objects);
+          }
+        }
+      });
+
       await page.goto(Tokens[currentIndex].refreshUrl, {
         waitUntil: 'networkidle2',
         timeout: 30000
       });
-      await page.evaluate(() => {
-        // 随机滚动
-        window.scrollBy(0, Math.random() * 500)
-      })
-      await page.evaluate(() => {
-        return new Promise(resolve => setTimeout(resolve, 2000))
-      })
-      // 直接从页面 cookies 中提取 aws-waf-token
+
+      // 获取最终token
       const awsWafToken = (await page.cookies()).find(
         cookie => cookie.name.toLowerCase() === 'aws-waf-token'
       )?.value;
 
-      if (awsWafToken) {
-        await browser.close();
-        return awsWafToken;
-      } else {
-        await browser.close();
-        return null;
-      }
+      await browser.close();
+      return awsWafToken;
 
     } catch (error) {
-      console.error('获取 aws-waf-token 出错:', error);
+      console.error('获取aws-waf-token出错:', error);
       await browser.close();
       return null;
     }