- Modificato
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!