• Llegar a las manos: Darse leches está mal visto. Meterse mano también.
• Jugárselo a piedra, papel o tijera: si es el otro es japonés estás perdido, vas a perder sí o sí, ellos nacieron con un don para ello. Si no es japonés nada te asegura que vayas a ganar, así que nada, mala opción.
• Jugárselo al tres-en-raya. Esta es la buena.

El tres en raya es un juego sencillo, cuando la gente se pone a jugar se cree que es un juego tonto (que lo es!) y que más o menos, sin considerar empates, el 50% de las partidas las ganarán y el resto las perderán pero no es tan tan sencillo. Así que le sueltas: “Pues ya está! Nos lo jugamos al tres en raya. El primero en ganar será el que tenga la razón, ¿es justo no?” Suelen aceptar.

Vamos a asumir que el juego es empezando con un tablero vacío, que empiezas donde quieras y que cuando ya has puesto las piezas posibles y no ha ganado nadie comienza una partida nueva desde cero.

También vamos a asumir que tú no estás en la parra y que sólo vas a perder si te provocan una situación en la que el contrincante te puede hacer tres en raya de dos maneras simultáneas y no es que se te ha escapado la línea ¬¬. Tú eres cruz, tu víctima será cara.

Cómo no perder

Se supone que el que empieza lleva la voz cantante. Tu contrincante puede empezar en el centro, en una esquina o en un lado. Lo decisivo son las 2 primeras posiciones.

Si él empieza en el centro, ve siempre a la esquina. En caso de que luego su ficha se ponga en línea tu ve de nuevo a una esquina.

Si empieza en una esquina nosotros cogemos el centro.  En caso de que él vuelva a colocar su ficha en línea entonces nosotros nos vamos a una posición que no sea esquina.

Si empieza en un lado cogemos el centro de nuevo. En caso de que él coga un lado contiguo debemos colocar nuestra ficha en la esquina común.

Ahora ya lo tenemos neutralizado.

Cómo intentar ganar

Intentar ganar viene a ser lo mismo pero al revés, con alguna variación más porque él no tiene por qué hacer de su primer movimiento los que yo he hecho antes.  Sólo tienes que esperar a que lleve 3 o 4 partidas y que ponga donde no toca en su segundo movimiento.

Aplicado al primer caso, si empiezas en el centro y él no pone en una esquina está muerto, en el caso de que lo haga tu colocas tu ficha haciendo línea. Ahora si él no se posiciona en una de las dos esquina restantes habrá perdido también.

Si tu contrincante se sabe esto, simplemente jugar será un while(true) hasta que uno de los dos se harte, y entonces, por supuesto, tiene razón el otro

P.S. Aprovecho este post para anunciar que TuXeD se ha comprado un dominio nuevo y pasa de /var/log/TuXeD a Limited Entropy Dot Com. ¡Ya estás actualizando tus feeds y bookmarks!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Cuestión de optimización
• [Campus Party 08] Diario de a bordo – Parte 1
• ¡Feliz no-cumpleaños!

Cómo se puede leer ya en muchos sitios, este año se celebra un nuevo congreso de seguridad informática en España. Su web es http://www.rootedcon.es y como ellos mismos dicen su objetivo es ofrecer conferencias altamente técnicas y fomentar el conocimiento, no bastante con conocer que existen cosas, hay que saber cómo son y por qué funcionan así

Se va a organizar un wargame tipo Capture The Flag a manos de un Sexy Panda, ¿qué más se puede tener? Además hay una serie de talleres intensivos denominados RootedLabs donde podrás aprender con los mejores sobre: ingeniería inversa, análisis forense, análisis de malware, pentesting, securización de redes inalámbricas y seguridad web (aún quedan plazas libres en los labs si te interesa algún área).

Allá por noviembre me enteré de la existencia el congreso y desde un principio me interesó acudir, pero ¿por qué no algo más? Hablando con TuXeD nos planteamos la posibilidad de enviar algo al Call For Papers, estuvimos unas cuantas semanas dudando pero tiró para adelante…

Unas semanas después (contra todo pronóstico, por lo menos mío) resulta que nos han seleccionado la propuesta, además junto con los primeros ponentes confirmados, cosa que considero un honor más aún. Ya de por sí, ser el último mono iba a ser considerado un éxito 100% por nuestra parte.

Para que os hagáis una idea del personal, esto es lo que hay confirmado por ahora:
http://www.rootedcon.es/rooted-con-2010/ponentes.html

– David Barroso, de S21Sec
- Joxean Koret, de 48bits & Panda Security
- Alfonso Muñoz Muñoz, de la EUI-UPM y colaborador cátedra Applus-UPM.
- Alejandro Ramos “dab”, de SecurityByDefault.
- Antonio Ramos, de S21Sec.
- David Reguera, de Hispasec Sistemas.
- Rubén Santamarta, de ReverseMode & 48bits.
- Chema Alonso, de Informática64

Y TuXeD y yo! No puedo ocultar que estoy emocionado me lo voy a pasar de lo lindo seguro.

Poco a poco se tienen que ir confirmando más ponentes y saldrán los detalles de la conferencias. Esto promete.

Si queréis acudir al evento daos prisa porque debido a la gran acogida pronto colgarán el cartel de todo vendido. Me alegro de que haya surgido una nueva iniciativa así y más aún con precios populares y apostando por gente muy capaz que hay por nuestro país.

Por la mocosfera mucha gente ya se ha hecho eco del evento:
http://www.securitybydefault.com/search/label/rootedcon

Y aquí entrevistas a gente que lo organiza o va a estar danzando por ahí:
http://elladodelmal.blogspot.com/search/label/Entrevistas

Can’t wait!

ACTUALIZACIÓN: Ya empiezan a salir más nombres de ponentes y títulos de las conferencias. Toda la información aquí

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• 25C3: Nothing to Hide
• Cuando no se tiene cuidado con la criptografía…
• [Campus Party 09] Planning

He cogido el script para generar los tonos del otro post y lo he cambiado para los pitidos duren 40ms (que se resume a cambiar que use 320 muestras en lugar de 1200 para cada pitido o silencio), para que sea un poco más real. El wav que voy a usar será el siguiente: ring.wav

Empezamos, ¿qué necesitamos? Cada pitido estará compuesto por una pareja de tonos así que para saber qué número es deberemos reconocer las dos frecuencias principales que tienen los pitidos, y conocer la frecuencia viene a ser lo mismo que saber el periodo.

Hace un tiempo hice una práctica de Tratamiento Digital de la Señal en la que se hacían cosas de estas, uno de los códigos no es mío, está indicado. El resto los hicimos Rafa y yo en su día.

Aprovechándonos de la Transformada de Fourier:

function [P,f]=periodograma(x,N)
% [P f]=periodograma(x,N)
% Calcula N muestras del periodograma de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
k=0:N-1;
f=k./N;
 
L=length(x);
P=1/L*(fft(x,N)).^2;

Pero lo propio será usar un programa que use ventanas para su propósito:

function [P,f]=periodmodif(x,ventana,N)
% [P ,f]=periodmodif(x,ventana,N)
%
% Calcula N muestras del periodograma modificado de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
if N <= length(x)
   error('N debe ser > que length(x)');
else
   k=0:N-1;
   f=k./N;
 
   L=length(x);
   m=0:L-1;
 
   U=1/L*(sum(ventana(m+1).^2));
   P=1/(L*U)*abs(fft(x.*ventana,N)).^2;
end

Cargamos el fichero ring.wav

>> [x,fs,nbits]= wavread('ring.wav')
>> t=0:1/fs:1/fs*(length(x)-1);
>> plot(x)

Ahora tendremos que calcular de cuanto es nuestra ventana mínima. La separación mínima entre tonos es de 320 muestras (que además en este caso es la misma entre todos los tonos) luego la frecuencia digital será 320 / fs = 320/8000 = 0.04

Y aquí un poco de teoría sobre ventanas gracias a los Apuntes de Pak:

Pero no voy a aburriros con ella así que nos quedaremos en que vamos a usar una ventana tipo Hamming, luego necesitaremos una longitud de ventana L = 4 / resolución = 4 / 0.04 = 100 muestras

Ahora vamos a determinar los dígitos, y para ello vamos a hacer uso de la siguiente función para búscar máximos:

function p=buscapicosu(x,umbral)
%posi_picos=buscapicosu(x,umbral)
% Busca los máximos locales de un vector mayores que un cierto umbral
% umbral se expresa en % respecto al valor máximo del vector.
% Ej. buscapicos(x,60) buscaria los picos mayores o iguales al 60% del
% pico más alto
%
% posi_picos son los indices del vector de entrada correspondientes a los picos.
 
% (C) Antonio Albiol , 2003
 
%Primero descarto los valores menores que el umbral
 
umbral=max(x(:))*umbral/100;
 
x=x.*(x>umbral);
 
%Ahora buscaré los máximos
 
%Primero creo un vector con dos valores muy pequeños en los extremos
xe=[-inf;x(:);-inf];
 
%Ahora calculo la derivada
d1=diff(xe);
ld1=length(d1);
%Ahora busco valores de la derivada de signo diferente consecutivos y que sean máximos
p=find(sign(d1(2:ld1)).*sign(d1(1:(ld1-1)))<0 & sign(d1(1:ld1-1))>0);

Cada pitido y cada silencio dura 320 muestras luego calculamos periodos en esas zonas. Vamos a por el primer dígito, con ventana Hamming de 100 y usando 1024 puntos:

>> [P,f]=periodmodif(x(320:320+99),hamming(100),1024);
>> buscapicosu(abs(P),50)
 
ans =
 
   110
   190
   836
   916

En el espectro digital, de 0 a 1, veremos que las frecuencias se repiten en espejo a partir de 0.5. Luego la frecuencia 110 se corresponde con la 916, igualmente ocurre entre la de 190 y 836, son lo mismo. Así que sólo tenemos que ver a qué corresponden 110 y 190.

Nota a tener en cuenta: en las FFTs (Fast Fourier Transforms) el cálculo se hace mucho más rapido cuando N es una potencia de 2, por eso la elección de hacerlo en 1024 puntos no ha sido del todo al azar.

>> 110/1024*fs
 
ans =
 
  859.3750
 
>> 190/1024*fs
 
ans =
 
  1.4844e+003

Nos vamos a la tablita y vemos con qué 2 valores más cercanos concuerdan 859.375 y 1484.4 Hz. Claramente sería con 852 y 1477 Hz que juntos corresponden con el dígito 9.

Y así con cada uno de los dígitos

Sé que estaría mucho mejor un script que hiciera todo el proceso entero y obtuviera qué número es de la tabla pero últimamente necesito días de 30 horas así os tendréis que conformar con esto. ¿A qué número he llamado?

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Llamando por teléfono con Matlab
• [Fprint] Procesado de la imagen – Huellas dactilares
• Cuestión de optimización

El pasado jueves acudí a la Masterclass de Carl Verheyen que se había organizado en Valencia y no defraudó, es más, no es que no defraudara si no que me impresionó mucho.

Calificado por varios medios como uno de los 10 mejores guitarristas del mundo y el mejor guitarrista de estudio que hay, ha grabado para varios cientos de discos, 200 bandas sonoras (incluyendo producciones recientes de Disney y Pixar por ejemplo), miles de jingles para televisión y radio, … vamos, que la lista es larga. Un señor del calibre de Dann Huff, Steve Lukhater y similares pero que, por su papel, suelen permanecer en un segundo plano comparados con el grupo de guitarristas a los que se les consideran estrellas.

La masterclass comenzó con su impresionante versión de Little Wing de Jimi Hendrix. Hay versiones geniales como la de Stevie Ray Vaughan o la de Andy Timmons pero fue verle tocar y dejar a todas las versiones que había oído hasta ahora totalmente por los suelos.

El enfoque fue dar un repaso a como ha ido viendo y aprendiendo las cosas desde que empezó a tocar, sus influencias, lo que él considera importante, etc, todo acompañado de ejemplos y pasajes.

Era alucinante el dominio de todos los estilos y cómo era capaz de sonar como quien quisiera. De todas las personas que le han influenciado fue desglosando con qué se había quedado él y que le parecía que ese guitarrista había aportado o supuesto a la música. Pasó por blues crudo de Albert King, el uso de pentatónicas mayores y menores de B.B. King, el vibrato de Eric Clapton, diferentes estilos de jazz, Wes Montgomery, las Walking Bass Lines de Joe Pass y muchos más, también como Jimi Hendrix supuso el nexo de unión entre toda esa música anterior y lo que vendría después en los 70 y 80 (cosa que él mismo dijo que no concebió hasta mucho después de que Hendrix muriera), estilos country, funky, rock y así hasta tiempo más actuales.

Prácticamente el 100% de sus influencias son americanas, por no decir el 100% pero mostró su interés por músicas europeas y orientales, como el flamenco, música india, pakistaní y otras.

Llegó un punto en su vida que comentó que dejó de centrarse en estilos, le gustaban tantas cosas distintas que decidió aprender todo lo que escuchara y le gustara independientemente de quien fuera o que estilo tuviera… y por lo visto lo ha hecho xDDD Se lo sabe todo, parecía que lo único en que no tenía interés era en técnicas de tapping a dos manos y poco más, cosas al estilo pajillero no han calado en él.

Comentó como durante décadas su planteamiento era 80% músico de sesión y 20% artista en solitario pero que ha ido evolucionando y posiblemente ahora sea justo al revés. Para ser un buen músico de sesión destacó la importancia de:

• conocer no, dominar muchos estilos
• saber leer música al vuelo
• un base rítmica muy sólida, aspecto mucho más importante que la faceta solista
• la puntualidad, el tiempo es oro en el estudio y generalmente hay una oportunidad

También hubo cabida para conceptos armónicos, improvisación, líneas melódicas, etc, todo explicado con la claridad pasmosa e igualmente cosas más de técnicas como chickenpicking para el country, como ajusta sus stratos para que no se desafinen con el uso del trémolo o jugar con los armónicos.

Suele usar stratos pero comentó que su arsenal estaba sobre las 70 guitarras, 50 amplificadores y 200 pedales. Para esta ocasión tocaba con un cabezal+pantalla Engl Powerball en el canal limpio que no era de su propiedad y poco más, de hecho quiso activar el bypass del bucle de efectos donde me parece que había un TC Electronics G Major (creo) y alguna cosa más.

Hubo turnos para preguntas donde la gente se animó bastante a participar y si hubiera sido por él la masterclass hubiera durado más y más.

La anécdota de la noche fue una historia sobre Chet Atkins. Se acaba de casar con su actual mujer y vivían en una casa de 2 habitaciones, la de dormir y “la del músico” xD donde estudiaba y practicaba y donde se tenían que cocer las habas para cambiar y dominar el mundo. Una día se levantó por la mañana y su puso a ensayar, … canciones de Chet Atkins, una de esas piezas típicas que pueden parecer chorras, o de canciones de niños (pero de eso nada) al levantarse su mujer y escucharle:

mujer: ¿¿pero qué estás tocando? O_o ¡¡eso es lo que tararea mi padre!! eso es perder el tiempo, ¿no se supone que esto era el cuarto donde “El Músico” tenía que crecer e inspirarse? ¿estudiar complicados pasajes del jazz más enrevesado?

Carl: cariño, pero esto… esto es importante, es Chet!! Tengo que dominarlo!

mujer: Pamplinas! Eso es perder el tiempo y tocar tonterías.

En este momento la mujer se va de casa refunfuñando y Carl continúa practicando esas melodías durante 3 horas cuando recibe una llamada.

teléfono: ¿oiga? Carl Verheyen, buscamos un músico de sesión para mañana a primera hora, ¿sabe grabar al estilo Chet Atkins? Son para 2 cuñas de 30 y 60 segundos para una cadena de supermercados.

Carl: Sí, por supuesto, allí estaré.

Al día siguiente Carl acudió al estudio, le propusieron una tonadilla en la tonalidad de C, que el transportó a E, la cambió bastante, hizo el arreglo y grabó ambas cuñas en cosa de 45 minutos (nos tocó el extracto). Por una hora de estudio pagaban según convenio $80 pero como era el único música era el principal luego percibió el doble, $160. No está mal por 45 minutos de trabajo. El se fue feliz a casa, día productivo.

El asunto es que ese jingle fue el usado en todos los supermercados de una cadena repartida por todo USA y por tema de royalties cada vez que se reproducía tenían que pagarle, es más, cada vez que la cambiarán también, con el detalle importante de que era la melodía para decir las ofertas del día, luego la cambiaban todos los días en todos los supermercados. “Hoy, en nuestro apartado de frutas tenemos, oferta manzanas a tanto”. Esto le supuso un sobresueldo de aproximadamente $1000 durante 4 años y medio (tengamos en cuenta que hace muchos años eso era mucho más dinero que hoy) y todo por 45 minutos de trabajo gracias a hacer el melón tocándo cancioncitas “chorras” al estilo Chet Atkins. Con eso se pagó la casa, entre otras cosas

Muchas gracias a la gente de Academia Musical Europa, que llevaban cámara y me han pasado las fotos (aunque yo ahora soy de L’espai Musical jeje )

Lo dicho, guitarrista 100% recomendable, me dijo que volvería a Valencia en marzo con su banda, así que no os lo perdáis!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Coldplay VS Joe Satriani
• The Night’s Soul
• Concierto Andy Timmons

Port-Knocking

Cuando nosotros tenemos un servicio en un servidor, éste, escucha en uno o varios puertos las peticiones externas. Este puerto deberá estar abierto en el firewall para que se puedan efectuar estas conexiones. La idea del Port Knocking es que el puerto del servicio permanece cerrado y sólo se abrirá bajo una petición externa basada en un paquete o grupo de paquetes específicos, previamente conocidos por el cliente, que serán enviados al servidor. Es decir, yo tendría mi servidor ssh con el puerto 22 cerrado y cuando un cliente envíe un paquete con ciertas características a otro puerto entonces el puerto 22 se abriría temporalmente para ese cliente. De este modo permanecería escondido antes escaneos de puertos e intentos automatizados de fuerza bruta, por ejemplo. Este sistema se podría ir mejorando:

• que tenga que ser una secuencia de puertos y no uno sólo
• que además tengan que ser unos puertos de origen específicos
• combinarlo con otras herramientas: Portsentry, denyhost, fail2ban (destaco la primera herramienta  ya que es una forma fácil de banear intentos de escaneos sin el uso de un IDS completo ni cortafuegos)
• jugar con las FLAGs TCP y opciones poco comunes de los paquetes
• abrir el puerto sólo para la IP llamante, no todas
• <paranoic>requerir una temporización determinada (algo elástica, claro está) entre en el envío de los paquetes</paranoic>
• y mil cosas que se nos puedan ocurrir

Para estos menesteres existen varias herramientas pero todo suelen terminar siendo scripts que escuchan los puertos y van cambiando reglas del cortafuegos y los servicios. Pero no todo es bonito e ideal, imaginad que no tienes una puerta trasera, ¿qué ocurre si cae el servicio encargado de escuchar el portknocking? Te quedas tú sin poder acceder. Deberías dejarte una IP blanca por ejemplo, que siempre tuviera acceso al puerto sin mayor barrera. O tener otro servicio que compruebe si el primer servicio está online y haga de watchdog xD.

Pero ¿cuál es la debilidad clave un sistema así? Replay Attack. Me explico, si mi máquina está en una subred y otra máquina de esa subred ha sido comprometida, ésta podría estar usando un sniffer (tcpdump, wireshark) y capturar la secuencia usada para la apertura de puertos. Y aquí es donde entra lo que he venido a contar.

Crypt-Port-Knocking

Vamos a cortar por lo sano esa debilidad: Single Packet Authentication. Esta manera de proceder difiere en que vamos a llamar a un puerto aleatorio cada vez y la conexión con el servicio también se hará en un puerto aleatorio cada vez pero lo que es más importante añadiremos información cifrada en el paquete gracias a OpenSSL con lo que se quiera hacer (en este caso usando 256-bit AES-cbc, se podría mejorar para ultraparanoicos™  usando un cifrado asimétrico con GPG, por ejemplo). Podríamos pensar que para evitar ataques replay en la información cifrada se podría incluir datos variantes en el tiempo, cambios preacordados de la clave de cifrado, usar iteraciones en una función de hashing pero se complica el tema cuando hay muchos usuarios. Para ello, es mejor opción aprovechar que podemos tener 16bytes de datos aleatorios en el paquete que luego podemos identificar gracias a un hash del mismo e ignorar todos los paquetes duplicados. Para crear los paquetes a medida podremos usar hping.

Para hacer uso de las características del Single Packet Authentication el autor del post, BoneKracker, ha creado una serie de scripts en bash, formados por un cliente y un servidor de una forma bastante clara y transparente. Echadle un vistazo que ahí está todo el código y con una explicación más extensa.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Dejar bonito un server SSH – Parte 1
• [Campus Party 08] Taller de antenas y charla sobre servidores
• Dejar bonito un server SSH – Parte 2

Para quien no lo conozca, las Arduino son una plataforma de desarrollo electrónico enfocada al prototipado rápido cuyas especificaciones son totalmente libres. Existen varios modelos de placas para los diseños con características más o menos avanzadas y podremos trabajar con ellas tanto en Windows, Mac OS X ó GNU/Linux, sin tener que usar compiladores y/o herramientas de desarrollo de pago.

La mía es una Arduino MEGA, que es una mejora de la Duemilanove y la Diecimila gracias a su mayor I/O y capacidad de memoria, entre otras cosas. Las specs principales son:

• Microcontrolador Atmel AVR 8-bit MEGA1280 @16MHz
• 128kB FLASH MEM (4kB usados por el bootloader incluído, usado para poder cargar cógido directamente)
• 8kB SRAM
• 4kB EEPROM
• 54 pines digitales (soportan hasta 40mA): I/O, comunicación serie, interrupciones, 8-bit PWM, SPI, I2C, …
• 16 pines de entrada analógica con una resolución de 10bits, útil para todo tipo de sensores.

Lo primero que tenemos que hacer para empezar a jugar es instalar las herramientas necesarias. En el árbol de paquete de Gentoo hay bastante para microcontroladores AVR ($ eix -S avr ) pero si además queremos afinar e ir a por el kit completo para Arduino tampoco tendremos problemas.

Necesitaremos una versión de Java (yo uso sun-jdk-1.6) además de los siguiente paquetes:

# emerge crossdev jikes uisp rxtx

Yo, de antes, ya tenía instalado avra (AVR Assembler) y avrdude (para subir y bajar código a las microcontroladoras) que había usado para trastear con las AVR Tiny2313, ATmega32 y ATmega64 aunque en realidad casi siempre usé el IDE que te proporciona ATMEL de forma gratuita para Windows y alguna vez Bascom-AVR.

Una vez tengamos los paquetes básicos instalados necesitamos generar el toolchain con el que vamos a trabajar para generar código compatible con la arquitectura AVR. Para ello nos ayudaremos de la herramienta crossdev:

# crossdev -t avr -s4 --without-headers

Tardará un ratillo pero una vez termine ya dispondremos de nuestro flamante compilador avr-gcc. Ahora nos bajamos el IDE que nos proporciona Arduino en http://www.arduino.cc/en/Main/Software, lo descomprimimos y lo dejamos por ahora ahí. Dependiendo de versiones puede que algunos tengan que hacer un enlace (por supuesto respetando paths y versiones de tu sistema):

$ ln -s /usr/lib/binutils/avr/2.19.1/ldscripts/ ~/programs/arduino-0017/ldscripts

Dependiendo de distribuciones o la configuración será necesario estar en los grupos tty y uucp, pero para ahorrarte problemas añade el usuario a esos grupos.

Mmmm ¿qué mas necesitamos? Arduino se conecta por USB a nuestro ordenador y el kernel de linux nos proporciona el driver, yo ya lo tenía instalado pero si no:

Device Drivers -> USB support -> USB Serial Converter support -> USB FTDI Single Port Serial Driver (EXPERIMENTAL)

Lo ponemos como módulo, compilamos y lo cargamos:

# make modules_install
# modprobe ftdi_sio

Conectamos la Arduino y podremos ver si todo funciona:

# dmesg
usb 4-2: new full speed USB device using uhci_hcd and address 5
usb 4-2: configuration #1 chosen from 1 choice
ftdi_sio 4-2:1.0: FTDI USB Serial Device converter detected
usb 4-2: Detected FT232RL
usb 4-2: FTDI USB Serial Device converter now attached to ttyUSB0

OK!

Volvemos al IDE que ya tenemos descomprimido y lo ejectuamos

$ ./arduino
Experimental:  JNI_OnLoad called.
Stable Library
=========================================
Native lib Version = RXTX-2.1-7
Java lib Version   = RXTX-2.1-7

Ahora sólo nos faltará elegir en la configuración que queremos el /dev/ttyUSB0 y que estamos usando una placa Arduino MEGA, et voilà!

Para probar el funcionamiento haremos un “Hello Word” al estilo electrónica, es decir, hacer parpadear un LED

Hay ejemplos por ahí pero el código sería:

const int ledPin =  13;    // LED connected to digital pin 13
 
void setup()
{
	pinMode(ledPin, OUTPUT); // set pin 13 as output
}
 
void loop()
{
	digitalWrite(ledPin, HIGH);   // set the LED on
	delay(1000);                  // wait for a second
	digitalWrite(ledPin, LOW);    // set the LED off
	delay(1000);                  // wait for a second
}

A ver si busco ratos y hago algo interesante con mi nuevo juguete, ya no hay excusa. Si quieres saber por donde empezar acude a http://arduino.cc

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [Fprint] La implemetación del driver
• El kernel de linux en profundidad
• Port-Knocking y Crypt-Port-Knocking

Jaime tenía sus charlas de PHP a las 10 y eso es primerísima hora en la campus, que digo! es una hora inaceptable en la campus! Intentamos llegar a tiempo para poder apoyarle pero durmiendo fuera y acostándonos tarde (más bien cerca del amanecer) era complicado estar antes de las 11. Además se nos juntaba con el suplicio de aparcar y llegar andando desde donde cristo perdió la cruz, al año que viene nos cogemos parking. Este año estuvo a buen precio (no como años anteriores) pero se nos pasó el momento o no nos lo planteamos lo suficiente. El catering a mí me pareció peor que otros años, era otra empresa y encima la CP no dió paella para todos gratis el miércoles como venía siendo tradición… ratas.

A diferencia de otros años, que ya el domingo disponíamos de las acreditaciones y incluso alguna vez teníamos la tienda puesta de antes, esta vez llegábamos de viaje por la tarde y no fue hasta la noche cuando estuvimos acomodados en el puesto. Así cerquita estábamos kuasar, Jaime, Mageles, TuXeD (a partir del jueves), phobeo, Ernesto (encantado de conocerte!), Laura, Ender, akae y unos cuantos más, justo en el medio de la zona de innovación. Repartidos por el resto de la campus estaban muchos más conocidos pero no terminaría nombrándolos, bueno va, a Flexa sí, que se hizo una camiseta super molona con TOOOOODOS nuestros nicks . Sigue leyendo!

Hoy no os traigo un diario detallado, no hay ganas de escribir tanto y además seguro que aburriría, que con el viaje por el Bosnia y Croacia os dejé un misal, por lo menos! El año pasado sí fue un poco más extenso: Campus Party 08 Parte 1 y Campus Party 08 Parte 2

TuXeD dió su charla sobre Smartcards y Side Channel el jueves por la mañana y yo la mía el sábado sobre Sistemas de Detección de Intrusos. Hubo cosas interesantes, hasta vino Jose de Castro a tocar! Este año han subido a youtube bastantes videos con talleres y ponencias.

Un año más hubo concurso de seguridad, esta vez organizado por SecurityByDefault, a los cuales fue un placer conocer en persona. El año pasado participamos TuXeD, Amine y yo juntos y lo ganamos así que este año nos pusimos manos a la obra de nuevo. TuXeD no pudo mirarse nada hasta bien entrado el jueves y el pobre Amín trabajaba en el restaurante de sus padres  (el cual recomiendo) todos los días full-time así que no tenía más remedio conectarse desde el ordenador del restaurante por vnc a su casa y mirarse las cosillas entre que servía un plato y otro xDDD En fin, menudo plan, aún así el equipo funcionó a la perfección y nos pudimos hacer de nuevo con el primer puesto después de mucho empeño Enhorabuena chicos!

El concurso estaba divido en 4 categorías: redes, web, binarios y cripto, para cubrir pruebas de todo tipo. El concurso me gustó mucho, con más nivel que otros años pero… siempre hay un pero jeje, había demasiado fuerza bruta/suerte. Si acertabas a la primera pan comido si no… 2 días perdidos, fue el “fallo/feature” más criticado por los participantes.

Hubo pruebas de todo tipo, algunas muy originales. Por ejemplo, en redes había obtener que orden de nmap había sido ejecutada viendo una captura o crackear la sharedKey del handshake en una autenticación RADIUS, esta prueba me gustó mucho ya que no existía/teníamos herramienta para hacerlo así que hubo que tirar del RFC y programarse un crackeador (en C). En cripto hubo que crackear un certificado pkcs12 y unos mensajes de twitter en cifrados RC4, en binarios en una había que modificar el comportamiento del programa gracias a un LD_PRELOAD y en otra era un buffer overflow en el cual había que volver a los inicios con el señor Aleph One. En una de las pruebas de web una herramienta de Dani Kachakil (nuestro chico maravillas) nos solventó la papeleta y la web4 fue la única prueba que nos quedó por resolver porque nos quedamos atascado en un detalle… no acertar el nombre de un fichero php! Había que saltarse la directiva LIMIT de un apache y luego era un Blind SQL. Lástima. Las últimas horas del concurso fueron muy estresantes,  la noche del viernes Skull y Dade se había puesto manos a la obra hasta el amanecer y se posicionaron segundos, ellos había resuelto la web4 que valía más puntos que la cripto3 así que si resolvían una prueba más nos adelantaban. Estaban a puntito a puntito de obtener la solución de la cripto4 con la que nos adelantaban pero a falta de 15minutos pudimos sacarla nosotros y nos alejamos Maldito LSB! Probamos decenas de herramientas! Joca y cucaracha estuvieron muy muy fuertes en la competición así que felicidades a ellos también.

No me he extendido mucho en las pruebas del wargame pero la gente de SecurityByDefault se han currado unos posts con las soluciones por categorías: Redes, Web, Cripto y Binarios.

Ricardo y Ernesto participaron en un par de competiciones y se las llevaron al agua las 2, si es que están hechos unos crás. Luego Ricardo confesó que había amenazado a los contrincantes para que huyeran despavoridos.

La última noche la pasamos de buen rollo en los jardines de al lado de la CAC, como tiene que ser, tirados en el césped y con spirits!

Os pondría más fotos y más decentes pero no tenía cámara así que sólo tengo las que salen por el flickr de la campus xDD

Otro año más, a poder ser mejor.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [Campus Party 08] Diario de a bordo – Parte 2
• En Berlin!
• [Campus Party 09] Planning

Primero de todo vamos a hacer un programa que nos permita calcular el hash md5 de un string que se le pase y luego ya pasaremos al crackeador.

Sería más fácil hacer un script en bash o perl gracias a la utilidad CLI de OpenSSL, a la hora de calcular un solo hash no importa mucho la velocidad pero si luego queremos hacer un pequeño crackeador no podemos partir de algo que ya sabemos que va a ser mucho más lento. Así que lo que vamos a usar es C y la librería de OpenSSL.

Si no sabemos por donde empezar un extracto del man:

$ man md5
...
SYNOPSIS
 
#include 
 
        unsigned char *MD5(const unsigned char *d, unsigned long n,
                         unsigned char *md);
 
        int MD5_Init(MD5_CTX *c);
        int MD5_Update(MD5_CTX *c, const void *data,
                         unsigned long len);
        int MD5_Final(unsigned char *md, MD5_CTX *c);
...
DESCRIPTION
...
Applications should use the higher level functions EVP_DigestInit(3) etc. instead of calling the hash functions directly.
...

Vemos que podríamos añadir esa librería y usar las funciones MD5_Init(), MD5_Update y MD5_Final pero ya nos avisan que deberíamos usar unas funciones de más alto nivel así que: EVP_DigestInit

$ man EVP_DigestInit
...
SYNOPSIS
        #include 
 
        void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
        EVP_MD_CTX *EVP_MD_CTX_create(void);
 
        int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
        int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
        int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
               unsigned int *s);

De paso, aprovecho para desaconsejar el uso de MD5 a día de hoy y como mínimo usar SHA1 o incluso dejarte de monsergas y pasar a SHA256, SHA512.

He intentado que el programa sea bastante fácil de entender y seguir, ahí va:

#include
#include 
 
#include 
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_WORD 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i< MAX_SIZE_WORD ){
 
		strncpy(buff, argv[1], strlen(argv[1]));
 
		// calculate string's md5 hash
		out = simple_digest("md5",buff,strlen(argv[1]),&olen);
 
		// print results
		if (DBG){
			printf("Word: %s\n",argv[1]);
			printf("Hash: ");
		}
		hex_print(out,olen);
		printf("\n");
 
		return 0;
	}
 
	printf("\nNot computing hash\n");
	printf("\nI can feel your dark side... ;)\n");
 
	return -1;
}

Compilamos y probamos:

$ gcc mymd5.c -o mymd5 -l ssl
$ ./mymd5 passworddeelite
5b4f50aa173b977e4cd0850cf7c52bd0

Podemos comprobar su correcto funcionamiento comparando con webs online que ofrecen utilidades para calcular hashes MD5 [1], [2].

Y ahora a por el crackeador. No vamos a intentar buscar colisiones sino a partir de un diccionario sacar la clave. Le pasaremos como parámetros un fichero con el hash y un diccionario con una palabra por línea.

#include
#include 
 
#include 
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_BUFF 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i<3) {
	        printf("Usage: mymd5crack /path/to/hashfile /path/to/dictfile\n");
        	exit(1);
	}
 
	FILE *hashfile;
	hashfile = fopen(argv[1],"r");
	if(!hashfile){
		perror(argv[1]);
	return -1;
	}
 
	FILE *dictfile;
	dictfile = fopen(argv[2],"r");
	if(!dictfile){
		perror(argv[2]);
	return -1;
	}
 
	read = getline(&line, &len, hashfile);
	if(strlen(line)!=33){
		fprintf(stderr,"ERROR: Invalid hash length %d\n",strlen(line));
		return -1;
	}	
 
	strtohex(line,hash,32);
 
	if(DBG){
			printf("Input hash: %s\n", line);
			printf("Input buffer from hash: ");
			hex_print(hash,16);
			printf("\n\n");
	}
 
	//Read words in a loop
	while((read = getline(&line, &len, dictfile)) != -1){
		if( strlen(line) < 200){
			tries++;	
 
			//Copy word into buffer
			strcpy(buff_words,line);
 
			if(DBG)
				printf("Input buffer from dict: %s \n",buff_words);
			// compute md5
			out = simple_digest("md5",buff_words,strlen(line)-1,&olen);
 
			if(DBG){
				printf("For password %s MD5 is: ",line);
				hex_print(out,olen);
				printf("\n\n");
			}
 
			//Compare computed md5 with hash
			if(memcmp(out,hash,16) == 0){
 
				printf("PASSWORD FOUND!! in %d tries: %s\n",tries,line);
 
				fclose(hashfile);
				fclose(dictfile);
				free(out);
				if(line)
					free(line);
 
				return 0;
			}
			free(out);
		}else{
			printf("\nA word from dict is too long... cough*, cough*...\n");
		}
	}
 
	printf("Password not found in %d tries!\n",tries);
 
	if(line)
		free(line);
 
	fclose(hashfile);
	fclose(dictfile);
 
	return 0;
}

Y comprobamos su funcionamiento metiendo en /tmp/hash el hash obtenido anteriormente:

$ gcc mymd5cracker.c -o mymd5cracker -l ssl
$ ./mymd5cracker /tmp/hash /tmp/dict
PASSWORD FOUND!! in 6 tries: passworddeelite

Premio! Podéis ir en paz.

Para descargar mymd5.c y mymd5cracker.c

Gracias a TuXeD que siempre está ahí para echar una mano.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descifrando un reto del FBI
• El kernel de linux en profundidad
• Soluciones del reto de criptografía – Parte 2

http://DOMAIN_NAME.TLD/wordpress/wp-login.php?action=rp&key=o7naCKN3OoeU2KJMMsag

Hasta aquí normal, de vez en cuando salen vulnerabilidades, además cuando recibes un correo (por ejemplo) con el link maloso te das cuenta de que hay gato encerrado.. pero ¿puede haber otros factores? Uhm, sí. ¿Qué tal los acortadores de direcciones? No se vería en principio a donde vas.

Por otro lado, hace un par de días actualicé Firefox a la versión 3.5.2 y esta mañana me he dado cuenta de que tiene activado un pre-fetch de links para navegar de un modo más rápido, es decir, precarga la primera búsqueda de google, precarga el siguiente post del blog que estás leyendo, etc. ¿Precarga un link malicioso que has recibido intentando explotar el bug anterior?

No me parece nada segura este tipo de navegación acelerada así que para desactivar esta opción se puede entrar en el about:config y desactivarla:

network.prefetch-next = false

Y ahora el mundo es un poquito mejor (de hecho ya han ido llegando correos maliciosos por algún sitio intentando explotarlo).

Sobre Wordpress, ó se actualiza a la versión 2.8.4 ó se cambia a mano el código vulnerable.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Búsquedas curiosas – Volumen 2
• Soluciones del reto de criptografía – Parte 2
• Para los amantes de XKCD llega…

A día de hoy contamos con ordenadores chorrecientas veces más rápidos que hace pocos años y cuando se programa haces pruebas con sistemas de 3GHz, varios MB de cache y 2GB de RAM mínimo y todo tira para adelante. Bueno, todo tira hasta cierto punto, tus programas luego se van a estar ejecutando juntos con otras decenas de programas o simplemente se van a estar ejecutando constantemente y vas a perder un gran porcentaje de la capacidad de proceso de cómo lo podrías estar haciendo.

Bueno, y es normal, cosas de la comodidad, yo el primero. Ahora te quedas tranquilo con que funcione, en los 80 tenía que funcionar y caber en 64kB de RAM. No digo que se programe peor (seguramente sí xD) pero ya no nos fijamos en muchos detalles que antes eran totalmente necesarios (la de trucos que usaba la gente para poder aprovechar el 100% del hardware del Commodore64) y ahora desperdiciamos por todos lados y al final sí que pasa factura. La gente que programe sistemas embebidos lo tiene muy claro aunque casi se va a acabar el asunto también ahí porque ya los procesadores de los móviles/PDAs/cosas_pequeñas tirán mucho.

Me he encontrado con programas que están al 100% de CPU en idle, con programas que daban su salida en unos 12~15 minutos cuando otro para el mismo propósito lo hacía en aproximadamente 1 segundo (no daré nombres xD), programas en los que notas el ‘refresco’ de los elementos cuando lo usas cuando te sobra CPU para hacerlo bien, etc. Hay que intentar evitar marañas de bucles for anidados!

Al final todo pasa por conocer muy bien el lenguaje que usas, haber pasado horas y horas, pensar las cosas antes de hacerlas, incluso un poquito de sentido común, cosa que creo que es difícil de abstraer a veces cuando se programa.

Por ejemplo, en matlab es muy importante reservar el espacio para las variables antes y crear los vectores del tamaño que van a ser al final de las operaciones porque si aumentamos el tamaño de un vector[n], internamente lo que siempre hace es crear un nuevo vector[n+1] y copiar los datos del antiguo.

Hace unos meses me comentó un amigo que en el trabajo tenían un método númerico que disminuyó su tiempo de ejecución en más de un 20% (siendo su tiempo varias horas) al sustituir un resultado de una operación que siempre era el mismo por el valor guardado en una variable! Es de cajón pero hay que caer.

Y ahora vienen algunos ejemplos, por no meterme en un lenguaje tipo C en el que hay muchas posibilidades de hacer las cosas y hay que currarse más los ejemplo iré a algo más sencillo como es hacer scripts cerdos para administrar un máquinas o similares.

Un ejemplo sería un uso poco adecuado de las órdenes cat, grep, ls, awk y similares. Cuando manipulamos algo pequeño no pasa nada pero cuando se trata de varios ficheros logs y son decenas de MB pues la cosa empieza a tomar importancia.

Respecto a grep cuando una persona empieza y se plantea buscar una cadena lo primero que piensa es ‘muestro el archivo y luego saco las líneas coincidentes’:

# cat tinyproxy.log | grep remote
real    0m55.071s
user    0m24.477s
sys     0m0.727s

Luego descubres que en realidad lo puedes hacer ‘todo en uno’ y es bastantes más rápido:

# grep remote tinyproxy.log
real    0m36.024s
user    0m22.550s
sys     0m0.527s

Luego, sin querer, entras en el man y te das cuenta de que existen varios tipos: grep, egrep (similar pero no idéntico a grep -E ) y  fgrep (idéntico a grep -F). Así que pruebas:

# egrep remote tinyproxy.log
real    0m55.122s
user    0m25.029s
sys     0m0.659s

Joder, vuelve a ser lento a pesar de no hacer un cat. ¿Por qué? Porque es una función más compleja.

• grep: soporta expresiones regulares básicas.
• fgrep: no soporta expresiones regulares => el más rápido.
• egrep: soporta expresiones regulares avanzadas => el más lento.

Para los curiosos, el nombre grep viene de g/re/p y significa lo que hace tal cual, buscar una expresión regular y hacer print de las coincidencias. En realidad a una escala grande ni siquiera deberíamos usar grep sino sed que es más rápido.

Lo mucha gente desconoce es que hay otra manera de evitar el cat de antes y ganar tiempo, y es que en realidad las concatenaciones siempre están ahí… así que lo podríamos hacer del siguiente modo:

# <tinyproxy.log grep remote
real    0m43.931s
user    0m22.338s
sys     0m0.578s

Del mismo modo estos conceptos se puede usar en otras órdenes

# cat tinyproxy.log | wc -l
104265

real    0m0.088s
user    0m0.021s
sys     0m0.053s

# wc -l tinyproxy.log
104265 tinyproxy.log

real    0m0.021s
user    0m0.013s
sys     0m0.006s

Y del mismo modo:

# cat tinyproxy.log | tail -n 200
real    0m0.121s
user    0m0.026s
sys     0m0.056s

# tail -n 200 tinyproxy.log
real    0m0.010s
user    0m0.000s
sys     0m0.003s

Cambiando de tercio también solemos usar echo más veces de las que toca. Por ejemplo si tenemos :

var="valor_o_resultado_de_una_evaluacion"
command -options `echo $var`

en la mayoría de los casos podremos sustituirlo por:

var="valor_o_resultado_de_una_evaluacion"
command -options $var

Y así mil chorradas. Por cierto, el que sólo se conozca la opción de awk para coger columnas le recomiendo que se mire manules que termina siendo muy útil.

Creo que este post lleva más de 6 meses en drafts y no he añadido nada (de hecho tampoco tengo ganas), así que aunque es un tema que da mucho de sí ha quedado bastante descafeinado técnicamente, pero ajo y agua!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descodificar tonos DTMF usando Matlab
• Port-Knocking y Crypt-Port-Knocking
• Dejar bonito un server SSH – Parte 1