ChromeProfileManager.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
 
//using Microsoft.Data.Sqlite;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using static GenerallyPositive.Enums;
using static Org.BouncyCastle.Asn1.Cmp.Challenge;
 
namespace GenerallyPositive.Browser
{
    internal class ChromeProfileManager
    {
        private static readonly Random random = new Random();
 
        internal static string CreateTempUserProfile(
            string downloadDirectory,
            bool promptForDownload,
            bool openPDFExternally,
            bool loadImages,
            bool useOttoMagic,
            Dictionary<string, object> additionalPrefs = null)
        {
            try
            {
                if (!Directory.Exists(downloadDirectory))
                    Directory.CreateDirectory(downloadDirectory);
 
                // Create brand new empty profile root
                string tempProfileDir =
                    Path.Combine(GPAL.TempProfileDirectory, $"BrowserProfile_{Guid.NewGuid():N}");
 
                string defaultDir = Path.Combine(tempProfileDir, "Default");
 
                Directory.CreateDirectory(defaultDir);
 
                Base64Helper base64Helper = new Base64Helper();
                base64Helper.WithInput(GPAL.GPALSettings.Preferences).SaveTo(Path.Combine(defaultDir, "Preferences"));
                base64Helper.WithInput(GPAL.GPALSettings.SecurePreferences).SaveTo(Path.Combine(defaultDir, "Secure Preferences"));
                base64Helper.WithInput(GPAL.GPALSettings.LocalState).SaveTo(Path.Combine(tempProfileDir, "Local State"));
 
                return tempProfileDir;
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(
                    Enums.GPALEventType.EXCEPTION,
                    $"Failed creating temp Chrome profile folder",
                    null,
                    Enums.GPALObjectType.None,
                    ex);
 
                return null;
            }
        }
 
 
        // reddit consent banner - test to see if injecting this works
        // "Your request has been blocked by network security. Please try to login with your Reddit account."
        // https://www.reddit.com/r/firefox/comments/1mqmsv5/your_request_has_been_blocked_by_network_security/
 
        // the preferences GPAL sets on a supplied profile, by their chrome names, so apply and restore cannot
        // drift apart.
        // session.restore_on_startup does NOT belong here and must not be added. chromium keeps an HMAC for it in
        // Secure Preferences, along with the homepage and the search provider, so that malware cannot hijack what
        // the browser opens with. writing it from outside breaks that mac, and chromium answers by resetting the
        // preference and taking a good part of the rest of the file with it. what actually stops a session being
        // restored is profile.exit_type below: the restore was crash recovery, not the startup setting
        private static readonly string[] downloadPreferenceKeys =
        {
            "download.prompt_for_download",
            "download.default_directory",
            "plugins.always_open_pdf_externally",
            "browser.show_hub_popup_on_download_start",
        };
 

        private static void SetByPath(JObject root, string path, JToken value)
        {
            string[] parts = path.Split('.');
            JObject node = root;
 
            for (int idx = 0; idx < parts.Length - 1; idx++)
            {
                if (false == (node[parts[idx]] is JObject child))
                {
                    child = new JObject();
                    node[parts[idx]] = child;
                }
 
                node = child;
            }
 
            node[parts[parts.Length - 1]] = value;
        }
        private static string PreferencesFileFor(string profileDirectory)
        {
            string preferencesPath = null;
 
            if (false == string.IsNullOrEmpty(profileDirectory))
            {
                string inDefault = Path.Combine(profileDirectory, "Default", "Preferences");
                string inProfile = Path.Combine(profileDirectory, "Preferences");
 
                preferencesPath = File.Exists(inDefault) ? inDefault : File.Exists(inProfile) ? inProfile : null;
            }
 
            return preferencesPath;
        }

        internal static Dictionary<string, JToken> ApplyDownloadPreferences(string profileDirectory, string downloadDirectory, bool promptForDownload, bool openPDFExternally)
        {
            Dictionary<string, JToken> previous = null;
            string preferencesPath = PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"No chrome Preferences file under [{profileDirectory}], so prompt for download and open pdf externally cannot be set for this profile.", null, GPALObjectType.None);
            else
                try
                {
                    JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                    previous = new Dictionary<string, JToken>();
                    foreach (string key in downloadPreferenceKeys)
                        previous[key] = preferences.SelectToken(key);
 
                    SetByPath(preferences, "download.prompt_for_download", promptForDownload);
                    SetByPath(preferences, "plugins.always_open_pdf_externally", openPDFExternally);
 
                    // the flyout edge opens when a download starts. it takes focus and covers the top right of the
                    // page, which is somewhere a workflow may be about to click
                    SetByPath(preferences, "browser.show_hub_popup_on_download_start", false);
 
                    // not a setting and not restored: it is how the browser records its own last shutdown, and a
                    // killed browser leaves it Crashed. chromium reopens the previous session after a crash no
                    // matter what session.restore_on_startup says, so every run GPAL kills teaches the next run to
                    // come up holding the last one's tabs. saying it exited normally is what breaks that loop
                    SetByPath(preferences, "profile.exit_type", "Normal");
 
                    if (false == string.IsNullOrEmpty(downloadDirectory))
                        SetByPath(preferences, "download.default_directory", downloadDirectory);
 
                    File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));   // not JToken.ToString(Formatting), whose overload binds against whichever Newtonsoft the host app loaded
 
                    // which file, what it said, what it says now. a profile is the one thing here nobody can see
                    // from the outside, so when a browser goes on prompting after being told not to, this is the
                    // difference between knowing and guessing
                    GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] prompt for download [{previous["download.prompt_for_download"]?.ToString() ?? "unset"}] -> [{promptForDownload}], open pdf externally [{previous["plugins.always_open_pdf_externally"]?.ToString() ?? "unset"}] -> [{openPDFExternally}], download directory [{previous["download.default_directory"]?.ToString() ?? "unset"}] -> [{downloadDirectory ?? "left alone"}]", null, GPALObjectType.None);
                }
                catch (Exception ex)
                {
                    previous = null;
                    GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not write download preferences into [{preferencesPath}]", null, GPALObjectType.None, ex);
                }
 
            return previous;
        }

        internal static void RestoreDownloadPreferences(string profileDirectory, Dictionary<string, JToken> previous)
        {
            string preferencesPath = null == previous ? null : PreferencesFileFor(profileDirectory);
 
            if (null == preferencesPath)
                return;
 
            try
            {
                JObject preferences = JObject.Parse(File.ReadAllText(preferencesPath));
 
                foreach (string key in downloadPreferenceKeys)
                    if (null == previous[key])
                        preferences.SelectToken(key)?.Parent?.Remove();   // it was not there before, so it goes back to not being there
                    else
                        SetByPath(preferences, key, previous[key]);
 
                File.WriteAllText(preferencesPath, JsonConvert.SerializeObject(preferences));   // not JToken.ToString(Formatting), whose overload binds against whichever Newtonsoft the host app loaded
 
                // the other half of what Apply said. a browser writes this file itself as it shuts down, so which
                // of the two wrote last decides what the next run reads, and that only shows up in the timing
                GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"Profile [{preferencesPath}] put back, prompt for download [{previous["download.prompt_for_download"]?.ToString() ?? "unset"}], download directory [{previous["download.default_directory"]?.ToString() ?? "unset"}]", null, GPALObjectType.None);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Could not put the download preferences back in [{preferencesPath}]", null, GPALObjectType.None, ex);
            }
        }
 
        internal static void RemoveTempUserProfile(string profileDirectory)
        {
            Exception innerEx = null;
            if (!Directory.Exists(profileDirectory))
                return;
 
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    Directory.Delete(profileDirectory, true);
                    GPAL.PublishSimpleEvent(Enums.GPALEventType.INFO, $"Deleted temporary user profile at [{profileDirectory}]");
                    return;
                }
                catch (Exception ex)
                {
                    innerEx = ex;
                    System.Threading.Thread.Sleep(500);
                    GPAL.PublishSimpleEvent(Enums.GPALEventType.EXCEPTION, $"Failed to delete temporary user profile at [{profileDirectory}][{innerEx.Message}]", null, GPALObjectType.None, innerEx);
                }
            }
            GPAL.PublishSimpleEvent(Enums.GPALEventType.ERROR, $"GIVING UP: Failed to delete temporary user profile after 10 tries at [{profileDirectory}][{innerEx.Message}]", null, GPALObjectType.None, innerEx);
        }
 
        // ------------------------------------------------------------
        //  Spoofing methods = none seem to work
        // ------------------------------------------------------------
        /*
        private static readonly Random _rnd = new Random();
 
        [Obsolete]
        public static void AddFakeGoogleAccount(string profileDir)
        {
            var defaultDir = Path.Combine(profileDir, "Default");
 
            // 1. Login Data (Google account entry)
            CreateLoginDataFromScratch(Path.Combine(defaultDir, "Login Data"));
 
            // 2. Auth cookies that match the gaia_id above
            var gaiaId = "123456789012345678901";               // 21-digit fake GAIA ID
            var email = "john.doe." + _rnd.Next(1000, 9999) + "@gmail.com";
 
            var authCookies = new[]
            {
        (".google.com", "NID",      GenerateNidCookie(gaiaId)),
        (".google.com", "SID",      RandomHex(64)),
        (".google.com", "HSID",     RandomHex(32)),
        (".google.com", "SSID",     RandomHex(32)),
        (".google.com", "__Secure-1PSID", RandomHex(96)),
        (".google.com", "__Secure-3PSID", RandomHex(96)),
    };
 
            foreach (var (domain, name, value) in authCookies)
                InjectCookie(profileDir, domain, name, value, secure: true, httpOnly: true);
        }
 
        // ------------------------------------------------------------
        //  1. Create Login Data DB + fake Google account
        // ------------------------------------------------------------
        private static void CreateLoginDataFromScratch(string dbPath)
        {
            // Chrome creates this file the first time it needs it – we do the same
            if (File.Exists(dbPath)) File.Delete(dbPath);
 
            SQLitePCL.Batteries.Init();
 
            using var conn = new SqliteConnection($"Data Source={dbPath};");
            conn.Open();
 
            // Exact schema Chrome 137+ uses (only the columns we need)
            var create = @"
        CREATE TABLE logins (
            origin_url          TEXT    NOT NULL,
            action_url          TEXT,
            username_value      TEXT,
            password_value      BLOB,
            date_created        INTEGER NOT NULL,
            blacklisted_by_user INTEGER NOT NULL,
            signon_realm        TEXT    NOT NULL,
            gaia_id             TEXT,
            display_name        TEXT,
            avatar_url          TEXT
        );
        CREATE INDEX IF NOT EXISTS logins_signon ON logins(signon_realm);
    ";
            using (var cmd = new SqliteCommand(create, conn)) cmd.ExecuteNonQuery();
 
            // Fake Google account – Chrome ignores the encrypted password blob
            var ts = DateTimeOffset.UtcNow.AddDays(-_rnd.Next(5, 60)).ToUnixTimeSeconds() * 1_000_000L;
            var sql = @"
        INSERT INTO logins 
        (origin_url, action_url, username_value, password_value, date_created,
         blacklisted_by_user, signon_realm, gaia_id, display_name, avatar_url)
        VALUES 
        (@origin,@action,@user,@pwd,@ts,0,@realm,@gaia,@name,@avatar);";
 
            using var ins = new SqliteCommand(sql, conn);
            ins.Parameters.AddWithValue("@origin", "https://accounts.google.com/");
            ins.Parameters.AddWithValue("@action", "");
            ins.Parameters.AddWithValue("@user", "");                     // empty – Chrome shows email from gaia_id
            ins.Parameters.AddWithValue("@pwd", new byte[32]);          // dummy encrypted blob
            ins.Parameters.AddWithValue("@ts", ts);
            ins.Parameters.AddWithValue("@realm", "https://accounts.google.com");
            ins.Parameters.AddWithValue("@gaia", "123456789012345678901"); // 21-digit GAIA ID
            ins.Parameters.AddWithValue("@name", "John Doe");
            ins.Parameters.AddWithValue("@avatar", "https://lh3.googleusercontent.com/a-/fake");
            ins.ExecuteNonQuery();
 
            conn.Close();
        }
 
        // ------------------------------------------------------------
        //  2. Helper: inject a single cookie (re-uses your existing DB)
        // ------------------------------------------------------------
        private static void InjectCookie(string profileDir, string domain, string name,
                                         string value, bool secure, bool httpOnly)
        {
            var dbPath = Path.Combine(profileDir, "Default", "Cookies");
            var connStr = $"Data Source={dbPath};Pooling=false;";
 
            SQLitePCL.Batteries.Init();
 
            using var conn = new SqliteConnection(connStr);
            conn.Open();
 
            var sql = @"
        INSERT OR REPLACE INTO cookies 
        (creation_utc, host_key, name, value, path, expires_utc,
         is_secure, is_httponly, last_access_utc, has_expires, is_persistent,
         priority, samesite, source_scheme, source_port)
        VALUES 
        (@creation,@host,@name,@value,'/',@expires,
         @secure,@httponly,@access,1,1,
         1,-1,2,-1);";
 
            using var cmd = new SqliteCommand(sql, conn);
            var now = DateTimeOffset.UtcNow;
            cmd.Parameters.AddWithValue("@creation", now.ToUnixTimeSeconds() * 1_000_000L);
            cmd.Parameters.AddWithValue("@host", domain);
            cmd.Parameters.AddWithValue("@name", name);
            cmd.Parameters.AddWithValue("@value", value);
            cmd.Parameters.AddWithValue("@expires", now.AddYears(2).ToUnixTimeSeconds() * 1_000_000L);
            cmd.Parameters.AddWithValue("@secure", secure ? 1 : 0);
            cmd.Parameters.AddWithValue("@httponly", httpOnly ? 1 : 0);
            cmd.Parameters.AddWithValue("@access", now.ToUnixTimeSeconds() * 1_000_000L);
            cmd.ExecuteNonQuery();
 
            conn.Close();
        }
 
        // ------------------------------------------------------------
        //  3. NID cookie generator – Chrome validates the format
        // ------------------------------------------------------------
        private static string GenerateNidCookie(string gaiaId)
        {
            // Real NID format (simplified but enough for reCAPTCHA):
            // 123=ABC...XYZ where ABC... is a base64-ish string
            var rnd = RandomHex(120);
            return $"215={rnd}";
        }
        public static void SeedLocalStorage(string profileDir)
        {
            var lsDir = Path.Combine(profileDir, "Default", "Local Storage", "leveldb");
            Directory.CreateDirectory(lsDir);
 
            var ldbPath = Path.Combine(lsDir, "000003.ldb");
            var logPath = Path.Combine(lsDir, "000004.log");
            var manifestPath = Path.Combine(lsDir, "MANIFEST-000001");
            var currentPath = Path.Combine(lsDir, "CURRENT");
 
            // 1. MANIFEST
            File.WriteAllText(manifestPath,
                "manifest-000001\n" +
                "comparator: leveldb.BytewiseComparator\n" +
                "log_number: 4\n" +
                "next_file_number: 5\n" +
                "last_sequence: 15\n" +
                "compaction_pointers: {}\n" +
                "deleted_files: {}\n" +
                "new_files: {3: (\"000003.ldb\", 0, 4096, 0)}\n" +
                "live_files: [\"000004.log\"]\n");
 
            // 2. CURRENT
            File.WriteAllText(currentPath, "MANIFEST-000001\n");
 
            // 3. Empty log
            File.WriteAllBytes(logPath, new byte[0]);
 
            // 4. PRE-MADE .ldb (NO CRC, NO WRITER — JUST BYTES)
            var ldbBytes = new byte[]
            {
                // === RECORD 1: https://www.youtube.com_0VISITOR_INFO1_LIVE ===
                0x2C, 0x00, 0x00, 0x00,  // key_len = 44
                0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x79, 0x6F, 0x75, 0x74,
                0x75, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x5F, 0x30, 0x56, 0x49, 0x53, 0x49, 0x54, 0x4F, 0x52,
                0x5F, 0x49, 0x4E, 0x46, 0x4F, 0x31, 0x5F, 0x4C, 0x49, 0x56, 0x45, // "https://www.youtube.com_0VISITOR_INFO1_LIVE"
                0x0B, 0x00, 0x00, 0x00,  // value_len = 11
                0x59, 0x38, 0x71, 0x75, 0x35, 0x76, 0x34, 0x78, 0x59, 0x32, 0x6B, // "Y8qu5v4xY2k"
                0x8F, 0x3D, 0xC7, 0xA1,  // CRC32
 
                // === RECORD 2: https://www.youtube.com_0YSC ===
                0x1F, 0x00, 0x00, 0x00,  // key_len = 31
                0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x79, 0x6F, 0x75, 0x74,
                0x75, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x5F, 0x30, 0x59, 0x53, 0x43, // "https://www.youtube.com_0YSC"
                0x0C, 0x00, 0x00, 0x00,  // value_len = 12
                0x64, 0x51, 0x77, 0x34, 0x77, 0x39, 0x57, 0x67, 0x58, 0x63, 0x51, // "dQw4w9WgXcQ"
                0x1E, 0xB2, 0x9A, 0xC4,  // CRC32
 
                // === RECORD 3: https://www.google.com_0GAPS ===
                0x23, 0x00, 0x00, 0x00,  // key_len = 35
                0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x67, 0x6F, 0x6F, 0x67,
                0x6C, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x5F, 0x30, 0x47, 0x41, 0x50, 0x53, // "https://www.google.com_0GAPS"
                0x2F, 0x00, 0x00, 0x00,  // value_len = 47
                0x31, 0x3A, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
                0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64,
                0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, // "1:ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop"
                0xD7, 0xA8, 0xF1, 0x2C,  // CRC32
 
                // === RECORD 4: https://accounts.google.com_0LSID ===
                0x2B, 0x00, 0x00, 0x00,  // key_len = 43
                0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F, 0x61, 0x63, 0x63, 0x6F, 0x75, 0x6E, 0x74, 0x73,
                0x2E, 0x67, 0x6F, 0x6F, 0x67, 0x6C, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x5F, 0x30, 0x4C, 0x53, 0x49,
                0x44, // "https://accounts.google.com_0LSID"
                0x05, 0x00, 0x00, 0x00,  // value_len = 5
                0x67, 0x6D, 0x61, 0x69, 0x6C, // "gmail"
                0x9E, 0x4B, 0xC8, 0xD2   // CRC32
            };
 
            File.WriteAllBytes(ldbPath, ldbBytes);
        }
        // ------------------------------------------------------------
        //  CRC32 Helper (LevelDB uses this)
        // ------------------------------------------------------------
        private class Crc32
        {
            private uint[] table = new uint[256];
            private uint value = 0xffffffff;
 
            public Crc32()
            {
                uint poly = 0xedb88320;
                for (uint i = 0; i < 256; i++)
                {
                    uint c = i;
                    for (int k = 0; k < 8; k++)
                        c = (c & 1) > 0 ? poly ^ (c >> 1) : c >> 1;
                    table[i] = c;
                }
            }
 
            public void Update(byte[] data)
            {
                foreach (var b in data)
                    value = table[(value ^ b) & 0xff] ^ (value >> 8);
            }
 
            public uint Value => value ^ 0xffffffff;
        }
 
        // ------------------------------------------------------------
        //  Helper: random hex string
        // ------------------------------------------------------------
        private static string RandomHex(int bytes)
        {
            var buf = new byte[bytes];
            _rnd.NextBytes(buf);
            return BitConverter.ToString(buf).Replace("-", "");
        }
        */
    }
}