TgTools

Vi presento TgTools, una raccolta di tools utili per Telegram in stile "offensive" grazie ai quali potete aumentare la vostra audience.
Premetto che fare scraping di utenti e trasferirli nel vostro gruppo è vietato dai termini di servizio di Telegram e ancora di più lo spam in privato di messaggi promozionali.
Vi consiglio di NON utilizzare il vostro account principale in quanto Telegram ha dei sistemi anti-spam che lo limitano per un tot di tempo, non permettendo più di inviare messaggi ad utenti al di fuori dei contatti.
Se avete il presentimento di essere limitati vi basta contattare "@SpamBot", lanciato il comando /start vi dovrà rispondere: "Good news, no limits are currently applied to your account. You’re free as a bird!"
Per risolvere il problema vi basta usare un VoIP (che offre un numero di telefono secondario), già menzionati qui.

I tools sono:

  • AddUserGroup.py: Permette di aggiungere membri a un gruppo Telegram da un file CSV contenente i membri. Gli utenti possono essere aggiunti tramite username o ID utente.
  • AddUsers.py: Simile al precedente ma permette di aggiungere membri utilizzando una struttura e una sintassi diverse. Chiede all'utente di selezionare il gruppo e il metodo di aggiunta (per username o ID utente).
  • WhoIsHere.py: Estrae i membri da un gruppo Telegram e li salva in un file CSV, quindi si seleziona il gruppo da cui si vuole estrarre i membri e vengono salvati in un file CSV.
  • spammer.py: Consente di inviare messaggi tramite file CSV, chiede all'utente il messaggio da inviare e invia il messaggio a ciascun contatto sfruttando l'API di Telegram.

Installazione:

Per installare i tools:

  • apt install git -y
  • git clone https://github.com/Samueleex/TgTools
  • cd TgTools
  • chmod +x * && python3 setup.py

Setup:

Per funzionare bisogna configurare il setup, apriamo Telegram Apps.
Dopo aver inserito il numero di telefono:

Ora digitando python3 nometool.py possiamo avviarli.

Codice:

AddUserGroup.py

from telethon.sync import TelegramClient
from telethon.tl.functions.messages import GetDialogsRequest
from telethon.tl.types import InputPeerEmpty, InputPeerChannel, InputPeerUser
from telethon.errors.rpcerrorlist import PeerFloodError, UserPrivacyRestrictedError
from telethon.tl.functions.channels import InviteToChannelRequest
import configparser
import csv
import traceback
import time
import random
import sys 

RED = "\033[1;31m"
GREEN = "\033[1;32m"
CYAN = "\033[1;36m"


def read_config():
    config = configparser.RawConfigParser()
    config.read('config.data')
    return config['cred']['id'], config['cred']['hash'], config['cred']['phone']

def initialize_telegram_client(api_id, api_hash, phone):
    client = TelegramClient(phone, api_id, api_hash)
    client.connect()
    if not client.is_user_authorized():
        client.send_code_request(phone)
        client.sign_in(phone, input(GREEN + '[+] Enter the sent code: ' + RED))
    return client

def read_users_from_csv(filename):
    users = []
    with open(filename, encoding='UTF-8') as file:
        reader = csv.reader(file, delimiter=",", lineterminator="\n")
        next(reader, None)
        for row in reader:
            user = {
                'username': row[0],
                'id': int(row[1]),
                'access_hash': int(row[2]),
                'name': row[3],
            }
            users.append(user)
    return users

def select_target_group(groups):
    print(GREEN + '[+] Scegli un gruppo per aggiungere memberi: ' + RED)
    for index, group in enumerate(groups):
        print(f"{index}- {group.title}")
    group_index = int(input(GREEN + "Numero: " + RED))
    return groups[group_index]

def select_add_member_mode():
    print(GREEN + "[1] Aggiungi membri da user ID\n[2] Membri da username ")
    return int(input(GREEN + "Input: " + RED))

def add_members_to_group(client, users, target_group, mode):
    target_entity = InputPeerChannel(target_group.id, target_group.access_hash)
    n = 0
    for user in users:
        n += 1
        if n % 50 == 0:
            time.sleep(900)
        try:
            print(f"Adding {user['id']}")
            if mode == 1:
                if not user['username']:
                    continue
                user_to_add = client.get_input_entity(user['username'])
            elif mode == 2:
                user_to_add = InputPeerUser(user['id'], user['access_hash'])
            else:
                sys.exit(RED + "[!] Invalid Mode Selected. Please Try Again.")  # Correzione: Aggiunta di sys.exit()
            client(InviteToChannelRequest(target_entity, [user_to_add]))
            print(GREEN + "[+] Waiting for 60-180 sec ...")
            time.sleep(random.randrange(60, 180))
        except PeerFloodError:
            print(RED + "[!] Errori da Telegram. \n[!] Lo script ha smesso di funzionare. \n[!] Riprova più tardi.")
        except UserPrivacyRestrictedError:
            print(RED + "[!] Conflitto con le impostazioni di privacy!")
        except Exception as e:
            traceback.print_exc()
            print(RED + "[!] errore ", e)
            continue

if __name__ == "__main__":
    api_id, api_hash, phone = read_config()
    telegram_client = initialize_telegram_client(api_id, api_hash, phone)
    input_file = input(GREEN + "Enter the CSV file name: " + RED)
    users = read_users_from_csv(input_file)
    dialogs = telegram_client(GetDialogsRequest(offset_date=None, offset_id=0, offset_peer=InputPeerEmpty(), limit=200, hash=0))
    groups = [dialog for dialog in dialogs.chats if hasattr(dialog, 'megagroup') and dialog.megagroup]
    target_group = select_target_group(groups)
    mode = select_add_member_mode()
    add_members_to_group(telegram_client, users, target_group, mode)

In questo tool sfrutto la libreria Telethon per interagire con l'API di Telegram e aggiungere membri a un gruppo.
Inizialmente si avvia una connessione al client utilizzando le credenziali precedentemente inserite nel setup. Se "l'utente" non è già autorizzato si richiede il codice di accesso e si autentifica.
Legge il file CSV (che contiene le info delle persone da aggiungere come username, ID e hash di accesso). Di seguito si ottiene una lista di gruppi a cui l'utente ha accesso e chiede all'utente di selezionare il gruppo a cui aggiungere i membri.
Il programma infine itera tutti i membri del file CSV.
Per eseguirlo python3 AddUserGroup.py <nomefile.csv>

AddUsers.py

import telethon.sync
import telethon.errors.rpcerrorlist
import telethon.tl.types
import telethon.tl.functions.messages
import telethon.tl.functions.channels
import configparser
import csv
import time
import random
import traceback
import sys

API_ID = ""  # ID API Telegram
API_HASH = ""  # hash API (32 caratteri)
PHONE_NUMBER = ""  # numero di telefono con il prefisso internazionale

def read_config():
    config = configparser.RawConfigParser()
    config.read('config.data')
    return config['cred']['id'], config['cred']['hash'], config['cred']['phone']

def initialize_telegram_client(api_id, api_hash, phone):
    client = telethon.sync.TelegramClient(phone, api_id, api_hash)
    client.connect()
    if not client.is_user_authorized():
        client.send_code_request(phone)
        client.sign_in(phone, input('Codice inviato: '))
    return client

def read_users_from_csv(filename):
    users = []
    with open(filename, encoding='UTF-8') as file:
        reader = csv.reader(file, delimiter=",", lineterminator="\n")
        next(reader, None)
        for row in reader:
            user = {
                'username': row[0],
                'id': int(row[1]),
                'access_hash': int(row[2]),
                'name': row[3],
            }
            users.append(user)
    return users

def select_target_group(groups):
    print('Scegli un gruppo: ')
    for index, group in enumerate(groups):
        print(f"{index}- {group.title}")
    group_index = int(input("Enter a Number: "))
    return groups[group_index]

def select_add_member_mode():
    print("[1] Aggiungi membri da user ID\n[2] Membri per username ")
    return int(input("Input: "))

if __name__ == "__main__":
    api_id, api_hash, phone = read_config()
    telegram_client = initialize_telegram_client(api_id, api_hash, phone)
    input_file = input("Enter the CSV file name: ")
    users = read_users_from_csv(input_file)
    dialogs = telegram_client(telethon.tl.functions.messages.GetDialogsRequest(offset_date=None, offset_id=0, offset_peer=telethon.tl.types.InputPeerEmpty(), limit=200, hash=0))
    groups = [dialog for dialog in dialogs.chats if hasattr(dialog, 'megagroup') and dialog.megagroup]
    target_group = select_target_group(groups)
    mode = select_add_member_mode()
    target_entity = telethon.tl.types.InputPeerChannel(target_group.id, target_group.access_hash)

    n = 0
    for user in users:
        n += 1
        if n % 80 == 0:
            time.sleep(60)
        try:
            print(f"Adding {user['id']}")
            if mode == 1:
                if not user['username']:
                    continue
                user_to_add = telegram_client.get_input_entity(user['username'])
            elif mode == 2:
                user_to_add = telethon.tl.types.InputPeerUser(user['id'], user['access_hash'])
            else:
                sys.exit("Scelta invalida!")
            telegram_client(telethon.tl.functions.channels.InviteToChannelRequest(target_entity, [user_to_add]))
            print("Waiting for 60-180 Seconds ...")
            time.sleep(random.randrange(0, 5))
        except telethon.errors.rpcerrorlist.PeerFloodError:
            print("Errori da Telegram. Lo script ha smesso di funzionare. Riprova più tardi.")
            time.sleep(100)
        except telethon.errors.rpcerrorlist.UserPrivacyRestrictedError:
            print("Conflitto con le impostazioni di privacy!")
            time.sleep(random.randrange(0, 5))
        except Exception as e:
            traceback.print_exc()
            print("Unexpected Error! ", e)
            continue

Inizialmente vengono prelevati l'API ID, l'API Hash e il numero di telefono dall'utente, di conseguenza viene inizializzato il client.
Viene letto il file CSV che contiene info sui membri da aggiungere e i dati vengono estratti e memorizzati in una lista di dizionari.
Simile a quello precedente, recupera i gruppi di chat a cui l'utente ha accesso e chiede di selezionare il gruppo di a cui aggiungere i membri e infine itera attraverso la lista dei membri e li aggiunge al gruppo selezionato gestendo anche diversi errori. Tra un'aggiunta di membro e l'altro il codice aspetta per un breve periodo di tempo per simulare un comportamento più naturale (questo non vi protegge da nulla, vi farà fare qualche membro in più prima di essere limitati).

WhoIsHere.py

import telethon.sync
import telethon.errors.rpcerrorlist
import telethon.tl.functions.messages
import telethon.tl.functions.channels
import configparser
import csv
import time

RED = "\033[1;31m"
GREEN = "\033[1;32m"
CYAN = "\033[1;36m"
YELLOW = "\033[1;33m"


def read_config():
    config = configparser.RawConfigParser()
    config.read('config.data')
    return config['cred']['id'], config['cred']['hash'], config['cred']['phone']

def initialize_telegram_client(api_id, api_hash, phone):
    client = telethon.sync.TelegramClient(phone, api_id, api_hash)
    client.connect()
    if not client.is_user_authorized():
        client.send_code_request(phone)
        client.sign_in(phone, input(GREEN + '[+] Codice di verifica appena inviato: ' + YELLOW))
    return client

def select_group_to_scrape(groups):
    print('Scegli un gruppo:')
    for index, group in enumerate(groups):
        print(f"[{index}] - {group.title}")
    group_index = int(input("Enter a Number: "))
    return groups[group_index]

if __name__ == "__main__":
    api_id, api_hash, phone = read_config()
    telegram_client = initialize_telegram_client(api_id, api_hash, phone)
    dialogs = telegram_client(telethon.tl.functions.messages.GetDialogsRequest(offset_date=None, offset_id=0, offset_peer=telethon.tl.types.InputPeerEmpty(), limit=200, hash=0))
    groups = [dialog for dialog in dialogs.chats if hasattr(dialog, 'megagroup') and dialog.megagroup]
    target_group = select_group_to_scrape(groups)

    print(GREEN + '[+] Fetching Members ...')
    time.sleep(1)
    all_participants = telegram_client.iter_participants(target_group)

    print(GREEN + '[+] Saving in file ...')
    time.sleep(1)
    with open("members.csv", "w", encoding='UTF-8') as f:
        writer = csv.writer(f, delimiter=",", lineterminator="\n")
        writer.writerow(['username', 'user id', 'access hash', 'name', 'group', 'group id'])
        for user in all_participants:
            username = user.username or ""
            first_name = user.first_name or ""
            last_name = user.last_name or ""
            name = (first_name + ' ' + last_name).strip()
            writer.writerow([username, user.id, user.access_hash, name, target_group.title, target_group.id])

    print(GREEN + '[+] Members scraped successfully!')

Vengono sempre importati i moduli necessari per il funzionamento, configparser per leggere i dettagli di configurazione e csv per i relativi file.
read_config() legge le credenziali (ID API, hash API e numero di telefono) da un file di configurazione denominato config.data.
initialize_telegram_client() inizializza un client tramite le credenziali fornite. select_group_to_scrape() chiede all'utente di selezionare un gruppo. Viene mostrata una lista di gruppi disponibili e l'utente sceglie selezionando il numero corrispondente. iter_participants() funzione richiamata per fare lo scrape vero e proprio degli utenti.
Tutti i dati verranno salvati in "members.csv" con le colonne: 'username', 'user id', 'access hash', 'name', 'group' e 'group id'.

spammer.py

import telethon.sync
import telethon.errors.rpcerrorlist
from telethon.tl.types import InputPeerUser
import configparser
import csv
import random
import time
import sys

RED = "\033[1;31m"
GREEN = "\033[1;32m"
CYAN = "\033[1;36m"
YELLOW = "\033[1;33m"
SLEEP_TIME = 30

class SMSBot:

    def __init__(self):
        self.api_id, self.api_hash, self.phone = self.read_config()
        self.client = self.initialize_telegram_client()

    def read_config(self):
        config = configparser.RawConfigParser()
        config.read('config.data')
        return config['cred']['id'], config['cred']['hash'], config['cred']['phone']

    def initialize_telegram_client(self):
        client = telethon.sync.TelegramClient(self.phone, self.api_id, self.api_hash)
        client.connect()
        if not client.is_user_authorized():
            client.send_code_request(self.phone)
            client.sign_in(self.phone, input(GREEN + '[+] Codice di verifica appena inviato: ' + YELLOW))
        return client

    def send_sms(self, input_file):
        users = self.read_users_from_csv(input_file)
        mode, message = self.get_user_input_for_sms()
        self.send_messages(users, mode, message)

    def read_users_from_csv(self, input_file):
        users = []
        with open(input_file, encoding='UTF-8') as f:
            rows = csv.reader(f, delimiter=",", lineterminator="\n")
            next(rows, None)
            for row in rows:
                user = {
                    'username': row[0],
                    'id': int(row[1]),
                    'access_hash': int(row[2]),
                    'name': row[3],
                }
                users.append(user)
        return users

    def get_user_input_for_sms(self):
        print(GREEN + "[1] Manda SMS da user ID\n[2] Manda username")
        mode = int(input(GREEN + "Input: " + RED))
        message = input(GREEN + "[+] Messaggio: " + YELLOW)
        return mode, message

    def send_messages(self, users, mode, message):
        for user in users:
            try:
                receiver = self.get_receiver(mode, user)
                print(GREEN + "[+] Sending Message to:", user['name'])
                self.client.send_message(receiver, message.format(user['name']))
                print(GREEN + "[+] Waiting {} seconds".format(SLEEP_TIME))
                time.sleep(SLEEP_TIME)
            except telethon.errors.rpcerrorlist.PeerFloodError:
                print(RED + "[!] Errori da Telegram. \n[!] Lo script ha smesso di funzionare. \n[!] Riprova più tardi.")
                break
            except Exception as e:
                print(RED + "[!] Errore:", e)
                print(RED + "[!] Sto riprovando ...")
                continue

    def get_receiver(self, mode, user):
        if mode == 1:
            return InputPeerUser(user['id'], user['access_hash'])
        elif mode == 2:
            if user['username']:
                return self.client.get_input_entity(user['username'])
            else:
                raise ValueError("Username non fornito")
        else:
            raise ValueError("Scelta invalida")


if __name__ == "__main__":
    sms_bot = SMSBot()
    input_file = sys.argv[1]
    sms_bot.send_sms(input_file)

Inizialmente viene richiamato telethon.sync per sincronizzare l'API, import telethon.errors.rpcerrorlist per gli elenchi di errori RPC, from telethon.tl.types import InputPeerUser che rappresenta un peer utente.
La classe principale è SMSBot che ha __init__ per connettere il client, read_config per fare un check dei file di configurazione, initialize_telegram_client dai file appena letti, get_receiver ottiene il destinatario in base all'opzione fornita.
Nell'esecuzione principale si verifica __name__ == "__main__" (programma principale).

setup.py

import os, sys
import configparser
re="\033[1;31m"
gr="\033[1;32m"
cy="\033[1;36m"
print(gr+"[+] Installing requierments ...")
os.system('python3 -m pip install telethon')
os.system('pip3 install telethon')
os.system("touch config.data")
cpass = configparser.RawConfigParser()
cpass.add_section('cred')
xid = input(gr+"[+] Enter API ID : "+re)
cpass.set('cred', 'id', xid)
xhash = input(gr+"[+] Enter Hash : "+re)
cpass.set('cred', 'hash', xhash)
xphone = input(gr+"[+] Enter Phone Number: "+re)
cpass.set('cred', 'phone', xphone)
with open('config.data', 'w') as setup:
	cpass.write(setup)
print(gr+"[+] Setup completato!")
print(gr+"[+] Ora puoi avviare tutti i tools presenti")
print(gr+"[+] Leggi la spiegazione del codice su EHF prima di usare i tools!")
print(gr+"[+] https://github.com/Samueleex/TgTools")

Qui nel setup vengono richiesti i dati dell'app creata dal sito di Telegram in modo da usarli per gli altri tools.

Potete trovare il codice sulla repo GitHub!

Guida diffusa a scopo informativo!

    8 giorni dopo

    Samueleex grazie mille. Fatto molto bene e semplice da usare.
    Sarebbe interessante creare anche un report tool per segnalare i vari gruppi o canali. Come questo: https://github.com/velarhibelean/TikTok-Analystics-Tool?tab=readme-ov-file (per me palesemente scam e fake quindi evitate di acquistare e spendere denaro. Però sarebbe interessante provare a ricreare quello descritto e mostrato nel canale di tg per davvero) che segnala automaticamente e , magari, riesce ad utilizzare proxy ed account già presenti in modo automatico (non so se ,effettivamente, possibile).
    Ho testato questo gratuito: https://github.com/esfelurm/Reporter-Telegram . Molto curioso anche se abbastanza inutile perché anche se magari fa( posso solo presumere) quello che promette...ha poco senso perché alla fine le segnalazioni che manderebbe verrebbero solo dallo stesso account che ha sempre lo stesso IP ecc. Quindi mandarne anche milioni (che provengono dallo stesso account) non avrebbe senso. Infatti poi i gruppi o canali segnalati non vengono moderati e chiusi. Conosco persone che usano tools per segnalare gruppi per poi chiuderli ma è difficile testare quelli online perché la maggior parte sono potenziali scam a pagamento.
    Per il resto questi tools che hai portato sono già molto interessanti. Molti li offrono a pagamento quindi grazie.

    21 giorni dopo

    Samueleex cmq se su l account abbiamo la verifica a due fattori non si può usare giusto? Non c'è un modo per inserire la password

      Kindy Si può implementare con una piccola modifica al setup:

      import os
      import configparser
      re="\033[1;31m"
      gr="\033[1;32m"
      cy="\033[1;36m"
      print(gr+"[+] Installing requirements ...")
      os.system('python3 -m pip install telethon')
      os.system('pip3 install telethon')
      os.system("touch config.data")
      cpass = configparser.RawConfigParser()
      cpass.add_section('cred')
      xid = input(gr+"[+] Enter API ID : "+re)
      cpass.set('cred', 'id', xid)
      xhash = input(gr+"[+] Enter Hash : "+re)
      cpass.set('cred', 'hash', xhash)
      xphone = input(gr+"[+] Enter Phone Number: "+re)
      cpass.set('cred', 'phone', xphone)
      
      # verifica a 2 fattori
      try:
          xpass = input(gr+"[+] Password (if two-factor auth is enabled): "+re)
          cpass.set('cred', 'password', xpass)
      except KeyboardInterrupt:
          print("\n"+re+"[!] User Interrupted!")
          sys.exit()
      
      with open('config.data', 'w') as setup:
          cpass.write(setup)
      print(gr+"[+] Setup completato!")
      print(gr+"[+] Ora puoi avviare tutti i tools presenti")
      print(gr+"[+] Leggi la spiegazione del codice su EHF prima di usare i tools!")
      print(gr+"[+] https://github.com/Samueleex/TgTools")
      4 mesi dopo

      Ogni volta che il bot si connette all'account, viene bannato. Qualcuno ha mai riscontrato questo problema? Avete possibili soluzioni?

        TakeMe Come da disclaimer:

        Vi consiglio di NON utilizzare il vostro account principale in quanto Telegram ha dei sistemi anti-spam che lo limitano per un tot di tempo, non permettendo più di inviare messaggi ad utenti al di fuori dei contatti.
        Se avete il presentimento di essere limitati vi basta contattare "@SpamBot", lanciato il comando /start vi dovrà rispondere: "Good news, no limits are currently applied to your account. You’re free as a bird!"
        Per risolvere il problema vi basta usare un VoIP (che offre un numero di telefono secondario), già menzionati qui.

        Questo tool (come si può notare dal video), l'ho usato senza problemi sul mio account principale solo per lo scraping di gruppi. Nell'aggiunta di persone da un gruppo all'altro se esagerata si riceve una limitazione. In questo caso, almeno per le prime volte Telegram limita ma non banna.
        Se hai usato un VoIP la situazione potrebbe cambiare perché Telegram molto probabilmente ne è consapevole.

          Samueleex Quindi pensi che la problematica sia dovuta all'utilizzo di un VoIP?

          TakeMe che numero è? Un +1?
          Se hai premium è meglio. Non usare numeri di paesi che terminano con -stan. Metti la protezione a 2 fattori e l'account deve avere un po' di "aura". Quindi meglio se vecchio e tieni gruppi a caso attivi dentro.

          Samueleex cmq sarebbe interessante un tool con altre funzioni "simili" per lo spam. Tipo spam inline con ubot o spam con forward quindi inoltrando messaggi da un canale ad esempio ad un elenco preciso di utenti dopo lo scraping. Perché solitamente il send normale fa limitare subito l'account e non riesci a spammare tanto

          Powered by: FreeFlarum.
          (remove this footer)