Ema Ortuzar

Si entran a http://www.smn.gov.ar/dpd/tiepre/mercobras/mb3uv.htm pueden la información meteorológica de la estación automática de observación que tiene el servicio meteorológico en la Ciudad de Buenos Aires.

Delicias del JavaScript

>> 1 == "1"

true

>> 1 === "1"

false

Conclusión, no usar == nunca más

His road to go

Mi amigo frandibar estrena su blog sobre sus experiencias jugando al go. ¡En una de esas hasta vean partidas mías por ahí!

Éxitos Fran!!!!!

D3 tips and tricks

Hace un tiempito que descubrí una fabulosa biblioteca que sirve para hacer visualizaciones y muchas más cosas, que se llama d3. Les recomiendo fuertemente que si quieren hacer cosas para browsers modernos le den una ojeada. Y buscando ejemplos y documentación sobre la misma encontré un libro on-line que me gustó, llamado D3 tips and tricks. En particular, me llamó la atención lo grosas que quedan las tablas cuando las hacés usando d3.


Happy hacking,
Aureliano.

Fracciones de Peano

Las últimas 2 semanas estuve haciendo en el laburo el curso de diseño orientado a objetos que da Hernán Wilkinson de 10 Pines. Dentro del curso, hay un ejercicio para hacer single dispatch que consiste en modelar números enteros y fracciones.
Como usar los números que me da el lenguaje para modelar los números me pareció choto, hice una implementación de los números de Peano y con eso hice las fracciones.

Abajo les dejo la primera versión que pasa los tests, pero que es media fea porque tiene ifs de la forma if isinstance(sumando, Enteros): #código. Si miran al final, van a ver los tests de unidad que tiene que pasar el código. Antes está la implementación.


import unittest

class Numero:

    DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO = 'No se puede dividir por 0'
   
    def esCero(self):
        self.shouldBeImplementedBySubclass()
   
    def esUno(self):
        self.shouldBeImplementedBySubclass()
   
    def __add__(self,sumando):
        self.shouldBeImplementedBySubclass()
   
    def __mul__(self,factor):
        self.shouldBeImplementedBySubclass()
   
    def __div__(self,divisor):
        self.shouldBeImplementedBySubclass()
   
    def shouldBeImplementedBySubclass(self):
        raise NotImplementedError('Should be implemented by the subclass')
   
    def __le__(self, other):
        return self < other or self == other

class Entero(Numero):
    pass

class Zero(Entero):
   
    def esCero(self): return True
   
    def esUno(self): return False
   
    def __eq__(self, other):
        return self.__class__ == other.__class__
   
    def __add__(self,sumando):
        return sumando
   
    def __mul__(self, factor):
        return self
   
    def __repr__(self): return "0"
   
    def __lt__(self, other): return not self == other

class Next(Entero):

    def __init__(self, before):
        self.before = before
   
    def esCero(self): return False
   
    def esUno(self): return self.before.esCero()
   
    def __add__(self,sumando):
   
        if isinstance(sumando, Entero):
            return Next(self.before + sumando)
       
        return sumando + self
   
    def __mul__(self, factor):
   
        return factor + self.before * factor
   
    def __repr__(self): return "N" + repr(self.before)
   
    def __eq__(self, other):
   
        if isinstance(other, Fraccion):
            return other == self
   
        if self.__class__ != other.__class__: return False

        return self.before == other.before
   
    def __lt__(self, other):
   
        if self.__class__ != other.__class__: return False
        return self.before < other.before
   
    def __div__(self, other):
   
        if isinstance(other, self.__class__):
            return Fraccion(self, other)
   
        if isinstance(other, Fraccion):
            return Fraccion(other.d * self, other.n)
   
        raise Exception("No se puede dividir por %r" % other)

class Fraccion(Numero):

    def __init__(self, n, d):
        if (d.esCero()):
            raise Exception(Numero.DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO)
           
        self.n = n
        self.d = d

    def __add__(self, other):

        #a/b + c/d = (a.d + c.b) / (b.d)
   
        if isinstance(other, self.__class__):
            return Fraccion((self.n * other.d + other.n * self.d), self.d * other.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n + other * self.d, self.d)
       
        raise Exception("No se sumar %r" % other)

    def __mul__(self, other):

        # (a/b) * (c/d) = (a.c) / (b.d)
        if isinstance(other, self.__class__):
            return Fraccion(self.n * other.n, self.d * other.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n * other, self.d)

    def __div__(self, other):
   
        # (a/b) / (c/d) = (a.d) / (b.c)
       
        if isinstance(other, self.__class__):
            return Fraccion(self.n * other.d, other.n * self.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n, self.d * other)
       
        raise Exception("No se dividir %r" % other)

    def __eq__(self, other):
   
        if isinstance(other, self.__class__):
            return self.n * other.d == self.d * other.n
       
        if isinstance(other, Entero):
            return self.n == self.d * other
       
        return False

    def __repr__(self): return repr(self.n) + "/" + repr(self.d)

class NumeroTest(unittest.TestCase):

    def createCero(self):
        return Zero()
   
    def createUno(self):
        return Next(self.createCero())
   
    def createDos(self):
        return Next(self.createUno())
   
    def createTres(self):
        return Next(self.createDos())
   
    def createCuatro(self):
        return Next(self.createTres())
   
    def createCinco(self):
        return Next(self.createCuatro())
   
    def createSeis(self):
        return Next(self.createCinco())
   
    def createSiete(self):
        return Next(self.createSeis())
   
    def createUnQuinto(self):
        return Fraccion(self.uno, self.cinco)
   
    def createDosQuintos(self):
        return Fraccion(self.dos, self.cinco)
   
    def createDosVeinticincoavos(self):
        return Fraccion(self.dos, self.cinco * self.cinco)
   
    def createUnMedio(self):
        return Fraccion(self.uno, self.dos)
   
    def createCincoMedios(self):
        return Fraccion(self.cinco, self.dos)
   
    def createSeisQuintos(self):
        return Fraccion(self.seis, self.cinco)
   
    def createCuatroMedios(self):
        return Fraccion(self.cuatro, self.dos)
   
    def createDosCuartos(self):
        return Fraccion(self.dos, self.cuatro)
   
    def setUp(self):
   
        self.cero = self.createCero()
        self.uno = self.createUno()
        self.dos = self.createDos()
        self.tres = self.createTres()
        self.cuatro = self.createCuatro()
        self.cinco = self.createCinco()
        self.seis = self.createSeis()
        self.siete = self.createSiete()
       
        self.unQuinto = self.createUnQuinto()
        self.dosQuintos = self.createDosQuintos()
        self.dosVeinticincoavos = self.createDosVeinticincoavos()
       
        self.unMedio = self.createUnMedio()
        self.cincoMedios = self.createCincoMedios()
        self.seisQuintos = self.createSeisQuintos()
        self.cuatroMedios = self.createCuatroMedios()
        self.dosCuartos = self.createDosCuartos()
   
    def testAEsCeroDevuelveTrueSoloParaElCero(self):
   
        self.assertTrue (self.cero.esCero())
        self.assertFalse (self.uno.esCero())
   
    def testBEsUnoDevuelveTrueSoloParaElUno(self):
   
        self.assertTrue (self.uno.esUno())
        self.assertFalse (self.cero.esUno())
   
    def testCSumaDeEnteros(self):
   
        self.assertEqual (self.dos,self.uno+self.uno)
   
    def testDMultiplicacionDeEnteros(self):
   
        self.assertEqual(self.cuatro, self.dos*self.dos)
       
    def testEDivisionDeEnteros(self):
   
        self.assertEqual(self.uno, self.dos/self.dos)
   
    def testFSumaDeFracciones(self):
   
        sieteDecimos = Fraccion( self.siete, self.dos * self.cinco ) # <- br="" corresponda="" lo="" por="" que="" reemplazar="">       
        self.assertEqual (sieteDecimos,self.unQuinto+self.unMedio)
       
        #
        # La suma de fracciones es:
        #
        # a/b + c/d = (a.d + c.b) / (b.d)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # NO SE ESTA TESTEANDO ESE CASO
        #
   
    def testGMultiplicacionDeFracciones(self):
   
        self.assertEqual (self.dosVeinticincoavos,self.unQuinto*self.dosQuintos)
       
        #
        # La multiplicacion de fracciones es:
        #
        # (a/b) * (c/d) = (a.c) / (b.d)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # TODAVIA NO SE ESTA TESTEANDO ESE CASO
        #
   
    def testHDivisionDeFracciones(self):
   
        self.assertEqual (self.cincoMedios,self.unMedio/self.unQuinto)
       
        #
        # La division de fracciones es:
        #
        # (a/b) / (c/d) = (a.d) / (b.c)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # TODAVIA NO SE ESTA TESTEANDO ESE CASO
        #
        #
   
    # Ahora empieza lo lindo! - Primero hacemos que se puedan sumar enteros con fracciones
    # y fracciones con enteros
    #
    def testISumaDeEnteroYFraccion(self):
   
        self.assertEqual (self.seisQuintos,self.uno+self.unQuinto)
   
    def testJSumaDeFraccionYEntero(self):
   
        self.assertEqual (self.seisQuintos,self.unQuinto+self.uno)
   
    #
    # Hacemos lo mismo para la multipliacion
    #
    def testKMultiplicacionDeEnteroPorFraccion(self):
   
        self.assertEqual(self.dosQuintos,self.dos*self.unQuinto)
   
    def testLMultiplicacionDeFraccionPorEntero(self):
   
        self.assertEqual(self.dosQuintos,self.unQuinto*self.dos)
   
    #
    # Hacemos lo mismo para la division
    #
   
    def testMDivisionDeEnteroPorFraccion(self):
   
        self.assertEqual(self.cincoMedios,self.uno/self.dosQuintos)
   
    def testNDivisionDeFraccionPorEntero(self):
   
        self.assertEqual(self.dosVeinticincoavos,self.dosQuintos/self.cinco)
   
    #
    # Ahora si empezamos con problemas de reduccion de fracciones
    #
   
    def testOUnaFraccionPuedeSerIgualAUnEntero(self):
   
        self.assertEquals(self.dos,self.cuatroMedios)
   
    def testPLasFraccionesAparentesSonIguales(self):
   
        self.assertEquals(self.unMedio,self.dosCuartos)
   
    #
    # Las fracciones se reducen utilizando el maximo comun divisor (mcd)
    # Por lo tanto, para a/b, sea c = mcd (a,b) => a/b reducida es:
    # (a/c) / (b/c).
    #
    # Por ejemplo: a/b = 2/4 entonces c = 2. Por lo tanto 2/4 reducida es:
    # (2/2) / (4/2) = 1/2
    #
    # Para obtener el mcd pueden usar el algoritmo de Euclides que es:
    #
    # mcd (a,b) =
    # si b = 0 --> a
    # si b != 0 -->mcd(b, restoDeDividir(a,b))
    #
   
    # Ejemplo:
    # mcd(2,4) ->
    # mcd(4,restoDeDividir(2,4)) ->
    # mcd(4,2) ->
    # mcd(2,restoDeDividir(4,2)) ->
    # mcd(2,0) ->
    # 2
    #
   
    def testQLaSumaDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals (self.uno,self.unMedio+self.unMedio)
   
    def testRLaMultiplicacionDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals(self.dos,self.cuatro*self.unMedio)
   
    def testSLaDivisionDeEnterosPuedeDarFraccion(self):
   
        self.assertEquals(self.unMedio, self.dos/self.cuatro)
   
    def testTLaDivisionDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals(self.uno, self.unMedio/self.unMedio)
   
    def testUNoSePuedeDividirEnteroPorCero(self):
   
        try:
            self.uno/self.cero
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
   
    def testVNoSePuedeDividirFraccionPorCero(self):
   
        try:
            self.unQuinto/self.cero
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
       
    # Este test puede ser redundante dependiendo de la implementacion realizada
   
    def testWNoSePuedeCrearFraccionConDenominadorCero(self):
   
        try:
            self.crearFraccionCon(self.uno,self.cero)
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
   
    def crearFraccionCon(self, numerador, denominador):
   
        return Fraccion(numerador, denominador)
   
    def descripcionDeErrorDeNoSePuedeDividirPorCero(self):
   
        return Numero.DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO

En futuros posts voy a ir factorizando este código para que quede más lindo.

Happy hacking,
Aureliano.

Compilando módulos del kernel

Voy a usar esta entrada del blog para guardar links a cosas que me parezcan relevantes para compilar/cambiar/hacer módulos del kernel de linux:

• http://www.codewhirl.com/2012/04/how-to-compile-a-single-module-in-ubuntu-linux/
• http://www.tldp.org/LDP/lkmpg/2.6/html/index.html
• http://wireless.kernel.org/  
• http://kernelnewbies.org/Documents/Kernel-Docbooks?action=AttachFile&do=get&target=mac80211_2.6.29.pdf

Espero que me sirva y les sirva,
Aureliano.

Instalando python 2.5

Estuve colaborando en impacket y agregué paquetes para parsear EAP y WPS. Como impacket anda a partir de python 2.5, me instalé un python 2.5 en un Linux Mint para ver que no rompí nada. Instalar un python 2.5 con soporte para crypto es difícil. Abajo les dejo las instrucciones:

Bajar tarballs de:

• python 2.5 (link)
• sqlite3 (tarball con autoconf) (link)
• openssl (link)
• libsasl2 (link)
• pycrypto (link)

Una vez que tengan todo eso hay que compilar. Yo decidí hacerlo en un lugar separado ($HOME/p25) para no mezclar las cosas con el resto de mi instalación.

Hay que destarear todo e instalarlo. Para eso, hacé esto (el orden de las instalaciones es importante):

sqlite3:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

openssl:
$ ./config --prefix=$HOME/p25 -shared
$ make
$ make install

libsasl2:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

python:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

pycrypto:
$ PATH=$HOME/p25/bin:$PATH
$ python setup.py build
$ python setup.py install

Y con eso tengo un python 25 en $HOME/p25/bin que puede correr los tests de impacket.

Espero que les sirva,
Aureliano.

Homeopatía, animales y efecto placebo

El viernes pasado, mientras estábamos almorzando en el trabajo, tuvimos una charla re interesante sobre la homeopatía. Yo afirmé que la homeopatía es puro efecto placebo y un compañero de laburo me dijo que eso era mentira porque él trató a su perro con un tratamiento homeopático. Después de eso yo dije que el efecto placebo seguramente también afecta a animales domésticos, pero ese argunmento no fue lo suficientemente fuerte. Después de eso, me dijo que "no todo lo puede explicar la ciencia" (sic).
Si quieren que yo refute algo, decirme algo así es un buen método. Entonces me puse a googlear y estuvo complicado, porque casi todos los papers de veterinaria están atrás de paywalls :(. Pero al final encontré un survey del año 1999 que se llama The placebo effect in animals pubicado en el "Journal of the American Veterinary Medical Association". También encontré este artículo, que cita varios papers (incluyendo al que mencioné antes).
Si los leen, van a ver que hay evidencia que hace pensar que es significativo el efecto placebo en perros. ¿Saben de alguna referencia mejor que apoye o refute la existencia del efecto placebo en animales?

Bouncer aggiornado

Después de mucho tiempo volví a programar un toque en ruby. Por necesidades laborales, tuve que usar de nuevo mi bouncer.rb, pero lamentablemente "rdoc/usage" no está en ruby 1.9. Así que lo adapté para que no lo necesite más. Abajo pongo el código:

#!/usr/bin/env ruby

# == Synopsis
#
# redirect.rb: Redirects TCP connections to distant machines. Handles simultaneously many connections.
#
# == Usage
#
# ruby redirect.rb [OPTION]
#
# -h, --help:
#   Show help
#
# --ip ip, -i ip:
#   Accept connections from ip (default 127.0.0.1)
#
# --port port, -p port:
#   Listen on port (default 12345)
#
# --target ip:port, -t ip:port
#   Connect to ip:port (default 127.0.0.1:23456)
#

require 'getoptlong'
#require 'rdoc/usage'
require 'socket'

class Redirect
 def initialize( source_ip, listening_port, target_ip, target_port )
  @source_ip = source_ip
  @target_ip = target_ip
  @target_port = target_port

  @server_socket = TCPServer.new( "", listening_port )
    @server_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
   
  @descriptors = [ @server_socket ]
  @next_step = {}
 end

 def handle_new_connection
  incoming = @server_socket.accept
  if incoming.peeraddr[3] == @source_ip
   begin
    outgoing = TCPSocket.new( @target_ip, @target_port )
   
    @next_step[ incoming ] = outgoing
    @next_step[ outgoing ] = incoming

    @descriptors += [ incoming, outgoing ]
   rescue
    silent_close( incoming )
   end
  else
   silent_close( incoming )
  end
 end

 def silent_close( sock )
  begin
   sock.close
  rescue
   #do nothing intentionally
  end
 end

  def propagate(sock)
    next_sock = @next_step[sock]
    next_sock.write(sock.read_nonblock(1000 * 1000))
  end

 def finish_connection(sock)
  next_sock = @next_step[sock]
  [ sock, next_sock ].each do
   |s|
   silent_close(s)
   @descriptors.delete(s)
   @next_step.delete(s)
  end
 end

 def run
  loop do
   connections = select( @descriptors )
   connections[0].each do
    |sock|
    if sock == @server_socket then
     handle_new_connection
    else
     begin
      sock.eof? ? finish_connection(sock) : propagate(sock)
     rescue
      finish_connection(sock)
     end
    end
   end
  end
 end
end

if $0 == __FILE__ then

 opts = GetoptLong.new(
   [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
   [ '--ip', '-i', GetoptLong::REQUIRED_ARGUMENT ],
   [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
   [ '--target', '-t', GetoptLong::REQUIRED_ARGUMENT ]
 )

 ip = '127.0.0.1'
 port = '12345'
 target = '127.0.0.1:23456'

 opts.each do
  |opt, arg|
  case opt
  when '--help'
   print """\
Usage:
ruby bouncer.rb [options]

options:
 -i [ip] --ip=[ip]
 -p [port] --port=[port]
 -t [host:port] --target=[host:port]
"""
   exit
  when '--ip'
   ip = arg
  when '--port'
   port = arg
  when '--target'
   target = arg
  end
 end

 port = port.to_i
 target = target.split(":")

 trap("SIGINT") do
   exit
 end

 Redirect.new(ip, port, target[0], target[1].to_i).run
end


Happy hacking,
Aureliano

No entiendo porqué uno anda y el otro no

Quiero ejecutar cscope buscando recursivamente en un directorio los archivos que van a ser indexados, para eso hago:

$ find . -type f -and \( -name "*.c" -or -name "*.h" \) | xargs cscope

y abre el cscope una décima de segundo y se cierra

pero si hago

$ cscope `find . -type f -and \( -name "*.c" -or -name "*.h" \)`

anda bien.

¿Se les ocurre que puede ser?

Debugueando en root con pydev

Update: Cambié el código para que standard output y standard error salgan en la consola del debugger.

Quiero poder debuguear cosas que estoy desarrollando y requieren root. Para eso, me hice un pequeño wrapper que sirve para ejecutar cualquier programa de python y se conecta a un pydevd server. 

#!/usr/bin/env bash
PYDEVD_LOCATION=/home/aure/Aptana_Studio_3/plugins/org.python.pydev_2.7.0.2013032300/pysrc
export PYTHONPATH=$PYDEVD_LOCATION:$PYTHONPATH
echo "Check the pydev debug console for output"
python $PYTHONARGS -c "import pydevd;pydevd.settrace(suspend=False,trace_only_current_thread=False,stdoutToServer=True,stderrToServer=True);import sys;sys.argv=sys.argv[1:];execfile(sys.argv[0])" $@


Para usarlo, copienlo en un archivo ejecutable que esté en el path y cambien PYDEVD_LOCATION para que apunte a dónde tienen pydev (en el script de arriba está como es en mi compu).

A partir de ahora puedo debuguear en root haciendo sudo pydevd my_script_que_corre_como_root.py y lo abre en el debugger de eclipse.

Happy hacking,
Aureliano.

Invalid private key

Poner un certificado nuevo en un ELB debería ser fácil, pero no. Genero un .csr y una clave privada a partir de un .conf usando openssl, lo mando a la autoridad certificante y cuando lo quiero subir a AWS se queja, "Invalid private key".  ¿Qué carajo te pasa AWS?

Lo que pasa es que es hincha bolas. Solo toma claves RSA. Si tu clave privada empieza así:
-----BEGIN PRIVATE KEY-----

Hay que transformarla en una que empiece así:
-----BEGIN RSA PRIVATE KEY-----

Para eso, hay que correr un comandito en openssl:
openssl rsa -in my.private.key -text

La salida está en el formato que necesito :D. Por suerte esto ya lo habían descubierto antes, porque sino hubiera estado mucho más tiempo para encontrarlo.

Happy hacking,
Aureliano.

Cambiando el MTU

Por algún motivo, mi conexión wifi está dropeando paquetes. No creo que sea el aparato, ya que probé con 2 distintos. Ahora voy a probar otra cosa. Lo que voy a hacer es cambiar el MTU (o sea el tamaño máximo de cada paquete) para la conexión wifi para ver si eso lo arregla.

Hacer eso en Windows 7 es re-oscuro. Googleando encontré acá cómo hacerlo. Dejo las instrucciones abajo para que quede claro:

1. Abrí un cmd cómo Administrator (botón derecho en Todos los Programas > Accessorios > Símbolo de Sistema y elegí Ejecutar como administrador) ...
2. Escribí netsh y esperá el prompt
3. Escribí interface y esperá el prompt
4. Escribí ipv4 y esperá el prompt
5. Escribí show interfaces y fijate cuál es la conexión que querés tocar (en mi compu fue Conexión de red inalámbrica)
6. Escribí set subinterface "Aca va el nombre de la conexion que queres cambiar" mtu=1400 store=persistent

Creo que eso arregla el problema.

Happy hacking,

Aureliano.

Línea de comando svn por proxy http

Para salir a través de un proxy usando la línea de comando de svn hay que cambiar la configuración del cliente de svn. Una opción es ir a tocar el archivo ~/.subversion/servers, otra opción es pasarle por línea de comando host y port del proxy así:

svn --config-option servers:global:http-proxy-host=the.proxy.server --config-option servers:global:http-proxy-port=3128  checkout http://some.svn/repo

Happy hacking!

¿Cómo cierro conexiones nesteadas de ssh?

Cuando una conexión de ssh se caga, para poder seguir usando la terminal hay que hacer: ENTER ~. ENTER y la conexión de ssh se corta.

El problema es que no sé como hacer para hacer algo similar para una conexión nesteada.

Desde mi workstation me ssheo al host A y desde el host A al B.

Las conexiones quedan así:

W ----ssh-----> A ------ssh-----> B

Y por algún motivo se caga la conexión entre A y B, todo el quilombo queda así:

W ----ssh-----> A --ssh(cagó)---> B

Para romper la conexión entre A y B hay que hacer: ENTER ~~. ENTER

El ñuflo extra es para escapar el ~ de la primera conexión y que le llegue a la segunda.

Happy hacking!

gnome-terminal y keepass2

Keepass2 en Linux (corriéndolo con mono), pone el password en un clipboard (cuando hacés Ctrl-C)  que gnome-terminal no usa por default (mirando con xset, lo pone en el clipboard "clipboard", pero no en el "secondary"). Por lo tanto, no anda ni CTRL-V ni el menú para hacer paste del password (o el usuario) sacado de keepass2. Este problema lo vi en Linux Mint, pero debería darse en cualquier interacción entre mono y gnome-terminal.

Workarounds:

1. Extrañamente, CTRL-SHIFT-INSERT sí pega las cosas que pusiste en el clipboard con keepass2 (fuente: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=645200).
2. Drag-and-drop de keepass2 a la gnome-terminal correspondiente.

Happy hacking,
Aureliano.

Bug Brother's Design Rules

• War is Peace: assume you are at war, all input is an attack, and then you can be at peace.
• Slavery is Freedom: the more you constrain your code's behavior, the more freedom you have to act. The smaller your interface, the smaller your attack surface.
• Ignorance is Strength: the less your code knows about, the fewer things it can break. This is the principle of least authority.

Fuentes: http://nedbatchelder.com/blog/201302/war_is_peace.html y http://pyvideo.org/video/309/pycon-2010--plenary--saturday-evening-lightning-t

Manejo de passwords

La vida me transformó en un devop por un rato, así que estoy teniendo algunos problemas de sysadmin. Entre ellos, estoy buscando un buen sistema de manejo de passwords. Hay passwords que son sólo míos (muejeje!) y passwords que tenemos que tener varias personas. Por último, estaría bueno tener acceso a esos passwords desde varias compus.

Para tener los passwords en una sola compu, keepass o password safe están bien. Para manejar los passwords que uso por la web, last pass parece estar bueno, pero ¿puedo tener passwords que uso en la línea de comando? (ejemplo, claves para desencriptar archivos .pem).

¿Pero, cómo hago para compartir algunos de estos passwords con otras personas? La solución que se nos ocurrió en el laburo es meter el archivo de keepass en el control de versiones (svn). Los problemas de esto es que si por algún motivo hay un conflicto, la resolución es un quilombo y que tener derecho más granulares sobre los passwords no parece algo fácil (¿diferentes archivos de keepass, con diferentes passwords, en función del dominio de seguridad?).

¿Alguien probó last pass premium? (que permite compartir passwords)

¿Alguna otra sugerencia?

Happy hacking,
Aureliano.