Habemus tags

Meta

Uno de los problemas que encontré con este alojamiento es que no tiene etiquetas (tags). De hecho, no sólo no las tiene sino que no está previsto que se incluyan fácilmente con la configuración actual porque no hay plugins disponibles Using Jekyll Plugins with GitHub Pages (Wow, un plugin de emojis, y otro de menciones!).

Pongo estas ideas aquí por si alguien me da pistas sobre cómo hacerlo mejor y/o por si alguien más puede aprovecharlas en su sitios.

Puesto que no puedo añadir plugins para las etiquetas y tampoco quiero generar todo el sitio estáticamente (quiero imaginar que es mejor utilizar jekyll en las github pages) pensé utilizar alguno de los plugins que hay para generar sólo las etiquetas. De los que encontré estoy probando jekyll-tagging que ha sido bastante fácil de instalar y configurar, como se explica más abajo. Hay más formas, como jekyll-tags-plugin, y en Tags In Jekyll hay otra explicación. Incluso llegué a pensar en hacerme un programita para generarlo pero me parecía demasiado trabajo tener que ver cómo va el sistema de plantillas y todo eso…

Primero, hago una nueva copia del sitio en local (con git clone): me servirá para generar el sitio con sus etiquetas y todo.

En este sitio sigo las instrucciones de los desarrolladores del plugin README para instalarlo. En particular, instalar la gema, generar el fichero Gemfile, poner el código en el directorio _plugins y modificar el _config.yml.

  • Genero el sitio con jekyll build --watch y en _site lo tengo en estático.
  • Copio al sitio donde mantengo el repositorio local (donde edito, genero y publico los posts) el directorio _site/tags a la raíz (parte estática pages) , lo añado con git add y publico.
  • Ahora tengo el sitio servido por jekyll con las etiquetas en modo estático.

Los problemas de esta forma de trabajar parecen evidentes: necesito dos copias en local del sitio, el flujo de trabajo complicado (aunque se puede automatizar). ¿Las ventajas? Tratar de mantener en la medida de lo posible el funcionamiento en github.io obteniendo la funcionalidad que nos ofrezcan. Veremos si es acertado o será mejor cambiar más adelante pero … ¡Tachán! Tenemos etiquetas.

Próximamente: Entiendo que podremos generar las categorías de una forma parecida (espero que no haga falta una tercera copia). Nunca he recibido muchos comentarios, pero espero poder incluirlos de alguna forma: la gente utiliza sitios como disqus pero fantaseo con algo más cercano a GitHub (¿tal vez a través de las issues? Veo que no soy el primero que lo piensa en GitHub hosted comments for GitHub hosted blogs. La limitación será entonces que para usarlo será necesario estar registrado en GitHub pero … ¿Saben por qué me apunté yo aquí? ¡Justo! Porque alguien me sugirió que lo hiciera (vimblog.vim: publicar en wordpress.com fácilmente).

Seguiremos informando.

Leer código de otros y buenos consejos de programación

Letras en la terminal

Esta entrada casi es una promesa a mi futuro yo porque no he leído el código de Doom ni es algo que prevea que vaya a poder hacer próximamente.

En The Exceptional Beauty of Doom 3’s Source Code hablan justamente de eso, el código de este juego y muestran ejemplos de codificación e ideas que tal vez podrían resultarnos útiles.

Siempre me ha interesado leer guías de estilo de codificación y ese tipo de cosas de diversas empresas y proyectos porque es útil para saber lo que queremos (o no querríamos) hacer con nuestro propio estilo. Sí que leo con cierta frecuencia código de otros en GitHub y en los proyectos de programación de nuestros estudiantes, que de todo el mundo se aprende.

El código de los proyectos de software libre (y las normas/consejos) de los propios proyectos nos pueden servir para leer un buen montón de código que es algo que, me temo, no hacemos con la suficiente frecuencia.

Mostrar la contraseña en el formulario o no

Entrada

Aunque es un tema que trato de traer a la discusión cuando se habla del diseño del proceso de identificación/autentificación con un formulario, veo que sólo enlazamos hace algún tiempo en Algunas ideas para simplificar el proceso de identificación y autentificación a Innovative Techniques To Simplify Sign-Ups and Log-Ins donde se habla de eso y alguna cuestión más.

Se trata de la idea (extendida y aplicada) del enmascaramiento de contraseñas cuando nos estamos autentificando en un sitio. Lo cierto es que puede ser una buena idea, pero para muchos usuarios es una molestia y, seguramente, es mejor darles la oportunidad de decidir si están en un entorno donde la contraseña debería enmascararse o no. De eso habla Luke Wroblewski en Showing Passwords on Log-In Screens continuando con algo que ya anticipó en Mobile Design Details: Hide/Show Passwords y que es un nuevo factor al que deberíamos darle algunas vueltas antes de diseñar nuestro sistema.

Muestra varios ejemplos y aprovecha también para introducir algunas ideas nuevas relativas a la identificación biométrica (con los iPhones, fundamentalmente).

Una buena lectura si te interesan estos temas.

Publicar en Facebook las entradas de este sitio usando Python

Enlaces en Página de Facebook

Ya anticipamos esta entrada hace un par de semanas en Extraer enlaces de una página web. Allí hablábamos de formatear una entrada de este sitio (u otro que proporcione RSS) para publicarla en Facebook (o donde nos parezca, claro). También en Publicar en Twitter las entradas de este sitio usando Python vimos algunas ideas sobre este tema, entonces para Twitter.

En este caso utilizamos el API oficial de Facebook y un paquete no oficial que la implenenta en Python, Facebook Python SDK.

Podemos instalarlo

fernand0@aqui:~$ sudo pip install facebook-sdk

Para su correcto funcionamiento necesita BeautifulSoup y requests y tal vez algunos módulos más. Si no están instalados en nuestro sistema, recibiremos las ‘quejas’ correspondientes.

Para obtener las credenciales tenemos que registrar nuestra aplicación en Facebook My Apps. Hace falta ir al menú avanzado (es más fácil registrar aplicaciones web, la verdad) y se nos asignarán algunos identificadores (fundamentalmente el token OAUTH, que podemos mirar en https://developers.facebook.com/tools/explorer/APPID/?method=GET&path=me%3Ffields%3Did%2Cname&version=v2.2, donde APPID es el que nos hayan asignado), que en nuestro caso almacenamos en ~/.rssFacebook y leeremos desde el programa.

El programa es muy sencillo, se puede descargar en rssToPages.py V.2015-01-26 (enlazo a la versión actual por si en el futuro hago algún cambio).

Como decíamos arriba, empezamos leyendo la configuración relativa a los blogs de los que queremos leer para elegir uno. Si sólo hubiera uno se elegiría directamente:

config = ConfigParser.ConfigParser()

config.read([os.path.expanduser('~/.rssBlogs')])

print "Configured blogs:"

i=1
for section in config.sections():
	print str(i), ')', section, config.get(section, "rssFeed")
	i = i + 1

if (int(i)>1):
	i = raw_input ('Select one: ')
else:
	i = 1

print "You have chosen ", config.get("Blog"+str(i), "rssFeed")

Esta configuración debe contener una sección por blog y para cada uno de ellos contendrá la fuente RSS, el nombre de la cuenta de Twitter y el nombre de la cuenta de Facebook. Para este sitio tendría el siguiente aspecto:

[Blog1]
rssFeed:http://fernand0.github.io/feed.xml
twitterAc:mbpfernand0
pageFB:fernand0.github.io

También puede contener un campo más, linksToAvoid que se usa en el programa de extraer los enlaces para evitar algunos de ellos (lo uso en otro blog para eliminar los enlaces a las categorías).

if (config.has_option("Blog"+str(i), "linksToAvoid")):
	linksToAvoid = config.get("Blog"+str(i), "linksToAvoid")
else:
	linksToAvoid = ""

Leemos la última entrada del blog y extraemos el texto y los enlaces de manera similar a como hacíamos en Extraer enlaces de una página web.

Y para evitar los enlaces que no queríamos a la hora de generar el contenido de la página:

		print linksToAvoid
		print re.escape(linksToAvoid)
		print str(link['href'])
		print re.search(linksToAvoid, link['href'])
		if ((linksToAvoid =="") 
			or (not re.search(linksToAvoid, link['href']))):
			link.append(" ["+str(j)+"]")
			linksTxt = linksTxt + "["+str(j)+"] " + link.contents[0] + "\n"
			linksTxt = linksTxt + "    " + link['href'] + "\n"
			j =  j + 1

Finalmente, buscamos si la entrada contiene alguna imagen. Si no la hay no pondremos nada, pero Facebook lo hará su cuenta (puede ser nuestra foto, un botón, lo primero que haya). Tal vez podríamos configurar una por defecto cuando nuestra entrada no tenga una, si no nos gusta la que sale por defecto (en mi caso es mi foto; como no me gusta verla allí esto me obliga siempre a pensar en una foto para el post):

pageImage = soup.findAll("img")
#  Only the first one
if len(pageImage) > 0:
	imageLink = (pageImage[0]["src"])
else:
	imageLine = ""

Leemos la configuración para Facebook y empezamos a trabajar, solicitando la lista de páginas de las que somos administradores (el nombre de la página en la que queremos publicar lo habremos puesto en ~/.rssBlogs):

config.read([os.path.expanduser('~/.rssFacebook')])
oauth_access_token= config.get("Facebook", "oauth_access_token")

graph = facebook.GraphAPI(oauth_access_token)
pages = graph.get_connections("me", "accounts")

El fichero de configuración tiene este aspecto en este caso:

[Facebook]
oauth_access_token:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Podría haber más cuentas de Facebook, pero no lo he probado así que no garantizo que todo vaya a funcionar correctamente.

De las páginas que gestionamos se elige la que queremos (que se pone en el apartado de configuración del blog, ~/.rssBlogs).

for i in range(len(pages['data'])):
	if (pages['data'][i]['name'] == pageFB):
		print "Writing in... ", pages['data'][i]['name']
		graph2 = facebook.GraphAPI(pages['data'][i]['access_token'])
		graph2.put_object(pages['data'][i]['id'], 
			"feed", message = theSummary, link=theLink, 
			picture = imageLink, 
			name=theTitle, caption='',
			description=theSummary.encode('utf-8'))

statusTxt = "Publicado: "+theTitle+" "+theLink

Ya llevo más de un mes probando con un par de blogs y la solución parece que funciona bastante bien. Lo más molesto fue conseguir las credenciales y dar de alta la aplicación (con un ‘falso’ paso a producción; falso porque no la usa nadie más, al ser de escritorio).

Dudas, comenarios, ideas… ¡Hazme un pull request o un issue!

Técnicas para evitar ataques comunes a la memoria

Vale, no es memoria, pero la analogía me sirve

Un texto interesante en Software defense: mitigating common exploitation techniques sobre diversas técnicas que los sistemas Windows ofrecen para proteger nuestros programas frente a ciertos ataques comunes, en particular relacionadas con la gestión de la memoria y dificultar a un atacante la posibilida de encontrar los datos en lugares predecibles.

De la misma serie también se pueden leer:

Una introducción a la criptografía elíptica

El escondido

La criptografía es de mis temas ‘menos’ favoritos en seguridad. Siempre nos avisan de que es algo difícil de hacer bien. Por lo tanto nos relega al papel de meros consumidores, eso sí, tratando de estar al día en los tamaños de claves, algoritmos criptográficos y esas cuestiones.

En A (relatively easy to understand) primer on elliptic curve cryptography se publicaba hace algunos meses justamente lo que dice el título: una introducción a la criptografía de curvas elípticas que puede servirnos como introducción para recordar/ponernos al día en este tema.

Empiezan hablando de RSA y las propiedades que lo hacen interesante (la factorización es costosa -lenta- y la multiplicación es rápida).

The RSA algorithm is the most popular and best understood public key cryptography system. Its security relies on the fact that factoring is slow and multiplication is fast. What follows is a quick walk-through of what a small RSA system looks like and how it works.

Incluso muestran un pequeño ejemplo:

Let’s make this more concrete with an example. Take the prime numbers 13 and 7. Their product gives us our maximum value of 91. Let’s take our public encryption key to be the number 5. Then using the fact that we know 7 and 13 are the factors of 91 and applying an algorithm called the Extended Euclidean Algorithm, we get that the private key is the number >29.

Y sigue…

Luego, entra más a fondo en la criptografía de curvas elípticas:

An elliptic curve cryptosystem can be defined by picking a prime number as a maximum, a curve equation, and a public point on the curve. A private key is a number priv, and a public key is the public point dotted with itself priv times. Computing the private key from the public key in this kind of cryptosystem is called the elliptic curve discrete logarithm function. This turns out to be the trapdoor function we were looking for.

Interesante.

Atacando a un jugador de póquer

Ordenador

Ya habíamos hablado de ataques dirigidos a personas concretas (por ejemplo: Ataques dirigidos: el caso de Facebook).

En Sharking: High-Rollers in the Crosshairs contaban el caso de un ataque a un jugador profesional de póquer. En su hotel de Barcelona le robaron el portátil y lo infectaron con un troyano que les permitía ver las jugadas cuando se conectaba a sitios de juego en línea. En este caso el ataque dirigido consiste en un robo físico, aprovechando la presencia en un hotel y que el propietario no tomó precauciones al salir de la habitación.

Fundamentos de gestión de cuentas

Defensa

Aunque sólo se trata de una hipotética conversación entre un desarrollador y el experto en seguridad Troy Hunt podemos leer en Introducing the “Secure Account Management Fundamentals” course on Pluralsight un resumen de bastantes de las cuestiones que hay que tener en cuenta a la hora de desarrollar o poner en funcionamiento un sistema de gestión de cuentas para nuestra aplicación web, algunas bastante sutiles.

Avisos, almacenamiento de las contraseñas, recuperación de las mismas, correos de registro, reputación, sesiones, bloqueo ante ataques, cambios,…

En clase solemos decir que parece más fácil de lo que realmente resulta ser al final.

PCI y desarrollo seguro

Donde vive el dinero

Una de las cosas que nos gustó ver cuando nació PCI Data Security Standards fue su atención al desarrollo seguro de programas. En particular el punto 6 y algunos otros inciden en ese tema. En 2013 se anunció la versión 3.0 y este año debería ser la transición de la versión 2.0 que sigue vigente a la nueva.

Nada más salir, en 2013 PCI Standards se comentaban los cambios y novedades del estándar en el punto relativo al desarrollo de programas.

There is plenty of discussion elsewhere about the new standards, so I thought I would focus on the PCI DSS changes in Requirement 6 (Develop and Maintain Secure Systems and Applications):

  • 6.1 & 6.2 Switched the order of requirements 6.1 and 6.2. Requirement 6.1 is now for identifying and risk ranking new vulnerabilities and 6.2 is for patching critical vulnerabilities. Clarified how risk ranking process (6.1) aligns with patching process (6.2) and also clarified that the latter applies to “applicable” patches.
  • 6.3 Added a note to clarify that the requirement for written software development processes applies to all internally- developed software and bespoke software, and now mentions “industry standards” as well as “industry best practice”.
  • 6.3.1 Added “development/test accounts” to “custom accounts” to clarify intent of requirement
  • 6.4 & 6.4.1-6.4.4 Enhanced, more specific, testing procedures to include document reviews for all requirements.
  • 6.4.1 Aligned language between requirement and testing procedures to clarify that separation of production/ development environments is enforced with access controls.
  • 6.5 Updated developer training to include how to avoid common coding vulnerabilities, and to understand how sensitive data is handled in memory.
  • 6.5.x Updated requirements to reflect current and emerging coding vulnerabilities and secure coding guidelines. Updated testing procedures to clarify how the coding techniques address the vulnerabilities.
  • 6.5.10 New requirement for coding practices to protect against broken authentication and session management.
  • 6.6 Increased flexibility by specifying automated technical solution that detects and prevents web-based attacks rather than “web-application firewall.” Added note to clarify that this assessment is not the same as vulnerability scans required at 11.2.

Se puede descargar de la Sección de documentos de la web de PCI.

Extraer enlaces de una página web

Enlaces en Página de Facebook

Hace algunas semanas hablábamos de Publicar en Twitter las entradas de este sitio usando Python y prometíamos hacer lo mismo con Facebook.

Echando un vistazo al API de Facebook y haciendo algunas pruebas me encontré con que no podía publicar enlaces con su texto (Facebook los transforma para que podamos pinchar en ellos, pero no permite -o no encontré la forma- que los pongamos con su texto y esas cosas). Por otro lado, quería experimentar con la posibilidad de publicar las entradas de esta bitácora completas allí; Facebook no favorece que introduzcamos textos largos porque nos muestra un trocito y permite abrir ‘el resto’.

Siempre me ha llamado la atención la ‘netiqueta’ de algunas listas de correo donde suele ponerse al lado del texto de los enlaces un número y al final del mensaje la lista de esos enlaces, cada uno asociado al número correspondiente.

Esto fue lo que decidí hacer para publicar en la página de Facebook de fernand0.github.io (y otras, claro). El programa que traemos hoy hace justamente eso, como paso previo a la publicación en la página de Facebook (y, tal vez, ¿para poder enviar las entradas por correo a los interesados?).

El programa puede verse en rssToLinks.py (apuntamos, como siempre, la versión actual por si hubiera cambios en algún momento).

Algunas formas de extraer los enlaces serían: buscarlos con expresiones regulares, o también con algún parser de HTML (en el Blogómetro hace años utilizábamos el Simple SGML parser. Buscando un poco encontré el proyecto Beautiful Soup que presume de ser una manera rápida de recorrer el contenido de una página web y decidí darle una oportunidad.

Para utilizarlo incluímos los módulos necesarios. Para obtener el contenido utilizamos la fuente RSS, así que también necesitaremos feedparser:

import feedparser
from bs4 import BeautifulSoup
from bs4 import NavigableString
from bs4 import Tag

Leemos la fuente RSS y vamos recorriendo las entradas:

feed = feedparser.parse(url)

for i in range(len(feed.entries)):

Y empieza la ‘magia’ de Beautiful Soup:

        soup = BeautifulSoup(feed.entries[i].summary)
        links = soup("a")

Esto es, le pasamos los datos al analizador, y lanzamos la pregunta de lo que queremos extraer. En este caso tenemos una entrada en el summary y queremos obtener los enlaces (etiqueta a) para la entrada que ocupa la posición i. Nos devolverá una lista de elementos html que incluyen dicha etiqueta.

En algunas entradas ponemos imágenes, que no queremos que aparezcan en el texto, así que utilizamos isinstance para comprobar si dentro del contenido del enlace hay otra etiqueta para evitarla (¿es posible que encontremos algún caso más adelante que sea problemático?). Recorremos la lista de enlaces (que vienen con las etiquetas y todo, claro). Ademas utilizamos el contador j para ir asociándoles números a los sucesivos enlaces (en el HTML original, todavía no lo hemos eliminado):

	j = 0
	linksTxt = ""
	for link in links:
		if not isinstance(link.contents[0], Tag):
			# We want to avoid embdeded tags (mainly <img ... )
			link.append(" ["+str(j)+"]")
			j =  j + 1

El contenido del enlace (ahora que ya sabemos que no es una etiqueta HTML) estará en link.contents[0] (puede haber más contenido, nuestros enlaces suelen ser ‘sencillos’).

	linksTxt = linksTxt + "["+str(j)+"] " + link.contents[0] + "\n"

El enlace está en link['href'].

	linksTxt = linksTxt + "    " + link['href'] + "\n"

Ahora necesitamos el texto del HTML:

	print soup.get_text()

En algunos casos el texto puede tener muchos saltos de línea, espacios, … Se podrían eliminar. Nuestras entradas suelen estar bien estructuradas y no aparece ese problema.

Ahora, si había algún enlace (¿publicaremos alguna vez una entrada sin ningún enlace?), lo añadimos al final:

	if linksTxt != "":
		print
		print "Links :"
		print linksTxt