.NET Tutorial 45. Como »Juankear» aplicaciones .NET y estrategias para evitarlo (Parte III)

Interesante vídeo:


(Ver a FullScreen y en 720p please)

 

¿Aún crees que nadie puede "adivinar" tus passwords, SQLs, números de serie, etc.? 🙂

Tags: Eazfuscator, unpack eazfuscator strings, reverse eazfuscator strings, decode eazfuscator strings, hack eazfuscator applications 

Saludos.
mov eax,ollydbg; Int 13h   

Calcular el gasto de combustible con PetroCOST

No hace mucho un amigo mío se ha comprado un coche y me comentó si sería posible que le diseñase una aplicación para Pocket PC para controlar el gasto de combustible que realizará durante el primer año.

Dándole un poco vueltas al asunto y mirar un poco lo que necesitaba he diseñado PetroCOST

PetroCOST es una sencilla aplicación escrita en NET Compact Framework que usa una pequeña base de datos SQL Compact Edition para guardar la información y poder jugar con ella.
De esta forma podremos llevar un control de los repostajes de gasolina / diésel, cuanto hemos gastado, cada cuandos kilómetros repostamos o cada cuantos días lo hacemos.

La aplicación funciona correctamente en los siguientes sistemas operativos:

  • Pocket PC 2003 SE
  • Windows Mobile 5.0 / 6.x

La pantalla principal de PetroCOST es la siguiente: 

En esta pantalla se muestra la información del vehículo "activo", así como los datos de las medias del respostaje y la información del último repostaje.

Los datos del último repostaje se mostrarán en color rojo o en color verde si éstos están por encima o debajo de la media respectivamente.

Además, en la parte inferior hay cuatro botones de acceso rápido a las funciones más comunes. Estas funciones son:

  • Realizar un nuevo repostaje
  • Añadir/Modificar una anotación a un respostaje
  • Cambiar de vehículo "activo"
  • Estadística de la evolución del precio del carburante

En las estádisticas del precio de carburante se muestra la siguiente información: 

Se muestra la siguiente información:

  • Numero total de repostajes
  • Valor mínimo (de color verde
  • Valor máximo (de color rojo)
  • Valor medio (de color azul)
  • Intervalo del muestreo
  • Fecha del valor mínimo y máximo
  • Diferencia entre el valor mínimo y máximo
  • Fecha y valor del máximo incremento de precio

Existen otros tipos de estadísticas tal y como se muestra en la siguiente ventana: 

La estadística de km nos mostrará cada cuantos kilómetros se han realizado los repostajes, pudiendo así ver la distancia media recorrida entre repostaje y repostaje.

La estadística de Días nos mostrará cada cuantos días se han realizado los repostajes: 

Con los datos representados podremos llegar a saber que realizamos de media un repostaje cada ‘x’ días

Resumen de las características de PetroCOST (versión 1.0.0.0)

  • Diseñada para Pocket PC 2003 / Windows Mobile 5.0 / 6.x
  • Base de datos SQL CE
  • Trabajar con múltiples vehículos
  • Borrarr vehículos
  • Crear repostajes
  • Añadir anotaciones a los repostajes
  • Listar repostajes
  • Borrar repostajes
  • Estadísticas para ver la evolución del precio del carburante
  • Estadísticas del kilometraje medio de repostaje
  • Estadísticas del tiempo medio (días) de repostaje
  • Visualización del total de importe gastado y de los litros repostados
  • Posibilidad de realizar un repostaje con "importe cero". Esto es útil si sólo queremos tener datos para ver la evolución del precio del carburante

Instalación del programa

La instalación requiere de los siguientes requisitos previos:

  • NET Compact Framework 3.5
  • Microsoft SQL Server Compact Edition 3.5

Para la instalación hay que realizar lo siguiente:

  1. Conectar la PDA / Pocket PC a nuestro PC. Al hacerlo deberá lanzarse automáticamente el ActiveSync o el Centro de dispositivos de Windows Mobile
  2. Desde "Equipo" ahora debería verse el dispositivo móvil 
  3. Copiar los "CABs" del NECF 3.5 y del SQLCE 3.5 al dispositivo móvil
  4. En el disposivo móvil hacer "click" en los "CABs" copiados anteiormente para instalarlos. Primero instalar el NETCF 3.5 y luego el SQLCE 3.5
  5. Copiar los archivos PetroCOST.exe y PetroCOSTDB.sdf en el dispositivo móvil
  6. (opcional) Crear un acceso directo a PetroCOST.exe y copiarlo en la carpeta de programas (normalmente dicha carpeta está dentro de "Mi dispositivoWindowsMenú InicioProgramas" De esta forma veremos el icono de PetroCOST en el menú de Programas:  

Como siempre, se admiten comentarios, críticas, sugerencías  y / o dudas !!! 

 

Saludos.
mov eax,ollydbg; Int 13h  

 

Enlaces de descarga:

NET Compact Framework 3.5: NETCFv35.ppc.armv4.cab

Microsoft SQL Server Compact Edition 3.5: sqlce.ppc.wce4.armv4.CAB

Descargar PetroCOST versión 1.0
(76 KB)  

.NET Tutorial 44. Serializando que es gerundio

En muchas ocasiones tenemos la necesidad de guardar una serie de parámetros que utilizan internamente nuestros programas. Dejando a parte el namespace My.Settings antiguamente (bueno, actualemente también) se usaban los ficheros INI

Un fichero INI tiene el siguiente aspecto:

[NombreSeccion1]
Clave1=Valor
Clave2=Valor
Clave3=Valor

[NombreSeccion2]
Clave1=Valor
Clave2=Valor
Clave3=Valor

Estos ficheros se dividen en secciones,cuyo nombre está siempre entre corchetes [   ]
Dentro de cada sección tendremos los distintos parámetros (Claves) y cada clave tiene un determinado valor (Valor)
Nota: Si una línea de un fichero INI comienza por punto y coma ( ; ) se considera que es un comentario y no se tiene en cuenta

Para trabajar con estos ficheros se hace uso de llamadas a la API de Windows del módulo kernel32, en concreto son GetPrivateProfileString y WritePrivateProfileString (via pinvoke.net)
Otra opción si no se quieren usar llamadas a la API de Windows es construirse un "parseador" que interprete el contenido del fichero INI.

Un ejemplo de fichero INI podría ser:

[Configuracion]
PermitirAcceso=false
NombreImpuesto=VAT
ValorImpuesto=8.23
LocationXForm=646
LocationYForm=268
Escala=5

En el caso anterior solo hay una sección (llamada Configuracion) y 6 parámetros con sus correspondientes valores.

Bien, llegados a este punto más de uno/a puede pensar que este sistema es ideal para guardar diversos parámetros. Error!!! 🙂

Ojo, no digo que no sea un mal método, de hecho yo lo he usado en más de una ocasión, sin embargo en .NET existe una forma mucho más eficaz, rápida y sencilla de conseguir el mismo resultado: Serialización y Deserialización.

Entendemos por Serialización el proceso que guarda en un fichero de disco el estado de un objeto, normalmente en formato XML
Deserializacion es el proceso contrario: establece el estado de un objeto leyéndolo de un fichero, normalmente en formato XML

Entendamos por "objeto" cualquier objeto de .NET y es aquí donde está la "gracia" del asunto.
Un objeto puede ser una estructura, una propiedad, un booleano, un string, una clase derivada de otra, un DataSet, un ArrayList, etc.

Otra ventaja frente a los ficheros INI también radica en que las rutinas de serialización y deserialización no se tienen que modificar aunque se añadan nuevos parámetros a la configuración.

Supongamos que tenemos los parámetros A, B y C

En le caso de los ficheros INI tendríamos algo como esto: (en pseudocódigo)
GuardarINI ("Configuracion", "A", "23" )
GuardarINI ("Configuracion", "B", "17" )
GuardarINI ("Configuracion", "C", "59" )

Para recuperar los valores tendríamos algo como esto: (en pseudocódigo)
Parametro_A = LeerINI ("Configuracion", "A")
Parametro_B = LeerINI ("Configuracion", "B")
Parametro_C = LeerINI ("Configuracion", "C")

Pasado un cierto tiempo, nos damos cuenta que necesitamos un nuevo parámetro, por ejemplo el "D"

Pues tendríamos que añadir esto para guardarlo en el INI

GuardarINI ("Configuracion", "D", "178" )

y esto para recuperarlo del INI:

Parametro_D = LeerINI ("Configuracion", "D")

Bien, otra vez llegados a este punto más de uno/a puede pensar que "tampoco es para tanto", solo hay que añadir una línea para guardarlo y otra linea para recuperarlo. Error!!! 🙂

1º) Sí, efectivamente "solo" hay que añadir 1 línea, pero eso es porque solo hemos añadido 1 nuevo parámetro. Si añadimos 20 parámetros nuevos, hay que añadir 40 líneas, sí añadimos 100 parámetros nuevos hay que añadir 200 líneas, …

2º) Ocurre más a menudo de lo que creéis que por despiste, para el parámetro "Z" se nos ha olvidado usar el GuardarINI, por lo que el LeerINI ("Z") de poco sirve, o al revés

3º) También ocurre más a menudo de lo que creéis que por despiste tenemos esto:

GuardarINI ("Configuracion123", "Z", "23" ) 
Parametro_Z = LeerINI ("Configuraci
ón133", "Z")

Estamos guardando el valor del "Parametro_Z" en la sección llamada Configuracion123, pero sin embargo estamos intentando recuperar la información de la sección "Configuración133" con lo cual no se recupera nada.

Espero que con todo lo anterior veáis los pros y contras de usar ficheros INI en lugar de usar Serialization.

Bien, ahora que ya os he medio convencido veamos que usar la serialización es tremendamente simple. Así que al lio 🙂

Para este tutorial tendremos lo siguiente:

Esa pantalla muestra una serie de parámetros. Pulsado en el botón Cambiar Configuración podremos cambiar dichos parámetros accediendo a esta otra pantalla:

Tendremos una clase llamada XMLserialization que se encarga de serializar y deserializar los objetos. El código de la clase es esta:


(Haz click para agrandar)

Como ya apunté antes ese código nos sirve aunque a "posteriori" añadamos (o quitemos) nuevos parámetros

Aquí es importante que los parámetros se encuentren en clases (no en módulos)

En nuestro caso tendremos dos clases:

  • Configuracion
  • Comunicaciones

Dentro de Configuración hay una serie de objetos Publicos que serán los que se van a serializar.
Podréis observar que los objetos son una Property, un Booleano, un String, un Single, un par de Integers y aqui viene lo bueno un objeto de tipo Comunicaciones

En Comunicaciones podési ver que hay enumeraciones, estructuras y un string

Nuestra variable principal de los parametros la he llamando mConfiguracion y es de tipo Configuracion:

Private mConfiguracion As Configuracion = New Configuracion

¿Cómo se cargan (deserializa) los parámetros? Pues tal que así:

mConfiguracion = DirectCast(XMLserialization.Deserialize(mConfiguracion.[GetType](), CONFIGURACION_FILENAME), Configuracion)

Como véis aquí se llama al método Deserialize que está dentro de la clase XMLserialization pasándole el nombre del fichero de configuración que está en la constante CONFIGURACION_FILENAME y que en nuestro caso es cfgParam.xml que por defecto se guarda en la misma carpeta de la aplicación ( debugcfgParam.xml )

Este por ejemplo es el fichero Serializado que se genera si no tuviesemos en cuenta el parámetro "DispositivoHardware1" que es de tipo Comunicacion: 


(Haz click para agrandar)

Como véis se parece bastante al fichero INI de ejemplo que pusimos arriba

Y este es el mismo fichero (repito, sin cambiar ni una línea en las rutinas de la clase XMLserialization) cuando tenemos el parámetro "DispositivoHardware1":

(Haz click para agrandar)

Si habéis estado un poco atentos a las imágenes veréis que los parámetros "LocationXForm" y "LocationYForm" no se pueden cambiar desde la pantalla de configuración de parámetros.

Estos dos parámetros se actualizan cuando se cierra el programa, en el evento Form_Closing y guardan la posición del formulario, de tal forma que cuando se ejecute de nuevo el programa el formulario se posicionará automáticamente en la misma posición que tenía cuando se había cerrado.

Por último decir que como se serializa una Property (en este caso el parámetro Escala)  y que en el Seteo tenemos unos condicionales si cambias el valor "a mano dentro del XML" por un valor no permitido, por ejemplo, 200 verás que cuando se desserializa se "Setea" dicha Property con el valor máximo

Esto no sería importante ya que en principio nadie debería tocar a "mano" el XML, aunque bueno, ya sabemos que hay mucho "manazas" por ahí 🙂

El fichero XML lo podéis abrir con el Internet Explorer, Firefox, Opera, Chorme, Bloc de notas, o incluso desde el propio IDE del Visual Studio.

 

No dudéis en comentar cualquier cosa que no veáis clara o lo que sea.

 

Saludos.
mov eax,ollydbg; Int 13h 

 

Descargar código fuente del .NET Tutorial 44
(26 KB. Visual Studio 2008) 

Crear códigos de barras con iTextSharp desde .NET

Debido al éxito de la anterior entrega (Crear y leer códigos QR desde VB.NET) he decidido publicar este tutorial antes de lo previsto.

Hoy os mostraré como generar los siguientes códigos de barras gracias a la librería iTextSharp y unas pequeñas modificaciones:

El código generado se guarda en un objeto de tipo Bitmap y podrás hacer con él lo que quieras: guardarlo, procesarlo, imprimirlo, usarlo en Crystal Reports,… lo que quieras.

iTextSharp es un port libre y gratuito al .NET Framework de la librería iText para Java.

Originalmente tanto iTextSharp como iText eran librerías para manejar documentos PDF. Sin embargo se han ido añadiendo funcionalidades, entre las cuales está la generación de un porrón de tipos de códigos de barras.

Nota: Hay otra caracteristica muy interesante que veremos en otros tutoriales y es la posibilidad de firmar digitalmente un documento PDF con un certificado emitido por una CA como puede ser VeriSign, la Fábrica Nacional de Moneda y Timbre o incluso mediante el e-DNI.
Cuando se firma digitalmente un documento se asegura que éste es original y que no ha sido modificado. La firma digital es "tremendamente fuerte" y no podrías romperla ni en un trillón de años. Por algo se usa en organismos oficiales tales como Hacienda, departamentos de justicia, militares, transferencias bancarias, etc.

Pero vamos, que me estoy enrollando y eso lo dejaremos para otro día 🙂

Bueno, al lío.

Como ya hemos dicho iTextSharp está pensada para trabjar con documentos PDF. Esto supone un "pequeño" inconveniente, ya que habrá caracterísiticas que tendremos que hacer a "mano" si lo que queremos es tener un objeto Bitmap (System.Drawing.Bitmap).
La principal es la de mostrar el propio código debajo del código de barras.
También necesitaremos modificar ligeramente el código de barras para los códigos tipo EAN13 como ya veréis más adelante.
Por último también se ha implementado la propiedad de "escalar" los códigos PDF417 y Data matrix para hacerlos más grandes.

Para ello hemos creado una clase llamada BarCode que realizará todas estas tareas de forma transparente

Nota: Los distintos tipos de códigos de barras tienen una serie de reglas y/o limitaciones. Así por ejemplo, los códigos de tipo codabar tienen que empezar por A,B,C o E, no contener letras y terminar por A,B,C o E.
Los códigos EAN13 tiene que tener 12 o 13 números y no pueden contener letras, los Code39 tampoco pueden tener letras, etc. 

A continuación mostraremos unos cuantos ejemplos del resultado de este tutorial.

Codabar 

La llamada es algo como esto:

Dim bm As Bitmap = BarCode.CodeCodABAR("A123456789012+B",True,50)

El primer parámertro es el código que queremos generar, el segundo parámetro indica que se va a visualizar el código debajo "de las barras" y el último indica la altura de las barras.
Podéis observar que en la representación del código no se incluye el primer carácter "A" ni el último "B" ya que estos son internos para construir el código.

EAN13

Para el código EAN13 (European Article Number 13) tenemos dos funciones:

  • BarCode.CodeEAN13("5901234123457", True, 60)
  • BarCode.CodeEAN13AutoGenerateChecksum("590123412345", True, 60)

Los códigos EAN13 tienen un total de 13 dígitos (y solo dígitos, no letras)

Para el código:

5901234123457

El 7 representa que el el checksum de los 12 primeros dígitos.
La función CodeEAN13 representará un código de 13 cifras, sin comprobar el checksum. Lo que se le envía es lo que se genera.
Sin embargo a la función CodeEAN13AutoGenerateChecksum se le pasarán 12 dígitos. La función calcula el checksum correcto y lo incluye en el código.

En los códigos EAN13 también podéis observar que el código tiene barras más largas que otras y que hay como dos zonas. De todo esto ya se encarga la clase BarCode.

Code39  

La llamada es algo así:

Dim bm As Bitmap = BarCode.Code39("12345678901234567890", True)

Al Code 39 internamente ya se añaden los carácteres "*" (asterisco) tanto al principio como al final

Como podéis observar, el parámetro de la altura es opcional y en este caso no se ha usado

Code128   

El Code 128 admite tanto letras como números. En esta demo se han incluído 3 tipos de code 128.

La llamada es similar que en los casos anteriores:

bm = BarCode.Code128("hola", iType, True, 50)

Donde iType representa uno de los 3 tipos de code 128

PDF417    

En este caso nos encontramos con un código "2D" donde se puede almacenar gran cantidad de información (algo parecido a los QR Codes que vimos en la entrega anterior)

La llamada es así:

Dim bm As Bitmap = BarCode.PDF417("Hola mundo")

Si queremos "escalar" el tamaño cuatro veces del generado por la librería iTextSharp:

Dim bm As Bitmap = BarCode.PDF417("Hola mundo", 4

Data matrix

Aquí también nos encontramos con un código "2D".

La llamada es así:

Dim bm As Bitmap = BarCode.DataMatrix("Hola mundo")

Si usamos un escalado como por ejemplo:

Dim bm As Bitmap = BarCode.DataMatrix("Hola mundo", 4

Obtenemos lo siguiente:

Por  último algunos links interesantes:

Generador online de diversos códigos 1-D: http://www.bcgen.com/linear-barcode-creator.html

Generador online de PDF417: http://www.bcgen.com/pdf417-barcode-creator.html

Generador online de Data matrix: http://www.bcgen.com/datamatrix-barcode-creator.html

Decodificador online de Data matrix: http://www.2dtg.com/decode.html

Decodificador online de PDF417: http://www.turbulence.org/Works/swipe/barcode_app.html

 

 

 

Saludos.
mov eax,ollydbg; Int 13h 

 

Descargar código fuente del iTextSharpCodigosBarras
(25 KB. Visual Studio 2008)


Ollydbg ProSignature

Verificar si un Windows es ‘Genuine’ desde .NET

Ocurre que a menudo un programa que en un PC funciona perfectamente, en otro PC "no funciona"

A veces esto ocurre porque se está ejecutando nuestro programa en un Windows "de dudosa procedencia". Es muy común que estos Windows, sobre todo Windows XP ("desatendidos" los llaman) no instalen ciertos componentes, ya que según los "mega-ultra-fashion-uber-pr0s" no hacen falta, consumen recursos, o vaya Vd. a saber que chorradas más.

El tema está en que en muchos de estos Windows desatendidos hay "problemas" para instalar correctamente el .NET Framework. Obviamente si hay "problemas" para instalar el .NET Framework y programamos en VB.NET o C# que utilizan dicho framework, no hay que ser un licenciado en el M.I.T para sumar 1+1 y darse cuenta de por donde pueden venir los problemas.

No hace mucho tiempo tuve una "movida" con un cliente al que le vendieron un programa que yo había desarrollado y supervisado. Era el típico cliente que rezabas para que todo fuese como la seda, ya que llamarle borde, chulo y prepotente era quedarse corto.
La cuestión es que instaló el programa en uno de esos Windows "desatendidos" y que según él "funcionaba muy bien". El tema estaba en que mi programa se colgaba, iba lento, producía pantallazos azules (BSoD), reinicios aleatorios y no sé que mas lindezas.
Y el tio erre que erre, que mi programa era una mierda (literalmente), que menudo asco, que el "Excell" y el "Güor" le funcionaban bien y que si patatín que si patatán.

Como ya estaba con la mosca detrás de la oreja y ya me olía el percal (uno ya tiene los huevos pelaos de lidiar día a día con tanto "listo") le envié un programa parecido al que comentaremos en este tutorial.
Cual fue mi sorpresa (o más bien no, para que nos vamos a engañar 🙂  que efectivamente, estaba usando un Windows XP más falso que un euro de madera.

Si ya hay problemas sin buscarlos, imaginad si además tienes que tener en cuenta que tal o cual Windows es pirata, o que las DLLs están "parcheadas" vete a saber como, etc.
Aquí el que no corre vuela, y como no les pares los pies, te crecen los enanos y se te suben a la chepa en un abrir y cerrar de ojos.
El tema fué que ante tal evidencia el cliente no pudo negar lo que estaba pasando. Para estos casos respuesta estándar número 33: "No damos soporte a sistemas operativos no originales"

Nota: No entraré si es ético o moral usar un Windows pirateado. No es ni el blog ni el ámbito apropiado. Lo que no es de recibo es que alguien te llame "gilipollas" (así, con todas las letras) a la cara y se quede tan tranquilo y más sabiendo que tiene tanta razón como el logaritmo de 1.

Bueno, al lio, que esto ya parecen "las histórias de la puta mili" 🙂

La verificación desde .NET de la autenticidad de Windows es distinta si lo que queremos verificar es un Windows XP o bien es un Windows Vista/7

Para Windows XP se usará la librería COM LegitCheckControlLib.dll
Para Windows Vista y superiores se hace uso de la Software Licensing API (http://msdn.microsoft.com/en-us/library/aa965837(v=VS.85).aspx) que está integrada en la librería Slwga.dll

Ambas librerías pertenecen a lo que se conoce como Windows Genuine Advantage (WGA para los amigos) y es el mecanismo que tiene Microsoft para detectar versiones no originales de su software. 

Ya como se comenta en el propio código fuente, para el caso de Windows Vista / 7 es más "complejo" realizar esta verificación, ya que existe el "riesgo" de usar una Slwga.dll donde la función SLIsGenuineLocal haya sido crackeada de tal forma que el valor devuelto siempre sea "true".

Para Windows XP, al usar la dll LegitCheckControlLib.dll podremos controlar un poco más el tema.

La librería LegitCheckControlLib.dll tiene también una función, llamada LegitCheck, que devuelve "true" o "false" cuando el Windows es genuino o no lo es respectivamente.

Suele ocurrir que estos Windows no originales, entre otras muchimas cosas, tienen modificada precisamente esta función, de tal modo que siempre devolverá "true".
Para modificar ese comportamiento de la función LegitCheck hay que abrir el IDA Pro o cualquier otro debugger y cambiar los bytes necesarios dentro del propio archivo LegitCheckControlLib.dll

Al cambiar aunque solo sea un JNE por un JMP dentro del código de la dll, estamos alterando su firma, por lo que una suma MD5 de la dll original no corresponderá con la dll modificada.

Lo que haremos nosotros es forzar el uso de un LegitCheckControlLib.dll original, donde la rutina LegitCheck no se ha parcheado.

En mi caso utilizo la versión 1.9.42.0 de la librería LegitCheckControlLib.dll, cuyo checksum MD5 es 3307a07b81206f354f0d4befee922437 Si no me equivoco, es la última versión hasta la fecha (XP Pro Service Pack 3)

En nuestro ejemplo podemos agregar la referencia de la dll instalada en la carpeta system32, que se debe encontrar bajo el nombre de "Windows Genuine Advantage Validation Tool":


(Haz click para agrandar)

O bien usar especificamente una determinada dll


(Haz click para agrandar)

En mi caso, tanto monta, monta tanto ya que ambas son originales

Lo que si es necesario es poner a true las propiedades Aislada y Copia local de la referencia:

Al ejecutar el programa, si el Windows es "Genuino" se muestra esta ventana:


(Haz click para agrandar)

En caso contrario se muestra esta otra (eres libre de cambiar el pirata pata-palo y el loro por cualquier otro art-work 🙂


(Haz click para agrandar)

Nota final: La referencia a la librería LegitCheckControlLib.dll solo se puede hacer desde Windows XP. Si intentas crear una referencia a dicha librería desde Visual Studio en Vista / 7 obtendras un bonito mensaje de error de COM.

Nota mental: Creo que no hace falta recordarlo, pero si sabes a ciencia cierta que estás usando un Windows XP no original, no usaría el OllyWGAxp para corroborarlo X’D X’D

Dudas, preguntas, comentarios varios…en el botón de abajo 🙂

 

Saludos.
mov eax,ollydbg; Int 13h  

Descargar código OllyWGAxp
(4 KB. Módulo)

Descargar OllyWGAxp
(787 KB. Requiere .NET Framework 3.5)