Control de licencias en componentes de software usando LicenseProvider

enero 30, 2011
By

Es frecuente la necesidad de proteger con algún mecanismo basado en licencias las aplicaciones o componentes de software que desarrollamos, ya sean controles visuales de Windows Forms o Web Forms, o componentes lógicos sin interfaz visual que encapsulen cierta funcionalidad. Para lograr este objetivo se pueden implementar varias soluciones a la medida, según el caso, e incluso existen soluciones comerciales que facilitan la creación y administración de licencias integradas en nuestro código. Sin embargo, existe una forma sencilla de lograr lo anterior mediante los propios recursos que brinda .NET Framework, que tiene como centro la clase abstracta System.ComponentModel.LicenseProvider.

Para implementar un esquema básico de licencias, bastará con heredar de System.ComponentModel.LicenseProvider e implementar nuestro propio proveedor de licencias, que en esencia consiste en implementar el método GetLicense. A continuación se muestra una implementación de la clase MyLicenseProvider, nuestro proveedor de licencias.

class MyLicenseProvider : System.ComponentModel.LicenseProvider
{
     public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
     {
	DateTime expirationDate = new DateTime(2011, 02, 19);
        // Verificar si la licencia expiró
        if (DateTime.Today.CompareTo(expirationDate) > 0)
	{
	    return null;
	}
	else
	{
	    return new MyLicense();
	}
     }
}

Como habrá notado, la implementación anterior raya en lo simplista y solo pretende ilustrar el patrón a seguir. En un escenario real es recomendable usar un mecanismo para recuperar y validar la licencia apropiado para la aplicación o componente que se quiere proteger. Por ejemplo, la fecha de expiración podría obtenerse de un fichero debidamente protegido contra modificaciones o de un servicio Web igualmente protegido, por ejemplo con SSL. En el código anterior se hace referencia a la clase MyLicense que no es más que un heredero de la clase abstracta System.ComponentModel.License, otro de los componentes del modelo de licencias propuesto en .NET. El código de la clase MyLicense se muestra a continuación y permite definir las propiedades de la licencia que devuelve el método GetLicense de nuestra clase MyLicenseProvider. La propiedad LicenseKey debe devolver un valor único para cada instancia diferente de MyLicense. Este valor permite a .NET identificar la licencias obtenidas como si se tratase de cookies. Para nuestro ejemplo no es relevante el valor que se utilice.

class MyLicense : System.ComponentModel.License
{
     public MyLicense() { }
     public override void Dispose() { }
     public override string LicenseKey
     {
	get { return "My License Key"; }
     }
}

Una vez creados nuestro proveedor de licencias, MyLicenseProvider, y nuestra definición de licencia, MyLicense, solo resta indicar a .NET que las use donde se requiera. Esto se logra en dos pasos. el primero es decorar con el atributo LicenseProviderAttribute la clase que representa el componente que se quiere proteger, es decir, el componente donde queremos verificar la licencia. El segundo paso es invocar el método estático Validate de la clase LicenseManager. Los parámetros que se pasen al método Validate serán pasados a su vez al método GetLicense de la clase MyLicenseProvider. A continuación se muestra un ejemplo de lo anterior.

[LicenseProvider(typeof(MyLicenseProvider))]
public class MyLicensedComponent
{
     private MyLicense license = null;

     public MyLicensedComponent()
     {
	// Guardar la licencia si se requiere en otros métodos o propiedades.
          license = LicenseManager.Validate(typeof(MyLicensedComponent), this);
     }

     ~MyLicensedComponent()
     {
	if(license != null)
	{
	      license.Dispose();
	      license = null;
	}
     }
}

En caso de no existir una licencia válida, el método GetLicense de nuestro proveedor devolverá null, y el método Validate lanzará una excepción del tipo System.ComponentModel.LicenseException.

Aunque este modelo de licencias de .NET fue concebido para aplicarlo a controles visuales, nada impide, como se ha ilustrado aquí, aplicarlo a cualquier componente de software, tenga o no interfaz visual. Con este enfoque se puede definir de manera sencilla un esquema de licencias propio para nuestras aplicaciones y componentes. Aunque no es objetivo de este artículo, debe considerarse también en la implementación del esquema de licencias el formato de almacenamiento de la información de las licencias y el mecanismo de obtención y validación por parte del método GetLicense. Como imaginará el lector detrás de esto deberá existir algún esquema criptográfico que garantice que las licencias no puedan ser manipuladas por los clientes a los que se le otorgan. Un próximo post tratará estos temas para brindar una solución segura al almacenamiento y la recuperación de licencias.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

*

Acerca del autor...

Lester Sánchez

Web: http://www.linkedin.com/in/lestersanchez
Lester Sánchez
Profesor de la Facultad de Matemática y Computación de la Universidad de La Habana. Entusiasta de las tecnologías .NET y en especial de SharePoint. Webmaster de weboomania.comLeer completo