ShadowB 0.1__py3-none-any.whl

ShadowB/Mail/make_mail.py

@@ -0,0 +1,36 @@
+try:
+    import requests
+except:
+    import os
+    os.system("pip install requests")
+    import requests
+
+import random
+import string
+import time
+
+BASE_URL = "https://api.mail.tm"
+
+def random_string(length=10):
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
+
+def create_temp_email():
+    domains_resp = requests.get(f"{BASE_URL}/domains")
+    domains_resp.raise_for_status()
+    domain = domains_resp.json()["hydra:member"][0]["domain"]
+    username = random_string()
+    password = random_string(14)
+    address = f"{username}@{domain}"
+    create_resp = requests.post(
+        f"{BASE_URL}/accounts",
+        json={"address": address, "password": password},
+    )
+    create_resp.raise_for_status()
+    token_resp = requests.post(
+        f"{BASE_URL}/token",
+        json={"address": address, "password": password},
+    )
+    token_resp.raise_for_status()
+    token = token_resp.json()["token"]
+    return (address,password,token)

ShadowB/Mail/res_msj.py

@@ -0,0 +1,44 @@
+try:
+    import requests
+except:
+    import os
+    os.system("pip install requests")
+    import requests
+
+import random
+import string
+import time
+
+BASE_URL = "https://api.mail.tm"
+
+def get_messages(token):
+    headers = {"Authorization": f"Bearer {token}"}
+    resp = requests.get(f"{BASE_URL}/messages", headers=headers)
+    resp.raise_for_status()
+    return resp.json()["hydra:member"]
+
+
+def get_message_details(token, message_id):
+    headers = {"Authorization": f"Bearer {token}"}
+    resp = requests.get(f"{BASE_URL}/messages/{message_id}", headers=headers)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def print_messages_separately(token):
+    messages = get_messages(token)
+    if not messages:
+        print("None")
+        return
+
+    for i, msg in enumerate(messages, start=1):
+        sender = msg["from"]["address"]
+        date = msg["createdAt"]
+        subject = msg["subject"]
+
+        print("=" * 50)
+        print(f"msj #{i}")
+        print(f"from        : {sender}")
+        print(f"date   : {date}")
+        print(f"subject   : {subject}")
+        print("=" * 50)

ShadowB/Mail/send_msj.py

@@ -0,0 +1,13 @@
+import smtplib
+from email.mime.text import MIMEText
+ 
+ 
+def send_email(sender, app_password, to, subject, body):
+    msg = MIMEText(body)
+    msg["Subject"] = subject
+    msg["From"] = sender
+    msg["To"] = to
+ 
+    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
+        server.login(sender, app_password)
+        server.send_message(msg)

ShadowB/Qrcode/generate.py

@@ -0,0 +1,35 @@
+import sys
+import os
+
+try:
+    import qrcode
+except ImportError:
+    os.system(f"{sys.executable} -m pip install qrcode[pil]")
+    import qrcode
+        
+   
+
+def qrcode(text, name="qrcode"):
+    output_filename = f"{name}.png"
+    try:
+        qr = qrcode.QRCode(
+            version=1, 
+            error_correction=qrcode.constants.ERROR_CORRECT_L, 
+            box_size=10, 
+            border=4, 
+        )
+        
+        
+        qr.add_data(text)
+        qr.make(fit=True)
+        
+       
+        img = qr.make_image(fill_color="black", back_color="white")
+        
+       
+        img.save(output_filename)
+        
+        print(f"[+] QRCode was generated successfully : '{output_filename}'")
+        
+    except Exception as e:
+        print(f"[-]  Error : {e}")

ShadowB/Qrcode/scan.py

@@ -0,0 +1,26 @@
+import sys
+import os
+
+try:
+    import cv2
+except ImportError:
+    os.system(f"{sys.executable} -m pip install opencv-python")
+    import cv2
+
+
+def scan(qrcode_path):
+    if not os.path.exists(qrcode_path):
+        return None
+
+    try:
+        img = cv2.imread(qrcode_path)
+        detector = cv2.QRCodeDetector()
+        data, bbox, _ = detector.detectAndDecode(img)
+        
+        if bbox is not None and data:
+            return data
+        else:
+            return None
+            
+    except Exception:
+        return None

ShadowB/Safe/clean.py

@@ -0,0 +1,127 @@
+import os
+import re
+
+try:
+    from pypdf import PdfReader
+except:
+    import os
+    os.system("pip install pypdf")
+    from pypdf import PdfReader
+    
+try:
+    from better_profanity import profanity
+except ImportError:
+    import os
+    os.system("pip install better_profanity")
+    from better_profanity import profanity
+
+custom_bad_words = ["irheb","de3ch","israil","اسرائيل","trump","ارهاب","إرهاب","zab", "zebi", "asba","3asba","nyk","nayek","nik","nik omk","3asba lik","mnayek","fuck","shit","fuck you","fuck u","nik omo","t7chi fih","yatek asba","yatek 3asba","ya3tek 3asba","zok","omk","kiss","زبي","عصب","نيك","امك","برا نيك","يعطك عصبة","عصبة"]
+
+def normalize(text):
+    text = text.lower()
+    text = re.sub(r'[^a-zA-Z0-9\u0600-\u06FF]', '', text)
+    return text
+
+
+
+
+
+def pdf_to_txt(file):
+    try:
+        if not file.lower().endswith(".pdf"):
+            raise ValueError("Currently, the accepted files are .pdf and .txt")
+
+        reader = PdfReader(file)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text() or ""
+
+        return text
+
+    except Exception as e:
+        print(e)
+        return "error"
+    
+    
+    
+def txt_to_text(file):
+    try:
+        if not file.lower().endswith(".txt"):
+            raise ValueError("Currently, the accepted files are .pdf and .txt")
+
+        with open(file, "r", encoding="utf-8") as f:
+            text = f.read()
+
+        return text
+
+    except Exception as e:
+        print(e)
+        return "error"
+
+
+
+def is_clean(text,check_list=None):
+    if not text:
+        print("Maybe there's a mistake, no text was received!")
+        return False
+
+    normalized_text = normalize(text)
+
+    
+    for word in custom_bad_words:
+        if word in normalized_text:
+            return False
+        
+    if check_list:
+        for w in check_list:
+            if w in normalized_text:
+                return False 
+
+  
+    if profanity.contains_profanity(text):
+        return False
+
+    return True
+
+
+
+def cleann(file,check_list=None):
+    if not file:
+        print("Maybe there's a mistake, no file was received!")
+        return False
+    
+    
+    
+    if file.lower().endswith(".pdf"):
+        text = pdf_to_txt(file)
+        
+    elif file.lower().endswith(".txt"):
+        text = txt_to_text(file)
+     
+    else:
+        print("Currently, the accepted files are .pdf and .txt")
+        return "Currently, the accepted files are .pdf and .txt"
+        
+    if text == "error":
+        print("An error occurred: Please try again, making sure the file is in PDF format and that it is a text document, not a scanned copy or image!")
+        return False
+
+    normalized_text = normalize(text)
+
+    
+    for word in custom_bad_words:
+        if word in normalized_text:
+            return False
+        
+    if check_list:
+        for w in check_list:
+            if w in normalized_text:
+                return False 
+
+  
+    if profanity.contains_profanity(text):
+        return False
+
+    return True
+
+

ShadowB/Safe/cleanText.py

@@ -0,0 +1,37 @@
+import os
+import re
+try:
+    from better_profanity import profanity
+except ImportError:
+    import os
+    os.system("pip install better_profanity")
+    from better_profanity import profanity
+
+custom_bad_words = ["irheb","ass","dick","cock","asshole","de3ch","israil","اسرائيل","trump","ارهاب","إرهاب","zab", "zebi", "asba","3asba","nyk","nayek","nik","nik omk","3asba lik","mnayek","fuck","shit","fuck you","fuck u","nik omo","t7chi fih","yatek asba","yatek 3asba","ya3tek 3asba","zok","omk","kiss","زبي","عصب","نيك","امك","برا نيك","يعطك عصبة","عصبة"]
+
+def normalize(text):
+    text = text.lower()
+    text = re.sub(r'[^a-zA-Z0-9\u0600-\u06FF]', '', text)
+    return text
+
+def is_clean(text,check_list=None):
+    if not text:
+        return True
+
+    normalized_text = normalize(text)
+
+    
+    for word in custom_bad_words:
+        if word in normalized_text:
+            return False
+        
+    if check_list:
+        for w in check_list:
+            if w in normalized_text:
+                return False 
+
+  
+    if profanity.contains_profanity(text):
+        return False
+
+    return True

ShadowB/Safe/ext.py

@@ -0,0 +1,5 @@
+import os
+
+def real_ext(file):
+    ext = os.path.splitext(file)[1].lower()
+    return ext

ShadowB/Safe/filename.py

@@ -0,0 +1,6 @@
+import os
+
+def real_filename(file):
+    name = ext = os.path.splitext(os.path.basename(file))[0]
+    return name
+ 

ShadowB/Safe/safeFile.py

@@ -0,0 +1,171 @@
+import os
+import subprocess
+import sys
+import zipfile
+
+
+def _ensure_package(import_name, pip_name=None):
+    
+    pip_name = pip_name or import_name
+    try:
+        return __import__(import_name)
+    except ImportError:
+        try:
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install",
+                 "--break-system-packages", pip_name],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            return None
+        try:
+            return __import__(import_name)
+        except ImportError:
+            return None
+
+
+
+magic = _ensure_package("magic", "python-magic")
+
+
+pyclamd = _ensure_package("pyclamd", "pyclamd")
+
+
+BLOCKED_EXTENSIONS = {
+    "exe", "bat", "cmd", "apk", "cpp", "py", "js", "html",
+    "css", "c", "java", "msi", "vbs", "ps1", "dll", "scr",
+    "sh", "rb", "php", "pl", "go", "rs", "ts", "jar", "com",
+    "pif", "reg", "hta", "wsf", "lnk"
+}
+
+
+EXECUTABLE_SIGNATURES = {
+    b"MZ": "Windows PE/EXE",
+    b"\x7fELF": "Linux ELF executable",
+    b"\xfe\xed\xfa\xce": "Mach-O 32-bit executable",
+    b"\xfe\xed\xfa\xcf": "Mach-O 64-bit executable",
+    b"\xca\xfe\xba\xbe": "Mach-O fat binary / Java class",
+}
+
+
+EXECUTABLE_LIKE_EXTENSIONS = {"exe", "dll", "com", "scr", "msi"}
+
+MAX_ZIP_DEPTH = 1                              
+MAX_UNCOMPRESSED_SIZE = 200 * 1024 * 1024      
+MAX_COMPRESSION_RATIO = 100                    
+
+ZIP_BASED_EXTENSIONS = {"zip", "jar", "apk", "docx", "xlsx", "pptx"}
+
+
+def _get_extension(file_path):
+    return os.path.splitext(file_path)[1].lower().lstrip(".")
+
+
+def _read_header(file_path, n=8):
+    try:
+        with open(file_path, "rb") as f:
+            return f.read(n)
+    except OSError:
+        return b""
+
+
+def _is_disguised_executable(file_path):
+   
+    header = _read_header(file_path, 8)
+    ext = _get_extension(file_path)
+
+    if ext in EXECUTABLE_LIKE_EXTENSIONS:
+        return False  
+
+    for sig in EXECUTABLE_SIGNATURES:
+        if header.startswith(sig):
+            return True
+    return False
+
+
+def _check_zip_bomb(file_path, depth=0):
+ 
+    if depth > MAX_ZIP_DEPTH:
+        return False
+
+    try:
+        with zipfile.ZipFile(file_path) as zf:
+            total_uncompressed = 0
+            for info in zf.infolist():
+                total_uncompressed += info.file_size
+                if total_uncompressed > MAX_UNCOMPRESSED_SIZE:
+                    return False
+
+                if info.compress_size > 0:
+                    ratio = info.file_size / max(info.compress_size, 1)
+                    if ratio > MAX_COMPRESSION_RATIO:
+                        return False
+
+                if info.filename.lower().endswith(".zip"):
+                    if depth + 1 > MAX_ZIP_DEPTH:
+                        return False
+                    tmp_path = f"{file_path}.__nested_{depth}.tmp"
+                    try:
+                        with zf.open(info) as nested_file:
+                            with open(tmp_path, "wb") as tmp:
+                                tmp.write(nested_file.read())
+                        nested_ok = _check_zip_bomb(tmp_path, depth + 1)
+                        if not nested_ok:
+                            return False
+                    except (zipfile.BadZipFile, OSError):
+                        return False
+                    finally:
+                        if os.path.exists(tmp_path):
+                            os.remove(tmp_path)
+    except zipfile.BadZipFile:
+        return False 
+    except OSError:
+        return False
+
+    return True
+
+
+def _clamav_scan(file_path):
+   
+    if pyclamd is None:
+        return None
+    try:
+        cd = pyclamd.ClamdUnixSocket()
+        if not cd.ping():
+            cd = pyclamd.ClamdNetworkSocket()
+            cd.ping()
+        result = cd.scan_file(file_path)
+        return result is None  
+    except Exception:
+        return None
+
+
+def is_safe(file):
+   
+    if not file or not os.path.isfile(file):
+        return False
+
+    ext = _get_extension(file)
+
+
+    if ext in BLOCKED_EXTENSIONS:
+        return False
+
+   
+    if _is_disguised_executable(file):
+        return False
+
+    
+    header = _read_header(file, 4)
+    looks_like_zip = header.startswith(b"PK\x03\x04") or ext in ZIP_BASED_EXTENSIONS
+    if looks_like_zip:
+        if not _check_zip_bomb(file):
+            return False
+
+    
+    av_result = _clamav_scan(file)
+    if av_result is False:
+        return False
+
+    return True

ShadowB/__init__.py

@@ -0,0 +1,44 @@
+from .core import start
+from .core import owner
+from .core import hp
+from .core import team
+from .core import vr
+
+from .getD import my_data
+from .getD import my_ip
+from .getD import get_cookies
+from .getD import scan
+from .getD import whm
+
+from .safe import ext
+from .safe import extR
+from .safe import name
+from .safe import cleanText
+from .safe import clean
+from .safe import size
+from .safe import safeFile
+
+
+from .passwords import check_strength
+from .passwords import create_password
+
+
+from .image import expMetadata
+from .image import removeMetadata
+from .image import check_img
+from .image import hide_file
+from .image import hide_text
+from .image import extr_file
+from .image import extr_text
+
+
+from .mail import create_email
+from .mail import get_msj
+from .mail import send_msj
+
+from .captcha import generate_captcha
+
+from .qrcode import generate_qrcode
+from .qrcode import scan_qrcode
+
+from .search import search_by_username

ShadowB/captcha.py

@@ -0,0 +1,73 @@
+import sys
+import os
+import random
+import string
+
+try:
+    from PIL import Image, ImageDraw, ImageFont
+except ImportError:
+    os.system(f"{sys.executable} -m pip install pillow")
+    from PIL import Image, ImageDraw, ImageFont
+
+def generate_captcha(name="captcha"):
+    output_filename = f"{name}.png"
+    characters = string.ascii_letters + string.digits
+    captcha_text = ''.join(random.choice(characters) for _ in range(7))
+    
+
+    width, height = 250, 80
+    background_color = (240, 240, 240)
+    
+   
+    image = Image.new("RGB", (width, height), color=background_color)
+    draw = ImageDraw.Draw(image)
+    
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 36)
+    except IOError:
+        font = ImageFont.load_default()
+
+    for _ in range(5):
+        x1 = random.randint(0, width)
+        y1 = random.randint(0, height)
+        x2 = random.randint(0, width)
+        y2 = random.randint(0, height)
+        line_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+        draw.line([(x1, y1), (x2, y2)], fill=line_color, width=2)
+        
+  
+    for _ in range(500):
+        x = random.randint(0, width - 1)
+        y = random.randint(0, height - 1)
+        pixel_color = (random.randint(100, 200), random.randint(100, 200), random.randint(100, 200))
+        draw.point((x, y), fill=pixel_color)
+
+    
+    current_x = 20
+    for char in captcha_text:
+       
+        char_color = (random.randint(0, 100), random.randint(0, 100), random.randint(0, 100))
+        
+        current_y = random.randint(15, 30)
+        
+        draw.text((current_x, current_y), char, fill=char_color, font=font)
+       
+        current_x += 30
+
+ 
+    image.save(output_filename)
+    
+    print(f"[+] Captcha code generated successfully : '{output_filename}'")
+    print(f"[+] Captcha code : {captcha_text}")
+    
+    return captcha_text
+
+# --- تجربة تشغيل الدالة ---
+if __name__ == "__main__":
+    # استدعاء الدالة
+    generated_code = generate_captcha("my_captcha.png")
+    
+    # لمعرفة أين تم حفظ الصورة تماماً في جهازك (باستخدام المفهوم السابق)
+    import os
+    print(f"مكان حفظ الصورة الكامل: {os.path.abspath('my_captcha.png')}")