Nota del autor

Si la entrada que estás leyendo carece de imágenes, no se ve el vídeo que teóricamente lleva incrustado o el código fuente mostrado aparece sin formato, podéis conocer los motivos aquí. Poco a poco iré restableciendo la normalidad en el blog.
Este blog es un archivo de los artículos situados previamente en Lobosoft.es y ha dejado de ser actualizado. Las nuevas entradas pueden encontrarse en www.lobosoft.es. Un saludo,
Lobosoft.

lunes, 30 de junio de 2008

Ahorro energético en la empresa

A principios del presente año, Electronic Data Systems (EDS) presentó una serie de consejos que venían a ser para las empresas el equivalente a las recomendaciones que presentábamos el pasado 5 de junio, Día Mundial del Medio Ambiente. Aunque muchos de estos consejos pueden parecer más que obvios, lo cierto es que se tienen mucho menos en cuenta de lo que debiéramos. Por eso, desde Lobosoft queremos lanzar al ciberespacio este mensaje. A partir de mañana presentaremos uno de estos consejos al día, al margen de cualquier otro tipo de entrada que consideremos de interés. Aunque sigo el esquema de los ocho consejos de EDS, la interpretación es propia y abundo un poco más en cada uno de ellos, presentando distintos puntos de vista así como experiencias propias que, así lo considero, pueden enriquecerlos un poco más. Si conoces alguna iniciativa al respecto o quieres dar tu opinión, como siempre, el blog está abierto a ello.


No quería terminar sin indicar que EDS (de la que podréis leer más en la Wikipedia, aunque es más que probable que su nombre os resulte conocido, ya que se trata de una de las consultoras con mayor trayectoria a nivel global, y recientemente surgió la noticia de la adquisición de ésta por parte de HP) mantiene un blog bastante interesante, especialmente en su vertiente de "tecnologías verdes", con artículos sobre los que reflexionar.


Actualización 08-07-2008:  Incluyo los enlaces a los comentarios generados en el blog sobre las recomendaciones de EDS en materia de ahorro energético y tecnología verde.



Google Code Search

 codesearch_logo.gif


En los días pasamos hemos visto algunas de las herramientas que brinda Google desde su sección de investigación y desarrollo, Google Labs, como pueden ser Google Sets, un buscador de conjuntos de palabras relacionadas con aquellas que especifiquemos en las consultas, pequeños trucos y utilidades incorporadas en Google Docs, incluido el uso de funciones avanzadas como Google LookUp, o herramientas como generadores de gráficos (Google Chart Image Generator). Incluso surgen iniciativas de terceros en torno al buscador más usado del mundo, como el entorno "textual" de Google, el Google Shell. Así, el Premio Príncipe de Asturias 2008 en Comunicación y Humanidades (por más que se presente como un mal referente desde el punto de vista ético), es ciertamente una de las empresas que más apuesta en investigación tecnológica, y más abierta se muestra hacia la comunidad de desarrolladores y usuarios (algo lógico, desde el punto de vista comercial).


Para esta comunidad de desarrolladores, Google ofrece utilidades como Google Code, un repositorio de proyectos software (similar al CodePlex que apoya Microsoft, o a páginas de ejemplos, como CodeProject o las siempre presentes La web del programador, La página de El Guille y similares). Pues bien, además de éste proyecto, Google incluye un buscador de código fuente (beta) llamado Google Code Search, con interesantes funciones como el uso de expresiones regulares en las búsquedas o el filtrado por tipo de licencia. Por ejemplo, podríamos buscar códigos donde se usara una determinada función, o se incluyese una librería específica, y que además fuesen distribuidas bajo los términos de una licencia GPL. Un interesante recurso que a buen seguro será útil para los desarrolladores, sea cual sea su lenguaje de programación preferido.



gcs.PNG

domingo, 29 de junio de 2008

Google Sets, o los conjuntos de Google

Hace unos meses trataba en el blog algunas de las funcionalidades curiosas de Google Docs, como el relleno automático de rangos de celdas en las hojas de cálculo, a partir de una "semilla" de dos o más palabras relacionadas. Google realizaba una búsqueda por similitud con dichas palabras, y era capaz de rellenar, con mayor o menor fortuna, el resto de celdas del rango con términos relacionados con los que le habíamos especificado.


Navegando hace unos días, encontraba una de las herramientas de Google Labs que proporcionaba, precisamente, esta misma utilidad. Se trata de Conjuntos de Google, o Google Sets. Indicando unas pocas palabras podemos obtener un conjunto de términos relacionados (en esta ocasión con enlaces de búsqueda interna en Google incluidos) en una sencilla web.



gs01.PNG


 Tras indicar algunas palabras, solicitamos un conjunto grande o pequeñoy, actuando en consonancia con nuestros deseos, Google devolverá un conjunto de resultados más o menos variopinto, según la lógica existente entre los términos de búsqueda que hayamos especificado.


gs02.PNG

sábado, 28 de junio de 2008

GoogleBot ya sabe escribir

Google ha dado un paso más allá con su web crawler GoogleBot. Ahora es capaz de rellenar automáticamente formularios y acceder a las páginas dinámicas que se generen tras los mismos. De momento está limitado a formularios que realizan el paso de parámetros mediante GET, es decir, aquellos que tras el formulario tienen una página con una URL única, sin parámetros variables que impidan que sea indexada, y entre cuyos campos no se encuentre ninguno de tipo “password” o de autenticación (por ejemplo, usando captchas).


Aunque la noticia en sí es interesante, de momento Google sólo usará esta función de GoogleBot en sitios web que considere relevantes, al igual que ya hizo con la búsqueda interna integrada en los resultados de consultas (la tecnología Teleportation), como el que aparece integrado por ejemplo en los resultados del sitio web de la NASA, y que pudimos conocer gracias al Blog de Nico y Paula.



nasa.PNG

viernes, 27 de junio de 2008

Monitorizando las búsquedas de Google

He estado probando una aplicación gratuita que puede convertirse en una herramienta bastante interesante para aquellos aficionados al posicionamiento web que quieran automatizar determinadas búsquedas en Google, presentándolas según su relevancia y, sobre todo, asociándolas a un determinado dominio web. Es decir, podemos realizar búsquedas a nivel mundial, relacionando sus contenidos con nuestro sitio web, y ver en qué posición aparece respecto a ese término de búsqueda.


fmg01.PNG


La aplicación en cuestión es Free Monitor for Google. Su uso es muy sencillo, bastando con crear un proyecto en el que incluiremos la URL del sitio web que deseamos estudiar, y añadir una serie de palabras clave que serán las usadas por la aplicación en las consultas a Google. Entre las opciones de configuración podemos establecer el número de enlaces que aparecerán (de forma predeterminada, el Top 10 de Google), y el motor de Google que usaremos (si filtramos por un determinado país o no). Una vez terminada la ejecución de las mismas, podemos ir viendo las diversas palabras clave y la posición que ocupa nuestro sitio web dentro del ranking particular de ese término. Para este ejemplo, he probado a buscar los términos Lobosoft, Eurodipity y DSL en el dominio de Lobosoft.es, y Silverlight y Albloguera en el blog de nuestro amigo más dotnetero.




fmg02.PNG




Sin duda, un interesante programa que puede descargarse desde la web de sus creadores, Cleverstat.

Más problemas con Firefox 3

Algo falla. No solo se detectan diversas vulnerabilidades en Firefox 3 (algo a lo que por desgracia nos vamos acostumbrando como usuarios en cada lanzamiento de un nuevo producto software), sino que además no muestra bien elementos que su predecesor presentaba correctamente. Sabemos además que Firefox 3 no supera el test Acid 3 en su totalidad, pero con el error de hoy he de confesar que me la ha jugado a base de bien. Me encanta iGoogle como "portal" configurable. Tengo así el buscador a mano y una serie de noticias (habitualmente suscripciones a RSS mediante Google Reader) de mi interés, como los blogs que sigo. Pues bien, si cambio el tamaño del navegador, o lo tengo maximizado, no se ven correctamente las "cajitas" del lector RSS.


 


errff301.PNG


Durante el proceso de cambio de tamaño de la ventana, hay un punto exacto en el que se ve todo bien. Algo parecido ocurre con las "ventanas" flotantes del chat de GMail.


errff302.PNG


¿Incompatibilidad del AJAX de Google con el nuevo Firefox? ¿En el tejado de quién está la pelota?


errff303.PNG

jueves, 26 de junio de 2008

Búsqueda de páginas por geolocalización

experimental_sm.gif


Ahora es posible realizar búsquedas de geolocalización de páginas web (al menos de aquellas que incluyan dicha información en su contenido) gracias a un servicio de Google, aún en desarrollo. Como viene siendo habitual, Google permite a los usuarios y desarrolladores realizar pruebas de sus nuevas funcionalidades a través de Google Labs, un entorno controlado en el que advierten muy claramente que todo aquello que estamos a punto de ver, usar y disfrutar, puede sufrir bastantes modificaciones hasta llegar a ser un producto maduro (de llegar a serlo).

El servicio de búsqueda está disponible en Google Experimental Labs, y se complementa con búsquedas en una línea de tiempo, que puede resultar útil en búsquedas relacionadas con hechos o personajes históricos.



busquedageo.PNG


Más experimentos interesantes son la sugerencia de palabras (al ir escribiendo un texto a buscar, aparece una lista desplegable con diversas opciones, una funcionalidad ya disponible en la barra de Google que podemos usar en conjunción con nuestro navegador preferido) o los atajos de teclado para evitar tener que ir alternando el uso de teclado y ratón durante la navegación en los resultados de consultas al buscador más famoso de la red de redes.


shot_suggest.jpg

miércoles, 25 de junio de 2008

Firmando digitalmente archivos XML con .NET

En una entrada anterior presentaba, a grandes rasgos, la recomendación de la W3C respecto a las firmas XML. Su versión 2.0 es bastante reciente (de 10 de junio), y se trata de un documento bastante completo donde poder profundizar en este tema.


Hoy veremos cómo implementar en .NET un sistema de firma y validación de archivos XML. El proceso, como veremos, es un simple calco de lo que presentaba en la teoría.


Partiremos de un archivo XML (prueba.xml) muy sencillo. Simplemente tiene un par de etiquetas: y . Como veréis, modifico los carecteres de cierre de la etiqueta ( ">" por "]"). Su finalidad es únicamente la de evitar el procesado de Wordpress previo a guardar la entrada, que provoca la modificación de las mismas, y que no se muestren adecuadamente. Dicho esto, el documento del que partimos en nuestro ejemplo será similar a este:



<saludo]
<hola]Mundo</hola]
</saludo]

Básicamente, tendremos una método encargado de cargar el documento XML y generar, a partir de una cadena de caracteres que le pasemos, la clave a usar en la firma. Para eso hacemos uso del RSACryptoServiceProvider, una clase de System.Cryptography que nos permite realizar la encriptación asimétrica mediante el algoritmo RSA. También cabría destacar el uso de la propiedad PreserveWhitespace del objeto XmlDocument, por lo que hablaba en el anterior post  respecto al CanonicalizationMethod.



[csharp]
private XmlDocument LoadDocument(string filename, string keystr, out RSACryptoServiceProvider rsaKey)
{
try
{
// Create a new CspParameters object to specify
// a key container.
CspParameters cspParams = new CspParameters();
cspParams.KeyContainerName = keystr;

// Create a new RSA signing key and save it in the container.
rsaKey = new RSACryptoServiceProvider(cspParams);

// Create a new XML document.
XmlDocument xmlDoc = new XmlDocument();

// Load an XML file into the XmlDocument object.
xmlDoc.PreserveWhitespace = true;
xmlDoc.Load(filename);

return xmlDoc;
}
}
[/csharp]

Hecho esto, sólo nos queda firmar o verificar la firma. Para ello, pasamos el objeto XmlDocument y la clave RSA al correspondiente método.


SignXML lleva a cabo la firma del documento XML, recuperando el árbol del mismo, generando la firma e insertando al final del mismo un nuevo elemento Signature.



[csharp]public string Sign(string key, string filename)
{
try
{
RSACryptoServiceProvider rsaKey;
XmlDocument xmlDoc = LoadDocument(filename, key, out rsaKey);

// Firmamos el documento XML
DigitalSign.SignXml(xmlDoc, rsaKey);

// Guardamos los cambios
xmlDoc.Save(filename);

// Mensaje de salida
return "Firmado el documento XML.";
}
}[/csharp]

Por su parte, VerifyXML genera la firma del XML y la contrasta con la almacenada en el documento XML.



 [csharp]
public string Verify(string key, string filename)
{
try
{
RSACryptoServiceProvider rsaKey;
XmlDocument xmlDoc = LoadDocument(filename, key, out rsaKey);

// Verificamos la firma del XML
bool result = DigitalSign.VerifyXml(xmlDoc, rsaKey);

// Y mostramos el resultado de la verificación
if (result)
{
return "La firma del XML es válida.";
}
else
{
return "La firma del XML no es válida.";
}
}
}
[/csharp]

La codificación interna de DigitalSign y VerifyXML la presentamos a continuación:



[csharp]
internal class DigitalSign
{
///


/// Firma un documento XML
///

/// El documento a firmar
/// Clave usada para firmarlo
internal static void SignXml(XmlDocument Doc, RSA Key)
{
try
{
// Creamos el objeto de firma XML
SignedXml signedXml = new SignedXml(Doc);

// Añadimos la clave a usar
signedXml.SigningKey = Key;

// Creamos una nueva referencia para ser firmada
Reference reference = new Reference();
reference.Uri = "";

// Añadimos una transformación de encapsulación o "ensobramiento" a la referencia
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(env);

// Añadimos la referencia al objeto de firma
signedXml.AddReference(reference);

// La calculamos
signedXml.ComputeSignature();

// Obtenemos la representación XML de la firma y la guardamos en un objeto XmlElement
XmlElement xmlDigitalSignature = signedXml.GetXml();

// Y por último añadimos el elemento al documento XML
Doc.DocumentElement.AppendChild(Doc.ImportNode(xmlDigitalSignature, true));
}
}
[/csharp]

[csharp]
internal static Boolean VerifyXml(XmlDocument Doc, RSA Key)
{
try
{
// Crea un nuevo objeto SignedXML y le pasa el documento
SignedXml signedXml = new SignedXml(Doc);

// Encuentra la firma y crea un nuevo objeto XmlNodeList
XmlNodeList nodeList = Doc.GetElementsByTagName("Signature");

// Si no la encuentra, lanza una excepción
if (nodeList.Count <= 0)
{
throw new CryptographicException("Error de verificación: No se encontró ninguna firma en el documento.");
}

// En este caso sólo se permite una firma por el documento XML completo. Si encuentra más de una
// lanza una excepción
if (nodeList.Count >= 2)
{
throw new CryptographicException("Error de verificación: se ha encontrado más de una firma en el documento.");
}

// Carga el primer nodo con la firma
signedXml.LoadXml((XmlElement)nodeList[0]);

// Y valida la firma, devolviendo si es válida o no
return signedXml.CheckSignature(Key);
}
}
[/csharp]

Y, tras aplicar la firma digital al documento de partida, prueba.xml, el resultado que obtendremos será el siguiente:


<saludo]
<hola]Mundo</hola]
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#" ]
<SignedInfo ]
<CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315" /]
<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1" /]
<Reference URI=""]
<Transforms]
<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature" /]
</Transforms]
<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" /]
<DigestValue]MDAWGdR299ZLHW13klBnxnSi094=</DigestValue]
</Reference]
</SignedInfo]
<SignatureValue]mmyQoNoNqIFjADmEhkDPshvG5KTEWxooLKdcp1oSz2DlALYd0HthnZ+q5eKcU9bU8g5TKIvNnPl3kT7/r5w19+TKdrYD43GFJZswWtrUXRTroroIcFdRpZFWNiFDI9JdJwMUUMKKkJ7JzWTrLoM5/W2+hzk+bwIQ4xU5AUDmUP0=</SignatureValue]
</Signature]
</saludo]

Por último, incluyo un código de ejemplo, con el proyecto de firma digital, y una aplicación de consola que firma y verifica los datos de la firma en un documento XML.


 [download#9]

martes, 24 de junio de 2008

La guerra de formatos

Proseguimos brindando a nuestros lectores la posibilida de reflexionar ante unas imágenes didácticas. Hoy, la guerra de formatos vista por dos supervivientes: la cinta VHS y el Spectrum.


http://www.youtube.com/v/ySRoqmEOfrU;rel=0


Y por si fuera poco, la Tira Ecol correspondiente:



tiraecol-277.png

Posicionamiento en Eurodipity

El posicionamiento SEO tiene sus peculiaridades. Me enteré de la existencia del concurso eurodipity por mera casualidad, cuando uno de sus participantes me escribió un mail solicitando un enlace a su sitio web, de modo que se incrementase su PageRank. Esta práctica, que imagino que será habitual entre los concursantes (ya que he podido ver listas de enlaces en blogs que son meros conjuntos de “eurodipitys” apuntando a uno u otro sitio web), tiene su lógica, ya que parte de los ingredientes de la poción mágica de Google viene determinada por la importancia que tenemos para los demás, en función del número y calidad de los sitios web que nos apuntan. En el caso de Lobosoft, aun con un modesto PageRank 3, tiene su trascendencia para subir rápidamente del PageRank 1 al 2, e incluso ayudar a ascender hasta el tercer nivel.


El caso es que tras un par de comentarios de otros concursantes de Eurodipity en la entrada del otro día sobre el concurso, me he preguntado cómo habían llegado hasta mí. Son miles los blogs que hablan sobre el tema. Así que he realizado una búsqueda en Google sobre la palabra Eurodipity en sitios webs de España (obvia decirlo, en las otras búsquedas aparecería bastante más atrás, así que por lógica debieron acceder a través de la opción más restrictiva de búsqueda). Y aquí estamos: en la quinta posición, con sólo un post sobre eurodipity.


ardilla.gif


Si bien el SPAM puede ser (y será) un gran problema de un concurso de este tipo, no lo es menos la interferencia de sitios web con una trayectoria previa en Internet, o dominios que ya tengan un determinado PageRank asociado en Google (o importancia relativa en otros motores de búsqueda). Imagino que la organización habrá tenido en cuenta este hecho, ya que de obviarlo sería posible que una página web con bastante importancia para los buscadores, por el mero hecho de publicar la noticia resultase vencedora del concurso.


Aquí dejo la captura del mini-momento de gloria de Lobosoft dentro de fenómeno Eurodipity.



eurodipity.PNG

lunes, 23 de junio de 2008

Firma digital de XML

La firma digital de documentos XML es una recomendación de la W3C que define una sintaxis XML para las firmas digitales. Dada la expansión de XML como soporte para tecnologías web (SOAP, SAML, etc.) así como para para el intercambio de información en general, resulta interesante conocer un poco más a fondo esta recomendación de la W3C.


Una firma XML sigue la estructura que reproducimos aquí, que no es otra que la ofrecida por W3C en su documento XMLDSig.



Signature
SignedInfo
SignatureMethod
CanonicalizationMethod
Reference
Transforms
DigestMethod
DigestValue
Reference ...

SignatureValue

KeyInfo

Object

Los elementos que presenta esta estructura son los siguientes:



  • SignedInfo especifica qué se firmó y con qué algoritmos. El SignatureMethod y CanonicalizationMethod elementos son utilizados por el elemento SignatureValue y se incluyen en SignedInfo para evitar una posible manipulación.

  • Reference Una lista de elementos de referencia recogen los recursos que se han firmado usando la URI de referencia. También especifica cualquier transformación que deba aplicarse a los recursos antes de aplicar el algoritmo has (en DigestMethod), y el resultado de aplicar a los recursos (codificada en DigestValue en Base64).

  • SignatureValue es la codificación en Base64 del valor de la firma generado según las especificaciones del método SignatureMethod de la clase SignedInfo, serializado por el elemento CanonicalizationMethod.

  • KeyInfo es un elemento opcional que permite obtener la clave necesaria para validar la firma. Habitualmente contiene un conjunto de certificados X.509.

  • Por último, Object contiene, de estar presente, contendrá los datos cifrados en caso de encontrarnos ante una firma con sobre (envolvente).


Respecto al CanonicalizationMethod, cabe indicar que es un poco más complejo de lo habitual, ya que por las características propias de XML los espacios en blanco son tratados como inexistentes dentro de las etiquetas (por ejemplo, sintácticamente los elementos y son iguales).


La validación de una firma XML sigue un procedimiento denominado Core Validation, o validación del núcleo. Básicamente consta de dos pasos:




  • Validación de referencias: Cada elemento Reference es verificado mediante el correspondiente recurso, aplicando aquellas transformaciones que sean necesarias. El resultado es comparado con el DigestValue almacenado. Si no coinciden, la validación será dada por errónea.

  • Validación de la firma: El elemento SignedInfo es serializado usando el método de canónico especificado en CanonicalizationMethod. La clave es recuperada habitualmente usando KeyInfo, y la firma validada mediante SignatureMethod.




En una próxima entrada veremos cómo poner en práctica estos conceptos para desarrollar una aplicación en .NET que permita firmar digitalmente documentos XML, así como validar si son correctos.

Kaspersky Lab indica una posible solución para datos cifrados por Gpcode.ak

Kaspersky Labs anuncia que es capaz de recuperar los datos cifrados por el virus (Virus.Win32.)Gpcode.ak, una variante de Gpcode que la firma rusa anunciaba en su sitio web a primeros del presente mes. Gpcode.ak presenta una curiosa peculiaridad respecto a otros virus: en lugar de eliminar la información la “secuestra”. Para ello realiza una encriptación de los datos de su víctima mediante un algoritmo RSA-1024, indicándole después que se ponga en contacto para recibir (previo pago) una clave que permita desencriptar la información perdida. En los foros de diversos sitios de seguridad se han hecho eco en los días pasados del virus, fundamentalmente por este curioso matiz que presenta. Sin embargo, y dejando de lado lo peculiar de su sistema de rapto, no es más dañino que cualquier otro virus que eliminase nuestra información. Éste, simplemente, nos ofrece una última oportunidad para recuperarla, previo pago de una cierta cantidad.


gpcode_ak.gif


En cualquier caso, como avanzaba al comienzo, Kaspersky afirma que es capaz de recuperar los datos cifrados. Para ello solicita al usuario que no reinicie su equipo, ni ejecute programas, navegue o haga uso del mismo. Y es que el sistema de recuperación no puede ser más simple: indican a los usuarios que pueden hacer uso de algún software gratuito, como PhotoRec, una aplicación distribuida bajo licencia GPL, y que acompañado por TestDisk permite recuperar desde archivos perdidos a particiones del disco duro. Como suele ocurrir con aplicaciones de este tipo, son capaces de recuperar archivos eliminados recientemente, pero no de reubicarlos en sus localizaciones originales. Kaspersky trabaja en estos momentos en una herramienta complementaria que permita agregarle esta funcionalidad.


Según afirman los técnicos de Kaspersky Labs, Gpcode.ak crea un archivo temporal mientras está realizando la encriptación de los datos, fichero que es posteriormente eliminado pero que es susceptible de ser recuperado por el método que acabamos de comentar. Y me pregunto: ¿para qué tanta encriptación con llaves de 1024 bits, si luego el virus no toma la simple precaución de llevar a cabo un borrado irrecuperable, sobrescribiendo el contenido del archivo temporal antes de eliminarlo?


De cualquier modo, es una buena noticia para aquellos usuarios que hayan sido infectados por este virus, no más dañino, como puede comprobarse, que cualquier otro. Eso sí, durante días ha sido tan mediático como lo fueron en su día Viernes 13 o I Love you.

Eurodipity

eurodipity-es.png


Quienes trabajamos (o lo hemos hecho) en la rama de la informática más vinculada a Internet sabemos la gran importancia que reviste poseer un buen posicionamiento en los buscadores (y, quien habla de buscadores habla de Google hoy día. Esta valoración de las páginas de Internet en base al arcano algoritmo del PageRank de Google ha llevado a crear disciplinas en torno al posicionamiento y su importancia. SEO, un referente en este aspecto, lleva un par de años dirigiendo a los internautas un reto: crear un determinado contenido web y conseguir el mejor posicionamiento en buscadores en un plazo de tiempo determinado. Este año el concurso se inició hace unos días, consistiendo en conseguir la mejor entrada de Google cuando un potencial usuario realice una búsqueda del término Eurodipity, palabra formada por la unión de Europa y Serendipity (el efecto por el cual alguien descubre algo accidentalmente). La decisión de usar Eurodipity como palabra clave se dio el pasado 19 de junio, y el concurso se prolongará hasta las 12 horas del 5 de septiembre de 2008. Entre los premios que se otorgarán a los tres primeros puestos en el ranking por país estarán varias noches de hotel y un portátil MacBook Pro.


Las reacciones no se han hecho esperar, como podemos observar si realizamos una búsqueda en Google del término en cuestión. Así, Eurodipity ofrece miles de resultados en los diversos países que participan en el juego. Para conseguir un mejor posicionamiento los concursantes no dudan en establecer listas de enlaces, referencias cruzadas con otros sitios web (especialmente con aquellos que tienen un mayor PageRank) o registro de dominios o subdominios que incluyan la mágina Eurodipity en sus URLs. No nos queda más que desear toda la suerte posible a los concursantes en su gesta. El próximo septiembre, por tanto, sabremos qué resultado arrojan SEO e Internet para los premios eurodipity.

domingo, 22 de junio de 2008

Sin comentarios

star-wars-ascii.jpg


Ya conocía la existencia de esta versión en ASCII de Stars Wars, y de hecho me constaba que provenía de un video (por llamarlo de algún modo) que podía verse a través de telnet. Buscando información sobre otro tema (El libro The Cathedral and the Bazaar de Eric S. Raymond, que está hecho un buen elemento...), me acabo de encontrar con una dirección desde la que es posible ver el original:


telnet towel.blinkenlights.nl


(Para los güindouseros sin mucha experiencia, basta con teclear el telnet desde Inicio->Ejecutar, o en la línea de comandos. Si lo ejecutáis desde el enlace que he puesto el navegador os mostrará una advertencia, ya que debe ejecutar una serie de aplicaciones en el equipo: run32, url.dll, ...)

sábado, 21 de junio de 2008

El virus I Love You

Siguiendo con la línea humorística y desenfadada, os dejo con un nuevo vídeo de Enjuto Mojamuto. En esta ocasión se ve infectado por el virus I Love You, y aparece en su ayuda un famoso antivirus. Pero a Enjuto le da igual: él usa una famosa distribución de GNU/Linux, así que no teme a los virus.


http://www.youtube.com/v/6iWOd0aYOX4;rel=0

El Libro de Mozilla

El pasado día 17 de junio era el previsto para el lanzamiento de Firefox 3. Ese día publiqué una noticia en el blog referente a este asunto encabezada por un texto parecido a una profecía. Algunos lectores de Lobosoft me preguntaron por el mismo y su significado. Realmente no se trata de un texto propio, sino de un fragmento del imaginario Libro de Mozilla. Estos fragmentos aparecen cuando en la barra de dirección de un navegador Mozilla se escribe about:mozilla. En cierto modo es una especie de Huevo de Pascua de esta familia de navegadores. En cada versión de Firefox cambia el mensaje, y el que publicaba el otro día se correspondía con el de la tercera versión del mismo.


Si tenéis interés en leer el resto de mensajes, están publicados (en inglés, eso sí) en la página que Mozilla posee a este respecto. Versiones traducidas de los mismos pueden encontrarse en la Wikipedia, donde también se encuentra un texto similar correspondiente a Flock.


Como curiosidad, cabría señalar que Mammon (curioso nombre) es Internet Explorer, y que en versiones antiguas del mismo aparecía una ventana azul, similar a la famosa "Pantalla de la muerte" de Windows cuando se escribía about:mozilla. Posteriormente fue cambiado a res://mshtml.dll/about.moz

viernes, 20 de junio de 2008

Control de procesos en Windows

Ayer sacaba del baúl de los recuerdos un código en VB.NET que permitía recuperar el valor del número de serie del disco duro a partir de una llamada a la función GetVolumeInformation de Kernel32. En aquella época también desarrollé una aplicación que sólo permitía una instancia en memoria en un momento dado. Es decir, podía ejecutarse una única vez, y si el ejecutable era lanzado de nuevo era capaz de detectar si el proceso ya estaba en ejecución, trayendo la ventana a primer plano. Lo cierto es que la aplicación en cuestión permanecía oculta para el usuario y sólo se reactivaba ante unos eventos determinados. En esto se parecía a un servicio de Windows, pero la solución adoptada no podía ser ésta, por lo que finalmente se trató de una aplicación de formulario de Windows.


Aunque no traeré aquí todo el código de la aplicación (sobre todo porque no tiene demasiada trascendencia), al ver la aplicación sí que me pareció interesante incluir una entrada con la forma de realizar las llamadas a las funciones SetForegroundWindow y FindWindow, en este caso de la librería User32, para traer a primer plano una aplicación determinada, y para encontrar el proceso si está en ejecución. También se trata de código en Visual Basic .NET.


[vbnet]
#Region " Saber si una aplicación está en memoria "
''' DECLARACIÓN DE LA FUNCIÓN DEL API DE WINDOWS PARA TRAER UNA VENTANA AL PRIMER PLANO
_
Public Shared Function SetForegroundWindow( _
ByVal hWnd As IntPtr) As Boolean
End Function
'
'
_
Public Shared Function FindWindow( _
ByVal lpClassName As String, _
ByVal lpWindowName As String) As IntPtr
End Function
'
Public Shared ceroIntPtr As New IntPtr(0)
'
#End Region

Public Shared Sub Main()
' Se comprueba si la aplicación está en memoria
Dim nWnd As IntPtr
'
nWnd = FindWindow(Nothing, "Alerta")
If nWnd.Equals(ceroIntPtr) Then
' Si no está, se carga la actual
Application.Run(New Alerta)
Else
' Si ya está, se activa
SetForegroundWindow(nWnd)
' y se sale de la actual
Application.Exit()
End If
End Sub
[/vbnet]

El código no guarda demasiados secretos. Básicamente se trata de comprobar al inicio de la ejecución de nuestra aplicación si ésta ya se encuentra en memoria. De ser así, la traemos a primer plano y salimos de la instancia actual. Si no es así, simplemente procedemos a lanzar el programa en sí.


Antes comentaba que la aplicación que desarrollé en su día debía mostrarse en primer plano en un momento dado. Para hacerlo, usaríamos la misma función SetForegroundWindow, pero en este caso el puntero usado sería a la propia aplicación, y proporcionado por :


[vbnet]SetForegroundWindow(Me.Handle)[/vbnet]

jueves, 19 de junio de 2008

Procesadores de textos avanzados

Aquí el abuelo cebolleta presentando sus recuerdos en esta humilde bitácora. Aunque la historia de la informática es ciertamente breve, no lo es menos que ha conseguido calar hondo en la cultura y, ante todo, en la forma de trabajar y relacionarse de la gente. Hoy día las transacciones bancarias, las compras electrónicas, la búsqueda de información a través de Internet, son tareas cotidianas que podrían parecer insulsas y pocas personas las tildarían de emocionantes. Sin embargo, hace pocos años eran mera ciencia ficción, dando lugar a relatos más o menos fidedignos con la realidad de la informática (recordemos la película Juegos de Guerra, por ejemplo, que traía al blog no hace mucho).


Hoy traigo unas capturas de pantalla que muestra cómo han cambiado las cosas en apenas unos años. El primer procesador de textos que tuve la fortuna de usar fue el Writing Assistant, del (llamémosle así) paquete ofimático IBM Assistants Series, un producto lanzado en 1984, y que yo pude usar alrededor de 1987 o, a lo sumo, en 1988. Corría el primer año (o puede que el segundo, pero no más) de instituto, y nuestro profesor de Historia nos presentaba unos rudos IBM PC, con su doble disquetera (de 3,5", que ya eran un lujo, y de los que había un par con disco duro y una disquetera de 5,25"). Comenzamos a aprender en estas clases de Historia algo que hoy sí que es historia: el uso de comandos como copy con, edlin y el manejo básico de archivos y directorios en MS-DOS, que hace unos años fueron sustituidos por carpetas, que son lo mismo pero más fáciles de transportar. Volviendo al Writing Assistant, aprendí a crear gráficos y a redactar textos frente al ordenador, saliéndome de mis incipientes programas (venga, vale, juegos) en BASIC de Spectrum.



wa1.PNG


menu.PNG


Llevaba años buscando el programa. Ni en páginas de abandonware, ni en redes P2P conseguía encontrarlo. Y esta noche me encuentro con una página llamada Vetusware, que como su nombre indica, alberga software tan vetusto, arcaico y entrañable como este.



ga2.PNG


Gracias a la magia de DosBOX he podido ejecutarlo sin mayor problema. Y qué deciros: dieciocho años después me resulta tan familiar usarlo como entonces.



wa2.PNG


ga1.PNG


¿Y vosotros, echáis de menos algún programa? ¿O preferís, sin lugar a dudas, estas aplicaciones actuales, visualmente más agradables, para qué negarlo, pero devoradoras de recursos?



word2007.PNG

Obtener el número de serie del disco duro en .NET

Hace varios años desarrollé una aplicación de escritorio que debía distribuirse de forma controlada, evitando una posible duplicación ilegal del mismo. Como sistema de control incluí en la aplicación una determinada funcionalidad que se basaba en la generación de números de serie vinculados a la unidad de disco duro donde era instalado el programa. Recientemente escribía una entrada sobre la obtención de los números de serie de dispositivos USB, y la forma de usar dicha información para crear una especie de llaves USB "caseras" que permitiesen validar software legal. Tanto una idea como otra son factibles, e incluso una combinación de ambas permitiría obtener una mayor seguridad, siempre teniendo en cuenta que deberían usarse adecuadamente, así como usar algún ofuscador de código, ya que el código objeto permite ser desensamblado, máxime cuando hablamos de código en .NET que, como ya sabemos, se traduce a lenguaje intermedio (IL) del CLR, y es fácil obtener el código fuente asociado al mismo en cualquiera de los lenguajes soportados por .NET (y particularmente, en VB.NET o C#).


El código que presento, por tanto, es el de la obtención del número de serie de un disco duro. Se trata de código en Visual Basic .NET, y se apoya en llamadas a librerías del sistema, en este caso de Kernel32.




[vbnet]Private Declare Function GetVolumeInformation Lib "kernel32" Alias "GetVolumeInformationA" (ByVal lpRootPathName As String, ByVal lpVolumeNameBuffer As String, _

Function HDSerial() As String
Dim sDrv As String, sVolumeName As String, sSysName, SN As String
Dim iSerial, R, i As Int32
sDrv = "C:\" & ControlChars.NullChar
sVolumeName = New String(ControlChars.NullChar, 100)
sSysName = New String(ControlChars.NullChar, 100)
R = GetVolumeInformation(sDrv, sVolumeName, sVolumeName.Length, iSerial, 0, 0, sSysName, sSysName.Length)
SN = iSerial.ToString("X8")
Return SN.Substring(0, 4) & "-" & SN.Substring(4, 4)
End Function
[/vbnet]

Como vemos, obtenemos el valor del número de serie del disco duro mediante una llamada a la función GetVolumeInformation, y recuperando en la variable iSerial el valor de este número de serie. Posteriormente es convertida a Hexadecimal con el método ToString y el formato "X". El número 8 indica el número de valores 0 (cero) significativos a la izquierda del valor, si no llega a los 8 dígitos necesarios.

De navegadores va la cosa

Ayer fue (día 17 de junio, aunque la diferencia horaria provocó equívocos a nivel mundial a este respecto), entre unas cosas y otras, el día de los navegadores, gracias al lanzamiento de Firefox 3. Recordé un video que se ha convertido prácticamente en un clásico (al igual que su personaje, un friki en toda regla). Se trata de Enjuto Mojamuto, uno de los personajes de Muchachada Nui, que en esta ocasión se enfrenta a un curioso elemento de su ordenador. Como no tiene desperdicio, aquí lo dejo para quien desee verlo.


http://www.youtube.com/v/bL1EDX-zDTM;rel=0

miércoles, 18 de junio de 2008

Informática y cambio climático

logo.png


Que el uso del ordenador afecta al medio ambiente es algo innegable. Tanto durante su producción, en la que se consumen considerables cantidades de agua y combustibles fósiles, como durante su vida útil durante la que requiere energía eléctrica para funcionar, así como al final de sus días, produciendo basura tecnológica, nuestro compañero de trabajo y ocio se convierte en un peligro para el medio ambiente. Sin embargo, si tomamos algunas medidas nuestro impacto sobre el medio puede ser mucho menor.


La iniciativa Climate Savers Computing (aquí en castellano) tiene como función principal promover el desarrollo y uso de tecnologías que mejoren de forma eficiente el consumo de energía de los ordenadores, tanto en su uso cotidiano como en los momentos en que permanecen inactivos, algo muy frecuente en determinados ámbitos, como en las oficinas en las que el ordenador es una mera herramienta más, que puede ser usado de forma discontinuada, y permanece numerosas horas inactivo pero consumiendo energía. Esta campaña de Adena/WWF es apoyada por diversas compañías del sector, desde fabricantes de hardware como Intel, Lenovo, Dell o IBM, hasta gigantes del software como Google, Sun o Microsoft. Como objetivo se marcan reducir las emisiones contaminantes de CO2 provenientes del uso del ordenador en 54 millones de toneladas por año (el equivalente al generado por unas 15 centrales térmicas como la que quieren instalar, por ejemplo, cerca del Parque Tecnológico de Andalucía, en Málaga, o a las emisiones anuales de 11 millones de automóviles). El ahorro no se daría solamente en el plano medioambiental, sino que supondría minorar en 3,7 billones de euros el gasto energético mundial. En resumen, se trata de reducir el consumo de los equipos en un 50%, y todo esto para dentro de un par de años: 2010. ¿Una utopía? No necesariamente.


Entre los recursos que brinda la página de Climate Savers Computing se encuentran diversas guías para elegir un ordenador eficiente desde el punto de vista del consumo energético, o cómo habilitar en los diversos sistemas operativos medidas de ahorro energético, algo que no sólo nos puede ahorrar un buen puñado de monedas al año, sino que contribuirá significativamente a no degradar aún más nuestro medio ambiente.


Entre todos, es posible. ¿Te sumas?

Firefox3 vs Acid3

Hoy mismo comentaba en el blog que instalaba -a prueba, eso sí- la versión 3 (beta) de Firefox. No he podido resistirme y publicar hoy mismo un par de capturas de pantalla con Firefox 3 enfrentándose a las pruebas Acid 2 y 3.


Aunque el navegador basado en Mozilla supera a la perfección el test Acid 2 (que no pasaba del todo en sus versiones 2.x, al igual que ocurre con iExplorer 6 y 7), no ocurre lo mismo con Acid 3. Ésta es la imagen que devuelve Firefox 3 ejecutar el Test Acid 2:


acid2firefox3.PNG


Acid 3, en cambio, se basa en mostrar un contador que se va incrementando, así como una serie de retículas que se van formando y coloreando conforme avanza el contador. Firefox 3 Beta sólo consigue llegar al mismo nivel que la última de sus RC (la Firefox RC 3), es decir, al punto 71.



acid3firefox3.PNG


El gráfico de referencia sería el siguiente:



acid3ref.PNG


Aquí mostramos una gráfica con el nivel de cumplimiento con los estándares, según el test, obtenida del blog Hardware 2.0:



ff3b5_acid3_graph_b.jpg


Como podemos observar, de momento el navegador de Apple es el que consigue un mayor grado de cumplimiento de la norma. En cualquier caso, la Beta 3 de Firefox consigue un notable a este respecto, máxime en comparación con el triste nivel 17 alcanzado por Internet Explorer 8 Beta:



ie87.png

Lanzamiento de Firefox 3

Mammon se durmió. Y la bestia renació, propagándose por toda la Tierra, y sus seguidores fueron legión. Y proclamaron los nuevos tiempos y sacrificaron cosechas con fuego, con la astucia de los zorros. Y construyeron un nuevo mundo a su propia imagen como prometían las palabras sagradas, y la palabra de la bestia y sus crías. Mammon se despertó, y súbitamente no era más que un rezagado.

de El Libro de Mozilla, 11:9
(10ª edición)

3-welcome-firstrun.png


Efectivamente, con todos ustedes Firefox 3 en el día de la descarga masiva tras su lanzamiento. A ver qué tal van esos 14.000 y pico cambios respecto a su predecesor. ¿Vencerá la astucia del tercer zorro a las artes del octavo Explorador?


medium.jpg


Actualización:


En la página Difunde Firefox se presenta un artículo con las novedades a nivel de interfaz de usuario que incorpora la versión 3 de Firefox. Por mi parte, incluyo un nuevo artículo con los resultados de los test Acid 2 y Acid 3 sobre esta nueva versión del navegador.


Actualización  26-06-2008:


Una de las cosas que me ha llamado la atención durante estos días de uso de Firefox es su capacidad para cambiar el tamaño de las páginas, y guardar la configuración preferida por el usuario para su visualización. Al igual que en versiones anteriores de Firefox, Firefox 3 es capaz de cambiar el zoom de la página (menú Ver->Tamaño, o Ctrl ++ , Ctrl -- para incrementar y disminuir el tamaño de letra de las páginas). Firefox 3 es capaz, además, de cambiar el tamaño de las imágenes y estructura de la página (divs, tablas, etc.) para mostrar una visión realmente escalada de la misma. Además, guarda la configuración elegida por el usuario para cada página de forma individual, e incluso entre sesiones. Una opción que considero bastante útil.


lunes, 16 de junio de 2008

Un escáner de equipos en la red

Existen numerosas herramientas disponibles para la detección de equipos en una red, que permiten a su vez comprobar qué puertos tiene abiertos uno de ellos en concreto. Sin embargo, no siempre disponemos de la posibilidad de contar con este software, porque no se nos permite su instalación y/o ejecución, o bien porque lo hemos olvidado y no trajimos nuestra memoria USB con las pertinentes aplicaciones portátiles.


La consola de comandos de Windows, aun sin ser tan potente y flexible como los diversos shells de Linux, permite realizar tareas bastante más avanzadas de las que habitualmente llevamos con ella (dir c:, cd windows, del *.* o format c: /u y similares). Lo cierto es que Microsoft parece haberse dado cuenta que tenía un campo de batalla abierto, y gracias a esto ha aparecido PowerShell para cubrir este hueco, tan necesario y útil para los administradores de red. Pero aun sin contar con esta consola de comandos avanzada (disponible en Windows Vista y Windows Server 2008, y mediante la instalación del correspondiente paquete, en Windows XP), lo cierto es que, como avanzaba, la consola de comandos ofrece la posibilidad de realizar tareas no tan sencillas, y automatizar tareas en los archivos de proceso por lotes (.bat) de toda la vida.


Hoy veremos cómo realizar un escáner de equipos en la red, que nos indicará aquellos que están accesibles desde nuestra ubicación. La herramienta por antonomasia para esta tarea, si no disponemos de ninguna otra, es ping. Ping es una aplicación sencilla pero utilísima que realiza una llamada a un equipo remoto, y nos devuelve si es accesible desde nuestra máquina. Esto nos permitirá ver si salimos correctamente a la red, si el otro equipo está disponible, y si todo funciona correctamente en nuestra red.


Sin embargo, si deseamos saber cuántos equipos hay disponibles en la red, la cosa se complica un poco. No esa cuestión de ir haciendo ping al resto de equipos de la red, uno por uno, y aquí entra la automatización de tareas de que hablábamos.


Creemos un archivo .bat, desde la consola, mediante el comando


edit escaneoequipos.bat


e introduzcamos en su interior las líneas siguientes:

@echo off
for /L %%a in (1,1,254) do ping -n 1 -w 350 192.168.1.%%a | findstr /i Respuesta

Procedemos a guardar los cambios, y salimos del editor.


Si ahora ejecutamos el archivo (escaneoequipos), comenzará a realizar ping a todas las máquinas de la subred indicada (192.168.1.1 a 192.168.1.254), y escribirá en pantalla aquellas direcciones desde las que reciba respuesta a su llamada.


La sintaxis del comando es muy simple:


En primer lugar, desactivamos el eco (echo off) para evitar la aparición de continuos mensajes. Podríamos dejarlo habilitado, simplemente con no incluirlo en el archivo, y trabajar así en modo verbose, con lo que sería mucho más sencillo depurar la ejecución.


For realiza un bucle, usando un contador %a (que en el caso de estar dentro de un archivo .bat ha de sustituirse por %%a, a modo de secuencia de escape), en el intervalo 1, 254, usando un salto (step) de 1, es decir, recorre todos los posibles valores del intervalo indicado. La tarea a realizar viene dada tras el do. Se trata de un ping con sólo una petición de eco (-n 1), y un tiempo de espera de respuesta de 350 milisegundos. Daremos la dirección IP de la red a que pertenezca nuestra máquina (podemos saberlo por la IP que tengamos otorgada, consultándola con el comando ipconfig), y usaremos el contador %%a para indicar la parte de la dirección IP que deseamos que sea cambiante. Por último, realizamos un filtrado (mediante un pipe | y el comando findstr) de aquellas respuestas que incluyan la subcadena "Respuesta" (si tenemos Windows en inglés, cambiar por Reply). ¡Y listo, ya tenemos un pequeño escáner de equipos en la red!


escanerhosts.PNG


Resulta sencillo ampliar la funcionalidad del script. Por ejemplo, podemos escanear todos los equipos dentro de una subred más amplica, anidando dos bucles del modo siguiente:

for /l %%a in (1,1,254) do for /l %%b in (1,1,254) do ping -n 1 -w 350 192.168.%%a.%%b | ...

Y recorreríamos todos los equipos comprendidos entre el 192.168.1.1 y el 192.168.254.254.

Dispositivos USB de sólo lectura

Seguimos dando vueltas en torno a la seguridad en torno a los dispositivos de almacenamiento USB. En los días pasados, hablábamos sobre la creación de software y el uso de unidades de almacenamiento USB como detectoras de software legal (tanto usando llaves HASP, como programando un sistema de reconocimiento de dispositivos basado en su número de serie, e implementación por software la detección del mismo y validación posterior de la aplicación). También veíamos cómo desactivar las unidades USB para prevenir la copia de datos en un entorno que deseábamos fuese mínimamente seguro (como los empresariales). Hoy veremos un sencillo método para establecer una política de seguridad sobre estos dispositivos, configurándolos como sólo lectura, un estado menos restrictivo que el anterior, ya que permitiremos la lectura de dispositivos USB pero no la escritura de datos en los mismos.


Para ello, simplemente debemos crear una entrada en el registro de Windows, en concreto dentro de

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control.


La llamaremos StorageDevicePolicies, y la configuraremos estableciendo una nueva entrada llamada WriteProtect, de tipo REG_DWORD, e inicializando su valor a 1 para permitir la lectura pero no la escritura en los mismos. Si cambiamos su valor a 0, volvemos a permitir la escritura en dispositivos USB. Cabe señalar que lo hemos probado con Windows XP SP2, quedando por comprobar si es válido en Windows Vista.


Si deseamos crear la entrada directamente desde .NET, podemos usar la clase RegistryKey incluida dentro del ensamblado Microsoft.Win32. La forma de hacerlo sería:


[csharp]
//Abrimos la key que deseamos del registro.
RegistryKey regKey = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Control", true);
//Creamos la subkey deseada. Lo recomendable sería comprobar que no existe previamente ;)
regKey.CreateSubKey("StorageDevicePolicies");
//Abrimos la key que acabamos de crear.
regKey.OpenSubKey("System\\CurrentControlSet\\Control\\StorageDevicePolicies");
//Establecemos el valor del parámetro WriteProtect. Aquí sí, si no existiera sería creado automáticamente.
regKey.SetValue("WriteProtect", "1");
[/csharp]

Por último, si queremos incluir la entrada mediante un archivo .reg, simplemente debemos crear un archivo de texto (con extensión .reg, claro está), en el que incluiremos el siguiente código:



; Especificamos el editor usado para incluir la entrada.
REGEDIT4
; Las diferencias entre REGEDIT 4 y la versión 5.00 es fundamentalmente que ésta última hace uso de UNICODE.
;
; Establecemos el valor de la key:
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\StorageDevicePolicies] “WriteProtect”=dword:0

domingo, 15 de junio de 2008

Generando texto aleatorio en Microsoft Word

Hace tiempo impartí clases de informática, y las materias que cubría mi labor docente iban desde el manejo básico o avanzado de paquetes ofimáticos (Open Office y Microsoft Office), a la administración de sistemas operativos, pasando por el diseño web y la programación de aplicaciones.


Aquellos que hayan impartido clases de Microsoft Word sabrán que la agilidad mecanográfica de los alumnos es bastante variable, en particular la de aquel alumnado que asiste a cursos de iniciación. Es por ello que, o bien proporcionamos textos de mayor o menor extensión o, si no hemos tenido tiempo para prepararlo o queremos sorprender a nuestros discentes, podemos usar una función escasamente documentada y poco conocida de Word. Se trata de Rand, una función que genera texto aleatorio. Para usarla, basta con escribirla en el documento que estemos utilizando, siguiendo la sintaxis de Excel, es decir, mediante un signo igual, seguido por el nombre de la función y un par de paréntesis, entre los que pueden ir opcionalmente los parámetros:


=rand()

Tras pulsar Enter, aparecerá cierta cantidad de texto, de forma aleatoria, según la versión de MS-Office que estemos usando.


Como apuntaba, la función Rand permite el paso de parámetros. En concreto, el número de párrafos y de frases por párrafo que deseamos que aparezcan en el documento.


=rand(num_parrafos,num_frases)

Como vemos, sencillo y práctico a la hora de generar una cantidad de texto determinada.Von vielen speziellen Anbieterseiten im Internet kann man sich (ganz kostenlos in der Regel) ein Programm herunterladen, mit Hilfe dessen der Spieler sich dann in einen so genannten „Pokerraum“ einloggen und gegen Gegner rund um den ganzen Globus <a href=\"http://www.casinoneu.de\">casinos</a> kann.

Obtener el número de serie de un dispositivo USB mediante clases WMI

En el ejemplo de ayer veíamos cómo crear un sistema de protección del software frente a copias ilegales del mismo, y nos basábamos para ello en una sencilla clase que consultaba el número de serie de los dispositivos USB. Al no tener acceso inicialmente al código interno de la misma, íbamos recorriendo todas las unidades del sistema, obteniendo su número de serie y comparándolo con el de referencia, que debería ser, claro está, el de la llave USB que habíamos proporcionado con el programa. Su uso era francamente sencillo, y bastaba con llamar al método GetSerialNumber() para obtener el número de serie de la unidad cuya letra pasáramos como argumento al mismo. Un ejemplo simple de su uso en un WinForm podría ser:


[csharp]
private void btnObtenerNumSerie_Click(object sender, EventArgs e)
{
USBDrives usbsn = new USBDrives();
txtSN.Text = usbsn.GetSerialNumber(txtDrive.Text);
}
[/csharp]

Ya advertimos que no se trataba de una aplicación totalmente segura (aunque podría usarse con éxito en pequeños proyectos, o conjuntamente con otras medidas de seguridad),y su función era ver una utilidad práctica para los conceptos que introduciré hoy: una introducción al manejo de dispositivos USB a través de las consultas sobre WMI (Windows Management Instrumentation, la implementación de Microsoft de WBEM, una iniciativa que pretende establecer una serie de estándares para permitir el acceso y compartir información de administración a través de una red empresarial).


La clase USBDrives contiene varios métodos privados, que se encargan fundamentalmente de parsear la información del dispositivo, tanto a la entrada del método GetSerialNumber () , que recibe la letra del dispositivo a examinar, tanto internamente, eliminando diversos caracteres innecesarios en los identificadores y nombres del mismo. El método que lleva todo el peso de la conversión es GetDriveSerialNumber(), cuyo código veremos a continuación:


[csharp]
///
/// Consulta el ManagementObjectSearcher para obtener el número de serie.
///

private void GetDriveSerialNumber()
{
string[] disks;
string drvNumber = string.Empty;
string drvLetter = string.Empty;

ManagementObjectSearcher objSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDiskToPartition");
foreach (ManagementObject diskManagement in objSearcher.Get())
{
disks = null;
drvLetter = ParserValue(diskManagement["Dependent"].ToString());
if (drvLetter == this._driveLetter)
{
disks = ParserValue(diskManagement["Antecedent"].ToString()).Split(',');
drvNumber = disks[0].Remove(0, 6).Trim();

ManagementObjectSearcher disks = new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
foreach (ManagementObject disk in disks.Get())
if (disk["Name"].ToString() == ("\\\\.\\PHYSICALDRIVE" + drvNumber) & disk["InterfaceType"].ToString() == "USB")
this._serialNumber = ParserSerial(disk["PNPDeviceID"].ToString());
}
}
}
[/csharp]

Para poder usar el código, debemos importar el ensamblado System.Management, que permite el uso de WMI, y su lenguaje de consulta WQL. Veamos qué hace este código.


Tras un bloque de declaración e inicialización de variables, instancia un objeto de la clase ManagementObjectSearcher, que será el encargado de ejecutar una consulta a algunas clases WMI Win32 para obtener las particiones lógicas y las unidades del sistema. Tras esto, iremos recorriéndolas, recuperando el árbol de unidades existentes en el equipo. Establecemos una comparación entre la letra de dispositivo (a partir de su ID correspondiente) y la que nos pasaron para obtener, y examinamos el valor del InterfaceType para saber si se trata de un dispositivo USB. Si en algún momento coincide todo ello, tenemos nuestra unidad localizada. El número de serie se obtiene a partir del PNPDeviceID, eliminando caracteres como "\" y "&".


Tal y como hemos visto, se trata de un método cómodo, elegante y organizado de obtener información de un dispositivo a partir de WMI, en lugar de tener que hacerlo mediante llamadas directas a la API de Windows (librería win32.dll en este caso) o usando código no manejado.


Para saber más:

sábado, 14 de junio de 2008

Creando una llave USB "casera" mediante código

Imaginemos que deseamos crear un sistema de seguridad para nuestro software basado en la comprobación de una llave hardware. Tradicionalmente, encontramos soluciones como el uso de disquetes con ciertas peculiaridades que impedían su grabación “normal”, por ejemplo mediante la inclusión en el mismo de sectores defectuosos o alterados que eran corregidos en la copia del disco, por lo que las copias eran inservibles para validar el software, evitando así (se supone) la duplicación no legal de estas aplicaciones. También se usaban llaves de encriptación, habitualmente conectadas al puerto serie, y últimamente es habitual el uso de llaves USB programables (del tipo de las llaves HASP) con este fin. Sin embargo, son dispositivos que tienen un precio si no elevado, sí al menos importante, y si lo que deseamos es proteger una aplicación cuyo coste no es demasiado elevado, puede costarnos, como suele decirse, más el collar que el perro. En la entrada de hoy quería usar un ejemplo, que se presenta únicamente (y el que avisa no es traidor) con fines didácticos y no como una solución real de seguridad, explicando cómo implantar la seguridad en el software basada en el uso de dispositivos USB de uso común, como un pendrive o memoria USB.


En la entrada de hoy crearemos un sistema de seguridad frente a la copia de nuestro software usando unidades de disco USB. Desarrollaremos una aplicación que sólo se ejecutará en presencia de una memoria USB que suministremos con el software. Podría servir incluso para distribuir la propia aplicación, y su capacidad no tiene por qué ser elevada.


Para conseguirlo, simplemente debemos obtener el número de serie del dispositivo (no el número de serie del volumen, que podemos obtener ejecutando el antiguo comando de MS-DOS vol sobre la unidad en cuestión, sino el número de serie físico), y con este número de serie convenientemente encriptado y almacenado en un archivo de configuración, llevar a cabo la comprobación en el inicio de la aplicación, o cuando deseemos comprobar si se trata de un software legalmente distribuido. El código para conseguirlo esto es sencillo. Imaginemos una aplicación de consola que verifica si tenemos conectado un determinado dispositivo USB. El código podría quedar como sigue:


[csharp]
class Program
{
static void Main(string[] args)
{
if (CheckUSB.CheckUSBKey())
Console.WriteLine("Llave USB detectada. Acceso permitido.");
else
Console.WriteLine("No se ha detectado la llave USB. Por favor, insértela y ejecute nuevamente la aplicación.");

Console.ReadLine();
}
}
[/csharp]

La comprobación viene dada por un método estático, CheckUSBKey, que devuelve un valor booleano tras comprobar el número de serie que hayamos especificado. Por simplicidad en el ejemplo, este valor es recuperado dentro del propio método.


[csharp]
static bool CheckUSBKey()
{
/* Este debería ser el valor adecuado del número de serie de nuestro dispositivo USB.
* Podríamos obtenerlo usando el método GetSerialNumber("letra_de_unidad") de la clase USBDrives,
* en el ensamblado USBSN.
*/
string _usbKeyAllowed = MiClaseConfiguracion.ObtenerNumeroSerieKEY() // un string con el número de serie que deseamos comprobar;
bool detected = false;

USBDrives usbDrive = new USBDrives();
string[] drives = Environment.GetLogicalDrives();

// Obtiene los nombres de los dispositivos, eliminando la \ de directorio
foreach (string strDrive in drives)
if (String.Equals(_usbKeyAllowed, usbDrive.GetSerialNumber(strDrive.Replace("\\", ""))))
detected = true;

return detected;
}
[/csharp]

Como vemos, simplemente recuperamos todas las unidades lógicas del equipo (entre las que se encuentran discos duros, unidades de disquete, CD o DVD, así como los discos USB que haya conectados en ese momento en el equipo. Para cada uno de ellos, comprueba si el número de serie devuelto es igual al del la llave USB que hemos utilizado, y que deberemos distribuir junto al programa. Hace uso de una clase, USBDrives, del espacio de nombres Lobosoft.Utilities.Disks, que viene incluido en el ensamblado adjunto, y que puede ser usado libremente. De momento incluye un único método, GetSerialNumber(string letra_unidad), que recibe una letra de unidad (vale tanto la letra en sí, por ejemplo "D", como el nombre de unidad, es decir, la letra seguida por dos puntos, "D:"), y devuelve una cadena de caracteres con el número de serie de esa unidad, si lo tiene, o la cadena vacía en caso contrario. En una próxima entrada veremos cómo funciona internamente esta clase.


La DLL de utilidad puede descargarse aquí:


Llave USB

jueves, 12 de junio de 2008

Cómo desactivar las unidades de almacenamiento USB en Windows

La gestión de la seguridad en la empresa pasa, entre otros factores, por el afianzamiento de los sistemas de entrada/salida de los equipos informáticos. Hoy día es extremadamente sencillo para un atacante extraer información de los sistemas, ya que los soportes de almacenamiento no sólo se han hecho más rápidos y eficientes, sino que han multiplicado por millares su capacidad de almacenamiento. Poco tienen que ver los vetustos disquetes de 5,25" ó 3,5", lentos y ruidosos, y con capacidades de 1,2 a 1,44MB (al menos usualmente) con las actuales memorias USB, de 4 u 8 GB, los teléfonos con memorias micro SD de varios GigaBytes, o simplemente con el correo electrónico o la transmisión de los datos por la red, inalámbrica o no.


En concreto, hoy veremos cómo establecer un control mínimo sobre los dispositivos USB, tan fáciles de traer y llevar, y susceptibles a albergar grandes cantidades de información. Nos centraremos en el sistema operativo Windows, y en particular en su edición XP, aunque buena parte de los temas que trataremos podrán ser probados en distintas versiones del mismo.


Podemos saber qué dispositivos se han conectado alguna vez a un equipo -incluidos aquellos que no estén presentes físicamente en el momento de llevar a cabo la comprobación, claro está-, usando el Administrador de Dispositivos de Windows. Si lo ejecutamos normalmente (Inicio->Ejecutar-> devmgmt.msc, o bien mediante botón derecho sobre el icono de Mi PC, seleccionando la opción Administrar del menú contextual y en el árbol desplegable de la izquierda, el Administrador de Dispositivos), veremos dentro de la opción de Unidades de Disco las unidades que hay actualmente conectadas, pero ninguna más.


Para ver todas las unidades a que ha tenido acceso el equipo en cuestión, iniciaremos una consola de comandos (Inicio->Ejecutar->cmd), y estableceremos a verdadera la variable de entorno devmgr_show_nonpresent_devices, mediante la introducción del comando:


set devmgr_show_nonpresent_devices=1

Otra opción sería establecer la variable de entorno para que quedase siempre inicializada de este modo. Para ello, pulsaríamos sobre el icono de Mi PC con el botón derecho del ratón, seleccionaríamos la opción Propiedades, y en la pestaña Avanzadas, haríamos clic sobre el botón de Variables de Entorno, y añadiríamos una nueva variable, bien para el usuario en cuestión, bien para el sistema, de modo que fuese independiente respecto al usuario que esté usando el equipo.


A continuación iniciaremos de nuevo el Administrador de Dispositivos, escribiendo


start devmgmt.msc

en la propia línea de comandos. Aparecerá nuevamente el Administrador, y dentro del menú Ver, activaríamos la opción Mostrar dispositivos ocultos. Ahora sí, encontraríamos todos los dispositivos que han sido instalados alguna vez en nuestro equipo bajo la rama Equipo->Unidades de disco, que aparecerán algo difuminados respecto a aquellos que están presentes en el equipo en ese momento.


admindispositivos.PNG


De este modo, podemos llevar a cabo una gestión (manual, eso sí, habría que ver cómo automatizar dicha tarea por ejemplo, mediante el uso de PowerShell) de los dispositivos USB conectados.Deshabilitando los puertos USB.

Windows lleva a cabo la gestión de los puertos USB en el propio registro de sistema. Por ello, bastará con editarlo para establecer si están habilitados o deshabilitados. En concreto, podemos llevar a cabo esta activación entrando en el Registro de Windows (Inicio->Ejecutar->regedit), y accediendo al nodo


HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\UsbStor.


El valor de la propiedad Inicio (Start) será el que determine el estado del servicio. Si su valor es 3 (que es lo habitual), el servicio de uso de dispositivos de almacenamiento USB estará activado. Bastará con cambiar el valor a 4 para desactivarlo, impidiendo así el acceso a los pendrives, discos duros externos, etc.


registro.PNG

miércoles, 11 de junio de 2008

Ponerle puertas al campo

Quería dejar constancia de la noticia referente al Registro Europeo de Blogs, así como mi particular visión sobre el mismo, antes incluso de publicar la “maravillosa” relación entre el Premio Príncipe de Asturias 2008 y el buscador Google, pero esta última me pareció tan aberrante que decidí adelantar su publicación.


Volviendo al registro de blogs, y según noticia de El País (y comentario en Microsiervos), lo cierto es que parece que aparece propuesto en una resolución de la Eurocámara de principios de mes. Se pretende llevar un registro de las bitácoras y sus autores, buscando dotar a Internet de las herramientas necesarias para el control de la información, fundamentalmente de dónde parte la misma, cuál es su fuente y razón. Así, todos los bloggers quedaríamos registrados, con nombre y apellidos, sexo, edad e incluso filias (¿y fobias?) políticas. Todo en aras de procurar a los usuarios de la red de redes el conocimiento sobre las fuentes de información, ante el exceso y proliferación de las mismas, al menos según palabras de Marta Badía, eurodiputada socialista. Palabras pronunciadas, a buen seguro, bajo el auspicio y tras la deliberación en torno a las palabras de Javier Rojo, presidente del Senado, que afirmaba el año pasado que en Internet no hay opiniones veraces ni contrastadas.


registro.png


Aunque se trata -de momento- de una mera recomendación por parte de la Eurocámara, y su aplicación dependerá de la legislación propia de los países miembros, lo cierto es que nos encontramos ante una medida de control innecesaria y, posiblemente, ineficaz. Al igual que es sencillo para cualquier usuario averiguar determinada información sobre un blog y su autor (a partir de un WHOIS, si cuenta con dominio propio, o usando los buscadores de Internet como "detectives privados"), no resultaría complicado para alguien eludir a dicho registro, alojando los blogs en servidores de hosting ajenos a la Comunidad Europea, o usando identidades falsas que se asemejasen a la de un autor ya registrado.


Los blogs son un medio de expresión libre que permite a los ciudadanos hacer llegar sus voces al resto del mundo cuando ningún medio “oficial” es capaz de hacerlo, bien porque la noticia no llegue a trascender del ámbito local, bien por otras razones que no entraremos aquí a juzgar. Lo cierto es que yo, como usuario de Internet, sé que un blog será tan serio como su autor pretendió hacerlo, y en mi mano está contrastar sus opiniones con otras y, lo que es más importante, con la mía, para intentar aproximarme a esa quimera llamada Verdad. Obviamente, el exceso de información puede llegar a provocar desinformación, pero es igualmente cierto que no siempre los medios de prensa llegan a cubrir todas las noticias, ni las páginas especializadas tienen la respuesta a todas las preguntas. Las bitácoras, por tanto, cubren estas carencias, o al menos lo intentan con mayor o menor éxito. Hay escritores reconocidos, programadores, artistas, políticos, que expresan su opinión en páginas oficiales, o en blogs personales. Dejemos que la ciudadanía se exprese libremente, siempre que sea a través del respeto, la comprensión y el mutuo reconocimiento, basándose siempre en el respeto a la libertad del otro. Y ante el exceso de información, enseñemos a los ciudadanos a leer y entender, a razonar sobre la información que se les presenta, porque sólo así se puede llegar a ser realmente libres. Menos registros y más libros, señorías.

Google, Premio Príncipe de Asturias 2008

googlewebhistory.jpg





Porque todo aquel que pide, recibe; y el que busca, halla; y al que llama, se le abrirá.



Mateo 7:7-12



No, el blog no cambia de temática, ni tan siquiera pretendo que sirva de púlpito desde el que adoctrinar a nadie. Sin embargo se entenderá perfectamente esta cita cuando presentemos la noticia de hoy (salvando la amplia familia de crisis que vive el país en estos últimos tiempos), que no es otra que la concesión por parte de la Fundación Príncipe de Asturias del Premio del mismo nombre al buscador Google. Tal y como leen: Google, Premio Príncipe de Asturias 2008 de Comunicación y Humanidades porque, en palabras del jurado,




Al poner de forma instantánea y selectiva al alcance de centenares de millones de personas el enorme caudal de información de Internet, Google ha hecho posible, en apenas una década, una gigantesca revolución cultural y ha propiciado el acceso generalizado al conocimiento. De este modo, Google contribuye de manera decisiva al progreso de los pueblos, por encima de fronteras ideológicas, económicas, lingüísticas o raciales.



Firmado en Oviedo, con fecha de hoy. Y se quedan tan anchos. En el blog he manifestado en ocasiones cómo me apasiona el buen hacer de Google en todo lo referido a la investigación de nuevas tecnologías y a la implantación de las mismas en sus productos. También que su postura, activa frente a los estándares (y no reactiva, como la de Microsoft, que intenta cambiarlos según su libre parecer) ha calado hondo entre la comunidad de usuarios y desarrolladores. Pero no lo es menos que en numerosas ocasiones he presentado aquí mi desacuerdo sobre la forma de actual, a nivel empresarial, tan peligrosa o más que la del gigante de Redmond, precisamente por lo que refería sabiamente el refranero, a saber, “líbrame Señor de las aguas mansas, que de las revueltas ya me cuido yo”. Google acapara cada día más información en sus sistemas que a día de hoy parecen capaces de procesar, si no una cantidad infinita de información, sí al menos una tremenda cuantía de la misma. El uso que dé a dicha información no es asunto nuestro... ¿o sí?


Personalmente, y desde el punto y hora en que no sabemos cuál es el límite autoimpuesto por Google en su recolecta de información, pienso que sí tenemos mucho que decir, y que sí es asunto nuestro. Obviamente, podría alegarse que podemos dejar de usar los servicios de Google: no a Gmail, ni a Blogger, ni a Picasa, ni al propio buscador. Pero, ¿quién nos defiende de su AdWords? Podemos navegar evitando la publicidad, al menos en cierto grado, pero la protección no siempre es total, ni del todo efectiva.


El problema de otorgar este premio a Google es que estamos obviando aspectos muy importantes de la compañía, puntera en las búsquedas en Internet (es parte de su negocio, al fin y al cabo), como por ejemplo la autocensura que se impuso hace un par de años cuando el Gobierno de China se lo exigió para continuar presente en el país, impidiendo a sus habitantes acceder a los servicios de correo, blogs personales y censurando los resultados de las búsquedas en páginas web y noticias. ¿Debería otorgarse un premio que se estimaba como prestigioso a una compañía así? ¿No eran suficientemente dignos el resto candidatos? Entre otros se contaban David Attenborough, el genial naturalista y ornitólogo, el político alemán Daniel Cohn-Bendit, portavoz del grupo de Los Verdes en el país teutón, y el loable proyecto de la Wikipedia, llevado a cabo gracias a las aportaciones desinteresadas de voluntarios en todo el mundo?


Hoy día puede comprobarse la diferencia existente entre las imágenes que devuelve Google cuando buscamos, pongamos por ejemplo, la palabra "Tiananmen". ¡Qué hermosas vistas de la plaza encontramos en la versión china del buscador! Y por contra, ¡cuán horrendas son las mostradas por Google.com!




Será por eso que, según declara su presidente y director ejecutivo, Eric Schmidt,




Nuestra verdadera pasión es poder ayudar a que toda la gente pueda acceder a la información que quiera en el idioma que prefiera. Sin embargo, sabemos que todavía hay muchas personas en el mundo que no tienen acceso a esta información y no pueden llevar a cabo en Internet todas las cosas que para nosotros son algo ya muy normal. Este premio debe servirnos como estímulo para dar una oportunidad a que toda esta gente pueda disfrutar de lo que nosotros disfrutamos.



Ciertamente... ¿curioso? ¿Incongruente? ¿O tal vez aberrante? La polémica está servida.