ShadowB 0.1__py3-none-any.whl

ShadowB/Core/fileorg.py

@@ -0,0 +1,38 @@
+import os
+import shutil
+
+def florg(folder=None):
+    if folder is None:
+        return "The folder path is required!"
+    types = {
+        ".jpg": "Images", ".png": "Images", ".jpeg": "Images",
+        ".zip": "Archives", ".rar": "Archives",
+        ".pdf": "Documents", ".docx": "Documents", ".txt": "Documents",
+        ".mp3": "Music", ".wav": "Music",
+        ".py": "Code", ".js": "Code", ".html": "Code",
+        ".exe": "Code", ".cpp": "Code", ".css": "Code"
+    }
+
+
+    skip_folders = set(types.values())
+
+    for root, dirs, files in os.walk(folder):
+
+        dirs[:] = [d for d in dirs if d not in skip_folders]
+
+        moved = 0
+        for file in files:
+            path = os.path.join(root, file)
+            ext = os.path.splitext(file)[1].lower()
+            if ext in types:
+                target_folder = os.path.join(root, types[ext])
+                os.makedirs(target_folder, exist_ok=True)
+                shutil.move(path, os.path.join(target_folder, file))
+                print(f"{file} → {root}/{types[ext]}/")
+                moved += 1
+            else:
+                print(f"Unknown extension: {file}")
+
+        if moved > 0:
+            print(f"\n Your files have been organized successfully: {root}\n")
+

ShadowB/Core/randwords.py

@@ -0,0 +1,76 @@
+import string
+from random import choice
+import itertools as ito
+from pathlib import Path
+
+
+def randw(filename,rep,others_chars,numbers,symbols,letters,form):
+    if numbers and symbols and letters:
+        if form == "maj":
+            final_combo = string.ascii_uppercase + string.digits + string.punctuation + others_chars
+        elif form == "min":
+            final_combo = string.ascii_lowercase + string.digits + string.punctuation + others_chars
+        else:
+            final_combo = string.ascii_letters + string.digits + string.punctuation + others_chars
+           
+           
+    # numbers       
+    elif numbers and symbols and not letters:
+        final_combo =  string.digits + string.punctuation + others_chars
+
+    elif numbers and not symbols and letters:
+        if form == "maj":
+            final_combo = string.ascii_uppercase + string.digits + others_chars
+        elif form == "min":
+            final_combo = string.ascii_lowercase + string.digits + others_chars
+        else:
+            final_combo = string.ascii_letters + string.digits + others_chars
+        
+    elif numbers and not symbols and not letters:
+        final_combo = string.digits
+        
+        
+    # letters    
+    elif letters and symbols and not numbers:
+        if form == "maj":
+            final_combo = string.ascii_uppercase + string.punctuation + others_chars
+        elif form == "min":
+            final_combo = string.ascii_lowercase + string.punctuation + others_chars
+        else:
+            final_combo = string.ascii_letters + string.punctuation + others_chars
+            
+            
+    elif letters and not symbols and not numbers:
+        if form == "maj":
+            final_combo = string.ascii_uppercase 
+        elif form == "min":
+            final_combo = string.ascii_lowercase 
+        else:
+            final_combo = string.ascii_letters
+            
+    
+    #symbols
+    elif symbols and not letters and not numbers:
+        if form == "maj":
+            final_combo = string.punctuation + others_chars
+        elif form == "min":
+            final_combo = string.punctuation + others_chars
+        else:
+            final_combo = string.punctuation + others_chars
+            
+    else:
+        final_combo = string.ascii_letters + string.digits + string.punctuation + others_chars
+    
+    
+    final_combo = string.ascii_letters + string.digits + someCaracters + others_chars
+    if rep > 5:
+        print("The maximum number of slots you can reach is 5")
+    if rep < 2:
+        print("The smallest number of digits possible is 2")
+    desktop = Path.home() / "Desktop"
+    words = [''.join(combo) for combo in ito.product(final_combo, repeat=rep)]
+    with open(desktop / f"{filename}.txt","w") as w:
+        for wr in words:
+            w.write(wr + "\n")
+        print(f"Alright, it has been saved in : {desktop / (filename + '.txt')}")
+         

ShadowB/GetD/make_cookies.py

@@ -0,0 +1,27 @@
+import os
+try:
+    import browser_cookie3
+except ImportError:
+    import os
+    os.system("pip install browser_cookie3")
+    import browser_cookie3
+
+
+def cookies(filename):
+    cookies = browser_cookie3.chrome()
+
+
+    with open(f"{filename}.txt", "w", encoding="utf-8") as f:
+        f.write("# Netscape HTTP Cookie File\n")
+        f.write("# This is a generated file! Do not edit.\n\n")
+        
+        for cookie in cookies:
+       
+            is_secure = "TRUE" if cookie.secure else "FALSE"
+            expiration = str(int(cookie.expires)) if cookie.expires else "0"
+            
+            line = f"{cookie.domain}\t{is_secure}\t{cookie.path}\t{is_secure}\t{expiration}\t{cookie.name}\t{cookie.value}\n"
+            f.write(line)
+    
+    print(f"Saved at : {filename}.txt and cookies") 
+    return cookies

ShadowB/GetD/my_data.py

@@ -0,0 +1,86 @@
+import platform
+import socket
+import os
+import shutil
+import ctypes
+import getpass
+
+
+def make_file():
+    
+    data = []
+
+    data.append("=== Device Information ===\n")
+
+    username = getpass.getuser()  
+
+
+
+
+    data.append(username)
+
+    hostname = socket.gethostname()
+    data.append(f"Hostname: {hostname}\n")
+
+
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        local_ip = s.getsockname()[0]
+        s.close()
+    except:
+        local_ip = "Not available"
+    data.append(f"Local IP: {local_ip}\n")
+
+
+    os_name = platform.system()
+    os_release = platform.release()
+    arch = platform.architecture()[0]
+    data.append(f"Operating System: {os_name} {os_release}\n")
+    data.append(f"Architecture: {arch}\n")
+
+
+    class MEMORYSTATUSEX(ctypes.Structure):
+        _fields_ = [
+            ("dwLength", ctypes.c_ulong),
+            ("dwMemoryLoad", ctypes.c_ulong),
+            ("ullTotalPhys", ctypes.c_ulonglong),
+            ("ullAvailPhys", ctypes.c_ulonglong),
+            ("ullTotalPageFile", ctypes.c_ulonglong),
+            ("ullAvailPageFile", ctypes.c_ulonglong),
+            ("ullTotalVirtual", ctypes.c_ulonglong),
+            ("ullAvailVirtual", ctypes.c_ulonglong),
+            ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+        ]
+
+        def __init__(self):
+            super(MEMORYSTATUSEX, self).__init__()
+            self.dwLength = ctypes.sizeof(self)
+
+    kernel32 = ctypes.windll.kernel32
+    stat = MEMORYSTATUSEX()
+    kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
+
+    ram_bytes = stat.ullTotalPhys
+    ram_mb = ram_bytes // (1024 * 1024)
+    ram_gb = round(ram_mb / 1024, 1)
+    data.append(f"Total RAM: {ram_gb} GB  ({ram_mb} MB)\n")
+
+
+    try:
+        total, used, free = shutil.disk_usage('C:\\')
+        total_gb = round(total / (1024**3), 1)
+        used_gb = round(used / (1024**3), 1)
+        free_gb = round(free / (1024**3), 1)
+        data.append(f"Disk C: Total {total_gb} GB\n")
+        data.append(f"Disk C: Used  {used_gb} GB\n")
+        data.append(f"Disk C: Free  {free_gb} GB\n")
+    except Exception as e:
+        data.append(f"Disk C: Error reading usage - {str(e)}\n")
+    d = [data]
+    data.append("\n=== End of Information ===\n")
+    
+    with open("PcData.txt", "w", encoding="utf-8") as f:
+        f.writelines(data)
+    print("Saved at : PcData.txt")    
+    return d

ShadowB/GetD/my_ip.py

@@ -0,0 +1,12 @@
+import socket
+
+def ip():
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        local_ip = s.getsockname()[0]
+        s.close()
+    except:
+        local_ip = "Not available"
+    print(local_ip)
+    return local_ip

ShadowB/GetD/scan.py

@@ -0,0 +1,72 @@
+import sys
+import os
+
+try:
+    from colorama import Fore, Style, init
+    init(autoreset=True)
+except ImportError:
+    print("[-] 'colorama' library is missing. Attempting to install it now...")
+    try:
+
+        os.system(f"{sys.executable} -m pip install colorama")
+        from colorama import Fore, Style, init
+        init(autoreset=True)
+        print("[+] 'colorama' installed successfully!\n")
+    except Exception as e:
+        print(f"[-] Failed to install the library: {e}. Proceeding without colors.")
+        
+        class Fore: GREEN = ''; RED = ''; RESET = ''
+        class Style: BRIGHT = ''
+
+import socket
+from datetime import datetime
+
+def scan(ip):
+    """
+    Scans a target IP address for open TCP ports.
+    """
+    print("-" * 50)
+    print(f"{Fore.GREEN}Starting scan on target: {ip}")
+    print(f"Time started: {str(datetime.now())}")
+    print("-" * 50)
+
+    
+    ports_to_scan = range(1, 1025)
+    open_ports = []
+
+    try:
+        for port in ports_to_scan:
+     
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            
+            s.settimeout(1.0)
+            
+           
+            result = s.connect_ex((ip, port))
+
+            if result == 0:
+                print(f"[+] Port {Fore.GREEN}{Style.BRIGHT}{port}{Style.RESET}: OPEN")
+                open_ports.append(port)
+            
+            s.close()
+            
+    except KeyboardInterrupt:
+        print(f"\n{Fore.RED}Scan stopped by user (Ctrl+C).")
+        sys.exit()
+        
+    except socket.gaierror:
+        print(f"\n{Fore.RED}[- ] Hostname could not be resolved.")
+        sys.exit()
+        
+    except socket.error:
+        print(f"\n{Fore.RED}[- ] Could not connect to server.")
+        sys.exit()
+
+
+    print("-" * 50)
+    print(f"{Fore.GREEN}Scan Completed!")
+    if open_ports:
+        print(f"Open ports found: {Fore.GREEN}{open_ports}")
+    else:
+        print(f"{Fore.RED}No open ports found in the scanned range.")
+    print("-" * 50)

ShadowB/Image/check_image.py

@@ -0,0 +1,39 @@
+import os
+
+try:
+    from PIL import Image
+    from PIL.ExifTags import TAGS, GPSTAGS
+except:
+    import os
+    os.system("pip install pillow")
+    from PIL import Image
+    from PIL.ExifTags import TAGS,GPSTAGS
+    
+    
+    
+try:
+    import stepic
+except:
+    import os
+    os.system("pip install stepic")
+    import stepic
+    
+    
+
+def check(image_path):
+    if not image_path or not os.path.exists(image_path):
+        return "No image provided or file does not exist"
+        
+    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')
+    if not image_path.lower().endswith(valid_extensions):
+        return "We only accept images"
+        
+    try:
+        img = Image.open(image_path)
+        decoded_data = stepic.decode(img)
+        
+        if decoded_data:
+            return "true"
+        return "false"
+    except:
+        return "false"

ShadowB/Image/export_metadata.py

@@ -0,0 +1,96 @@
+import os
+
+try:
+    from PIL import Image
+    from PIL.ExifTags import TAGS, GPSTAGS
+except:
+    os.system("pip install pillow")
+    from PIL import Image
+    from PIL.ExifTags import TAGS,GPSTAGS
+
+
+try:
+    import stepic
+except:
+    os.system("pip install stepic")
+    import stepic
+    
+    
+    
+def _convert_to_degrees(value):
+    try:
+        degrees = float(value[0])
+        minutes = float(value[1])
+        seconds = float(value[2])
+        return degrees + (minutes / 60.0) + (seconds / 3600.0)
+    except Exception:
+        return None
+
+def exp(file_path):
+   
+    if not os.path.exists(file_path):
+        return "File does not exist"
+    
+    
+    try:
+        with Image.open(file_path) as img:
+          
+            metadata = {
+                "Filename": os.path.basename(file_path),
+                "Format": img.format,
+                "Dimensions": f"{img.width}x{img.height} pixels",
+                "Mode": img.mode,
+                "Capture_Date": "Unknown",      
+                "Camera_Make": "Unknown",      
+                "Camera_Model": "Unknown",     
+                "Software": "Unknown",      
+                "Location_GPS": "Unknown"     
+            }
+            
+            
+            exif_data = img._getexif()
+            
+            if exif_data is not None:
+                gps_info = {}
+                
+                for tag_id, value in exif_data.items():
+                    tag_name = TAGS.get(tag_id, tag_id)
+                    
+          
+                    if tag_name == "DateTimeOriginal" or tag_name == "DateTime":
+                        metadata["Capture_Date"] = str(value)
+                    
+                   
+                    elif tag_name == "Make":
+                        metadata["Camera_Make"] = str(value).strip()
+                    elif tag_name == "Model":
+                        metadata["Camera_Model"] = str(value).strip()
+                    elif tag_name == "Software":
+                        metadata["Software"] = str(value).strip()
+                        
+                  
+                    elif tag_name == "GPSInfo":
+                        for key in value:
+                            sub_tag = GPSTAGS.get(key, key)
+                            gps_info[sub_tag] = value[key]
+                
+                
+                if gps_info and "GPSLatitude" in gps_info and "GPSLongitude" in gps_info:
+                    lat = _convert_to_degrees(gps_info["GPSLatitude"])
+                    lon = _convert_to_degrees(gps_info["GPSLongitude"])
+                    
+                  
+                    if lat and gps_info.get("GPSLatitudeRef") == "S":
+                        lat = -lat
+                    if lon and gps_info.get("GPSLongitudeRef") == "W":
+                        lon = -lon
+                        
+                    if lat and lon:
+                   
+                        metadata["Location_GPS"] = f"{lat:.6f}, {lon:.6f}"
+            
+            return metadata
+
+    except (IOError, SyntaxError, Image.UnidentifiedImageError):
+        return "This is not an image"
+    

ShadowB/Image/extr_hidden_files.py

@@ -0,0 +1,44 @@
+import os
+
+try:
+    from PIL import Image
+    from PIL.ExifTags import TAGS, GPSTAGS
+except:
+    os.system("pip install pillow")
+    from PIL import Image
+    from PIL.ExifTags import TAGS,GPSTAGS
+
+
+try:
+    import stepic
+except:
+    os.system("pip install stepic")
+    import stepic
+    
+
+def extract_file_from_img(image_path, output_directory="."):
+    try:
+        img = Image.open(image_path)
+        decoded_data = stepic.decode(img)
+        
+        if not decoded_data:
+            return "No hidden data found in this image"
+            
+        if isinstance(decoded_data, str):
+            decoded_data = decoded_data.encode('utf-8')
+            
+        header_parts = decoded_data.split(b':', 2)
+        if len(header_parts) < 3:
+            return "Hidden data does not match the expected file format"
+            
+        file_name = header_parts[0].decode('utf-8')
+        file_size = int(header_parts[1].decode('utf-8'))
+        file_data = header_parts[2][:file_size]
+        
+        out_file_path = os.path.join(output_directory, file_name)
+        with open(out_file_path, 'wb') as f:
+            f.write(file_data)
+            
+        return f"File extracted successfully and saved as: {out_file_path}"
+    except Exception as e:
+        return f"An error occurred during extraction: {str(e)}"

ShadowB/Image/extr_hidden_text.py

@@ -0,0 +1,39 @@
+import os
+
+try:
+    from PIL import Image
+    from PIL.ExifTags import TAGS, GPSTAGS
+except:
+    os.system("pip install pillow")
+    from PIL import Image
+    from PIL.ExifTags import TAGS,GPSTAGS
+    
+    
+try:
+    import stepic
+except:
+    os.system("pip install stepic")
+    import stepic
+
+
+def extract_text_from_img(image_path):
+    if not image_path or not os.path.exists(image_path):
+        return "No image provided or file does not exist"
+        
+    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')
+    if not image_path.lower().endswith(valid_extensions):
+        return "We only accept images"
+        
+    try:
+        img = Image.open(image_path)
+        decoded_data = stepic.decode(img)
+        
+        if not decoded_data:
+            return "No hidden text found in this image"
+            
+        if isinstance(decoded_data, bytes):
+            return decoded_data.decode('utf-8')
+            
+        return decoded_data
+    except Exception as e:
+        return f"An error occurred: {str(e)}"

ShadowB/Image/makeFile.py

@@ -0,0 +1,48 @@
+import os
+
+try:
+    from PIL import Image
+except:
+    os.system("pip install pillow")
+    from PIL import Image
+
+try:
+    import stepic
+except:
+    os.system("pip install stepic")
+    import stepic
+
+
+def hide_file_in_img(image_path, file_to_hide_path):
+    if not image_path or not os.path.exists(image_path):
+        return "No image provided or file does not exist"
+        
+    if not file_to_hide_path or not os.path.exists(file_to_hide_path):
+        return "File to hide does not exist"
+        
+    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')
+    if not image_path.lower().endswith(valid_extensions):
+        return "We only accept images"
+        
+    try:
+        img = Image.open(image_path)
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+            
+        file_name = os.path.basename(file_to_hide_path)
+        with open(file_to_hide_path, 'rb') as f:
+            file_data = f.read()
+            
+        header = f"{file_name}:{len(file_data)}:".encode('utf-8')
+        payload = header + file_data
+        
+        encoded_img = stepic.encode(img, payload)
+        
+        img_dir, img_name = os.path.split(image_path)
+        filename, _ = os.path.splitext(img_name)
+        output_path = os.path.join(img_dir, f"{filename}_with_file.png")
+        
+        encoded_img.save(output_path, format='PNG')
+        return f"Success! File hidden inside image. Saved at: {output_path}"
+    except Exception as e:
+        return f"An error occurred: {str(e)}"

ShadowB/Image/makeText.py

@@ -0,0 +1,41 @@
+import os
+
+try:
+    from PIL import Image
+except:
+    os.system("pip install pillow")
+    from PIL import Image
+
+try:
+    import stepic
+except:
+    os.system("pip install stepic")
+    import stepic
+    
+
+def hide_text_in_img(image_path, text):
+    if not image_path or not os.path.exists(image_path):
+        return "No image provided or file does not exist"
+        
+    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.webp')
+    if not image_path.lower().endswith(valid_extensions):
+        return "We only accept images"
+        
+    if not text:
+        return "No text provided to hide"
+        
+    try:
+        img = Image.open(image_path)
+        
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+            
+        encoded_img = stepic.encode(img, text.encode('utf-8'))
+        
+        filename, ext = os.path.splitext(image_path)
+        output_path = f"{filename}_hidden.png"
+        
+        encoded_img.save(output_path, format='PNG')
+        return f"Success! Image saved at: {output_path}"
+    except Exception as e:
+        return f"An error occurred: {str(e)}"

ShadowB/Image/remove_metadata.py

@@ -0,0 +1,48 @@
+import os
+
+try:
+    from PIL import Image
+    from PIL.ExifTags import TAGS, GPSTAGS
+except:
+    import os
+    os.system("pip install pillow")
+    from PIL import Image
+    from PIL.ExifTags import TAGS,GPSTAGS
+
+
+def remove(file_path, output_suffix="_cleaned"):
+   
+    if not os.path.exists(file_path):
+        return "File does not exist"
+    
+
+    try:
+        with Image.open(file_path) as img:
+           
+            file_dir, file_name = os.path.split(file_path)
+            name, ext = os.path.splitext(file_name)
+            
+            
+            new_file_name = f"{name}{output_suffix}{ext}"
+            output_path = os.path.join(file_dir, new_file_name)
+            
+          
+            cleaned_img = Image.new(img.mode, img.size)
+            cleaned_img.putdata(img.getdata())
+            
+           
+            cleaned_img.save(output_path, format=img.format)
+            
+  
+            return {
+                "Status": "Success",
+                "Message": "Metadata removed successfully",
+                "Original_File": file_name,
+                "Cleaned_File": new_file_name,
+                "Format": img.format,
+                "Dimensions": f"{img.width}x{img.height} pixels"
+            }
+
+    except (IOError, SyntaxError, Image.UnidentifiedImageError):
+       
+        return "This is not an image"