block-proxy 0.1.0

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "block-proxy",
+  "version": "0.1.0",
+  "description": "Small-scale network proxy filter",
+  "bin":{
+    "block-proxy": "./bin/start.js"
+  },
+  "dependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-scripts": "5.0.1",
+    "web-vitals": "^2.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jayli/block-proxy.git"
+  },
+  "scripts": {
+    "cp": "cp ./hack-of-anyproxy/lib/requestHandler.js ./node_modules/anyproxy/lib/",
+    "craco": "craco start",
+    "dev": "BLOCK_PROXY_DEV=1 npm run express",
+    "start": "npm run express",
+    "socks5": "node ./socks5/start.js",
+    "express": "npm run cp && node ./server/start.js",
+    "proxy": "npm run cp && node ./proxy/start.js",
+    "build": "react-scripts build",
+    "docker:build": "npm run build && docker build -t block-proxy .",
+    "docker:build_arm": "npm run build && docker buildx build --platform linux/arm64/v8 -t block-proxy .",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject"
+  },
+  "devDependencies": {
+    "@craco/craco": "^7.1.0",
+    "anyproxy": "^4.1.3",
+    "axios": "^1.13.2",
+    "express": "^5.1.0",
+    "http-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7.0.6",
+    "ping": "^1.0.0",
+    "write-file-atomic": "^7.0.0"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

package/proxy/attacker.js

@@ -0,0 +1,135 @@
+// proxy/attacker.js
+// 存储每个 IP 的访问信息
+const ipAccessLog = new Map(); 
+// value: { timestamps: number[], isBad: boolean, lastSeen: number, goodUntil: number | null }
+
+const WINDOW_MS = 2 * 60 * 1000;        // 2 分钟滑动窗口
+const BAD_THRESHOLD = 20;               // 恶意阈值
+const INACTIVE_TIMEOUT = 10 * 60 * 1000; // 普通 IP 10 分钟无活动则清理
+const GOOD_GUY_DURATION = 10 * 60 * 1000; // 好人豁免期：10 分钟
+
+/**
+ * 记录并返回指定 IP 在过去 2 分钟内的访问次数
+ * 如果在“好人豁免期”内，即使高频也不标记为恶意
+ */
+function countIPAccess(ip) {
+  const now = Date.now();
+  const cutoff = now - WINDOW_MS;
+
+  let record = ipAccessLog.get(ip);
+  if (!record) {
+    record = {
+      timestamps: [],
+      isBad: false,
+      lastSeen: 0,
+      goodUntil: null // 新增字段
+    };
+  }
+
+  // 清理过期时间戳
+  const recentTimestamps = record.timestamps.filter(ts => ts > cutoff);
+  recentTimestamps.push(now);
+  const currentCount = recentTimestamps.length;
+
+  // 🔒 判断是否处于“好人豁免期”
+  const isInGoodPeriod = record.goodUntil && now < record.goodUntil;
+
+  // 只有不在豁免期，才可能被标记为坏人
+  const newIsBad = isInGoodPeriod 
+    ? false 
+    : (record.isBad || currentCount >= BAD_THRESHOLD);
+
+  ipAccessLog.set(ip, {
+    timestamps: recentTimestamps,
+    isBad: newIsBad,
+    lastSeen: now,
+    goodUntil: record.goodUntil // 保留原有 goodUntil
+  });
+
+  return currentCount;
+}
+
+/**
+ * 判断是否为恶意 IP
+ * 注意：即使 isBad=true，若在 goodUntil 期内，也应视为非恶意（但按你要求，isBad 字段可保留）
+ * 但根据你的描述：“只要被标记过是好人就不能被标记为坏人”，我们让 isBad=false 在豁免期内
+ * —— 实际上上面 countIPAccess 已确保 isBad 不会为 true
+ */
+function isBadGuy(ip) {
+  const record = ipAccessLog.get(ip);
+  if (!record) return false;
+
+  const now = Date.now();
+  const isInGoodPeriod = record.goodUntil && now < record.goodUntil;
+
+  // 豁免期内，即使 isBad 字段残留，也返回 false
+  return isInGoodPeriod ? false : record.isBad;
+}
+
+/**
+ * 手动将 IP 标记为“好人”：获得 10 分钟豁免权
+ * - 不能被标记为恶意
+ * - 记录至少保留 10 分钟（即使无访问）
+ */
+function setGoodGuy(ip) {
+  const now = Date.now();
+  let record = ipAccessLog.get(ip);
+
+  if (!record) {
+    record = {
+      timestamps: [],
+      isBad: false,
+      lastSeen: now,
+      goodUntil: null
+    };
+  }
+
+  // 设置豁免截止时间
+  record.goodUntil = now + GOOD_GUY_DURATION;
+  record.lastSeen = now; // 更新 lastSeen 防止被 cleanup 立即删掉
+  record.isBad = false;  // 立即洗白
+
+  ipAccessLog.set(ip, record);
+}
+
+/**
+ * 清理过期记录：
+ * - 普通 IP：10 分钟无访问 → 删除
+ * - 好人 IP：即使无访问，只要 goodUntil 未过期 → 保留
+ */
+function cleanupInactiveIPs() {
+  const now = Date.now();
+  const inactiveCutoff = now - INACTIVE_TIMEOUT;
+
+  for (const [ip, record] of ipAccessLog.entries()) {
+    const isGoodGuyActive = record.goodUntil && now < record.goodUntil;
+
+    if (!isGoodGuyActive && record.lastSeen < inactiveCutoff) {
+      // 不是活跃好人，且超过 10 分钟无访问 → 删除
+      ipAccessLog.delete(ip);
+    } else {
+      // 清理 timestamps 中的过期项
+      const recent = record.timestamps.filter(ts => ts > now - WINDOW_MS);
+      if (recent.length !== record.timestamps.length) {
+        ipAccessLog.set(ip, { ...record, timestamps: recent });
+      }
+    }
+  }
+
+  // 在 countIPAccess 中增加硬上限（例如最多保留 10,000 个 IP）
+  if (ipAccessLog.size > 10000) {
+    // 按 lastSeen 排序，删除最旧的一批
+    const sorted = Array.from(ipAccessLog.entries())
+      .sort((a, b) => a[1].lastSeen - b[1].lastSeen);
+    for (let i = 0; i < 1000; i++) {
+      ipAccessLog.delete(sorted[i][0]);
+    }
+  }
+}
+
+module.exports = {
+  countIPAccess,
+  isBadGuy,
+  setGoodGuy,
+  cleanupInactiveIPs
+};

package/proxy/domain.js

@@ -0,0 +1,26 @@
+// proxy/domain.js
+const { lookup, resolve4 } = require('dns');
+const { promisify } = require('util');
+
+const lookupAsync = promisify(lookup);
+const resolve4Async = promisify(resolve4);
+
+async function getDomainIP(domain) {
+  try {
+    const addresses = await resolve4Async(domain);
+    return addresses; // 返回数组，如 ['93.184.216.34']
+  } catch (err) {
+    console.error(`Failed to resolve ${domain}:`, err.message);
+    return null;
+  }
+}
+
+// 使用示例
+/*
+getDomainIP('example.com').then(ips => {
+  if (ips) {
+    console.log(`${ips.length} IP(s):`, ips.join(', '));
+  }
+});
+*/
+module.exports.getDomainIP = getDomainIP;

package/proxy/fs.js

@@ -0,0 +1,46 @@
+// proxy/fs.js
+const fs = require('fs').promises;
+const path = require('path');
+const writeFileAtomic = require('write-file-atomic'); // 引入 write-file-atomic
+
+const configPath = path.join(__dirname, '../config.json');
+const CONFIG_FILE_PATH = configPath;
+
+// 传入的是对象
+async function writeConfig(newData) {
+  try {
+    // 使用 write-file-atomic 进行原子写入
+    // 它会在内部创建一个临时文件，写入成功后再重命名为目标文件
+    await writeFileAtomic(CONFIG_FILE_PATH, JSON.stringify(newData, null, 2), 'utf8');
+    // console.log('Config file written successfully');
+  } catch (error) {
+    console.error('Error writing config file:', error.message);
+    throw error; // 或者根据需要处理错误
+  }
+}
+
+// 示例：读取配置
+// 返回的是对象
+async function readConfig() {
+  try {
+    const data = await fs.readFile(CONFIG_FILE_PATH, 'utf8');
+    const config = JSON.parse(data);
+    return config;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.error('Config file does not exist.');
+      return {}; // 或返回一个默认配置对象
+    } else if (error instanceof SyntaxError) {
+      console.error('Error parsing config file JSON:', error.message);
+      throw error;
+    } else {
+      console.error('Error reading config file:', error.message);
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  writeConfig,
+  readConfig
+};

package/proxy/http.js

@@ -0,0 +1,224 @@
+// proxy/http.js
+const net = require('net');
+
+/**
+ * 发送 HTTP 请求并返回完整响应（绕过头校验）
+ * @param {Object} options - 同 http.request 的 options
+ * @returns {Promise<{ statusCode: number, headers: Object, body: string }>}
+ */
+function requestNoValidationSync(options) {
+  return new Promise((resolve, reject) => {
+    const method = (options.method || 'GET').toUpperCase();
+    const hostname = options.hostname || options.host || 'localhost';
+    const port = options.port || 80;
+    const path = options.path || '/';
+    const headers = options.headers || {};
+
+    // 构造 Host 头
+    let host = hostname;
+    if (port !== 80) host += ':' + port;
+    const finalHeaders = { ...headers };
+    if (!('Host' in finalHeaders) && !('host' in finalHeaders)) {
+      finalHeaders.Host = host;
+    }
+
+    // 构造请求头
+    let headerStr = `${method} ${path} HTTP/1.1\r\n`;
+    for (const [key, val] of Object.entries(finalHeaders)) {
+      headerStr += `${key}: ${val}\r\n`;
+    }
+    headerStr += '\r\n';
+
+    const socket = net.connect(port, hostname);
+
+    const handleError = (err) => {
+      socket.destroy();
+      reject(err);
+    };
+
+    socket.on('error', handleError);
+
+    let buffer = Buffer.alloc(0);
+    let responseParsed = false;
+    let statusCode, statusMessage, headersObj, rawHeaders;
+    let bodyChunks = [];
+    let expectedBodyLength = null;
+    let receivedBodyLength = 0;
+
+    socket.write(headerStr);
+
+    // 如果有请求体（简单支持字符串）
+    if (options.body) {
+      socket.write(options.body);
+    }
+    // 注意：不要在这里调用 socket.end()，避免过早关闭连接
+
+    socket.on('data', (chunk) => {
+      if (!responseParsed) {
+        buffer = Buffer.concat([buffer, chunk]);
+        const headerEndIndex = buffer.indexOf('\r\n\r\n');
+        if (headerEndIndex === -1) return;
+
+        const headerBytes = buffer.slice(0, headerEndIndex);
+        // 修正: 只需要跳过 \r\n\r\n (4 bytes) 而不是8 bytes
+        const bodyStart = headerEndIndex + 4;
+        const bodyChunk = buffer.slice(bodyStart);
+
+        const lines = headerBytes.toString('ascii').split('\r\n');
+        const statusLine = lines[0];
+        const match = statusLine.match(/^HTTP\/[10]\.[10]\s+(\d{3})\s*(.*)$/i);
+        if (!match) {
+          return handleError(new Error('Invalid HTTP status line'));
+        }
+
+        statusCode = parseInt(match[1], 10);
+        statusMessage = match[2] || '';
+
+        // 手动解析头部（不校验冲突！）
+        headersObj = {};
+        rawHeaders = [];
+        for (let i = 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (!line) continue;
+          const idx = line.indexOf(':');
+          if (idx === -1) continue;
+          const key = line.slice(0, idx).trim();
+          const val = line.slice(idx + 1).trim();
+          const lowerKey = key.toLowerCase();
+          rawHeaders.push(key, val);
+          if (headersObj[lowerKey] === undefined) {
+            headersObj[lowerKey] = val;
+          } else if (Array.isArray(headersObj[lowerKey])) {
+            headersObj[lowerKey].push(val);
+          } else {
+            headersObj[lowerKey] = [headersObj[lowerKey], val];
+          }
+        }
+
+        // 获取Content-Length
+        const contentLength = headersObj['content-length'];
+        if (contentLength !== undefined) {
+          expectedBodyLength = parseInt(contentLength, 10);
+        }
+
+        responseParsed = true;
+
+        if (expectedBodyLength == 0) {
+          socket.end();
+        }
+
+        // 处理初始的bodyChunk（如果有）
+        if (bodyChunk.length > 0) {
+          // 检查是否为chunked编码
+          const transferEncoding = headersObj['transfer-encoding'];
+          if (transferEncoding && transferEncoding.includes('chunked')) {
+            // 对于chunked数据，我们将其存储为原始数据，在end事件中统一处理
+            bodyChunks.push(bodyChunk);
+            receivedBodyLength += bodyChunk.length;
+          } else {
+            // 非chunked数据按原来的方式处理
+            bodyChunks.push(bodyChunk);
+            receivedBodyLength += bodyChunk.length;
+          }
+        }
+
+        // 如果已知内容长度且已经接收完毕，则关闭连接
+        if (expectedBodyLength !== null && receivedBodyLength >= expectedBodyLength) {
+          socket.end();
+        }
+      } else {
+        // 已经解析了响应头，正在接收响应体
+        bodyChunks.push(chunk);
+        receivedBodyLength += chunk.length;
+
+        // 检查是否已接收完整的响应体
+        if (expectedBodyLength !== null && receivedBodyLength >= expectedBodyLength) {
+          socket.end();
+        }
+      }
+    });
+
+    socket.on('end', () => {
+      // 检查是否为分块传输编码
+      const transferEncoding = headersObj['transfer-encoding'];
+      let finalBody = '';
+
+      if (transferEncoding && transferEncoding.includes('chunked')) {
+        // 对每个buffer分别进行解码
+        for (const chunkBuffer of bodyChunks) {
+          const chunkString = chunkBuffer.toString('utf8');
+          let decodedChunk = '';
+          let position = 0;
+
+          while (position < chunkString.length) {
+            // 查找当前块大小行的结束位置
+            let lineEnding = chunkString.indexOf('\r\n', position);
+            if (lineEnding === -1) break;
+
+            // 提取块大小（十六进制字符串）
+            const chunkSizeHex = chunkString.substring(position, lineEnding).trim();
+            const chunkSize = parseInt(chunkSizeHex, 16);
+
+            // 如果块大小为0，表示这是最后一个块
+            if (chunkSize === 0) {
+              break;
+            }
+
+            // 块数据开始位置
+            const dataStart = lineEnding + 2;
+            // 块数据结束位置
+            const dataEnd = dataStart + chunkSize;
+
+            // 确保我们没有超出边界
+            if (dataEnd <= chunkString.length) {
+              // 提取块数据
+              decodedChunk += chunkString.substring(dataStart, dataEnd);
+              // 移动到下一个块的大小行
+              position = dataEnd + 2; // 跳过数据后的 \r\n
+            } else {
+              // 数据不完整，跳出循环
+              break;
+            }
+          }
+
+          // 将解码后的chunk添加到最终结果中
+          finalBody += decodedChunk;
+        }
+
+        body = finalBody;
+      } else if (expectedBodyLength != 0) {
+        // 非chunked编码，直接连接buffers
+        const bodyBuffer = Buffer.concat(bodyChunks);
+        body = bodyBuffer.toString('utf8'); // 默认 UTF-8
+
+        // 尝试修复可能的响应体问题
+        // 如果body以数字开头，可能是Content-Length的值残留
+        if (/^\d+\s*\n/.test(body)) {
+          // 移除开头的数字和换行符
+          body = body.replace(/^\d+\s*\n/, '');
+        }
+      } else {
+        body = "";
+      }
+
+      resolve({
+        statusCode,
+        statusMessage,
+        headers: headersObj,
+        body
+      });
+    });
+
+    socket.on('close', (hadError) => {
+      if (!responseParsed) {
+        reject(new Error('Socket closed before response'));
+      } else if (hadError && !responseParsed) {
+        reject(new Error('Socket closed unexpectedly'));
+      }
+    });
+  });
+}
+
+module.exports = {
+  request: requestNoValidationSync
+};

package/proxy/mitm/persistentStore.js

@@ -0,0 +1,34 @@
+// proxy/mitm/persistentStore.js
+const fs = require('fs');
+const path = require('path');
+
+// 存储文件路径（可自定义）
+const STORE_PATH = path.join(__dirname, './persistentStore.json');
+
+// 确保存储文件存在
+if (!fs.existsSync(STORE_PATH)) {
+  fs.writeFileSync(STORE_PATH, '{}');
+}
+
+function read(key) {
+  const data = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+  return data[key] || null;
+}
+
+function write(value, key) {
+  const data = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+  data[key] = value;
+  fs.writeFileSync(STORE_PATH, JSON.stringify(data, null, 2));
+}
+
+function remove(key) {
+  const data = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+  delete data[key];
+  fs.writeFileSync(STORE_PATH, JSON.stringify(data, null, 2));
+}
+
+module.exports = {
+  read,
+  write,
+  remove
+};

package/proxy/mitm/persistentStore.json

@@ -0,0 +1,3 @@
+{
+  "YouTubeAdvertiseInfo": "{\"version\":\"1.0\",\"whiteNo\":[474376530,79129962,48602820],\"blackNo\":[],\"whiteEml\":[\"cell_divider.eml-fe\",\"inline_injection_entrypoint_layout.eml-fe\",\"video_lockup_with_attachment.eml-fe\",\"images_post_root_slim.eml-fe\",\"spacing_cell.eml-fe\",\"video_metadata_carousel.eml-fe\",\"chips_shelf.eml-js-fe\",\"horizontal_shelf.eml-fe\",\"inbox_notification.eml-fe\",\"expandable_inbox_notification.eml-fe\",\"promo_notification.eml-fe\",\"compact_channel.eml-js-fe\",\"brand_video_singleton.eml-fe\",\"images_post_responsive_root.eml-fe\",\"statement_banner.eml-fe\",\"community_guidelines.eml-fe\",\"text_post_root_slim.eml-fe\"],\"blackEml\":[\"inline_injection_entrypoint_layout.eml\",\"video_display_carousel_buttoned_layout.eml-fe\",\"video_display_button_group_layout.eml-fe\",\"full_width_square_image_layout.eml-fe\",\"video_display_full_buttoned_layout.eml-fe\",\"full_width_square_image_carousel_layout.eml-fe\",\"video_display_full_layout.eml-fe\",\"full_width_portrait_image_layout.eml-fe\",\"video_display_full_buttoned_short_dr_layout.eml-fe\",\"display_tracking.eml-fe\",\"carousel_footered_layout.eml-fe\",\"video_display_carousel_button_group_layout.eml-fe\",\"landscape_image_wide_button_layout.eml-fe\"]}"
+}

package/proxy/mitm/rule.js

@@ -0,0 +1,116 @@
+// proxy/mitm/rule.js
+
+const YoutubeResponse = require('./youtube/youtube.response.js');
+const YDCD = require('./ydcd/ydcd.js');
+
+function getContentLength(body) {
+  let contentLength = 0;
+
+  // 1. 检查是否为 Uint8Array 类型
+  if (body instanceof Uint8Array) {
+    contentLength = body.length; // Uint8Array 的 length 就是字节数
+  }
+  // 2. 检查是否为 Buffer 类型 (注意：Buffer 是 Uint8Array 的子类)
+  else if (Buffer.isBuffer(body)) {
+    contentLength = body.length;
+  }
+  // 3. 检查是否为字符串类型
+  else if (typeof body === 'string') {
+    // 如果是字符串，按 UTF-8 编码转换为字节
+    const encoder = new TextEncoder();
+    const uint8Array = encoder.encode(body);
+    contentLength = uint8Array.length; // 或 uint8Array.byteLength，两者在此处等价
+  }
+  // 4. 如果都不是，可以返回 0 或根据需要处理其他类型（如 null, undefined, 对象等）
+  //    这里保持原样返回 0
+
+  return contentLength;
+}
+
+// 统一劫持 Response 的方法
+function hijackResponse(url, request, response, RuleMojo) {
+  return new Promise((resolve, reject) => {
+    var responseResult = null;
+    RuleMojo.injection({
+      callback: function(obj) {
+        // console.log('💙💙💙',response);
+        var contentLength = 0;
+        if (obj.hasOwnProperty('body')) {
+          contentLength = getContentLength(obj.body);
+        } else {
+          contentLength = getContentLength(response.body);
+        }
+        response.header['Content-Length'] = String(contentLength);
+        responseResult = {
+          response: {
+            statusCode: response.statusCode,
+            status: response.statusCode,
+            header: response.header,
+            body: obj.hasOwnProperty('body') ? obj.body : response.body
+          }
+        }
+        // console.log('>>>>>>>>>>>>>>>>>', request)
+        resolve(responseResult);
+      },
+      url: url,
+      response: response,
+      request: request
+    });
+    RuleMojo.main();
+  }); // -- promise
+}
+
+
+// 这里增加规则即可，不用修改 proxy.js
+// callback 被 MITMHandler 调用
+// callback 返回值是一个包含 response 的对象，如果不做处理则返回原 response 里的内容
+module.exports = {
+  Youtube: [
+    // Rule1
+    {
+      'type': 'beforeSendResponse',
+      'host': 'youtubei.googleapis.com',
+      'regexp': "/youtubei/v1/(browse|next|player|search|reel/reel_watch_sequence|guide|account/get_setting|get_watch)",
+      'callback': async function(url, request, response) {
+        return await hijackResponse(url, request, response, YoutubeResponse);
+      } // -- callback
+    },
+    // Rule2...
+    {
+      type: "beforeSendRequest",
+      host: "googlevideo.com",
+      regexp: "(^https?://[\\w-]+\.googlevideo\.com/.+)(ctier=L)(&.+)",
+      callback: async function(url, request, response) {
+        const matchRegExp = new RegExp(this.regexp);
+        const matchResult = url.match(matchRegExp);
+        if (matchResult !== null) {
+          const newUrl = matchResult[1] + matchResult[3];
+          // console.log(`302 ---------------- ${newUrl}`);
+          return {
+            response: {
+              statusCode: 302,
+              header: {
+                'Location': newUrl,
+                'Content-Length': '0'
+              },
+              body: Buffer.alloc(0)
+            }
+          };
+        } else {
+          return null;
+        }
+      } // -- callback
+    },
+  ],
+  // 有道词典
+  YDCD: [
+    {
+      type: "beforeSendResponse",
+      host: "dict.youdao.com",
+      regexp: "^https:\/\/dict\.youdao\.com\/vip\/user\/status",
+      callback: async function(url, request, response) {
+        return await hijackResponse(url, request, response, YDCD);
+      }
+    }
+  ]
+};

package/proxy/mitm/uaFilter.js

@@ -0,0 +1,47 @@
+
+const filtered_mitm_domains = [
+  "youtube.com",
+  "googlevideo.com",
+  "youtubei.googleapis.com"
+];
+
+// a.com:443 → a.com
+function trimHost(host) {
+  if (/:\d+$/.test(host)) {
+    host = host.split(":")[0];
+  }
+  return host;
+}
+
+module.exports = {
+  filtered_mitm_domains: filtered_mitm_domains,
+  getUA: function(headers) {
+    if (headers.hasOwnProperty("User-Agent")) {
+      return headers["User-Agent"];
+    } else if (headers.hasOwnProperty("user-agent")) {
+      return headers["user-agent"];
+    } else {
+      return "";
+    }
+  },
+  isYoutubeApp: function(ua) {
+    if (ua.startsWith("com.google.ios.youtube") || ua.startsWith("com.google.android.youtube")) {
+      return true;
+    } else {
+      return false;
+    }
+  },
+  // 判断是否需要放行
+  // 无须做mitm: return true
+  // 需要做mitm: return false
+  match: function(headers, host) {
+    host = trimHost(host);
+    // Hack，Youtube 广告拦截不兼容浏览器，浏览器访问 Youtube 的广告拦截都不做 mitm
+    if (!this.isYoutubeApp(this.getUA(headers)) &&
+      this.filtered_mitm_domains.some(domain => host.endsWith(domain) || host === domain)) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};