Mad about .NET | A blog by Jose Bonnin

Encrypting with Certificates

.NET provides us with several algorithm implementations to perform encryption and decryption. Next you can see an easy way to make use of a certificate to encrypt / decrypt using the RSACryptoServiceProvider

The first thing we need to do is to create a test certificate, this can be done by using the tool makecert. Just open the VS 2005 command prompt and type the next line:

makecert -n CN=Test -pe -ss My -sr LocalMachine

The command above will create a certificate called "Test" and will install it in the "My" location (displayed as "Personal") of the Local Computer, the -pe will mark the private key as exportable.

You can see the test certificate you have created following the next steps:

1. Run the Microsoft Management Console (MMC) snap-in utility by running the command mmc from a command prompt.
2. On the File menu, click Add/Remove Snap-in.
3. In the dialog box that displays, click Add.
4. Under Snap-in, double-click Certificates.
5. Click Computer account to access the LocalMachine store, and then click Next.
6. Click Finish.
7. Click the Certificates node, Personal, Certificates and et voila, your certificate is there.

Now let's see how we can make use of the certificate.

public static X509Certificate2 LoadCertificate(StoreName storeName, 
        StoreLocation storeLocation, string certificateName)
{
    X509Store store = new X509Store(storeName, storeLocation);
  
    try
    {
        store.Open(OpenFlags.ReadOnly);
  
        X509Certificate2Collection certificateCollection =
            store.Certificates.Find(X509FindType.FindBySubjectName, 
                                    certificateName, false);
  
        if (certificateCollection.Count > 0)
        {
            //  We ignore if there is more than one matching cert, 
            //  we just return the first one.
            return certificateCollection[0];
        }
        else
        {
            throw new ArgumentException("Certificate not found");
        }
    }
    finally
    {
        store.Close();
    }
}
  
public static byte[] Encrypt(byte[] plainData, bool fOAEP, 
                             X509Certificate2 certificate)
{
    if (plainData == null)
    {
        throw new ArgumentNullException("plainData");
    }
    if (certificate == null)
    {
        throw new ArgumentNullException("certificate");
    }
  
    using (RSACryptoServiceProvider provider = new RSACryptoServiceProvider())
    {
        // Note that we use the public key to encrypt
        provider.FromXmlString(GetPublicKey(certificate));
  
        return provider.Encrypt(plainData, fOAEP);
    }
}
  
public static byte[] Decrypt(byte[] encryptedData, bool fOAEP, 
                             X509Certificate2 certificate)
{
    if (encryptedData == null)
    {
        throw new ArgumentNullException("encryptedData");
    }
    if (certificate == null)
    {
        throw new ArgumentNullException("certificate");
    }
  
    using (RSACryptoServiceProvider provider = new RSACryptoServiceProvider())
    {
        // Note that we use the private key to decrypt
        provider.FromXmlString(GetXmlKeyPair(certificate));
  
        return provider.Decrypt(encryptedData, fOAEP);
    }
}
  
public static string GetPublicKey(X509Certificate2 certificate)
{
    if (certificate == null)
    {
        throw new ArgumentNullException("certificate");
    }
  
    return certificate.PublicKey.Key.ToXmlString(false);
}
  
public static string GetXmlKeyPair(X509Certificate2 certificate)
{
    if (certificate == null)
    {
        throw new ArgumentNullException("certificate");
    }
  
    if (!certificate.HasPrivateKey)
    {
        throw new ArgumentException("certificate does not have a private key");
    }
    else
    {
        return certificate.PrivateKey.ToXmlString(true);
    }
}

The code to use the above methods is very simple:

X509Certificate2 cert = LoadCertificate(
     System.Security.Cryptography.X509Certificates.StoreName.My,
     System.Security.Cryptography.X509Certificates.StoreLocation.LocalMachine, "Test");
 
byte[] encoded = System.Text.UTF8Encoding.UTF8.GetBytes("Encrypt me");
  
byte[] encrypted = Encrypt(encoded, true, cert);
byte[] decrypted = Decrypt(encrypted, true, cert);
 
System.Console.Out.WriteLine(System.Text.UTF8Encoding.UTF8.GetString(decrypted));

.NUG Baleares on .NET

Filed under Development

I'm proud to announce that a new .NET Users Group has been created in the Balearic Islands (Spain).

The group will try to introduce .net technologies to the developers community through different online and presential activities.

You can join us at http://www.baleareson.net (Spanish)

Handling Network Connections

Filed under Development

Talking again about my virus there was another nice thing it was doing, the virus opened IE windows redirecting to an antivirus page (it was an ironic virus).

The cool thing is that it only tried to do it when I was connected to my router, setting the browser to work offline was not enough since it tried to connect anyway in the background, but when I had my cable disconnected the virus didn't try. So I guess the virus was monitoring the network status.

To reproduce this I think the best would be to use WMI, because it provides us all kind of information regarding the system including this one. I've build a very simple class that catches the WMI events and throws a custom event notifying that the cable is connected or disconnected.

If you want to build an application that makes use of it you only need to create the handlers for the events NetworkConnect and NetworkDisconnect, and use the methods Start and Stop for monitoring the network, I think they are quite descriptive. Don't forget to call Dispose when are finished with the NetworkManager.

public class NetworkEventArgs
{
    string instanceName;
  
    public string InstanceName
    {
        get { return instanceName; }
    }
  
    public NetworkEventArgs(string name)
    {
        instanceName = name;
    }
}
  
public class NetworkManager : IDisposable
{
    private ManagementEventWatcher wmiDisconnect;
    private ManagementEventWatcher wmiConnect;
  
    public delegate void NetworkEventHandler(object sender, NetworkEventArgs e);
  
    public event NetworkEventHandler NetworkDisconnect;
    public event NetworkEventHandler NetworkConnect;
  
    private bool disposed;
  
    #region Constructor
    public NetworkManager()
    {
        wmiDisconnect = new ManagementEventWatcher(
                "SELECT * FROM MSNdis_StatusMediaDisconnect");
        wmiConnect = new ManagementEventWatcher(
                "SELECT * FROM MSNdis_StatusMediaConnect");
  
        wmiDisconnect.Scope = new ManagementScope(@"root\WMI");
        wmiConnect.Scope = new ManagementScope(@"root\WMI");
  
        wmiDisconnect.EventArrived += new EventArrivedEventHandler(WMIDisconnect_EventArrived);
        wmiConnect.EventArrived += new EventArrivedEventHandler(WMIConnect_EventArrived);
    }
    #endregion Stop
  
    #region Wmi Events
    private void WMIDisconnect_EventArrived(object sender, EventArrivedEventArgs e)
    {
        string instanceName = e.NewEvent.Properties["InstanceName"].Value as string;
  
        OnNetworkDisconnect(instanceName);
    }
  
    private void WMIConnect_EventArrived(object sender, EventArrivedEventArgs e)
    {
        string instanceName = e.NewEvent.Properties["InstanceName"].Value as string;
  
        OnNetworkConnect(instanceName);
    }
    #endregion Wmi Events
  
    #region Event Firing
    protected void OnNetworkConnect(string instanceName)
    {
        NetworkEventHandler networkConnect = NetworkConnect;
  
        if (networkConnect != null)
            NetworkConnect(this, new NetworkEventArgs(instanceName));
    }
  
    protected void OnNetworkDisconnect(string instanceName)
    {
        NetworkEventHandler networkDisconnect = NetworkDisconnect;
  
        if (networkDisconnect != null)
            NetworkDisconnect(this, new NetworkEventArgs(instanceName));
    }
    #endregion Event Firing
  
    #region Start
    public void Start()
    {
        if (disposed)
            throw new ObjectDisposedException("NetworkManager");
  
        wmiDisconnect.Start();
        wmiConnect.Start();
    }
    #endregion Start
    
    #region Stop
    public void Stop()
    {
        if (disposed)
            throw new ObjectDisposedException("NetworkManager");
  
        wmiDisconnect.Stop();
        wmiConnect.Stop();
    }
    #endregion Stop
  
    #region Dispose Related
    public void Dispose()
    {
        Dispose(true);
  
        GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                Stop();
  
                wmiConnect.Dispose();
                wmiDisconnect.Dispose();
            }
            disposed = true;
        }
    }
  
    ~NetworkManager()
    {
        Dispose(false);
    }
    #endregion Dispose Related
}

Accessing UI controls with Multithreading applications

Filed under Development

If you work with multithreading applications, probably you will need to access UI controls created in the main thread from a different thread. As you know, one of the rules of Windows programming, is that the changes done over UI controls must be done from the thread that created the control. Otherwise with .net 2.0 an exception will be thrown at execution time, but in previous versions of .net it is worse since you can obtain unexpected results.

Let's see a simple sample that would create troubles:

private void bttStart_Click(object sender, System.EventArgs e)
{
    System.Threading.Thread thread = new System.Threading.Thread(
        new System.Threading.ThreadStart(DoWork));
    thread.Name = "Worker Thread";
    thread.IsBackground = true;
    thread.Start();
}
 
private void DoWork()
{
    int iteration = 0;
    while (true)
    {
        iteration++;
        textBox1.Text = iteration.ToString(
            System.Globalization.CultureInfo.InvariantCulture);
        System.Threading.Thread.Sleep(3000);
    }
}

Therefore this is avoidable just adding a few lines more. All the UI controls have a property called InvokeRequired, which indicates if the caller comes from a different thread than the one that created the control. In this case we only need to invoke the method again in the right thread. Let's see how to fix it:

public delegate void TextUpdate(string text);
  
private void SetText(string text)
{
    if (textBox1.InvokeRequired)
    {
        textBox1.Invoke(new TextUpdate(SetText), text);
    }
    else
    {
        textBox1.Text = text;
    }
}

As you can see the changes are very simple. We have created a method called SetText, which checks if the method that is going to modify the Text property is in a different thread, if that's the case it creates an instance of the TextUpdate delegate. The delegate just points to the method SetText. Now when you call the Invoke method of the TextBox, the only thing that it will do is to call again the method SetText but this time from the thread which created the control.

Registry Handling

Filed under Development

These days I’ve been bothered by a virus that decided to live on my laptop.

I’m not going to explain how it arrived there, because I get really mad, I’m just going to give a common sense suggestion: never, never let your laptop to other people, doesn’t matter how friends you are ….

In any case there was an interesting part on all this, since the virus had nice things to learn which I’m going to try to reproduce using .NET:

The virus introduced lot of keys in the registry; one of the most interesting was added to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Notify. Maybe in another post I will explain why this one is interesting, but first let’s try to add or modify registry keys from C#.

The .NET Framework, once more, has done most of the work for us. We only need to take a look to the Microsoft.Win32 namespace and there we will find the classes "Registry" and "RegistryKey", which makes extremely easy to work with the Windows Registry.

Take a look to the next code:

string keyName = @"Software\Microsoft\Windows NT\CurrentVersion\WinLogon\Notify";
  
RegistryKey notifyKey = Registry.LocalMachine.OpenSubKey(keyName, true); 
RegistryKey testKey = notifyKey.CreateSubKey("TestKey"); 
  
testKey.SetValue("Asynchronous", 0x00000001, RegistryValueKind.DWord); 
testKey.SetValue("DllName", "FakeVirus.dll", RegistryValueKind.String); 
testKey.SetValue("Impersonate", 0x00000000, RegistryValueKind.DWord); 
testKey.SetValue("Logoff", "Logoff", RegistryValueKind.String); 
testKey.SetValue("Logon", "Logon", RegistryValueKind.String);

As you already deducted we have created a new sub key called TestKey and introduced in it 5 different values, Asynchronous, DllName, Impersonate … very easy, isn't it?

With the virus I wasn’t able to delete the registry entries added because they were regenerated immediately after any kind of change. This was done monitoring the entries, something that cannot be done directly with the managed classes but Windows supports through its API.

Reproduce this mechanism is not a big problem since even if .NET doesn’t have an equivalent method we can use p/invoke (Platform Invoke) to use the unmanaged functions of the Win32 API. For more information about it you can check the next link: http://msdn2.microsoft.com/en-us/library/ms724892.aspx

I add here the most interesting part of the code in order you can build your own monitor:

// P/Invoke methods and constants 
  
internal class NativeMethods
{
   private NativeMethods()
   {
   } 
  
   [DllImport("advapi32.dll", SetLastError = true)]
   internal static extern int RegNotifyChangeKeyValue(
      IntPtr hKey,
      [MarshalAs(UnmanagedType.Bool)] 
      bool watchSubtree,
      int dwNotifyFilter, 
      IntPtr hEvent, 
      [MarshalAs(UnmanagedType.Bool)] 
      bool fAsynchronous 
   ); 
  
   [DllImport("advapi32.dll", SetLastError = true)]
   internal static extern int RegOpenKeyEx(
      IntPtr hKey,
      string subKey,
      uint options,
      int sam,
      out IntPtr phkResult 
   ); 
  
   [DllImport("advapi32.dll", SetLastError = true)]
   internal static extern int RegCloseKey(
      IntPtr hKey 
   ); 
  
   internal const int HKEY_CLASSES_ROOT = unchecked((int)0x80000000);
   internal const int HKEY_CURRENT_USER = unchecked((int)0x80000001);
   internal const int HKEY_LOCAL_MACHINE = unchecked((int)0x80000002);
   internal const int HKEY_USERS = unchecked((int)0x80000003);
   internal const int HKEY_PERFORMANCE_DATA= unchecked((int)0x80000004);
   internal const int HKEY_CURRENT_CONFIG = unchecked((int)0x80000005);
   internal const int HKEY_DYN_DATA = unchecked((int)0x80000006); 
  
   internal const int KEY_NOTIFY = 0x0010; 
  
   internal const int REG_NOTIFY_CHANGE_NAME = 0x00000001;
   internal const int REG_NOTIFY_CHANGE_ATTRIBUTES = 0x00000002;
   internal const int REG_NOTIFY_CHANGE_LAST_SET = 0x00000004;
   internal const int REG_NOTIFY_CHANGE_SECURITY = 0x00000008;
} 
  
.................................
  
IntPtr parentKey = new IntPtr(NativeMethods.HKEY_LOCAL_MACHINE); 
  
string subKey = "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Notify\TestKey" 
  
IntPtr monitoredKey; 
  
try 
{ 
   int ret = NativeMethods.RegOpenKeyEx(parentKey, subKey, 0, NativeMethods.KEY_NOTIFY, out monitoredKey);
   if (ret != 0)
   {
      throw new Win32Exception(ret);
   } 
  
   using (AutoResetEvent monitorEvent = new AutoResetEvent(false))
   {
      ret = NativeMethods.RegNotifyChangeKeyValue(parentKey, true, 
                        NativeMethods.REG_NOTIFY_CHANGE_NAME | NativeMethods.REG_NOTIFY_CHANGE_ATTRIBUTES | 
                        NativeMethods.REG_NOTIFY_CHANGE_LAST_SET | NativeMethods.REG_NOTIFY_CHANGE_SECURITY, 
                        monitorEvent.Handle, true); 
  
      if (ret != 0)
      {
         throw new Win32Exception(ret);
      }  
  
      monitorEvent.WaitOne();
      // Do something after the registry has changed 
   } 
} 
finally
{
   parentKey = IntPtr.Zero;
   if (monitoredKey != IntPtr.Zero)
   {
      NativeMethods.RegCloseKey(monitoredKey);
      monitoredKey = IntPtr.Zero;
   } 
}

Nice, don't you think?

Encrypting with Certificates

If you like the article, please share it

.NUG Baleares on .NET

If you like the article, please share it

Handling Network Connections

If you like the article, please share it

Accessing UI controls with Multithreading applications

If you like the article, please share it

Registry Handling

If you like the article, please share it