%\documentclass{beamer}
\documentclass[10pt]{beamer}
\mode<presentation>
{
  \usetheme{Warsaw}
  \setbeamercovered{transparent}
}

\usepackage[spanish]{babel}
\usepackage[utf8]{inputenc}
\usepackage{times}
\usepackage[T1]{fontenc}
%\usepackage{pdfpages}

\title[sudo] 
{La Herramienta sudo}

\subtitle[Admon Delegada]
{Administración Delegada de Servidores Linux}

\author
{Amaya Rodrigo}

\institute[MAP | Alanta]
{
  Ministerio de Administraciones Públicas\\
  Alanta OpenSource Technologies}

\date[Oct 2006]
{2 3 y 4 de Octubre, 2006}

\subject{Administración Delegada de Servidores Linux}

% Delete this, if you do not want the table of contents to pop up at
% the beginning of each subsection:
\AtBeginSubsection[]
{
  \begin{frame}<beamer>
    \frametitle{Índice}
    \tableofcontents[currentsection,currentsubsection]
  \end{frame}
}

% If you wish to uncover everything in a step-wise fashion, uncomment
% the following command: 
%\beamerdefaultoverlayspecification{<+->}

\begin{document}

\begin{frame}
  \titlepage
\end{frame}

\begin{frame}
  \frametitle{Índice}
  \tableofcontents
  % You might wish to add the option [pausesections]
\end{frame}

\section{Introducción}
\subsection[Presentación]{Presentación}

\begin{frame}
  \frametitle{Diferentes técnicas}

  Administración delegada de servidores Linux
  \begin{itemize}
   \item
     Permisos del sistema de archivos.
   \item
     La herramienta su
   \item
     Cuentas con uid 0
   \item
     Mediante ssh
   \item
     La herramienta sudo
   \item
     La herramienta sudosh
   \item
     La herramienta gksu
   \item
     \texttt{Peticiones especiales}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Objetivos}

  Convivencia de varios administradores
  \begin{itemize}
   \item
     Otorgar los permisos de forma granular
   \item
     Proteger la contraseña de root
   \item
     Evitar implicaciones serias de seguridad
   \item
     Permitir que el sistema se mantenga seguro, pero usable
   \item
     Monitorizar el uso de estos privilegios 
  \end{itemize}
\end{frame}

% ========================================================================
\section{Técnicas}
\subsection[Permisos Unix]{Permisos Unix}

\begin{frame}
  \frametitle{Permisos Unix}

  Los permisos de un archivo se definen según a quién se otorgan:
  \begin{itemize}
   \item 
     Al propietario del archivo
   \item
     A los miembros del grupo al que pertenece el archivo
   \item    
     Al resto de usuarios del sistema
  \end{itemize}
  Sólo el dueño de un archivo y root pueden cambiar los permisos
\end{frame}

\begin{frame}[fragile]
  \frametitle{Visualizar los permisos}
  Para visualizar los permisos, ejecutamos la orden \texttt{ls} con el parámetro \texttt{-l}
   \begin{block}{ls -l}
   \begin{columns}
   \begin{column}{11cm}
   \scriptsize
   \begin{semiverbatim}
 \$ ls -l
  -rw  -r-  -r--  1 tux1 users  4217 2006-09-29 15:40 archivo1
  -rw  -r-  -r--  1 tux2 users  4217 2006-09-29 15:40 archivo2
 drwx  r-x  r-x  1 tux1 users  4217 2006-09-29 15:40 directorio1
 ____  ___  ___  _ ____ _____  ____ ________________ ___________
   |    |    |   |  |     |      |          |             |
   u    g    a   | dueño grupo tamaño     mtime         nombre 
                 |
                  -> número de enlaces simbólicos que apuntan al archivo
   \end{semiverbatim}
  \end{column}
 \end{columns}
\end{block}
\end{frame}

\begin{frame}
  \frametitle{Permisos: Notación simbólica}
  archivos ordinarios
  \begin{itemize}
   \item
     \texttt{r} lectura: el archivo se puede leer
   \item
     \texttt{w} escritura: el archivo se puede modificar o borrar
   \item
     \texttt{x} ejecución: el archivo es ejecutable
  \end{itemize}
  directorios
  \begin{itemize}
   \item
     \texttt{r} lectura: se puede listar el contenido del directorio (ls)
   \item
     \texttt{w} escritura: se puede modificar el contenido del directorio
	\begin{itemize}
	\item
	permite crear, renombrar y borrar archivos
	\item
	aunque no se tenga permiso de escritura sobre el archivo
	\end{itemize}
   \item
     \texttt{x} ejecución: se puede entrar en el directorio (cd)
  \end{itemize}
\end{frame}
 
\begin{frame}[fragile]
  \frametitle{Permisos: Notación octal}
   \begin{block}{Notación Octal}
   \begin{columns}
   \begin{column}{11cm}
   \begin{semiverbatim}
 -rwx  r-x  ----               
 ____  ___  ___               r = 4
   |    |    |                w = 2
   |    |     -> 0+0+0=0      x = 1
   |    |                     
   |     -> 4+0+1=5           - = 0
   |                               
    -> 4+2+1=7   

    Los permisos son: 750
              
   \end{semiverbatim}
  \end{column}
 \end{columns}
\end{block}
\end{frame}

\begin{frame}
  \frametitle{Permisos: Combinaciones más comunes}
\texttt{600 (rw- ---- ----)} Archivos privados

\texttt{700 (rwx ---- ----)} Programas y directorios privados

\texttt{644 (rw- r--- r---)} Archivos legibles por todos

\texttt{666 (rw- rw- rw-)} Archivos modificables por todos 

\begin{centering}
{\small{(no muy común)}}
\par
\end{centering}

\texttt{777 (rwx rwx rwx)} Directorios públicos 

\begin{centering}
{\small{con permiso de escritura (/tmp)}}
\par
\end{centering}

\end{frame}

\begin{frame}
  \frametitle{Permisos especiales}
  El bit \texttt{SUID} (Switch UID)
  \begin{itemize}
   \item
     El programa se ejecuta con el UID y los permisos del propietario
   \item
     Suele usarse para poder ejecutar órdenes como root
   \item
     Suele aplicarse en el caso de ejecutables
   \item
     Carece de significado en directorios
   \item
     No sirve para scripts de shell (en algunos sistemas) 
  \end{itemize}
\end{frame}

\begin{frame}
\frametitle{Permisos especiales}
El bit \texttt{SGID} (Switch GID)
 \begin{itemize}
   \item
     En ejecutables:
     	\begin{itemize}
	\item
	 El programa se ejecuta con el UID y los permisos del grupo
	\end{itemize}
  \item
     En directorios:
        \begin{itemize}
	\item
	 Cualquier archivo/directorio creado en su interior conservará los
	 permisos del padre en lugar de los del usuario que lo crea.
	\end{itemize}
  \end{itemize}


Podemos encontrar estos archivos con la orden:


\texttt{find / -perm +6000 -ls}
\end{frame}

\begin{frame}
\frametitle{Permisos especiales}
El \texttt{Sticky Bit}
 \begin{itemize}
   \item
     En ejecutables:
     	\begin{itemize}
	\item
	 El programa no debe ser eliminado de la memoria tras ejecutarse.
	\item
	 Acelera posteriores ejecuciones del programa
	\item
	 También aumenta el consumo de memoria
	\item
	 En desuso, el kernel lo ignora
	\end{itemize}
  \item
     En directorios, incluso aunque haya permisos de escritura globales en el directorio:
        \begin{itemize}
	\item
	 Los usuarios sólo pueden borrar/modificar los archivos de los que son dueños
	\item
	 El dueño del directorio, en cambio, tiene acceso total a todo el contenido
	\end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Permisos: casos especiales}
   \begin{block}{Permisos de un enlace simbólico}
   \begin{columns}
   \begin{column}{11cm}
   \scriptsize
   \begin{semiverbatim}
\$ ls -l bin/vi
lrwxrwxrwx 1 root root 12 2003-12-18 01:50 bin/vi -> /usr/bin/vim

\$ ls -l /usr/bin/vim
-rwxr-xr-x 1 root root 1382568 2006-09-10 12:27 /usr/bin/vim

   \end{semiverbatim}
  \end{column}
 \end{columns}
\end{block}

Los permisos de los enlaces simbólicos parecen universales, pero no tienen efecto.
Los permisos reales son los del archivo al que apuntan.
\end{frame}

\begin{frame}[fragile]
\frametitle{Cambio de permisos: chmod}
  \begin{block}{Sintaxis de chmod}
  \begin{columns}
  \begin{column}{11cm}
	\scriptsize
    \begin{verbatim}
	chmod { [ugoa] {+-=} [rwx] | [ug] {+-=}s | [0] {+-w}t } archivo  

	chmod <octal> archivo
    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
  \begin{itemize}
   \item
    Admite notación octal o simbólica
   \item
   Los bits \texttt{SUID}, \texttt{SGID} y \texttt{Sticky} tienen parámetros especiales
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Cambio de permisos: propietarios}
\texttt{chown} permite cambiar los propietarios de un archivo
  \begin{block}{Sintaxis de chown}
  \begin{columns}
  \begin{column}{11cm}
    \begin{verbatim}
	chown [-R] usuario:grupo archivo
	chown [-R] usuario.grupo archivo
    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
\texttt{chgrp} permite cambiar el grupo a un archivo
  \begin{block}{Sintaxis de chgrp}
  \begin{columns}
  \begin{column}{11cm}
    \begin{verbatim}
	chgrp grupo archivo
    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
\end{frame}

\begin{frame}
  \frametitle{Conclusiones}
Ventajas
  \begin{itemize}
  \item
    Jugando con los permisos del sistema, podemos permitir a otros usuarios ejecutar órdenes como root, sin desvelar la contraseña
  \end{itemize}
Inconvenientes
  \begin{itemize}
  \item
    Es relativamente fácil escalar privilegios aprovechando un agujero de seguridad en un ejecutable con el bit suid activado
  \end{itemize}
Conviene extremar las precauciones
\end{frame}

% ========================================================================
\subsection[Cuentas con uid 0]{Cuentas con uid 0}
\begin{frame}[fragile] 
  \frametitle{Cuentas con uid 0}
  \begin{block}{}
  \begin{columns}
  \begin{column}{11cm}
    \begin{verbatim}
$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
root-carmen:x:0:0:root:/root:/bin/bash
root-jorge:x:0:0:root:/root:/bin/bash
jmartinez:x:0:0:root:/root:/bin/bash

    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
\end{frame}

\subsection[Claves ssh]{Claves ssh}
\begin{frame}[fragile] 
  \frametitle{Con claves de ssh}
\texttt{SSH} (Secure Shell) 
  \begin{itemize}
   \item
	Puede autentificar por clave pública, permitiendo ejecutar órdenes de root local o remotamente.
   \item
	Permite restringir privilegios forzando las órdenes con ssh.
   \end{itemize}

  \begin{block}{Restringir el acceso ssh}
  \begin{columns}
  \begin{column}{11cm}
    \footnotesize
    \begin{verbatim}
$ cat /root/.ssh/authorized_keys:
command="/usr/local/bin/programa" ssh-dss fky7Dj7bGYxdHRYuHN ...

$ ssh -l root -i ruta_clave_privada localhost

    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
\end{frame}

\begin{frame}
  \frametitle{Problemas}
Las cuentas con uid 0 y las claves públicas de ssh, constituyen un método:
  \begin{itemize}
  \item
    Fácil y rápido, pero aporta pocas ventajas
  \item
    Y muchos inconvenientes
	\begin{itemize}
	\item
	Es faćil perder la cuenta
	\item
	No es granular
	\item
	Difícil de registrar qué hace cada uno
	\end{itemize}
\end{itemize}
\end{frame}

% ========================================================================

\subsection[La Herramienta su]{La Herramienta su}
\begin{frame}
  \frametitle{La Herramienta su}
\texttt{su}: switch user

Permite cambiar a otro usuario cuando se está dentro de una sesión y en
particular ejecutar órdenes como root
  \begin{itemize}
  \item
   Pide la contraseña del usuario al cual se pretende cambiar
	\begin{itemize}
  	\item
	root puede ejecutar su y cambiar a cualquier usuario sin introducir
	ninguna contraseña
  	\end{itemize}
  \item
   Para salir, se puede usar \texttt{Ctrl-d}, \texttt{logout}, o \texttt{exit}
  \end{itemize}
Implica revelar la contraseña de root
\end{frame}


\begin{frame}[fragile] 
  \frametitle{La Herramienta su}
  \begin{block}{Sintaxis de su}
  \begin{columns}
  \begin{column}{11cm}
    \begin{verbatim}
    	su [-] [usuario] [-c orden]
    \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}

  \begin{itemize}
  \item
    Sin argumentos, se asume root 
  \item
    Seguido de un nombre de usuario, cambia a éste
  \item
    su con el argumento \texttt{-} importa el entorno del usuario de destino, como una
    shell de login
  \item
    Si se incluye el argumento \texttt{-c}, se ejecuta la instrucción unix que va detrás de -c con el usuario indicado
  \item
    Se puede configurar mediante PAM (Plugable Authentication Modules)
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{su: entorno de usuario}
Diferencias de una shell de root y una shell de root tipo login
    \begin{block}{su}
    \begin{columns}
    \begin{column}{11cm}
    \footnotesize
    \begin{verbatim}
$ env > /tmp/env.user
$ su
# env > /tmp/env.rootshell
# diff /tmp/env.user /tmp/env.rootshell
# exit
     \end{verbatim}
     \end{column}
     \end{columns}
     \end{block}
    \begin{block}{su -}
    \begin{columns}
    \begin{column}{11cm}
    \footnotesize
    \begin{verbatim}
$ su -
# env > /tmp/env.rootlogin
# diff /tmp/env.rootshell /tmp/env.rootlogin
# exit
     \end{verbatim}
     \end{column}
     \end{columns}
     \end{block}
\end{frame}

% ========================================================================

\section[La Herramienta sudo]{La Herramienta sudo}
\subsection{La Herramienta sudo}

\begin{frame}[fragile]
\frametitle{La Herramienta sudo}
	\begin{centering}%
	\pgfdeclareimage[width=4cm]{sandwich}{sandwich}
	\pgfuseimage{sandwich}
	  \par%
	  \end{centering}%
\end{frame}

\begin{frame}[fragile]
  \frametitle{La Herramienta sudo}
\texttt{sudo}: superuser do
  \begin{itemize}
    \item
    Permite ejecutar órdenes con permisos de root
    \item
    Pide la contraseña del propio usuario en lugar de la de root
\end{itemize}

\begin{block}{Ejemplo}
 \begin{columns}
 \begin{column}{10cm}
  \footnotesize
  \begin{semiverbatim}
\$ sudo vi /etc/shadow
We trust you have received the usual lecture from the local 
System Administrator. It usually boils down to these three 
things:

    #1) Respect the privacy of others.
    #2) Think before you type.
    #3) With great power comes great responsibility.

Password: \alert{(su propia contraseña de usuario)}
    \end{semiverbatim}
    \end{column}
   \end{columns}
  \end{block}
\end{frame}

\begin{frame}[fragile]
Si tux1 intenta usar sudo sin los permisos adecuados:
\begin{block}{Ejemplo}
 \begin{columns}
 \begin{column}{11cm}
  \begin{verbatim}
   $ sudo vi /etc/passwd
   Sorry, user tux1 is not allowed to execute 
   "/usr/bin/vi /etc/passwd" as root on www.map
   \end{verbatim}
    \end{column}
   \end{columns}
  \end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Diferencias con su}

  \begin{itemize}
      \item
      \texttt{su} da aceso a una consola de root, \texttt{sudo} se emplea dando el nombre del programa
      \item
      \texttt{su} pide la clave de root, \texttt{sudo} la del propio usuario
      \item
      \texttt{sudo} guarda un registro de las órdenes que ejecuta cada usuario
      \item
      \texttt{sudo} vuelve a pedir la contraseña cada X minutos (configurable)
\end{itemize}
Y muchas más...
\end{frame}

\begin{frame}[fragile]
  \frametitle{Un poco de historia}

  \begin{itemize}
    \item
     \texttt{1980}: Nace en el Departamento de Computer Science en SUNY/Buffalo
    \item
     \texttt{1991}: se relicencia bajo GPL
    \item
     \texttt{1999}: se reescribe y relicencia bajo ISC (parecida a la BSD)
    \item
    Última versión:
	\begin{itemize}
	\item
	\texttt{sudo 1.6.8p12}, 8 de Noviembre, 2005
	\item
	software muy estable y probado
	\item
	Pocos cambios, sólo problemas de seguridad
	\item
	Licencia \texttt{ISC-style}, tipo BSD 
	\end{itemize}
   \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Instalación}
Se puede obtener
    \begin{itemize}
      \item
	Un paquete binario, con la propia distribución (recomendado)
      \item
	Compilar e instalar el código fuente
	\begin{itemize}
        \item
	Requiere conocimientos avanzados
        \item
	Puede tener resultados imprevisibles
	\item
	Pero hay parémetros que sólo se pueden cambiar recompilando
		\begin{itemize}
		\item
		Lo mejor es obtener los paquetes fuentes de la distribución que estemos usando
		\end{itemize}
	\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{/usr/sbin/sudo}
El propio \texttt{sudo} es un binario de tipo \texttt{suid}
    \begin{block}{Permisos}
    \begin{columns}
    \begin{column}{11cm}
    \scriptsize
    \begin{verbatim}
---s--x--x    1 root     root        81644 Jan 14 15:36 /usr/bin/sudo
    \end{verbatim}
    \end{column}
    \end{columns}
    \end{block}

\begin{itemize}
	\item
	La \texttt{s} significa que es un programa suid
	\item
	Con permisos de ejecución para todos
	\item
	Al ejecutarlo, y pertenecer a root, se ejecuta con permisos de root
	\item
	Si lo invocáramos para abrir una shell, nos convertiríamos en root
        \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración}
\texttt{/etc/sudoers}
	\begin{itemize}
	\item
	Enumera qué usuarios pueden ejecutar qué órdenes
	\item
	Se pueden definir macros para reducir la complejidad
	\end{itemize}

    \begin{block}{Sintaxis de /etc/sudoers}
    \begin{columns}
    \begin{column}{11cm}
    \scriptsize
    \begin{verbatim}
$ ls -l /etc/sudoers
-r--r----- 1 root root 1189 2006-02-09 21:42 /etc/sudoers

$ cat /etc/sudoers
# Sintaxis básica de /etc/sudoers
# user  host = commands
User_Alias OPERATORS = tux1, tux2, tux3
Host_Alias WEBSERVERS = www, www-1, www-3
Cmnd_Alias PRINTCMNDS = /usr/bin/printtool, /usr/bin/lpq
tux1 WEBSERVERS = (root) /sbin/service/httpd restart
OPERATORS printssvr = (root) PRINTCMNDS
    \end{verbatim}
    \end{column}
    \end{columns}
    \end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración}

    \begin{block}{Sintaxis de /etc/sudoers}
    \begin{columns}
    \begin{column}{11cm}
    \scriptsize
    \begin{verbatim}
$ cat /etc/sudoers
# Hacemos alias, que es la forma normal de trabajar con sudo:
User_Alias	WEBROOT = tux1
Host_Alias	WEBSERVER = webserver.dmz
Cmnd_Alias	SERVICES = /etc/init.d/httpd,/etc/init.d/named,/etc/init.d/sshd
Cmnd_Alias	COMMAND = /bin/mount

# Traduccion: Los usuarios dentro de WEBROOT, en el HOST WEBSERVER,
# pueden ejecutar los servicios SERVICES.
WEBROOT WEBSERVER = SERVICES,COMMAND
WEBROOT WEBSERVER = NOPASSWD: SERVICES,COMMAND

# Usuarios sin restricciones
tux2	ALL=(ALL) NOPASSWD: ALL
tux3	ALL=(ALL)ALL

# Añadimos un log 
Defaults logfile=/var/log/sudo.log, log_year, mail_badpass, \
      mailto=tux3@localhost
    \end{verbatim}
    \end{column}
    \end{columns}
    \end{block}

\end{frame}

\begin{frame}[fragile]
  \frametitle{visudo}
    \begin{block}{Sintaxis de visudo}
    \begin{columns}
    \begin{column}{9cm}
    \scriptsize
    \begin{verbatim}
visudo [ -c ] [ -f sudoers ] [ -q ] [ -s ] [ -V ]
    \end{verbatim}
    \end{column}
    \end{columns}
    \end{block}

\texttt{-c} comprueba la sintaxis (devuelve 0 ó 1)

\texttt{-f} ruta al archivo sudoers

\texttt{-q} modo silencioso 
		\begin{itemize}
		\item
		No imprime los errores
		\item
		se usa junto a \texttt{-c}
		\item 
		se usa en scripts: \texttt{visudo -cq} 
			\begin{itemize}
			\item
			el valor de salida se almacena en \texttt{\$?}
			\end{itemize}
		\end{itemize}


\texttt{-s} comprobación estricta

\texttt{-f} ruta al archivo sudoers

\texttt{-V} nos da la versión

\end{frame}

\begin{frame}[fragile]
  \frametitle{visudo}
\begin{itemize}
\item
Al ejecutar \texttt{visudo} se crea el archivo \texttt{/etc/sudoers.tmp}
	\begin{itemize}
	\item
	Indica que el fichero está en uso 
	\item	
	Impide que varias personas lo editen a la vez
	\end{itemize}
\item
Antes de guadar \texttt{/etc/sudoers}, se realizan comprobaciones de sintaxis
\item
El editor se puede configurar con la variable \texttt{\$EDITOR}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Sintaxis de sudo}

\begin{block}{Opciones}
  \begin{columns}
  \begin{column}{11cm}
  \begin{verbatim}
    sudo -K | -L | -V | -h | -k | -l | -v
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\texttt{-H} la variable \texttt{\$HOME} cambia a la del usuario de destino. Por defecto se conserva el \texttt{\$HOME} del usuario de origen

\texttt{-K} la contraseña es borrada de la memoria por completo

\texttt{-L} lista los valores existententes en la línea Defaults

\texttt{-V} (como usuario) Da la versión de sudo

\texttt{-V} (como root) Da más información. Valores por defecto, opciones de compilación, info de la máquina

\texttt{-h} muestra la ayuda


\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}
\texttt{-l} nos muestra lo permitido o prohibido para nuestro usuario en este host

\begin{block}{Listar los permisos}
  \begin{columns}
  \begin{column}{11cm}
  \scriptsize
  \begin{verbatim}
$ sudo -l
User swift may run the following commands on this host:
    (root)   /usr/libexec/xfsm-shutdown-helper
    (root)   /usr/bin/emerge
    (root)   /usr/bin/passwd [a-zA-Z]*
    (root)   !/usr/bin/passwd root
    (apache) /usr/bin/pkill
    (apache) /bin/kill
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}

\texttt{-k} la contraseña es borrada de la memoria
	\begin{itemize}
	\item
	revocar privilegios desde el .bash\_logout
	\end{itemize}

\texttt{-v} refresca el timestamp de la contraseña. Si es necesario, la pide. Si no ha caducado, no.

\begin{block}{Prolongar el tiempo de expiración de la contraseña}
  \begin{columns}
  \begin{column}{11cm}
  \begin{verbatim}
 $ sudo -v
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\small
Por defecto, si un usuario ha introducido su contraseña para autenticarse ante
sudo, ésta es recordada durante 5 o 15 minutos, según el sistema, o el
\texttt{/ect/sudoers}.  Si el usuario quiere prolongar este periodo, puede
ejecutar sudo -v para reiniciar la marca de tiempo de modo que pasen otros
cinco minutos antes de que sudo pregunte de nuevo por la contraseña.

Lo contrario es matar la marca de tiempo usando sudo \texttt{-k}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}
\begin{block}{Parámetros completos}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
sudo 
[-HPSb] [-a auth_type] [-c class|-] [-p prompt] [-u username|#uid] {-e file [...] | -i | -s | command}
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\texttt{-S} lee la contraseña de stdin

\texttt{-b} ejecuta la orden en segundo plano

\texttt{-a} tipo de autentificación (\texttt{/etc/login.conf})
	\begin{itemize}
	\item
	usando el parámetro \texttt{auth-sudo} en \texttt{/etc/login.conf}
	\item
	sudo compilado con \texttt{--with-bsdauth} 
	\end{itemize}

\texttt{-c class} la orden se ejecuta con el límite de recursos definido en \texttt{/etc/login.conf} para la clase class

\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}
\texttt{-p} Personaliza cómo pedimos la contraseña
	\begin{itemize}
	\item
	\texttt{\%u} login del usuario
	\item
	\texttt{\%U} login del usuario de destino
	\item
	\texttt{\%h} nombre de la máquina
	\item
        \texttt{\%H} fqdn: nombre de la máquina con dominio
        \item
        \texttt{\%\%} Pinta un \texttt{\%}
	\end{itemize}

\begin{block}{Prompt personalizado}
  \begin{columns}
  \begin{column}{9cm}
  \begin{verbatim}
$ sudo -p  %u@%h:  ls
tux1@www:
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}
\begin{block}{Parámetros completos}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
sudo
[-HPSb] [-a auth_type] [-c class|-] [-p prompt] [-u username|#uid] {-e file [...] | -i | -s | command}
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\texttt{-u usuario} ejecuta la orden como el usuario especificado

\texttt{-e archivo} no se ejecuta una orden, se edita el archivo indicado:
        \begin{itemize}
        \item
	se hacen copias temporales del archivo a editar
        \item
	se editan los archivos temporales 
		\begin{itemize}
		\item
		con el editor indicado por \texttt{\$HOME}
		\item
		con el editor indicado en \texttt{/etc/sudoers} (variable \texttt{editor})
		\end{itemize}
        \item
	Si se guardan los cambios, los archivos editados sustituyen a los reales.
        \item
	Si el archivo no existe, se crea
        \item
	En caso de error, o si no se puede guardar, se avisa al usuario y se
	conservan los temporales
	\end{itemize}

Es indiferente invocar \texttt{sudoedit} o \texttt{sudo -e}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Parámetros}
\begin{block}{Parámetros completos}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
sudo
[-HPSb] [-a auth_type] [-c class|-] [-p prompt] [-u username|#uid] {-e file [...] | -i | -s | command}
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}

\texttt{-i} simula un login inicial
	\begin{itemize}
	\item
	con la shell del usuario según dicte \texttt{/etc/passwd}
	\item
	\texttt{sudo} intenta entrar en el \texttt{\$HOME} del usuario de destino
	\item
	inicializa el entorno, conservando la variable \texttt{\$TERM}, pero
	cambia \texttt{\$HOME}, \texttt{\$SHELL}, \texttt{\$USER},
	\texttt{\$LOGNAME}, y \texttt{\$PATH}
        \end{itemize}

\texttt{-s} ejecuta la shell definida por \texttt{\$SHELL} o en \texttt{/etc/passwd}

\end{frame}

\begin{frame}[fragile]
  \frametitle[sudo]{sudo}
\begin{itemize}
\item
\texttt{sudo} realiza una comprobación del entorno antes de ejecutarse
\item
Al ejecutarlo con \texttt{-V}, muestra las variables de entorno que comprueba
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle[sudo]{sudo}
\begin{block}{}
  \begin{columns}
  \begin{column}{11cm}
  \scriptsize
  \begin{verbatim}
Sudo version 1.6.4
 [...]
Environment variables to check for sanity:
        LANGUAGE
        LANG
        LC_*
Environment variables to remove:
        BASH_ENV
        ENV
        TERMCAP
        TERMPATH
        TERMINFO_DIRS
        TERMINFO
        _RLD*
        LD_*
        PATH_LOCALE
        NLSPATH
        HOSTALIASES
        RES_OPTIONS
        LOCALDOMAIN
        IFS
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Variables de entorno} 
\footnotesize
\texttt{sudo} utiliza las siguientes variables de entorno:

\texttt{\$EDITOR} editor por defecto para usar con \texttt{-e} o \texttt{sudoedit} si \texttt{\$VISUAL} está vacía

\texttt{\$HOME} qué valor usar con \texttt{-s} o \texttt{-H} 
	\begin{itemize}
	\item
	si se compiló con la opción \texttt{--enable-shell-sets-home}, el del usuario de destino
	\end{itemize}

\texttt{\$PATH} se examina, y se limpia si se compiló con la opción \texttt{--with-secure-path}

\texttt{\$SHELL} qué shell ejecutar ocn la opción \texttt{-s}

\texttt{\$SUDO\_PROMPT} prompt de contraseña por defecto

\texttt{\$SUDO\_COMMAND} orden a ejecutar por sudo

\texttt{\$SUDO\_USER} login usuario que ejecuta \texttt{sudo}

\texttt{\$SUDO\_UID} el del usuario que ejecuta \texttt{sudo}  

\texttt{\$SUDO\_GID} el del usuario que ejecuta \texttt{sudo}  

\texttt{\$SUDO\_PS1} prompt o símobolo del sistema

\texttt{\$USER} usuario de destino por defecto (root o el indicado con \texttt{-u})

\texttt{\$VISUAL} editor por defecto para usar con \texttt{-e / sudoedit}

\end{frame}
\begin{frame}[fragile]
  \frametitle{Variables de entorno} 
\scriptsize
\texttt{sudo} borra las siguientes variables de entorno, para protegernos: 
\begin{block}{Variables peligrosas}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
     IFS
     LOCALDOMAIN
     RES_OPTIONS
     HOSTALIASES
     NLSPATH
     PATH_LOCALE
     TERMINFO
     TERMINFO_DIRS
     TERMPATH
     TERMCAP
     ENV
     BASH_ENV
     LC_  (si contiene '/' o '%')
     LANG (si contiene '/' o '%')
     LANGUAGE (si contiene '/' o '%')
     LD_*
     SHLIB_PATH (solo HP-UX)
     LIBPATH (solo AIX)
     KRB_CONF (solo kerberos4)
     KRBCONFDIR (solo kerberos4)
     KRBTKFILE (solo kerberos4)
     KRB5_CONFIG (solo kerberos5)
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle[sudoers]{Sintaxis de /etc/sudoers}

\begin{itemize}
\item
Dos tipos de entradas
	\begin{itemize}
	\item
	Alias: son variables
	\item
	Especificaciones de usuario: quién ejecuta qué
	\end{itemize}
\item
Cuando varias reglas afectan a un usuario, se aplican por orden
\item
En caso de conflicto, se aplica la última
\item
Se usa la gramática \texttt{Extended Backus-Naur Form (EBNF)}. 
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle[sudoers]{Guía rápida de EBNF}

EBNF es una forma concisa y exacta de describir la gramática de un lenguaje.
Cada definición de EBNF se compone de reglas:


\texttt{symbol ::= definition | alternate1 | alternate2 }


Cada regla hace referencia a otras reglas, se forma una gramática para el lenguaje


Operadores (iguales que en las expresiones regulares)
\begin{itemize}
\item
\texttt{?} El símbolo anterior (o grupo de símbolos) es opcional, puede aparecer una vez o ninguna.
\item
\texttt{*} El símbolo anterior (o grupo de símbolos) puede aparecer cero o más veces.
\item
\texttt{+} El símbolo anterior (o grupo de símbolos) puede aparecer una o más veces.
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle[sudoers]{Sintaxis de /etc/sudoers}
Los alias se definen así 



\texttt{Alias\_Type NAME = item1, item2, ...}




Tipos de Aliases
\begin{itemize}
\item
\texttt{User\_Alias} 
\item
\texttt{Runas\_Alias} 
\item
\texttt{Host\_Alias} 
\item
\texttt{Cmnd\_Alias} 
\end{itemize}

\end{frame}

\begin{frame}[fragile]
  \frametitle[sudoers]{Sintaxis de /etc/sudoers}

\texttt{User\_Alias} 

\begin{itemize}
\item
	Uno o más nombres de usuario.
\item
	grupos del sistema: se indican con \texttt{\%}
\item
	Se puede usar el operador \texttt{!} 
		\begin{itemize} 
		\item
		Número impar de \texttt{!} -> niega 
		\item
		Número par de \texttt{!} -> se cancelan entre ellos 
		\end{itemize}
\end{itemize}

\texttt{Runas\_Alias} 

\begin{itemize}
\item
Se parece a \texttt{User\_Alias}, pero también puede contener uids
\item
Los uids llevan el prefijo \texttt{\#}
\item
Los nombres de usuario y grupo se comparan en cadenas completas, su valor
numérico no tiene efecto:
	\begin{itemize}
	\item
	Dos usuarios (o grupos) con el mismo uid (o gid) se consideran
	diferentes
	\item
	Para denotar a todos los usuarios con el mismo uid a la vez, se puede
	usar el valor númerico de su uid:
	\item
	Si el usuario root tiene uid 0 y el usuario toor tiene también uid 0,
	se puede referenciar a ambos con: \texttt{\#0}
	\end{itemize}
\end{itemize}

\end{frame}

\begin{frame}[fragile]
  \frametitle[sudoers]{Sintaxis de /etc/sudoers}
\texttt{Host\_Alias} 
\begin{itemize}
\item
Nombres de host, direcciones IP, o redes.
Las máscaras de red:
\item
Notación numérica: 255.255.255.0
\item
Número de bits: /24 
\end{itemize}

\texttt{Cmnd\_Alias} 
\begin{itemize}
\item
Lista de órdenes, directorios o aliases.
\item
Las órdenes pueden incluir "asteriscos", y la ruta completa. 
\item
Con \texttt{""} indicamos que sólo se puede ejecutar \alert{sin} arcgumentos.
\item
Una ruta del tipo: \texttt{/usr/bin/} indica un directorio. Se pueden ejecutar
las órdenes en ese directorio, pero no en los subdirectorios que haya en él.
\item
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Los valores por defecto}
Se pueden cambiar algunos parámetros de configuración sin recompilar, cambiando
las directivas por defecto: Se pueden cambiar para todos los usuarios, en
cualquier máquina, usuarios específicos de una máquina, un usuario específico,
o sólo órdenes ejecutadas por un usuario en concreto.
\begin{block}{}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}

        Default_Type ::= ’Defaults’ |
                         ’Defaults’ ’@’ Host |
                         ’Defaults’ ’:’ User |
                         ’Defaults’ ’>’ RunasUser

        Default_Entry ::= Default_Type Parameter_List

        Parameter_List ::= Parameter |
                           Parameter ’,’ Parameter_List

        Parameter ::= Parameter ’=’ Value |
                      Parameter ’+=’ Value |
                      Parameter ’-=’ Value |
                      ’!’* Parameter

  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Los valores por defecto}
\begin{block}{Modificar el entorno}
  \begin{columns}
  \begin{column}{11cm}
  \footnotesize
  \begin{verbatim}
# /etc/sudoers file.

Defaults:tux1    timestamp_timeout=-1, env_delete+="BOOP"
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
  \begin{itemize}
  \item
\texttt{+=} Añade al entorno
  \item
\texttt{=} Sobreescribe el entorno 
  \item
\texttt{-=} Quita del entorno
  \item
\texttt{timestamp\_timeout=0} La contraseña no será recordada
  \item
\texttt{timestamp\_timeout=-1} Sólo se pedirá la contraseña una vez, será recordada, aunque salga de la sesión.
	\begin{itemize}
	\item
	hasta reiniciar el sistema
	\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{ignore\_dot}: ignorar \texttt{.} o \texttt{’’} (directorio actual en el
\texttt{PATH}. \alert{Por defecto sí}. No se puede cambiar. \alert{Para uso
futuro}.

\item
\texttt{mail\_always}: envia email cada vez que un usuario ejecuta sudo.  \alert{Por defecto no}.

\item
\texttt{mail\_badpass}: envia email cada vez que un usuario se equivoca con la
contraseña. \alert{Por defecto no}.

\item
\texttt{mail\_no\_user}: envia email si el usuario no está en el
\texttt{sudoers}. \alert{Por defecto sí}.

\item
\texttt{mail\_no\_host}: envia email si el usuario está en el \texttt{sudoers},
pero no puede ejecutar órdenes en este host. \alert{Por defecto no}.

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{mail\_no\_perms}: envia email si el usuario está en el
\texttt{sudoers}, pero no puede ejecutar la orden que intentó ejecutar.
\alert{Por defecto no}.

\item
\texttt{tty\_tickets}: obliga al usuario a poner la contraseña en cada terminal
que use sudo. \alert{Por defecto no}. Lo normal es tener un timestamp por
usuario sin que importe el terminal. \alert{Por defecto no}.

\item
\texttt{authenticate}: exige contraeña antes de ejcutar nada. Admite
variaciones con los parámetros: \texttt{PASSWD} y \texttt{NOPASSWD}.
\alert{Por defecto sí}. 

\item
\texttt{root\_sudo}: root puede usar sudo. Si se deshabilita impide que los
usuarios encadenen órdenes apra obtener root: \texttt{sudo sudo /bin/sh} o que
root ejecute \texttt{sudo} y \texttt{sudoedit}. \alert{Sólo existe por motivos
históricos}. No aporta mayor seguridad. \alert{Por defecto sí}.
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{log\_host}: el nombre de host se registrará en el archivo de log de
\texttt{sudo}. \alert{Por defecto no}.

\item
\texttt{log\_year}: Uso de los 4 dígitos del año. \alert{Por defecto no}.

\item
\texttt{shell\_noargs}: ejecuta una shell de root si no se dan parámetros al
ejecutar \texttt{sudo}. \alert{Por defecto no}. Actúa como \texttt{sudo -s}

\item
\texttt{set\_home}: en caso de ejecutar \texttt{sudo -s} ls variable de entorno
\texttt{HOME} cambia a la del usuario de destino. Fuerza que \texttt{sudo -s}
implique además \texttt{sudo -H}. \alert{Por defecto no}.

\item
\texttt{always\_set\_home}: establece que la variabe de entorno \texttt{HOME}
cambie a la del usuario de destino. \alert{Por defecto no}.
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{path\_info}: da información sobre el contenido del \texttt{PATH} autorizado:
	\begin{itemize}
	\item
	habilitado: le dice al usuario que la orden no está en el \texttt{PATH}
	\item
	deshabilitado: le dice al usuario que no tiene permiso (confunde al usuario).
	\item
	\alert{Por defecto no}.
	\end{itemize}

\item
\texttt{fqdn}: si vamos a usar fqdn en el archivo. Si el dns deja de funcionar,
(p.e: no hay red) sudo también deja de funcionar. Ignora los alias (CNAME).
\alert{Por defecto sí}. 

\item
\texttt{insults}: insulta a los usuarios si se equivocan de contraseña.
\alert{Por defecto no}.

\item
\texttt{requiretty}: impide ejecutar sudo a no ser que se esté en un terminal.
Se habilita porque en ciertos terminales no "reales" se ve la contraseña.
\alert{Por defecto no}.
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{env\_editor}: fuerza a usar un editor, ignorando la variabe de entorno
\texttt{EDITOR} o \texttt{VISUAL}. Lista de editores, separada por \texttt{:}
\alert{Por defecto sí}.

\item
\texttt{rootpw}: pide la clave de root en vez de la del usuario. \alert{Por
defecto no}.

\item
\texttt{runaspw}: pide la conraseña del usuario de destino que indica
\texttt{runas}. \alert{Por defecto no}.  

\item
\texttt{targetpw}: pide la conraseña del usuario de destino. \alert{Por defecto
no}.

\item
\texttt{env\_reset}: borra el entorno y lo restringe:  \texttt{HOME},
\texttt{LOGNAME}, \texttt{PATH}, \texttt{SHELL}, \texttt{TERM}, \texttt{USER} y
\texttt{SUDO\_*}. Sólo \texttt{TERM} se copia del entorno original.

\item
\texttt{noexec}: Impide ejecutar órdenes desde un editor u otro programa que
permita salir a una shell. \alert{Por defecto no}.
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}

Valores numéricos:
\begin{itemize}
\item
\texttt{passwd\_tries}: número de intentos fallidos permitidos. \alert{Por
defecto 3}.

\item
\texttt{timestamp\_timeout}: minutos en que expira la contraseña. \alert{Por
defecto 15}.
\end{itemize}

Cadenas:
\begin{itemize}
\item
\texttt{mailsub}: Asunto del email: Por defecto: \texttt{*** SECURITY
information for \%h ***}

\item
\texttt{badpass\_message}: se muestra cuando el usuario se equivoca de
contraseña. Por defecto: \texttt{Sorry, try again}. A no ser que se habiliten
los insultos.

\item
\texttt{runas\_default}: usuario de destino. Por defecto: \texttt{root}.

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}
\item
\texttt{passprompt}: cambia la cadena de petición de contraseña. Por defecto: \texttt{Password:}.
        \begin{itemize}
        \item
        \texttt{\%u} login del usuario
        \item
        \texttt{\%U} login del usuario de destino
        \item
        \texttt{\%h} nombre de la máquina
        \item
        \texttt{\%H} fqdn: nombre de la máquina con dominio
        \item
        \texttt{\%\%} Pinta un \texttt{\%}
        \end{itemize}

\item
\texttt{editor}: Por defecto: \texttt{vi}.

\item
\texttt{lecture}: instrucciones antes de pedir la contraseña:
	\begin{itemize}
        \item
        \texttt{never} nunca
        \item
        \texttt{once} la primera vez
        \item
        \texttt{always} siempre
        \end{itemize}

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Los valores por defecto}
\begin{itemize}

\item
\texttt{lecture\_file}: ruta completa al archivo que contiene las instrucciones

\item
\texttt{lecture\_file}: ruta completa al archivo que contiene las instrucciones

\item
\texttt{logfile}: ruta completa al archivo donde queramos que quede el registro

\item
\texttt{mailerpath}: ruta completa al binario del servidor de correo

\item
\texttt{mailerflags}: parámetros con que invocar el binario del servidor de
correo. Por defecto: \texttt{-t}

\item
\texttt{mailto}: email del encargado de recibir los avisos

\item \texttt{exempt\_group}: grupo exento de contraseña y comprobaciones de
\texttt{PATH}. Por defecto, grupo \texttt{sudo}

\item \texttt{listpw}: pide contraseña para una opción que normalmente no la
necesita: \texttt{sudo -l}

\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{/etc/sudoers}

  \tiny
  \begin{verbatim}
        # User alias specification
        User_Alias     FULLTIMERS = millert, mikef, dowdy
        User_Alias     PARTTIMERS = bostley, jwfox, crawl
        User_Alias     WEBMASTERS = will, wendy, wim

        # Runas alias specification
        Runas_Alias    OP = root, operator
        Runas_Alias    DB = oracle, sybase

        # Host alias specification
        Host_Alias     SPARC = bigtime, eclipse, moet, anchor :\
                       SGI = grolsch, dandelion, black :\
                       ALPHA = widget, thalamus, foobar :\
                       HPPA = boa, nag, python
        Host_Alias     CUNETS = 128.138.0.0/255.255.0.0
        Host_Alias     CSNETS = 128.138.243.0, 128.138.204.0/24, 128.138.242.0
        Host_Alias     SERVERS = master, mail, www, ns
        Host_Alias     CDROM = orion, perseus, hercules

        # Cmnd alias specification
        Cmnd_Alias     DUMPS = /usr/bin/mt, /usr/sbin/dump, /usr/sbin/rdump,\
                               /usr/sbin/restore, /usr/sbin/rrestore
        Cmnd_Alias     KILL = /usr/bin/kill
        Cmnd_Alias     PRINTING = /usr/sbin/lpc, /usr/bin/lprm
        Cmnd_Alias     SHUTDOWN = /usr/sbin/shutdown
        Cmnd_Alias     HALT = /usr/sbin/halt
        Cmnd_Alias     REBOOT = /usr/sbin/reboot
        Cmnd_Alias     SHELLS = /usr/bin/sh, /usr/bin/csh, /usr/bin/ksh, \
                                /usr/local/bin/tcsh, /usr/bin/rsh, \
                                /usr/local/bin/zsh
        Cmnd_Alias     SU = /usr/bin/su
  \end{verbatim}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración}
\begin{block}{Definir valores por defecto}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
        # Override built-in defaults
        Defaults               syslog=auth
        Defaults>root          !set_logname
        Defaults:FULLTIMERS    !lecture
        Defaults:millert       !authenticate
        Defaults@SERVERS       log_year, logfile=/var/log/sudo.log
  \end{verbatim}
  \end{column}
  \end{columns}
\end{block}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración I}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}

# Host alias specification

# User alias specification
Runas_Alias OP = root

# Cmnd alias specification
Cmnd_Alias ADMIN
= /usr/bin/apt-get, /usr/bin/dpkg, /bin/mv, /bin/cp, /usr/bin/nbtscan, \
			/sbin/reboot, /etc/init.d/*, /usr/bin/tail, /bin/ping
Cmnd_Alias ADMIN_NOPASS = /bin/kill, /usr/bin/lsof, /usr/sbin/iptraf
Cmnd_Alias ADMIN_NOEXEC = /usr/bin/more, /usr/bin/vi, /usr/bin/less

Cmnd_Alias OPERADOR
= /usr/bin/nbtscan, /sbin/reboot, /etc/init.d/*, /usr/bin/tail, /bin/ping
Cmnd_Alias OPERADOR_NOPASS = /bin/kill, /usr/bin/lsof, /usr/sbin/iptraf
Cmnd_Alias OPERADOR_NOEXEC = /usr/bin/more, /usr/bin/less

# User privilege specification
root    ALL=(ALL) ALL
tecnico ALL=(OP) ADMIN, (OP) NOPASSWD: ADMIN_NOPASS, (OP) NOEXEC:
ADMIN_NOEXEC
#hector  ALL=(OP) OPERADOR, (OP) NOPASSWD: OPERADOR_NOPASS, (OP) NOEXEC:
OPERADOR_NOEXEC

  \end{verbatim}
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración II}
  \tiny
  \begin{verbatim}
# Host alias specification
Host_Alias SERVERS=+sun-servers
Host_Alias BUSOPS=HOST1,HOST2,HOST3
Host_Alias HPCLIENTS=+NETGROUP1
Host_Alias IOTCHOSTS=HOST4,HOST5,HOST6
# Cmnd alias specification
Cmnd_Alias REBOOT=/etc/reboot,/etc/halt
Cmnd_Alias LPCS=/usr/ucb/lpc,/usr/etc/lpc,/usr/ucb/lprm
Cmnd_Alias CAPSTUFF=/usr/local/cap/etc/stop-cap-servers, 
			/usr/local/cap/etc/start-cap-servers
Cmnd_Alias INTERNCMD=/usr/local/bin/changepassword, 
			/usr/local/etc/mkaliases,
			/usr/local/etc/mkhosts, 
			/usr/local/bin/pprdist,
			/usr/local/etc/nismake, 
			/usr/local/bin/edadmin,
			/usr/local/bin/chuser, 
			/usr/ucb/lpc,
			/usr/etc/lpc,/usr/ucb/lprm, 
			/usr/local/cap/etc/stop-cap-servers, 
			/usr/local/cap/etc/start-cap-servers
Cmnd_Alias HTTP=/app/http/httpd_1.4/restart_httpd
Cmnd_Alias HTTP1=/app/http/httpd_1.4/start_httpd
  \end{verbatim}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración III}
  \tiny
  \begin{verbatim}
Cmnd_Alias SHELLS=/bin/sh,/sbin/sh,/sbin/jsh,/usr/bin/sh, 
			/bin/csh,/usr/bin/csh,
			/bin/ksh,/usr/bin/ksh, 
			/usr/local/share/bin/tcsh,
			/usr/local/share/bin/bash, 
			/usr/local/bin/tcsh,
			/usr/local/bin/bash
Cmnd_Alias SU=/bin/su,/usr/bin/su

# User specification
# Sysadmins
sa1 ALL=ALL
sa2 ALL=ALL
# machine drew
drews-a1 drew=ALL
drews-a2 drew=ALL

  \end{verbatim}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración IV}
  \tiny
  \begin{verbatim}
# DNS functions
#
dns-sa1 HOST1=ALL:+HOST1-sun-clients=ALL
dns-sa2 HOST1=/usr/local/bin/DNSpush:+HOST1-sun-clients=ALL
dns-sa3 HOST1=/usr/local/bin/DNSpush:+HOST1-sun-clients=ALL
# Remote Sysadmins
REM1-sa1 ALL=ALL
REM2-sa2 REMOTEHOSTS=ALL:REMOTECLIENTS=ALL:ALL=INTERNCMD
REM3-sa1 ALL=ALL
REM3-sa2 ALL=INTERNCMD
REM4-sa1 REM4HOSTS=ALL:ALL=INTERNCMD
REM4-sa2 REM4HOSTS=ALL:ALL=INTERNCMD
REM5-sa1 REM5HOSTS=ALL:ALL=INTERNCMD
# Intern Admins
intern-sa1 ALL=INTERNCMD
intern-sa2 ALL=INTERNCMD

  \end{verbatim}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Configuración V}
  \begin{columns}
  \begin{column}{11cm}
  \tiny
  \begin{verbatim}
##############################################
## HOST1
##############################################
sa1 HOST1=/usr/local/etc/mkhosts
sa2 HOST1=/usr/local/etc/nismake: HOST2=ALL:HOST3=ALL
##############################################
## Remote print servers, etc
##############################################
REM1-sa1 REMOTECLIENTS=ALL:HOST1=ALL:HOST2=LPCS,/bin/chmod,
					/bin/chgrp,/bin/rm,
					/bin/cp,/usr/ucb/vi
REM1-sa2 REMOTECLIENTS=ALL
REM1-sa3 HOST1=LPCS
REM1-sa4 HOST1=LPCS:itl-titan=LPCS
# pre-1/96. Added per request from ADMIN1 to allow USER1 to reboot HP`s
user1 HPCLIENTS=REBOOT
# pre-1/96. Allow the guys to start/restart HTTP
# Huge security hole BTW, since they can change these scripts ...
user2 HOST1=HTTP,HTTP1
user3 HOST2=HTTP,HTTP1
# pre-1/96. Added per these guys` request (they said they needed the rope ...)
user1 SOMEHOSTS=ALL
user2 SOMEHOSTS=ALL
# pre-1/96. These guys say they need sudo to do development (see comment above)
user1 MOREHOSTS=ALL
user2 MOREHOSTS=ALL

 \end{verbatim}
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}[fragile]
  \frametitle{syslog}
\tiny

\begin{verbatim}
Nov 14 18:02:44 HOST1 sudo: ADM1 : TTY=pts/4 ; PWD=/appl/sudo/etc ; 
          USER=root ; COMMAND=/usr/bin/date
Nov 14 18:03:40 HOST2 sudo: ADM1 : TTY=pts/0 ; PWD=/var/adm/syslog ; 
          USER=root ; COMMAND=/usr/bin/vi /etc/syslog.conf
Nov 14 18:04:15 HOST3 sudo: ADM3 : TTY=pty/ttys0 ; PWD=/tmp_mnt/home/ADM3 ; 
          USER=root ; COMMAND=/usr/bin/vi /etc/defaultdomain
Nov 14 18:04:38 HOST4 sudo: ADM1 : TTY=pts/0 ; PWD=/var/adm/syslog ; 
          USER=root ; COMMAND=/etc/reboot
Nov 14 18:28:23 HOST5 sudo: ADM1 : TTY=pts/2 ; PWD=/var/adm ; 
          USER=root ; COMMAND=/usr/sbin/poweroff
Nov 14 18:59:10 HOST6 sudo: ADM1 : TTY=pts/5 ; PWD=/appl/sudo/etc ; 
          USER=root ; COMMAND=/usr/bin/cp sudoers /tmp
Nov 14 18:59:15 HOST7 sudo: ADM1 : TTY=pts/5 ; PWD=/tmp ; 
          USER=root ; COMMAND=/usr/bin/chmod 777 sudoers
Nov 14 19:01:38 HOST8 sudo: ADM2 : TTY=pts/2 ; PWD=/appl/someapp/bin ; 
          USER=root ; COMMAND=/usr/bin/vi applwrapper
Nov 14 21:33:42 HOST9 sudo: ADM1 : 3 incorrect passwords ; TTY=pts/4 ; 
          PWD=/home/ADM1 ; USER=root ; COMMAND=/usr/bin/date
Nov 14 21:34:02 HOST9 sudo: ADM8 : user NOT in sudoers ; TTY=pts/6 ; 
          PWD=/home/ADM8 ; USER=root ; COMMAND=/usr/bin/date
Nov 14 21:36:53 HOST9 sudo: ADM9 : command not allowed ; TTY=pts/6 ; 
          PWD=/home/ADM9 ; USER=root ; COMMAND=/usr/bin/vi /etc/passwd
\end{verbatim}
\end{frame}

\subsection[Complementos]{Complementos}
\begin{frame}[fragile]
  \frametitle{sudosh}
sudosh es un filtro que se usa como shell (login shell)
\begin{itemize}
\item
Diseñado para ser usado con sudo, o en solitario
\item
Permite ejecutar órdenes como root, o una shell de root
\item
Todo queda registrado, tanto las órdenes como la salida
\end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Diferencias con sudo}
Si se ejecuta una shell con sudo...
\begin{itemize}
\item
sudo -s 
\item
sudo /bin/sh 
\item 
sudo 
	\begin{itemize}
	\item
	no registra en syslog qué órdenes se ejecutaron
	\item
	sólo que se abrió una shell
	\end{itemize}
\item 
sudosh 
	\begin{itemize} 
	\item 
	independientemente de qué shell se use
	\item 
	tenga implementado la funcionalidad de un archivo histórico o no
	\item 
	registra en syslog todas la órdenes
	\item 
	incluso lo que se teclea en una sesión de vi
	\end{itemize} 
\item
sudoscript (http://egbok.com/sudoscript/rationale.html)
\end{itemize} 
\end{frame}

\begin{frame}[fragile]
  \frametitle{Precaución}
sudosh
    \begin{itemize}
      \item
	Es un programa relativamente nuevo
      \item
	Poco usado
	\begin{itemize}
        \item
	Puede tener problemas de seguridad no conocidos
        \item
	Puede tener resultados imprevisibles
	\item
	Puede penalizar el rendimiento del sistema
		\begin{itemize}
		\item
		Escrituras masivas a disco con syslog
		\end{itemize}
	\end{itemize}
\end{itemize}
\end{frame}

\subsection{Herramientas gráficas}

\begin{frame}
  \frametitle{xsu}

Nos podemos crear nuestro propio script, si queremos ejecutar aplicaciones
gráficas como otro usuario:

\begin{itemize}
\item
El archivo \texttt{.Xauthority} de root no tiene las credenciales adecuadas
para acceder a nuestro display gráfico:

\item
\texttt{** WARNING ** cannot open display}

\item
Se ejecuta: \texttt{\$ xsu  orden}
\item
Con esta solución, \texttt{XAUTHORITY} sería \texttt{~user/.Xauthority} en
lugar de \texttt{~root/.Xauthority}
\item
No funciona con NFS sin acceso remoto como root (si usamos la opción
\texttt{root\_squash} en \texttt{/etc/exports}, porque el usuario root se mapea
al anómino.
\end{itemize}
\end{frame}

\begin{frame}
  \frametitle{gksu}

Interfaz gráfica para \texttt{su} y \texttt{sudo}. COmo opciones, ofrece:

\begin{itemize}
\item
shell de login

\item
Preservar el entorno

\item
Se usa en elementos de menú que requieren preguntar contraseñas:

\begin{centering}%
\pgfdeclareimage[width=4cm]{gksu2}{gksu2}
\pgfuseimage{gksu2}
\par%
\end{centering}%

\end{itemize}
\end{frame}
\begin{frame}
  \frametitle{gksu}
    \begin{itemize}


\item
O para ejecutar órdenes como usuario:

\begin{centering}%
\pgfdeclareimage[width=4cm]{gksu}{gksu}
\pgfuseimage{gksu}
\par%
\end{centering}%

\end{itemize}
\end{frame}



\section*{Resumen}

\begin{frame}
  \frametitle{Problemas}
El uso de sudo a gran escala:
  \begin{itemize}
  \item
    De los métodos que hemos visto, es el más potente, pero también el más complejo
  \item
    Tiene inconvenientes
	\begin{itemize}
	\item
	Las claves de usuario se convierten en claves de root (aunque restringidas)
	\item
	Hay que tener cuidado:
		\begin{itemize}
		\item
		Qué órdenes
		\item
		Con qué parámetros
		\item
		Ejemplo: vi
		\end{itemize}
	\item
	Posibles problemas de seguridad del propio sudo. De todos los programas
	suid, este es el más peligroso.
	\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}
  \frametitle<presentation>{Resumen}

  % Keep the summary *very short*.
  \begin{itemize}
  \item
    Administración \texttt{Delegada} de Sistemas Linux.
  \item
    Administración \texttt{Segura} de Sistemas Linux.
  \item
    Distintas \texttt{Técnicas}, que se pueden combinar.
  \end{itemize}
\end{frame}

\end{document}


