Friday, October 17, 2014

MVVM PasswordBox, SecurePassword and SecureString


PasswordBox implementation using MVVM is one of the widly debated topic around MVVM arena. Problem statement is how to bind Password property of PasswordBox to a property in a ViewModel. This problem stems from the fact that Password property of the PasswordBox is not a dependency property for obvious security reasons, hence we cant bind it as we would normally do.


Now there are many solutions and workarounds like having event in ViewModel that is registerd in view and acts as the password catcher, passing whole PasswordBox to ViewModel in command paramter of login button Command, having content control binding to the property in ViewModel of type PasswordBox, handling password change in code behind and creating PasswordBoxHelper attached behaviour etc.

You can find the discussion and solutions in below thread :-

http://stackoverflow.com/questions/1483892/how-to-bind-to-a-passwordbox-in-mvvm

What I found well suited in accordance with the MVVM implementation is having attached property extend the PasswordBox and provide much needed dependency property for binding. Below is sample of PasswordHelper class that extends the PasswordBox and provide dependency property BindablePassword for binding.

Sample is based on below blog post

http://blog.functionalfun.net/2008/06/wpf-passwordbox-and-data-binding.html

I have modified the PasswordHelper class to incorporate following :-

1) Implementation of SecureString type for dependency property instead of String.

2) Binding SecureString type property from ViewModel to PasswordBox's SecurePassword property instead of Password property.

3) Utility method to convert from SecureString to String and vice versa.

These all have been implemented to tackle the security issues with implementing dependency property as String. Which I will shortly demonstrate.

PasswordHelper
public static class PasswordHelper
{

public static readonly DependencyProperty BindablePasswordProperty =
DependencyProperty.RegisterAttached("BindablePassword",
typeof(SecureString), typeof(PasswordHelper),
new FrameworkPropertyMetadata(string.Empty, OnPasswordPropertyChanged));

public static readonly DependencyProperty BindPasswordProperty =
DependencyProperty.RegisterAttached("BindPassword",
typeof(bool), typeof(PasswordHelper), new PropertyMetadata(false, BindPassword));

private static readonly DependencyProperty UpdatingPasswordProperty =
DependencyProperty.RegisterAttached("UpdatingPassword", typeof(bool),
typeof(PasswordHelper));

public static void SetBindPassword(DependencyObject dp, bool value)
{
     dp.SetValue(BindPasswordProperty, value);
}

public static bool GetBindPassword(DependencyObject dp)
{
      return (bool)dp.GetValue(BindPasswordProperty);
}

public static string GetBindablePassword(DependencyObject dp)
{
      return (string)dp.GetValue(BindablePasswordProperty);
}

public static void SetBindablePassword(DependencyObject dp, SecureString value)
{
      dp.SetValue(BindablePasswordProperty, value);
}

private static bool GetUpdatingPassword(DependencyObject dp)
{
      return (bool)dp.GetValue(UpdatingPasswordProperty);
}

private static void SetUpdatingPassword(DependencyObject dp, bool value)
{
      dp.SetValue(UpdatingPasswordProperty, value);
}

private static void OnPasswordPropertyChanged(DependencyObject sender,
DependencyPropertyChangedEventArgs e)
{
     PasswordBox passwordBox = sender as PasswordBox;
     passwordBox.PasswordChanged -= PasswordChanged;
     if (!(bool)GetUpdatingPassword(passwordBox))
    {
         passwordBox.Password = (string)e.NewValue;
    }
    passwordBox.PasswordChanged += PasswordChanged;
}

private static void BindPassword(DependencyObject sender,
DependencyPropertyChangedEventArgs e)
{
     PasswordBox passwordBox = sender as PasswordBox;
     if (passwordBox == null)
           return;
     if ((bool)e.OldValue)
    {
        passwordBox.PasswordChanged -= PasswordChanged;
     }
     if ((bool)e.NewValue)
    {
        passwordBox.PasswordChanged += PasswordChanged;
    }
}

private static void PasswordChanged(object sender, RoutedEventArgs e)
{
    PasswordBox passwordBox = sender as PasswordBox;
    SetUpdatingPassword(passwordBox, true);
    SetBindablePassword(passwordBox, passwordBox.SecurePassword);
    SetUpdatingPassword(passwordBox, false);
}
}

View Model

public class MainWindowViewModel

{
   SecureString networkPassword;
   public SecureString NetworkPassword
   {
      get
      {
          return networkPassword;
      }
      set
     {
          networkPassword = value;
      }
}

public MainWindowViewModel()
{
     //Just for demo
     NetworkPassword = SecureStringUtility.ConvertToSecureString("SomeString");
}
}

View

<xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:PBinding"
Title="MainWindow" Height="350" Width="525">

  
       
<  local:PasswordHelper.Password="{Binding Path=NetworkPassword, Mode=TwoWay,      

      UpdateSourceTrigger=PropertyChanged}"
      Height="80"
      Margin="2" />
  


  Sample is simple containing window with PasswordBox control, a ViewModel with single property NetworkPassword to bind to PasswordBox, PasswordHelper class to extend PasswordBox and Utility methods to convert from SecureString to String and vice versa.

Let come to the reason for implementing SecureString in PasswordHelper class. If we go by the orignal sample PasswordAssistant class from above blog which is implementing String as dependency property, we would get into some security risk as below screenshot shows. Password can be easily reterived using WPF sniffer tool like Snoop which I have used.


So as we can see Password in password field of PasswordAssistant class is easily visible if Dependency Property is of Type String in PasswordAssistant class.

Now below is the screen shot of same application using PasswordHelper class with SecureString implementation.



SecureString is type from System.Security namespace and PasswordBox in WPF also contains property SecurePassword along with Password property. These both properties are not Dependency properties so can't be used in binding. For that reason we have to come up with Attached dependency property for PasswordBox with with we can bind our ViewModel's property. Now property in ViewModel should also be SecureString type as we have to bind it with SecureString type dependency property.

So in our application,Password remains as secure string and can be converted from Secure string to string and vice versa wherever needed. This can be done using utility methods ConvertToUnsecureString and ConvertToSecureString.

public static string ConvertToUnsecureString(SecureString securePassword)
{
    if (securePassword == null)
    throw new ArgumentNullException("securePassword");
    IntPtr unmanagedString = IntPtr.Zero;
    try
   {
     unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(securePassword);
     return Marshal.PtrToStringUni(unmanagedString);
    }
    finally
   {
       Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
   }
}

public static SecureString ConvertToSecureString( string password)
{
    if (password == null)
    throw new ArgumentNullException("password");
    unsafe
   {
      fixed (char* passwordChars = password)
      {
          var securePassword = new SecureString(passwordChars, password.Length);
          securePassword.MakeReadOnly();
          return securePassword;
      }
}

These methods proper implementation has been taken from the blog :-
http://blogs.msdn.com/b/fpintos/archive/2009/06/12/how-to-properly-convert-securestring-to-string.aspx

We have just modified the PasswordHelper class to provide secure and proper MVVM based implementation for PasswordBox. Hope it will be helpful.

Sunday, October 12, 2014

Visual Studio Team Foundation Server (Visual Studio Online )

These are very exiting times and a lot of things are going around technologies and businesses. The competitive market is demanding continuous, improved, innovative and affordable products. There is race among companies to introduce next big thing in there respective arenas. Need for continuous release of products in market to get early feedback and rapid prototyping, demands tools and processes that will facilitate rapid development, resourcefulness, optimized cost and better project tracking.

This led me to explore Visual Studio Team Foundation Server (Visual Studio Online) for complete Application Life cycle Management (ALM) solution. Experience was quite good with my setup of Visual Studio 2014 CTP and Visual Studio Online.

Here is the snapshot of Visual Studio 2012 team explorer that integrates with Visual Studio Online portal for our team project. There are options to choose Version control system for code repository from : VS TFS and Git


We can easily navigate to Visual Studio Online to get the project stats. Below is the home screen for portal.

Here on portal you can see link Home, Code, Work , Build and Test. These are the base categories which are fully configurable to individual project requirements. On home screen we can find various options for :-
1) Managing Team members
2) Managing Work areas
3) Creating Schedules and iterations.
4) Managing Backlogs and sprints.
5) Kanban Boards
5) Team Boards etc

Once code has been uploaded to repository on TFS or GIT here is view under code menu.



From home screen we can configure our Sprints and schedules, below are screenshots from sample project:-





Once we have planned our sprints, we can manage backlogs, assign work items and track sprints.



An intuitive interface to manage all the project activities.
Automated build process and testing, these are the areas which I still need to explore, but overall a good experience so far. Will keep on posting about further exploration.

http://msdn.microsoft.com/en-us/library/dd286521.aspx

Sunday, September 25, 2011

Java api in .Net (JavaIntrop)

In my previous blog I have said something about using a java library in .Net . My case demanded me to use a java library in .Net . Many times we find  a decent and clean library to use but its a java library and some time we find a java library that is impossible to ignore , in that case we hope for a way to use java api in .Net . I roamed the net and tried the fit and that fit happened to fit my case.  That is IKVM.Net by Jeroen Frijters .

http://www.ikvm.net/index.html

IKVM.net is a open source  java implementation , that comes with the OpenJdk  implementation  in .Net and various tools to interop between  java and .Net  . Whole JVM is implemented in  .Net and its very easy to convert java jar files to .Net assemblies and .Net assemblies to java  jars (interface and stub classes ).

Taking on my case to convert java jar files to .Net assemblies , there comes a command line utility with IKVM called ikvmc.exe . To generate the .Net assembly for a jar file we first specify the command line switch [-target:library] for generating  a dll .  Without this command line switch ikvmc.exe will generate a exe for a jar file if it encounters a main method in a class.  On command prompt we change directory to IKVM binaries folder and specify command :

C:\IKVM>ikvmc.exe –target:library  hapi-base-1.2.jar

The jar file is in same directory as ikvm binaries , this will generate the hapi-base-1.2.dll . There will be many warnings by ikvmc.exe of noclassdeffound  , this is because we haven’t specified the dependency dll’s. IKVM comes with the OpenJdk implementation in .Net and they are in form of dll’s. Now we have to specify the OpenJdk dll’s that our jar file depends upon to rectify the warnings.

C:\IKVM>ikvmc.exe –target:library  hapi-base-1.2.jar –reference:IKVM.OpenJDK.Core.dll  -reference:IKVM.OpenJDK.Util.dll

In example I have only referenced some of OpenJdk dll’s , but we have to reference all the dll’s that our jar file depends upon.  Upon completion of the command a hapi-base-1.2.dll will be generated . Now moving on to next jar file (hapi-structures-v21-1.2.jar).

C:\IKVM>ikvmc.exe –target:library  hapi-structures-v21-1.2.jar –reference:IKVM.OpenJDK.Core.dll  -reference:IKVM.OpenJDK.Util.dll

As this new jar file have dependency on previous jar file , we have to reference the dll of previous jar file to make a successful porting of this jar file to a dll.

C:\IKVM>ikvmc.exe –target:library  hapi-structures-v21-1.2.jar –reference:hapi-base-1.2.dll  –reference:IKVM.OpenJDK.Core.dll  -reference:IKVM.OpenJDK.Util.dll

And so on we can create dll’s from jar files resolving the dependency using the [-reference:<dllname>] .Now these dll’s are ready to be used in your .Net project . We have to at least add reference of IKVM.Runtime.dll in our project and other OpenJdk dll’s that out converted jar dll’s depend upon.  Keep on porting .

Friday, September 23, 2011

Health Standard 7 (HL7) Development - C#

Getting into the development of  HL7 system , there are not many free libraries on net to start with.  HL7 being the standard way to talk between various components in a modern medical infrastructure is a way too old format to work with (except with new xml based HL7 3.0).  This lend to the complexity while dealing with the HL7 development. 

HL7 messages is a flat text with standard specifying the format of the message. HL7 message is divided into segments to hold the medical record information of various types (ex patient details, insurance details,patient visit etc). These segments are separated by carriage returns. 

MSH|^~\&|DDTEK LAB|ELAB-1|DDTEK OE|BLDG14|200502150930||ORU^R01^ORU_R01|CTRL-9876|P|2.4 CR 
PID|||010-11-1111||Estherhaus^Eva^E^^^^L|Smith|19720520|F|||256 Sherwood Forest CR
EVN|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||CR OBR|1|948642^DDTEK OE|917363^DDTEK LAB|1554-5^GLUCOSE|||200502150730||||||||| CR

Segments  are  divided into fields separated by the pipe (|) and further fields are divided into   components and subcomponents separated  by  “ ^ “ .  There has been many versions of HL7 standards with several updates and new additions, primarily we can deduct most important versions to be  2.1,  2.3,  2.4,  2.5,  2.6  (2.x version) . Out of which 2.5 is most widely used and  stable version . Version  3.0 of  HL7 is a move to shift from flat file base to new xml based HL7 standard format,  but it is not yet that much accepted in common use.

Now coming on to the development of HL7 standard from the view point of .Net developer, what many option do we really have ?.  Having good knowledge of what to implement is easy as there are many resources available to make our self familiar with nitty-gritty of HL7 standard  , but having the tools to implement HL7 is another matter.  There is support from Microsoft on HL7 in form of BizTalk Accelerator for HL7 ( http://www.microsoft.com/biztalk/en/us/accelerator-hl7.aspx )   , but as you guessed its not free  . Second option is to write a new library to deal with HL7, but its not a trivial task , as HL7 standard is divided into various versions and industry implement all these versions to certain degree . Another option is to write only specific demand based api for HL7 , targeting a single module or implementation of certain feature of HL7, but that's also not a very good solution as what happens when that specific api expands to accommodate multiple version of HL7. Why to reinvent the wheel , there should be some thing on web that targets the HL7 development in  .Net.  

Two top notch free solution for HL7 development are Hapi and NHapi . Hapi is open source extensive  java library   to deal with almost all the versions and angles of HL7 development.  Nhapi is  .Net implementation of the Hapi project.

Hapi:-  http://hl7api.sourceforge.net/

NHapi:- http://nhapi.sourceforge.net/home.php

So we do have .Net open source library for HL7 development . NHapi supports versions from 2.1  to  2.5 and will suffice for most of HL7 related development.  API’s are simple and easy to use . It creates a Object model for a HL7 message being parsed and can convert that into HL7 standard xml for easy use or for transformation via xslt. Using the HL7 message object model we can do variety of things related to the HL7 parsing and creation. 

Downside is that Nhapi is not as extensive as Hapi (Java library).    HL7 message validation is not there except for some low level validation (e.g  MSH segment validation , primitive validation etc ) . HL7 communication module is not there . Support up to 2.5 version of HL7 as comparison to  Hapi support up to 2.6 version . Most important of all there has been no activity recorded for Nhapi for some time and it makes future dependence on Nhapi a little scary (although its a open source and anybody is invited to contribute and extend ). 

Hapi is on the top list when it comes to the HL7 library , they recently released  Hapi 1.2 in June and forums are abuzz with discussions . Support for 2.6 is included and future support for HL7 3.0 and more are anticipated. HL7 message validation is very mature and there is good support for HL7 message communication .

So the question is how we,  .Net developers can leverage Hapi project and use it in our .Net applications . The answer can be  in using   java in [ .Net] ,  is it possible ? . Yes we can use java libraries in [.Net] , as they are [.Net] libraries and can use  full feature of  Hapi project.

Java interop tool developed  Jeroen Frijters (who is contributed for bringing  J# to its demise)  is the best and easy bet to use Hapi java api in .Net . I have done it and it works great . I will be soon writing on how to convert java jar files to .Net assemblies.

Technorati Tags:

Friday, July 15, 2011

Microsoft Extensibility ( MEF 4.0) :-

Writing an extensible application is always a challenge , considering the incorporation of future functionalities that are not known at the time of designing application architecture.  Extensible application basically consists of the core framework that has to remain unchanged and work as the base engine for application , extending the application at runtime.

One very good example of extensible application can be seen in design architecture of the Sharp-develop  IDE.  I have previously blogged about the Sharp-develop and its design . Sharp-develop application consists of base engine -SharpDevelop.Core ,  which is the responsible for loading up all the add-ins and extending the application at runtime.  

SharpDevelop uses add-in based extensibility . Microsoft has always provided the extensibility framework to design our application upon . Add-in based framework such as Add-in pipeline framework let us to create a host application and expose its Object model to be extended by the application addins . There is well defined architecture for this kind of application development  consisting of Host,  Hostadpter, Addinadpater, Addin . You can look my previous blogs on add-in pipeline development for detail into architecture. One good example of application that follows the Add-in pipeline development is VSTA  (Visual studio tools for application) which uses the addin framework provided in System.Addin and its sister namespaces. Details for VSTA can also be found in my previous blog entries.

The new child on the block in the arena of extensibility from Microsoft is MEF (Microsoft Extensibility Framework). It is projected as the extensible framework and also have the capability of DI (Dependency Injection) as Unity framework. While Unity framework is DI framework , MEF work as extensibility framework along with DI capabilities . For detail in to MEF programming you can check my previous blog entries .

I have my share of experience  of developing application using MEF .  Although MEF acts great whereas its DI capabilities and functionalities are concerned , but lack of support for standard publish/subscribe mechanism and modularity functionalities within the framework itself  is somehow concerning.  We have to use MEF extensions provided within PRISM library to fully achieve extensibility features.  PRISM with MEF is great , where we have to develop an extensible UI based application . It provides us with standard publish/subscribe mechanism which is loosely coupled with in the application and uses weak references for events. Then we have Modularity in form of IModule which help us to get a extensible UI based application. There are all other great  features of PRISM , but if we can get the above said features right in MEF it will  greatly ease the development of application which is not UI based .

Hopefully I will write some details upon MEF extension within PRISM 4.0 .

Friday, March 4, 2011

C# :- Imaging ( AForge.net )

If you are doing some image processing there is an interesting and cool open source project called AForge.net .  It contains many routines and filters for image processing.  I started playing with Glyph’s Recognition,  glyph’s recognition engine is provided by AForge Framework.   There is  GRATF  (Glyph Recognition and Tracking Framework)  project  based upon  AForge framework.  GRATF framework mainly deals with the Glyph recognition algorithm and glyph tracking  , utilizing the AForge.Net  image processing library. 

To  get started with Glyph recognition , download the GRATF source code from source code repository at Google :-

http://code.google.com/p/gratf/downloads/list 

After downloading the source  you can start exploring the  code. There is an application that comes with download called Glyph’s Recognition Studio.  It lets you to specify the particular glyph to be recognized and also support 2d augmentation , that lets you to place a particular image over the recognized glyph.   Implementation and description of the glyph recognition algorithm is described at :-  http://www.aforgenet.com/articles/glyph_recognition/.

Glyph to be recognised is created on a white paper with outermost white border , then black border with glyph inside.

Glyph’s recognition make use of various image filters from the AForge Framework. It starts all with the bitmap to be processed , its the managed bitmap captured from the source . Bitmap image is converted into Unmanaged image using the UnmanagedImage class of AForge.Imaging namespace.  UnmanagedImage class takes the BitmapData as a parameter in its constructor and converts the Bitmap image into unmanaged image. With unmanaged image we do not have to lock image bits before processing the image pixels , as with managed bitmap image , so overhead of locking and unlocking bitmap is avoided

BitmapData bitmapData = image.LockBits( new Rectangle( 0, 0, image.Width, image.Height ),
                ImageLockMode.ReadOnly, image.PixelFormat );

UnmanagedImage unmanagedImg = new UnmanagedImage( bitmapData ) ;

With our unmanaged image , first step is to apply the GrayScale filter to unmanaged image . GrayScale filter processes the image pixels and returns only the pixels within gray range from 0 to 1 . Gray range is from complete white to black and varied gray component in-between . As we are only concerned with the intensity of the pixels, so we discard the colour information  by applying the GrayScale filter of AForge framework.

UnmanagedImage grayImage = UnmanagedImage.Create( image.Width, image.Height, PixelFormat.Format8bppIndexed );
Grayscale.CommonAlgorithms.BT709.Apply( image, grayImage );

After we have reduced the image with only gray intensity pixels, we apply DifferenceEdgeDetector filter on the grayscale image to detect the edges in the image .

DifferenceEdgeDetector edgeDetector = new DifferenceEdgeDetector();
           UnmanagedImage edgesImage = edgeDetector.Apply(grayImage);

Then we apply Threshold filter to the image to convert gray range pixels into  black or white pixels using the threshold value taken as constructor parameter by Threshold filter.

Threshold thresholdFilter = new Threshold(40);
           thresholdFilter.ApplyInPlace(edgesImage);

We use BlobCounter class to get all the detected blobs in the image of particular size and width.

BlobCounter blobCounter = new BlobCounter();
          blobCounter.MinHeight = 48;
          blobCounter.MinWidth = 48;

blobCounter.ProcessImage(edgesImage);
           Blob[] blobs = blobCounter.GetObjectsInformation();

We iterate over all the blobs detected and use SimpleShapeChecker to check if the blob is of a particular shape.

List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners = null;

if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
              

After passing the IsQuadrilateral check of SimpleShapeChecker we calculate the average brightness of the pixels from both the sides of the edges of Quadrilateral . If the average brightness exceeds a predefined value we further process to get the glyph value.  We apply QuadrilateralTransformation filter on the corners of the Quadrilateral and get the rectangle image of the glyph.

Once we have the rectangle image of the glyph we can iterate over all the pixels of the image using the UnmanagedImage pixel byte pointer and calculate the intensity of the pixels for the each cell of the image and then checking it with the glyph database for glyph recognition.

http://www.aforgenet.com/projects/gratf/

http://www.aforgenet.com/projects/gratf/code_samples.html

Wednesday, March 2, 2011

Silverlight Video Streaming and IIS Smooth streaming

Previously , I have written a blog about the WCF streaming  (here) .  I have got many responses on this blog entry and now I will further explore the streaming with Silverlight streaming and the IIS smooth streaming .

Silverlight streaming make use of Microsoft Expression encoder to package the media content with a silverlight media template . Microsoft Expression encoder is the application which comes with the expression suit applications from Microsoft.  It lets you to adjust the bitrates and resolution of your media content and package it along with the silverlight media template to play it in. Microsoft expression encoder lets you to publish the media content to the silverlight services and azure cloud.

We can download the expression encoder from here download encoder . Hosting of media contents with silverlight services has been discontinued as it was in beta phase. Now we have option of hosting our media content on Azure.

These are the some links to get started with the silverlight streaming and azure media hosting using Microsoft Expression Encoder .

Silverlight Services hosting (Discontinued)

Hosting videos on Azure

Apart for hosting our media on the Azure cloud , we can host the media on our web server and take the benefit of the  IIS Smooth streaming feature .  Here are some links that will get you started with configuring and using IIS Smooth streaming.

Getting started :- IIS Smooth streaming

IIS Smooth streaming sample application

Installing and configuring IIS Smooth streaming

Smooth Streaming fundamental

There are many possibilities to build the media content delivery system on top of these streaming choices.                          Happy streaming…..