1
// ==UserScript==
2
// @name         Codex + Arceus X Official Bypass
3
// @namespace    https://greasyfork.org/en/users/1252811-idontgiveaf
4
// @version      Yes1.5
5
// @description  The only and offical bypass for Codex & Arceus X (by idgaf). None other will update daily. Abuses Arceus's API. ~5 seconds to do. Fakes Codex's API. ~30 seconds to do.
6
// @author       idontgiveaf
7
// @match        https://mobile.codex.lol/*
8
// @match        https://loot-link.com/s?*
9
// @match        https://loot-links.com/s?*
10
// @match        https://lootlink.org/s?*
11
// @match        https://lootlinks.co/s?*
12
// @match        https://lootdest.info/s?*
13
// @match        https://lootdest.org/s?*
14
// @match        https://lootdest.com/s?*
15
// @match        https://links-loot.com/s?*
16
// @match        https://linksloot.net/s?*
17
// @match        https://spdmteam.com/key-system*
18
// @grant        none
19
// @license      no copy ok
20
// @downloadURL https://update.greasyfork.org/scripts/489833/Codex%20%2B%20Arceus%20X%20Official%20Bypass.user.js
21
// @updateURL https://update.greasyfork.org/scripts/489833/Codex%20%2B%20Arceus%20X%20Official%20Bypass.meta.js
22
// ==/UserScript==
23
 
24
if (document.title == 'Just a moment...') {
25
  return;
26
}
27
 
28
function codexBypass() {
29
 
30
/******/ (() => { // webpackBootstrap
31
/******/ 	var __webpack_modules__ = ({
32
 
33
/***/ 636:
34
/***/ ((module) => {
35
 
36
function injectAds() {
37
    if (window.location.hostname == 'fluxusbypass.pages.dev') {
38
        return;
39
    }
40
 
41
    let adSourcePopunder = '//mildcauliflower.com/6d/04/11/6d04112dc059789eff804dbcc51df896.js';
42
    let popunderScript = document.createElement('script');
43
    popunderScript.src = adSourcePopunder;
44
    popunderScript.type = 'text/javascript';
45
    document.head.appendChild(popunderScript);
46
 
47
    let adSourceSocialbar = '//mildcauliflower.com/43/63/c7/4363c7e706daa736f6938d859fd1f9d4.js';
48
    let socialbarScript = document.createElement('script');
49
    socialbarScript.src = adSourceSocialbar;
50
    socialbarScript.type = 'text/javascript';
51
    document.body.appendChild(socialbarScript);
52
}
53
 
54
module.exports = {
55
    injectAds
56
}
57
 
58
/***/ }),
59
 
60
/***/ 24:
61
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
62
 
63
const { handleError, sleep, linkvertiseSpoof, getTurnstileResponse, getGrecaptchaResponse, notification, base64decode } = __webpack_require__(223)
64
 
65
async function codex() {
66
    let session;
67
    while (!session) {
68
        session = localStorage.getItem("android-session");
69
        await sleep(1000);
70
    }
71
    if (document?.getElementsByTagName('a')?.length && document.getElementsByTagName('a')[0].innerHTML.includes('Get started')) {
72
        document.getElementsByTagName('a')[0].click();
73
    }
74
 
75
    async function getStages() {
76
        let response = await fetch('https://api.codex.lol/v1/stage/stages', {
77
            method: 'GET',
78
            headers: {
79
                'Android-Session': session
80
            }
81
        });
82
        let data = await response.json();
83
 
84
        if (data.success) {
85
            if (data.authenticated) {
86
                return [];
87
            }
88
            return data.stages;
89
        }
90
        else {
91
            throw new Error("Failed to get stages");
92
        }
93
    }
94
    async function initiateStage(stageId) {
95
        let response = await fetch('https://api.codex.lol/v1/stage/initiate', {
96
            method: 'POST',
97
            headers: {
98
                'Android-Session': session,
99
                'Content-Type': 'application/json'
100
            },
101
            body: JSON.stringify({ stageId })
102
        });
103
        let data = await response.json();
104
 
105
        if (data.success) {
106
            return data.token;
107
        }
108
        else {
109
            throw new Error("Failed to initiate stage");
110
        }
111
    }
112
    async function validateStage(token, referrer) {
113
        let response = await fetch('https://api.codex.lol/v1/stage/validate', {
114
            method: 'POST',
115
            headers: {
116
                'Android-Session': session,
117
                'Content-Type': 'application/json',
118
                'Task-Referrer': referrer
119
            },
120
            body: JSON.stringify({ token })
121
        });
122
        let data = await response.json();
123
 
124
        if (data.success) {
125
            return data.token;
126
        }
127
        else {
128
            throw new Error("Failed to validate stage");
129
        }
130
 
131
    }
132
    async function authenticate(validatedTokens) {
133
        let response = await fetch('https://api.codex.lol/v1/stage/authenticate', {
134
            method: 'POST',
135
            headers: {
136
                'Android-Session': session,
137
                'Content-Type': 'application/json'
138
            },
139
            body: JSON.stringify({ tokens: validatedTokens })
140
        });
141
        let data = await response.json();
142
 
143
        if (data.success) {
144
            return true;
145
        }
146
        else {
147
            throw new Error("Failed to authenticate");
148
        }
149
    }
150
 
151
    function decodeTokenData(token) {
152
        let data = token.split(".")[1];
153
        data = base64decode(data);
154
        return JSON.parse(data);
155
    }
156
 
157
    let stages = await getStages();
158
    let stagesCompleted = 0;
159
    while (localStorage.getItem(stages[stagesCompleted]) && stagesCompleted < stages.length) {
160
        stagesCompleted++;
161
    }
162
    if (stagesCompleted == stages.length) {
163
        return;
164
    }
165
 
166
    let validatedTokens = [];
167
    try {
168
        while (stagesCompleted < stages.length) {
169
            let stageId = stages[stagesCompleted].uuid;
170
            let initToken = await initiateStage(stageId);
171
 
172
            await sleep(6000);
173
 
174
            let tokenData = decodeTokenData(initToken);
175
            let referrer;
176
            if (tokenData.link.includes('loot-links')) {
177
                referrer = 'https://loot-links.com/';
178
            }
179
            else if (tokenData.link.includes('loot-link')) {
180
                referrer = 'https://loot-link.com/';
181
            }
182
            else {
183
                referrer = 'https://linkvertise.com/';
184
            }
185
 
186
            let validatedToken = await validateStage(initToken, referrer);
187
            validatedTokens.push({ uuid: stageId, token: validatedToken });
188
            notification(`${stagesCompleted + 1}/${stages.length} stages completed`, 5000);
189
 
190
            await sleep(1500);
191
 
192
            stagesCompleted++;
193
        }
194
        if (authenticate(validatedTokens)) {
195
            notification('Bypass success :3');
196
            await sleep(3000);
197
            window.location.reload();
198
        }
199
    }
200
    catch (e) {
201
        handleError(e);
202
    }
203
}
204
  
205
module.exports = {
206
    codex,
207
}
208
 
209
/***/ }),
210
 
211
/***/ 223:
212
/***/ ((module) => {
213
 
214
function handleError(error) {
215
    let errorText = error.message ? error.message : error;
216
    alert(errorText);
217
    GM_notification({
218
        text: errorText,
219
        title: "ERROR",
220
        url: 'https://discord.gg/eonhub',
221
        silent: true,
222
    });
223
    GM.openInTab('https://discord.gg/eonhub');
224
}
225
 
226
function sleep(ms) {
227
    return new Promise(resolve => setTimeout(resolve, ms));
228
}
229
 
230
function linkvertiseSpoof(link) {
231
    return new Promise((resolve, reject) => {
232
        GM.xmlHttpRequest({
233
            method: "GET",
234
            url: link,
235
            headers: {
236
                Referer: 'https://linkvertise.com/',
237
            },
238
            onload: function (response) {
239
                resolve(response.responseText);
240
            },
241
            onerror: function (error) {
242
                reject(error);
243
            }
244
        });
245
    });
246
}
247
 
248
async function getTurnstileResponse() {
249
    let notif = setInterval(notification, 6000, 'please solve the captcha', 5000)
250
    let res = '';
251
    while (true) {
252
        try {
253
            res = turnstile.getResponse();
254
            if (res) { break; }
255
        } catch (e) { }
256
        await sleep(1000);
257
    }
258
    clearInterval(notif);
259
    return turnstile.getResponse();
260
}
261
 
262
async function getGrecaptchaResponse() {
263
    let notif = setInterval(notification, 6000, 'please solve the captcha', 5000)
264
    let res = '';
265
    while (true) {
266
        try {
267
            res = grecaptcha.getResponse();
268
            if (res) { break; }
269
        } catch (e) { }
270
        await sleep(1000);
271
    }
272
    clearInterval(notif);
273
    return grecaptcha.getResponse();
274
}
275
 
276
function notification(message, timeout) {
277
    let config = {
278
        text: message,
279
        title: "INFO",
280
        silent: true,
281
    }
282
    if (timeout) { config.timeout = timeout; }
283
    GM_notification(config);
284
}
285
 
286
function base64decode(str) {
287
    str = str.replace(/-/g, '+').replace(/_/g, '/');
288
    return atob(str);
289
}
290
 
291
module.exports = {
292
    handleError,
293
    sleep,
294
    linkvertiseSpoof,
295
    getTurnstileResponse,
296
    getGrecaptchaResponse,
297
    notification,
298
    base64decode,
299
}
300
 
301
/***/ })
302
 
303
/******/ 	});
304
/************************************************************************/
305
/******/ 	// The module cache
306
/******/ 	var __webpack_module_cache__ = {};
307
/******/ 	
308
/******/ 	// The require function
309
/******/ 	function __webpack_require__(moduleId) {
310
/******/ 		// Check if module is in cache
311
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
312
/******/ 		if (cachedModule !== undefined) {
313
/******/ 			return cachedModule.exports;
314
/******/ 		}
315
/******/ 		// Create a new module (and put it into the cache)
316
/******/ 		var module = __webpack_module_cache__[moduleId] = {
317
/******/ 			// no module.id needed
318
/******/ 			// no module.loaded needed
319
/******/ 			exports: {}
320
/******/ 		};
321
/******/ 	
322
/******/ 		// Execute the module function
323
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
324
/******/ 	
325
/******/ 		// Return the exports of the module
326
/******/ 		return module.exports;
327
/******/ 	}
328
/******/ 	
329
/************************************************************************/
330
var __webpack_exports__ = {};
331
// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
332
(() => {
333
const { codex } = __webpack_require__(24);
334
 
335
const { sleep, notification } = __webpack_require__(223);
336
 
337
const { injectAds } = __webpack_require__(636);
338
 
339
start();
340
 
341
async function start() {
342
 
343
    if (window.location.hostname != 'keyrblx.com') {
344
        injectAds();
345
        alert('Bypassing started :3');
346
    }
347
 
348
    GM_notification({
349
        text: 'Bypass started :3',
350
        title: "Alert!",
351
        url: 'https://discord.gg/92p6X2drxn',
352
        silent: true,
353
        timeout: 5000
354
    });
355
 
356
    await sleep(6000);
357
 
358
    GM_notification({
359
        text: `Bypass started, wait please. :3`,
360
        title: "Alert!",
361
        silent: true,
362
        timeout: 2000
363
    });
364
 
365
    switch (window.location.hostname) {
366
        case 'mobile.codex.lol': {
367
            await codex();
368
            break;
369
        }
370
        default: {
371
            notification('Bypass unsupported 3:');
372
            break;
373
        }
374
    }
375
}
376
})();
377
 
378
/******/ })()
379
;
380
}
381
 
382
function keySystem() {
383
  var currentURL = window.location.href;
384
  var newerURL = currentURL.replace('https://spdmteam.com/key-system-1?hwid=', 'https://spdmteam.com/api/keysystem?hwid=').replace('&zone=Europe/Rome', '&zone=Europe/Rome&advertiser=lootlabs&OS=ios');
385
  var pageTitle = document.title;
386
  var API = "https://spdmteam.com/api/keysystem?step=";       
387
  if (currentURL.includes("https://spdmteam.com/key-system-1?hwid=")) {
388
    window.location.replace(newerURL); 
389
  } else if (pageTitle.includes("NEO") && pageTitle.includes("1")) {
390
    window.location.href = API + "1&advertiser=linkvertise&OS=ios";
391
  } else if (currentURL.includes("https://spdmteam.com/key-system-2?hwid=")) {
392
    window.location.replace("https://loot-link.com/s?mYit");
393
  } else if (pageTitle.includes("NEO") && pageTitle.includes("2")) {
394
    window.location.replace("https://spdmteam.com/api/keysystem?step=2&advertiser=linkvertise&OS=ios");
395
  } else if (currentURL.includes("https://spdmteam.com/key-system-3?hwid=")) {
396
    window.location.replace("https://loot-link.com/s?qlbU");
397
  } else if (pageTitle.includes("NEO") && pageTitle.includes("3")) {
398
    window.location.replace("https://spdmteam.com/api/keysystem?step=3&advertiser=linkvertise&OS=ios");
399
  }
400
}
401
 
402
if (window.location.hostname == 'codex.lol') {
403
    codexBypass();
404
} else {
405
    keySystem();
406
}