One liners( 11 ): "desescapando" caracteres html tipo {

dst = re.sub(r'&#([0-9]+);', lambda x:unichr(int(x.group(1))), src)

  • re.sub() hace sustituciones guiada por una expresión regular.
  • r'&#([0-9]+);' es una expresión regular que captura lo que buscamos y expone lo que nos interesa, el número
  • lambda x:unichr(int(x.group(1))) es la función (anónima en este caso) que decide por que se reemplaza, por el caracter UTF con el código en cuestión.
  • src la cadena original

ps: corregido para evitar capturar &#;

Navegar por TOR y I2P con Firefox de forma transparente

Veamos como navegar por los Eepsites de I2P y los servicios_ocultos de TOR ( dos redes descentralizadas y anónimas ) como si fueran sitios normales con Firefox, para esto usaremos el plugin FoxyProxy.

Nota: este proceso está probado en la distro Trisquel GNU/Linux ( derivada de Ubuntu, y esta de Debian ), pero excepto el proceso de instalación ( que por otra parte es la mayoría :P ) que es el habitual para cualquier programa, lo demás se hace igual.

TOR

Comencemos instalando TOR, en la página_del_proyecto hay una_lista_de repositorios_de_TOR_para_la_mayoría_de_las_distros, sería recomendable instalarlo desde este repositorio para asegurarnos de tener la última versión disponible, pero en todo caso varias distros proveen el software en sus propios repositorios, así que usar los "oficiales" es opcional.

Traducción automática de programas

Esto lleva un rato parado, pero ya toca presentar una prueba recién terminado, la idea básica es muy sencilla: un programa ( o gran parte de el ) es relativamente sencillo de traducir, dado que muchas cadenas se repiten y como 'Help' y 'Download', la mayoría de las cosas no tienen un contexto o necesitan considerarlo.

Así, el proyecto es simple, una página web a la que se le envía un archivo de traducción ( por ahora solo soporta .po y .mo ), y devuelve el archivo formateado como .po, y con las cadenas que pudo traducir añadidas, además se da la opción de contribuir con traducciones ( desde archivos ya traducidos ), ya sea desde el mismo formulario o de una API.

[Haskell] cantidad de entropía en un archivo

Estos días un usuario ha estado posteando código haskell en HackXCrack, lo que renovó el poco interés que tenía en dicho lenguaje ( muy recomendable Learn_You_a_Haskell_for_Greater_Good! para empezar, btw ), así que aquí está un ejemplo, muestra la cantidad de entropía en un archivo, de 0 a 8 [ entropy.hs ] . El plugin para mostrar código no tira de haskell, así que está coloreado con pyments dentro del post... ===============================================================================

!/usr/bin/runhaskell

-- Written by kenkeiras under the WTFPLv2

-- Para getArgs() import System.Environment

-- Para ord() import Data.Char

-- Cuenta las ocurrencias de cada tipo de caracteres countChars s = [ sum[ if ord(c) == code then 1 else 0|c<-s] | code <- [0 .. 255]]

-- Calcula la entropía a través del número de ocurrencias y el número total entropy arr l = sum[ if n /= 0 then (n / l) * logBase 2 (l / n) else 0 | n <- arr ]

showEntropy fname = do     f <- readFile fname -- Lee el contenido del archivo

Sets de Julia y Mandelbrot con Python

Creo que cualquiera que programe algo en cualquier momento de su vida acabará por preguntarse como podría generar ese carnaval de colores que son los fractales, y es posible que acabe por desistir bajo el pensamiento de que es complicado.

Bien, sin llegar a tocar la teoría, el algoritmo para determinar el número:
1. Tomamos C como el punto ( un número complejo, dos valores ).
2. Z = C
3. Mientras no se haya completado el límite de iteraciones:
4. Si Z.real2 + Z.imag ** 2 >= 4:
5. Devolvemos el número de iteraciones [ FIN ]
6. Sinó, Z = Z
2 + C [ volvemos a 3 ]
7. Si se acabaron las iteraciones, el punto no tiende a infinito.

Así de sencillo, para el set de Julia lo mismo, pero Z es el punto, y C una constante para todo el set que se renderiza.

Ahora en Freenet !

Este blog ya se puede leer desde Freenet añadiendo esto después de la dirección del FProxy ( normalmente http://127.0.0.1:8888 ):
USK@69aFOJiagwUh2c3s2a2V6qvdLSIspAmvDwwyyqSz3Pg,eyH2DiCXsHjp
5PdP9meBoVDMAUiSqTD1jYA-TozTDTc,AQACAAE/codigoparallevar/1

Y aunque parece que me cargé los CSS y los dos últimos posts aún no están subidos ( este y el anterior ), porque ni siquiera estaban previstos antes de empezar la subida, funciona.

Como preparar y como saltarse un antidebuggers sencillo en Gnu/Linux

No se como llegó este tema aquí, pero la propuesta es esa, veremos:

  • Como hacer ingeniería inversa a un programa que nos pide una contraseña ( muy rápidamente ).
  • Como añadir un anti-debugger sencillo a ese programa para evitar que se recupere la contraseña.
  • Como eliminar nuestra propia protección.

Veamos, entonces el programa, nos enfrentamos a esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char **argv){
    if(argc != 2){
        printf("%s <contraseña>\n", argv[0]);
        exit(0);
    }

    char passwd[12];
    int i;

    memset(passwd, '\0', 12);
    for( i = 0; i < 11; i++ ){
        passwd[i] = i<5?i*2+0x30:i<10?i*2+0x41:i+0x61;
    }

    printf("%s\n",strcmp(argv[1],passwd)?"Error :/":"OK");
}

Así que lo compilamos e intentaremos extraer la contraseña:

1
gcc example.c -o example

Cálculos con Python

Mientras no saco tiempo para algo más elaborado, cálculos de raíces e interpolación con Python! * Cálculo de raíces con el método_de_Newton-Raphson: *

def newton( indice, funcion_der, funcion, x ):

for i in xrange(indice):

 x -= funcion( x ) / float(funcion_der( x ))

return x

El primer parámetro es el número de iteraciones a realizar, el segundo indica la función derivada, después la función, y por último el punto de partida. Por ejemplo: it = 5

print "Raíces [ %s iteraciones]" % it

print "Función: Raíz estimada Valor real"

Newton-Raphson para x

n = newton( it, lambda x: 1, lambda x: x, 10 )

print "x : %s %s" % (n, n)

Newton-Raphson para x + 1

n = newton( it, lambda x: 1, lambda x: x+1, 10 )

print "x + 1 : %s %s" % (n, n+1)

Newton-Raphson para 2x

n = newton( it, lambda x: 2, lambda x: 2*x, 10 )

print "2x : %s %s" % (n, 2n)

Newton-Raphson para x**2

n = newton( it, lambda x: 2x, lambda x: x*2, 10 )

print "x2 : %s %s" % (n, n2)

Salida: Raíces [ 5 iteraciones]

Función: Raíz estimada Valor real

x : 0.0 0.0

One liners( 10 ): limpiando metadatos

Para limpiar los metadatos de una imágen ( habiendo importado la clase Image de PIL ): Image.open( entrada ).save( salida )

O, como un script independiente:

!/usr/bin/env python

from PIL import Image

from sys import argv

if len(argv)!=3: print "%s " % argv[0]

else:Image.open(argv[1]).save(argv[2])

Saludos

Newer posts Older posts