├── .gitignore
├── eslint.config.js
├── src
    ├── providers
    │   ├── upcloud.ts
    │   ├── megacloudrabbitstream.ts
    │   ├── fmcloud.ts
    │   └── f2cloud.ts
    ├── main.ts
    ├── sources
    │   ├── viewvault.org.ts
    │   ├── flixhq.ts
    │   ├── myflixerz.ts
    │   ├── vidsrc.pro.ts
    │   ├── vidsrc.me.ts
    │   ├── embed.su.ts
    │   ├── vidsrc.cc.ts
    │   ├── vidsrc.ts
    │   ├── vidstream.to.ts
    │   ├── aniwave.ts
    │   └── watchseries.ts
    ├── utils.ts
    └── getkeys.ts
├── eslint.config.mjs
├── tsconfig.json
├── LICENSE
├── package.json
├── .github
    └── workflows
    │   └── main.yml
├── README.md
└── dist
    └── keys.json


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | package-lock.json
3 | 


--------------------------------------------------------------------------------
/eslint.config.js:
--------------------------------------------------------------------------------
 1 | import globals from "globals";
 2 | import pluginJs from "@eslint/js";
 3 | 
 4 | 
 5 | export default [
 6 |   { languageOptions: { globals: globals.browser } },
 7 |   pluginJs.configs.recommended,
 8 | ];
 9 | 
10 | 


--------------------------------------------------------------------------------
/src/providers/upcloud.ts:
--------------------------------------------------------------------------------
 1 | import { Provider, Stream } from '../utils';
 2 | import RabbitStream from './rabbitstream.js'
 3 | 
 4 | export const UpCloud: Provider = {
 5 |   ALT_HOSTS: [],
 6 |   async stream(url: string): Promise<Stream> {
 7 |     const id = url.split("/").at(-1)!.split("?").at(0);
 8 |     return (await RabbitStream.stream(id)) as Stream;
 9 |   }
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/src/providers/megacloudrabbitstream.ts:
--------------------------------------------------------------------------------
 1 | import { Provider, Stream } from '../utils.js';
 2 | import RabbitStream from './rabbitstream.js'
 3 | 
 4 | export const MegaCloudRabbitStream: Provider = {
 5 |   ALT_HOSTS: [],
 6 |   async stream(url: string): Promise<Stream> {
 7 |     const id = url.split("/").at(-1)!.split("?").at(0);
 8 |     return await RabbitStream.stream(id, 1);
 9 |   }
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/eslint.config.mjs:
--------------------------------------------------------------------------------
 1 | 
 2 | import eslint from '@eslint/js';
 3 | import tseslint from 'typescript-eslint';
 4 | 
 5 | let myrules = [{
 6 |   rules: {
 7 |     "no-unused-vars": "off",
 8 |     "@typescript-eslint/no-unused-vars": ["error", {
 9 |       argsIgnorePattern: "^_",
10 |       varsIgnorePattern: "^_",
11 |       caughtErrorsIgnorePattern: "^_",
12 |     }],
13 |   },
14 | }];
15 | 
16 | export default tseslint.config(
17 |   eslint.configs.recommended,
18 |   ...tseslint.configs.recommended,
19 |   ...myrules
20 | );
21 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "module": "es2022",
 4 |     "esModuleInterop": true,
 5 |     "allowSyntheticDefaultImports": true,
 6 |     "target": "es6",
 7 |     "noImplicitAny": true,
 8 |     "moduleResolution": "node",
 9 |     "sourceMap": true,
10 |     "outDir": "dist",
11 |     "baseUrl": "src/types",
12 |     "allowJs": true,
13 |     "paths": {
14 |       "*": [
15 |         "node_modules/*",
16 |         "src/*"
17 |       ]
18 |     },
19 |     "lib": [
20 |       "es2021",
21 |       "dom"
22 |     ],
23 |     "noUnusedLocals": false,
24 |     "noUnusedParameters": false
25 |   },
26 |   "include": [
27 |     "src/**/*"
28 |   ]
29 | }
30 | 


--------------------------------------------------------------------------------
/src/providers/fmcloud.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { Provider, Stream } from '../utils';
 3 | 
 4 | const ALT_HOSTS: Array<string> = [];
 5 | async function stream(url: string): Promise<Stream> {
 6 |   const resp: string = (await (await fetch(url)).text());
 7 |   const reg: RegExp = new RegExp(/<script.*?>(.*?)<\/script>/gm);
 8 |   let script: string = reg.exec(resp.match(reg)!.at(-1)!)![1];
 9 |   script = eval(script.replace('eval', ''));
10 |   const sources: string = "{" + (/videop.setup\(\{(.*?)\}\);/gm).exec(script)![1] + "}";
11 |   const data: Stream = eval(`let s = ${sources}; s`);
12 |   return data;
13 | }
14 | 
15 | export const FMCloud: Provider = { stream, ALT_HOSTS };
16 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { Aniwave } from './sources/aniwave.js';
 2 | import { Vidsrc } from './sources/vidsrc.js';
 3 | import { Watchseries } from './sources/watchseries.js';
 4 | import { FlixHQ } from './sources/flixhq.js';
 5 | import { Myflixerz } from './sources/myflixerz.js';
 6 | import { VidsrcPro } from './sources/vidsrc.pro.js';
 7 | import { VidStream } from './sources/vidstream.to.js';
 8 | import { VidsrcMe } from './sources/vidsrc.me.js';
 9 | import { VidsrcCC } from './sources/vidsrc.cc.js';
10 | import { EmbedSu } from './sources/embed.su.js';
11 | 
12 | async function main() {
13 | 
14 |   // Last Edit 28/01/2025
15 |   EmbedSu.test()
16 | 
17 |   // Not Maintained since 30/09/2024
18 |   //FlixHQ.test();
19 |   //Myflixerz.test();
20 |   //VidsrcPro.test();
21 |   // sometimes fails due to cloudflare
22 |   //VidsrcMe.test();
23 |   //VidStream.test();
24 |   //VidsrcCC.test();
25 | 
26 |   // Dead since 26/08/2024
27 |   //Watchseries.test();
28 |   //Vidsrc.test();
29 |   //Aniwave.test();
30 | }
31 | 
32 | main();
33 | 
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 xgampx
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "type": "module",
 3 |   "scripts": {
 4 |     "build": "tsc",
 5 |     "start": "node dist/main.js",
 6 |     "keys": "node dist/getkeys.js",
 7 |     "lint": "eslint --ignore-pattern src/providers/rabbitstream.js src",
 8 |     "fix": "eslint --fix --ignore-pattern src/providers/rabbitstream.js src"
 9 |   },
10 |   "devDependencies": {
11 |     "@eslint/js": "^9.9.1",
12 |     "@types/eslint__js": "^8.42.3",
13 |     "@typescript-eslint/eslint-plugin": "^8.2.0",
14 |     "eslint": "^9.9.1",
15 |     "lint": "^0.8.19",
16 |     "typescript": "^5.5.4",
17 |     "typescript-eslint": "^8.2.0"
18 |   },
19 |   "dependencies": {
20 |     "@babel/generator": "^7.25.5",
21 |     "@babel/parser": "^7.25.4",
22 |     "@babel/traverse": "^7.25.4",
23 |     "@babel/types": "^7.25.4",
24 |     "@types/babel__core": "^7.20.5",
25 |     "@types/babel__traverse": "^7.20.6",
26 |     "@types/node": "^22.5.0",
27 |     "@types/node-fetch": "^2.6.11",
28 |     "@types/puppeteer": "^5.4.7",
29 |     "browser-env": "^3.3.0",
30 |     "crypto-js": "^4.2.0",
31 |     "node-fetch": "^3.3.2",
32 |     "puppeteer": "^23.1.1",
33 |     "puppeteer-extra": "^3.3.6",
34 |     "puppeteer-extra-plugin-stealth": "^2.11.2",
35 |     "webcrack": "^2.14.1"
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | name: Generate keys
 2 | on:
 3 |   workflow_dispatch:
 4 | jobs:
 5 |   installDependencies:
 6 |     name: Generate keys
 7 |     runs-on: ubuntu-latest
 8 |     steps:
 9 |       - uses: actions/checkout@v3
10 |       - name: Install Dependencies
11 |         uses: actions/setup-node@v2
12 |         env:
13 |           PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: "true"
14 |         with:
15 |           args: install
16 |       - name: npm ci and npm run keys
17 |         run: |
18 |           npm ci
19 |           npm run keys 
20 |         env:
21 |           CI: true
22 |       - name: checking status
23 |         run: git status
24 |       - name: setting identity
25 |         run: |
26 |           git config --global user.email "rovelli.gianmarai@gmail.com"
27 |           git config --global user.name "Gianmaria Rovelli"
28 |       - name: stage keys file
29 |         run: git add src/keys.json
30 |       - name: commit keys
31 |         run: git commit -am "Updating keys.json" || true
32 |       - name: switching from HTTPS to SSH
33 |         run: git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}
34 |       - name: push code to main
35 |         run: git push origin main || true
36 |         env:
37 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # VideoGatherer 
 2 | 
 3 | Scraping movies and tv series from:
 4 | - embed.su (28/01/2025)
 5 | - flixhq.to (not maintained since 30/09/2024) 
 6 | - myflixerz.to (not maintained since 30/09/2024)
 7 | - vidsrc.net (not maintained since 30/09/2024)
 8 | - vidsrc.pro (moved to embed.su)
 9 | - vidsrc.cc (not maintained since 30/09/2024)
10 | - vidstream.to (not maintained since 30/09/2024)
11 | - vidsrc.to (not maintained since 30/09/2024)
12 | - aniwave.to (dead)
13 | - watchseriesx.to (dead)
14 | 
15 | At the moment the purpose of this repository is to expose methods used 
16 | to scrape websites.
17 | 
18 | In the future it could be developed a user interface to allow regular users
19 | to easily watch movies/tv series.
20 | 
21 | ### Read read read
22 | 
23 | vidsrc.to, watchseriesx.to, aniwave.to are DOWN (26/08/2024, DD-MM-YYYY)
24 | The project keeps their scrapers as learning material, please do not open an ISSUE about this.
25 | 
26 | ### How to install it
27 | 
28 | ```sh
29 | git clone git@github.com:giammirove/videogatherer.git
30 | cd videogatherer
31 | npm i
32 | npm run build # to build
33 | npm run keys # to get the keys
34 | npm run start # to execute
35 | ```
36 | 
37 | ### How to run it
38 | 
39 | ```sh
40 | npm run build # if not done yet
41 | npm run start
42 | ```
43 | 
44 | Examples of how to request an episode/movie can be found in the `test` function
45 | of each module in `src/sources`.
46 | 
47 | ### What if it does not work
48 | 
49 | Those website are not 100% stable, it is normal if they have downtime.
50 | 
51 | What you can do is to manually open the browser and check whether the website 
52 | is working correctly.
53 | If it is working, maybe the keys (see `dist/keys.json`) are changed.
54 | To fix that you can run
55 | ```sh
56 | npm run keys
57 | ```
58 | Then retry ... :)
59 | 
60 | If it still does not work .. well we tried folks.
61 | 
62 | ### Note
63 | 
64 | This project is intended as proof of concept, 
65 | the distribution of program is intended for educational purposes ONLY.
66 | 


--------------------------------------------------------------------------------
/src/sources/viewvault.org.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { Source, Stream, ServerListItem, try_stream, isJSON, log, error, debug } from '../utils.js';
 3 | 
 4 | type EpisodeJson = {
 5 |   link: string;
 6 | }
 7 | 
 8 | type MovieJson = {
 9 |   link: string;
10 | }
11 | 
12 | const HOST = 'viewvault.org';
13 | const ALT_HOSTS = [HOST];
14 | const SERVERS: Array<ServerListItem> = [
15 | ];
16 | const ID = "FH";
17 | 
18 | async function episode(data_id: string, _server?: string): Promise<Stream> {
19 |   let url = `https://${HOST}/ajax/episode/servers/${data_id}`;
20 |   const resp: string = (await (await fetch(url)).text()).replace(/\n/g, '');
21 |   const new_data_id = (new RegExp(`data-id="(.*?)".*title=".*?${_server}"`, 'g')).exec(resp)![1];
22 |   url = `https://${HOST}/ajax/episode/sources/${new_data_id}`;
23 |   const json_data: EpisodeJson = await (await fetch(url)).json() as EpisodeJson;
24 |   return await try_stream(SERVERS, _server, json_data.link);
25 | };
26 | 
27 | async function movie(id: string, _server?: string) {
28 |   let movie_id = id.split("-").at(-1);
29 |   let url = `https://${HOST}/ajax/episode/list/${movie_id}`;
30 |   const resp = (await (await fetch(url)).text()).replace(/\n/g, '');
31 |   movie_id = (new RegExp(`data-linkid="(.*?)".*title="${_server}"`, 'gs')).exec(resp)![1];
32 |   url = `https://${HOST}/ajax/episode/sources/${movie_id}`;
33 |   const json_data = await (await fetch(url)).json() as MovieJson;
34 |   return await try_stream(SERVERS, _server, json_data.link);
35 | }
36 | 
37 | async function tv(id: string, s: number = 1, e: number = 1, _server?: string) {
38 |   const url = `https://${HOST}/episode/${id}/${s}-${e}`;
39 |   const resp = await (await fetch(url)).text();
40 |   let data_id = (/data-id="(.*?)"/gm).exec(resp)![s];
41 |   const resp2 = await (await fetch(`https://${HOST}/ajax/season/episodes/${data_id}`)).text();
42 |   data_id = (/data-id="(.*?)"/gm).exec(resp2)![e];
43 |   return await episode(data_id, _server);
44 | }
45 | 
46 | async function test() {
47 |   try {
48 |     const tests = [movie("watch-the-pastor-111166"), tv("watch-the-big-bang-theory-39508", 1, 1)];
49 |     const results = await Promise.all(tests);
50 |     for (const r of results) {
51 |       if (!isJSON(r))
52 |         throw `${JSON.stringify(r)} is not json`;
53 |       debug(ID, JSON.stringify(r));
54 |     }
55 |     log(ID, `${HOST} passed the tests`);
56 |   } catch (e: unknown) {
57 |     error(ID, `${HOST} failed the tests`, (e as Error));
58 |   }
59 | }
60 | 
61 | export const FlixHQ: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test };
62 | 
63 | 


--------------------------------------------------------------------------------
/src/providers/f2cloud.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { debug, mapp, reverse, subst_, subst, rc4, get_keys, dec_with_order, enc_with_order, get_encrypt_order, ScrapeConfig, Stream, Provider, TransformText } from '../utils.js';
 3 | 
 4 | type StreamJson = {
 5 |   result: string;
 6 | }
 7 | 
 8 | // alternative hosts
 9 | const HOST = "vid2v11.site";
10 | const ALT_HOSTS = [HOST, "vid2faf.site"];
11 | const ID = "F2";
12 | 
13 | const SCRAPE_CONFIG: ScrapeConfig = {
14 |   ID: ID,
15 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36, Playstation',
16 |   EXPECTED_KEYS: 19,
17 |   INJECT_URLS: [
18 |   ],
19 |   // input of encrypt function
20 |   ENTRY: new RegExp(`https://.*?/e/(.*?)\\?`.replace(/\//g, '/')),
21 |   // output of encrypt function
22 |   OUT: new RegExp(`https://.*?/mediainfo/(.*?)[&\\?]`.replace(/\//g, '/')),
23 |   INIT_URL: `https://${HOST}/`,
24 |   BTN_ID: "",
25 | }
26 | 
27 | function enc(inp: string): string {
28 |   const keys: Array<string> = get_keys(ALT_HOSTS);
29 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
30 |   if (order.length > 0)
31 |     return enc_with_order(keys, order, inp);
32 |   let a: string = mapp(inp, keys[0], keys[1]);
33 |   a = reverse(a);
34 |   a = rc4(keys[2], a);
35 |   a = subst(a);
36 |   a = reverse(a);
37 |   a = mapp(a, keys[3], keys[4]);
38 |   a = rc4(keys[5], a);
39 |   a = subst(a);
40 |   a = rc4(keys[6], a);
41 |   a = subst(a);
42 |   a = reverse(a);
43 |   a = mapp(a, keys[7], keys[8]);
44 |   a = subst(a);
45 |   return a;
46 | }
47 | 
48 | function dec(inp: string): string {
49 |   const keys: Array<string> = get_keys(ALT_HOSTS);
50 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
51 |   if (order.length > 0)
52 |     return dec_with_order(keys, order, inp);
53 |   let a: string = subst_(inp);
54 |   a = mapp(a, keys[8], keys[7]);
55 |   a = reverse(a);
56 |   a = subst_(a);
57 |   a = rc4(keys[6], a);
58 |   a = subst_(a);
59 |   a = rc4(keys[5], a);
60 |   a = mapp(a, keys[4], keys[3]);
61 |   a = reverse(a);
62 |   a = subst_(a);
63 |   a = rc4(keys[2], a);
64 |   a = reverse(a);
65 |   a = mapp(a, keys[1], keys[0]);
66 |   return a;
67 | }
68 | 
69 | async function stream(iurl: string): Promise<Stream> {
70 |   const url: URL = new URL(iurl);
71 |   const embed_id: string = url.pathname.split("/")[2];
72 |   debug(ID, embed_id);
73 |   const mediainfo_url: string = `https://${url.host}/mediainfo/${enc(embed_id)}${url.search}&ads=0`;
74 |   debug(ID, mediainfo_url);
75 |   const resp: StreamJson = await (await fetch(mediainfo_url)).json() as StreamJson;
76 |   debug(ID, JSON.stringify(resp));
77 |   const playlist = dec(resp.result)?.replace(/\\\//g, "/");
78 |   debug(ID, playlist);
79 |   return JSON.parse(playlist) as Stream;
80 | }
81 | 
82 | export const F2Cloud: Provider = { SCRAPE_CONFIG, ALT_HOSTS, stream };
83 | 
84 | 


--------------------------------------------------------------------------------
/src/sources/flixhq.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { Source, Stream, ServerListItem, try_stream, isJSON, log, error, debug } from '../utils.js';
 3 | import { UpCloud } from '../providers/upcloud.js';
 4 | 
 5 | type EpisodeJson = {
 6 |   link: string;
 7 | }
 8 | 
 9 | type MovieJson = {
10 |   link: string;
11 | }
12 | 
13 | const HOST = 'flixhq.to';
14 | const ALT_HOSTS = [HOST];
15 | const SERVER_UPCLOUD: string = 'UpCloud';
16 | const SERVER_VIDCLOUD: string = 'Vidcloud';
17 | const SERVER_UPSTREAM: string = 'Upstream';
18 | const SERVERS: Array<ServerListItem> = [
19 |   { id: SERVER_UPCLOUD, handler: UpCloud },
20 |   { id: SERVER_VIDCLOUD, handler: UpCloud },
21 |   { id: SERVER_UPSTREAM, handler: UpCloud },
22 | ];
23 | const ID = "FH";
24 | 
25 | async function episode(data_id: string, server = SERVER_UPCLOUD): Promise<Stream> {
26 |   let url = `https://${HOST}/ajax/episode/servers/${data_id}`;
27 |   const resp: string = (await (await fetch(url)).text()).replace(/\n/g, '');
28 |   const new_data_id = (new RegExp(`data-id="(.*?)".*title=".*?${server}"`, 'g')).exec(resp)![1];
29 |   url = `https://${HOST}/ajax/episode/sources/${new_data_id}`;
30 |   const json_data: EpisodeJson = await (await fetch(url)).json() as EpisodeJson;
31 |   return await try_stream(SERVERS, server, json_data.link);
32 | };
33 | 
34 | async function movie(id: string, server = SERVER_UPCLOUD) {
35 |   let movie_id = id.split("-").at(-1);
36 |   let url = `https://${HOST}/ajax/episode/list/${movie_id}`;
37 |   const resp = (await (await fetch(url)).text()).replace(/\n/g, '');
38 |   movie_id = (new RegExp(`data-linkid="(.*?)".*title="${server}"`, 'gs')).exec(resp)![1];
39 |   url = `https://${HOST}/ajax/episode/sources/${movie_id}`;
40 |   const json_data = await (await fetch(url)).json() as MovieJson;
41 |   return await try_stream(SERVERS, server, json_data.link);
42 | }
43 | 
44 | async function tv(id: string, s: number = 1, e: number = 1, server = SERVER_UPCLOUD) {
45 |   const tv_id = id.split("-").at(-1);
46 |   let resp = await (await fetch(`https://${HOST}/ajax/season/list/${tv_id}`)).text();
47 |   let data_id = (/data-id="(.*?)"/gm).exec(resp)![s];
48 |   resp = await (await fetch(`https://${HOST}/ajax/season/episodes/${data_id}`)).text();
49 |   data_id = (/data-id="(.*?)"/gm).exec(resp)![e];
50 |   return await episode(data_id, server);
51 | }
52 | 
53 | async function test() {
54 |   try {
55 |     const tests = [movie("watch-the-pastor-111166"), tv("watch-the-big-bang-theory-39508", 1, 1)];
56 |     const results = await Promise.all(tests);
57 |     for (const r of results) {
58 |       if (!isJSON(r))
59 |         throw `${JSON.stringify(r)} is not json`;
60 |       debug(ID, JSON.stringify(r));
61 |     }
62 |     log(ID, `${HOST} passed the tests`);
63 |   } catch (e: unknown) {
64 |     error(ID, `${HOST} failed the tests`, (e as Error));
65 |   }
66 | }
67 | 
68 | export const FlixHQ: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test };
69 | 
70 | 


--------------------------------------------------------------------------------
/src/sources/myflixerz.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { error, debug, isJSON, log, Source, try_stream } from '../utils.js';
 3 | import { MegaCloudRabbitStream } from '../providers/megacloudrabbitstream.js';
 4 | import { UpCloud } from '../providers/upcloud.js';
 5 | 
 6 | type EpisodeJson = {
 7 |   link: string;
 8 | }
 9 | 
10 | type MovieJson = {
11 |   link: string;
12 | }
13 | 
14 | const HOST = 'myflixerz.to';
15 | const ALT_HOSTS = [HOST];
16 | const SERVER_UPCLOUD = 'UpCloud';
17 | const SERVER_MEGACLOUD = 'MegaCloud';
18 | const SERVER_UPSTREAM = 'Upstream';
19 | const SERVERS = [
20 |   { id: SERVER_UPCLOUD, handler: MegaCloudRabbitStream },
21 |   { id: SERVER_MEGACLOUD, handler: MegaCloudRabbitStream },
22 |   { id: SERVER_UPSTREAM, handler: UpCloud },
23 | ]
24 | const ID = "FE";
25 | 
26 | async function episode(data_id: string, server: string = SERVER_UPCLOUD) {
27 |   let url = `https://${HOST}/ajax/episode/servers/${data_id}`;
28 |   const resp = (await (await fetch(url)).text()).replace(/\n/g, '');
29 |   const new_data_id = (new RegExp(`data-id="(.*?)".*title=".*?${server}"`, 'gms')).exec(resp)![1];
30 |   url = `https://${HOST}/ajax/episode/sources/${new_data_id}`;
31 |   const json_data = await (await fetch(url)).json() as EpisodeJson;
32 |   return await try_stream(SERVERS, server, json_data.link);
33 | }
34 | 
35 | async function movie(id: string, server: string = SERVER_UPCLOUD) {
36 |   let movie_id = id.split("-").at(-1);
37 |   let url = `https://${HOST}/ajax/episode/list/${movie_id}`;
38 |   const resp = (await (await fetch(url)).text()).replace(/\n/g, '');
39 |   movie_id = (new RegExp(`data-linkid="(.*?)".*title="${server}"`, 'gs')).exec(resp)![1];
40 |   url = `https://${HOST}/ajax/episode/sources/${movie_id}`;
41 |   const json_data = await (await fetch(url)).json() as MovieJson;
42 |   return await try_stream(SERVERS, server, json_data.link);
43 | }
44 | 
45 | async function tv(id: string, s: number = 1, e: number = 1, server: string = SERVER_UPCLOUD) {
46 |   const tv_id = id.split("-").at(-1)!.split(".").at(0);
47 |   let resp = await (await fetch(`https://${HOST}/ajax/season/list/${tv_id}`)).text();
48 |   let data_id = (/data-id="(.*?)"/gm).exec(resp)![s];
49 |   resp = await (await fetch(`https://${HOST}/ajax/season/episodes/${data_id}`)).text();
50 |   data_id = (/data-id="(.*?)"/gm).exec(resp)![e];
51 |   return await episode(data_id, server);
52 | }
53 | 
54 | async function test() {
55 |   try {
56 |     const tests = [movie("watch-the-pastor-111166"), tv("the-big-bang-theory-39508.4857451", 1, 1, SERVER_UPSTREAM)];
57 |     const results = await Promise.all(tests);
58 |     for (const r of results) {
59 |       if (!isJSON(r))
60 |         throw `${JSON.stringify(r)} is not json`;
61 |       debug(ID, JSON.stringify(r));
62 |     }
63 |     log(ID, `${HOST} passed the tests`);
64 |   } catch (e: unknown) {
65 |     error(ID, `${HOST} failed the tests`, (e as Error));
66 |   }
67 | }
68 | 
69 | export const Myflixerz: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test };
70 | 
71 | 


--------------------------------------------------------------------------------
/src/sources/vidsrc.pro.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import { mapp, reverse, rc4, subst, subst_, debug, get_keys, error, log, isJSON, get_encrypt_order, enc_with_order, dec_with_order, ScrapeConfig, Stream, Source, ServerListItem, TransformText } from '../utils.js';
  3 | 
  4 | const HOST: string = 'vidsrc.pro';
  5 | const ALT_HOSTS: Array<string> = [HOST];
  6 | const ID: string = 'VSP';
  7 | 
  8 | type EpisodeJson = {
  9 |   source: string,
 10 |   format: string,
 11 |   subtitles: [
 12 |     { label: string, file: string }
 13 |   ]
 14 | }
 15 | type SourceJson = {
 16 |   result: { url: string }
 17 | }
 18 | type VConfig = {
 19 |   title: string,
 20 |   server: string,
 21 |   hash: string,
 22 |   referer: string,
 23 |   xid: string,
 24 |   episodeId: string,
 25 |   captchaKey: string,
 26 |   v: string,
 27 |   uwuId: string,
 28 | }
 29 | type ServerVidSrc = {
 30 |   name: string,
 31 |   hash: string
 32 | }
 33 | 
 34 | const SCRAPE_CONFIG: ScrapeConfig = {
 35 |   ID: ID,
 36 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36;',
 37 |   EXPECTED_KEYS: 0,
 38 |   INJECT_URLS: [
 39 |   ],
 40 |   // input of encrypt function
 41 |   ENTRY: new RegExp(''),
 42 |   // output of encrypt function
 43 |   OUT: new RegExp(''),
 44 |   INIT_URL: `https://${HOST}/embed/movie/385687`,
 45 |   BTN_ID: "",
 46 |   MAX_TIMEOUT: 2500
 47 | }
 48 | 
 49 | const SERVERS: Array<ServerListItem> = [
 50 | ];
 51 | 
 52 | const HEADERS = {
 53 |   Referer: `https://${HOST}`
 54 | }
 55 | 
 56 | function dec(inp: string): string {
 57 |   return atob(inp.split("").reverse().join(""));
 58 | }
 59 | 
 60 | async function episode(hash: string): Promise<Stream> {
 61 |   const servers: Array<ServerVidSrc> = JSON.parse(dec(hash));
 62 |   const server: ServerVidSrc = servers[0];
 63 |   const url: string = `https://vidsrc.pro/api/e/${server.hash}`;
 64 |   debug(ID, url);
 65 |   const resp = await (await fetch(url)).json() as EpisodeJson;
 66 |   return { stream: resp.source, subtitles: resp.subtitles } as Stream;
 67 | }
 68 | 
 69 | async function movie(id: string): Promise<Stream> {
 70 |   const url = `https://${HOST}/embed/movie/${id}`;
 71 |   const resp = (await (await fetch(url, { headers: HEADERS })).text()).replace(/ /g, '').replace(/\n/g, '');
 72 |   const config: VConfig = JSON.parse((/window.vConfig=({.*?})<\/script>/g).exec(resp)![1]) as VConfig;
 73 |   debug(ID, config.hash);
 74 |   return await episode(config.hash);
 75 | }
 76 | 
 77 | async function tv(id: string, s: number = 1, e: number = 1): Promise<Stream> {
 78 |   const url = `https://${HOST}/embed/tv/${id}/${s}/${e}`;
 79 |   const resp = (await (await fetch(url, { headers: HEADERS })).text()).replace(/ /g, '').replace(/\n/g, '');
 80 |   const config: VConfig = JSON.parse((/window.vConfig=({.*?})<\/script>/g).exec(resp)![1]) as VConfig;
 81 |   debug(ID, config.hash);
 82 |   return await episode(config.hash);
 83 | }
 84 | 
 85 | async function test() {
 86 |   try {
 87 |     const tests: Array<Promise<Stream>> = [movie("385687"), tv("tt0944947", 1, 1), tv("tt1190634", 1, 1)];
 88 |     const results = await Promise.all(tests);
 89 |     for (const r of results) {
 90 |       if (!isJSON(r))
 91 |         throw `${JSON.stringify(r)} is not json`;
 92 |       debug(ID, JSON.stringify(r));
 93 |     }
 94 |     log(ID, `${HOST} passed the tests`);
 95 |   } catch (e: unknown) {
 96 |     error(ID, `${HOST} failed the tests`, (e as Error));
 97 |   }
 98 | }
 99 | 
100 | export const VidsrcPro: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test, SCRAPE_CONFIG };
101 | 


--------------------------------------------------------------------------------
/src/sources/vidsrc.me.ts:
--------------------------------------------------------------------------------
 1 | import fetch from 'node-fetch';
 2 | import { webcrack } from 'webcrack';
 3 | import vm from 'node:vm';
 4 | 
 5 | import { Source, Stream, ServerListItem, isJSON, log, error, debug, NO_STREAM_ERROR } from '../utils.js';
 6 | import { RequestInit } from 'node-fetch';
 7 | 
 8 | 
 9 | 
10 | const HOST = 'vidsrc.xyz';
11 | const ALT_HOSTS = [HOST, 'vidsrc.me', 'vidsrc.net'];
12 | const SERVERS: Array<ServerListItem> = [
13 | ];
14 | const ID = "VDM";
15 | const REFERER = `http://${HOST}`;
16 | const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36';
17 | let js_context = vm.createContext(globalThis);
18 | 
19 | const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
20 | 
21 | async function fetchReferer(url: URL | string, args: RequestInit = { headers: {} }) {
22 |   if (args.headers == undefined)
23 |     args.headers = {};
24 |   if ((args.headers as Record<string, string>)['Referer'] == undefined && (args.headers as Record<string, string>)['Referer'] != "")
25 |     (args.headers as Record<string, string>)['Referer'] = REFERER;
26 |   (args.headers as Record<string, string>)['User-Agent'] = USER_AGENT;
27 |   return fetch(url, args);
28 | }
29 | 
30 | async function episode(data_id: string, _server?: string): Promise<Stream> {
31 |   const url = `https://${HOST}/embed/${data_id}`;
32 |   debug(ID, url);
33 |   const res = await (await fetchReferer(url)).text();
34 |   let script = "";
35 |   let enc_url = "";
36 |   let script_id = "";
37 |   for (let i = 0; i < 10; i++) {
38 |     try {
39 |       const url2 = 'https:' + (/id="player_iframe" src="(.*?)"/gm).exec(res)[1].trim();
40 |       const res2 = await (await fetchReferer(url2)).text();
41 |       const host = (new URL(url2)).host;
42 |       const srcrcpLink = /src:\s*'(.*?)'/gm.exec(res2)![1];
43 |       const url3 = `https://${host}${srcrcpLink}`;
44 |       // sometimes it returns 404
45 |       const res3 = await (await fetch(url3)).text();
46 |       enc_url = (/<div id=".*?" style="display:none;">(.*?)<\/div>/gm).exec(res3)![1];
47 |       const script_url = `https://${host}` + (/<script src="(.{20,}\.js\?_=.*?)"/gm).exec(res3)![1];
48 |       const res_script = await fetchReferer(script_url);
49 |       debug(ID, `${data_id} -> ${res_script.status.toString()}`);
50 |       if (res_script.status != 200) {
51 |         await sleep(1000);
52 |         continue;
53 |       }
54 |       script = await (res_script).text();
55 |       script_id = /window\[bMGyx71TzQLfdonN\(["'](.*?)["'].*innerHTML\);$/gm.exec(script)![1];
56 |       const new_script = (await webcrack(script, { mangle: false })).code;
57 |       try {
58 |         vm.runInContext(new_script, js_context);
59 |       } catch (e) {
60 |       }
61 |       break;
62 |     } catch {
63 |     }
64 |   }
65 |   if (script == "")
66 |     throw NO_STREAM_ERROR;
67 |   const dec_url = vm.runInContext(`${script_id}('${enc_url}')`, js_context);
68 |   debug(ID, dec_url);
69 |   return { stream: dec_url } as Stream;
70 | };
71 | 
72 | async function movie(id: string, _server?: string): Promise<Stream> {
73 |   debug(ID, id);
74 |   return episode(id, _server);
75 | }
76 | 
77 | async function tv(id: string, s: number = 1, e: number = 1, _server?: string): Promise<Stream> {
78 |   debug(ID, id);
79 |   return episode(`${id}/${s}-${e}`, _server);
80 | }
81 | 
82 | async function test() {
83 |   try {
84 |     const tests = [movie("tt1300854"), tv('tt1312171', 1, 1)];
85 |     const results = await Promise.all(tests);
86 |     for (const r of results) {
87 |       if (!isJSON(r))
88 |         throw `${JSON.stringify(r)} is not json`;
89 |       debug(ID, JSON.stringify(r));
90 |     }
91 |     log(ID, `${HOST} passed the tests`);
92 |   } catch (e: unknown) {
93 |     error(ID, `${HOST} failed the tests`, (e as Error));
94 |   }
95 | }
96 | 
97 | export const VidsrcMe: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test };
98 | 
99 | 


--------------------------------------------------------------------------------
/src/sources/embed.su.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import fs from 'fs';
  3 | import vm from 'node:vm';
  4 | // YOU SHOULD NEVER USE THIS ... anyway
  5 | import browserEnv from "browser-env";
  6 | browserEnv();
  7 | let js_context = vm.createContext(globalThis)
  8 | 
  9 | 
 10 | import { mapp, reverse, rc4, subst, subst_, debug, get_keys, error, log, isJSON, get_encrypt_order, enc_with_order, dec_with_order, ScrapeConfig, Stream, Source, ServerListItem, TransformText } from '../utils.js';
 11 | 
 12 | const HOST: string = 'embed.su';
 13 | const ALT_HOSTS: Array<string> = [HOST];
 14 | const ID: string = 'EMS';
 15 | 
 16 | type EpisodeJson = {
 17 |   source: string,
 18 |   format: string,
 19 |   subtitles: [
 20 |     { label: string, file: string }
 21 |   ]
 22 | }
 23 | type VConfig = {
 24 |   title: string,
 25 |   server: string,
 26 |   hash: string,
 27 |   referer: string,
 28 |   xid: string,
 29 |   episodeId: string,
 30 |   captchaKey: string,
 31 |   v: string,
 32 |   uwuId: string,
 33 | }
 34 | type EmbedSuSrc = {
 35 |   name: string,
 36 |   hash: string
 37 | }
 38 | 
 39 | const SCRAPE_CONFIG: ScrapeConfig = {
 40 |   ID: ID,
 41 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36;',
 42 |   EXPECTED_KEYS: 0,
 43 |   INJECT_URLS: [
 44 |   ],
 45 |   // input of encrypt function
 46 |   ENTRY: new RegExp(''),
 47 |   // output of encrypt function
 48 |   OUT: new RegExp(''),
 49 |   INIT_URL: `https://${HOST}/embed/movie/385687`,
 50 |   BTN_ID: "",
 51 |   MAX_TIMEOUT: 2500
 52 | }
 53 | 
 54 | const SERVERS: Array<ServerListItem> = [
 55 | ];
 56 | 
 57 | const HEADERS = {
 58 |   Referer: `https://${HOST}`
 59 | }
 60 | 
 61 | function dec(inp: string): any {
 62 |   let b: any = atob(inp).split(".").map(a => {
 63 |     return a.split("").reverse().join("");
 64 |   });
 65 |   b = JSON.parse(atob(b.join("").split("").reverse().join("")));
 66 |   //let c = {
 67 |   //  servers: b.map(a: any => {
 68 |   //    return { ...a, default: a.name === window.vConfig.server };
 69 |   //  }), title: window.vConfig.title, id: window.vConfig.episodeId, poster: window.vConfig.poster
 70 |   //};
 71 |   return b;
 72 |   //if (location.pathname.includes("/tv/") && a.season && a.episode) {
 73 |   //  c = { ...c, currentSeason: a.season, currentEpisode: a.episode, seasons: vConfig.seasons };
 74 |   //}
 75 | 
 76 | }
 77 | 
 78 | async function episode(hash: string): Promise<Stream> {
 79 |   const servers: Array<EmbedSuSrc> = dec(hash);
 80 |   const server: EmbedSuSrc = servers[0];
 81 |   const url: string = `https://${HOST}/api/e/${server.hash}`;
 82 |   debug(ID, url);
 83 |   const resp = await (await fetch(url, { headers: HEADERS })).json() as EpisodeJson;
 84 |   return { stream: resp.source, subtitles: resp.subtitles } as Stream;
 85 | }
 86 | 
 87 | // movie and tv
 88 | async function item(url: string): Promise<Stream> {
 89 |   const resp = (await (await fetch(url, { headers: HEADERS })).text()).replaceAll('\n', '').replaceAll('\r', '');
 90 |   const script = (/<script>(.*?)<\/script>/gm).exec(resp)![1];
 91 |   try {
 92 |     vm.runInContext(script, js_context);
 93 |   } catch (e) {
 94 |   }
 95 |   const config: VConfig = js_context['window']['vConfig'];
 96 |   debug(ID, config.hash);
 97 |   return await episode(config.hash);
 98 | }
 99 | 
100 | async function movie(id: string): Promise<Stream> {
101 |   const url = `https://${HOST}/embed/movie/${id}`;
102 |   return item(url);
103 | }
104 | 
105 | async function tv(id: string, s: number = 1, e: number = 1): Promise<Stream> {
106 |   const url = `https://${HOST}/embed/tv/${id}/${s}/${e}`;
107 |   return item(url);
108 | }
109 | 
110 | async function test() {
111 |   try {
112 |     const tests: Array<Promise<Stream>> = [movie("385687"), tv("tt0944947", 1, 1), tv("tt1190634", 1, 1)];
113 |     const results = await Promise.all(tests);
114 |     for (const r of results) {
115 |       if (!isJSON(r))
116 |         throw `${JSON.stringify(r)} is not json`;
117 |       debug(ID, JSON.stringify(r));
118 |     }
119 |     log(ID, `${HOST} passed the tests`);
120 |   } catch (e: unknown) {
121 |     error(ID, `${HOST} failed the tests`, (e as Error));
122 |   }
123 | }
124 | 
125 | export const EmbedSu: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test, SCRAPE_CONFIG };
126 | 


--------------------------------------------------------------------------------
/dist/keys.json:
--------------------------------------------------------------------------------
1 | {"keys":{"vidsrc2.to":["ZlPQBwa7ehv","hL2iJXRTZMS8Wq","M82hWTSXqZRJiL","btBf67Tj8Dsw","G3PLTmaZFq0Kc","GFqPKmZL0acT3","kWxCGXMrEc7f9K","E7Wf9cGrXKxMCk","qQgt1k9Ho5wlJZ"],"vid2v11.site":["E1KyOcIMf9v7XHg","gMvO97yE1cfKIXH","dawQCziL2v","ZSsbx4NtMpOoCh","ZCo4MthpsNxSOb","thDz4uPKGSYW","QIP5jcuvYEKdG","fH0n3GZDeKCE6","0GCn6e3ZfDKEH"],"watchseriesx.to":["5j6Ak1GJaTy8XoC","56kC8jyGoXTAa1J","hAGMmLFnoa0","PUoVzgdK5FLZt","FVogUPtKzdZL5","oUHxby23izOI5","PEQmieNvWhrOX","OEehvmXQrWiPN","tX6D4K8mPrq3V"],"vid2faf.site":["E1KyOcIMf9v7XHg","gMvO97yE1cfKIXH","dawQCziL2v","ZSsbx4NtMpOoCh","ZCo4MthpsNxSOb","thDz4uPKGSYW","QIP5jcuvYEKdG","fH0n3GZDeKCE6","0GCn6e3ZfDKEH"],"aniwave.to":["AP6GeR8H0lwUz1","UAz8Gwl10P6ReH","ItFKjuWokn4ZpB","fOyt97QWFB3","1majSlPQd2M5","da1l2jSmP5QM","CPYvHj09Au3","0jHA9CPYu3v","736y1uTJpBLUX"]},"traces":{"vidsrc2.to":[{"0":"ZlPQBwa7ehv","1":"vSLkbFoL","host":"vidsrc2.to","type":"rc4"},{"0":"iqUNEKQTWR0=","1":"hL2iJXRTZMS8Wq","2":"M82hWTSXqZRJiL","host":"vidsrc2.to","type":"map"},{"0":"btBf67Tj8Dsw","1":"hLUNEKQXiS0=","host":"vidsrc2.to","type":"rc4"},{"0":"oD59vKALZCGOZAvI","1":"G3PLTmaZFq0Kc","2":"GFqPKmZL0acT3","host":"vidsrc2.to","type":"map"},{"0":"oD59vTAPLCGOLAvI","1":"kWxCGXMrEc7f9K","2":"E7Wf9cGrXKxMCk","host":"vidsrc2.to","type":"map"},{"0":"qQgt1k9Ho5wlJZ","1":"IvALO9fLPATvC5Do","host":"vidsrc2.to","type":"rc4"}],"vid2v11.site":[{"0":"51J0O435ZYQ8","1":"E1KyOcIMf9v7XHg","2":"gMvO97yE1cfKIXH","host":"vid2v11.site","type":"map"},{"0":"dawQCziL2v","1":"8QYZ53490JM5","host":"vid2v11.site","type":"rc4"},{"0":"76pnLUxBWHuOVY04","1":"ZSsbx4NtMpOoCh","2":"ZCo4MthpsNxSOb","host":"vid2v11.site","type":"map"},{"0":"thDz4uPKGSYW","1":"76NnLUMBWHuxVY0t","host":"vid2v11.site","type":"rc4"},{"0":"QIP5jcuvYEKdG","1":"MGMpg05Ed9GI5lT1g-Z5Xg==","host":"vid2v11.site","type":"rc4"},{"0":"eQ-Fl8y0GrRirFf-9VDXBNhGpJ1aDGdN","1":"fH0n3GZDeKCE6","2":"0GCn6e3ZfDKEH","host":"vid2v11.site","type":"map"}],"watchseriesx.to":[{"0":"37700","1":"5j6Ak1GJaTy8XoC","2":"56kC8jyGoXTAa1J","host":"watchseriesx.to","type":"map"},{"0":"hAGMmLFnoa0","1":"00773","host":"watchseriesx.to","type":"rc4"},{"0":"-cfCYLc=","1":"PUoVzgdK5FLZt","2":"FVogUPtKzdZL5","host":"watchseriesx.to","type":"map"},{"0":"oUHxby23izOI5","1":"=cZYCfc-","host":"watchseriesx.to","type":"rc4"},{"0":"SjmO5OCfUYU=","1":"PEQmieNvWhrOX","2":"OEehvmXQrWiPN","host":"watchseriesx.to","type":"map"},{"0":"tX6D4K8mPrq3V","1":"=UYUfCP5PhjS","host":"watchseriesx.to","type":"rc4"}],"vid2faf.site":[{"0":"E6JRV9WO9Y3X","1":"E1KyOcIMf9v7XHg","2":"gMvO97yE1cfKIXH","host":"vid2faf.site","type":"map"},{"0":"dawQCziL2v","1":"I3Yc9WcVRJ6g","host":"vid2faf.site","type":"rc4"},{"0":"pXunppHUy2-AVQik","1":"ZSsbx4NtMpOoCh","2":"ZCo4MthpsNxSOb","host":"vid2faf.site","type":"map"},{"0":"thDz4uPKGSYW","1":"NXunNNHUy2-AVQik","host":"vid2faf.site","type":"rc4"},{"0":"QIP5jcuvYEKdG","1":"SQ0Sg0xfcsamnAzMg-4gQQ==","host":"vid2faf.site","type":"rc4"},{"0":"eQeIs0XvGrR9FxtoZNhFGBzVpJFS-f8K","1":"fH0n3GZDeKCE6","2":"0GCn6e3ZfDKEH","host":"vid2faf.site","type":"map"}],"aniwave.to":[{"0":"177","1":"AP6GeR8H0lwUz1","2":"UAz8Gwl10P6ReH","host":"aniwave.to","type":"map"},{"0":"ItFKjuWokn4ZpB","1":"H77","host":"aniwave.to","type":"rc4"},{"0":"fOyt97QWFB3","1":"QTP8","host":"aniwave.to","type":"rc4"},{"0":"8pNEJg==","1":"1majSlPQd2M5","2":"da1l2jSmP5QM","host":"aniwave.to","type":"map"},{"0":"8pNEJg==","1":"CPYvHj09Au3","2":"0jHA9CPYu3v","host":"aniwave.to","type":"map"},{"0":"736y1uTJpBLUX","1":"==gJENp8","host":"aniwave.to","type":"rc4"}]},"entries_outs":{"vidsrc2.to":{"entry":"LoFbkLSv","out":"LUhIc2JhUE5wOF9lQjhLVDFIaDBxdz09"},"vid2v11.site":{"entry":"51J0O435ZYQ8","out":"ZlEtRmw4eUNlclJpckYwLTlWWlhCTmhlcEoxYVplZE4="},"watchseriesx.to":{"entry":"37700","out":"ZE5acjYwVGN2LVBDandScg=="},"vid2faf.site":{"entry":"E6JRV9WO9Y3X","out":"ZlFmSXNDWHZlclI5Rnh0bzNOaEZlQnpWcEpGUy0wOEQ="},"aniwave.to":{"entry":"177","out":"cEpfVjFpcm9oLWc9"}},"encrypt_order":{"vidsrc2.to":["reverse","rc4","subst","mapp","rc4","subst","reverse","mapp","mapp","reverse","rc4","subst","subst"],"vid2v11.site":["mapp","reverse","rc4","subst","reverse","mapp","rc4","subst","rc4","subst","reverse","mapp","subst"],"watchseriesx.to":["mapp","reverse","rc4","subst","mapp","reverse","rc4","subst","mapp","reverse","rc4","subst","subst"],"vid2faf.site":["mapp","reverse","rc4","subst","reverse","mapp","rc4","subst","rc4","subst","reverse","mapp","subst"],"aniwave.to":["mapp","rc4","subst","rc4","subst","mapp","mapp","reverse","rc4","subst","subst"]}}


--------------------------------------------------------------------------------
/src/sources/vidsrc.cc.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | 
  3 | import { Source, Stream, ServerListItem, isJSON, log, error, debug, rc4, NO_STREAM_ERROR, Subtitle } from '../utils.js';
  4 | import { UpCloud } from '../providers/upcloud.js';
  5 | 
  6 | type ServerJson = {
  7 |   name: string,
  8 |   hash: string
  9 | }
 10 | type ServersJson = {
 11 |   data: Array<ServerJson>,
 12 |   success: boolean
 13 | }
 14 | type SourceJson = {
 15 |   data: {
 16 |     source: string,
 17 |     subtitles: Array<Subtitle>,
 18 |     format: string
 19 |   },
 20 |   success: boolean
 21 | }
 22 | type ItemType = 'tv' | 'movie';
 23 | 
 24 | const HOST = 'vidsrc.cc';
 25 | const ALT_HOSTS = [HOST];
 26 | const SERVER_UPCLOUD: string = 'UpCloud';
 27 | const SERVER_VIDCLOUD: string = 'VidCloud';
 28 | const SERVERS: Array<ServerListItem> = [
 29 |   { id: SERVER_UPCLOUD, handler: UpCloud },
 30 | ];
 31 | const ID = "VSC";
 32 | const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36';
 33 | 
 34 | function enc(input: string): string {
 35 |   let key = "78B22E5E862BC";
 36 |   return encodeURIComponent(btoa(btoa(rc4(key, input))));
 37 | }
 38 | 
 39 | async function episode(id: string, type: ItemType = 'tv', s: number = 1, e: number = 1, _server = SERVER_VIDCLOUD): Promise<Stream> {
 40 |   const postfix: string = type == 'tv' ? `tv/${id}/${s}/${e}` : `movie/${id}`;
 41 |   const url: string = `https://${HOST}/v2/embed/${postfix}`;
 42 |   debug(ID, url);
 43 |   const res = await (await fetch(url, {
 44 |     headers: {
 45 |       'Host': HOST,
 46 |       'User-Agent': USER_AGENT,
 47 |       'Sec-Fetch-Site': 'same-origin',
 48 |       'Sec-Fetch-Mode': 'navigate',
 49 |       'Sec-Fetch-Dest': 'iframe',
 50 |       'Referer': HOST,
 51 |     }
 52 |   })).text();
 53 |   const new_data_id = (new RegExp(`data-id="(.*?)" data-number=`, 'g')).exec(res)![1];
 54 |   debug(ID, new_data_id);
 55 |   const v_value = (new RegExp(`var v = "(.*?)"`, 'g')).exec(res)![1];
 56 |   debug(ID, `v value: ${v_value}`);
 57 |   const vrf = encodeURIComponent(enc(id));
 58 |   debug(ID, `vrf: ${vrf}`);
 59 |   const api_url = `https://${HOST}/api/episodes/${new_data_id}/servers?id=${id}&season=${s}&episode=${e}&type=${type}&isMobile=false&v=${encodeURIComponent(v_value)}&vrf=${vrf}`;
 60 |   debug(ID, api_url);
 61 |   const res2: ServersJson = await (await fetch(api_url, {
 62 |     headers: {
 63 |       'Host': HOST,
 64 |       'User-Agent': USER_AGENT,
 65 |       'Referer': HOST,
 66 |     }
 67 |   }
 68 |   )).json() as ServersJson;
 69 |   const server_hash: ServerJson | undefined = res2.data.find(v => v.name == _server);
 70 |   debug(ID, `server hash: ${server_hash.hash}`);
 71 |   if (server_hash == undefined)
 72 |     throw NO_STREAM_ERROR;
 73 |   // not used at the moment ... it could be useful in the future
 74 |   const key = encodeURIComponent(btoa(id + "-" + new_data_id));
 75 |   debug(ID, `key: ${key}`);
 76 |   const embed_url = `https://${HOST}/api/source/${server_hash.hash}`;
 77 |   debug(ID, `embed url: ${embed_url}`);
 78 |   const res3: SourceJson = await (await
 79 |     fetch(embed_url, {
 80 |       headers: {
 81 |         'Host': HOST,
 82 |         'User-Agent': USER_AGENT,
 83 |         'Sec-Fetch-Site': 'same-origin',
 84 |         'Sec-Fetch-Mode': 'cors',
 85 |         'Sec-Fetch-Dest': 'empty',
 86 |       }
 87 |     })
 88 |   ).json() as SourceJson;
 89 |   if (res3.success == false)
 90 |     throw NO_STREAM_ERROR;
 91 |   debug(ID, res3.data.source)
 92 |   return { stream: res3.data.source, subtitles: res3.data.subtitles } as Stream;
 93 | };
 94 | 
 95 | async function movie(id: string, _server?: string): Promise<Stream> {
 96 |   debug(ID, id);
 97 |   return episode(id, 'movie', 1, 1, _server);
 98 | }
 99 | 
100 | async function tv(id: string, s: number = 1, e: number = 1, _server?: string): Promise<Stream> {
101 |   debug(ID, id);
102 |   return episode(id, 'tv', s, e, _server);
103 | }
104 | 
105 | async function test() {
106 |   try {
107 |     //const tests = [movie("385687"), tv('tt0944947', 2, 3)];
108 |     const tests = [tv('tt0944947', 2, 3)];
109 |     const results = await Promise.all(tests);
110 |     for (const r of results) {
111 |       if (!isJSON(r))
112 |         throw `${JSON.stringify(r)} is not json`;
113 |       debug(ID, JSON.stringify(r));
114 |     }
115 |     log(ID, `${HOST} passed the tests`);
116 |   } catch (e: unknown) {
117 |     error(ID, `${HOST} failed the tests`, (e as Error));
118 |   }
119 | }
120 | 
121 | export const VidsrcCC: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test };
122 | 
123 | 


--------------------------------------------------------------------------------
/src/sources/vidsrc.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import { mapp, reverse, rc4, subst, subst_, debug, get_keys, error, log, isJSON, get_encrypt_order, enc_with_order, dec_with_order, ScrapeConfig, Stream, Source, ServerListItem, TransformText } from '../utils.js';
  3 | import { F2Cloud } from '../providers/f2cloud.js';
  4 | 
  5 | const HOST: string = 'vidsrc2.to';
  6 | const ALT_HOSTS: Array<string> = [HOST];
  7 | const ID: string = 'VS';
  8 | 
  9 | type EpisodeJson = {
 10 |   result: [
 11 |     { id: string }
 12 |   ]
 13 | }
 14 | type SourceJson = {
 15 |   result: { url: string }
 16 | }
 17 | 
 18 | const SCRAPE_CONFIG: ScrapeConfig = {
 19 |   ID: ID,
 20 |   // PlayStation bypasses dev tools detection
 21 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36; PlayStation',
 22 |   EXPECTED_KEYS: 19,
 23 |   INJECT_URLS: [
 24 |     "all.js",
 25 |     "embed.js",
 26 |     "web.js"
 27 |   ],
 28 |   // input of encrypt function
 29 |   ENTRY: new RegExp(`https://.*?/ajax/embed/episode/(.*?)/sources\\?.*`.replace(/\//g, '/')),
 30 |   // output of encrypt function
 31 |   OUT: new RegExp(`https://.*?/ajax/embed/episode/.*?/sources\\?.*token=(.*?)$`.replace(/\//g, '/')),
 32 |   INIT_URL: `https://${HOST}/embed/movie/385687`,
 33 |   BTN_ID: "#btn-play",
 34 |   MAX_TIMEOUT: 2500
 35 | }
 36 | 
 37 | const SERVERS: Array<ServerListItem> = [
 38 | ];
 39 | 
 40 | function enc(inp: string): string {
 41 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 42 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 43 |   if (order.length > 0)
 44 |     return enc_with_order(keys, order, inp);
 45 | 
 46 |   let a: string = mapp(subst(rc4(keys[0], reverse(inp))), keys[1], keys[2]);
 47 |   a = mapp(reverse(subst(rc4(keys[3], a))), keys[4], keys[5]);
 48 |   a = rc4(keys[8], reverse(mapp(a, keys[6], keys[7])));
 49 |   return subst(subst(a));
 50 | }
 51 | 
 52 | function dec(inp: string): string {
 53 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 54 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 55 |   if (order.length > 0)
 56 |     return dec_with_order(keys, order, inp);
 57 | 
 58 |   let a: string = subst_(inp);
 59 |   a = mapp(reverse(rc4(keys[8], subst_(a))), keys[7], keys[6]);
 60 |   a = rc4(keys[3], subst_(reverse(mapp(a, keys[5], keys[4]))));
 61 |   a = reverse(rc4(keys[0], subst_(mapp(a, keys[2], keys[1]))));
 62 |   return a;
 63 | }
 64 | 
 65 | async function episode(data_id: string): Promise<Stream> {
 66 |   const t: string = new Date().getTime().toString(16);
 67 |   const time_params: string = `t=${encodeURIComponent(t)}&h=${encodeURIComponent(enc(t))}`
 68 |   debug(ID, time_params);
 69 |   let url: string = `https://${HOST}/ajax/embed/episode/${data_id}/sources?token=${encodeURIComponent(enc(data_id))}&${time_params}`;
 70 |   debug(ID, url);
 71 |   const resp = await (await fetch(url)).json() as EpisodeJson;
 72 |   // 0 is F2Cloud
 73 |   const f2cloud_id = resp.result[0].id;
 74 |   debug(ID, f2cloud_id);
 75 |   url = `https://${HOST}/ajax/embed/source/${f2cloud_id}?token=${encodeURIComponent(enc(f2cloud_id))}&${time_params}`;
 76 |   debug(ID, url);
 77 |   const resp2 = await (await fetch(url)).json() as SourceJson;
 78 |   const f2cloud_url = resp2.result.url;
 79 |   debug(ID, f2cloud_url);
 80 |   const f2cloud_url_dec: string = dec(f2cloud_url);
 81 |   return await F2Cloud.stream(f2cloud_url_dec);
 82 | }
 83 | 
 84 | async function movie(id: string): Promise<Stream> {
 85 |   const resp: string = await (await fetch(`https://${HOST}/embed/movie/${id}`)).text();
 86 |   const data_id: string = (/data-id="(.*?)"/g).exec(resp)![1];
 87 |   debug(ID, data_id);
 88 |   debug(ID, enc(id));
 89 |   return await episode(data_id);
 90 | }
 91 | 
 92 | async function tv(id: string, s: number = 1, e: number = 1): Promise<Stream> {
 93 |   const resp = await (await fetch(`https://${HOST}/embed/tv/${id}/${s}/${e}`)).text();
 94 |   const data_id = (/data-id="(.*?)"/g).exec(resp)![1];
 95 |   return await episode(data_id);
 96 | }
 97 | 
 98 | async function test() {
 99 |   try {
100 |     const tests: Array<Promise<Stream>> = [movie("385687"), tv("tt0944947", 1, 1), tv("tt1190634", 1, 1)];
101 |     const results = await Promise.all(tests);
102 |     for (const r of results) {
103 |       if (!isJSON(r))
104 |         throw `${JSON.stringify(r)} is not json`;
105 |     }
106 |     log(ID, `${HOST} passed the tests`);
107 |   } catch (e: unknown) {
108 |     error(ID, `${HOST} failed the tests`, (e as Error));
109 |   }
110 | }
111 | 
112 | export const Vidsrc: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test, SCRAPE_CONFIG };
113 | 


--------------------------------------------------------------------------------
/src/sources/vidstream.to.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import { debug, mapp, reverse, subst_, subst, rc4, try_stream, get_keys, error, isJSON, log, enc_with_order, dec_with_order, get_encrypt_order, ServerListItem, ScrapeConfig, Stream, SearchResult, SearchResultType, Source, TransformText } from '../utils.js';
  3 | import { UpCloud } from '../providers/upcloud.js';
  4 | 
  5 | type EpisodeListJson = {
  6 |   result: string
  7 | }
  8 | type EpisodeJson = {
  9 |   data: {
 10 |     link: string
 11 |   };
 12 | }
 13 | 
 14 | const HOST: string = 'vidstream.to';
 15 | const ALT_HOSTS: Array<string> = [HOST];
 16 | const SERVER_UPCLOUD: string = 'UpCloud';
 17 | const SERVERS: Array<ServerListItem> = [
 18 |   { id: SERVER_UPCLOUD, handler: UpCloud },
 19 | ];
 20 | const ID: string = 'VDT';
 21 | 
 22 | // watchseries sometimes crashes ... just retry
 23 | const SCRAPE_CONFIG: ScrapeConfig = {
 24 |   ID: ID,
 25 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36, Playstation',
 26 |   EXPECTED_KEYS: 0,
 27 |   INJECT_URLS: [
 28 |   ],
 29 |   // input of encrypt function
 30 |   ENTRY: new RegExp(''),
 31 |   // output of encrypt function
 32 |   OUT: new RegExp(''),
 33 |   INIT_URL: ``,
 34 |   BTN_ID: "",
 35 |   MAX_TIMEOUT: 3500
 36 | }
 37 | 
 38 | async function episode(data_id: string, server: string = SERVER_UPCLOUD): Promise<Stream> {
 39 |   const url: string = `https://${HOST}/ajax/movie/episode/servers/${data_id}`;
 40 |   const resp = await (await fetch(url)).text();
 41 |   const new_data_id = (new RegExp(`data-id="(.*?)".*${server}.*?<\/a>`)).exec(resp)![1];
 42 |   debug(ID, new_data_id);
 43 |   const url2 = `https://${HOST}/ajax/movie/episode/server/sources/${new_data_id}`;
 44 |   const resp2 = await (await fetch(url2)).json() as EpisodeJson;
 45 |   debug(ID, resp2.data.link);
 46 |   return await try_stream(SERVERS, server, resp2.data.link);
 47 | }
 48 | 
 49 | async function movie(id: string, server: string = SERVER_UPCLOUD): Promise<Stream> {
 50 |   const url = `https://${HOST}/watch-movie/${id}`;
 51 |   const redirect = await fetch(url, { redirect: 'manual' });
 52 |   debug(ID, redirect.headers.get("location"));
 53 |   const new_url = redirect.headers.get("location");
 54 |   const new_id = new_url.split("/").at(-1);
 55 |   return await episode(new_id, server);
 56 | }
 57 | 
 58 | async function tv(id: string, s: number = 1, e: number = 1, server: string = SERVER_UPCLOUD): Promise<Stream> {
 59 |   debug(ID, id);
 60 |   const real_id = id.split("-").at(-1);
 61 |   const seasons_url = `https://${HOST}/ajax/movie/seasons/${real_id}`;
 62 |   const resp_seasons = await (await fetch(seasons_url)).text();
 63 |   const season_id = (/data-id="(.*?)"/g).exec(resp_seasons)![s];
 64 |   debug(ID, season_id);
 65 | 
 66 |   const episodes_url = `https://${HOST}/ajax/movie/season/episodes/${season_id}`;
 67 |   const resp_episodes = await (await fetch(episodes_url)).text();
 68 |   const episode_id = (/data-id="(.*?)"/g).exec(resp_episodes)![e];
 69 |   debug(ID, episode_id);
 70 |   return await episode(episode_id, server);
 71 | }
 72 | 
 73 | async function search(query: string): Promise<Array<SearchResult>> {
 74 |   const url: string = `https://${HOST}/search?keyword=${encodeURIComponent(query)}`;
 75 |   const resp: string = await (await fetch(url)).text();
 76 |   const results = resp.match(new RegExp(`<a href=".*?" title=".*?">`, 'gm'))!;
 77 |   const ret: Array<SearchResult> = [];
 78 |   for (const r of results) {
 79 |     const [, type_raw, id, title] = (new RegExp(`href="/(.*?)/(.*?)" title="(.*?)"`)).exec(r)!;
 80 |     let type: SearchResultType = 'tv';
 81 |     if (type_raw !== 'watch-series')
 82 |       type = 'movie';
 83 |     const item: SearchResult = { type, title, id };
 84 |     ret.push(item);
 85 |   }
 86 |   return ret;
 87 | }
 88 | 
 89 | async function test() {
 90 |   try {
 91 |     const tests: Array<Promise<Stream>> = [tv("watch-the-big-bang-theory-39508", 1, 1), movie("watch-the-lord-of-the-rings-16510")];
 92 |     const results = await Promise.all(tests);
 93 |     for (const r of results) {
 94 |       if (!isJSON(r))
 95 |         throw `${JSON.stringify(r)} is not json`;
 96 |     }
 97 |     const results2: Array<SearchResult> = await search("the big bang theory tv series");
 98 |     if (results2[0].type == 'tv') {
 99 |       const r = (await tv(results2[0].id, 1, 1));
100 |       if (!isJSON(r))
101 |         throw `${JSON.stringify(r)} is not json`;
102 |     }
103 |     else {
104 |       const r = (await movie(results2[0].id));
105 |       if (!isJSON(r))
106 |         throw `${JSON.stringify(r)} is not json`;
107 |     }
108 |     log(ID, `${HOST} passed the tests`);
109 |   } catch (e: unknown) {
110 |     error(ID, `${HOST} failed the tests`, (e as Error));
111 |   }
112 | }
113 | 
114 | export const VidStream: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, search, SCRAPE_CONFIG, test };
115 | 
116 | 


--------------------------------------------------------------------------------
/src/sources/aniwave.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import { mapp, reverse, subst_, subst, rc4, debug, try_stream, get_keys, error, log, isJSON, get_encrypt_order, enc_with_order, dec_with_order, ServerListItem, ScrapeConfig, Stream, SearchResult, SearchResultType, Source, TransformText } from '../utils.js';
  3 | import { F2Cloud } from '../providers/f2cloud.js';
  4 | import { FMCloud } from '../providers/fmcloud.js';
  5 | 
  6 | type EpisodeListJson = {
  7 |   result: string
  8 | }
  9 | type EpisodeJson = {
 10 |   result: {
 11 |     url: string
 12 |   };
 13 | }
 14 | 
 15 | const HOST: string = 'aniwave.to';
 16 | const ALT_HOSTS: Array<string> = [HOST];
 17 | const SERVER_F2CLOUD: string = '41';
 18 | const SERVER_MEGACLOUD: string = '28';
 19 | const SERVER_FMCLOUD: string = '45';
 20 | const SERVERS: Array<ServerListItem> = [
 21 |   { id: SERVER_F2CLOUD, handler: F2Cloud },
 22 |   { id: SERVER_MEGACLOUD, handler: F2Cloud },
 23 |   { id: SERVER_FMCLOUD, handler: FMCloud },
 24 | ]
 25 | const ID: string = 'AW';
 26 | 
 27 | const SCRAPE_CONFIG: ScrapeConfig = {
 28 |   ID: ID,
 29 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36; PlayStation',
 30 |   EXPECTED_KEYS: 18,
 31 |   INJECT_URLS: [
 32 |     "all.js",
 33 |     "embed.js",
 34 |     "scripts.js"
 35 |   ],
 36 |   // input of encrypt function
 37 |   ENTRY: new RegExp(`https://.*?/ajax/episode/list/(.*?)\\?`.replace(/\//g, '/')),
 38 |   // output of encrypt function
 39 |   OUT: new RegExp(`https://.*?/ajax/episode/list/.*?\\?vrf=(.*?)$`.replace(/\//g, '/')),
 40 |   INIT_URL: "https://aniwave.to/watch/one-piece.x3ln/ep-1",
 41 |   BTN_ID: "#player-wrapper",
 42 |   MAX_TIMEOUT: 2500
 43 | }
 44 | 
 45 | function enc(inp: string): string {
 46 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 47 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 48 |   if (order.length > 0)
 49 |     return enc_with_order(keys, order, inp);
 50 |   let a = reverse(subst(rc4(keys[2], mapp(inp, keys[0], keys[1]))));
 51 |   a = mapp(subst(rc4(keys[3], reverse(a))), keys[4], keys[5]);
 52 |   a = subst(rc4(keys[8], reverse(mapp(a, keys[6], keys[7]))));
 53 |   return subst(a);
 54 | }
 55 | 
 56 | function dec(inp: string): string {
 57 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 58 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 59 |   if (order.length > 0)
 60 |     return dec_with_order(keys, order, inp);
 61 |   let a = subst_(inp);
 62 |   a = mapp(reverse(rc4(keys[8], subst_(a))), keys[7], keys[6]);
 63 |   a = reverse(rc4(keys[3], subst_(mapp(a, keys[5], keys[4]))));
 64 |   return mapp(rc4(keys[2], subst_(reverse(a))), keys[1], keys[0]);
 65 | }
 66 | 
 67 | async function episode(data_id: string, server: string = SERVER_F2CLOUD): Promise<Stream> {
 68 |   let url = `https://${HOST}/ajax/server/list/${data_id}?vrf=${encodeURIComponent(enc(data_id))}`;
 69 |   const resp = await (await fetch(url)).json() as EpisodeListJson;
 70 |   const new_data_id = (new RegExp(`data-sv-id="${server}" data-link-id="(.*?)"`)).exec(resp.result)![1];
 71 |   url = `https://${HOST}/ajax/server/${new_data_id}?vrf=${encodeURIComponent(enc(new_data_id))}`;
 72 |   const resp2 = await (await fetch(url)).json() as EpisodeJson;
 73 |   const url_dec = dec(resp2.result.url);
 74 |   return await try_stream(SERVERS, server, url_dec);
 75 | }
 76 | 
 77 | async function movie(id: string, server: string = SERVER_F2CLOUD): Promise<Stream> {
 78 |   return await tv(id, 1, 1, server);
 79 | }
 80 | 
 81 | async function tv(id: string, _: number = 1, e: number = 1, server: string = SERVER_F2CLOUD) {
 82 |   const resp: string = await (await fetch(`https://${HOST}/watch/${id}/ep-${e}`)).text();
 83 |   let data_id = (/data-id="(.*?)"/g).exec(resp)![1];
 84 |   debug(ID, data_id);
 85 |   const url = `https://${HOST}/ajax/episode/list/${data_id}?vrf=${encodeURIComponent(enc(data_id))}`
 86 |   debug(ID, url);
 87 |   const resp2 = await (await fetch(url)).json() as EpisodeListJson;
 88 |   data_id = (new RegExp(`data-num="${e}".*?data-ids="(.*?)"`, 'g')).exec(resp2.result)![1];
 89 |   debug(ID, data_id);
 90 |   return await episode(data_id, server);
 91 | }
 92 | 
 93 | async function search(query: string): Promise<Array<SearchResult>> {
 94 |   const url = `https://${HOST}/filter?keyword=${query}`;
 95 |   const resp = await (await fetch(url)).text();
 96 |   const results = resp.match(new RegExp(`<a class="name d-title" href=".*?">.*?</a>`, 'g'))!;
 97 |   const ret: Array<SearchResult> = [];
 98 |   for (const r of results) {
 99 |     const [, type_raw, id, title] = (new RegExp(`href="/(.*?)/(.*?)" .*>(.*?)</a>`)).exec(r)!;
100 |     let type: SearchResultType = 'tv';
101 |     if (type_raw !== 'tv')
102 |       type = 'movie';
103 |     const item: SearchResult = { type, title, id };
104 |     ret.push(item);
105 |   }
106 |   return ret;
107 | }
108 | 
109 | async function test() {
110 |   try {
111 |     const tests = [tv("one-piece.x3ln", 1, 1)];
112 |     const results = await Promise.all(tests);
113 |     for (const r of results) {
114 |       if (!isJSON(r))
115 |         throw `${JSON.stringify(r)} is not json`;
116 |     }
117 |     const results2 = await search("one piece");
118 |     if (results2[0].type == 'tv') {
119 |       const r = (await tv(results2[0].id, 1, 2));
120 |       if (!isJSON(r))
121 |         throw `${JSON.stringify(r)} is not json`;
122 |     }
123 |     else {
124 |       const r = (await movie(results2[0].id));
125 |       if (!isJSON(r))
126 |         throw `${JSON.stringify(r)} is not json`;
127 |     }
128 |     log(ID, `${HOST} passed the tests`);
129 |   } catch (e: unknown) {
130 |     error(ID, `${HOST} failed the tests`, (e as Error));
131 |   }
132 | }
133 | 
134 | export const Aniwave: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, test, search, SCRAPE_CONFIG };
135 | 
136 | 


--------------------------------------------------------------------------------
/src/sources/watchseries.ts:
--------------------------------------------------------------------------------
  1 | import fetch from 'node-fetch';
  2 | import { debug, mapp, reverse, subst_, subst, rc4, try_stream, get_keys, error, isJSON, log, enc_with_order, dec_with_order, get_encrypt_order, ServerListItem, ScrapeConfig, Stream, SearchResult, SearchResultType, Source, TransformText } from '../utils.js';
  3 | import { F2Cloud } from '../providers/f2cloud.js';
  4 | import { FMCloud } from '../providers/fmcloud.js';
  5 | 
  6 | type EpisodeListJson = {
  7 |   result: string
  8 | }
  9 | type EpisodeJson = {
 10 |   result: {
 11 |     url: string
 12 |   };
 13 | }
 14 | 
 15 | const HOST: string = 'watchseriesx.to';
 16 | const ALT_HOSTS: Array<string> = [HOST];
 17 | const SERVER_F2CLOUD: string = '41';
 18 | const SERVER_MEGACLOUD: string = '28';
 19 | const SERVER_FMCLOUD: string = '45';
 20 | const SERVERS: Array<ServerListItem> = [
 21 |   { id: SERVER_F2CLOUD, handler: F2Cloud },
 22 |   { id: SERVER_MEGACLOUD, handler: F2Cloud },
 23 |   { id: SERVER_FMCLOUD, handler: FMCloud },
 24 | ];
 25 | const ID: string = 'WA';
 26 | 
 27 | // watchseries sometimes crashes ... just retry
 28 | const SCRAPE_CONFIG: ScrapeConfig = {
 29 |   ID: ID,
 30 |   USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36, Playstation',
 31 |   EXPECTED_KEYS: 19,
 32 |   INJECT_URLS: [
 33 |     "all.js",
 34 |     "scripts.js",
 35 |     "embed.js"
 36 |   ],
 37 |   // input of encrypt function
 38 |   ENTRY: new RegExp(`https://.*?/ajax/episode/list/(.*?)\\?`.replace(/\//g, '/')),
 39 |   // output of encrypt function
 40 |   OUT: new RegExp(`https://.*?/ajax/episode/list/.*?\\?vrf=(.*?)$`.replace(/\//g, '/')),
 41 |   INIT_URL: `https://${HOST}/tv/the-big-bang-theory-jyr9n`,
 42 |   BTN_ID: ".movie-btn",
 43 |   MAX_TIMEOUT: 3500
 44 | }
 45 | 
 46 | function enc(inp: string): string {
 47 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 48 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 49 |   if (order.length > 0)
 50 |     return enc_with_order(keys, order, inp);
 51 |   let a: string = subst(rc4(keys[2], reverse(mapp(inp, keys[0], keys[1]))));
 52 |   a = subst(rc4(keys[5], reverse(mapp(a, keys[3], keys[4]))));
 53 |   a = subst(rc4(keys[8], reverse(mapp(a, keys[6], keys[7]))));
 54 |   a = subst(a);
 55 |   return a;
 56 | }
 57 | 
 58 | function dec(inp: string): string {
 59 |   const keys: Array<string> = get_keys(ALT_HOSTS);
 60 |   const order: Array<TransformText> = get_encrypt_order(ALT_HOSTS);
 61 |   if (order.length > 0)
 62 |     return dec_with_order(keys, order, inp);
 63 |   let c = subst_(inp);
 64 |   c = mapp(reverse(rc4(keys[8], subst_(c))), keys[7], keys[6])
 65 |   c = mapp(reverse(rc4(keys[5], subst_(c))), keys[4], keys[3])
 66 |   c = mapp(reverse(rc4(keys[2], subst_(c))), keys[1], keys[0])
 67 |   return c;
 68 | }
 69 | 
 70 | async function episode(data_id: string, server: string = SERVER_F2CLOUD): Promise<Stream> {
 71 |   let url: string = `https://${HOST}/ajax/server/list/${data_id}?vrf=${encodeURIComponent(enc(data_id))}`;
 72 |   const resp: EpisodeListJson = await (await fetch(url)).json() as EpisodeListJson;
 73 |   const new_data_id = (new RegExp(`data-id="${server}" data-link-id="(.*?)"`)).exec(resp.result)![1];
 74 |   debug(ID, new_data_id);
 75 |   url = `https://${HOST}/ajax/server/${new_data_id}?vrf=${encodeURIComponent(enc(new_data_id))}`;
 76 |   const resp2 = await (await fetch(url)).json() as EpisodeJson;
 77 |   const url_dec = dec(resp2.result.url);
 78 |   debug(ID, url_dec);
 79 |   return await try_stream(SERVERS, server, url_dec);
 80 | }
 81 | 
 82 | async function movie(id: string, server: string = SERVER_F2CLOUD): Promise<Stream> {
 83 |   return await tv(id, 1, 1, server);
 84 | }
 85 | 
 86 | async function tv(id: string, s: number = 1, e: number = 1, server: string = SERVER_F2CLOUD): Promise<Stream> {
 87 |   const resp: string = await (await fetch(`https://${HOST}/tv/${id}/${s}-${e}`)).text();
 88 |   const data_id = (/data-id="(.*?)"/g).exec(resp)![1];
 89 |   debug(ID, data_id);
 90 |   const url = `https://${HOST}/ajax/episode/list/${data_id}?vrf=${encodeURIComponent(enc(data_id))}`;
 91 |   debug(ID, url);
 92 |   const resp2: EpisodeListJson = await (await fetch(url)).json() as EpisodeListJson;
 93 |   const new_data_id: string = (new RegExp(`${s}-${e}" data-id="(.*?)"`, 'g')).exec(resp2.result)![1];
 94 |   debug(ID, new_data_id);
 95 |   return await episode(new_data_id, server);
 96 | }
 97 | 
 98 | async function search(query: string): Promise<Array<SearchResult>> {
 99 |   const url: string = `https://${HOST}/filter?keyword=${query}`;
100 |   const resp: string = await (await fetch(url)).text();
101 |   const results = resp.match(new RegExp(`<a href=".*?" class="title">.*?</a>`, 'g'))!;
102 |   const ret: Array<SearchResult> = [];
103 |   for (const r of results) {
104 |     const [, type_raw, id, title] = (new RegExp(`href="/(.*?)/(.*?)" .*>(.*?)</a>`)).exec(r)!;
105 |     let type: SearchResultType = 'tv';
106 |     if (type_raw !== 'tv')
107 |       type = 'movie';
108 |     const item: SearchResult = { type, title, id };
109 |     ret.push(item);
110 |   }
111 |   return ret;
112 | }
113 | 
114 | async function test() {
115 |   try {
116 |     const tests: Array<Promise<Stream>> = [tv("the-big-bang-theory-jyr9n", 1, 1), movie("movie-vika-online-k3n6m")];
117 |     const results = await Promise.all(tests);
118 |     for (const r of results) {
119 |       if (!isJSON(r))
120 |         throw `${JSON.stringify(r)} is not json`;
121 |     }
122 |     const results2: Array<SearchResult> = await search("big bang theory");
123 |     if (results2[0].type == 'tv') {
124 |       const r = (await tv(results2[0].id, 1, 2));
125 |       if (!isJSON(r))
126 |         throw `${JSON.stringify(r)} is not json`;
127 |     }
128 |     else {
129 |       const r = (await movie(results2[0].id));
130 |       if (!isJSON(r))
131 |         throw `${JSON.stringify(r)} is not json`;
132 |     }
133 |     log(ID, `${HOST} passed the tests`);
134 |   } catch (e: unknown) {
135 |     error(ID, `${HOST} failed the tests`, (e as Error));
136 |   }
137 | }
138 | 
139 | export const Watchseries: Source = { HOST, ALT_HOSTS, SERVERS, ID, movie, tv, search, SCRAPE_CONFIG, test };
140 | 
141 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
  1 | import fs from 'fs';
  2 | import path from 'path';
  3 | import { fileURLToPath } from 'url';
  4 | 
  5 | const __filename = fileURLToPath(import.meta.url);
  6 | const __dirname = path.dirname(__filename);
  7 | 
  8 | export const DEBUG = process?.env?.DEBUG == "true";
  9 | 
 10 | export type ScrapeConfig = {
 11 |   ID: string,
 12 |   // input of encrypt function
 13 |   ENTRY: RegExp,
 14 |   // output of encrypt function
 15 |   OUT: RegExp,
 16 |   USER_AGENT: string,
 17 |   INJECT_URLS: Array<string>,
 18 |   INIT_URL: string,
 19 |   BTN_ID: string,
 20 |   MAX_TIMEOUT?: number
 21 |   EXPECTED_KEYS?: number,
 22 | }
 23 | 
 24 | export type Subtitle = {
 25 |   label: string, file: string
 26 | }
 27 | export type Stream = {
 28 |   stream: string
 29 |   subtitles?: Array<Subtitle>
 30 | }
 31 | 
 32 | export type Source = {
 33 |   HOST: string,
 34 |   ALT_HOSTS: Array<string>,
 35 |   SERVERS: Array<ServerListItem>,
 36 |   ID: string,
 37 |   SCRAPE_CONFIG?: ScrapeConfig,
 38 |   movie(id: string, server?: string): Promise<Stream>;
 39 |   tv(id: string, s: number, e: number, server?: string): Promise<Stream>;
 40 |   search?(query: string): Promise<Array<SearchResult>>;
 41 |   test(): void
 42 | }
 43 | 
 44 | export type Provider = {
 45 |   ALT_HOSTS: Array<string>,
 46 |   SCRAPE_CONFIG?: ScrapeConfig,
 47 |   stream(url: string, args?: Record<string, string>): Promise<Stream>;
 48 | }
 49 | 
 50 | export type ServerListItem = {
 51 |   id: string,
 52 |   handler: Provider
 53 | }
 54 | 
 55 | export type Trace = Record<string, string>;
 56 | export type EntryOut = {
 57 |   entry: string,
 58 |   out: string
 59 | }
 60 | export type Store = {
 61 |   keys: Record<string, Array<string>>,
 62 |   encrypt_order: Record<string, Array<string>>,
 63 |   traces: Record<string, Array<Trace>>,
 64 |   entries_outs: Record<string, EntryOut>
 65 | }
 66 | 
 67 | export type SearchResultType = 'tv' | 'movie';
 68 | 
 69 | export type SearchResult = {
 70 |   type: SearchResultType,
 71 |   title: string,
 72 |   id: string
 73 | }
 74 | 
 75 | export type TransformText = ((...arg: Array<string>) => string);
 76 | 
 77 | export function log(ID: string, msg: string) {
 78 |   console.log(`[!-${ID}] ${msg} `);
 79 | }
 80 | export function debug(ID: string, msg: string) {
 81 |   if (DEBUG == true)
 82 |     console.log(`[D - ${ID}] ${msg} `);
 83 | }
 84 | export function error(ID: string, msg: string, e?: Error) {
 85 |   console.log(`[x - ${ID}] ${msg} `);
 86 |   if (DEBUG == true && e)
 87 |     console.log(e);
 88 | }
 89 | 
 90 | export function isJSON(d: object): boolean {
 91 |   try {
 92 |     if (typeof (d) === "string") {
 93 |       JSON.parse(d);
 94 |     } else {
 95 |       JSON.parse(JSON.stringify(d));
 96 |     }
 97 | 
 98 |     return true;
 99 |   } catch {
100 |     return false;
101 |   }
102 | }
103 | 
104 | export function rc4(key: string, inp: string): string {
105 |   const arr = [];
106 |   let counter = 0;
107 |   let i = 0;
108 |   let tmp = 0;
109 |   let decrypted = "";
110 |   for (i = 0; i < 256; i++) {
111 |     arr[i] = i;
112 |   }
113 |   for (i = 0; i < 256; i++) {
114 |     counter = (counter + arr[i] + key.charCodeAt(i % key.length)) % 256;
115 |     tmp = arr[i];
116 |     arr[i] = arr[counter];
117 |     arr[counter] = tmp;
118 |   }
119 |   i = 0;
120 |   counter = 0;
121 |   for (let j = 0; j < inp.length; j++) {
122 |     i = (i + 1) % 256;
123 |     counter = (counter + arr[i]) % 256;
124 |     tmp = arr[i];
125 |     arr[i] = arr[counter];
126 |     arr[counter] = tmp;
127 |     decrypted += String.fromCharCode(inp.charCodeAt(j) ^ arr[(arr[i] + arr[counter]) % 256]);
128 |   }
129 |   return decrypted;
130 | }
131 | export function subst(a: string) {
132 |   return (btoa(a)).replace(/\//g, '_').replace(/\+/g, '-');
133 | }
134 | export function subst_(a: string) {
135 |   return atob((a).replace(/_/g, '/').replace(/-/g, '+'));
136 | }
137 | export function mapp(a: string, b: string, c: string) {
138 |   let d = b.length;
139 |   const e: Record<string, string> = {};
140 |   while (d-- && (e[b[d]] = c[d] || '')) {
141 |     ;
142 |   }
143 |   return a.split('').map(a => e[a] || a).join('');
144 | }
145 | export function reverse(a: string) {
146 |   return a.split('').reverse().join('');
147 | }
148 | 
149 | export function general_enc(key: string, inp: string) {
150 |   inp = encodeURIComponent(inp);
151 |   const e = rc4(key, inp);
152 |   const out = btoa(e).replace(/\//g, "_").replace(/\+/g, '-');
153 |   return out;
154 | }
155 | 
156 | export function general_dec(key: string, inp: string) {
157 |   const i = atob((inp).replace(/_/g, "/").replace(/-/g, "+"));
158 |   let e = rc4(key, i);
159 |   e = decodeURIComponent(e);
160 |   return e;
161 | }
162 | 
163 | function string_to_func(func: string): TransformText {
164 |   switch (func) {
165 |     case "rc4":
166 |       return rc4;
167 |     case "mapp":
168 |       return mapp;
169 |     case "subst":
170 |       return subst;
171 |     case "reverse":
172 |       return reverse;
173 |   }
174 |   return ((v: string) => v);
175 | }
176 | 
177 | export async function try_stream(SERVERS: Array<ServerListItem>, server: string, url: string, args?: Record<string, string>): Promise<Stream> {
178 |   const handler = SERVERS.find(e => e.id == server)?.handler;
179 |   try {
180 |     return await handler!.stream(url, args);
181 |   } catch {
182 |     for (const h of SERVERS) {
183 |       if (h.handler == handler)
184 |         continue;
185 | 
186 |       try {
187 |         return await h.handler.stream(url, args);
188 |       } catch {
189 |         continue;
190 |       }
191 |     }
192 | 
193 |     throw NO_STREAM_ERROR;
194 |   }
195 | }
196 | 
197 | export function enc_with_order(keys: Array<string>, order: Array<TransformText>, inp: string) {
198 |   let res = "";
199 |   let k_i = 0;
200 | 
201 |   function use_func(func: TransformText, inp: string) {
202 |     let r: string = "";
203 |     switch (func) {
204 |       case rc4:
205 |         r = rc4(keys[k_i], inp);
206 |         k_i++;
207 |         break;
208 |       case mapp:
209 |         r = mapp(inp, keys[k_i], keys[k_i + 1]);
210 |         k_i += 2;
211 |         break;
212 |       default:
213 |         r = func(inp);
214 |         break;
215 |     }
216 |     return r;
217 |   }
218 | 
219 |   try {
220 |     for (let i = 0; i < order.length; i++)
221 |       res = use_func(order[i], i == 0 ? inp : res);
222 |   } catch {
223 |     return "";
224 |   }
225 | 
226 |   return res;
227 | }
228 | export function dec_with_order(keys: Array<string>, order: Array<TransformText>, inp: string) {
229 |   return enc_with_order(keys.concat().reverse(), order.concat().reverse().map(f => f == subst ? subst_ : f), inp);
230 | }
231 | 
232 | export const keys_path = path.join(__dirname, "keys.json");
233 | const store: Store = JSON.parse((fs.existsSync(keys_path)) ? fs.readFileSync(keys_path).toString() : "{}");
234 | const keys: Record<string, Array<string>> = store.keys;
235 | const encrypt_orders: Record<string, Array<string>> = store.encrypt_order
236 | 
237 | export function get_keys(hosts: Array<string>): Array<string> {
238 |   for (const h of hosts) {
239 |     if (keys[h])
240 |       return keys[h];
241 |   }
242 |   throw NO_KEY_ERROR;
243 | }
244 | 
245 | export function get_encrypt_order(hosts: Array<string>): Array<TransformText> {
246 |   for (const h of hosts) {
247 |     if (encrypt_orders[h])
248 |       return encrypt_orders[h].map(f => string_to_func(f));
249 |   }
250 |   return [];
251 | }
252 | 
253 | export const NO_STREAM_ERROR = "NO_STREAM";
254 | export const NO_KEY_ERROR = "NO_KEY";
255 | 


--------------------------------------------------------------------------------
/src/getkeys.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The idea is to use the AST of the original script to find the RC4 function
  3 |  * Then open a real url, patch the script in a way that the RC4 function 
  4 |  * can exfiltrate its parameters (keys) and gather them
  5 |  */
  6 | 
  7 | import puppeteer from 'puppeteer-extra'
  8 | import StealthPlugin from 'puppeteer-extra-plugin-stealth';
  9 | puppeteer.use(StealthPlugin());
 10 | import { executablePath } from 'puppeteer';
 11 | import parser from '@babel/parser';
 12 | import traverse from '@babel/traverse';
 13 | import fs from 'fs';
 14 | 
 15 | import { keys_path, debug, error, log, rc4, mapp, subst, reverse, enc_with_order, ScrapeConfig, Source, Provider, Store, EntryOut, Trace, TransformText } from './utils.js';
 16 | import { Watchseries } from './sources/watchseries.js';
 17 | import { Vidsrc } from './sources/vidsrc.js';
 18 | import { Aniwave } from './sources/aniwave.js';
 19 | import { F2Cloud } from './providers/f2cloud.js';
 20 | import { VidStream } from './sources/vidstream.to.js';
 21 | 
 22 | type ForWhile = {
 23 |   fors: number,
 24 |   whiles: number
 25 | }
 26 | 
 27 | type ASTNodes = {
 28 |   name: string,
 29 |   code: string,
 30 |   type: string,
 31 |   source: string
 32 | }
 33 | 
 34 | const ID = 'GK';
 35 | 
 36 | //const FLIX2: ScrapeConfig = {
 37 | //  ID: 'FL',
 38 | //  USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
 39 | //  EXPECTED_KEYS: 5,
 40 | //  INJECT_URLS: [
 41 | //    "all.js",
 42 | //    "embed.js"
 43 | //  ],
 44 | //  ENTRY: new RegExp('', ''),
 45 | //  OUT: new RegExp('', ''),
 46 | //  INIT_URL: "https://2flix.to/tv/the-big-bang-theory-watch-online-jjgjg/1-1",
 47 | //  BTN_ID: ".playnow-btn",
 48 | //  MAX_TIMEOUT: 2500
 49 | //}
 50 | //
 51 | //const VIDSRCCC: ScrapeConfig = {
 52 | //  ID: "CC",
 53 | //  USER_AGENT: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36, Playstation',
 54 | //  EXPECTED_KEYS: 5,
 55 | //  INJECT_URLS: [
 56 | //    "all.js",
 57 | //    "all.min.js",
 58 | //    "embed.js",
 59 | //    "embed.min.js"
 60 | //  ],
 61 | //  ENTRY: new RegExp('', ''),
 62 | //  OUT: new RegExp('', ''),
 63 | //  INIT_URL: "https://vidsrc.cc/v2/embed/tv/tt0898266",
 64 | //  BTN_ID: "#btn-play",
 65 | //  MAX_TIMEOUT: 5000,
 66 | //}
 67 | 
 68 | const ENTRIES: Record<string, ScrapeConfig> = {
 69 | }
 70 | 
 71 | 
 72 | const funcs = [reverse, subst];
 73 | const mfuncs = [[subst], [reverse, subst]];
 74 | 
 75 | /**
 76 |  * Returns names of the (sorted) functions used to produce `expected`
 77 |  *
 78 |  * @param {string} expected The expected value.
 79 |  * @param {Trace} prev_trace The trace of the step before (can be empty in case of first step).
 80 |  * @param {string} r1 Only used for the first step. It is the entry value (e.g. `LoFbkLSv`).
 81 |  * @return {Array} Names of the functions.
 82 |  */
 83 | function find_funcs(expected: string = "", prev_trace: Trace = {}, r1: string = ""): Array<TransformText> {
 84 |   let fun: Array<TransformText> = [];
 85 |   if (prev_trace["type"] == "rc4") {
 86 |     r1 = rc4(prev_trace["0"], prev_trace["1"]);
 87 |     fun = [rc4];
 88 |   } else if (prev_trace["type"] == "map") {
 89 |     r1 = mapp(prev_trace["0"], prev_trace["1"], prev_trace["2"]);
 90 |     fun = [mapp];
 91 |   }
 92 | 
 93 |   if (r1 === expected) {
 94 |     return fun;
 95 |   }
 96 | 
 97 |   if (r1 === "")
 98 |     r1 = expected;
 99 |   for (let i = 0; i < funcs.length; i++) {
100 |     const r2 = funcs[i](r1);
101 |     if (r2 == expected)
102 |       return [...fun, funcs[i]];
103 |     for (let j = 0; j < mfuncs[i].length; j++) {
104 |       const r3 = mfuncs[i][j](r2);
105 |       if (r3 == expected)
106 |         return [...fun, funcs[i], mfuncs[i][j]];
107 |     }
108 |   }
109 | 
110 |   throw "NO COMBINATION";
111 | }
112 | 
113 | 
114 | /**
115 |  * Returns the result of the previous trace (it is the argument of the current trace)
116 |  *
117 |  * @param {Trace} trace The trace that has per argument the previous trace result
118 |  * @return {string} Result
119 |  */
120 | function get_result_from_prev_trace(trace: Trace): string {
121 |   if (trace["type"] == "rc4") {
122 |     return trace["1"];
123 |   } else if (trace["type"] == "map") {
124 |     return trace["0"];
125 |   }
126 |   return "";
127 | }
128 | 
129 | function get_result_from_trace(trace: Trace): string {
130 |   if (trace["type"] == "rc4") {
131 |     return rc4(trace["0"], trace["1"]);
132 |   } else if (trace["type"] == "map") {
133 |     return mapp(trace["0"], trace["1"], trace["2"]);
134 |   }
135 |   return "";
136 | }
137 | function get_func_from_trace(trace: Trace): TransformText {
138 |   if (trace["type"] == "rc4") {
139 |     return rc4;
140 |   } else if (trace["type"] == "map") {
141 |     return mapp;
142 |   }
143 |   return ((v: string) => v);
144 | }
145 | 
146 | // Assumption: 
147 | // - while intercepting using puppeteer we ONLY get keys (not false positives)
148 | // - the order of the keys intercepted is critical
149 | // - we log only the first usage of the encrypt function (we get there `entry` and `out`)
150 | // - `entry` and `out` must be related to `traces`
151 | //
152 | // The idea is that we log every call to "important" functions (e.g. rc4, mapp)
153 | // The logs must be in the correct order
154 | // With the logs we know parameters and we can compute the output
155 | // We then try all the combinations to find the correct functions
156 | // 
157 | function reverse_crypt_function(traces: Array<Trace>, entry = "", out = ""): Array<TransformText> {
158 | 
159 |   let log = '';
160 |   const funcs: Array<TransformText> = [];
161 |   if (entry != "") {
162 |     const prev_res = get_result_from_prev_trace(traces[0]);
163 |     const comb = find_funcs(entry, {}, prev_res);
164 |     funcs.push(...comb);
165 |     log += (`0. ${comb.map(f => f.name)}\n`);
166 |   }
167 |   for (let i = 1; i < traces.length; i++) {
168 |     const prev_res = get_result_from_prev_trace(traces[i]);
169 |     const comb = find_funcs(prev_res, traces[i - 1]);
170 |     funcs.push(...comb);
171 |     log += (`${i}. ${comb.map(f => f.name)}\n`);
172 |   }
173 | 
174 |   const prev_res = get_result_from_trace(traces[traces.length - 1]);
175 |   const comb = find_funcs(out, {}, prev_res);
176 |   funcs.push(get_func_from_trace(traces[traces.length - 1]));
177 |   funcs.push(...comb);
178 |   log += (`L${traces.length}. ${comb.map(f => f.name)}\n`);
179 |   debug(ID, log);
180 | 
181 |   return funcs;
182 | }
183 | 
184 | // finding possible names for the rc4 function
185 | // a new source is not generated since some functions depend on the min algorithm
186 | // used originally
187 | async function get_rc4_names(source: string): Promise<Array<ASTNodes>> {
188 | 
189 |   function rec_search(p: any): ForWhile {
190 |     const body = p?.body?.body || p?.consequent?.body || p?.init?.body;
191 |     if (!body || body?.length == undefined || body.length == 0)
192 |       return { fors: 0, whiles: 0 };
193 |     let fors = 0;
194 |     let whiles = 0;
195 |     for (const n of body) {
196 |       if (n.type == 'ForStatement')
197 |         fors++;
198 |       if (n.type == 'WhileStatement')
199 |         whiles++;
200 | 
201 |       const r = rec_search(n);
202 |       fors += r.fors;
203 |       whiles += r.whiles;
204 |     }
205 |     return { fors, whiles };
206 |   }
207 | 
208 |   const ast = parser.parse(source);
209 |   const names: Array<ASTNodes> = [];
210 |   const MyVisitor: any = {
211 |     FunctionDeclaration(path: any) {
212 |       const s = source.slice(path.node.start, path.node.end);
213 |       const name = s.split("{")[0].replace("(", "\\(").replace(")", "\\)");
214 |       const r: ForWhile = rec_search(path?.node);
215 |       if (r.fors >= 3 && !names.find(t => t.code == s)) {
216 |         names.push({ name: name, code: s, type: 'rc4', source: 'func' });
217 |         return;
218 |       }
219 |       if ((r.whiles == 1 || r.fors == 1) && path.node.params.length == 3 && !names.find(t => t.code == s)) {
220 |         names.push({ name: name, code: s, type: 'map', source: 'func' });
221 |         return;
222 |       }
223 |     },
224 |     Function(path: any) {
225 |       const s = source.slice(path.node.start, path.node.end);
226 |       //const name = s.split("{")[0].replace("(", "\\(").replace(")", "\\)");
227 |       const r: ForWhile = rec_search(path?.node);
228 |       if (r.fors >= 3 && !names.find(t => t.code == s)) {
229 |         //names.push({ name: name, code: s, type: 'func_expr', source: 'func' });
230 |       }
231 |     }
232 |   };
233 | 
234 |   // dirty bypass ... can you help me?
235 |   (traverse as any).default(ast, MyVisitor);
236 |   return names;
237 | }
238 | 
239 | const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
240 | 
241 | // https://gist.github.com/jabney/5018b4adc9b2bf488696
242 | function entropy(str: string): number {
243 |   const len = str.length
244 |   const frequencies = Array.from(str)
245 |     .reduce((freq: any, c: any) => (freq[c] = (freq[c] || 0) + 1) && freq, {})
246 |   return Object.values(frequencies)
247 |     .reduce((sum: any, f: any) => sum - f / len * Math.log2(f / len), 0) as number;
248 | }
249 | 
250 | async function handle_intercept(request: any, config: ScrapeConfig, entries_outs: Record<string, EntryOut> = {}) {
251 |   const url = decodeURIComponent(request.url());
252 |   const host = (new URL(url)).host;
253 |   if (config.INJECT_URLS!.some(v => url.includes(v))) {
254 |     let body = await (await fetch(url)).text();
255 |     const funcs = await get_rc4_names(body);
256 |     debug(ID, url);
257 |     debug(ID, JSON.stringify(funcs));
258 |     // risky approach since we could modify multiple functions
259 |     // ... but in the worst case we would just be printing so no harm
260 |     for (const n of funcs) {
261 |       const proxy = `if(arguments){arguments['host']='${host}';arguments['type']='${n.type}';window.mylog(arguments);}`;
262 |       switch (n.type) {
263 |         case 'func_expr':
264 |           const reg_res = (/^function.*?{/gm).exec(n.code);
265 |           if (reg_res) {
266 |             const func_name = reg_res[0];
267 |             const updated = n.code.replace(func_name, `${func_name}${proxy}`);
268 |             body = body.replaceAll(n.code, updated);
269 |           }
270 |           break;
271 | 
272 |         default:
273 |           const sel = (new RegExp(`${n.name}\\s*{`, 'gms')).exec(body);
274 |           if (sel) {
275 |             const rep = `${sel[0]}${proxy}`;
276 |             body = body.replaceAll(sel[0], rep);
277 |           }
278 |           break;
279 | 
280 |       }
281 |     }
282 |     request.respond({
283 |       status: 200,
284 |       body: body
285 |     });
286 |   } else {
287 |     if (ENTRIES[host] && ENTRIES[host].ENTRY.test(url)) {
288 |       if (entries_outs[host] == undefined)
289 |         entries_outs[host] = { entry: "", out: "" }
290 |       if (entries_outs[host].entry == "")
291 |         entries_outs[host].entry = ENTRIES[host].ENTRY.exec(url)![1];
292 |       debug(ID, `ENTRY : ${entries_outs[host].entry} for ${host}`);
293 |     }
294 |     if (ENTRIES[host] && ENTRIES[host].OUT.test(url)) {
295 |       if (entries_outs[host] == undefined)
296 |         entries_outs[host] = { entry: "", out: "" }
297 |       if (entries_outs[host].out == "")
298 |         entries_outs[host].out = ENTRIES[host].OUT.exec(url)![1];
299 |       debug(ID, `OUT : ${entries_outs[host].out} for ${host}`);
300 |     }
301 |     request.continue();
302 |   }
303 | }
304 | 
305 | async function find_keys(config: ScrapeConfig) {
306 |   const args = [
307 |     '--no-sandbox',
308 |     '--disable-web-security',
309 |   ];
310 | 
311 |   const options = {
312 |     args,
313 |     executablePath: process.env.PUPPETEER_EXEC_PATH || executablePath(),
314 |     headless: false,
315 |   };
316 | 
317 |   const browser = await puppeteer.launch(options);
318 |   const page = await browser.newPage()
319 | 
320 |   const keys: Record<string, Array<string>> = {};
321 |   let keysNum = 0;
322 |   const traces: Record<string, Array<Trace>> = {};
323 |   const entries_outs: Record<string, EntryOut> = {};
324 | 
325 |   page.setDefaultNavigationTimeout(30000);
326 |   await page.setUserAgent(config.USER_AGENT!);
327 |   await page.setViewport({
328 |     width: 1080,
329 |     height: 1080
330 |   })
331 |   await page.setRequestInterception(true);
332 |   page.on('request', async (request) => {
333 |     await handle_intercept(request, config, entries_outs);
334 |   });
335 | 
336 |   const closed = false;
337 | 
338 |   function add_key(host: string, key: string, trace: Trace) {
339 |     if (!keys[host].includes(key) && entropy(key) > 3.2) {
340 |       keys[host].push(key)
341 |       if (!traces[host].includes(trace))
342 |         traces[host].push(trace);
343 |       return true;
344 |     }
345 |   }
346 |   await page.exposeFunction('mylog', (data: Trace) => {
347 |     if (!data['0'])
348 |       return;
349 |     if (data['type'] == 'func_expr' && Object.values(data).includes('tt0898266'))
350 |       console.log(ID, JSON.stringify(data));
351 |     if (!keys[data['host']]) {
352 |       keys[data['host']] = [];
353 |       traces[data['host']] = [];
354 |     }
355 |     if (data['type'] == 'rc4') {
356 |       if (add_key(data['host'], data['0'], data)) {
357 |         keysNum++;
358 |       }
359 |     } else if (data['type'] == 'map') {
360 |       if (add_key(data['host'], data['1'], data)) {
361 |         keysNum++;
362 |       }
363 |       if (add_key(data['host'], data['2'], data)) {
364 |         keysNum++;
365 |       }
366 |     }
367 |   });
368 | 
369 |   await page.goto(config.INIT_URL!);
370 |   await page.waitForSelector(config.BTN_ID!, { timeout: 5_000 });
371 |   try {
372 |     for (let i = 0; i < 50; i++) {
373 |       if (closed) {
374 |         break;
375 |       }
376 |       await page.bringToFront();
377 |       const btn = await page.$(config.BTN_ID!);
378 |       if (btn && !closed) {
379 |         await page.evaluate((element: HTMLElement) => {
380 |           element.click()
381 |         }, btn)
382 |       }
383 |       await sleep(100);
384 |     }
385 |   }
386 |   catch (e: any) {
387 |     if (!closed)
388 |       error(ID, "", e);
389 |   }
390 | 
391 |   if (keysNum < config.EXPECTED_KEYS!) {
392 |     await sleep(config.MAX_TIMEOUT || 2500);
393 |   }
394 |   await browser.close();
395 |   debug(ID, `${config.ID} got ${keysNum}/${config.EXPECTED_KEYS}`);
396 |   return ({ keys, traces, entries_outs });
397 | }
398 | 
399 | // TODO: generalize and refactor
400 | function prepare_entries(arr: Array<Source | Provider>) {
401 |   for (const e of arr) {
402 |     if (e.SCRAPE_CONFIG!.ENTRY) {
403 |       for (const h of e.ALT_HOSTS) {
404 |         ENTRIES[h] = e.SCRAPE_CONFIG!;
405 |       }
406 |     }
407 |   }
408 | }
409 | 
410 | function test_keys_funcs(keys: Array<string>, funcs: Array<TransformText>, entry: string, out: string) {
411 |   const res = enc_with_order(keys, funcs, entry);
412 |   return res == out;
413 | }
414 | 
415 | async function main() {
416 |   // disabled
417 |   return;
418 |   prepare_entries([Vidsrc, F2Cloud, Watchseries, Aniwave]);
419 |   const promises = [find_keys(Vidsrc.SCRAPE_CONFIG!), find_keys(Watchseries.SCRAPE_CONFIG!), find_keys(Aniwave.SCRAPE_CONFIG!)];
420 |   const results_promises = (await Promise.all(promises));
421 |   const results = { keys: {}, traces: {}, entries_outs: {}, encrypt_order: {} } as Store
422 |   for (const r of results_promises) {
423 |     results.keys = Object.assign({}, results.keys, r.keys);
424 |     results.traces = Object.assign({}, results.traces, r.traces);
425 |     results.entries_outs = Object.assign({}, results.entries_outs, r.entries_outs);
426 |   }
427 |   const keys = results["keys"];
428 |   const traces: Record<string, Array<Trace>> = results["traces"];
429 |   const entries_outs: Record<string, EntryOut> = results["entries_outs"];
430 |   for (const t in traces) {
431 |     const entry = entries_outs[t].entry;
432 |     const out = entries_outs[t].out;
433 |     if (entry && out && keys[t]) {
434 |       const funcs = reverse_crypt_function(traces[t], entry, out);
435 |       if (test_keys_funcs(keys[t], funcs, entry, out)) {
436 |         log(ID, `Encrypt function found for ${t}`);
437 |         results.encrypt_order[t] = funcs.map(f => f.name);
438 |       }
439 |     }
440 |   }
441 |   fs.writeFileSync(keys_path, JSON.stringify(results));
442 |   log(ID, `Keys successfully stored in ${keys_path}`);
443 | }
444 | 
445 | main();
446 | 
447 | 
448 | 


--------------------------------------------------------------------------------