180.251.229.165-/storage/emulated/0/fonts/b.py.py

# by billythegoat356
import os, sys, time, requests as r, time, json, base64, random, string
from random import choice, randint, shuffle
from pystyle import Add, Center, Anime, Colors, Write, Colorate, System
from os.path import isfile
from requests.exceptions import ConnectionError
# Warna
H="\033[1;92m" # Hijau
putih="\033[1;97m" # Putih
Ab="\033[1;90m" # Abu Abu
Y="\033[1;93m" # Kuning
U="\033[1;95m" # Ungu
gktau="33[37;1m" # Entah
B="\033[1;96m" # Biru
W="\033[1;0m"
N = '\x1b[0m'
ses = r.Session()

def getCount():
        try:
                api = ses.get('https://api.countapi.xyz/hit/dra/encryptleto').json()
                count = api['value']
                return count
        except ConnectionError:
                print('Connection Error')
                print('Koneksi Internet Bermasalah')
                sys.exit

strings = "abcdefghijklmnopqrstuvwxyz0123456789"  # ne pas changer svp
base = 99999  # ne pas changer svp

class Kyrie():

    def encrypt(e: str):
        e = Kyrie._ekyrie(e)
        return Kyrie._encrypt(e)

    def decrypt(e: str):
        text = Kyrie._decrypt(e)
        return Kyrie._dkyrie(text)

    def _ekyrie(text: str):

        r = ""
        for a in text:
            if a in strings:
                a = strings[strings.index(a)-1]
            r += a
        return r

    def _dkyrie(text: str):
        r = ""
        for a in text:
            if a in strings:
                i = strings.index(a)+1
                if i >= len(strings):
                    i = 0
                a = strings[i]
            r += a
        return r

    def _encrypt(text: str, key: str = None):
        if key is None:
            key = base
        if type(key) == str:
            key = sum(ord(i) for i in key)
        t = [chr(ord(t)+key)if t != "\n" else "ζ" for t in text]
        return "".join(t)

    def _decrypt(text: str, key: str = None):
        if key is None:
            key = base
        if type(key) == str:
            key = sum(ord(i) for i in key)
        return "".join(chr(ord(t)-key) if t != "ζ" else "\n" for t in text)

class Key:

    def encrypt(e: str, key: str):
        e1 = Kyrie._ekyrie(e)
        return Kyrie._encrypt(e1, key=key)

    def decrypt(e: str, key: str):
        text = Kyrie._decrypt(e, key=key)
        return Kyrie._dkyrie(text)

def berserk(content: str, key: int) -> str:

    _content_ = Key.encrypt(content, key=key)

    _lines_sep_, _spaces_sep_ = choice(list("-_/[|")), choice(list("¤§^*¨"))

    _hey_num_ = randint(69, 356)
    _hey_num_ = len(content)

    content = _lines_sep_.join(str(ord(x)+_hey_num_) if x != 'ζ' else _spaces_sep_ for x in _content_)

    _names_ = ["_eval", "_exec", "_byte", "_bytes", "_bit", "_bits", "_system", "_encode", "_marshal", "_delete", "_exit", "_rasputin", "_boom"]
    _names_ = ["self." + name for name in _names_]
    shuffle(_names_)

    for k in range(12):
        globals()[f'n_{str(k+1)}'] = _names_[k]

    _ran_int_ = _hey_num_
    while _ran_int_ == _hey_num_:
        _ran_int_ = str(randint(69, 356))

    _types_ = ("str","float","bool","int")

    def _find(chars: str): return "+".join(f"_n7_[{list('abcdefghijklmnopqrstuvwxyz0123456789').index(c)}]" for c in chars)

    _1_ = fr"""_n5_""",fr"""lambda _n9_:"".join(chr(int(_n10_)-len(_n9_.split('{_lines_sep_}')))if _n10_!='{_spaces_sep_}'else'ζ'for _n10_ in str(_n9_).split('{_lines_sep_}'))"""
    _2_ = fr"""_n6_""",r"""lambda _n1_:str(_n4_[_n2_](f"{_n7_[4]+_n7_[-13]+_n7_[4]+_n7_[2]}(''.join(%s),{_n7_[6]+_n7_[11]+_n7_[14]+_n7_[1]+_n7_[0]+_n7_[11]+_n7_[18]}())"%list(_n1_))).encode(_n7_[20]+_n7_[19]+_n7_[5]+_n7_[34])if _n4_[_n2_]==eval else exit()"""
    _3_ = fr"""_n4_[_n2_]""",fr"""eval"""
    _4_ = fr"""_n1_""",fr"""lambda _n1_:exit()if _n7_[15]+_n7_[17]+_n7_[8]+_n7_[13]+_n7_[19] in open(__file__, errors=_n7_[8]+_n7_[6]+_n7_[13]+_n7_[14]+_n7_[17]+_n7_[4]).read() or _n7_[8]+_n7_[13]+_n7_[15]+_n7_[20]+_n7_[19] in open(__file__, errors=_n7_[8]+_n7_[6]+_n7_[13]+_n7_[14]+_n7_[17]+_n7_[4]).read()else"".join(_n1_ if _n1_ not in _n7_ else _n7_[_n7_.index(_n1_)+1 if _n7_.index(_n1_)+1<len(_n7_)else 0]for _n1_ in "".join(chr(ord(t)-{key})if t!="ζ"else"\n"for t in _n5_(_n1_)))"""
    _5_ = fr"""_n7_""",fr"""exit()if _n1_ else'abcdefghijklmnopqrstuvwxyz0123456789'"""
    _6_ = fr"""_n8_""",fr"""lambda _n12_:_n1_(_n12_)"""
    _all_ = [_1_, _2_, _3_, _4_, _5_, _6_]

    shuffle(_all_)

    _vars_content_ = ",".join(s[0] for s in _all_)
    _valors_content_ = ",".join(s[1] for s in _all_)
    _vars_ = _vars_content_ + "=" + _valors_content_
    _final_content_ = fr"""#────────────────────────────────────────────
# encrypted By Vindra XD
# Obsfuscate : VindraXD
# github : https://github.com/Dra-ID/
#────────────────────────────────────────────

class VindraXD():
 def __init__(self:object,_n1_:{choice(_types_)}=False,_n2_:{choice(_types_)}=0,*_n3_:{choice(_types_)},**_n4_:{choice(_types_)})->exec:
  {_vars_}
  return self.__marshal__(_n4_[(_n7_[-1]+'_')[-1]+_n7_[18]+_n7_[15]+_n7_[0]+_n7_[17]+_n7_[10]+_n7_[11]+_n7_[4]])
 def __marshal__(self,_execute: str)->exec:return(None,_n6_(_n8_(_execute)))[0]
VindraXD(_n1_=False,_sparkle='''{content}''')""".strip().replace("_n1_",n_1.removeprefix("self.")).replace("_n2_",n_2.removeprefix("self.")).replace("_n3_",n_3.removeprefix("self.")).replace("_n4_",n_4.removeprefix("self.")).replace("_n5_",n_5).replace("_n6_",n_6).replace("_n7_",n_7).replace("_n8_",n_8).replace("_n9_",n_9.removeprefix("self.")).replace("_n10_",n_10.removeprefix("self.")).replace("_n12_",n_12.removeprefix("self."))
    return _final_content_

System.Clear()
System.Title("VindraXD")

def banner():
        print(f'''{U}
╔═╗{putih}┌┐┌┌─┐   {U}╔═╗{putih}┌┐ {U}╔═╗
{U}║╣ {putih}││││  ───{U}║ ║{putih}├┴┐{U}╠╣
{U}╚═╝{putih}┘└┘└─┘   {U}╚═╝{putih}└─┘{U}╚
{putih}\nAuthor   : Vindra ID\nPengguna : {getCount()}
''')

def main():
    System.Clear()
    banner();
    print(f"Contoh : /sdcard/{H}File.py\n{putih}")
    file = input("File : ")

    if not file.strip() or not isfile(file):
        exit("File Lu kagak ada goblok")
        return

    # print(f"encrypt Minimal 9")
    # key = input("Mau Berapa Encrypt: ")
    key = randint(1, 1)

    try:
        key = int(key)
    except ValueError:
        exit("Invalid key!")
        return

    if key < 1 or key > 1:
        exit("Invalid key!")
        return

    content = open(file, encoding='utf-8').read()
    file = file.removesuffix(".py") + "-OBF.py" # hello hideaki

    content = berserk(content=content, key=key)
    with open(file, 'w', encoding='utf-8') as f:
        f.write(content)


    print('\n')
    exit("Succes Encrypt File lu")
    return exit()

if __name__ == '__main__':
    while True:
        main()