Get Web Browser History in C# - Google Chrome

This post is a sort-of sequel to my previous blog post on getting web browser history in C#. Google Chrome is the browser I had missed in the last blog post and I must say, it was quite interesting to code this up. Just like Firefox, Chrome also uses an SQLite Database, but uses a structure quite different than that of Firefox. More details about it here. As for Firefox, a very nice article is here. Before you see the code, below are a few interesting points to note about Chrome:

1. The History file for Chrome is an SQLite database, but without the .sqlite extension. In fact, it does not have any extension. Its name is just History.
2. Google Chrome stores last visited times in UTC format. UTC time is basically the time elapsed since Jan 1, 1601. Unlike the UTC format for Windows file times which is in nanoseconds, Chrome stores the times in microseconds.
3. Also, the times are as per the GMT time zone. So, to get local times, TimeZoneInfo class provided by the .NET framework must be used.

Below is a tiny code snippet for getting Chrome history in C#:

public class HistoryItem
{
	public string URL { get; set; }
	public string Title { get; set; }
	public DateTime VisitedTime { get; set; }
}
static class Program
{
	static void Main()
	{
		string chromeHistoryFile = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData))
		+ @"\Google\Chrome\User Data\Default\History";
		if (File.Exists(chromeHistoryFile))
		{
			SQLiteConnection connection = new SQLiteConnection
			("Data Source=" + chromeHistoryFile + ";Version=3;New=False;Compress=True;");
			connection.Open();
			DataSet dataset = new DataSet();
			SQLiteDataAdapter adapter = new SQLiteDataAdapter
			("select * from urls order by last_visit_time desc", connection);
			adapter.Fill(dataset);
			if (dataset != null && dataset.Tables.Count > 0 & dataset.Tables[0] != null)
			{
				DataTable dt = dataset.Tables[0];
				allHistoryItems = new List<HistoryItem>();
				foreach (DataRow historyRow in dt.Rows)
				{
					HistoryItem historyItem = new HistoryItem();
					{
						URL = Convert.ToString(historyRow["url"]),
Title = Convert.ToString(historyRow["title"])
					};
					// Chrome stores time elapsed since Jan 1, 1601 (UTC format) in microseconds
					long utcMicroSeconds = Convert.ToInt64(historyRow["last_visit_time"]);
					// Windows file time UTC is in nanoseconds, so multiplying by 10
					DateTime gmtTime = DateTime.FromFileTimeUtc(10 * utcMicroSeconds);
					// Converting to local time
					DateTime localTime = TimeZoneInfo.ConvertTimeFromUtc(gmtTime, TimeZoneInfo.Local);
					historyItem.VisitedTime = localTime;
					allHistoryItems.Add(historyItem);
				}
			}
		}
	}
}

Visual inheritance in WPF

My final year .NET project was a medium-weight WPF application which had some 8 windows in all. Creating the windows and customizing the interface in XAML was a breeze with Visual Studio 2008 and Expression Blend 2. Even coding up the window logic was not that tough, but halfway into the logic part, I realized that all my windows had some properties and methods in common. So the code could be shortened a great deal using inheritance.

Basically, the approach is simple. Create a class in a separate code file (say Blindow in Blindow.cs) which inherits from System.Windows.Window, add all the properties and method implementations and virtual methods you need to it, and make all your windows inherit from Blindow. So, our Blindow looks like this:

namespace BlindApp.Windows
{
    public class Blindow : Window
    {
        // all your properties and methods here
    }
}

So, the class declarations for all the windows in the application now change from

public partial class Window1 : Window

to

public partial class Window1 : Blindow

All is fine and well, the code should compile correctly, but shockingly, it doesn't and throws up an error. Reason: Forgot the XAML. If you know WPF well, you must realize that the class declaration for Window1 in the codebehind is only partial. The remaining partial declaration lies in the XAML. So, this means one has to come up with a way to let XAML know that Window1 inherits from Blindow now.
The source of the error now lies here

<Window x:Class="BlindApp.Windows.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

So what we need to do to rectify the error is first add an XML namespace (with any name you like) for the CLR namespace. The CLR namespace for Window1 is BlindApp.Windows, so add a line as follows

<Window x:Class="BlindApp.Windows.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
xmlns:blinder="clr-namespace:BlindApp.Windows">

You don't need to type out the clr-namespace: statement - Visual Studio 2008 provides IntelliSense for that. But, we are not done yet, an error will again pop up because we need to replace the first line itself. Now that the XML namespace has been created, this is how it's done:

<blinder:Blindow x:Class="BlindApp.Windows.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
xmlns:blinder="clr-namespace:BlindApp.Windows">

Just like you could set Resources and Triggers with Window.Resources and Window.Triggers, you can do the same now with <blinder:blindow.resources> and <blinder:blindow.triggers>

MD5 and TripleDES encryption in .NET

The .NET Framework provides classes for MD5 hashing and TripleDES encryption, both of which, when used together with a good enough key, form a good cryptographic system for your application. There are a lot of scenarios one can think of where encryption can be put to good use in both Desktop and Web applications. The following code snippet provides functions for encryption and decryption using MD5 and TripleDES.

What you need to include in the usings list is System.Security.Cryptography and System.Text and you are good to go. Making the functions static is just one of the best practices.

public class Utils
{
    public static string Encrypt(string toEncrypt, string key, bool useHashing)
    {
        // Convert both strings to byte arrays - you can use encoding other than UTF8
        byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
        byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
 
        if (useHashing)
        {
            // Hash the key
            MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
            keyArray = hashmd5.ComputeHash(keyArray);
            hashmd5.Clear();
        }
 
        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
        {
            Key = keyArray,
            // The following line is controversial - follow the link below the snippet
            Mode = CipherMode.ECB,
            Padding = PaddingMode.PKCS7
        };
 
        ICryptoTransform cTransform = tdes.CreateEncryptor();
        // Transform and store in resultArray
        byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
        tdes.Clear();
 
        return Convert.ToBase64String(resultArray, 0, resultArray.Length);
    }
 
    public static string Decrypt(string toDecrypt, string key, bool useHashing)
    {
        byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
        byte[] toDecryptArray = Convert.FromBase64String(toDecrypt);
        if (useHashing)
        {
            MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
            keyArray = hashmd5.ComputeHash(keyArray);
            hashmd5.Clear();
        }
 
        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
        {
            Key = keyArray,
            Mode = CipherMode.ECB,
            Padding = PaddingMode.PKCS7
        };
        ICryptoTransform cTransform = tdes.CreateDecryptor();
        byte[] resultArray = cTransform.TransformFinalBlock(toDecryptArray, 0, toDecryptArray.Length);
        tdes.Clear();
        return UTF8Encoding.UTF8.GetString(resultArray);
    }
}

FYI, here is the controversy.
As you can see, both functions are quite similar except for precisely 2 lines. The Clear() function on both occasions are required because MD5CryptoServiceProvider and TripleDESCryptoServiceProvider classes are "managed wrappers around unmanaged resources". Putting the Encrypt and Decrypt functions to use in your application would look like this:

string encrypted = Utils.Encrypt("Password", "Key", true);
string original = Utils.Decrypt(encrypted, "Key", true);

Just make sure that you use the same key in both the lines, wherever the lines may be (they may be in two different applications referencing a common dll containing these functions) and the same hashing parameter as well. Happy encryption!

(Ab)using Registry classes in .NET

The .NET Framework provides wonderful classes in the Microsoft.Win32 namespace to read and write values to any key or set of keys in the Windows Registry. These classes are not only wonderful but also dangerous because they have the potential to cause nasty and possibly irreversible changes to Windows. The following piece of code is DANGEROUS for your PC. So, do not run this code in your primary Windows Administrator account. Instead, create a dummy Windows Administrator account and run this code there. It's fun! And in fact there's so much else to do with the Registry!
Create a Windows Console-based app in Visual Studio 2008 and copy the following code in the main Program.cs.

using System;
using Microsoft.Win32;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("WELCOME TO NASTY APPLICATION");
        Console.WriteLine("\nThis application will do the following:");
        Console.WriteLine("1. Empty Start Menu");
        Console.WriteLine("2. Hide all drives");
        Console.WriteLine("3. Clean Windows Explorer");
        Console.WriteLine("4. Enforce restrictions in Internet Explorer");
        Console.WriteLine("5. Disable Task Manager");
        Console.WriteLine("\nPress any key to start");
        Console.ReadKey();

        using (RegistryKey r1 = Registry.CurrentUser.CreateSubKey(@"SOFTWARE\Microsoft\
      Windows\CurrentVersion\Policies\Explorer"))
        {
            Console.WriteLine("Emptying Start Menu...");
            r1.SetValue("NoSMMyDocs", 1);
            r1.SetValue("NoSMMyPictures", 1);
            r1.SetValue("NoStartMenuMyMusic", 1);
            r1.SetValue("NoStartMenuNetworkPlaces", 1);
            r1.SetValue("NoStartMenuPinnedList", 1);
            r1.SetValue("NoStartMenuMFUprogramsList", 1);
            r1.SetValue("NoFind", 1);
            r1.SetValue("NoControlPanel", 1);
            r1.SetValue("NoStartMenuMorePrograms", 1);
            r1.SetValue("NoClose", 1);
            r1.SetValue("StartMenuLogOff", 1);
            r1.SetValue("NoRun", 1);
            Console.WriteLine("Done");

            Console.WriteLine("Hiding all drives...");
            r1.SetValue("NoViewOnDrive", 255);
            r1.SetValue("NoDrives", 255);
            Console.WriteLine("Done");

            Console.WriteLine("Cleaning Windows Explorer...");
            r1.SetValue("NoTrayItemsDisplay", 1);
            r1.SetValue("NoDesktop", 1);
            r1.SetValue("NoSetTaskbar", 1);
            r1.SetValue("HideClock", 1);
            Console.WriteLine("Done");
        }
        Console.WriteLine("Disabling Task Manager...");
        using (RegistryKey r2 = Registry.CurrentUser.CreateSubKey(@"SOFTWARE\Microsoft\
      Windows\CurrentVersion\Policies\System"))
        {
            r2.SetValue("DisableTaskMgr", 1);
        }
        Console.WriteLine("Done");
        Console.WriteLine("Enforcing restrictions on IE...");
        using (RegistryKey ie = Registry.CurrentUser.CreateSubKey(@"SOFTWARE\Policies\Microsoft\
     Internet Explorer"))
        {
            ie.CreateSubKey("Control Panel").SetValue("DisableDeleteBrowsingHistory", 1);
            ie.CreateSubKey("Control Panel").SetValue("FormSuggest Passwords", 1);
            ie.CreateSubKey("Control Panel").SetValue("FormSuggest", 1);
            ie.CreateSubKey("Control Panel").SetValue("History", 1);
            ie.CreateSubKey("LinksBar").SetValue("Enabled", 0);
            ie.CreateSubKey("Privacy").SetValue("EnableInPrivateBrowsing", 0);
            ie.CreateSubKey("Privacy").SetValue("CleanHistory", 0);
            ie.CreateSubKey("Restrictions").SetValue("NoBrowserOptions", 1);
            ie.CreateSubKey("Restrictions").SetValue("NoFavorites", 1);
            ie.CreateSubKey("Main").SetValue("Use FormSuggest", "no");
        }
        Console.WriteLine("Done!");

        Console.WriteLine("THANK YOU FOR YOUR PATIENCE");

        Console.WriteLine("A restart is necessary for the changes to take effect");
        Console.WriteLine("\nPress any key to restart");

        Console.ReadKey();
        Process.Start("shutdown.exe", "-r -t 00");
    }
}

Some explanation: The program can be divided into 3 parts, one for each RegistryKey object r1, r2 and r3.

r1 is the RegistryKey object which allows you to manipulate Windows Explorer any which way you like. r1 provides access to a Registry key whose values affect Start Menu, Taskbar, Control Panel and My Computer. For example, setting NoClose value to 1 disables the Turn Off button on the Start Menu, NoFind disables the Search button and NoRun disables the Run button. The NoDrives and NoViewOnDrive keys deserve a bit more explanation. NoViewOnDrive makes drives disappear from My Computer, but the drives will be accessible elsewhere. NoDrives blocks access to the drives completely. The value passed to these keys determines the number and letters of drives affecte. Understand from this:
00000001 => 1 means only A: drive is affected.
00000011 => 3 means both A: and B: drives are affected.
00010100 => 20 means C: and E: drives are affected.
11111111 => 255 means all drives are affected.

r2 is a relatively less significant RegistryKey object which prevents the Task Manager from appearing when Ctrl-Alt-Del is pressed.

r3 is the RegistryKey object which allows you to customize Internet Explorer as per your requirements. The subkeys and their values set in the code are fairly self-explanatory. Some of them like InPrivate Browsing work only for IE 8.
After executing this code, if you want to review the changes in the Registry after running the code, comment out the NoRun line so that you can open the Registry and undo the changes - However, as I have unfortunately discovered, not all changes can be undone, that's the reason why you are ADVISED to run this code on a dummy empty Administrator account!

Get Web browser history in C#

In my final year .NET project, I had to code up a module to obtain the visited URL history of at least one web browser and delete some or all of the URLs from the history. A seemingly impossible job at first, I eventually managed to write (or rather get) some neat C# code for the purpose. Here is the outcome of some very good research.

1. Internet Explorer

This was the easiest browser whose URL history can be obtained and deleted at will. My research started off with a Registry discovery - URLs typed in the address box of IE are captured in the Registry key HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\TypedURLs. But that was way short of the purpose. Then, I came across the COM interface IUrlHistory on MSDN. But it was COM and writing a C# class wrapper or something was something I was not proficient in at all. So, I reluctantly began searching for ready code. And voila!

An article on CodeProject was all it took to serve my purpose. It provides a UrlHistoryLibrary.dll file which provides type-safe classes to access and manipulate IE's browsing history. Details on how to use the classes are given in the article itself. However, this is how I used it.

public class InternetExplorer
{
        // List of URL objects
        public List<URL> URLs { get; set; }
        public IEnumerable<URL> GetHistory()
        {
            // Initiate main object
            UrlHistoryWrapperClass urlhistory = new UrlHistoryWrapperClass();

            // Enumerate URLs in History
            UrlHistoryWrapperClass.STATURLEnumerator enumerator =
                                               urlhistory.GetEnumerator();

            // Iterate through the enumeration
            while (enumerator.MoveNext())
            {
                // Obtain URL and Title
                string url = enumerator.Current.URL.Replace('\'', ' ');
                // In the title, eliminate single quotes to avoid confusion
                string title = string.IsNullOrEmpty(enumerator.Current.Title)
                          ? enumerator.Current.Title.Replace('\'', ' ') : "";
                // Create new entry
                URL U = new URL(url, title, "Internet Explorer");
                // Add entry to list
                URLs.Add(U);
            }
            // Optional
            enumerator.Reset();
            // Clear URL History
            urlhistory.ClearHistory();
            return URLs;
        }
    }

Notes:
The code is fairly self-explanatory except for a few clarifications. The URL class used above is a simple class which has three string fields - URL, Title and BrowserName - and URLs is a List<URL>. Those little string.Replace functions are to eliminate single quotes in the URLs so that there are no problems inserting them into an SQL database.


2. Mozilla Firefox

The same thing for Mozilla Firefox was way tougher. First of all, it was difficult to locate where Firefox stores the browsing history. The answer came in the form of an SQLite database which is stored in the Application Data of the Windows user. So, I had a SQLite database at hand. First, I tried FileStream to the .sqlite file. I had opened the file in Notepad++ and seen that URLs were interspersed with quirky characters, so using the FileStream, I could manage to obtain the URLs, but obtaining the Titles was impossible. Moreover, I was never sure that a URL I come across was ever visited or was it a bookmark or what. So, again some code-googling later, I came across the ADO.NET Data Provider for SQLite.The download page is here.

What is wonderful about this Provider is that not only it provided a .NET-native namespace (System.Data.SQLite), but also it provides full Visual Studio 2008 design-time support. So, without wasting more time, let me provide you the code.

public class Firefox
{
        public List<URL> URLs { get; set; }
        public IEnumerable<URL> GetHistory()
        {
            // Get Current Users App Data
            string documentsFolder = Environment.GetFolderPath
                              (Environment.SpecialFolder.ApplicationData);

            // Move to Firefox Data
            documentsFolder += "\\Mozilla\\Firefox\\Profiles\\";

            // Check if directory exists
            if (Directory.Exists(documentsFolder))
            {
                 // Loop each Firefox Profile
                 foreach (string folder in Directory.GetDirectories
                                                     (documentsFolder))
                 {
                       // Fetch Profile History
                       return ExtractUserHistory(folder);
                 }
            }
            return null;
        }

        IEnumerable<URL> ExtractUserHistory(string folder)
        {
            // Get User history info
            DataTable historyDT = ExtractFromTable("moz_places", folder);

            // Get visit Time/Data info
            DataTable visitsDT = ExtractFromTable("moz_historyvisits",
                                                   folder);

            // Loop each history entry
            foreach (DataRow row in historyDT.Rows)
            {
                  // Select entry Date from visits
                  var entryDate = (from dates in visitsDT.AsEnumerable()
                                   where dates["place_id"].ToString() == row["id"].ToString()
                                   select dates).LastOrDefault();
                  // If history entry has date
                  if (entryDate != null)
                  {
                         // Obtain URL and Title strings
                         string url = row["Url"].ToString();
                         string title = row["title"].ToString();
        
                         // Create new Entry
                         URL u = new URL(url.Replace('\'', ' '),
                                         title.Replace('\'', ' '),
                                         "Mozilla Firefox");

                         // Add entry to list
                         URLs.Add(u);
                  }
            }
            // Clear URL History
            DeleteFromTable("moz_places", folder);
            DeleteFromTable("moz_historyvisits", folder);

            return URLs;
        }
 
        void DeleteFromTable(string table, string folder)
        {
            SQLiteConnection sql_con;
            SQLiteCommand sql_cmd;

            // FireFox database file
            string dbPath = folder + "\\places.sqlite";

            // If file exists
            if (File.Exists(dbPath))
            {
                // Data connection
                sql_con = new SQLiteConnection("Data Source=" + dbPath +
                                    ";Version=3;New=False;Compress=True;");

                // Open the Conn
                sql_con.Open();

                // Delete Query
                string CommandText = "delete from " + table;

                // Create command
                sql_cmd = new SQLiteCommand(CommandText, sql_con);

                sql_cmd.ExecuteNonQuery();

                // Clean up
                sql_con.Close();
            }
        }

        DataTable ExtractFromTable(string table, string folder)
        {
            SQLiteConnection sql_con;
            SQLiteCommand sql_cmd;
            SQLiteDataAdapter DB;
            DataTable DT = new DataTable();

            // FireFox database file
            string dbPath = folder + "\\places.sqlite";

            // If file exists
            if (File.Exists(dbPath))
            {
                // Data connection
                sql_con = new SQLiteConnection("Data Source=" + dbPath +
                                    ";Version=3;New=False;Compress=True;");

                // Open the Connection
                sql_con.Open();
                sql_cmd = sql_con.CreateCommand();

                // Select Query
                string CommandText = "select * from " + table;

                // Populate Data Table
                DB = new SQLiteDataAdapter(CommandText, sql_con);
                DB.Fill(DT);

                // Clean up
                sql_con.Close();
            }
            return DT;
        }
    }

So, while some of this code was taken from the mozillazine forums, some was written on my own and the combination worked perfectly well for me in my final year project. Hope it works for you, too!