feat(utils): rewrite session generate utility

Author: Morb0

types/mtproto__core/index.d.ts

@@ -18,7 +18,7 @@ declare module '@mtproto/core' {
 
     call(
       method: string,
-      params: Record<string, any>,
+      params?: Record<string, any>,
       options?: {
         dcId?: number;
         syncAuth?: boolean;
@@ -27,6 +27,8 @@ declare module '@mtproto/core' {
 
     setDefaultDc(dcId: number): Promise<string>;
 
+    updateInitConnectionParams(params: Record<string, any>): void;
+
     updates: {
       // eslint-disable-next-line @typescript-eslint/ban-types
       on(updateName: string, handler: Function): void;

utils/generate-mtproto-session.util.ts

@@ -1,14 +1,16 @@
-import { MTProto } from '@mtproto/core';
-import dotenv from 'dotenv';
-dotenv.config();
+import * as MTProto from '@mtproto/core';
+import * as fs from 'fs';
+import { stdin as input, stdout as output } from 'process';
+import * as readline from 'readline';
 
-const PHONE = '';
-const CODE = '';
+const rl = readline.createInterface({ input, output });
+const API_ID = '';
+const API_HASH = '';
 
 const store: Record<string, string> = {};
 const api = new MTProto({
-  api_id: Number(process.env.TELEGRAM_API_ID!),
-  api_hash: process.env.TELEGRAM_API_HASH!,
+  api_id: Number(API_ID),
+  api_hash: API_HASH,
   storageOptions: {
     instance: {
       get: async (key: string) => store[key],
@@ -19,44 +21,76 @@ const api = new MTProto({
   },
 });
 
+api.updateInitConnectionParams({
+  platform: 'Web',
+  system_version: '1.1.1',
+  device_model: 'tgbucket',
+  app_name: 'TGBucket',
+  app_version: '1.1.1',
+});
+
 (async () => {
-  const user = await getUser();
-  console.log('currentUser', user);
+  try {
+    await createSession();
+    process.exit(0);
+  } catch (e) {
+    console.error('Failed to create session', e);
+    process.exit(1);
+  }
+})();
 
-  if (!user) {
-    try {
-      const { phone_code_hash } = await sendCode(PHONE);
+/* Core */
+async function createSession(): Promise<void> {
+  try {
+    await logIn();
+  } catch (e: any) {
+    if (e.error_message === 'SESSION_PASSWORD_NEEDED') {
+      console.log('Account have enabled 2FA');
+      await logIn2FA();
+      return;
+    }
 
-      const signInResult = await signIn(CODE, PHONE, phone_code_hash);
+    throw e;
+  }
+}
 
-      console.log('result', signInResult);
-      console.log('session', JSON.stringify(store));
-    } catch (err: any) {
-      if (err.error_message !== 'SESSION_PASSWORD_NEEDED') {
-        console.log(`error:`, err);
+async function logIn(): Promise<void> {
+  const phone = await prompt('Phone (without +):');
+  console.log('phone', phone, phone.length);
+  const { phone_code_hash } = await sendCode(phone);
 
-        return;
-      }
+  const code = await prompt('Code:');
+  const signInResult = await signIn(code, phone, phone_code_hash);
 
-      console.error('2FA is set');
-    }
-  }
-})();
+  console.debug('signInResult', signInResult);
+  saveSessions();
+}
 
-async function getUser() {
-  try {
-    const user = await api.call('users.getFullUser', {
-      id: {
-        _: 'inputUserSelf',
-      },
-    });
+async function logIn2FA(): Promise<void> {
+  const password = await prompt('Password:');
+  const { srp_id, current_algo, srp_B } = await getPassword();
+  const { g, p, salt1, salt2 } = current_algo;
+  const { A, M1 } = await (api as any).crypto.getSRPParams({
+    g,
+    p,
+    salt1,
+    salt2,
+    gB: srp_B,
+    password,
+  });
 
-    return user;
-  } catch (error) {
-    return null;
-  }
+  const checkPasswordResult = await checkPassword(srp_id, A, M1);
+  console.debug('checkPasswordResult', checkPasswordResult);
+  saveSessions();
 }
 
+function saveSessions(): void {
+  const session = JSON.stringify(store);
+  console.log('Session created:', session);
+  fs.writeFileSync('./session.json', session);
+}
+
+/* MTProto */
 function sendCode(phone: string) {
   return api.call('auth.sendCode', {
     phone_number: phone,
@@ -73,3 +107,25 @@ function signIn(code: string, phone: string, phoneCodeHash: string) {
     phone_code_hash: phoneCodeHash,
   });
 }
+
+function getPassword() {
+  return api.call('account.getPassword');
+}
+
+function checkPassword(srpId: string, A: string, M1: string) {
+  return api.call('auth.checkPassword', {
+    password: {
+      _: 'inputCheckPasswordSRP',
+      srp_id: srpId,
+      A,
+      M1,
+    },
+  });
+}
+
+/* Utils */
+function prompt(text: string): Promise<string> {
+  return new Promise<string>((resolve) => {
+    rl.question(text + ' ', (input) => resolve(input));
+  });
+}