Colaboraciones en el Guille

El paradigma SAV (2ª Parte)

Continuamos con nuestro 'control remoto' para encriptar.

Fecha: 15/Oct/2005 (13-10-05)
Autor: Raul Carrillo Garrido aka metsuke ([email protected])

Este artículo es la continuación de El paradigma SAV ('Simply A Video'). Si no lo has leído te recomiendo que le eches un vistazo para poder seguir fácilmente las explicaciones siguientes.


Antes de entrar en materia... un pequeño juguete al mas puro 'Simply Style'.

En el artículo anterior, dejamos nuestro control remoto justo después de completar la desencriptación simétrica, y estaba previsto continuar directamente con la encriptación asimétrica y algoritmos hash, pero voy a hacer una pequeña parada para mostrar lo rápido que se puede construir nueva funcionalidad basándonos en nuestro control remoto, sin renunciar por ello a la robustez y simplicidad de mantenimiento.

Vamos a construir un par de funciones que nos permitan encriptar y desencriptar de forma simétrica pero empleando los cuatro proveedores en secuencia. Lo cierto es que no se si esto aumenta o disminuye la seguridad de la cadena encriptada, pero nos servirá como ejercicio:

 Imports EncryptionClassLibrary 

Namespace Cryptography
Public Class Crypto

Private pvSymmetricKey As String = "1r+!1-esKªPZyL"

#Region "Enums" [...]

#Region "Symmetric" [...]

#Region "SymmetricAll"

Public Function CryptSymmetricAll( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Hex _
) As String
Try
pString = CryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.DES)
pString = CryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.RC2)
pString = CryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.TripleDES)
pString = CryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.Rijndael)
Return pString
Catch ex As Exception
Throw
End Try
End Function

Public Function DecryptSymmetricAll( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Hex _
) As String
Try
pString = DecryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.Rijndael)
pString = DecryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.TripleDES)
pString = DecryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.RC2)
pString = DecryptSymmetric(pString, pFormat, SymmetricEncryptionMethod.DES)
Return pString
Catch ex As Exception
Throw
End Try
End Function
#End Region

#Region "Properties" [...]

End Class
End Namespace

Como podemos observar, nada diferente a lo que ya habíamos realizado en el resto de la clase, lo único a destacar es lo fácilmente que hemos programado la nueva funcionalidad utilizando las funciones previamente encapsuladas, y que nuevamente hacemos uso de parámetros opcionales en lugar de las sobrecargas.

Parámetros Opcionales vs. Sobrecarga

Tal y como comenté en El paradigma SAV ('Simply A Video'), sigo defendiendo el uso de parámetros opcionales siempre que se pueda conseguir la misma funcionalidad que con las sobrecargas, pero últimamente he leído algunos argumentos de Francesco Balena a favor de lo contrario que han sembrado en mí dudas más que razonables con respecto a la 'validez objetiva' de ese planteamiento.

Por ello tengo previsto realizar un artículo monográfico sobre esta cuestión en el que me gustaría salir de dudas realizando una comparativa lo más objetiva posible entre los dos sistemas tomando como medidas:

  1. Tamaño de ejecutable generado.
  2. Consumo de memoria de la aplicación al ser ejecutada.
  3. Medidas de rendimiento real en cuanto a tiempo utilizando NTime.
  4. Facilidad o no del uso de las clases generadas en otros lenguajes de la plataforma .NET.

Si a alguien le parece interesante que tenga en cuenta algún otro parámetro, ruego me lo indique por email a [email protected] indicando en el subject 'Comentario Articulo SAV' para tenerlo en cuenta. Gracias por adelantado.

Y ahora a por la Encriptación Asimétrica.

Tomando como base las recomendaciones del autor de la clase Simple Encryption, generamos las rutinas para encriptar y desencriptar. Lo primero que necesitamos son dos variables privadas que almacenen la clave pública y la clave privada, así como la inicialización de las mismas a través de los constructores.

Observando el código que reproduzco a continuación, podemos observar dos constructores, uno sin parámetros y otro que permite proporcionar una clave para encriptación simétrica. Ambos constructores llaman a un procedimiento que se encarga de generar claves las publica y privada 'por defecto' para la instancia (cumpliendo el requerimiento SAV de que funcione con el mínimo necesario de información por parte del usuario pero permitiendo configurar el mayor numero de elementos posible):

 Imports EncryptionClassLibrary 

Namespace Cryptography
Public Class Crypto

Private pvSymmetricKey As String = "1r+!1-esKªPZyL"
Private pvAsymmetricPublicKey As New Encryption.Asymmetric.PublicKey
Private pvAsymmetricPrivateKey As New Encryption.Asymmetric.PrivateKey

#Region "Constructor"
Public Sub New()
Try
InitializeAssymmetricKeys()
Catch ex As Exception
Throw
End Try
End Sub

Public Sub New(ByVal pSymmetricKey As String)
Try
Me.SymmetricKeyWord = pSymmetricKey
InitializeAssymmetricKeys()
Catch ex As Exception
Throw
End Try
End Sub

Private Sub InitializeAssymmetricKeys()
Try
Dim asym As New Encryption.Asymmetric
asym.GenerateNewKeyset(pvAsymmetricPublicKey, pvAsymmetricPrivateKey)
Catch ex As Exception
Throw
End Try
End Sub

#End Region

#Region "Enums" [...]

#Region "Asymmetric"
Public Function CryptAsymmetric( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Base64 _
) As String [...]

Public Function DecryptAsymmetric( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Base64 _
) As String [...]

#End Region

#Region "Symmetric" [...]

#Region "SymmetricAll" [...]

#Region "Properties"
Public Property SymmetricKeyWord() As String [...]

Public Property AsymmetricPublicKey() As String [...]

Public Property AsymmetricPrivateKey() As String [...]
#End Region

End Class
End Namespace

Podemos observar que hemos generado, además de lo descrito anteriormente, dos nuevas funciones para encriptar y desencriptar, así como sendas propiedades que nos permitirán proporcionar y recoger las claves pública y privada, en caso de que deseemos utilizar claves diferentes.

CryptAsymmetric y DecryptAsymmetric

Veamos las funciones para encriptar y desencriptar:

 ... 
#Region "Asymmetric"
Public Function CryptAsymmetric( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Base64 _
) As String
Try

If pString.Length > 117 Then
Throw New System.ArgumentException( "Limite de tamaño 117 caracteres para este tipo de encriptacion")
Else

Dim asym As New Encryption.Asymmetric

Dim EncryptedData As Encryption.Data
EncryptedData = asym.Encrypt(New Encryption.Data(pString), pvAsymmetricPublicKey)

Select Case pFormat
Case CryptedStringFormat.Base64 : Return EncryptedData.Base64
Case CryptedStringFormat.Hex : Return EncryptedData.Hex
End Select
End If
Catch ex As ArgumentException 'Por tamaño de la cadena a encriptar.
Throw
Catch ex As Exception
Throw
End Try
End Function

Public Function DecryptAsymmetric( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Base64 _
) As String
Try
Dim Asym As New Encryption.Asymmetric
Dim decryptedData As New Encryption.Data

Select Case pFormat
Case CryptedStringFormat.Base64 : decryptedData.Base64 = pString
Case CryptedStringFormat.Hex : decryptedData.Hex = pString
End Select

decryptedData = Asym.Decrypt(decryptedData, pvAsymmetricPrivateKey)
Return decryptedData.Text

Catch ex As Exception
Throw
End Try
End Function
#End Region
...

Como podemos observar, el formato de las funciones no muestra ningún detalle técnico destacable. El único elemento nuevo es la comprobación del tamaño de la cadena a encriptar, y es que a partir de la longitud indicada, se produce una excepción (el método asimétrico está pensado para cadenas relativamente cortas, ya que es un método 'caro' en términos de recursos y velocidad), así que para simplificar la depuración se comprueba la longitud y en caso de que supere el límite permitido, se lanza una excepción explicando en detalle la causa del problema, de modo que el programador no tenga que volverse loco buscando un porqué.

Los Properties

En relación a la este tipo de encriptación solo queda mostrar las dos propiedades que nos permiten asignar y obtener las claves pública y privada. .NET nos proporciona la posibilidad de obtener y asignar dichas claves en un formato XML fácilmente manejable, hecho que aprovecharemos para simplificar el proceso al máximo:

 #Region "Properties" 
Public Property SymmetricKeyWord() As String [...]

Public Property AsymmetricPublicKey() As String
Get
Try
Return pvAsymmetricPublicKey.ToXml.ToString
Catch ex As Exception
Throw
End Try
End Get
Set(ByVal Value As String)
Try
pvAsymmetricPublicKey.LoadFromXml(Value)
Catch ex As Exception
Throw
End Try
End Set
End Property

Public Property AsymmetricPrivateKey() As String
Get
Try
Return pvAsymmetricPrivateKey.ToXml.ToString
Catch ex As Exception
Throw
End Try
End Get
Set(ByVal Value As String)
Try
pvAsymmetricPrivateKey.LoadFromXml(Value)
Catch ex As Exception
Throw
End Try
End Set
End Property
#End Region

Como podemos ver, salvo el detalle de la asignación y obtención de las claves en formato XML, no hay nada que destacar en esta porción del código de nuestro control remoto.

Algoritmos Hash

Solo nos queda completar la primera versión de nuestra clase incorporando la función que implementa los algoritmos hash de Simple Encryption:

 Imports EncryptionClassLibrary 

Namespace Cryptography
Public Class Crypto

Private pvSymmetricKey As String = "1r+!1-esKªPZyL"
Private pvAsymmetricPublicKey As New Encryption.Asymmetric.PublicKey
Private pvAsymmetricPrivateKey As New Encryption.Asymmetric.PrivateKey

#Region "Constructor" [...]

#Region "Enums"
Public Enum CryptedStringFormat
Hex = 1
Base64 = 2
End Enum

Public Enum SymmetricEncryptionMethod
DES = 1
RC2 = 2
TripleDES = 4
Rijndael = 8
End Enum

Public Enum HashEncryptionMethod
SHA1 = 1
SHA256 = 2
SHA384 = 4
SHA512 = 8
MD5 = 16
CRC32 = 32
End Enum
#End Region

#Region "Asymmetric" [...]

#Region "Hash"

Public Function CalculateHash( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Hex _
, Optional ByVal pHashAlgorithm As HashEncryptionMethod = HashEncryptionMethod.SHA512 _
) As String
Try

Dim HashObject As Encryption.Hash
Dim HashBaseData As New Encryption.Data(pString)

Select Case pHashAlgorithm
Case HashEncryptionMethod.CRC32
HashObject = New Encryption.Hash(Encryption.Hash.Provider.CRC32)
Case HashEncryptionMethod.MD5
HashObject = New Encryption.Hash(Encryption.Hash.Provider.MD5)
Case HashEncryptionMethod.SHA1
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA1)
Case HashEncryptionMethod.SHA256
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA256)
Case HashEncryptionMethod.SHA384
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA384)
Case HashEncryptionMethod.SHA512
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA512)
End Select

Select Case pFormat
Case CryptedStringFormat.Base64
Return HashObject.Calculate(HashBaseData).Base64
Case CryptedStringFormat.Hex
Return HashObject.Calculate(HashBaseData).Hex
End Select

Catch ex As Exception
Throw
End Try

End Function

#End Region

#Region "Symmetric" [...]

#Region "SymmetricAll" [...]

#Region "Properties" [...]

End Class
End Namespace

Como podemos ver nada fuera de lo común: un enum para establecer los distintos tipos de algoritmos hash disponibles, parámetros opcionales (esta vez se ha tomado como formato de devolución por defecto Hex) y poco más.

Legibilidad del Código Fuente

A lo largo de estos dos artículos quizá habréis notado cierta tendencia a la 'simetría' en la colocación en el código. Esto no es algo aleatorio, considero tanto o más importante que la simplicidad del código en sí, el que este , en la medida de lo posible, sea legible mediante la reducción de la 'información consciente' a evaluar para que nuestro cerebro interprete adecuadamente el código fuente que observa.

Al hablar de legibilidad no pretendo imponer unos formatos de codificación extremadamente estrictos, ya que la excesiva dureza en dichos estándares lleva bien a una reducción drástica de productividad o a ignorarlos completamente, lo cual no ayuda nada al proyecto. En su lugar abogo por un 'compromiso individual de legibilidad' según el cual y siempre siguiendo un conjunto de normas mínimo (a pactar dentro del equipo de desarrollo), la legibilidad se convierta un parámetro más a tomar en consideración al planificar cualquier bloque de código.

De este modo y de forma natural el código queda suficientemente legible sin afectar negativamente a la productividad. Es un equilibrio delicado y cuya 'formula' hay que ajustar a cada proyecto en función del nivel de compromiso profesional del grupo de desarrolladores. En mi caso particular hay dos cuestiones que suelo utilizar siempre que puedo:

Colocar el código de forma que las 'diferencias' queden destacadas.

Formatos del tipo 'Select Case' que podemos ver en código anterior ayuda a que nuestro cerebro tome automáticamente la estructura como una 'lista de elementos a seleccionar' y que se centre en la parte final de cada línea para saber que hace el código basándose en las diferencias, ya que el resto del código es 'obvio'.

Incluso en un if..else hay veces que es mejor usar select case simplemente por cuestiones de legibilidad. Observemos el código siguiente:

 If (metodoEncriptacion = "Method 1") Then 
provEncriptacion = "Proveedor 1"
Else 'Method 2
provEncriptacion = "Proveedor 2"
End If

El código en sí es válido, la única razón para cambiarlo bien podría ser la legibilidad:

 Select Case metodoEncriptacion 
Case "Method 1": provEncriptacion = "Proveedor 1"
Case Else: provEncriptacion = "Proveedor 2" 'Method 2
End Select

O incluso mejor:

 Select Case metodoEncriptacion 
Case "Method 1": provEncriptacion = "Proveedor 1"
Case "Method 2": provEncriptacion = "Proveedor 2"
Case Else: provEncriptacion = "Proveedor Default"
End Select

Personalmente me gusta mucho más la tercera opción, principalmente porque mi cerebro asume la lógica del código y la relación entre método y proveedor sin necesidad de pensar, pero cada cual debe juzgar cual es el método de 'legibilidad' más acorde con sus gustos y necesidades.

Espaciado del código

Es común encontrarse con código fuente en el que de forma sistemática se tiende a no dejar nunca líneas en blanco entre bloques. Personalmente prefiero jugar con esas líneas en blanco para dotar al código de una 'organización por bloques' de modo que cada bloque esté relacionado con una idea. Por ejemplo en el código que implementa el algoritmo hash podemos ver un primer bloque con declaraciones e inicializaciones, un segundo bloque 'que ejecuta' la acción, y un último bloque 'de devolución'. Todo esto lo vemos sin necesidad de un solo comentario.

Creo que la mejor forma de mostrarlo es ver el mismo código sin los espacios, y que cada uno compare la legibilidad con el bloque anterior en el que se incluían las líneas en blanco:

 Imports EncryptionClassLibrary 
Namespace Cryptography
Public Class Crypto
Private pvSymmetricKey As String = "1r+!1-esKªPZyL"
Private pvAsymmetricPublicKey As New Encryption.Asymmetric.PublicKey
Private pvAsymmetricPrivateKey As New Encryption.Asymmetric.PrivateKey
#Region "Constructor" [...]
#Region "Enums"
Public Enum CryptedStringFormat
Hex = 1
Base64 = 2
End Enum
Public Enum SymmetricEncryptionMethod
DES = 1
RC2 = 2
TripleDES = 4
Rijndael = 8
End Enum
Public Enum HashEncryptionMethod
SHA1 = 1
SHA256 = 2
SHA384 = 4
SHA512 = 8
MD5 = 16
CRC32 = 32
End Enum
#End Region
#Region "Asymmetric" [...]
#Region "Hash"
Public Function CalculateHash( _
ByVal pString As String _
, Optional ByVal pFormat As CryptedStringFormat = CryptedStringFormat.Hex _
, Optional ByVal pHashAlgorithm As HashEncryptionMethod = HashEncryptionMethod.SHA512 _
) As String
Try
Dim HashObject As Encryption.Hash
Dim HashBaseData As New Encryption.Data(pString)
Select Case pHashAlgorithm
Case HashEncryptionMethod.CRC32
HashObject = New Encryption.Hash(Encryption.Hash.Provider.CRC32)
Case HashEncryptionMethod.MD5
HashObject = New Encryption.Hash(Encryption.Hash.Provider.MD5)
Case HashEncryptionMethod.SHA1
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA1)
Case HashEncryptionMethod.SHA256
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA256)
Case HashEncryptionMethod.SHA384
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA384)
Case HashEncryptionMethod.SHA512
HashObject = New Encryption.Hash(Encryption.Hash.Provider.SHA512)
End Select
Select Case pFormat
Case CryptedStringFormat.Base64
Return HashObject.Calculate(HashBaseData).Base64
Case CryptedStringFormat.Hex
Return HashObject.Calculate(HashBaseData).Hex
End Select
Catch ex As Exception
Throw
End Try
End Function
#End Region
#Region "Symmetric" [...]
#Region "SymmetricAll" [...]
#Region "Properties" [...]
End Class
End Namespace

Entiendo que la imagen habla por sí misma, aunque insisto en que cada uno debe aplicar las medidas con respecto a sus propias convicciones, esto es solo un ejemplo de un método posible, no es el único ni probablemente el mejor.

End Try

A través de estos artículos he tratado de mostrar un método de trabajo y filosofía de codificación basada en la simplificación, de modo que no nos pongamos trabas nosotros mismos al desarrollar. Bastante complicado es ya como para tropezarnos voluntariamente por pisarnos los cordones de los zapatos.

En futuros artículos , además de la comparativa entre parámetros opcionales y sobrecarga de métodos (para salir de dudas), procuraré abordar el proyecto savLib, cuyo objetivo es simplificar distintas funcionalidades de forma que podamos recurrir a ellas en cualquier momento con la misma facilidad que usaremos con este control remoto la encriptación en .NET.

Espero que hayan disfrutado leyendo este artículo tanto como yo escribiéndolo. No olviden que pueden dirigir cualquier aportación, comentario y/o crítica (siempre constructiva, apliquemos la metodología SAV también a esto) a [email protected].


Espacios de nombres usados en el código de este artículo:

System.Security.Cryptography (usado por la librería sobre la que se basa el articulo)


Fichero con el código de ejemplo: metsuke_savIntroduccion2.zip - 4 KB


Creative Commons License


ir al índice principal del Guille