Você está na página 1de 25

Administración de Sistemas

Gestión de Usuarios : Linux

I TAHISA M. D ÍAZ D ÍAZ

M ARÍA D. BATISTA G ALVÁN

E SCUELA T ÉCNICA S UPERIOR DE I NGENIERÍA I NFORMÁTICA

Universidad de La Laguna
R ESUMEN . El presente informe tiene como objetivo describir el desarrollo de la práctica
realizada en el laboratorio de la asignatura Administración de Sistemas. En dicho labo-
ratorio se tuvo que llevar a cabo la gestión de usuarios dentro de un supuesto práctico,
el cual consistía en una organización cuyo sistema informático era Linux. Concreta-
mente, la práctica se implementó sobre una máquina virtual creada para trabajar como
servidor, cuyo sistema operativo era CentOS.
Para la gestión o administración de los usuarios de la organización se hizo uso de los me-
canismos y herramientas proporcionados por el sistema operativo. Dichas herramientas
permitieron la creación de usuarios y grupos de la organización, así como una estructura
de carpetas donde los usuarios almacenarían y compartirían su información. Además fue
necesario establecer ciertas normas de seguridad para el acceso a dicha información a
través de la asignación de permisos, listas de control de acceso y cuotas de disco.
Por otra parte, la estructura del informe está determinada por las cuestiones propuestas
en la práctica, a las que se irá respondiendo y describiendo los procesos para su conse-
cución. En particular, se explica y responde al caso práctico propuesto en concreto, sin
embargo se ha desarrollado un script con el objetivo de facilitar la tarea de gestión de
una manera más general, y menos específica, pero que sirve igualmente para la práctica.
Dicho script se incluye como anexo en el siguiente enlace A.
Además, en el presente informe se muestra con detalle todo los procedimientos seguidos,
pero se excluye en ellos, la reiterada información de las líneas de comandos de casos
similares. Y eso es debido, a que no se quiso cargar el informe demasiado con detalles
evidentes (ej. sólo se añadió la siguiente línea de comando “passwd usu5 -x 90 -w 1 -i
2”, entendiendo que se tendría que hacer para el resto de usuarios).

1
Índice

1. Contraseñas 3

2. Directorio de cada usuario 4

3. Proyecto en Ejecución 8

4. Ejecutivos 10

Anexos 13

A. Script : Gestión de Usuarios 13

B. Limitación de horas de conexión 24

2
1. Contraseñas
En la práctica, la contraseña de cada usuario coincidirá con el nombre de usuario.

Para la realización de esta parte fue necesario crear previamente a todos los usuarios y ejecutivos
involucrados en la práctica (esto puede verse a continuación en el apartado 2). Una vez creados, se
añadió a cada usuario la contraseña cifrada en el fichero “/etc/shadow” en su fila correspondiente.
Para conseguir esto sin tener que editar el fichero, sirvió de ayuda el comando “passwd” y la opción “-
-stdin”, donde esta opción dejaría introducir mediante un pipe la contraseña ($password=$user) del
usuario ($user). A continuación puede verse un ejemplo general en el que se han definido previamente
dos variables (user y password):

[alumno:0:~]$ echo "$password" | passwd --stdin $user

Los usuarios deben cambiar sus contraseñas cada 3 meses.

Es necesario notificar a los usuarios 1 día antes de que su contraseña caduque.

Transcurridos 2 días desde la caducidad del password, la cuenta ha de quedar desactivada.

Seguidamente, para una correcta realización, se tendría que modificar 3 campos de la fila del usuario
referidos a las limitaciones de la contraseña en el mismo fichero “/etc/shadow”. Al igual que ante-
riormente, se volvió a utilizar el comando “passwd” para evitar tener que editar el fichero, pero en este
caso se usaron opciones diferentes que se describen a continuación:
Opciones Descripción : passwd
-x Establece el no máximo de días antes del cambio de contraseña.
-w Establece los días de aviso de expiración.
-i Estable la inactividad de la contraseña tras su expiración.

Teniendo en cuenta estas opciones y los requerimientos pedidos, se puede ver a continuación un
ejemplo particular:

[alumno:0:~]$ passwd usu5 -x 90 -w 1 -i 2

3
2. Directorio de cada usuario
Todo usuario del sistema debe poseer un subdirectorio del directorio /home cuyo nombre
debe coincidir con el de la cuenta del usuario.

Este apartado se escogió como punto de inicio para la realización de la práctica, donde no se añadió
tan sólo el directorio de conexión del usuario, sino que además, se añadió el propio usuario al fichero
“/etc/passwd” y “/etc/shadow”. Para ello, se utilizó el comando “useradd” con las siguientes
opciones que se describen a continuación:
Opciones Descripción : useradd
-m Forzamos la creación del directorio en su home (si no está creado).
-d Directorio de trabajo o home del usuario, campo 6 de /etc/passwd.
-s Shell por defecto del usuario cuando ingrese al sistema. Si no se especifica, bash, es el que queda establecido.
-u UID del usuario, si no se especifica, se establece el siguiente no disponible a partir del último usuario creado.

Un ejemplo particular, en el que implementa lo requerido en el enunciado es el que se muestra a


continuación:

[alumno:0:~]$ useradd -m -d /home/usu3 -s /bin/bash -u 502 usu3

Aunque a simple vista pueda verse un ejemplo algo redundante, puesto que se ha elegido la opción
“-s /bin/bash” cuando por defecto se añade esa, y también, la opción “-u 502” cuando por de-
fecto añade el último. Es debido, a que en el script que puede verse en el anexo A, se da la oportunidad
al administrador de introducir otra shell y otra manera de gestionar los uid, aunque por defecto el script
lo realiza como en RedHat, de manera secuencial a partir de 500.

En este directorio, el usuario debe poder crear y borrar ficheros y directorios, pero no debe
poder modificar los permisos de su directorio de conexión.

Para conseguir que un usuario no pueda modificar los permisos de su propio directorio de conexión,
donde cabe destacar que es él, el propietario y cuyo grupo es él mismo, y esto ocurre por defecto a la hora
de la creación del usuario (visto anteriormente). Sólo hubo que cambiarle el propietario del directorio
de conexión por root (mediante el comando “chown”) y cambiarle el permiso de escritura, lectura y
ejecución sólo para el grupo (mediante el comando “chmod”). De esta manera, se consiguió que sólo el
miembro del grupo (que es sólo el propio usuario) pudiera tener los beneficios requeridos, y que dicho
usuario no pudiera cambiar los permisos del directorio raíz por no ser el propietario del directorio. Esto
se muestra a continuación mediante un ejemplo:

[alumno:0:~]$ chown root /home/usu1


[alumno:0:~]$ chmod 070 /home/usu1

Ningún otro usuario del sistema podrá acceder a dicho directorio ni a su contenido.

Como se mostró en el apartado anterior, el hecho de proporcionarle permiso sólo a los miembros del
grupo (usu1), donde sólo usu1 es miembro, evita que otro usuario del sistema pueda acceder a dicho
directorio raíz y a su contenido.

4
[alumno:0:~]$ chmod 070 /home/usu1

Cada usuario tendrá una cuota de disco de 50 Mb que podrá sobrepasar temporalmente (2
días).

Esta parte de la práctica resulta bastante útil y esencial para la gestión de un sistema, debido a que
así se podrá controlar la cantidad de espacio que puede usar un usuario o grupo determinados y así evitar
que una única aplicación devore todos los gigas disponibles.
Para ello, fue necesario la instalación del paquete “quota” para poder establecer cuotas de disco en
este sistema Linux, tal como se muestra a continuación:

[alumno:0:~]$ yum install -y quota

Las cuotas se establecieron por sistema de archivos para usuarios o grupos. Aunque en este sistema
Linux se podía utilizar varios sistemas de archivos, se sabe que en “/home” es donde los usuarios
tienen sus directorios. Por lo tanto, se entiende que sólo en este sistema de archivos es donde se crearían
las cuotas, ya que en el resto no tendría sentido. Luego, se tuvo el inconveniente de que el sistema de
ficheros ya estaba montado, por lo que fue necesario volver a montar el sistema de ficheros con las
opciones que indican el deseo de usar cuotas (“usrquota” y “grpquota”, para dar soporte de cuotas a
usuarios y grupos, respectivamente).
Para ello, se tuvo que editar el archivo “/etc/fstab” y añadir “usrquota” (ya que este apartado
sólo se requiere para usuarios), para que el sistema de ficheros ya existente “/home” pudiera soportar
cuotas, y luego montarlo. Para evitar editar el fichero, y realizar toda esa tarea de una vez, se usó el
comando “mount” utilizando las siguientes opciones:
Opciones Descripción : mount
-t Especifica el tipo de sistema de archivos a instalar.
-o Dice a mount que aplique las opciones que son especificadas para el sistema de archivos que se montará.

A continuación, se remontó el dispositivo “/dev/mapper/vg_as07-LogVol02” (un volumen


lógico donde se alojó el “/home”) con soporte para cuotas tan sólo para usuarios.

[alumno:0:~]$ mount -t ext4 -o remount,usrquota /dev/mapper/


vg_as07-LogVol02 /home/

La opción “remount” del comando “mount” intenta remontar el sistema de ficheros especificado
con las opciones indicadas, lo que evita desmontarlo (algo imposible de hacer mientras haya aplicaciones
usando dicho sistema de ficheros).
Para que el sistema puede llevar un control de las cuotas configuradas y de la parte usada de cada
usuario fue necesario crear un archivo (“aquota.user”) en el directorio raíz (“/home/”) del sistema
de ficheros en el que se configuró las cuotas de disco. Sin embargo, estos archivos son binarios y no se
pueden editar directamente como casi cualquier otro archivo de configuración, sino que se usa la utilidad
“quotacheck” para iniciar su contenido con la ocupación actual en disco de cada usuario, con las
opciones siguientes:

5
Opciones Descripción : quotacheck
-m Evita que el sistema se remonte como de solo lectura.
-u Verifica por soporte de cuotas para usuarios.

[alumno:0:~]$ quotacheck -m -u /home/

El comando “quotacheck” recorrió todos los archivos y directorios del sistema de ficheros contabi-
lizando el uso actual por parte de cada usuario y almacenando el resultado en el archivo “aquota.user”.
A continuación, se instruyó al núcleo para que hiciera un seguimiento continuo de los accesos a disco y
contabilizara el espacio ocupado constantemente. Para ello se activó el sistema de cuotas para el sistema
de ficheros deseado mediante el comando “quotaon” y sus opciones:
Opciones Descripción : quotaon
-u Activa las cuotas de usuario; esta es la opción por defecto.
-v Se muestra un mensaje por cada sistema de ficheros en el que se han activado las cuotas.
-a Activa las cuotas en todos los sistemas de ficheros incluidos en /etc/fstab.
-p Muestra si el sistema operativo está gestionando las cuotas en los sistemas de archivos.

[alumno:0:~]$ quotaon -uv /home/

Antes de continuar se compróbó que el sistema operativo realmente estaba gestionando las cuotas de
este sistema de ficheros, mediante el mismo comando pero con la opción adicional “-p”:

[alumno:0:~]$ quotaon -vuap

Ahora hay que aplicar la cuota por usuario, aunque el sistema de archivos ya soporta cuotas y están
habilitadas, por defecto ningún usuario tiene establecidas cuotas. Según el enunciado cada usuario tendrá
una cuota de 50MB (51.200 KB) la cual podrá superar por un periodo de tiempo. Por lo que, esa cuantía
se referirá al límite soft (para bloques o inodos), que es inferior al límite hard. Además, se limitará al
usuario la cuantía de bloques de 1 KB y no el número de archivos que está utilizando. Así que para
iniciar las cuotas habrá que administrar cada usuario a través del comando setquota sabiendo que
este comando tiene el siguiente formato “setquota -u usuario softBlock hardBlock softInodo hardInodo
directorio”:

[alumno:0:~]$ setquota -u usu3 51200 60000 0 0 /home/usu3

Para finalizar, se establecerá el tiempo de gracia de dos días (172800 seg) de manera global. Para
ello, se utilizará el mismo comando “setquota” pero esta vez con la opción “-t” que implica a todos
los usuarios del sistema de ficheros. Además, en esta ocasión se añadirá a los inodos también el mismo
periodo que a los block aunque no significará nada. Por último, tener en cuenta, que pasado el límite soft
fuera del periodo de gracia se comportará como hard mientras no se reduzca la ocupación en disco a
niveles inferiores a la cuota soft.

[alumno:0:~]$ setquota -t -u 172800 172800 /home

6
A continuación, para verificar el buen funcionamiento de las cuotas, se limitará el tiempo de gracia a
un par de minutos (120 seg), y se creará un fichero lleno de ceros de 55 MB que exceda las cuotas permi-
tidas, gracias al comando “dd” que trasfiere datos entre archivos donde sus opciones bs hace referencia
al tamaño de los bloques (1024 Byte = 1 KB) y count al número de bloques (56.320), y “/dev/zero”
es un archivo especial que provee de caracteres null:

[alumno:0:~]$ dd if=/dev/zero of=/home/usu2/vacio bs=1024 count


=56320

7
3. Proyecto en Ejecución
La Organización tiene varios proyectos en curso. Para estos proyectos, se ha de cumplir:

Cada proyecto debe tener un directorio bajo el directorio /export/proyectos donde se almace-
nará la documentación asociada al mismo.

Todos los usuarios que participan en un proyecto deben tener la posibilidad de leer, modificar,
crear y borrar los archivos que forman parte del proyecto.

Cuando un usuario cree un archivo en el directorio del proyecto, por defecto, éste debe poder
ser leído, modificado o borrado por cualquier otro usuario del mismo proyecto.

Ningún otro usuario podrá acceder a estos directorios.

En primer lugar, se creó un directorio por cada proyecto (aeropuerto, comercial y parque) en la
ruta correspondiente (“/export/proyectos”). Para ello, se hizo uso del comando “mkdir” el cual
permitió, con sus opciones, no sólo la creación de los ficheros sino también establecer los permisos
necesarios:
Opciones Descripción : mkdir
-m Establece los permisos (como en chmod) a los directorios creados.
-p Crea directorios intermedios si no existen.

[alumno:0:~]$ mkdir -p -m 2070 /export/proyectos/aeropuerto/ /


export/proyectos/comercial/ /export/proyectos/parque/

Como puede observarse, se ha otorgado el permiso especial setgid que permite que todos los archivos
y directorios creados dentro de estos directorios (“/aeropuerto”, “/comercial” y “/parque”) hereden el
mismo grupo de ellos. Además, se establecieron los permisos de lectura, escritura y ejecución sólo a los
miembros del grupo. Consiguiendo así, que al crearse un archivo o directorio sólo los miembros del grupo
puedan realizar los cambios permitidos en el enunciado, anulando la posibilidad de que otros usuarios
que no pertenezcan al grupo puedan acceder al directorio, y mucho menos realizar modificaciones en
ellos.
Cabe destacar que para que lo anterior tenga sentido, fue necesario establecerle los grupos a cada
directorio cuyos nombres se correspondieron con la denominación de cada proyecto. Para ello, previa-
mente se tuvo que crear los grupos con el comando “groupadd” y su opción “-r” que crea un grupo
del sistema con un GID menor que 500:

[alumno:0:~]$ groupadd -r aeropuerto

Una vez creados los grupos ya se pudo asignar a los directorios los grupos correspondientes, además
de otorgarle el propietario al root, según se ve a continuación en un ejemplo:

[alumno:0:~]$ chown root.comercial /export/proyectos/comercial

8
Para finalizar se añadió a cada usuario los grupos según los proyectos a los que pertenecían. Esto se
realizó mediante el comando “usermod” y las opciones:
Opciones Descripción : usermod
-a Añade al usuario un nuevo grupo secundario.
-G Se añade un listado de grupos secundarios.

[alumno:0:~]$ usermod -a -G aeropuerto,comercial usu4

Existirá un directorio /export/proyectos/comun donde se almacenará información común a to-


dos los proyectos de tal forma que todos los usuarios puedan añadir y modificar información
a este directorio, pero sólo el propietario de cada carpeta pueda eliminarla.

Se actuó de igual manera que antes, pero con la salvedad de que se añadió un nuevo permiso es-
pecial, para ajustarse a los requerimientos del enunciado. Este permiso fue sticky, y se utilizó para que
únicamente el usuario que crea el archivo (i.e. el propietario) tenga la posibilidad de eliminarlo.

[alumno:0:~]$ mkdir -p -m 3070 /export/proyectos/comun/


[alumno:0:~]$ groupadd -r comun
[alumno:0:~]$ chown root.comun /export/proyectos/comun/

Hay que matizar que en este caso sí es obligatorio añadir la opción “-a” del comando “usermod”,
debido a que sino se hiciera se borrarían los grupos anteriores adquiridos y se quedaría como único grupo
secundario común.

[alumno:0:~]$ usermod -a -G comun usu2

9
4. Ejecutivos
En la empresa existen varios ejecutivos que tienen asignada la evaluación de algunos de los
proyectos existentes con las siguientes restricciones:

Para esta parte se hizo necesario la utilización de Listas de Control de Acceso, ACL, debido a que los
ejecutivos gozarán de permisos exclusivos para ellos, que no se regirán por los impuestos en apartados
anteriores.
Para trabajar con las ACL fue necesario instalar el paquete acl:

[alumno:0:~]$ yum install -y acl

Se establecieron las ACL al sistema de ficheros ya existente, de manera que tan sólo con una línea de
comando se evitaría tener que editar el fichero “/etc/fstab”. Y al igual que pasaba con las cuotas,
habrá que montar el sistema por el mismo motivo:

[alumno:0:~]$ mount -t ext4 -o remount,usrquota,acl /dev/mapper/


vg_as07-LogVol02 /home/

Los ejecutivos asociados a un determinado proyecto podrán leer la información de ese pro-
yecto.

Los ejecutivos que no pertenezcan a un proyecto no deben poder acceder directamente a los
directorios de los proyectos.

Se inicializaron las ACL de los tres directorios (“/aeropuerto”, “/comercial” y “/parque”), eliminando
todas las existentes, añadiendo las ACL por defecto y de manera recursiva a todos sus subdirectorios. Se
llevó a cabo con el comando “setfacl” y las siguientes opciones:
Opciones Descripción : setfacl
-b Elimina todas las ACL impuestas sin excepción.
-k Elimina las ACL por defecto.
-R Aplica las operaciones a todos los archivos y directorios recursivamente.
-m Modifica o añade permisos.

[alumno:0:~]$ setfacl -b -k -R /export/proyectos/parque

Para facilitar el manejo de los permisos de los ejecutivos dentro de los directorios, teniendo en cuenta
que un ejecutivo pueda cambiar de proyecto en cualquier momento, resultó interesante la creación de tres
grupos nuevos (aeropuertoACL, parqueACL y comercialACL) para cada proyecto. Y así, evitar tener que
ir directorio a directorio cambiando el permiso para cada ejecutivo modificado, de tal manera, que sólo
sería necesario cambiar de grupo al ejecutivo implicado.

[alumno:0:~]$ groupadd -r aeropuertoACL

10
Se añadió a cada ejecutivo su correspondiente proyecto, no haciéndose necesaria la opción “-a” ya
que no se le ha asignado ningún grupo secundario previamente.

[alumno:0:~]$ usermod -G aeropuertoACL,parqueACL ejec1


[alumno:0:~]$ usermod -G aeropuertoACL,comercialACL ejec2

Por último, se establecieron los permisos de sólo lectura a cada uno de los directorios del proyecto con
su grupo ACL correspondiente. Esto se llevó a cabo con el comando “setfacl” (que lleva por sintaxis
tres campos separados por “:”, el primero se refiere a si es a un grupo (g) o usuario (u), el segundo el
nombre del grupo o usuario, y el tercero al tipo de permiso):

[alumno:0:~]$ setfacl -R -m g:parqueACL:r-- /export/proyectos/


parque

Para que estos ejecutivos puedan controlar el estado de cada proyecto, deben existir en el
directorio /usr/local/bin tantos programas como proyectos existan.

Estos programas internamente han de realizar un “ls” sobre el directorio del proyecto co-
rrespondiente.

Con el fin de utilizar un pequeño programa en C que realizase la función de listar un directorio, fue
necesario instalar el compilador de C:

[alumno:0:~]$ yum install -y gcc

Dichos programas utilizan la librería “unistd.h” que contiene funciones para el manejo de ficheros
y directorios en sistemas UNIX. En dichos programas se deja usar todas las opciones del comando ls,
pero se ha restringido que el usuario pueda elegir el directorio deseado. Esto se consiguió realizando una
copia de los argumentos de entrada, pero filtrando cualquier posibilidad de entrada de algún directorio.
Además, para que fuera posible la ejecución del comando “ls” se utilizó, de la familia exec, aquel que
deja utilizar los parámetros de entrada por un vector en su segundo parámetro, execv, y cuyo primer
parámetro “/bin/ls” es el fichero ejecutable.

1 #include <unistd.h>
2

3 main(int argc, char* argv[])


4 {
5 int i, j = 0;
6 char* args[argc+2];
7

8 for (i = 0; i < argc; i++)


9 if ((argv[i][0] == ’-’) || (i == 0))
10 {
11 args[j] = argv[i];

11
12 j++;
13 };
14 args[j] = "/export/proyectos/parque";
15 args[j+1] = NULL;
16

17 execv("/bin/ls", args);
18 }

Una vez compilado los tres programas realizados (lsAer.c, lsCom.c y lsPar.c), se ubicó los ejecutables
en el directorio que “/usr/local/bin” tal como pedía el enunciado, lo cual permitió poder ejecutar
estos programas desde cualquier directorio en que se encuentrase como si fuera un comando de Linux.

El programa que permite evaluar cada proyecto, debe cumplir lo siguiente:

• Debe poder ser ejecutado únicamente por los ejecutivos de la organización.


• Debe tener asignado los permisos suficientes para poder ejecutar el “ls” sobre el direc-
torio correspondiente.

Dichos programas tuvieron como propietario al root, debido que es él único usuario que puede ac-
ceder a todos esos directorios y realizar un ls. Por lo que, para que los ejecutivos pudieran usar estos
programas y además, tuviera éxito en el acceso a la información de los archivos existentes, se habilitó
el bit setuid a cada uno de los ficheros para que aquel que ejecutara alguno de los archivos contara con
los privilegios heredados del propietario. A continuación, se creó un grupo nuevo llamado ejecutivo y se
añadió a este nuevo grupo a los dos ejecutivos y además, se modificó el grupo de los ficheros a ejecutivo.

[alumno:0:~]$ groupadd -r ejecutivo


[alumno:0:~]$ usermod -a -G ejecutivo ejec1
[alumno:0:~]$ usermod -a -G ejecutivo ejec2
[alumno:0:~]$ chown root.ejecutivo lsAer

Esto logró que tras otorgarle los permisos de sólo ejecución a los grupos, y anular el resto, fueran los
ejecutivos los únicos que pudieran ejecutar estos ficheros con los privilegios de root.

[alumno:0:~]$ chmod 4010 /usr/local/bin/lsCom

12
ANEXOS
A. Script : Gestión de Usuarios
A continuación se muestra el código del script que fue creado para la realización de la práctica. El
objetivo principal no era sólo el satisfacer los requerimientos de la práctica, sino también una base para
la gestión de usuarios de una manera más genérica. Además, se añadieron nuevas secciones bastante
relevantes bajo nuestro modesto criterio.

1 #!/bin/bash
2
3 clear
4
5 # Este filtro sólo dejará ejecutar el script al root
6 if [ "‘whoami‘" != "root" ]; then
7 echo -e "\n"
8 echo -e "\033[1;31m Permiso denegado : No eres root. \033[0m"
9 echo -e "\n"
10 exit 1
11 fi
12
13 # Variable que almacenará el n o de usuarios estándar creados
14 i=1
15
16 #***********************************************************************************
17 # CABECERA Y SALIDA
18 #***********************************************************************************
19
20 # Es la función que crea la cabecera del scripts
21 function cabecera
22 {
23 clear
24 echo -e "\033[1m***********************************************************"
25 echo " $1 "
26 echo -e "***********************************************************"
27 }
28
29 #***********************************************************************************
30 # FUNCIONES DE LOS MENÚS
31 #***********************************************************************************
32
33 # GESTIÓN DE USUARIOS : USUARIOS
34 # Función : Dará de alta un usuario en /etc/passwd y /etc/shadow
35 function altaUsu
36 {
37 cabecera "USUARIOS : ALTA"
38 echo -e "\n \033[0m"
39
40 # Usuario ********************************************************
41 read -p " Nombre : " user
42 if [ -z "$user" ]; then
43 user="usu$i"
44 i=‘expr $i "+" 1‘
45 fi
46 existUser=‘grep -E $user /etc/passwd | cut -d":" -f1‘
47 if [ -n "$existUser" ]; then
48 echo -e -n "\033[1;31m El usuario ya existe. \033[0m"
49 else
50 # Directorio de Conexión Inicial *********************************
51 read -p " Home : " home
52 [ -z "$home" ] && home="/home/$user"
53
54 # uid del usuario ************************************************
55 # uid : de manera secuencial a partir de 500 (igual que RedHat)

13
56 read -p " uid : " uid
57 if [ -z "$uid" ]; then
58 ultUID="NOHALLADO"
59 uid=500
60 while [ -n "$ultUID" ]
61 do
62 ultUID=‘grep -E $uid /etc/passwd | cut -d":" -f3‘
63 [ -n "$ultUID" ] && uid=‘expr $uid "+" 1‘ || break
64 done
65 fi
66
67 # Shell de Arranque **********************************************
68 read -p " Shell : " shell
69 [ -z "$shell" ] && shell="/bin/bash"
70
71 # Contraseña *****************************************************
72 read -p " Contraseña : " password
73 [ -z "$password" ] && password="$user"
74
75 # Crear usuario **************************************************
76 useradd -m -d $home -s $shell -u $uid $user
77
78 # Crear contraseña ***********************************************
79 echo "$password" | passwd --stdin $user
80
81 # Modificación del tiempo de expiración, aviso y deshabilitación *
82 read -p " Tiempo expiracion (días) : " texp
83 [ -z "$texp" ] && texp="90"
84 read -p " Tiempo aviso (días) : " tavi
85 [ -z "$tavi" ] && tavi="1"
86 read -p " Tiempo deshabilitación (días) : " tdes
87 [ -z "$tdes" ] && tdes="2"
88 passwd $user -x $texp -w $tavi -i $tdes
89 fi
90
91 sleep 1
92 }
93
94 # GESTIÓN DE USUARIOS : USUARIOS
95 # Función : Elimina un usuario
96 function bajaUsu
97 {
98 cabecera "USUARIOS : BAJA"
99 echo -e "\n \033[0m"
100
101 read -p " Nombre : " user
102 if [ -n "$user" ]; then
103 existUser=‘grep -E $user /etc/passwd | cut -d":" -f1‘
104 if [ -z "$existUser" ]
105 then
106 echo -e -n "\033[1;31m El usuario no existe. \033[0m"
107 else
108 userdel -r $user
109 fi
110 else
111 echo -e -n "\033[1;31m No ha introducido usuario. \033[0m"
112 fi
113
114 sleep 1
115 }
116
117 # GESTIÓN DE USUARIOS : USUARIOS
118 # Función : Muestra los usuarios creados
119 function MostrarUsu
120 {
121 cabecera "USUARIOS : MOSTRAR"
122 echo -e "\n \033[0m"
123
124 echo -e "\033[0;33m /etc/passwd \033[0m"
125 grep -E x:5.{2}:5.{2} /etc/passwd

14
126 echo -e "\n"
127
128 sleep 2
129
130 echo -e "\033[0;33m /etc/shadow \033[0m"
131 for usu in ‘grep -E x:5.{2}:5.{2} /etc/passwd | cut -d":" -f1‘
132 do
133 grep -E $usu /etc/shadow
134 done
135
136 echo -e "\033[1;34m \n"
137 read -p " Presiona [ENTER] para continuar. " enterKey
138 echo -e "\033[0m"
139 }
140
141 # GESTIÓN DE USUARIOS : GRUPOS
142 # Función : Dará de alta un grupo en /etc/group
143 function altaGru
144 {
145 cabecera "GRUPOS : ALTA"
146 echo -e "\n \033[0m"
147
148 read -p " Nombre : " group
149 if [ -z "$group" ]; then
150 echo -e -n "\033[1;31m No ha introducido grupo. \033[0m"
151 else
152 existGroup=‘grep -E $group /etc/group | cut -d":" -f1‘
153 if [ -n "$existGroup" ]
154 then
155 echo -e -n "\033[1;31m El grupo ya existe. \033[0m"
156 else
157 groupadd -r $group
158 fi
159 fi
160
161 sleep 1
162 }
163
164 # GESTIÓN DE USUARIOS : GRUPOS
165 # Función : Elimina un grupo
166 function bajaGru
167 {
168 cabecera "GRUPOS : BAJA"
169 echo -e "\n \033[0m"
170
171 read -p " Nombre : " group
172 if [ -z "$group" ]; then
173 echo -e -n "\033[1;31m No ha introducido grupo. \033[0m"
174 else
175 existGroup=‘grep -E $group /etc/group | cut -d":" -f1‘
176 if [ -z "$existGroup" ]
177 then
178 echo -e -n "\033[1;31m El grupo no existe. \033[0m"
179 else
180 groupdel $group
181 fi
182 fi
183
184 sleep 1
185 }
186
187 # GESTIÓN DE USUARIOS : GRUPOS
188 # Función : Añadir grupos a los usuarios
189 function anadGruUsu
190 {
191 cabecera "USUARIOS : GRUPOS"
192 echo -e "\n \033[0m"
193
194 read -p " Nombre usuario : " user
195 if [ -z "$user" ]; then

15
196 echo -e -n "\033[1;31m No se ha introducido usuario. \033[0m"
197 else
198 existUser=‘grep -E $user /etc/passwd | cut -d":" -f1‘
199 if [ -z "$existUser" ]
200 then
201 echo -e -n "\033[1;31m El usuario no existe. \033[0m"
202 else
203 # Puede dar un fallo si alguno de los grupos metidos no existe
204 read -p " Nombre/s grupo/s separados por , : " group
205 if [ -z "$group" ]; then
206 echo -e -n "\033[1;31m No se ha introducido grupo. \033[0m"
207 else
208 usermod -a -G $group $user
209 fi
210 fi
211 fi
212
213 sleep 1
214 }
215
216 # GESTIÓN DE USUARIOS : GRUPOS
217 # Función : Modificar los grupos secundarios a un usuario
218 function modGruUsu
219 {
220 cabecera "USUARIOS : GRUPOS"
221 echo -e "\n \033[0m"
222
223 read -p " Nombre usuario : " user
224 if [ -z "$user" ]; then
225 echo -e -n "\033[1;31m No se ha introducido usuario. \033[0m"
226 else
227 existUser=‘grep -E $user /etc/passwd | cut -d":" -f1‘
228 if [ -z "$existUser" ]
229 then
230 echo -e -n "\033[1;31m El usuario no existe. \033[0m"
231 else
232 # Puede dar un fallo si alguno de los grupos metidos no existe
233 read -p " Nombre/s grupo/s separados por , : " group
234 if [ -z "$group" ]; then
235 echo -e -n "\033[1;31m No se ha introducido grupo. \033[0m"
236 else
237 usermod -G $group $user
238 fi
239 fi
240 fi
241
242 sleep 1
243 }
244
245 # GESTIÓN DE USUARIOS : GRUPOS
246 # Función : Mostrar grupos usuarios
247 function MostrarGruUsu
248 {
249 cabecera "GRUPOS : MOSTRAR"
250 echo -e "\n \033[0m"
251
252 echo -e "\033[0;33m /etc/group \033[0m"
253 for usu in ‘grep -E x:5.{2}:5.{2} /etc/passwd | cut -d":" -f1‘
254 do
255 grep -E $usu /etc/group
256 done | sort | uniq
257
258 echo -e "\033[1;34m \n"
259 read -p " Presiona [ENTER] para continuar. " enterKey
260 echo -e "\033[0m"
261 }
262
263 # GESTIÓN DE USUARIOS : DIRECTORIO
264 # Función : Crea un directorio con permisos
265 function creaDir

16
266 {
267 cabecera "DIRECTORIO : CREAR"
268 echo -e "\n \033[0m"
269
270 read -p " Rutas/directorios separados por espacios : " directorio
271 if [ -z "$directorio" ]; then
272 echo -e -n "\033[1;31m No se ha introducido ruta. \033[0m"
273 else
274 read -p " Permisos : " permiso
275 if [ -n "$permiso" ]; then
276 permiso="-m $permiso"
277 fi
278 mkdir $permiso -p $directorio
279 fi
280
281 sleep 1
282 }
283
284 # GESTIÓN DE USUARIOS : DIRECTORIO
285 # Función : Borrar un directorio
286 function borrarDir
287 {
288 cabecera "DIRECTORIO : BORRAR"
289 echo -e "\n \033[0m"
290
291 read -p " Ruta/directorios separados por espacios : " directorio
292 if [ -z "$directorio" ]; then
293 echo -e -n "\033[1;31m No se ha introducido directorio. \033[0m"
294 else
295 [ -d "$directorio" ] && rm -R $directorio || echo -e -n "\033[1;31m No existe
directorio \033[0m"
296 fi
297
298 sleep 1
299 }
300
301 # GESTIÓN DE USUARIOS : DIRECTORIO
302 # Función : Modifica propietario y nombre del grupo de un directorio
303 function modiOwnGruDir
304 {
305 cabecera "DIRECTORIO : MODIFICAR"
306 echo -e "\n \033[0m"
307
308 read -p " Nombre de la ruta del directorio : " directorio
309 if [ -z "$directorio" ]; then
310 echo -e -n "\033[1;31m No se ha introducido ruta. \033[0m"
311 else
312 read -p " (Nombre del propietario)(y/o).(Nombre del grupo) : " ownGroup
313 if [ -z "$ownGroup" ]; then
314 echo -e -n "\033[1;31m No se ha introducido cambio. \033[0m"
315 else
316 chown $ownGroup $directorio
317 fi
318 fi
319
320 sleep 1
321 }
322
323 # GESTIÓN DE USUARIOS : DIRECTORIO
324 # Función : Mostrar ls -l
325 function mostrarDir
326 {
327 cabecera "DIRECTORIO : MOSTRAR"
328 echo -e "\n \033[0m"
329
330 read -p " Ruta del directorio : " directorio
331 if [ -z "$directorio" ]; then
332 ls -l
333 else
334 if [ -d "$directorio" ]; then

17
335 ls -l "$directorio"
336 else
337 echo -e -n "\033[1;31m Directorio no existe. \033[0m"
338 fi
339 fi
340
341 echo -e "\033[1;34m \n"
342 read -p " Presiona [ENTER] para continuar. " enterKey
343 echo -e "\033[0m"
344 }
345
346 # GESTIÓN DE USUARIOS : PERMISOS
347 # Función : Modificar permisos de fichero o directorio
348 function modiPermiso
349 {
350 cabecera "PERMISOS/UNIX : MODIFICAR"
351 echo -e "\n \033[0m"
352
353 read -p " Nombre del fichero o ruta directorio : " fich
354 if [ -z "$fich" ]; then
355 echo -e -n "\033[1;31m No se ha introducido datos. \033[0m"
356 else
357 if [ -d "$fich" ]; then
358 read -p " Permiso : " permiso
359 if [ -z "$permiso" ]; then
360 echo -e -n "\033[1;31m No se ha introducido permiso. \033[0m"
361 else
362 chmod $permiso $fich
363 fi
364 else
365 echo -e -n "\033[1;31m Directorio no existe. \033[0m"
366 fi
367 fi
368
369 sleep 1
370 }
371
372 # GESTIÓN DE USUARIOS : CUOTAS
373 # Función : Preparar el sistema para el uso de cuotas
374 function actCuotas
375 {
376 cabecera "CUOTAS : ACTIVAR"
377 echo -e "\n \033[0m"
378
379 echo -e "\033[0;32m Añadiendo soporte de cuotas a un sistema de ficheros ya en uso:"
380 echo -e "/dev/mapper/vg_as07-LogVol02 /home/ \033[0m"
381 sleep 1
382 mount -t ext4 -o remount,usrquota /dev/mapper/vg_as07-LogVol02 /home/
383
384 df
385
386 echo -e "\n"
387 echo -e "\033[0;32m Montando el sistema de ficheros con las opciones de usar cuotas de disco
.\033[0m"
388 mount
389 sleep 1
390 echo -e "\033[0;32m El sistema de archivos home está listo para soportar cuotas.\033[0m"
391 sleep 1
392
393 echo -e "\n"
394 echo -e "\033[0;32m Inicializando el contenido del fichero que lleva el control de la cuotas
.\033[0m"
395 quotacheck -m -u /home/
396 sleep 1
397 echo -e "\033[0;32m Comprobando que existe. \033[0m"
398 ls -l /home/
399 sleep 1
400
401 echo -e "\n"
402 echo -e "\033[0;32m Indicando al núcleo que esté preparado para gestionar la cuotas.\033[0m"

18
403 quotaon -uv /home/
404 sleep 1
405
406 echo -e "\n"
407 echo -e "\033[0;32m Comprobando que el SO está gestionando las cuotas.\033[0m"
408 quotaon -vuap
409
410
411 echo -e "\033[1;34m \n"
412 read -p " Presiona [ENTER] para continuar. " enterKey
413 echo -e "\033[0m"
414 }
415
416 # GESTIÓN DE USUARIOS : CUOTAS
417 # Función : Establecer cuota
418 function estCuota
419 {
420 cabecera "CUOTAS : ESTABLECER"
421 echo -e "\n \033[0m"
422
423 read -p " Usuario : " user
424
425 if [ -n "$user" ]; then
426 existUser=‘grep -E $user /etc/passwd | cut -d":" -f1‘
427 if [ -z "$existUser" ]; then
428 echo -e -n "\033[1;31m El usuario no existe. \033[0m"
429 else
430 read -p " Softlimit : " soft
431 read -p " Hardlimit : " hard
432 read -p " Ruta/Directorio : " directorio
433 [ -z "$soft" ] && soft="51200"
434 [ -z "$hard" ] && hard=‘expr $soft "+" 8800‘
435 [ -z "$directorio" ] && directorio="/home"
436 ‘setquota -u $user $soft $hard 0 0 $directorio‘
437 fi
438 else
439 echo -e -n "\033[1;31m No se ha introducido el usuario. \033[0m"
440 fi
441
442 sleep 1
443 }
444
445 # GESTIÓN DE USUARIOS : CUOTAS
446 # Función : Tiempo de gracia
447 function tgracia
448 {
449 cabecera "CUOTAS : T GRACIA"
450 echo -e "\n \033[0m"
451
452 read -p " Tiempo de gracia : " tgra
453 read -p " Ruta/Directorio : " directorio
454 [ -z "$tgra" ] && tgra="172800"
455 [ -z "$directorio" ] && directorio="/home/"
456 ‘setquota -t -u $tgra $tgra $directorio‘
457
458 sleep 1
459 }
460
461 # GESTIÓN DE USUARIOS : CUOTAS
462 # Función : Mostrar
463 function mostrarCuot
464 {
465 cabecera "CUOTAS : MOSTRAR"
466 echo -e "\n \033[0m"
467
468 repquota -u /home/
469
470 echo -e "\033[1;34m \n"
471 read -p " Presiona [ENTER] para continuar. " enterKey
472 echo -e "\033[0m"

19
473 }
474
475 # GESTIÓN DE USUARIOS : ACL
476 # Función : Preparar el sistema para el uso de ACL
477 function actACL
478 {
479 cabecera "PERMISOS/ACL : ACTIVAR"
480 echo -e "\n \033[0m"
481
482 echo -e "\033[0;32m Añadiendo soporte de ACL a un sistema de ficheros ya en uso:"
483 echo -e "/dev/mapper/vg_as07-LogVol02 /home/ \033[0m"
484 sleep 1
485 mount -t ext4 -o remount,usrquota,acl /dev/mapper/vg_as07-LogVol02 /home/
486
487 df
488
489 echo -e "\n"
490 echo -e "\033[0;32m Montando el sistema de ficheros con la opción ACL.\033[0m"
491 mount
492 sleep 1
493 echo -e "\033[0;32m El sistema de archivos está listo para utilizar ACL.\033[0m"
494
495 echo -e "\033[1;34m \n"
496 read -p " Presiona [ENTER] para continuar. " enterKey
497 echo -e "\033[0m"
498 }
499
500 # GESTIÓN DE USUARIOS : ACL
501 # Función : Introducimos un nuevo permiso a un grupo o usuario a un directorio o fichero
502 function introPerm
503 {
504 cabecera "PERMISOS/ACL : ACTIVAR"
505 echo -e "\n \033[0m"
506
507 read -n 1 -p " A un Usuario(u) o Grupo (g) : " user
508 echo -e "\n"
509 if [ -z "$user" ]; then
510 echo -e -n "\033[1;31m No se ha introducido el usuario. \033[0m"
511 else
512 read -p " Nombre del usuario/grupo/todos : " name
513 read -p " Permiso (rwx,-wx,r--,...) : " permiso
514 read -p " ruta/directorio : " directorio
515 [ -d "$directorio" ] && setfacl -R -m $user:$name:$permiso $directorio || echo -e -n "
\033[1;31m No existe directorio. \033[0m"
516 fi
517
518 }
519
520 # GESTIÓN DE USUARIOS : ACL
521 # Función : Elimina todas las ACL, añade los por defectos y de manera recursiva a sus directorios
522 function inicializa
523 {
524 cabecera "PERMISOS/ACL : INICIALIZAR"
525 echo -e "\n \033[0m"
526
527 read -p " ruta/directorio raíz a inicializar : " directorio
528 [ -d "$directorio" ] && setfacl -b -k -R $directorio || echo -e -n "\033[1;31m El directorio
no existe. \033[0m"
529
530 sleep 1
531 }
532
533 # GESTIÓN DE USUARIOS : ACL
534 # Función : Visualiza los permisos impuestos a un directorio
535 function mostrarACL
536 {
537 cabecera "PERMISOS/ACL : MOSTRAR"
538 echo -e "\n \033[0m"
539
540 read -p " ruta/directorio : " directorio

20
541 [ -d "$directorio" ] && getfacl $directorio || echo -e -n "\033[1;31m El directorio no existe
. \033[0m"
542
543 echo -e "\033[1;34m \n"
544 read -p " Presiona [ENTER] para continuar. " enterKey
545 echo -e "\033[0m"
546 }
547
548 #***********************************************************************************
549 # MENÚS
550 #***********************************************************************************
551
552 # MENÚ USUARIOS -----------------------
553 function menuUsu
554 {
555 cabecera USUARIOS
556
557 select opcionUsu in "Alta" "Baja" "Mostrar Usuarios" "Salir"
558 do
559 echo -e "\n \033[0m"
560 case "$opcionUsu" in
561 "Alta") altaUsu;;
562 "Baja") bajaUsu;;
563 "Mostrar Usuarios") MostrarUsu;;
564 "Salir") break;;
565 esac
566 break
567 done
568 }
569
570 # MENÚ GRUPOS -------------------------
571 function menuGru
572 {
573 cabecera GRUPOS
574
575 select opcionGru in "Alta" "Baja" "Añadir Usuario a Grupo" "Mostrar Grupo de Usuarios" "Salir"
576 do
577 echo -e "\n \033[0m"
578 case "$opcionGru" in
579 "Alta") altaGru;;
580 "Baja") bajaGru;;
581 "Añadir Usuario a Grupo") anadGruUsu;;
582 "Modificar Grupo a Usuario") modGruUsu;;
583 "Mostrar Grupo de Usuarios") MostrarGruUsu;;
584 "Salir") break;;
585 esac
586 break
587 done
588 }
589
590 # DIRECTORIOS -------------------------
591 function menuDir
592 {
593 cabecera DIRECTORIOS
594
595 select opcionDir in "Crear" "Borrar" "Modificar Propietario" "Mostrar Directorio" "Salir"
596 do
597 echo -e "\n \033[0m"
598 case "$opcionDir" in
599 "Crear") creaDir;;
600 "Borrar") borrarDir;;
601 "Modificar Propietario")modiOwnGruDir;;
602 "Mostrar Directorio") mostrarDir;;
603 "Salir") break;;
604 esac
605 break
606 done
607 }
608
609 # ACL ---------------------------------

21
610 function menuACL
611 {
612 cabecera PERMISOS
613
614 select opcionACL in "Activar" "Introducir Permiso" "Inicializar Directorio" "Mostrar ACL" "Salir
"
615 do
616 echo -e "\n \033[0m"
617 case "$opcionACL" in
618 "Activar") actACL;;
619 "Introducir Permiso") introPerm;;
620 "Inicializar Directorio") inicializa;;
621 "Mostrar ACL") mostrarACL;;
622 "Salir") break;;
623 esac
624 break
625 done
626 }
627
628 # PERMISOS ----------------------------
629 function menuPermiso
630 {
631 cabecera PERMISOS
632
633 select opcionPermiso in "ACL" "UNIX" "Salir"
634 do
635 echo -e "\n \033[0m"
636 case "$opcionPermiso" in
637 "ACL") menuACL;;
638 "UNIX") modiPermiso;;
639 "Salir") break;;
640 esac
641 break
642 done
643 }
644
645 # CUOTAS ------------------------------
646 function menuCuota
647 {
648 cabecera CUOTAS
649
650 select opcionCuota in "Activar" "Añadir" "Tiempo de Gracia" "Mostrar Cuotas" "Salir"
651 do
652 echo -e "\n \033[0m"
653 case "$opcionCuota" in
654 "Activar") actCuotas;;
655 "Añadir") estCuota;;
656 "Tiempo de Gracia") tgracia;;
657 "Mostrar Cuotas") mostrarCuot;;
658 "Salir") break;;
659 esac
660 break
661 done
662 }
663
664 # MENÚ PRINCIPAL ----------------------
665 while true
666 do
667 cabecera "GESTIÓN DE USUARIOS"
668
669 PS3="Elige una opción : "
670 select opcion in "Usuarios" "Grupos" "Directorios" "Permisos" "Cuotas" "Salir"
671 do
672 case "$opcion" in
673 "Usuarios") menuUsu;;
674 "Grupos") menuGru;;
675 "Directorios") menuDir;;
676 "Permisos") menuPermiso;;
677 "Cuotas") menuCuota;;
678 "Salir") clear

22
679 echo -e "\n \033[1m"
680 echo -n " Guardando los cambios... "
681 sleep 2
682 echo -e "\033[0m \n"
683 exit 2;;
684 esac
685 break
686 done
687 done

23
B. Limitación de horas de conexión
Con el fin de restringir que los usuarios utilizaran el sistema en determinados periodos de tiempo, bajo
un terminal concreto, aplicaciones, ... se utilizó el mecanismo PAM, Pluggable Authentication Modules.
En primer lugar, fue necesario editar el archivo “/etc/pam.d/login”, añadir un nuevo módulo
(pam_time) bajo la interfaz de account (la cual permitirá controlar la autenticación), con el indicador de
control required (que indica que el resultado del módulo debe ser exitoso para continuar con la auten-
ticación, pero si el módulo falla no se notifica al usuario hasta los otros módulos referenciados no se
verifiquen):

[alumno:0:~]$ vi /etc/pam.d/login
...
account required pam_time.so
...

Aclarar que este módulo se añadió justo antes del primer módulo con interfaz account existente.
Luego, se tuvo que editar el fichero “/etc/security/time.conf” para incorporar las restric-
ciones pertinentes. Estas restricciones tienen un formato (services;ttys;users;times) a seguir separados
por “;” cuyos campos son:

a) Primer campo: Servicios.

b) Segundo campo: Terminales.

c) Tercero campo: Usuarios.

d) Cuarto campo: Indicadores de tiempo.

Y algunas opciones de los indicadores de tiempo son:


Opciones Descripción : indicadores de tiempo
Mo Lunes Tu Martes We Miércoles
Th Jueves Fr Viernes Sa Sábado
Su Domingo Al Todos los días Wd Fin de Semana
wk De lunes a viernes

El ejemplo escogido en clase para verificar el funcionamiento del PAM, fue restringir al usuario usu5
el terminal tty3 para que sólo puediera hacer login los lunes de 18 a 23 horas.

[alumno:0:~]$ vi /etc/security/time.conf
login;tty3;usu5;Mo1800-2300

Para comprobarlo, se habrió el terminal tty3 (CTRL + F3) y se intentó autenticarse con usu5, el cual
no pudo hacerlo.

24