mirror of
https://git.stupid.fish/teidesu/scripts.git
synced 2025-10-12 15:51:23 +11:00
365 lines
10 KiB
TypeScript
365 lines
10 KiB
TypeScript
import type { Browser } from 'patchright'
|
|
import type { EmailVerificationProvider } from '../../utils/temkakit/email-verification.ts'
|
|
import { writeFile } from 'node:fs/promises'
|
|
import { faker } from '@faker-js/faker'
|
|
import { sleep } from '@fuman/utils'
|
|
import { load } from 'cheerio'
|
|
import { Cookie, CookieJar } from 'tough-cookie'
|
|
import { ffetch as ffetchBase } from '../../utils/fetch.ts'
|
|
import { AnymessageEmailVerificationProvider } from '../../utils/temkakit/anymessage.ts'
|
|
import { solveKasadaSalamoonder } from '../../utils/temkakit/kasada-solver.ts'
|
|
import { createLibcurlFetch } from '../../utils/temkakit/libcurl.ts'
|
|
|
|
// half broken, unfinished
|
|
|
|
function getProxy() {
|
|
// return {
|
|
// user: 'JaTjXK',
|
|
// pass: 'WYsU4C',
|
|
// host: '38.152.247.16',
|
|
// port: 9785,
|
|
// }
|
|
return {
|
|
user: '',
|
|
pass: '',
|
|
host: '127.0.0.1',
|
|
port: 7891,
|
|
}
|
|
}
|
|
|
|
function proxyToUrl(proxy: { user: string, pass: string, host: string, port: number }) {
|
|
return `http://${proxy.user}:${proxy.pass}@${proxy.host}:${proxy.port}`
|
|
}
|
|
|
|
const THREADS = 1
|
|
const ACCOUNTS_COUNT = 2
|
|
|
|
const TWITCH_PJS = 'https://k.twitchcdn.net/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/p.js'
|
|
|
|
async function twitchAutoreg(options: {
|
|
// browser: Browser
|
|
emailProvider: EmailVerificationProvider
|
|
log?: (format: string, ...args: any[]) => void
|
|
proxy?: string
|
|
}) {
|
|
const {
|
|
// browser,
|
|
proxy,
|
|
emailProvider,
|
|
log = (fmt, ...args) => console.log(fmt, ...args),
|
|
} = options
|
|
const jar = new CookieJar()
|
|
|
|
log('proxy', proxy)
|
|
const ffetch = ffetchBase.extend({
|
|
cookies: jar,
|
|
fetch: createLibcurlFetch({ proxy }),
|
|
})
|
|
|
|
log('fetching main page')
|
|
const mainPage = await ffetch('https://www.twitch.tv/').text()
|
|
const twilightBuildId = mainPage.match(/window.__twilightBuildID="([^"]+)"/)?.[1]
|
|
if (!twilightBuildId) {
|
|
throw new Error('failed to get twilightBuildId')
|
|
}
|
|
|
|
await jar.setCookie(new Cookie({
|
|
key: 'api_token',
|
|
value: `twilight.${faker.string.hexadecimal({ length: 32 })}`,
|
|
domain: 'twitch.tv',
|
|
path: '/',
|
|
secure: true,
|
|
sameSite: 'None',
|
|
hostOnly: false,
|
|
expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
|
|
}), 'https://www.twitch.tv')
|
|
await jar.setCookie(new Cookie({
|
|
key: 'experiment_overrides',
|
|
value: encodeURIComponent(JSON.stringify({ experiments: {}, disabled: [] })),
|
|
domain: 'twitch.tv',
|
|
path: '/',
|
|
secure: true,
|
|
sameSite: 'None',
|
|
hostOnly: false,
|
|
expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
|
|
}), 'https://www.twitch.tv')
|
|
|
|
const deviceId = faker.string.alphanumeric({ length: 32 })
|
|
const sessionId = faker.string.hexadecimal({ length: 16 })
|
|
|
|
log('generating integrity token')
|
|
|
|
// const kasadaSolver = await createKasadaSolver({
|
|
// pageUrl: 'https://www.twitch.tv/',
|
|
// scriptUrl: '',
|
|
// browser,
|
|
// beforePageLoad: async (page) => {
|
|
// await syncCookiesIntoBrowser(jar, page.context())
|
|
// },
|
|
// requests: [
|
|
// {
|
|
// protocol: 'https',
|
|
// method: 'POST',
|
|
// domain: 'gql.twitch.tv',
|
|
// path: '/integrity',
|
|
// },
|
|
// {
|
|
// protocol: 'https',
|
|
// method: 'POST',
|
|
// domain: 'passport.twitch.tv',
|
|
// path: '/integrity',
|
|
// },
|
|
// {
|
|
// protocol: 'https',
|
|
// method: 'POST',
|
|
// domain: 'passport.twitch.tv',
|
|
// path: '/protected_register',
|
|
// },
|
|
// {
|
|
// protocol: 'https',
|
|
// method: 'POST',
|
|
// domain: 'passport.twitch.tv',
|
|
// path: '/protected_login',
|
|
// },
|
|
// ],
|
|
// })
|
|
|
|
const commonHeaders: Record<string, string> = {
|
|
'X-Device-Id': deviceId,
|
|
'Client-Id': 'kimne78kx3ncx6brgo4mv6wki5h1ko',
|
|
'Client-Request-Id': faker.string.alphanumeric({ length: 32 }),
|
|
'Client-Session-Id': sessionId,
|
|
'Client-Version': twilightBuildId,
|
|
}
|
|
|
|
const kasadaSolution = await solveKasadaSalamoonder({ pjs: TWITCH_PJS })
|
|
// const integrityToken = await kasadaSolver.request({
|
|
// url: 'https://gql.twitch.tv/integrity',
|
|
// method: 'POST',
|
|
// headers: commonHeaders,
|
|
// }) as { token: string }
|
|
const integrityToken = await ffetch('https://gql.twitch.tv/integrity', {
|
|
method: 'POST',
|
|
headers: {
|
|
...commonHeaders,
|
|
...kasadaSolution,
|
|
},
|
|
}).json() as { token: string }
|
|
|
|
const ffetchGql = ffetchBase.extend({
|
|
headers: {
|
|
'Sec-Fetch-Dest': 'empty',
|
|
'Sec-Fetch-Mode': 'cors',
|
|
'Sec-Fetch-Site': 'same-site',
|
|
...commonHeaders,
|
|
'Client-Integrity': integrityToken.token,
|
|
},
|
|
})
|
|
|
|
// await syncCookiesFromBrowser(kasadaSolver.page.context(), jar)
|
|
|
|
let username
|
|
while (true) {
|
|
username = faker.internet.username().toLowerCase().replace(/[^a-z0-9]/gi, '')
|
|
log('checking username', username)
|
|
const r = await ffetchGql.post('https://gql.twitch.tv/gql', {
|
|
json: [
|
|
{
|
|
operationName: 'UsernameValidator_User',
|
|
variables: { username },
|
|
extensions: {
|
|
persistedQuery: {
|
|
version: 1,
|
|
sha256Hash: 'fd1085cf8350e309b725cf8ca91cd90cac03909a3edeeedbd0872ac912f3d660',
|
|
},
|
|
},
|
|
},
|
|
],
|
|
}).json() as any
|
|
|
|
if (r[0].errors) {
|
|
throw new Error(`failed to check username:${JSON.stringify(r[0].errors)}`)
|
|
}
|
|
|
|
if (r[0].data.isUsernameAvailable) {
|
|
log('username is available: %s', username)
|
|
break
|
|
}
|
|
|
|
await sleep(1000)
|
|
}
|
|
|
|
log('ordering email')
|
|
|
|
const email = await emailProvider.getEmail()
|
|
|
|
log('got email: %s, registering', email)
|
|
|
|
const password = faker.internet.password({ length: 16, pattern: /[a-z0-9]/ })
|
|
const birthday = faker.date.birthdate({ min: 18, max: 25, mode: 'age' })
|
|
const registerBody: Record<string, any> = {
|
|
username,
|
|
password,
|
|
email,
|
|
birthday: {
|
|
day: birthday.getDate(),
|
|
month: birthday.getMonth() + 1,
|
|
year: birthday.getFullYear(),
|
|
isOver18: true,
|
|
},
|
|
email_marketing_opt_in: false,
|
|
client_id: 'kimne78kx3ncx6brgo4mv6wki5h1ko',
|
|
is_password_guide: 'nist',
|
|
}
|
|
|
|
for (let i = 0; i < 5; i++) {
|
|
// const r1 = await kasadaSolver.request({
|
|
// url: 'https://passport.twitch.tv/protected_register',
|
|
// method: 'POST',
|
|
// body: JSON.stringify(registerBody),
|
|
// headers: {
|
|
// 'Content-Type': 'text/plain;charset=UTF-8',
|
|
// 'Accept': '*/*',
|
|
// },
|
|
// credentials: 'include',
|
|
// }) as { error_code: number }
|
|
log('solving kasada')
|
|
const kasadaSolution = await solveKasadaSalamoonder({ pjs: TWITCH_PJS })
|
|
const r1 = await ffetch.post('https://passport.twitch.tv/protected_register', {
|
|
validateResponse: false,
|
|
json: registerBody,
|
|
headers: {
|
|
...kasadaSolution,
|
|
},
|
|
}).json() as { error_code: number }
|
|
|
|
log('r1', r1)
|
|
|
|
if (i < 4 && r1.error_code === 5025) {
|
|
log('integrity failed, retrying...')
|
|
continue
|
|
}
|
|
|
|
if (r1.error_code !== 2026) {
|
|
await emailProvider.dispose()
|
|
throw new Error(`failed to register: ${JSON.stringify(r1)}`)
|
|
}
|
|
|
|
break
|
|
}
|
|
|
|
log('waiting for code')
|
|
const message = await emailProvider.waitForMessage({ timeout: 90_000 })
|
|
const message$ = load(message)
|
|
const code = message$('center p[style^=background]').text() // what the fuck is this selector
|
|
// const code = await question('code: ')
|
|
|
|
if (!code.match(/^\d{6}$/)) {
|
|
log('❌ invalid code parsed: %s', code)
|
|
log(message)
|
|
await emailProvider.dispose()
|
|
throw new Error(`invalid code parsed:${code}`)
|
|
}
|
|
|
|
log('code: %s', code)
|
|
|
|
registerBody.email_verification_code = code
|
|
for (let i = 0; i < 5; i++) {
|
|
// const r2 = await kasadaSolver.request({
|
|
// url: 'https://passport.twitch.tv/protected_register',
|
|
// method: 'POST',
|
|
// body: JSON.stringify(registerBody),
|
|
// headers: {
|
|
// 'Content-Type': 'text/plain;charset=UTF-8',
|
|
// },
|
|
// credentials: 'include',
|
|
// }) as { error_code: number }
|
|
log('solving kasada')
|
|
const kasadaSolution = await solveKasadaSalamoonder({ pjs: TWITCH_PJS })
|
|
const r2 = await ffetch.post('https://passport.twitch.tv/protected_register', {
|
|
json: registerBody,
|
|
validateResponse: false,
|
|
headers: {
|
|
...kasadaSolution,
|
|
},
|
|
}).json() as { error_code: number }
|
|
|
|
if (i < 4 && r2.error_code === 5025) {
|
|
log('integrity failed, retrying...')
|
|
continue
|
|
}
|
|
|
|
if (r2.error_code) {
|
|
await emailProvider.dispose()
|
|
throw new Error(`❌ failed to register:${r2.error_code}`)
|
|
}
|
|
|
|
break
|
|
}
|
|
|
|
// await syncCookiesFromBrowser(kasadaSolver.page.context(), jar)
|
|
|
|
log('авторег работает!')
|
|
await emailProvider.dispose()
|
|
|
|
return {
|
|
username,
|
|
password,
|
|
email,
|
|
cookies: await jar.store.getAllCookies(),
|
|
}
|
|
}
|
|
|
|
let started = 0
|
|
let completed = 0
|
|
await Promise.all(Array.from({ length: THREADS }).map(async (_, idx) => {
|
|
const emailProvider = new AnymessageEmailVerificationProvider({
|
|
site: 'twitch.tv',
|
|
domain: 'hotmail.com',
|
|
})
|
|
|
|
let browser: Browser | null = null
|
|
while (true) {
|
|
if (started >= ACCOUNTS_COUNT) {
|
|
break
|
|
}
|
|
|
|
started++
|
|
|
|
const log = (fmt: string, ...args: any[]) => console.log(`[worker ${idx}] ${fmt}`, ...args)
|
|
|
|
try {
|
|
const proxy = getProxy()
|
|
|
|
// browser = await chromium.launch({
|
|
// channel: 'chrome',
|
|
// headless: false,
|
|
// env: {
|
|
// TZ: 'Europe/Amsterdam',
|
|
// },
|
|
// proxy: {
|
|
// server: `http://${proxy.host}:${proxy.port}`,
|
|
// username: proxy.user,
|
|
// password: proxy.pass,
|
|
// },
|
|
// })
|
|
|
|
const acct = await twitchAutoreg({
|
|
// browser,
|
|
proxy: proxyToUrl(proxy),
|
|
emailProvider,
|
|
log,
|
|
})
|
|
|
|
await writeFile('assets/twitch-accs.txt', `${JSON.stringify(acct)}\n`, { flag: 'a' })
|
|
|
|
completed++
|
|
log('completed: %d/%d', completed, ACCOUNTS_COUNT)
|
|
} catch (e) {
|
|
log('autoreg error: %s', e)
|
|
// await browser?.close()
|
|
browser = null
|
|
started--
|
|
}
|
|
}
|
|
}))
|