Linux Administrator

LINUX ADMINISTRATOR
pág. 1

Tabla de contenido
Formación de la comunidad de aprendizaje: .................................................................................................... 8
Reglas de oro: .................................................................................................................................................... 8
Cumplimiento de expectativas: ......................................................................................................................... 9
Introducción ................................................................................................... 10
Unidad 1.- Instalación del SistemaOperativo y Ajustes posteriores .................... 11
Introducción .................................................................................................................................................... 11
Sistema Operativo UNIX .................................................................................................................................. 13
Sistema Operativo Linux .................................................................................................................................. 14
Requerimientos de Hardware de Linux ........................................................................................................... 17
Distribuciones de Linux .................................................................................................................................... 18
Organización de Linux ...................................................................................................................................... 18
Sistema de Archivos en Linux ........................................................................................................................... 21
Procesamiento de Texto .................................................................................................................................. 23
Características del Sistema Linux ...................................................................... 26

Software disponible en Linux ............................................................................ 27
Distribuciones Linux ........................................................................................ 27
Estándar de Jerarquía de Sistema de Archivos. .................................................. 31
Estructura de los directorios general ............................................................................................................... 31
Estructura de Archivos ..................................................................................................................................... 32
Instalacion Centos ........................................................................................... 36

Editor de texto VI y VIM .................................................................................. 52
Modo de entrada de texto (añadir, insertar) .................................................................................................. 53
Borrando y cambiando texto ........................................................................................................................... 54
Deshaciendo cambios ...................................................................................................................................... 54
Guardando cambios y permaneciendo en vi ................................................................................................... 54
Abandonando vi .............................................................................................................................................. 54
Comandos adicionales para posicionamiento del cursor ................................................................................ 55
Búsqueda ......................................................................................................................................................... 55
Borrar texto ..................................................................................................................................................... 55
Comandos de control: ..................................................................................................................................... 57
Plymouth: ........................................................................................................................................................ 67
Zona Horaria .................................................................................................................................................... 68
Control – Alt – Supr ......................................................................................................................................... 69
Planificadores de entrada / salida. .................................................................................................................. 70
Uso de disco de rescate en CentOS 6.5 ........................................................................................................... 72
Gestion de memoria Swap .............................................................................................................................. 85
Unidad 2 Administración del Sistema de Archivos. ............................................. 88
pág. 2

Límites de tamaño ........................................................................................................................................... 89

Niveles del journaling ...................................................................................................................................... 89
Desventajas ..................................................................................................................................................... 90
Mejoras ............................................................................................................................................................ 91
Sistema de archivos de gran tamaño ............................................................................................................... 91
Extents ............................................................................................................................................................. 91
Compatibilidad hacia adelante y hacia atrás ................................................................................................... 91
Asignación persistente de espacio en el disco ................................................................................................ 91
Asignación retrasada de espacio en el disco ................................................................................................... 92
Límite de 32000 subdirectorios superado ....................................................................................................... 92
Chequeo del sistema de ficheros más rápido .................................................................................................. 92
Uso de e2fsck ................................................................................................................................................... 92
Noatime (No tiempos de acceso) .................................................................................................................... 93
Swapinees ........................................................................................................................................................ 96
Commit ............................................................................................................................................................ 96
fsck ................................................................................................................ 97
Uso de dd ......................................................................................................................................................... 99
Sintaxis Básica: ................................................................................................................................................. 99
A) Sobre discos duros y particiones: .............................................................................................................. 102
B) Sobre un CD/DVD ...................................................................................................................................... 103
C) Sobre MBR y VBS: ...................................................................................................................................... 104
D) Otros: ........................................................................................................................................................ 105
Unidad 3. Administración de Sofware y servicios. ............................................ 107

RPM ............................................................................................................. 108
Instalación de paquetes. ................................................................................................................................ 110
Gestion de Servicios ...................................................................................................................................... 117
Nivel de ejecución 0# ..................................................................................................................................... 117
Secuencia de arranque .................................................................................................................................. 119
Arranque y parada de lo servicios ................................................................................................................. 123
Envío de señales a los procesos ..................................................................................................................... 124
Unidad 4.Gestión de usuarios, grupos y privilegios. ....................................... 129

Gestión de cuentas de usuario. ...................................................................... 129
Tipos de usuarios ........................................................................................................................................... 129
pág. 3

Añadir usuarios con useradd ......................................................................................................................... 134

Modificar usuarios con usermod ................................................................................................................... 135
Eliminar usuarios con userdel ........................................................................................................................ 136
Cambiar contraseñas con passwd ................................................................................................................. 137
Archivos de configuración ............................................................................................................................. 138
Resumen de comandos y archivos de administración de usuarios ............................................................... 139
Gestion de cuentas de grupos: ...................................................................................................................... 141
SUDO ........................................................................................................... 142

Visudo ............................................................................................................................................................ 144
Sudoers .......................................................................................................................................................... 145
Alias ............................................................................................................................................................... 146
Cmnd_Alias .................................................................................................................................................... 146
User_Alias ...................................................................................................................................................... 147
Runas_Alias .................................................................................................................................................... 148
Host_Alias ...................................................................................................................................................... 148
Listas .............................................................................................................................................................. 149
Tags (etiquetas de comandos) ....................................................................................................................... 152
Sudo ............................................................................................................................................................... 155
Uso de los Aliases .......................................................................................................................................... 158
Unidad 5. Permisos y Atributos del Sistema de Archivos. .................................. 160

Uso de las ACLs ............................................................................................. 174
Creación de una ACL básica. .......................................................................................................................... 175
ACLs por defecto ............................................................................................................................................ 181
Lsattr y chattr: control de atributos de ficheros Linux .................................................................................. 184
lsattr .............................................................................................................................................................. 185
chattr ............................................................................................................................................................. 186
Unidad 6. Herramientas básicas del Sistema Operativo. ................................... 191

Mandatos de uso básico, muévete por la consola. ........................................... 191
Compresión y descompresión de archivos. ................................................................................................... 202
Gestión de procesos y trabajos. .................................................................................................................... 212
Ps ................................................................................................................................................................... 213
Pstree ............................................................................................................................................................. 215
Kill .................................................................................................................................................................. 215
Killall .............................................................................................................................................................. 216
Nice ................................................................................................................................................................ 216
nohup y & ...................................................................................................................................................... 217
Jobs ................................................................................................................................................................ 218
Top ................................................................................................................................................................. 219
lsof. ................................................................................................................................................................ 224
pág. 4

Introducción a sed. ........................................................................................................................................ 226

Introducción a GnuPG. .................................................................................................................................. 228
Definiendo los requerimientos en seguridad ................................................................................................ 229
Selección del tamaño de la clave ................................................................................................................... 229
Protección de la clave privada ....................................................................................................................... 230
Selección de las fechas de caducidad y uso de subclaves ............................................................................. 232
Gestión del anillo de confianza ...................................................................................................................... 233
IMPLEMENTAR Y ADMINISTRAR CUOTAS DE DISCO (DISK QUOTAS) EN LINUX ...... 235

Tipos de cuota ............................................................................................................................................... 236
Límites ........................................................................................................................................................... 236
Configuración ................................................................................................................................................ 237
Aplicando la cuota a usuarios ........................................................................................................................ 240
Verificando el uso de las cuotas .................................................................................................................... 241
Estableciendo el tiempo de gracia ................................................................................................................. 242
Fijar cuotas de manera global a todos los usuarios ....................................................................................... 243
Configuración de red. .................................................................................................................................... 246
Configuración del fichero resolv.conf ............................................................................................................ 250
Configuración y uso de crond. ........................................................................ 252

¿Qué es cron? ................................................................................................................................................ 252
Usando cron .................................................................................................................................................. 253
Filtrado de paquetes ...................................................................................................................................... 262
Diferencias entre iptables e ipchains ............................................................................................................. 264
Opciones usadas en comandos iptables ........................................................................................................ 265
Estructura de las opciones iptables ............................................................................................................... 265
Opciones de comandos ................................................................................................................................. 266
Opciones de parámetros de iptables ............................................................................................................. 267
Opciones de coincidencia para iptables ........................................................................................................ 268
Protocolo TCP ................................................................................................................................................ 268
Protocolo UDP ............................................................................................................................................... 270
Protocolo ICMP .............................................................................................................................................. 270
Módulos con opciones de coincidencias adicionales .................................................................................... 270
Opciones del objetivo .................................................................................................................................... 271
Opciones de listado ....................................................................................................................................... 275
Guardar reglas iptables ................................................................................................................................. 276
Scripts de control de iptables ........................................................................................................................ 276
Archivo de configuración de scripts de control de iptables ........................................................................... 277
Introducción a SELinux .................................................................................. 279

Archivos relacionados con SELinux ................................................................................................................ 279
El pseudo sistema de archivos /selinux/ ........................................................................................................ 279
Archivos de configuración de SELinux ........................................................................................................... 280
pág. 5

El archivo de configuración /etc/sysconfig/selinux ....................................................................................... 280

El directorio /etc/selinux/ .............................................................................................................................. 281
Utilidades para SELinux ................................................................................................................................. 282
Seguridad ..................................................................................................... 283

Historia .......................................................................................................................................................... 283
Versiones ....................................................................................................................................................... 283
Características de SSH ................................................................................................................................... 284
¿Por qué usar SSH? ........................................................................................................................................ 284
Secuencia de eventos de una conexión SSH .................................................................................................. 285
Capa de transporte ........................................................................................................................................ 286
Autenticación ................................................................................................................................................ 287
Canales .......................................................................................................................................................... 288
El Protocolo de Transferencia de Archivos ...................................................... 292

Puertos múltiples, modos múltiples .............................................................................................................. 293
Servidores FTP ............................................................................................................................................... 294
Vsftpd ............................................................................................................................................................ 294
Archivos instalados con vsftpd ...................................................................................................................... 295
Iniciar y detener vsftpd .................................................................................................................................. 296
Introducción a Samba .................................................................................... 308

Características de Samba ............................................................................................................................... 309
Demonios Samba y Servicios relacionados .................................................................................................... 309
Descripción general de los demonios ............................................................................................................ 309
El demonio smbd ........................................................................................................................................... 309
El demonio nmbd .......................................................................................................................................... 310
Arrancar y detener el Samba ......................................................................................................................... 310
Tipos de servidores Samba y el archivo smb.conf ......................................................................................... 311
Servidor independiente ................................................................................. 311

Anónimo de sólo lectura ............................................................................................................................... 311
Anónimo Lectura/Escritura ............................................................................................................................ 312
Servidor de impresión anónimo .................................................................................................................... 312
Servidor miembro de dominio ....................................................................................................................... 315
Servidor miembro de dominio Active Directory ............................................................................................ 315
Servidor miembro de dominio basado en Windows NT4 .............................................................................. 316
Domain Controller ......................................................................................................................................... 317
Modos de seguridad Samba .......................................................................................................................... 318
Seguridad a nivel de usuario .......................................................................................................................... 318
Seguridad a nivel de usuarios ........................................................................................................................ 319
Modo de seguridad de dominio (seguridad a nivel del usuario) ................................................................... 319
Modo de seguridad de Active Directory (seguridad a nivel de usuario) ........................................................ 320
Modo de seguridad de servidor (seguridad a nivel de usuario) .................................................................... 320
pág. 6

Bases de datos de información de cuentas Samba ....................................................................................... 320
Motores con compatibilidad ascendente ......................................................... 321

Nuevos motores ............................................................................................................................................ 321
Navegación de red con Samba ...................................................................................................................... 322
Navegación de grupos de trabajo .................................................................................................................. 322
WINS (Windows Internetworking Name Server) ........................................................................................... 324
CONCLUSIONES ............................................................................................................................................. 334
CIBERGRAFIA ................................................................................................................................................. 335

pág. 7

Formación de la comunidad de aprendizaje:

La formación de la comunidad de aprendizaje es un proceso que debe llevarse a cabo para
iniciar cada uno de nuestros cursos. Su finalidad es crear un clima propicio para la celebración
de la actividad instruccional, es decir, generar un entendimiento previo entre el instructor y los
participantes sobre los temas que se desarrollarán durante ésta, así como las estrategias
educativas que se llevarán a cabo para lograr un mejor aprendizaje.
Un adecuado manejo de la comunidad de aprendizaje es un elemento fundamental para
garantizar la satisfacción de uno de los clientes involucrados en la impartición de los cursos: los
participantes.
Presentación del instructor:

Nombre, profesión, años de experiencia como instructor, experiencia en la impartición del
curso, o cursos similares o relacionados.
Alineación de expectativas:
• El instructor recabará las expectativas de los participantes respecto al curso, con el fin de
dejarles claro el objetivo del mismo.
• En caso de que alguna expectativa no coincida con los temas que el curso contiene, el
instructor dejará claro cuáles de las expectativas expresadas no serán cubiertas con el curso y
porqué.
• Las expectativas alineadas serán anotadas en hojas de rotafolio para su revisión al término
del curso.
• Durante el desarrollo del curso el instructor deberá cubrir las expectativas alineadas.

Presentación del objetivo del curso:
• El instructor presentará a los participantes el objetivo del curso, aclarando dudas al
respecto si las hubiese.
Reglas de oro:
• El instructor promoverá el establecimiento de reglas por parte de los participantes que se
observarán a través del curso; por lo que puede proponer: tiempo de tolerancia para iniciar las
sesiones, respeto hacia los compañeros, participación de todos en técnicas y ejercicios grupales,
etc.; se incluirán todos los puntos que los participantes consideren pertinentes.
pág. 8

• Se anotarán los acuerdos en hojas de rotafolio y se colocarán en un espacio en el que sean

visibles a lo largo de todo el curso.
Cumplimiento de expectativas:
• Al finalizar el curso el instructor deberá llevar a cabo una revisión de las expectativas
alineadas que se anotaron en hojas de rotafolio al inicio del curso.

Se revisará cada una de las expectativas alineadas palomeando las que hayan sido
cumplidas, y el instructor explicará de qué manera se llevó a cabo tal cumplimiento.
pág. 9

Introducción

Linux es un sistema operativo de la familia Unix, gratuito, creado mediante la política de
“código abierto”. Estas características implican un gran ahorro en los costes de instalación de
los equipos, pero también una mayor especialización por parte del personal informático.
En todo sistema Unix existe un usuario administrador (root), que controla el funcionamiento
completo del sistema, tiene acceso universal y puede realizar cualquier operación con los
datos y los dispositivos de la máquina.
Por lo tanto, este curso tiene como finalidad la formación de profesionales en el área de
Administración de Redes que le permite al participante obtener conocimientos profundos en el
área de infraestructura. Combina una sólida formación teórico -práctica con una metodología
que logra un importante nivel de entrenamiento técnico.
pág. 10

Unidad 1.- Instalación del SistemaOperativo y Ajustes posteriores

Introducción
Un sistema de computadora es un dispositivo electrónico programable que puede
almacenar, recuperar y procesar datos. Ejecuta un conjunto de instrucciones llamado
programa. La ejecución del programa da al usuario final el resultado deseado. Un ejemplo de
ejecución de un programa es cuando se trabaja con una calculadora en un sistema
operativo Windows.

Una computadora es capaz de realizar múltiples tareas, tales como:
• Ejecutar programas de usuario
• Conectar computadoras en una Red de Área Local (Local Área Network – LAN)
• Compartir los recursos
• Controlar su hardware

Para que una computadora sea capaz de hacer todo esto, requiere de un programa especial
llamado sistema operativo. El sistema operativo reside en el disco duro de la
computadora y actúa como un puente entre los programas de usuario y los programas
que controlan le hardware de la computadora.

El sistema operativo trabaja principalmente en segundo plano. Se encarga de los
componentes hardware de una computadora, además de asegurar el inicio y ejecución de
diversos programas. También se encarga de los datos almacenados en los dispositivos de
almacenamiento de la computadora.

El sistema operativo es el responsable de las siguientes funciones del sistema de
computadora:

• Arrancar o iniciar la computadora
• Actuar como interfaz entre el CPU y el mundo externo
• Coordinar los dispositivos del sistema
• Coordinar las aplicaciones o programas en ejecución

pág. 11

El sistema operativo controla todo el trabajo de la computadora. Sin el, la computadora

solo es un montón de circuitos electrónicos.
Programa de Sistema Programas que

Usuario Operativo controlan
Ilustración 1 Rol de un Sistema Operativo
Los siguientes son algunos de los usos del sistema operativo:
Proporciona diferentes recursos a los usuarios, tales como: calculo, almacenamiento,

dispositivos de Entrada/Salida (Input/Output – I/O) manejo de red, etc
Permite que varios usuarios trabajen juntos compartiendo e intercambiando
programas, aplicaciones y datos en la misma instalación.
Ayuda a resolver conflictos cuando los usuarios solicitan el mismo recurso
simultáneamente.
Proporciona seguridad cuando los usuarios comparten datos y programas.
Asiste en la administración y evaluacion del uso y eficacia de un sistema, recolectando
datos sobre la utilización de los recursos.
En los sistemas de computadoras, existen varios componentes que solo trabajan en
forma secuencial y que solo se pueden compartir directamente en forma marginal. Los
sistemas operativos permiten que se haga un uso eficiente de estos componentes.
Inicio de un Sistema Operativo

El proceso de iniciar el sistema operativo es llamado arranque (bootstrapping o
booting). Aquí se mencionan algunos puntos acerca de cómo se inicia un sistema
operativo.
Las instrucciones para el arranque están incluidas en uno de los chips de la
computadora, llamado el chip BIOS (Basic Input/Output System)
El chip BIOS informa a la computadora que busque un programa especial llamado el
gestor de arranque (boot loader)
El gestor de arranque esta disponible en un lugar fijo en el disco de arranque. El disco de
arranque en cualquier computadora es el disco duro primario.
El gestor de arranque inicia la parte principal del sistema operativo.
pág. 12

Los sistemas operativos son clasificados en dos tipos:

Sistema Operativo de Usuario Único: permite que solo un usuario use todos los recursos del
sistema de computadora en cualquier momento dado. Mientras el procesador maneja un
usuario o programa, otros programas o usuarios no pueden usar estos recursos. Un ejemplo
de Este tipo el sistema operativo DOS.
Sistema Operativo Multiusuario: permite que más de un usuario o programa se ejecuten o
usen recursos del sistema en forma simultánea. Algunos ejemplos de estos sistemas
operativos multiusuario son UNIX, XENIX, Linux, Solaris, etc.
En los tiempos en que los sistemas operativos como DOS únicamente permitían solo un
usuario para realizar tareas simples, la introducción de UNIX creo una nueva forma de
computación. A pesar que Windows también es un sistema operativo principalmente de
usuario único, permite que varias tareas se realicen en forma simultanea. A continuación se
aprenderá acerca del sistema operativo UNIX, dado que Linux es una variación del sistema
operativo UNIX.

Sistema Operativo UNIX

El sistema operativo UNIX tiene una historia muy interesante. Algunos aspectos de su
evolución son:

Bell Telephone Laboratorios (BTL), GE y MIT se unieron intentando crear un sistema
operativo que permitiera trabajar simultáneamente hasta mil usuarios. Ken Thompson y
Dennis Ritchie de BTL trabajaron en esto y crearon un sistema operativo llamado MULTICS, un
acrónimo de MULTiplexed Information and Computer Services (Servicio de Información
Multiplexada y Calculo).

BTL se retiro del proyecto durante el desarrollo del trabajo.
En 1969-70, Thompson y Ritchie reescribieron el sistema operativo para jugar un juego de
guerra espacial con otra maquina mas pequeña.
Este sistema operativo fue llamado Uniplexed Information and Computing Services (UNICS),
un juego de palabras del MULTICS original.
El nombre de UNICS luego fue transformado a UNIX.
En 1972-73, el sistema UNIX fue reescrito usando el lenguaje de programación C
El sistema operativo UNIX es uno de los mas poderosos versátiles y flexibles en el mundo hoy
en día.
pág. 13

El sistema operativo UNIX corre en un rango de computadores desde microcomputadoras
hasta mainframes. Algunas de sus características son:

Es conocido como un sistema operativo “ abierto” dado que puede ser llevado e instalado
en cualquier clase de sistema de computadora y plataforma de hardware.
Normalmente, los sistemas operativos son escritos en lenguaje ensamblador. Sin embargo,
UNIX esta escrito en un lenguaje de alto nivel y su código fuente esta disponible
fácilmente. Esto supone una ventaja para los programadores cuando incorporan cambios
para ajustarse a sus necesidades.
Es un sistema multiusuario y multitarea. Multitarea significa que el sistema operativo
coordina múltiples tareas o trabajos en forma simultanea. Mientras un usuario esta
compilando un programa en C, otro puede crear documentos usando un editor, cada
ignorando la presencia del otro.
UNIX es uno de los sistemas operativos más poderosos existentes, por el hecho de poder
compartir recursos en tiempo real.
A pesar de que UNIX esta desarrollado para programadores, proporciona un entorno tan
flexible que también es usado en negocios, ciencias, educación e industria.
Los interruptores de telecomunicación y sistemas de transmisión son algunos ejemplos del
uso del sistema operativo UNIX

A continuación se aprenderá acerca del sistema operativo Linux:
Sistema Operativo Linux

Linux es un sistema operativo distribuido gratuitamente basado en el sistema operativo
UNIX. Fue desarrollado originalmente por Linus Torvalds, quien empezó a trabajar sobre
Linux en 1991 siendo estudiante de la Universidad de Helsinki en Finlandia. Luego, miles de
programadores contribuyeron a su desarrollo y fue distribuido gratuitamente por Internet.

Por los años 80, los sistemas operativos eran básicamente propietarios, lo que significaba que
se tenía que usar solo el sistema operativo proporcionado para una plataforma especifica. El
proyecto GNU fue fundado por Richard Stallman, quien fue el también fundador de Free
Software Foundation (FSF), autor de GNU GPL (General Public License) y el desarrollador
original de algunos programas de software GNU (por ejemplo, el compilador gcc y el editor
de texto Emacs)
pág. 14

Las principales metas del proyecto GNU incluyeron las siguientes:

• Desarrollar un sistema operativo compatible con UNIX
• Soportar diferentes arquitecturas de hardware
• Hacer que el sistema operativo estuviese disponible libre de costo para
asegurar que los usuarios pudiesen redistribuir todo el sistema y cambiar ó
contribuir a alguna parte de él.

En 1990, la mayoría de las piezas de software del sistema operativo basado en GNU se
habían escrito, excepto la más importante, el kernel. El kernel es el núcleo del sistema
operativo. Mas tarde, el kernel gratuito basado en UNIX, desarrollado por Linus
Torvalds fue combinado con el sistema GNU. Así nació un sistema operativo, el sistema GNU
basado en Linux.

Las etapas significativas en la evolución de Linux son:

• En 1991, Linus Torvalds desarrollo Linux con el soporte de desarrolladores a lo
largo del mundo y lo llamo Linux
• El lanzo la versión 0.02 de Linux en 1991
• En 1994, fue lanzada la versión 1.0 de Linux
• La versión 2.6 completa fue lanzada en Diciembre de 2003. Sin embargo, su
desarrollo continúa.

pág. 15

Los siguientes son algunos de los hechos básicos acerca del sistema operativo Linux:

Es desarrollado, escrito, distribuido y respaldado bajo GPL de GNU (GNU no es UNIX).
Como resultado, su código fuente puede ser distribuido gratuitamente y disponible
para el publico en general.
Los sistemas Linux se usan para redes, desarrollo de software, soluciones de
alojamiento basados en Web y como plataforma de usuario final.
La mascota oficial, que Linus eligió para su sistema operativo, es el pingüino Linux
llamado Tux (Torvalds Unix), que se presente en la figura 1.2

Ilustración 2 “TUX”, la mascota de Linux

Linux no es un derivado del código fuente de UNIX. Sin embargo, la interfaz de Linux
es intencionalmente como la de UNIX. Así las lecciones aprendidas acerca de UNIX,
incluyendo información sobre seguridad son aplicables tanto a UNIX como a Linux
Linux es un sistema operativo estable y versátil, especialmente como un servidor de
red.
Proporciona un sólido entorno grafico, paquetes fáciles de instalar y aplicaciones de
alto nivel.

pág. 16

Requerimientos de Hardware de Linux

Linux soporta plataformas de hardware tales como Intel x86, PowerPC, S/390, SPARC y
Alpha. Los diferentes requerimientos de hardware para Linux se listan en la siguiente tabla
Hardware Requerimientos
CPU La serie x86 de Intel y sus compatibles,
DEC, Alpha, Motorola, PowerPC, etc.
Tarjeta Madre (MotherBoard) Sistemas de bus PCI, EISA, VESA y MCA.
Memoria 64 MB(mínimo), 256 MB recomendados
para mayor eficiencia y ejecución
Monitor y Adaptador de Video CGA, EGA, VGA, IBM monochrome, Súper
VGA y otras tarjetas aceleradoras de video
Dispositivos de Puntero Ratón serial estándar como Logitech, serie
MM, Microsoft 2 botones, Sistemas Mouse de 3
botones, etc.
Controlador de Disco Duro IDE, EIDE, MFM \, RLL y la mayoría de los
controladores ESDI
Espacio de Disco Duro Requiere un mínimo de 100 MB de espacio
para una instalación mínima de Linux. Para una
instalación completa con todos los servicios, los
requerimientos pueden ser tanto como 2 GB
Unidades de CD-ROM Sistema estándar de archivo ISO 9660 para CD-ROMS
Unidades de Cinta SCSI

Impresoras Impresoras paralelas
Modems Modems seriales internos y externos
Tarjetas Ethernet Soporta tarjetas Ethernet y adaptadores LAN
populares
3 Tabla: Requerimientos de Hardware de Linux
pág. 17

Distribuciones de Linux

Como el código fuente para Linux fue desarrollado esta siendo distribuido gratuitamente,
diferentes compañías han desarrollado sus propias versiones o distribuciones de Linux Cada
una de estas variedades tiene su propio conjunto de características, tales como
procedimientos de instalación y administración, paquetes de software y configuraciones.
Muchas de ellas están configuradas para un tipo específico de computadora.
Las 10 distribuciones principales se listan a continuación:

Mandrake Linux, desarrollado por MandrakeSoft.

Red Hat Linux, desarrollado por Red Hat
Debian GNU/Linux, desarrollado por Debian.
SuSE Linux, desarrollado por SuSe, Inc.
Gentoo Linux, desarrollado por Gentoo Technologies, Inc.
El Proyecto Slackware Linux, desarrollado por Slackware Linux, Inc.
Lycoris Desktop, desarrollado por Lycoris
Beehive Linux, desarrollado por el Equipo Beehive
Caldera OpenLinux, desarrollada por Caldera Internacional, Inc.
Turbolinux, desarrollado por Turbolinux, Inc.
Existen muchas más, aunque la distribución mas usada es Red Hat Linux
Organización de Linux
El sistema operativo Linux esta organizado funcionalmente en los siguientes tres niveles:
Kernel (Núcleo)
Shell (Interprete de Comandos)
Herramientas y aplicaciones.
La representación esquemática de las tres partes principales del sistema operativo Linux se
presenta en la Figura 4

pág. 18

kernel
Shell
Programas
Ilustración 4 Partes Principales del Sistema Operativo Linux
El kernel

El kernel es el núcleo de un sistema operativo, así como la CPU es el núcleo de un
sistema de computadora. El kernel es una colección de programas, la mayoría escritos en C y
solo existe un kernel para cualquier sistema operativo. Este se comunica directamente con el
hardware y sin un kernel un sistema operativo no puede interactuar con el hardware.
Algunas de las tareas importantes del kernel son:

• Verificar si el usuario es un usuario autorizado
• Hacer seguimiento de los diferentes programas que están ejecutándose y
asignar un tiempo especifico a cada programa
• Asignar espacio de almacenamiento para los archivos en el sistema
• Ejecutar el programa shell
• Manejar la transferencia de información entre la computadora y las terminales

En un sistema multiusuario, a cada terminal se le asigna un numero y los usuarios trabajan
en terminales conectadas a la computadora principal. El sistema operativo se comunica
con la Terminal a través de los números de Terminal
pág. 19

El Shell
El sistema operativo Linux usa un shell para transferir los comandos desde el teclado a la
computadora. El shell (interprete de comandos) es solo otro programa escrito en C.
Actúa como un intérprete entre los programas de los usuarios y el kernel. Traduce los
comandos del usuario en la acción apropiada. El shell interactúa con el usuario, mientras que
el kernel interactúa con el hardware de la maquina.

El shell es el programa que toma comandos y, ejecuta el programa apropiado o lo traduce en
instrucciones que el kernel entiende. Por ejemplo, un comando tal como chdir será
traducido por el shell a un formato entendible por el kernel, mientras que un comando tal
como ls será ejecutado por el shell como un programa en el directorio /usr/bin/ls.

El shell es una interfaz basada en texto para el sistema Linux. En Linux, las interfaces
graficas tales como el Sistema X Window (similar al presentado por Windows NT y 2000, que
permiten al usuario ejecutar comandos usando el ratón y el teclado) también pueden ser
usadas. El shell por defecto en Linux es bash (Bourne Again Shell). Otros tipos de shell
disponibles en Linux son:

csh (C Shell)
ksh (Korn Shell)
sh (Shell)
esch (enhanced C Shell)

Bourne Shell y el C Shell son los que se usan comúnmente. Ambos son controlados por
comandos. El Korn Shell es el menos usado. Todos los shells sirven para el mismo propósito,
pero tiene diferentes características y sintaxis.

Herramientas y Aplicaciones

En el sistema Linux existe un cierto número de herramientas disponibles. Las herramientas

son programas de usuario que pueden ser escritos por terceros para determinados tipos de
aplicaciones. Típicamente, las herramientas se agrupan para realizar ciertas funciones, tales
como programación, aplicaciones de negocio y procesamiento de texto.

pág. 20

A continuación se aprenderá acerca de la organización del sistema de archivos en el

sistema operativo Linux

Sistema de Archivos en Linux

Todos los programas de usuario, documentos, herramientas, aplicaciones, etc son

almacenados como archivos en sistema de computadora. Todos los archivos son
almacenados en un dispositivo de almacenamiento secundario (usualmente un disco). Una
porción del disco es separada para almacenar la información relacionada a los archivos
almacenados. Esta unidad funcional se denomina sistema de archivos.
Algunos de los puntos importantes aquí son:

El área de la superficie donde se almacenan los archivos se dividen en pistas
circulares.
Las pistas circulares están divididas en sectores o bloques de disco (en forma de torta)
Todos los bloques del disco son del mismo tamaño y tienen un numero único
llamado el numero de bloque de disco
El tamaño del bloque de disco varía dependiendo de la distribución Linux.

La mayoría de los sistemas modernos tienen un tamaño de bloque de disco de un 1 KB
(kilobytes). Los bloques de disco están organizados en los siguientes cuatro grupos:

Bloque de Arranque (Boot)
Superbloque
Bloque Inodo (128 bytes)
Bloque de Datos

Cada sistema de archivos tiene un bloque de arranque, un superbloque, una lista de
bloques inodos y una lista de bloques de datos.

Ahora se va a entender la necesidad y uso de cada bloque en el sistema de archivos.
pág. 21

Bloque de Arranque
Consiste de un bloque de disco que contiene el código para iniciar la computadora,
Ocupa el primer bloque de un sistema de archivos
Un sistema solo requiere de un bloque de arranque para iniciar el sistema. En el resto de los
sistemas de archivos, este bloque permanece vacío.
Superbloque
Esta a continuación del bloque de arranque en el sistema de archivos
Consiste de un bloque de disco que contiene información acerca del sistema de archivos
Contiene información acerca del número de bloques en el sistema de archivos, el número
de bloques asignados para inodos (se aprenderá acerca de los inodos más adelante) y el
número de bloques que están actualmente libres.
Bloque Inodo
Es el tercer grupo de bloques en un sistema de archivos.
Contiene más de un bloque de disco para mantener información acerca de los archivos
en el sistema de archivos.
Bloque de Datos
Almacena el contenido del archivo
Sigue a los bloques asignados para inodos.
Un sistema de archivos contiene cierto número de bloques de datos.
Antes de proceder a aprender acerca de la partición del disco, se entenderá un poco mas
acerca de la información que mantiene inodos. Los inodos mantienen información acerca del
propietario del archivo, los bloques de disco usados en el archivo, etc. Los archivos, por
otro lado, contienen los datos del archivo.

Asuma que se crea un archivo llamado midocumento.txt. Este debe ser almacenado en el
disco. Dependiendo del sistema de archivos al que este asociado, los datos del archivo se
almacenaran en los bloques de datos y otra información administrativa acerca de este, será
almacenada en los bloques inodos.

pág. 22

Partición de Disco
Aquí, el sistema divide el disco en particiones de disco.
Cada partición consiste en bloques, situados en forma contigua, pero separados de las otras
particiones
La partición puede ser un sistema de archivos o un espacio de intercambio
(space swap).
Un espacio de intercambio (space swap) se usa para implementar la memoria virtual,
donde una porción de la memoria principal se almacena temporalmente
La partición primaria es donde se almacenan los archivos relacionados al arranque.
Las particiones del espacio de intercambio (space swap) son una secuencia lineal de
bloques.
El tamaño de los archivos cambia a través del tiempo (crece o disminuye)
Un bloque de datos de un archivo puede no estar en una secuencia lineal de bloques. En
vez de ello, puede estar disperso a lo largo de toda la partición.
Procesamiento de Texto
El sistema Linux proporciona métodos poderosos de procesamiento de un texto.
Un ejemplo simple de procesamiento es encontrar el número de ocurrencias de un patrón
dado en un texto.
A continuación se considerara un ejemplo:
“La pronunciación de la palabra pronunciación es pronunciación”

En esta oración el patrón ‘pronunciación’ ocurre tres veces en el texto. Cierto número de
herramientas, tales como grep, egrep y fgrep, están disponibles para realizar el
procesamiento de texto.

También existen otras herramientas de procesamiento de texto, que son conocidas como
editores. Estos proporcionan las funcionalidades para crear, editar (modificar) y guardar
texto.
pág. 23

Algunos ejemplos de editores son:

Vi: es conocido como editor visual y es el editor más popular. Vi es un programa que
permite a los usuarios editar tanto archivos de texto como binarios. Los archivos de
texto son aquellos que tienen caracteres alfanuméricos, mientras que los binarios
contienen caracteres entendibles por la maquina. A pesar que también puede leer
archivos binarios, vi es conocido normalmente como un editor de texto.
Un editor de texto es como un procesador de palabras. Los editores de texto se usan
principalmente para escribir programas, que luego son convertidos en un código
entendible por la maquina a través de otro programa.
Ed: mientras que vi es un editor que permite visualizar el contenido de un archivo, una
pantalla a la vez, ed es un editor en linea. En cualquier momento, solo puede mostrarse
una linea del archivo.

Sed: es un editor de flujos basado en ed. Puede editar archivos sin intervención del
usuario. Los comandos de edición pueden ser pasados como argumentos de linea de
comandos. Los argumentos de linea de comandos son aquellos que se proporcionan
junto con un comando, antes de que el comando sea ejecutado. Estos argumentos van
como entradas sobre las cuales el programa puede trabajar para producir cierta salida.
Sed se utiliza extensivamente en los sistemas Linux. Proporciona mecanismos poderosos
para editar flujos de datos pasados a el como entrada.
Emacs: es un poderoso editor de texto. Siendo C el lenguaje de programación usado
comúnmente en los sistemas Linux, emacs tiene características incorporadas que
permite dar formato automático a los programas C, a su vez también permite la
búsqueda de patrones y lectura de correo electrónico desde el editor.
A continuación se presenta una breve discusión sobre las capacidades de programación y
documentación disponibles en Linux.
Programación
Se puede programar a través del shell y esto se conoce como programación de shell Linux
proporciona más de un shell. El Bourne Again Shell (popularmente conocido como bash) es
el shell mas usado. Se aprenderá acerca de los diferentes shells que proporciona
Linux en la unidad 2: El Sistema Linux. Cada shell en Linux proporciona la capacidad de
programación. Un programa shell puede invocar las herramientas proporcionadas en Linux
a través de una sintaxis simple. La programación de shell es similar a un lenguaje de
programación como C. pero con una sintaxis diferente.
pág. 24

Combinado con el poder del procesamiento de texto, la programación en Linux es
extremadamente poderosa. La administración de sistemas complejos en sistemas operativos
estilo UNIX se hace típicamente a través de la programación del shell. El administrador del
sistema usa la programación del shell en forma extensiva para administrar y monitorear el
sistema operativo.
Documentación.
Linux proporciona una documentación bastante elaborada para todas sus herramientas. Las
herramientas son referidas comúnmente como comandos.

El sistema Linux proporciona cierto número de comandos. Algunos de ellos son:

clear – limpia la pantalla
date – muestra la fecha y hora
cal – muestra el calendario del mes actual
who – muestra los usuarios que están actualmente conectados al sistema
Sin embargo, dado que los comandos son tan extensos, no es posible para ningún
usuario recordar todos los comandos y la sintaxis asociada con estos.
La documentación puede ser leída fácilmente con la ayuda de una herramienta controlada por
comandos llamada man.
A continuación se dan ejemplos algunos comandos de uso en conjunto con man

man clear
man date
man man

Los primeros dos usos del comando man muestran la documentación para los comandos
clear y date, respectivamente. El tercer uso, muestra la documentación del mismo
comando man

pág. 25

Características del Sistema Linux

El sistema Linux ofrece las siguientes características:
Estabilidad: tiene protección de la memoria entre procesos, de manera que uno de ellos
no pueda colgar el sistema.
Multitarea: varios programas (realmente procesos) ejecutándose al mismo tiempo
Multiplataforma: se ejecuta en muchos tipos de CPU, no solo Intel
Multiusuario: varios usuarios en la misma maquina al mismo tiempo (y sin licencias para
todos)
Manejo de la Memoria: la memoria gestiona como un recurso unificado para los
programas de usuario y para cache de disco, de tal forma que toda la memoria libre
puede ser usada para cache y este puede a su vez ser reducido cuando se ejecutan
grandes programas
Interfaz Grafica de Usuario: KDE, GNOME.
Desarrollo de Software: KDevelop (Lenguaje C, C++, Java, PHP, Perl, Phyton, entre
otros)
Trabajo de redes: TCP/IP, incluyendo ftp, telnet, NFS, Gíreles, etc.
Disponibilidad del código Fuente: todo el código fuente esta disponible, incluyendo el
núcleo completo, todos los drivers, las herramientas de desarrollo y todos los
programas de usuario; además están disponibles libremente.

pág. 26

Software disponible en Linux

En Linux se encuentran disponibles varios tipos de software. Algunas de las categorías son:
Aplicaciones
Software de Desarrollo
Software Científico
Software de Sistema
Utilitarios
Juegos.

Distribuciones Linux.
Linux es un sistema de libre distribución por lo que puedes encontrar todos los ficheros y
programas necesarios para su funcionamiento en multitud de servidores conectados a Internet.
La tarea de reunir todos los ficheros y programas necesarios, asi como instalarlos en tu sistema y
configurarlo, puede ser una tarea bastante complicada y no apta para muchos. Por esto mismo,
nacieron las llamadas distribuciones de Linux, empresas y organizaciones que se dedican a hacer
el trabajo "sucio" para nuestro beneficio y comodidad.

Ilustración 5 Distribuciones de Linux

Una distribución no es otra cosa, que una recopilación de programas y ficheros, organizados y
preparados para su instalación. Estas distribuciones se pueden obtener a traves de Internet, los
cuales contendrán todo lo necesario para instalar un sistema Linux bastante completo y en la
mayoría de los casos un programa de instalación que nos ayudara en la tarea de una primera
instalación. Casi todos los principales distribuidores de Linux, ofrecen la posibilidad de bajarse
sus distribuciones, via FTP (sin cargo alguno).
pág. 27

Existen muchas y variadas distribuciones creadas por diferentes empresas y organizaciones a

unos precios bastantes asequibles (si se compran los CDs, en vez de bajársela via FTP), las cuales
deberías poder encontrar en tiendas de informática ó librerías. En el peor de los casos siempre
puedes encargarlas directamente por Internet a las empresas y organizaciones que las crean. A
veces, las revistas de informática sacan una edición bastante aceptable de alguna distribución.

A continuacion una gráfica con todas las distribuciones a lo largo de los últimos años. Este
gráfico es grande asi que pulsar en el mismo para ver la versión en tamaño original.

Ilustración 6 Distribuciones en los ultimos años
Si vas a instalar el sistema por primera vez, te recomiendo que pruebes una distribucion LiveCD.
Con una de ellas podras probar Linux sin necesidad de instalarlo. A continuación puedes
encontrar informacion sobre las distribuciones más importantes de Linux (aunque no las únicas).
UBUNTU.-Distribución basada en Debian, con lo que esto conlleva y

centrada en el usuario final y facilidad de uso. Muy popular y con
mucho soporte en la comunidad. El entorno de escritorio por defecto es
GNOME.

http://www.ubuntu.com/
pág. 28

REDHAT ENTERPRISE.-Esta es una distribución que tiene muy buena

calidad, contenidos y soporte a los usuarios por parte de la empresa
que la distribuye. Es necesario el pago de una licencia de soporte.
Enfocada a empresas.

http://www.redhat.com/
FEDORA.-Esta es una distribución patrocinada por RedHat y soportada

por la comunidad. Facil de instalar y buena calidad.

http://fedora.redhat.com/
DEBIAN.- Otra distribución con muy buena calidad. El proceso de

instalacion es quizas un poco mas complicado, pero sin mayores
problemas. Gran estabilidad antes que últimos avances.
http://www.debian.org/

OpenSuSE.-Otra de las grandes. Facil de instalar. Version libre de la

distribucion comercial SuSE.

http://www.opensuse.org/es/
SuSE LINUX ENTERPRISE.-Otra de las grandes. Muy buena calidad,

contenidos y soporte a los usuarios por parte de la empresa que la
distribuye, Novell. Es necesario el pago de una licencia de soporte.
Enfocada a empresas.

https://www.suse.com/
SLACKWARE.- Esta distribución es de las primeras que existio. Tuvo un

periodo en el cual no se actualizo muy a menudo, pero eso es historia.
Es raro encontrar usuarios de los que empezaron en el mundo linux
hace tiempo, que no hayan tenido esta distribucion instalada en su

ordenador en algun momento.
http://www.slackware.com/
pág. 29

GENTOO.-Esta distribución es una de las unicas que incorporaron un

concepto totalmente nuevo en Linux. Es una sistema inspirado en BSD-
ports. Podeis compilar/optimizar vuestro sistema completamente
desde cero. No es recomendable adentrarse en esta distribucion sin
una buena conexion a internet, un ordenador medianamente potente
(si quereis terminar de compilar en un tiempo prudencial) y cierta
experiencia en sistemas Unix.

http://www.gentoo.org/
KUBUNTU.-Distribución basada en Ubuntu, con lo que esto conlleva y

centrada en el usuario final y facilidad de uso. La gran diferencia con
Ubuntu es que el entorno de escritorio por defecto es KDE.

http://www.kubuntu.org/
MANDRIVA.-Esta distribución fue creada en 1998 con el objetivo de

acercar el uso de Linux a todos los usuarios, en un principio se llamo
Mandrake Linux. Facilidad de uso para todos los usuarios.

http://www.mandrivalinux.org/
pág. 30

Estándar de Jerarquía de Sistema de Archivos.

Introducción.
El estándar de jerarquía de archivos (FHS o Filesystem Hierarchy Standard) define los principales
directorios y sus contenidos en GNU/Linux y otros sistemas operativos similares a Unix.
En agosto de 1993 inició un proceso para desarrollar un estándar de sistema de archivos
jerárquico, como un esfuerzo para reorganizar las estructuras de archivos y directorios de
GNU/Linux. El 14 de Febrero de 1994 se publicó el FSSTND (Filesystem Standard), un estándar
de jerarquía de archivos específico para GNU/Linux. Revisiones de éste se publicaron el 9 de
Octubre de 1994 y el 28 de Marzo de 1995.
A principios de 1996, con la ayuda de miembros de la comunidad de desarrolladores de BSD, se

fijó como objetivo el desarrollar una versión de FSSTND más detallada y dirigida no solo hacia
Linux sino también hacia otros sistemas operativos similares a Unix. Como uno de los resultados
el estándar cambió de nombre a FHS o Filesystem Hierarchy Standard.

El FHS es mantenido por Free Standards Group, una organización sin fines de lucro constituida
por compañías que manufacturan sustento físico (Hardware) y equipamiento lógico (Software)
como Hewlett Packard, Dell, IBM y Red Hat. La mayoría de las distribuciones de Linux, inclusive
las que forman parte de Free Software Standards, utilizan este estándar sin aplicarlo de manera
estricta.
La versión 2.3 del FHS, que es la utilizada por CentOS, Fedora™, Red Hat™ Enterprise Linux,
openSUSE™ y SUSE™ Linux Enterprise, fue anunciada el 29 de enero de 2004.
Estructura de los directorios general

En el sistema de ficheros de UNIX (y similares), existen varias “sub-jerarquías” de directorios
que poseen múltiples y diferentes funciones de almacenamiento y organización en todo el
sistema.[1] Estos directorios pueden clasificarse en:
Estáticos: Contiene archivos que no cambian sin la intervención del administrador (root),
sin embargo, pueden ser leídos por cualquier otro usuario. (/bin, /sbin, /opt, /boot,
/usr/bin...)
Dinámicos: Contiene archivos que son cambiantes, y pueden leerse y escribirse (algunos
sólo por su respectivo usuario y el root). Contienen configuraciones, documentos, etc. Para
estos directorios, es recomendable una copia de seguridad con frecuencia, o mejor aún,
pág. 31

deberían ser montados en una partición aparte en el mismo disco, como por ejemplo,
montar el directorio /home en otra partición del mismo disco, independiente de la
partición principal del sistema; de esta forma, puede repararse el sistema sin afectar o
borrar los documentos de los usuarios. (/var/mail, /var/spool, /var/run, /var/lock,
/home...)
Compartidos: Contiene archivos que se pueden encontrar en un ordenador y utilizarse en
otro, o incluso compartirse entre usuarios.
Restringidos: Contiene ficheros que no se pueden compartir, solo son modificables por el
administrador. (/etc, /boot, /var/run, /var/lock...)
Estructura de Archivos

Existe una estructura de archivos estándar FHS (Filesystem Hierarchy Standard) El estándar de
jerarquía de archivos que es un conjunto de recomendaciones orientadas a la compatibilidad de
aplicaciones, herramientas de administración y desarrollo entre distintos sistemas. Esta es una
de las estructuras de archivos que deja la instalación por defecto de CentOS

Pero esa estructura tiene ventajas tales como:

• Permitir al software conocer la ubicación de directorios y archivos instalados; Permitir al
software conocer donde se deben instalar los archivos de un programa
• Permitir al usuario conocer dónde encontrar los archivos y directorios de los programas
instalados. En un sistema que cumpla con las especificaciones del FHS, los directorios del
sistema de archivos raíz o "/", deben ser suficientes para arrancar, reparar y/o recuperar
el sistema.
Los siguientes directorios son necesarios en el directorio raíz o "/":
En este directorio están los ficheros ejecutables básicos (bin = binarios) Directorio /boot
Aquí están los ficheros y directorios de arranque (boot) Directorio /dev
Contiene ficheros de dispositivos. Directorio /etc
Contiene ficheros y directorios de configuración específicos de tu sistema.

pág. 32

Ilustración 7 Contenido del directorio /etc

Directorio /bin: En este directorio están los ficheros ejecutables básicos (bin = binaries)
Directorio /boot: Aquí están los ficheros y directorios de arranque (boot)
Directorio /dev: Contiene ficheros de dispositivos.
Directorio /etc: Contiene ficheros y directorios de configuración específicos de tu sistema.
Directorio /home: Contiene los archivos utilizados por el usuario, documentos, escritorio,
descargas, etc.
Directorio /lib: Bibliotecas compartidas esenciales para los binarios de /bin/, /sbin/ y el
núcleo del sistema.
Directorio /lost+found: Directorio especifico para archivos perdidos. Cada partición tiene
el suyo propio independientemente.
Directorio /media: Puntos de montaje para dispositivos de medios como unidades lectoras
de discos compactos.
Directorio /misc: Abreviación de miscelánea.
Directorio /mnt: Sistemas de ficheros montados temporalmente.
Directorio/opt: En este directorio se suelen almacenar todos los archivos de una
instalación fuera de los repositorios como puede ser cuando instalamos un .deb
Directorio/proc: Directorio que contiene información sobre diferentes partes del sistema,
cpu, discos, tiempo uptime, irqs, memoria, etc
Directorio/root: Directorio particular del superusuario del sistema ( root )
Directorio/sbin: Contiene archivos ejecutables que por lo general son comandos usados
para la administración del sistema.
Directorio /srv: Es un directorio que contiene datos específicos que son servidos por el
sistema servidor (SeRVer).
Directorio /sys: Contiene parámetros de configuración del sistema que se está ejecutando.
pág. 33

Datos referidos al kernel, bus, dispositivos, firmware, fs (filesystem) y otros.

Directorio /tmp: Directorio donde se almacenan los ficheros temporales. Son ficheros que
se eliminan con el apagado del sistema.
Directorio /usr: Este es el espacio compartido de todos los usuarios del sistema. Aquí se
guardan los datos compartidos de usuarios: aplicaciones, librerías, manuales, etc.
Directorio /var: Contiene los datos que están cambiando continuamente en el sistema
como ficheros de log del sistema, correo, colas de impresión, etc.
El diseño predeterminado del instalador de CentOS, Fedora™ y Red Hat™ Enterprise Linux utiliza
4 particiones:
Partición Descripción
/boot Requiere de 200 MiB a 512 MiB.
/ Si se utiliza el diseño de tres particiones, asignar el resto

del espacio disponible en la unidad de almacenamiento. Si
se van asignar particiones para los directorios
mencionados adelante, se requieren de 3072 MiB a 5120
MiB.
/home En estaciones de trabajo, a esta partición se asigna al
menos la mitad del espacio disponible para
almacenamiento.
Memoria de Memoria diseñada para el intercambio de información
intercambio (Swap) cuando la memoria ram es insuficiente.

Los siguientes directorios jamás deberán estar fuera de la partición que corresponda a /, es
decir, “jamás se deben asignar como particiones separadas”:
/etc
/bin
/dev
/lib y /lib64
/media
/mnt
/proc
/root
pág. 34

/sbin
/sys
Para futuras versiones de CentOS, el directorio /var también deberá estar dentro de la misma
partición que corresponda a /, pues el proceso de arranque, que será gestionado por Systemd,
así lo requerirá.
Otras particiones que se recomienda asignar, son:
Partición Función
/usr Requiere al menos 3072 MiB en instalaciones básicas. Debe

considerarse el equipamiento lógico se planee instalar a futuro. Para
uso general se recomiendan al menos de 5120 MiB, y, de ser posible,
considere un tamaño óptimo de hasta 20480 MiB.
/tmp Requiere al menos 350 MiB y puede asignarse hasta 5 GiB o más,
dependiendo de la carga de trabajo y del tipo de aplicaciones. Si, por
ejemplo, el sistema cuenta con un grabador de DVD, será necesario
asignar a /tmp el espacio suficiente para almacenar una imagen de
disco DVD, es decir, al menos 4.2 GiB, asumiendo que es de una sola
cara y de densidad simple. Algunas distribuciones de vanguardia
utilizan un disco RAM —es decir un RAM disk— para este directorio
con la finalidad de mejorar el rendimiento del sistema.
/var Requiere al menos 3072 MiB en estaciones de trabajo sin servicios.
En servidores regularmente se le asigna al menos la mitad del
espacio disponible para almacenamiento.
/usr/local Requiere al menos 3072 MiB en instalaciones básicas. Debe
considerarse el equipamiento lógico que se planee compilar desde
código fuente, e instalar, a futuro. Al igual que /usr, para uso general
se recomiendan al menos de 5120 MiB, y, de ser posible, considere
un tamaño óptimo de hasta 20480 MiB.
/opt Requiere al menos 3072 MiB en instalaciones básicas. Debe
considerarse el equipamiento lógico de terceros que se planee
instalar a futuro. Al igual que /usr, para uso general se recomiendan
al menos de 5120 MiB, y, de ser posible, considere un tamaño
óptimo de hasta 20480 MiB.
/var/lib Si se asigna como partición independiente de /var, lo cual permitiría
optimizar el registro por diario utilizando el modo journal para un
pág. 35

Partición Función
mejor desempeño, requiere al menos 3072 MiB en instalaciones

básicas. Deben considerarse las bases de datos o directorios de
LDAP, que se planeen hospedar a futuro. Recuerde que LDAP es
capaz de mandar mensajes a nivel de PING, de igual manera que es
usado para actualizar el cache de la librería del software.
/var/www o Dependiendo del sistema operativo utilizado, el directorio raíz del
/srv/www servidor HTTP Apache puede encontrarse dentro de dos diferentes
rutas. CentOS, Fedora™ y Red Hat™ Enterprise Linux utilizan
/var/www, mientras que openSUSE™ y SUSE™ Linux Enterprise
utilizan /srv/www. Asignar como partición independiente cualquiera
de éstos directorios permite optimizar el registro por diario —
utilizando el modo writeback— para mejorar el desempeño.
Requiere al menos 3072 MiB en instalaciones básicas. Deben
considerarse los anfitriones virtuales, aplicaciones y contenido para
ser servido a través del protocolo HTTP, que se planeen hospedar a
futuro.

Instalacion Centos

CentOS es una distribución Linux de clase empresarial derivado de fuentes libremente ofrecidos
al público por un destacado proveedor de América del Norte Enterprise Linux. CentOS se ajuste
plenamente a la política de redistribución del proveedor de aguas arriba y aspira a ser 100%
compatible a nivel binario. (CentOS principalmente cambia los paquetes para eliminar marcas
comerciales del proveedor y obras de arte.) CentOS es gratuito. CentOS es desarrollado por un
equipo pequeño pero creciente número de desarrolladores del núcleo. A su vez, los
desarrolladores principales están respaldados por una activa comunidad de usuarios como los
administradores de sistemas, administradores de redes, los usuarios empresariales, gerentes,
colaboradores principales de Linux y los entusiastas de Linux de todo el mundo. CentOS tiene
numerosas ventajas sobre algunos de los proyectos de otros clones, incluyendo: una activa y la
creciente comunidad de usuarios, reconstruida rápidamente, probado y QA'ed paquetes de
erratas, una extensa red de servidores espejos , los desarrolladores que están tocados y de
respuesta, múltiples vías de apoyo gratuitos, como un Chat IRC , listas de correo , Foros , una
dinámica de preguntas frecuentes . Este sitio hace uso de Javascript. Si su navegador no
funciona con JavaScript, le recomendamos que use Firefox.
pág. 36

Introducción
Bienvenidos a la versión 6.5 de CentOS, una Distribución Linux de Rango Empresarial obtenida a
partir de los fuentes puestos a libre disposición del público por nuestro Proveedor de OS
(Upstream OS Provider , UOP).
CentOS se adapta completamente a la política de redistribución de nuestro proveedor y aspira a
ser 100% compatible con sus binarios (CentOS principalmente modifica los paquetes para
eliminar la marca y el diseño gráfico original).
Hemos decidido no imitar la utilización que hace el UOP de los Códigos de Instalación. Todos los
canales están a disposición del administrador del sistema en el momento de la instalación.

Siguiendo la práctica del proveedor original de los fuentes, no hay soporte para actualizar la
instalación desde una versión principal anterior de CentOS (en estos momentos CentOS 5 o
CentOS 4) a una versión posterior. Esto no es una limitación impuesta por CentOS, sino que
refleja la postura del proveedor en esta cuestión.
Quienes se sientan aventureros y quieran experimentar, que no olviden hacer y comprobar
previamente una copia de respaldo. Como aviso para aquellos que intenten la actualización a
pesar de esta advertencia, por ejemplo mediante la no soportada opción upgreadeany
utilizando la línea de comandos del medio de instalación, por favor, tengan en cuenta que
necesitarán recuperar manualmente el paquete centos-release actual, hacer manualmente un
rpm -e nodeps para eliminar el paquete centos-release anterior, y entonces instalar
manualmente el paquete centos-release de CentOS 6, pues de lo contrario yum no tendría
ninguna posibilidad de funcionar correctamente.
PROCEDIMIENTO
Al hacer boot se nos dan 2 opciones para instalar, la primera el sistema detectara la tarjeta de
vídeo y entrara en modo gráfico (lo cual a veces falla) por lo tanto recomiendo elegir la segunda
opción; la cual carga un driver básico de vídeo que diría que todos los equipos reconocen sin
problemas. Presionamos Enter

pág. 37

-Podemos verificar si nuestro DVD o instalación de USB están OK. Si ya lo hicimos o

estamos seguros, damos Enter en Skip

pág. 38

ENTORNO GRAFICO:

Vamos a iniciar la instalación del sistema operativo, damos clic en next

Seleccionamos el idioma
pág. 39

Seleccionamos la distribución del teclado

Damos en la opción Basic que aparece por defecto
pág. 40

Damos en la opción no conservar datos, puesto que tenemos un espacio ya designado en
el disco para la instalación

Le asignamos el nombre a nuestro servidor (Dominio)

pág. 41

Verificamos que el DHCP este marcada la casilla conectar automático

Seleccionamos el área o región para los usos horarios
pág. 42

Asignamos una contraseña para nuestro administrador root
«Usar todo el espacio» eliminará cualquier partición de cualquier otro sistema operativo
presente y creará de forma automática las particiones necesarias.
«Reemplazar sistema(s) Linux existente(s)» sólo eliminará todas las particiones Linux
existentes y creará de forma automática las particiones necesarias.
«Achicar el sistema actual» cambiará el tamaño de las particiones existentes de otros
sistemas operativos como Windows, haciendo el espacio necesario para poder instalar un
diseño predeterminado de particiones Linux.
«Usar espacio libre» creará de forma automática las particiones necesarias en el espacio
disponible, basándose sobre un diseño predeterminado.
«Crear un diseño personalizado» permitirá elegir las particiones estándar o volúmenes
lógicos, que uno requiera.

pág. 43

Seleccionamos crear un diseño personalizado, para asignarle los porcentajes a las carpetas
del sistema manualmente

En esta imagen muestra que tenemos 50 GB de espacio disponible, lo distribuiremos de la
siguiente forma: el 50% lo dividimos para las carpetas (/) y (home). Y el 50% restante lo
dividimos en 6 para las demás carpetas, EJEMPLO
pág. 44

Seleccionamos crear partición estándar y le asignamos el porcentaje
pág. 45

Le damos en formatear
pág. 46

Elegimos la opción que necesitemos, en este caso servidor básico y seleccionamos la opción
personalizar ahora para seleccionar los paquetes a instalar

pág. 47

pág. 48

Esperamos que carguen los archivos de la instalación
pág. 49

Reiniciamos

Conceptos importantes, hay que recordar que siempre hay que distinguir los distintos
dispositivos en las instalaciones:

/dev = dispositivo
/sda = disco duro
/st0 = dispositivo de cinta grabable
/nst0 = dispositivo de cinta en modo no regrabable

Y los tipos de particiones, anteriores, actuales y los mas importantes:

ext2 - Second Extended Filesystem es un consolidado y maduro sistema de archivos para
GNU/Linux muy estable. Uno de sus inconvenientes es que no tiene apoyo para el registro
(journaling) (véase más abajo) o las barreras. La falta de registro por diario («journaling») puede
traducirse en la pérdida de datos en caso de un corte de corriente o fallo del sistema. También
puede no ser conveniente para las particiones root (/) y /home, porque las comprobaciones del
sistema de archivos pueden tomar mucho tiempo.
Un sistema de archivos ext2 puede ser convertido a ext3.
ext3(soporta Jornaling) - Third Extended Filesystem es, esencialmente, el sistema de archivos
ext2 pero con el apoyo de journaling y la escritura de barreras. Es compatible con ext2, bien
probado, y extremadamente estable.
ReiserFS(soporta Jornaling) - Sistema de archivos con journaling y altas prestaciones de Hans
Reiser (V3) que utiliza un método muy interesante de transferencia de datos basado en un
algoritmo creativo e innovador. ReiserFS es anunciado como muy rápido, especialmente cuando
se trata de muchos archivos pequeños. ReiserFS es rápido en dar formato, sin embargo,
comparativamente lento en el montaje. Muy maduro y estable. ReiserFS (V3) no está siendo
activamente desarrollado en este momento. Generalmente considerado como una buena
opción para /var.
XFS (soporta Jornaling) - Primeros sistemas de archivos con journaling desarrollado
originalmente por Silicon Graphics para el sistema operativo IRIX y portado después a
GNU/Linux. Proporciona un rendimiento muy rápido en los archivos y sistemas de archivos
grandes y es muy rápido en el formato y montaje. Pruebas de benchmark comparativa han
demostrado que es más lento cuando trata con muchos archivos pequeños. XFS es muy maduro
pág. 50

y ofrece capacidad de desfragmentación en línea, además este permite soporte para ACLs sin
opciones de montado especial.

Felicidades Tu Servidor ha sido instalado de manera satisfactoria!!!!

Hay que tener en cuenta la importancia de recordar lo siguiente:

1. Para que vamos a utilizar nuestro servidor, es decir para administración de páginas
web, administración de puntos de venta, administración corporativa, etc.
2. El ciclo de vida que manejaremos dependiendo del tipo de instalación que tendremos y
el cual es vital para este punto.
3. El Hardware que se maneja y el volumen de usuarios a los cuales se les dara soporte
con este.
Una vez terminando de instalar el servidor por ahora solo hacermos una corrección al server
para poder tener salida a internet y este es realizando una corrección al archivo que esta
ubicado en la siguiente ruta

Vi /etc/sysconfig/network-scripts/ifcfg-eth0

Lo cual nos abrirá un archive con la siguiente estructura:

DEVICE="eth0"
NM_CONTROLLED="yes"
ONBOOT="yes"
HWADDR=08:00:27:89:15:BE
TYPE=Ethernet
BOOTPROTO=dhcp

La opción ONBOOT, debe estar en no, con la tecla i, podremos insertar la modificación, entrares
y lo modificaremos a “yes” y saldremos del archivo con “:wq” y reiniciaremos el sistema.

Tenga cuidado de no modificar nada mas en el archivo pues no tendrá acceso a internet.
pág. 51

Editor de texto VI y VIM

Vi (Visual) es un programa informático que entra en la categoría de los editores de texto. Pues a
diferencia de un procesador de texto no ofrece herramientas para determinar visualmente
cómo quedará el documento impreso. Por esto carece de opción como centrada o justificación
de párrafos, pero permite mover, copiar, eliminar o insertar caracteres con mucha versatilidad.
Este tipo de programas es frecuentemente utilizado por programadores para escribir código
fuente de software.

Vi fue originalmente escrito por Bill Joy en 1976, tomando recursos de ed y ex, dos editores de
texto para Unix, que trataban de crear y editar archivos, de ahí, la creación de vi.
Hay una versión mejorada que se llama Vim, pero Vi es un editor de texto que se encuentra en
—casi— todo sistema de tipo Unix, de forma que conocer rudimentos de Vi es una salvaguarda
ante operaciones de emergencia en diversos sistemas operativos.

Vim (del inglés Vi IMproved) es una versión mejorada del editor de texto vi, presente en todos
los sistemas UNIX.
Su autor, Bram Moolenaar, presentó la primera versión en 1991, fecha desde la que ha
experimentado muchas mejoras. La principal característica tanto de Vim como de Vi consiste en
que disponen de diferentes modos entre los que se alterna para realizar ciertas operaciones, lo
que los diferencia de la mayoría de editores comunes, que tienen un solo modo en el que se
introducen las órdenes mediante combinaciones de teclas o interfaces gráficas.
La mejor forma de entender estos conceptos es simplemente usando vi para editar un archivo de
prueba.

La sintaxis para vi es: vi
Nombrearchivo
donde nombrearchivo es el nombre del archivo que quieres editar.

Así se inicia el editor y, como el fichero no existe todavía, lo crea para ser editado. El editor está
ahora en modo de comandos esperando por un comando.

Partamos vi tipeando [xxx]%
vi prueba
pág. 52

Ejemplo

lo cual editará el archivo prueba. Deberías ver algo como esto:

~
~
~
~
~
~
"prueba" [New file]

para comenzar a insertar texto usa la tecla i

Mientras estés insertando texto, puedes tipear cuantas líneas quieras (presionando [Enter]
después de cada una, por supuesto), y puedes corregir los errores.
Para finalizar el modo de edición, y volver al modo de comandos, presiona [esc]. Mientras estés
en modo de comandos, puedes usar las teclas de flechas para moverte
por todo el archivo. Aquí, como tenemos solo una línea de texto, al tratar de usar las
flechas para subir y para bajar vi hará un pitido.

Las siguientes teclas controlar el movimiento del cursor.

k arriba
j abajo
h izquierda
l derecha

Modo de entrada de texto (añadir, insertar)

a añade texto a partir del carácter en que está situado el cursor i inserta texto a partir de la
posición del cursor
o inserta una línea debajo de la posición del cursor
O inserta una línea encima de la posición del cursor
pág. 53

Borrando y cambiando texto

Los cinco comandos más utilizados para alterar el texto son x borra el carácter en el cursor
r sustituye el carácter en el cursor
dd borra la línea en la que está el cursor
:s/palabrainicial/palabrafinal/c cambia de a una de las coincidencias
:s/palabrainicial/palabrafinal/g cambia todas las coincidencias
Estos cinco comandos son ejecutados en el modo de comandos, y vuelven al modo de
comandos después de ejecutarse.
Deshaciendo cambios
Hay veces que se realizan cambios y nos damos cuenta inmediatamente que hemos cometido
un error. El editor vi facilita mecanismos para deshacer acciones de comandos previos.

El comando u deshace el comando previo.

El comando U deshace todos los cambios realizados en la línea actual.
Guardando cambios y permaneciendo en vi
Es muy recomendable guardar los cambios que se van realizando de una forma regular. Para ello
se utiliza

:w

Si decides que no quieres sobrescribir el fichero que estás editando, sino que quieres guardar los
cambios como un fichero nuevo, añade al comando :w el nombre del nuevo fichero,

:w nuevo_fichero2

Abandonando vi

Para dejar vi se utiliza;

ZZ Guarda los cambios en el fichero original, y vuelve al intérprete de comandos
:wq Igual que ZZ
:q! Abandona el editor, no guarda los cambios, y vuelve al intérprete de comandos
pág. 54

Comandos adicionales para posicionamiento del cursor

Además de las teclas h, j, k, l existen cuatro más:
b mueve el cursor al comienzo de la palabra anterior e mueve el cursor al final de la palabra
siguiente
0 mueve el cursor al comienzo de la línea (cero)
$ mueve el cursor al final de la línea

Los comandos para avanzar una pantalla arriba y abajo (12 líneas) son control-d una pantalla
abajo control-u una pantalla arriba

Para ficheros muy largos, se puede ir a una línea del texto 3000G a a la línea número 3000
Para posicionar el curso en la última línea del fichero, teclea /G/
Para posicionar el cursor al comienzo del fichero, teclea 1G
El siguiente comando muestra el número de línea actual control-g

Búsqueda

Otro método de posicionarse dentro de un fichero es buscando una cadena de caracteres. En el
modo de comandos, cualquier cadena de caracteres precedida por / significa el comando de
búsqueda hacia adelante. El cursor se posiciona en la primera ocurrencia de dicha cadena.

El comando n busca hacia adelante la siguiente ocurrencia. Para buscar hacia atrás, se utiliza el
comando?
Borrar texto

Ya se vio anteriormente el comando dd para borrar la línea actual.

El comando dw borra la palabra actual. Nótese que el comando de borrado comienza por d,
seguido por el ámbito de aplicación (d para una línea, w para una palabra (word en inglés)).
Quitar y poner

Cuando se borra algo, es almacenado en un buffer temporal. El contenido de este buffer puede
ser accedido y 'puesto' o pegado en cualquier sitio del texto.
pág. 55

Para recuperar el último texto borrado, se usa el comando p

Resumen y algo mas

El presente editor consta de diferentes comandos, los cuales se dan a conocer en el siguiente
resumen:

vi [archivo].

Movimientos básicos:
=> Un espacio a la izquierda. j => Una línea hacia abajo.
k => Una línea hacia arriba.
l => Un espacio a la derecha.
$ => Mueve al final de la línea actual.
+ => Comienzo de la línea siguiente.
- => Comienzo de la línea anterior. 0 => Comienzo de la línea actual.

Control de despliegue:

CTRL-d => Deslizar hacia adelante.

CTRL-u => Deslizar hacia atrás.
CTRL-f => Pantalla siguiente.
CTRL-b => Pantalla anterior
CTRL-l => Redibuja la pantalla.
G => Moverse al final del archivo.

Comandos para agregar textos:

A => A final de la línea. i => Antes del cursor.

I => Al principio de la línea.
O => Abre una línea por encima. O
=> Abre una línea por debajo.

Comandos para eliminar y cambiar texto:

dd => Elimina línea.

cc => Cambiar línea.
pág. 56

D => Elimina hasta el final de línea.

C => Cambiar hasta final de línea
x => Elimina el carácter del cursor.
r => Cambia el carácter del cursor.

Comandos sobre palabras:

cw => Cambiar palabra.
dw => Elimina palabra.
:s/palabrainicial/palabrafinal/c cambia de a una de las incidencias
:s/palabrainicial/palabrafinal/g cambia todas las incidencias
e => Mueve cursor a final de palabra.
w => Mueve cursor a siguiente palabra.

Comandos de búsqueda:

/ => Búsqueda hacia adelante.

? => búsqueda hacia atrás.
n => Siguiente ocurrencia.
N => Posterior ocurrencia.
:set nu => mostrar números de línea

Comandos de edición avanzada:

u => Deshacer cambio más reciente.

U => Recupera todos los cambios de una línea.
p => Coloca el contenido del buffer a la derecha del cursor.
P => Coloca el contenido del buffer a la izquierda del cursor.
y => Copia los carácteres comenzando en el cursor en el buffer.
Y => Copia la línea actual completa en el buffer.

Comandos de control:

:w => Guarda sin salir.

:wq => Guarda y sale.
:q => Abandona si no hay modificaciones.
:q! => Abandona aún con los cambios.
pág. 57

:número => Ir a la línea número.

ZZ => Guarda y sale.

Otros
J unir dos líneas en una
C reemplaza caracteres
C o c$ reemplaza hasta el fin de línea
c0 reemplaza desde el comienzo de línea
BS borrar caracter hacia la izquierda
:set cambio de opciones
:set nonu no mostrar números de línea
:set showmode mostrar modo actual de vi
:set noshowmode no mostrar modo actual de vi
Nota: Los comandos en mayúsculas y minúsculas alteran el resultado (cuidado)

Para volver de nuevo al Modo de Comandos, lo cual es necesario, por ejemplo, para mover el
cursor, presiona la tecla de escape o <esc>. Si no recuerdas en qué modo estás presiona <esc>:
si estabas en Modo de Inserción, ahora pasas al Modo de Comandos; si estabas en Modo de
Comandos, vi emitirá un pitido y te dejará en Modo de Comandos.

Un editor de texto es simplemente un programa que se usa para editar ficheros que contengan
texto. Aunque hay muchos editores disponibles, el único que vas a encontrar seguro en todos
los sistemas UNIX es vi (el "editor visual").

Existe un editor vi ampliado llamado vim que contiene facilidades adicionales, así como diversas
versiones del vi original. En todos los casos, el conjunto de comandos básicos es el mismo.

Ejercicio:

Instala VI y VIM
Generamos un usuario nuevo y que no tenga privilegios:
# useradd –m pruebavi
Asignamos un password a nuestro usuario
# passwd pruebavi
Nos cambiamos al usuario
pág. 58

# su –l pruebavi
Creamos un documento nuevo con el comando vim
$ vim nuevo.txt
~
~
~
~
~
~
"nuevo.txt" [New file]
Una vez abierto el documento presionamos la tecla i para insertar texto nuevo
~
~
~
~
~
-INSERT-

Una vez que presiones i, aparecerá insertar en la interface, esto indica que podemos editar el
archivo creado, una vez hecho esto escribiremos la frase Linux el mejor sistema y pulsamos
enter, a continuación escribiremos “El megor sistema que conosco” este texto tiene errores
ortográficos, escríbalo de manera errónea pues el ejercicio es para realizar dichas correcciones
utilizando el editor VIM.

~Linux el mejor sistema
~El megor sistema que conosco
~
~
~
-INSERT-
Ahora posicionese sobre la malabra “megor” sobre la letra g y presione shift + r y acontinuacion
aparecerá la opción remplazar, pulse la letra “j” y observe como se reemplaza por la letra g,
pág. 59

repita el procedimiento y corrija la letra z por la s en la palabra “conosco”

~ Linux el mejor sistema

~ El megor sistema que conosco
~
~
~
~
-REMPLAZAR-
Precione la tecla “Esc” seguido de : y la letra “w” para guardar los cambios.

~ El mejor sistema que conozco
~
~
~
~
:w
Al pulsar enter notara un mensaje que dice que los cambios han sido realizados.

Vuelva a pulsar: (dos puntos) y luego escriba otro.txt pulse enter y ahora notara que se guardo
el archivo con el nombre otro.txt


~
~
~
~
"otro.txt" [New file]

Vuelva a pulsar i, de nuevo aparecerá el mensaje de – INSERTAR –

~
~
pág. 60

~
~
-INSERT-

Escriba lo siguiente:


~Hoy es un dia aburrido
~conozco solo gente aburrida
~mi novia es muy aburrida
~
-INSERT-

Ahora pulse esc, seguido pulse: (dos puntos) y por ultimo escriba lo siguiente:
%s/aburrid/divertid/g


~Hoy es un dia aburrido
~conozco solo gente aburrida
~mi novia es muy aburrida
~
%s/aburrid/divertid/g

Pulse enter y observara lo siguiente:


~Hoy es un dia divertido
~conozco solo gente divertida
~mi novia es muy divertida
~
3 sustituciones en 3 lineas

En este ejercicio, el símbolo % indicaba que se aplicaría un procedimiento a todo el archivo,
además de la línea misma, la letra «s» indicaba que se realizaría la búsqueda de la cadena de
caracteres «mal» definida después de la diagonal (/) por la cadena de caracteres «aburrid» en
pág. 61

toda la línea, indicado por la letra «g».

A continuación, posiciones el cursor de teclado utilizando las flechas del teclado hasta el primer
carácter de la primera línea:
~El mejor sistema que conozco
~
Pulsamos la letra d en dos ocaciones para ver como se elimina la primera línea del archivo
~
Ahora pulsamos la tecla p para pegar la línea


~

En este caso usted podrá ver que se pega debajo del texto o donde tenga el cursor, lo cual
quiere decir que hay que posicionarse en la línea correcta para pegar lo copiado

Ahora posiciónese en la primera línea del texto y va a oprimir 3 y después dd y podra observar
como se copiaron ahora las 3 lineas consecutivas a partir de donde esta posicionado el texto y
podra pegar de la misma manera


~

Ahora vuelva a pulsar p y se restauran las tres líneas principales pero si pulsamos p de nueva se
volverán a pegar las líneas copiadas esto podría pasar n cantidad de veces según sea el caso

pág. 62


~
Ahora procedemos a salir del archivo guardando los datos, pulsaremos: wq seguido de enter


~ mi novia es muy divertida
~ Hoy es un dia divertido
~
: wq

Vuelva a editar el archivo pulsando vi nuevo.txt y pulsaremos : /divertid y veremos como se
raliza una búsqueda sombreando las cadenas de coincidencias.

pág. 63


~
/divertid

Para cancelar el resaltado de los resultados, pulse la combinación de teclas: nohl:
Si pulsamos shift + a, se realizara la inserción, pero al final de la línea.

Pulse Esc y seguido la tecla de la letra “o” y observara como se inicializa la función insertar pero
en una nueva línea.

~ conozco solo gente divertida
~
~
pág. 64

-INSERT-

Pulse nuevamente la tecla <Esc> y en seguida la combinación dG (d, luego SHIFT+G). Notará que
elimina todo el contenido del texto desde la posición del cursor hasta el final del archivo:


~
9 lineas menos

Precione: u y observara como se cancela la modificación hecha:

~ conozco solo gente divertida
~
~
9 Lineas más

Una vez verificado esto guardamos el archivo y salimos de la edición.

Para mayor información revisar la documentación y la orientación de comandos incluida en este

manual sobre VI.

Ajustes y Optimizacion del Servidor.

A partir de este momento se pretende realizar un checklist con los puntos importantes a
configurar en el server para ponerlo a punto para cualquier entrega.
pág. 65

Localización

La internacionalización es el proceso de diseñar software de manera tal que pueda adaptarse a
diferentes idiomas y regiones sin la necesidad de realizar cambios de ingeniería ni en el código.
La localización es el proceso de adaptar el software para una región específica mediante la
adición de componentes específicos de un locale y la traducción de los textos, por lo que
también se le puede denominar regionalización. No obstante la traducción literal del inglés es la
más extendida.1

Es una práctica común en el idioma inglés (sobre todo en el ámbito de la computación),
abreviar internationalization con elnumerónimo "i18n". Ello se debe a que entre la primera i y la
última ene de dicha palabra hay 18 letras. Lo mismo sucede con localization, que se abrevia
"L10n". La L mayúscula se utiliza para distinguirla de la i minúscula de i18n.
Algunas empresas, como Microsoft e IBM, usan el término globalización para referirse a la
combinación de internacionalización y localización. Globalización puede también abreviarse con
el numerónimo "g11n".
Internacionalización y localización son dos de los conceptos más en boca en la
moderna industria del lenguaje.

La localización del sistema se logra mediante la edición de 2 archivos localizados en las rutas:

/etc/sysconfig/i18n:

/boot/grub/menu.lst

En ambos hay que buscar la configuración LANG="es_ES.UTF-8” y hay que modificarla por
LANG=es_MX.UTF-8

Esto nos dará la virtud de modificar la configuración de español de España por la configuración
de español de México.
pág. 66

Una vez realizada esta tarea se realizara un reincio de sistema para hacer los cambios de manera
permanente con el comando:
#reboot y enter.
Plymouth:

Plymouth es un programa de arranque de sistema en modo gráfico que despliega una animación
mientras la computadora se inicia.
Plymouth ha sido desarrollado como reemplazo de RHGB (Red Hat Graphical Boot) y escrito
como un nuevo programa con el fin de lograr que "La experiencia de arranque sea sin
parpadeos, sutil y brillante".
Plymouth se ejecuta muy pronto en el proceso de arranque (incluso antes de que el sistema de
archivos raíz esté montado) Luego muestra una animación mientras el proceso de arranque de
sistema sucede en el fondo, antes y después de que Xcomienza hasta la ejecución de la entrada
de usuario. La idea es que Plymouth esté configurado de forma nativa para el arranque utilizado
por el sistema operativo. El objetivo final es deshacerse de todos los parpadeos durante el
inicio.

Para deshabilitar el Plymouth en Centos y poder mostrar los mensajes de lo que se carga y los
servicion en el sistema hay que desabilitarlo en el archivo que esta en la siguiente ruta:

vi /boot/grub/menu.lst

Nota: Hay que recordar que en este archivo es donde se configuran los distintos sistemas
operativos Linux a configurar y para esto hay que tener en cuenta que se debe configurar:

El titulo, el initrd y el kernel.

Se desabilita simplemente eliminando rhgb y el espacio sobrante del archive que se esta
editando en la linea:

latin1 crashkernel=auto rhgb quiet

se guarda el archive con :wq y listo.

pág. 67

Zona Horaria

Un ordenador tiene dos relojes que deben tenerse en cuenta: el «reloj del
hardware/ordenador» y el «reloj del sistema/software».

El reloj del hardware (también conocido como el Reloj en Tiempo Real (RTC) o reloj CMOS)
guarda los valores de: año, mes, día, hora, minuto y segundos. No tiene la capacidad de guardar
el horario estándar (localtime o UTC), ni si DST (horario de verano) se utiliza.
El reloj del sistema (también conocido como reloj del software) realiza un seguimiento de: Hora,
Zona horaria y DTS (el horario de verano, si procede). Ello es calculado por el kernel de Linux por
el número de segundos transcurridos desde la medianoche del 1 de enero 1970, UTC.

El valor inicial del reloj del sistema se establece a partir del reloj del hardware, en función de lo
establecido en el archivo /etc/adjtime. Una vez completado el arranque, el reloj del sistema se
configura independientemente del reloj del hardware. El kernel de Linux sigue los ajustes del
reloj del sistema para integrar las interrupciones del temporizador.

Para realizar la correccion del la zona horarioa hay que verificar y/o editar en caso de que sea
necesario el archivo que esta en la siguiente ruta:

vi /etc/sysconfig/clock

Asumiendo que nos encontramos en la ciudad de México tendríamos que verificar o cambiar
según sea el caso por

ZONE="America/Mexico_City"

Y realizaremos un remplazo de un archivo con el siguiente comando:

cp /usr/share/zoneinfo/America/Mexico_City /etc/localtime

Para poder garantizar que la hora tanto local como on line están sincronizados también
instalaremos el archivo ntp

yum -y install ntp
pág. 68

Con este método garantizaríamos la sincronización de la hora tanto de manera local con en
línea, siempre y cuando exista una conexión a internet.
La manera de ver la hora seria pulsando el comando.

# date o date –s

Control – Alt – Supr

En el principio creó Dios los cielos y la Tierra. Y la tierra estaba desordenada, vacía y las tinieblas
estaban sobre la faz del abismo y como Dios vio que esto era malo dijo: ¡Sea CTRL+ALT+SUPR
una secuencia de teclas que me permita salirme de un programa que ha dejado de ser
ejecutado o para reiniciar el Universo! Así fue pues, como Dios, reinicio el universo y le creó de
nuevo a la galaxia, y por consiguiente nuestro planeta, que después de todo, le salio bien
bonito!
100 millones de años después, el famoso evangelista y experto en electrónica: Bill Gates, decidió
crear un sistema operativo para computadoras personales, de manera que pudiese llevar esta
herramienta a todos los hogares del planeta y cristianizar a todo el mundo. Sin embargo, el
sistema operativo de Gates tenia muchos fallos, los cuales obligaban al usuario a desconectar a
la máquina de la toma de corriente, nada parecía solventar los problemas del software y todo
parecía perdido para Bill, pero mientras leía la Biblia se percato de la solución, y el resto es
historia.

Desactivar esta conbinacion de teclas:

Hay que editar el siguiente archivo

vi /etc/init/control-alt-delete.conf

y lo único que hay que hacer es comentar con un #, la línea:

exec /sbin/shutdown -r now "Control-Alt-Delete pressed"

y automaticamente quedara desabilitada dicha función.

pág. 69

Planificadores de entrada / salida.

Planificación de E/S (entrada/salida) es el término utilizado para describir el método mediante el

cual los sistemas operativos deciden una cosa el orden por el cual se van a enviar las peticiones
de lectura y escritura al subsistema de disco. A veces se le llama también planificación de disco.

Existen varias razones por las que puede ser deseable aplicar métodos de planificación de E/S:
Minimizar el tiempo de búsqueda (seek time) en el disco.
Dar prioridad a las peticiones de E/S de ciertos procesos.
Dar una porción del ancho de banda de lectura del disco a cada proceso.
Garantizar que ciertas peticiones se atenderán antes de un tiempo determinado: la
conocida como deadline (línea de la muerte en inglés).

Los planificadores de E/S normalmente tienen que trabajar con discos que comparten la
propiedad de tardar bastante tiempo en acceder a una posición que esté muy alejada de la
posición actual del cabezal (lo que se conoce como un tiempo de búsqueda o seek time elevado).
Para minizar el efecto que esto tiene sobre el rendimiento del sistema de E/S, muchos
planificadores implementan variantes del algoritmo del ascensor, que lo que hace es reordenar
las peticiones aleatorias siguiendo el orden en que el cabezal se irá encontrando las posiciones
demandadas.

Planificadores de I/O disponibles en linux

Completely Fair Queuing (cfq): CFQ es la predeterminada en muchas distribuciones de
Linux. CFQ coloca solicitudes sincrónicas presentados por los procesos en un número de
colas por proceso y luego asigna intervalos de tiempo para cada una de las colas para
acceder al disco. La longitud de la porción de tiempo y el número de peticiones de una cola
se le permite presentar depende de la prioridad de E/S del proceso dado. Peticiones
asíncronas para todos los procesos se procesan por lotes juntos en un menor número de
colas, una para cada ámbito prioritario.
NOOP (noop): Es el planificador de Entrada/Salida más simple que existe para el núcleo de
Linux. Funciona insertando todas las peticiones de Entrada/Salida, dentro de una cola de
procesamiento tipo FIFO (first in, first out, que se traduce como primero en entrar, primero
en salir), e implementando fusión de peticiones y reduciendo el tiempo de petición, y la
variabilidad del tiempo de servicio de Entrada/Salida.
pág. 70

Anticipatory (anticipatory): Es un algoritmo para programar el disco duro E/S. Su objetivo

es aumentar la eficiencia de la utilización del disco de “Previsión” operaciones de lectura
sincrónica.
Deadline (deadline): El objetivo de Deadline es garantizar un tiempo de servicio de inicio
de la petición. Para ello, se establece un plazo de todas las operaciones de E/S para evitar
colisión de las solicitudes.

Diferencia entre estos:

CFQ: Configuracion que esta definida por default y recomendada si desconoce el uso de los
planificadores.

ANTICIPATORY: Planificador diseñado para servidores HTTP o sistemas con hw SCSI-1 o

IDE/serial ATA, diseñada para equipos antiguos la cual presta rendimiento superior al minimo.

DEADLINE: Su funcionamiento es basado al funcionamiento en tiempo real, funciona a la par de

la escritura y distribucion del ancho de banda con respecto al dispositivo, recomendado para
servers con dispositivos de tipo PATA, SATA, SCSI-2.

NOOP: El mas común de todos, su funcionamiento esta basado en un algoritmo FIFO,

recomendado para servidores con unidades de tipo flash, NAND, SDRAM, unidades controladas
por tarjetas inteligentes como RAID y sistemas basados en MV.

La manera de ver que planificador tenemos en funcionamiento es realizando el siguiente

mandato:

# cat /sys/block/sdc/queue/scheduler
noop anticipatory deadline [cfq]
# cat /sys/block/sda/queue/scheduler
noop anticipatory deadline [cfq]

para realizar la modificación de este se debe editar el archivo menú.lst que se encuentra en la
ruta

vi /boot/grub/menú.lst
pág. 71

y hay que agregar el código elevator=cfq/anticipatory/noop/deadline según sea el caso en el

código:

kernel /vmlinuz-2.6.32-279.el6.i686 ro root=UUID=09c6dc39-a62b-409e-8306-
5344640cd104 rd_LVM_LV=Swap/LogVol00 rd_NO_LUKS rd_NO_MD rd_NO_DM LANG=es_MX.
UTF-8 SYSFONT=latarcyrheb-sun16 KEYBOARDTYPE=pc KEYTABLE=la-
latin1 crashkernel=auto rhgb quiet elevator=noop
initrd /initramfs-2.6.32-279.el6.i686.img

Una vez realizado el cambio reiniciar para guardar los cambios de manera definitiva.

Uso de disco de rescate en CentOS 6.5

Esta tarea es el equivalente a tener algun problema con el arranque del sistema o con el server
en comun, por lo cual recurriremos a meter el DVD en la disquetera y bootear desde esta para
realizar las tareas de reparacion o de mantenimiento segun sea el caso

Una vez que booteemos con el DVD nos aparecera la misma interfaz de inicio cuano realizamos
la instalacion la primera vez.

Aqui cambiaremos el IDE secundario maestro y pondermos la imagen

pág. 72

Una vez seleccionado se aceptan los cambios y se inicia la instalación

En esta hay que mover el cursor con las flechas para detener el contador automatico que corre
con un total de 60 segundos, antes de que se realize la seleccion de manera automatica.

pág. 73

Ahora seleccionaremos la opcion numero 3, que indica Rescue installed System, con lo cual
accesaremos a las opciones de rescate de sistema.

Una vez que se realice la deteccion de la media realizara una carga y nos pedira el idioma con el
cual trabajaremos, seleccionaremos español
pág. 74

A continuacion elegiremos el idioma del teclado, el cual es importante para manipulacion de la
consola con la que trabajaremos.

A continuación nos pide que elijamos si vamos a necesitar la configuracion de la tarjeta de red.

pág. 75

Automaticamente nos detectara la tarjeta o tarjetas de red conectadas al servidor.

De ser necesarias se realizan las configuracion con las direcciones necesarias para lograr las
conexiones y poder realizar los respaldos.

pág. 76

Una vez realizada la configuracion nos desplegara las siguientes opciones que nos indican lo
siguiente.

CONTINUAR >> El entorno de rescate intentará encontrar una instalación de GNU/Linux en el

disco duro e intentará montar todas las particiones en el árbol que corresponde, debajo del
directorio /mnt/sysimage. De este modo se podrá acceder en modo lectura y escritura al
sistema de archivos y así poder realizar los cambios o modificaciones que requiera.

MODO LECTURA >> Similar a la opción anterior, pero todo el sistema de archivos se montará en
modo de sólo lectura.

OMITIR >> Se omitirá el montado del sistema de archivos del disco duro. Esta opción es idónea
para realizar reparaciones del sistema de archivos de las particiones, utilizando fsck o bien para
realizar operaciones que requieren que las particiones estén sin montar.

AVANZADO >> Permitirá hacer uso de dispositivos especiales de almacenamiento, como Redes
de Área de Almacenamiento (SAN), es decir FCoE, iSCSI y zFCP.

De este modo seleccionaremos continuar lo cual realizara una deteccion de los dispositivos, y se
realizara el montaje de los directories en el fhs de /mnt/sysimage
pág. 77

Y seleccionaremos continuar:

Una vez realizada esta tarea nos enviara a una nueva interfaz con 3 opciones distintas:

pág. 78

SHELL START SHELL >> Iniciará el intérprete de mandatos, desde el cual podrá trabajar de
modo similar al nivel de ejecución 1 (mono usuario) y tendrá acceso a un conjunto básico de
herramientas de diagnóstico y reparación.
FAKD RUN DIAGNOSTIC >> Ejecutará FirstAidKit, una herramienta que realiza verificación y
reparación, automática de algunos problemas comúnes.
REBOOT REBOOT >>. Reiniciará el sistema.
pág. 79

Seleccionaremos la opcion de Start Shell

Esto nos dejara en la consola de administracion con permisos de Root

La opción de Fakd realizara una tarea de diagnostic y reparacion si es necesaria.

Con la opción reboot se realizara un reincio de sistema.

Una vez realizadas last areas realizaremos el apagado de la maquina y reconfiguraremos el disco
pág. 80

a su estado normal para reiniciar.

Nivel de Ejecución 1 o monousuario

Un sistema operativo monousuario (de mono: 'uno'; y usuario) es un sistema operativo que sólo
puede ser ocupado por un único usuario en un determinado tiempo. Ejemplo de sistemas
monousuario son las versiones domésticas de Windows. Administra recursos de memoria
procesos y dispositivos de las PC'S.
Es un sistema en el cual el tipo de usuario no está definido y, por lo tanto, los datos que tiene el
sistema son accesibles para cualquiera que pueda conectarse.
En algunos sistemas operativos se accede al sistema reproductor de un usuario único que tiene
permiso para realizar cualquier operación. Este es el caso de los sistemas operativos más
antiguos como MS-DOS y algunos más recientes como la serie Windows 95/98/Me de Microsoft
o MacOS (antes de Mac OS X) de Macintosh. En estos sistemas no existe una diferenciación clara
entre las tareas que realiza un administrador del sistema y las tareas que realizan los usuarios
habituales, no disponiendo del concepto de multiusuario, un usuario común tiene acceso a
todas las capacidades del sistema, pudiendo borrar, incluso, información vital para su
funcionamiento. Un usuario malicioso (remoto o no) que obtenga acceso al sistema podrá
realizar todo lo que desee por no existir dichas limitaciones.
Nivel de ejecucion 1 o s (single), es el nivel de ejecucion de monousuario, sin acceso a servicios
pág. 81

de red, este nivel es regularmente utilizado en tareas de mantenimiento del sistema y el usuario
que ejecuta es root, permite reparar problemas en el sistema.

La manera de acceder al sistema en modo monousuario es el siguiente:

Cuando se inicia el sistema lo primero que carga es el grub, donde se encuentran las tablas de
booteo, en caso de tener mas sistemas seria la parte donde se elegiria el sistema a iniciar, en
nuestro caso que solo tenemos un sistemas iniciara un contador de 3 segundo, para lo cual
detendremos este conteo presionando cualquier tecla menos enter, porque esto accesaria al
sistema de manera inmediata:

En este punto seleccionaremos la letra “p” para poder introducer el password del grub que se
ingreso en la instalacion inicial:
pág. 82

Se pone el password:

A continuacion presionaremos la tecla “e” para realizar la edicion del commando de booteo:

pág. 83

Seleccionamos la linea que del kernel de inicio:
Recuerde estas tres funciones del booteo o arranque
Lo primero es que el kernel o nucleo busca y monta el initrd
Linuxrc carga los modulos para montar el file system
El gestor de arranque carga el kernel e inintrd en la memoria.

Editamos esta de igual forma y al final de la linea ponemos un espacio y un numero “1”,
presionamos enter y nos regresara a la lista de configuraciones nuevamente, estando en esta
presionamos b como indica el menu para realizar el booteo:

pág. 84

Y esto nos dara acceso al sistema en nivel monousuario, para realizar las tareas que impliquen
tener este tipo de nivel.

Gestion de memoria Swap

La memoria es uno de los recursos más valiosos que gestiona el sistema operativo. Uno de
los elementos principales que caracterizan un proceso es la memoria que utiliza. Ésta está
lógicamente separada de la de cualquier otro proceso del sistema (excepto los threads de un
mismo proceso que comparten normalmente la mayor parte de la memoria que tienen
asignada). Un proceso no puede acceder, al espacio de memoria asignado a otro proceso, lo
cual es imprescindible para la seguridad y estabilidad del sistema. El direccionamiento es una
parte importante de la gestión de memoria, puesto que influye mucho en la visión del mismo
por parte de un proceso, como en el aprovechamiento del hardware y el rendimiento del
sistema. En Linux, además, un proceso tiene dos espacios de memoria: el espacio de
memoria del usuario, único para ese proceso, y el espacio de memoria del kernel, idéntico en
todos los procesos.

Objetivos del sistema de gestión de memoria:

Ofrecer a cada proceso un espacio lógico propio.
Proporcionar protección entre procesos.
Permitir que los procesos compartan memoria.
pág. 85

Dar soporte a las distintas regiones del proceso.

Maximizar el rendimiento del sistema.
Proporcionar a los procesos mapas de memoria muy grandes.
Espacio de direcciones de un proceso
Conjunto de direcciones a las que hace referencia.

Los espacios de direcciones involucrados en la gestión de la memoria son de tres tipos:
A. Espacio de direcciones físicas. Las direcciones físicas son aquellas que referencian
alguna posición de la memoria física. Se obtienen después de aplicar una
transformación por parte de la MMU (Unidad de Manejo de Memoria).
B. Espacio de direcciones lógicas o virtuales. Las direcciones lógicas son las
direcciones utilizadas por los procesos. Sufren una serie de transformaciones,
realizadas por el procesador (la MMU), antes de convertirse en direcciones físicas.
C. Espacio de direcciones lineales. Las direcciones lineales se obtienen a partir de
las direcciones lógicas tras haber aplicado una transformación dependiente de la
arquitectura. En Linux las direcciones lógicas y lineales son idénticas. En el i386, es
el nombre que reciben las direcciones tras haber aplicado la técnica de
segmentación. En la segmentación, tras haber realizado las correspondientes
comprobaciones de seguridad, se le suma a la dirección lógica una cierta dirección
base, obteniendo así la dirección lineal. A partir del kernel de Linux 2.2.x, las
direcciones base de casi todos los segmentos es 0, y por lo tanto, las direcciones
lineales y las lógicas son las mismas.

La unidad de manejo de memoria (MMU) es parte del procesador. Sus funciones son:

a) Convertir las direcciones lógicas emitidas por los procesos en direcciones físicas.
b) Comprobar que la conversión se puede realizar. La dirección lógica podría no tener
una dirección física asociada. Por ejemplo, la página correspondiente a una
dirección se puede haber intercambiada a una zona de almacenamiento secundario
temporalmente.
c) Comprobar que el proceso que intenta acceder a una cierta dirección de memoria
tiene permisos para ello.

En caso de fallo se lanzará una excepción que deberá ser resuelta por el kernel del sistema
operativo. El kernel del sistema operativo está siempre en memoria principal, puesto que si se
intercambia a una zona de almacenamiento secundario, ¿quién sería el encargado de llevarlo a
pág. 86

memoria principal cuándo se produjera un fallo de acceso a memoria?

La MMU se inicializa para cada proceso del sistema. Esto permite que cada proceso pueda
usar el rango completo de direcciones lógicas (memoria virtual), ya que las conversiones de
estas direcciones serán distintas para cada proceso.

En todos los procesos se configura la MMU para que la zona del kernel (el cuarto gigabyte)
sólo se pueda acceder en modo kernel (modo privilegiado). La configuración correspondiente al
espacio de memoria del kernel es idéntica en todos los procesos. Todos los threads de un
mismo proceso también compartirán la configuración del espacio de memoria del usuario.

Para ejecutar un proceso Þ debe estar, al menos en parte, en memoria principal. Subsistema de
Gestión de Memoria (parte del kernel del sistema operativo):

Decide qué procesos residen en memoria principal (al menos una parte).
Maneja parte del espacio de direcciones virtuales que ha quedado fuera.
Controla la cantidad de memoria principal.
Gestiona el intercambio de procesos entre memoria principal y memoria secundaria o
dispositivo de swap.
La memoria se asigna de la siguiente manera:

a. Si se tiene menos de 1Gb de memria ram, se asigna el doble de la cantidad de memoria.

b. Si se tienen mas de 1Gb de memoria ram, se asigna la cantidad de memoria ram mas 2.
pág. 87

Unidad 2 Administración del Sistema de Archivos.

Ext3 (third extended filesystem o "tercer sistema de archivos extendido") es un sistema de
archivos con registro por diario(journaling). Fue el sistema de archivos más usado
en distribuciones Linux, aunque en la actualidad ha sido remplazado por su sucesor, ext4.
La principal diferencia con ext2 es el registro por diario. Un sistema de archivos ext3 puede
ser montado y usado como un sistema de archivos ext2. Otra diferencia importante es que ext3
utiliza un árbol binario balanceado (árbol AVL) e incorpora elasignador de bloques de disco
Orlov.
Ventajas
Aunque su velocidad y escalabilidad es menor que sus competidores, como JFS, ReiserFS o XFS,
tiene la ventaja de permitir actualizar de ext2 a ext3 sin perder los datos almacenados ni tener
que formatear el disco. Tiene un menor consumo de CPU y está considerado más seguro que
otros sistemas de ficheros en Linux dada su relativa sencillez y su mayor tiempo de prueba.
El sistema de archivo ext3 agrega a ext2 lo siguiente:

Registro por diario.
Índices en árbol para directorios que ocupan múltiples bloques.
pág. 88

Límites de tamaño
Ext3 tiene dos límites de tamaño distintos. Uno para archivos y otro para el tamaño del sistema
de archivos entero. El límite del tamaño del sistema de archivos es de 232 bloques

Tamaño del Tamaño máximo de los Tamaño máximo del sistema de

bloque archivos ficheros
1 KiB 16 GiB 2 TiB
2 KiB 256 GiB 8 TiB
4 KiB 2 TiB 16 TiB
8 KiBlímites 1 2 TiB 32 TiB

Niveles del journaling

Hay tres niveles posibles de journaling (registro por diario)
Diario (riesgo bajo)
Los metadatos y los ficheros de contenido son copiados al diario antes de ser llevados al sistema
de archivos principal. Como el diario está en el disco continuamente puede mejorar el
rendimiento en ciertas ocasiones. En otras ocasiones el rendimiento es peor porque los datos
deben ser escritos dos veces, una al diario y otra a la parte principal del sistema de archivos.
Pedido (riesgo medio)

Solo los metadatos son registrados en el diario, los contenidos no, pero está asegurado que el
contenido del archivo es escrito en el disco antes de que el metadato asociado se marque como
transcrito en el diario. Es el sistema por defecto en la mayoría de las distribuciones de Linux. Si
hay un bajón de tensión o kernel Panic cuando el fichero se está escribiendo o está empezando,
el diario indicará que el nuevo archivo o el intento no ha sido pasado, por lo que será purgado
por el proceso de limpiado.
pág. 89

Reescritura (riesgo alto)
Solo los metadatos son registrados en el diario, el contenido de los archivos no. Los contenidos
pueden estar escritos antes o después de que el diario se actualice. Como resultado, los archivos
modificados correctamente antes de una ruptura pueden volverse corruptos. Por ejemplo, un
archivo pendiente de ser marcado en el diario como mayor de lo que actualmente es,
convirtiendo en basura al final de la comprobación. Las versiones antiguas de los archivos
pueden aparecer inesperadamente después de una recuperación de diario. La carencia de
sincronización entre los datos y el diario es rápidamente subsanada en muchos casos. JFS usa
este nivel de journaling, pero se asegura de que cualquier basura es borrada al reiniciar

Desventajas
Como ext3 está hecho para ser compatible con ext2, la mayoría de las estructuras del
archivación son similares a las del ext2. Por ello, ext3 carece de muchas características de los
diseños más recientes como las extensiones, la localización dinámica de los inodos, y la
sublocalización de los bloques. Hay un límite de 31998 subdirectorios por cada directorio, que se
derivan de su límite de 32000 links por inodo. Ext3, como la mayoría de los sistemas de archivos
actuales de Linux, no puede ser chequeado por el fsck mientras el sistema de archivos está
montado para la escritura. Si se intenta chequear un sistema de ficheros que está montado
puede detectar falsos errores donde los datos no han sido volcados al disco todavía, y
corromper el sistema de archivos al intentar arreglar esos errores.

Ext4 (fourth extended filesystem o «cuarto sistema de archivos extendido») es un sistema de
archivos transaccional (en inglésjournaling), anunciado el 10 de octubre de 2006 por Andrew
Morton, como una mejora compatible de ext3. El 25 de diciembre de2008 se publicó el kernel
Linux 2.6.28, que elimina ya la etiqueta de "experimental" de código de ext4.
Las principales mejoras son:
Soporte de volúmenes de hasta 1024 PiB.
Soporte añadido de extent.
Menor uso del CPU.
Mejoras en la velocidad de lectura y escritura.

pág. 90

Mejoras

Sistema de archivos de gran tamaño

El sistema de archivos ext4 es capaz de trabajar con volúmenes de gran tamaño, hasta
1 exbibyte1 y ficheros de tamaño de hasta 16 TiB.
Extents
Los extents han sido introducidos para reemplazar al tradicional esquema de bloques usado por
los sistemas de archivos ext2/3. Un extent es un conjunto de bloques físicos contiguos,
mejorando el rendimiento al trabajar con ficheros de gran tamaño y reduciendo la
fragmentación. Un extent simple en ext4 es capaz de mapear hasta 128 MiB de espacio contiguo
con un tamaño de bloque igual a 4 KiB.2

Compatibilidad hacia adelante y hacia atrás

Cualquier sistema ext3 existente puede ser montado como ext4 sin necesidad de cambios en el
formato del disco. También es posible actualizar un sistema de archivos ext3 para conseguir las
ventajas del ext4 ejecutando un par de comandos. Esto significa que se puede mejorar el
rendimiento, los límites de almacenamiento y las características de sistemas de archivos ext3 sin
reformatear y/o reinstalar el sistema operativo. Si se requiere de las ventajas de ext4 en un
sistema de producción, se puede actualizar el sistema de archivos. El procedimiento es seguro y
no existe riesgo para los datos (aunque siempre es recomendado hacer un respaldo de la
información crítica). Ext4 usará la nueva estructura de datos sólo para la información nueva. La
estructura antigua será conservada sin modificación y será posible leerla y/o modificarla cuando
sea necesario. Esto significa que si se convierte un sistema de archivos a ext4 no se podrá
regresar a ext3 de nuevo.3
El uso de extents está fijado por defecto desde la versión del kernel 2.6.23. Anteriormente, esta
opción requería ser activada explícitamente (por ejemplo mount /dev/sda1 /mnt/point -t
ext4dev -o extents ).

Asignación persistente de espacio en el disco
El sistema de archivos ext4 permite la reserva de espacio en disco para un fichero. Hasta ahora
la metodología consistía en rellenar el fichero en el disco con ceros en el momento de su
creación. Esta técnica no es ya necesaria con ext4, ya que una nueva llamada del sistema
"preallocate()" ha sido añadida al kernel Linux para uso de los sistemas de archivos que
permitan esta función. El espacio reservado para estos ficheros quedará garantizado y con
mucha probabilidad será contiguo. Esta función tiene útiles aplicaciones en streaming y bases de
datos.
pág. 91

Asignación retrasada de espacio en el disco
Ext4 hace uso de una técnica de mejora de rendimiento llamada Allocate-on-flush, también
conocida como reserva de memoria retrasada. Consiste en retrasar la reserva de bloques de
memoria hasta que la información esté a punto de ser escrita en el disco, a diferencia de otros
sistemas de archivos, los cuales reservan los bloques necesarios antes de ese paso. Esto mejora
el rendimiento y reduce la fragmentación al mejorar las decisiones de reserva de memoria
basada en el tamaño real del fichero.

Límite de 32000 subdirectorios superado
En ext3 el nivel de profundidad en subdirectorios permitido estaba limitado a 32000. Este límite
ha sido aumentado a 64000 en ext4, permitiendo incluso ir más allá de este límite (haciendo uso
de "dir_nlink"). Para permitir un rendimiento continuo, dada la posibilidad de directorios mucho
más grandes, htree está activado por defecto en ext4. Esta función está implementada desde la
versión 2.6.23. htree está también disponible en ext3 cuando la función dir_index está activada.

Chequeo del sistema de ficheros más rápido
En ext4, los grupos de bloques no asignados y secciones de la tabla de inodos están marcados
como tales. Esto permite a e2fsck saltárselos completamente en los chequeos y en gran medida
reduce el tiempo requerido para chequear un sistema de archivos del tamaño para el que ext4
está preparado. Esta función está implementada desde la versión 2.6.24 del kernel Linux.

Uso de e2fsck

Permite escanear el sistema de archivos de particiones ext2/ext3/ext4 verificando que no

existan errores. Es muy importante aplicar el comando e2fsck sólo a particiones que “no estén
montadas”. Además, antes de comenzar, es necesario que tengas claro cuáles son tus
particiones, para ello puedes ejecutar el comando fdisk de la siguiente forma: fdisk -l o ejecuta
el comando cfdisk sin parámetros.

Recuerde que la tabla de particiones con fdisk cambia de la siguiente manera:
a. Inicia Fdisk
b. Cambia la tabla de particiones
c. Escribe la tabla de particiones en el disco duro
d. Sale de Fdisk
e. Realiza la carga

pág. 92

Recuerde que las particiones tienes ciertas características:

Una partición extendida puede ser subdivida en N cantidad de particiones lógicas
Una partición primaria consiste en un continuo rango de cilindros o fragmentos
Las particiones lógicas no requieren entradas en la tabla principal de particiones

De igual manera puede ver las particiones dando df y especificar la parición a demontar y
realizar el ejercicio:

Ejemplo

e2fsck -pc /dev/sda1 comprueba el sistema de ficheros /dev/sda1 revisando los sectores
defectuosos (-c esta opción usa la herramienta badblocks, en caso de usar dos veces esta opción
el escaneo de sectores dañados se hará usando un test no destructivo de lectura/escritura.)
permitiendo que la lista de sectores dañados pueda actualizarse y se repararán
automáticamente todos los problemas que sea seguro arreglar (-p).

e2fsck -E fragcheck /dev/sda3 se imprimirá en pantalla un reporte de aquellos archivos que
presenten bloques discontinuos en el sistema de archivos /dev/sda3

e2fsck –f –D /dev/sda1 la D realiza la optimizacion de los directories, y la –f realiza la tarea de
manera forzada para la verificacion de las particiones.
badblocks
Este programa lo único que hace es comprobar los sectores y mostrar los que son defectuosos,
por lo que es preferible que se emplee integrado con un programa encargado de comprobar la
coherencia del sistema de ficheros si lo que se quiere es "repararlo". Si lo único que se buscas es
ver el estado de la superficie del disco, sin importarte la información que contenga, por ejemplo
para saber si debes o no tirar el disco se puede ejecutar:
badblocks -ns /dev/sda comprueba los sectores del dispositivo /dev/sda en modo solo lectura
(-n)

Noatime (No tiempos de acceso)

Hoy vamos a ver una configuración muy simple de aplicar, y que hace que el sistema vaya
muuucho más flúido. Y estoy hablando del parámetro "noatime".

pág. 93

Qué es esto de "noatime"? Pues "noatime " es un parámetro especial en el montaje de los
dispositivos como discos duros o memórias extraibles. Se acostumbra a modificar en el fichero
/etc/fstab.

[Explicación]
Resulta que nuestro sistema de ficheros guarda, para cada uno de nuestros ficheros, un
parámetro que se llama "atime", o "access time". Total, que cada vez que accedemos
(leemos) un fichero, el valor "atime" se actualiza. Así podemos saber cuál fué la última vez que
accedimos/leimos un determinado fichero.
Pero claro, esto tiene un comportamiento no deseado: Resulta que por cada lectura que
hacemos a disco, necesitamos escribir algo a disco!! (Actualizar el valor "access time"). Esto
parece absurdo! Para leer tenemos que escribir.

Habrá alguien que pensará: exagerado! No es para tanto. Total, tiene que escribir a disco tan
solo unos pocos bytes, esto no es nhà.

Pues bueno, resulta que escribir estos pocos bytes si jode, y mucho. Me explico. Linux tiene un
sistema fantástico de caches, completamente transparente para el usuario. Te permite hacer lo
siguiente:

# cat ./bashrc
# cat ./bashrc

La primera vez que haces el "cat" de cualquier fichero ( en nuestro caso, .bashrc ), se va al disco
duro, y lo lee. Pero también lo pone en la memoria RAM. La segunda vez que ejecutas el
comando "cat", sabe que lo tiene cacheado y lo lee directamente de memória RAM. No hace
falta tocar disco duro. Esto hace que el sistema vaya muuuucho más rápido, ya que todo los
ficheros que hayas leido una vez ( y no se hayan modificado ) ya están cacheados, y no se
precisa leer a disco. Pero que pasa si no tenemos desactivado el "atime", pues que con
cada lectura, aunque la tuvieses cacheada, tienes que hacer una escritura a disco para
actualizar el tiempo de acceso. Nos ha jodido.

Esto, en portátiles tiene un impacto muy grande ya que al cabo de X segundos de no utilizar
el disco duro, éste se para. Un tema de ahorro de energía. Qué pasa si queremos hacer una
pág. 94

lectura o escritura? Pues que el disco se tiene que volver a poner a girar con el consiguiente
consumo energético/tiempo perdido. Pero si intentamos leer un fichero CACHEADO por el
sistema, el disco duro ni se entera. Sigue parado. Por lo que es genial.

Como hacerlo:
Cómo activar la opción "noatime"?
Con tu editor preferido (gedit, nano, emacs) el fichero, en mi caso "vim":
# sudo vim /etc/fstab

Busca tu disco duro principal. Lo mas seguro es que sea una entrada como esta:
UUID=3e9532f9-226c-4f17-ae64-dad42519a1fc / ext4 errors=remount-ro 0 1

y añade simplemente "noatime" en las opciones para que quede tal que así:
UUID=3e9532f9-226c-4f17-ae64-dad42519a1fc / ext4 noatime,errors=remount-ro 0 1

y punto. Reinicia y ya lo tienes.

[Cuándo aplicar esta configuración]
Bueno pues, recomendado, a todas las máquinas en general. Sin excepción.

Muy recomendado, en portátiles. Por el tema de ahorro de corriente, y del encendido/parado
del disco.

Y OBLIGATORIO en los equipos:

- Servidores ( web-ftp-sambda ) con muchas lecturas. Aquí si que utilizar el sistema de cachés es
algo básico, y no quitar el atime podría hacer que el rendimiento fuese pésimo.
- Equipos con discos duros SSD. Esto es debido a que los SSD tienen un número de escrituras
máximas por bloque, y al llegar este número se desactiva el bloque y no se utiliza nunca más.
Por lo que tener el "atime" activado significa que la vida del disco va a ser mucho mas corta.

pág. 95

Swapinees
De modo predeterminado, el núcleo de Linux utiliza un valor de 60 para vm.swapiness y tiene la
finalidad de permitir hacer pruebas a los desarrolladores del núcleo de Linux.
Este valor corresponde a la frecuencia con la que las aplicaciones utilizan memoria virtual.
Pueden establecerse valores entre 0 y 100, donde el valor más bajo establece que se utilice
menos la memoria de intercambio, lo cual significa que se reclamará en su lugar el caché de la
memoria.

Para la mayoría de los casos, conviene cambiar este valor por uno más bajo a fin de que el
sistema utilice menos la memoria de intercambio y utilice más la memoria cache. Ésta es una
clase de memoria RAM estática de acceso aleatorio (SRAM o
Static Random Access Memory). Se sitúa entre la Unidad Central de Procesamiento (CPU) y la
memoria RAM y se presenta de forma temporal y automática para el usuario proporcionado
acceso rápido a los datos de uso más frecuente.

Lo más recomendable es cambiar el valor de vm.swappiness a 10, que resulta un valor más
apropiado para un sistema de escritorio o una portátil. Para tal fin, se edita el archivo
/etc/sysctl.conf y se añade al final de éste:
vm.swappiness = 10
Con lo anterior, la siguiente vez que se inicie el sistema aplicará el cambio y se utilizará con
menos frecuencia la memoria virtual. Para que el cambio surta efecto de inmediato, se ejecuta
lo siguiente:
sysctl -w vm.swappiness=10

Si se asigna 0 (cero) como valor para vm.swappiness, se estará desactivando el uso de memoria
virtual, lo cual es poco recomendado, salvo que se disponga de una buena cantidad de memoria
física. Por lo general, el valor 0 para esta opción se utiliza solo en portátiles con unidades SSD,
donde, de hecho, se busca realizar cuanto menos escritura como sea posible sobre las unidades
de almacenamiento.

Commit
Esta opción controla el tiempo que se utilizará entra cada operación sincronización (sync) de
datos y metadatos en una partición. El tiempo predeterminado es de 5 segundos y puede
incrementarse para mejorar el desempeño, tomando en consideración que si se específica
pág. 96

demasiado tiempo y ocurre una interrupción de energía antes de hacer una operación de
sincronización (sync), se perderán los datos más recientes con los que se haya trabajado. Sólo
usarla se recomienda si se dispone de un sistema de respaldo de energía confiable.
/dev/mapper/lv_varwww /var/www ext4 defaults,commit=30 1 2
fsck (file system check o bien file system consistency check) es una utilidad de los
sistemas Unix y similares, como Linux, AIX y MAC OS X que se utiliza ante alguna inconsistencia
del sistema de archivos para corregir los posibles errores en el sistema.
fsck se ejecuta automáticamente al inicio del sistema ante alguna anomalía, pero también
puede ser utilizada manualmente por el administrador del sistema para forzar una verificación.
Para verificar un sistema de archivos es muy aconsejable hacerlo mientras éste
está desmontado.
Para detectar, verificar y corregir los errores del sistema de archivos. Es recomendable utilizarlo
solo con sistemas desmontados.
Su sintaxis es de la forma:

fsck [-sAVRTMNP] [-C[fd]] [-t fstype] [filesys..] [fs-specific-options]

Donde:
-C Muestra el progreso en tiempo real de un modo visual.
-A Chequea todos los dispositivos definidos en el fichero /etc/fstab
-M No chequea sistemas montados.
-t Especifica el tipo o tipos de sistema de ficheros a chequear. Si lo acompañamos de la
opción -A, solo chequearemos los sistemas que coincidan con fstype(una lista
separada por comas).
Filesys

Puede ser el nombre de un dispositivo (/dev/hdc1, /dev/sda3), un punto de montaje

(/, /usr, /home) o un label o UUID (UUID=f6c797e5-605b-4884-92d7-cdb694a42122,
LABEL=home). Si no se especifica, por defecto se analizaran los definidos en el
fichero /etc/fstab
pág. 97

Opciones:
--a repara de manera automática, no pide confirmación.
--n reporta los problemas sin repararlos.
--c busca bloques dañados y los agrega a la lista de bloques dañados.
--f forzar la revisión.
--v verbose, genera más información.
--r modo interactivo. Espera nuestra respuesta.
--y si a todo.
Ejercicio:
Con el siguiente comando determinamos que dispositivo corresponde a /boot:

# df -h | grep /boot
Desmontamos la partición correspondiente a /boot.
# umount /boot
Revisamos nuevamente que la partición /boot esté desmontada:
# df -h | grep /boot
Siempre que se incluye la opción “–y” se asume que se responderá que si a todas las preguntas
de confirmación que mande la ejecución de los comandos y con la opción “–C” muestra una
barra de progreso.
# fsck -fyC /dev/sda1
Si añadimos la opción –c realizara la verificación de solo lectura para realizarla sobre bloques
que pudieran estar dañados, y con la opción –k preservara la lista donde añadirán los nuevos
bloques dañados.
# fsck -fykc /dev/sda1

Realizando la tarera con la opción –cc realizara la verificación de lectura y escritura pero de
manera no destructiva.
# fsck -fykcc /dev/sda1

Con la opción –p realizara la verificación y reparación de manera automática.
# fsck -fpC /dev/sda1

Comando que realiza la misma tarea, pero combinando todas la opciones mencionadas
pág. 98

anteriormente.
# fsck -fpkcc /dev/sda1

Con la opción “–D” realizara la verificación optimizando al mismo tiempo la estrutura de los
directorios.
# fsck -fpD /dev/sda1

La optimización de directorios se realiza volviendo a crear un índice de éstos sí el sistema de
archivos incluye soporte para índices (como es el caso de Ext4) o bien re-ordenando y
comprimiendo directorios en los casos de directorios pequeños o bien sistemas de archivos que
utilicen directorios lineales tradicionales.
Con el comando en este formato este se añade al inodo (nodo índice) de bloques dañados.
# fsck -fpDkcc /dev/sda1

Montaremos /boot una vez terminado el ejercicio.
# mount /boot
Con el siguiente comando forzaremos a realizar una verificación de sistema de archivos:
# shutdown -F -r now

Uso de dd
El comando dd (Dataset Definition), es una herramienta sencilla, útil, y sorprendentemente fácil

de usar; con esta herramienta se puede hacer lo mismo, sobre dispositivos: discos y particiones,
que con programas comerciales como Norton Ghost, en Windows o libres como CloneZilla, en
Linux, con solo una pequeña línea de comandos.
Sintaxis Básica:
La sintaxis más básica para el uso del comando dd, seria esta:
$ sudo dd if=origen of=destino
Donde if significa “input file=archivo de entrada“, es decir, lo que se quiere copiar y of significa
pág. 99

“output file=archivo de salida“, o sea, el archivo destino (donde se van a copiar los datos);
origen y destino pueden ser dispositivos (lectora de CD o DVD, disco duro, diskettera, pendrive,
partición, etc.), archivo de copia de seguridad o imagen de disco, etc, pero no carpetas o
subcarpetas.
Para el uso sin problemas de este comando, lo primero siempre es tener claro como se llaman
las particiones/discos duros en Linux (/dev/sda1 por ejemplo; /dev deriva de device=
dispositivo, en inglés). Para saber el disco/partición de origen y el de destino, algo que
averiguamos fácilmente con el comando sudo fdisk -l o con algún programa gráfico de
particiones como gparted. Toda la información sobre el comando dd, se puede consultar con el
comando man dd e info dd ,
Se debe utilizar este comando con precaución, y comprobando siempre el orden y nombre de
los discos/particiones, porque lo mismo que se clona un disco, lo borra en un visto y no visto.

Sintaxis con el comando pv: Usar el comando dd con la sintaxis anterior tiene un pequeño
inconveniente, ya que es un comando muy reservado – no da información – , pues al ejecutarlo,
el prompt de la terminal queda inmóvil, por lo que no sabemos que es lo que esta pasando y
cuanto tiempo falta para que termine de ejecutarse. Este pequeño inconveniente se puede
solucionar añadiendo el comando pv, ( *) – el cual actúa como una tubería de terminal que mide
los datos que pasan a través de ella- a la sintaxis del comando dd , de forma que ahora la
sintaxis seria:
$ dd if=origen |pv|dd of=destino
Como resultado obtendríamos en el terminal una especie de barra de progreso, la información

sobre bytes transferidos, el tiempo que lleva ejecutándose y la tasa de transferencia, todo esto
en tiempo real.
( alf ) – ( ~ )
>> dd if=/demmcblk0p1 |pv|dd of=/dev/mmcblk0p2
1,630GB 0:21:30 [1,12MB/s] [
pág. 100

Además al terminar nos muestra estadísticas de la tasa de transferencia, el total de bytes

transferidos y el tiempo total que tardó en transferir todos los datos.
( alf ) - ( ~ )

└──┤ dd if=/devmmcblk0p1 |pv|dd of=/dev/mmcblk0p2

10530816+0 registros leídos <=>

10530816+0 registros escritos

5391777792 bytes (5.4 GB) copiados, 3873,48 s, 1,4 MB/s

5,02GB 1:04:33 [1,33MB/s] [ <=>

10530816+0 registros leídos <=>

10530816+0 registros escritos

5391777792 bytes (5.4 GB) copiados, 3873,48 s, 1,4 MB/s

( alf ) - ( ~ )

└──┤
(*) Comprobar antes de ejecutar cualquier linea de comandos con esta segunda sintaxis, que
tenemos instalado en el sistema el paquete pv, o instalarlo si no lo tuviéramos.
Vamos a ver algunos ejemplos prácticos y opciones de este comando ( en su versión con el truco
explicado anteriormente con el comando pv ) :
pág. 101

A) Sobre discos duros y particiones:

= Clonar un disco duro:
Con esto clonaríamos el disco hda en hdb. (discos IDE):
$ sudo dd if=/dev/hda |pv|dd of=/dev/hdb bs=1M
Con esto clonaríamos el disco sda en sdb. (discos SATA):
$ sudo dd if=/dev/hda |pv|dd of=/dev/sdb bs=1M

Con la opción bs=1M , se consigue que tanto la lectura como la escritura se haga en bloques de
1 megabyte, (menos, seria mas lento pero mas seguro, y con mas nos arriesgamos a perder
datos por el camino).
Hay que tener en cuenta que de esta forma se graba el disco “tal cual”, MBR, tabla de
particiones, espacio vacío, etc…, por lo que solo podrás grabar en un disco del mismo o mayor
tamaño.
= Grabar solo la primera partición (hda1) del disco de origen en el disco (hdb) de destino:
$ sudo dd if=/dev/hd1 |pv|dd of=/dev/hdb bs=1M

= Grabar el disco completo (hda) en la primera partición (hdb1) del disco de destino:

$ sudo dd if=/dev/hda |pv|dd of=/dev/hdb1 bs=1M

= Crear una imagen – puede ser bin o iso – del disco duro (hda) , en el directorio /home:

$ sudo dd if=/dev/hda |pv|dd of=/home/hda.bin

= Borrar totalmente la información de un disco: para ello, llena el disco con caracteres
aleatorios, cinco veces. No va a quedar ni rastro de información en el disco:
For n in {1..5}; do dd if=/dev/undandom |pv|dd of=/dev/hda bs=8b

Conv=notrunc;
= Borrar cualquier partición y disco completo de cualquier dispositivo:

$ sudo dd if=/dev/zero |pv|dd of=/dev/sdx (borrado del disco completo)
pág. 102

$ sudo dd if=/dev/zero |pv|dd of=/dev/sdxa (borrar una partición)

donde: x es el disco a borrar , a es la partición a borrar

Esta operación es muy útil para borrar completamente cualquier partición, además los datos
que se borrarán no se pueden recuperar, por lo tanto es un borrado a bajo nivel y muy seguro,
muy útil por ejemplo para cuando los pendrives se nos infectan de virus con nuestro querido
windows.
B) Sobre un CD/DVD
= Crear/Montar una imagen .iso de un CD (o DVD)

Para crear la imagen .iso de un CD en el directorio /home:

$ sudo dd if=/dev/cdrom |pv|dd of=/home/imagendeCD.iso

Para montar la imagen .iso del CD:

$ sudo mount –o loop imagendeCD.iso /mnt/home

= Recuperar un DVD rayado (Esto no recupera todo el DVD, en este caso, solo los sectores
legibles). Sirve también para discos duros defectuosos:

$ sudo dd if=/dev/cdrom |pv|dd of=/home/dvd_recuperadp.iso
conv=noerror,sync

La opción noerror, sirve para obviar los errores de lectura en cualquier situación.
pág. 103

C) Sobre MBR y VBS:
Los primeros 512 bytes del disco duro o unidad de almacenamiento utilizado para el sistema
operativo, corresponde al sector de arranque maestro, donde:
Los primeros 446 bytes corresponden al gestor de arranque
Los siguientes 64 bytes corresponden a la tabla de particiones. 16 bytes para cada partición
primaria y/o extendida que existan.
Los últimos 2 bytes corresponden a la firma de unidad con capacidad de inicio. También se
les conoce como los 2 bytes mágicos.
= Copiar/Restaurar el Master Boot Record (MBR):

Para copiar el MBR:

# dd if=/dev/sda of=mbr.bin bs=512 count=1

Para restaurar el MBR:

# dd if=mbr.bin of=/dev/sda bs=512 count=1

= Limpiar nuestro MBR y la tabla de particiones:

$ sudo dd if=/dev/zero |pv|dd of=/dev/had bs=512 count=1

= Limpia el MBR pero no toca la tabla de particiones, ( muy útil para borrar el GRUB sin perder
datos en las particiones):

$ sudo dd if=/dev/zero |pv|dd of=/dev/had bs=446 count=1

= Copiar/Restaurar el Volume Boot Sector (VBS):
Para copiar el VBS:
$ sudo dd if=/dev/hda |pv|dd of=/home/sector_arranque_hda count=1 bs=512
pág. 104

Para restaurar el VBS:

$ sudo dd if=/home/sector_arranque_hda |pv|dd of=/dev/had
D) Otros:
= Grabar una imagen del disco en nuestro directorio /home saltándonos los errores del disco
(muy útil para discos que se están muriendo):
$ sudo dd conv=noerror if=/dev/hda |pv|dd of=~/home/imagen_disco_con_errores-iso

= Crear un archivo vacío de 1 Mb:
$ sudo dd if=/dev/zero |pv|dd of=archivo_nuevo_vacio bs=1024 count=1024

= Crear un archivo swap de 2Gb:

$ sudo dd if=/dev/zero |pv|dd of=/swapspace bs=4k count=2048 mkswap /swapspace

# swapon /swapspace

= Convertir todas las letras en mayúsculas:

$ sudo dd if=miarchivo |pv|dd of=miarchivo conv=ucase

Formato de bajo nivel.
Si es necesario dar un formato de bajo nivel a fin de eliminar toda la información del disco duro,
puede ejecutar lo siguiente, considerando en el ejemplo que se intenta dar formato de bajo
nivel al disco duro /dev/sda, para escribir 0 (ceros) en cada sector de la unidad de
almacenamiento.
# dd if=/dev/zero of=/dev/sda
pág. 105

Ejecute lo siguiente para dar formato de bajo nivel escribiendo números aleatorios en todos los
sectores de una unidad de almacenamiento que corresponde a /dev/sda:
# dd if=/dev/urandom of=/dev/sda
pág. 106

Unidad 3. Administración de Sofware y servicios.

Antiguamente muchos programas Linux eran distribuidos como código fuente, que el usuario
construía en el programa o en la serie de programas en los que era necesario, junto con las
páginas de los manuales que fueran necesarias, los archivos de configuración, y demás. Hoy en
día, la mayoría de los distribuidores de Linux utilizan programas o sets de programas
prearmados denominados paquetes, los cuales son enviados para su distribución listos para
instalar. Aprenderá de qué manera las herramientas para administración de programas lo
ayudan a instalar, actualizar, y eliminar paquetes. Este manual trata particularmente el tema
del Red Hat Package Manager (RPM), desarrollado por by Red Hat, y del Yellowdog Updater
Modified (YUM), originalmente desarrollado para administrar los sistemas Red Hat Linux en el
Departamento de Física de la Universidad Duke.

Dado que los desarrolladores de Linux se han esforzado para que el uso de Linux sea más fácil,
las herramientas básicas han sido complementadas por otras, incluyendo las herramientas GUI,
las cuales ocultan al usuario algunas de las complejidades de las herramientas básicas. RPM,
YUM, y APT (para los sistemas Debian) poseen muchas similitudes. Todos ellos pueden instalar y
quitar paquetes. La información sobre los paquetes instalados se guarda en una base de datos.
Todos ellos tienen funcionalidad de línea básica de comando, además de herramientas
adicionales que pueden proporcionar al usuario interfaces de uso más sencillo. Todos ellos
pueden recuperar paquetes de Internet.

Al instalar un sistema Linux, por lo general usted puede instalar una gran variedad de paquetes.
El set puede personalizarse según el uso que se quiera dar al sistema, como servidor, escritorio,
o terminal de trabajo del desarrollador. Y en algún momento probablemente sea necesario
instalar paquetes nuevos para obtener alguna otra funcionalidad, actualizar el paquete que
posee, o incluso borrar paquetes que ya no se necesitan o son obsoletos debido a la aparición
de nuevos paquetes. Demos un vistazo a la forma en la que usted realiza estas tareas, y a
algunos de los desafíos a los que debe hacer frente, como la búsqueda de algún paquete que
contenga algún comando en particular.

pág. 107

Si no sabemos o tenemos información de algún paquete o programa, podremos utilizar

inicialmente el comando info, que es el encargado de mostrar la información en forma de
manual del programa si esta instalado con el comando info:

# info yum

RPM
Red Hat lanzó RPM en 1995. Actualmente RPM es el sistema de gestión de paquetes usado para
crear paquetes en Linux Standard Base (LSB). Las opciones del comando rpm están agrupadas en
tres subgrupos según se utilicen para:

Consultar y verificar paquetes
Instalar, actualizar y borrar paquetes
Realizar varias funciones

En este manual nos ocuparemos de los dos primeros subgrupos de opciones de comandos.
Usted encontrará información sobre el tercer subgrupo en las páginas de los manuales para
RPM.
Deberíamos tener en cuenta también que rpm es el nombre de comando para el comando
principal utilizado con RPM, mientras que .rpm es la extensión utilizada en los archivos RPM. Por
lo tanto "un rpm" o "el xxx rpm" se referirá generalmente a un archivo RPM, mientras
que rpm por lo general se referirá al comando.
Si en algún momento la base de datos que contiene la información de los rpm’s se corrompe por
cualquier tipo de daño, sea software o hardware con el siguiente comando puede reconfigurarla
a su estado original:
# rpm –rebuilddb

Si lo que necesita es revisar si tiene instalado algún paquete dentro de su sistema, ejecutando el
siguiente comando puede realizar esta consulta, agregando la opción –q la cual realizara un
query como el bases de datos, es decir una consulta, para el siguiente ejemplo tomaremos como
ejemplo el paquete coreutils, el cual debe estar instalado, dándonos una salida con la
información del paquete:
# rpm -q coreutils
pág. 108

Si necesitamos una infomacion mas detallada de dicho paquete usaremos el comando

agregando la opción “–i”:
# rpm -qi coreutils
Al substituir la i por la opción “–l” (ele) podríamos listar todos los componentes que son
afectados por dicho paquete:
# rpm -ql coreutils
Si nos interesa saber a que paquete pertenece alguna aplicación ejecutaríamos al comando
como sigue
# rpm -qf /bin/kill

Ejecutando el siguiente comando nos mostrara la lista de paquetes instalados.
# rpm -qa |more

Si buscamos un paquete en específico utilizaremos el siguiente.
# rpm -qa |grep utils

Si queremos ver los paquetes en orden de instalación, es decir los que se instalaron primero
hasta los últimos, teclearemos el siguiente:
# rpm -qa --last|more

Si queremos verificar todos los componentes del sistema mostrando los modificados ,
ejecutaremos lo siguiente:
# rpm -Va

pág. 109

Instalación de paquetes.

Lo primero es descargar el rpm que vamos a utilizar lo cual lo haremos en la siguiente liga:

http://get.adobe.com/es/flashplayer/

Una vez descargado lo transferiremos a la maquina virtual.
Una vez descargado el paquete de flash podríamos realizar una revisión detallada de lo que
incluye el paquete ejecutando el siguiente comando:
# rpm -qpi flash-plugin-11.2.202.424-release.i386.rpm

Para realizar la instalación después de descargar el rpm que vallamos a utilizar, se instala con el
comando:
En este ejemplo vamos a instalar el paquete de flash-plugin-11.2.202.424-release.i386.rpm
# rpm –ivh y el nombre del paquete
Para ver los componentes que esta instalando el paquete ejecutamos el siguiente comando:
# rpm -qpl y el nombre del paquete instalado

Para verificar que el paquete de firmas es el adecuado para el paquete ejecutamos el siguiente
comando:
# rpm -K el nombre del paquete instalado

En caso contrario nos podría salir un mensaje parecido al siguiente:
Nombre del paquete instalado: (sha1) dsa sha1 MD5 GPG NOT OK
Si tuviera alguna complicación y el paquete no se instalara agregara al comando la opción --
force:
# rpm -ivh --force Nombre del paquete a instalar
Si le interesa saber en algún momento las dependencias del paquete podría ejecutar el siguiente
pág. 110

comando:
# rpm -qp --requires Nombre del paquete a instalar

Si se desea desinstalar cualquier paquete sin importar que otros dependan de este, se puede
utilizar con la opción --nodeps. Esto es contraindicado y sólo debe ser utilizado en situaciones
muy particulares. Evite siempre desinstalar paquetes que sean dependencia de otros en el
sistema a menos que vaya a reinstalar inmediatamente un paquete que cubra las dependencias
que se hayan visto afectadas.
Para desinstalar un rpm necesitaría ejecutar el siguiente comando:

# rpm –e Nombre del paquete.
En resumen:
Para instalar:
# rpm -i paquete.rpm
Para desinstalar:
# rpm -e paquete.rpm
Para instalar y ver el progreso:
# rpm -iv paquete.rpm

Para instalar o actualizar segun el caso y ver el progreso (opción recomendada):
# rpm -Uvh paquete.rpm
Para confirmar si esta instalado o no:
# rpm -q paquete.rpm
Para forzar la desinstalacion (opción no recomendada):
# rpm -e paquete.rpm --force

Instalar un paquete que tiene una versión anterior previamente instalada:
pág. 111

# rpm –Fvh paquete.rpm
Uso de YUM.
Yellow dog Updater, Modified (YUM) es una herramienta libre de gestión de paquetes para
sistemas Linux basados en RPM. Fue desarrollado por Seth Vidal y un grupo de programadores
voluntarios, y actualmente se mantiene como parte del proyectoLinux@DUKE de la Universidad
de Duke. A pesar de que yum es una utilidad para línea de comandos, otras herramientas
proveen a yum de una interfaz gráfica de usuario, como pup, pirut y yumex. Desde que Seth
Vidal trabaja en Red Hat, programadores de dicha compañía están implicados en el desarrollo
de yum.
Yum es una utilidad totalmente reescrita a partir de su herramienta predecesora, Yellowdog
Updater (YUP), y fue desarrollada principalmente para actualizar y controlar los sistemas Red
Hat utilizados en el departamento de física de la Universidad de Duke. Desde entonces, ha sido
adoptada por Fedora, CentOS, y otras distribuciones de GNU/Linux basadas en RPM, incluyendo
el mismo Yellow Dog, donde reemplazó a la utilidad original YUP. El manejador de paquetes
de Red Hat, up2date, también puede hacer uso de los repositorio de software de yum cuando
realiza actualizaciones de software. Red Hat Enterprise 5 reemplazó up2date por yum y pirut.
Con los paquetes "yum-updatesd" o "yum-updateonboot" se puede hacer una actualización de
software automática.
El sistema de repositorios yum está convirtiéndose rápidamente en un estándar para los
repositorios basados en RPM. En SUSE Linux 10.1 se añade soporte para repositorios YUM
en YaST, y los repositorios de openSUSE están basados exclusivamente en Yum.
Yellow dog Updater, Modified está disponible bajo licencia GNU GPL versión 2 o superiores.

pág. 112

Ejercicio:

# yum list available | more > Lista todo los paquetes disponibles
# yum list installed | more > Lista los paquetes instalados
# yum list installed kernel > Lista la versión instalada en el kernel
# yum list updates | less > Lista los paquetes que pueden ser actualizados
# yum list all | less > Lista todos los paquetes existentes
# yum grouplist > Lista los grupos de paquetes disponibles en YUM

# yum search nombre-paquete > Realiza la búsqueda de un paquete(cups)
# yum info nombre-paquete > Consulta de información de paquetes(cups)
#yum groupinfo "Grupo" > Muestra la información de un grupo(servidor

web)
#yum install nombre-paquete > Instala un paquete(openssh)
# yum install --nogpgcheck nombre-paquete > Instala con resolución de

dependencias
pág. 113

# yum -y install nombre-paquete > Instala con respuesta positiva a los

modulos que instala(cups-pdf)
Instalación de grupos de paquetes con resolución automática de dependencias:

# yum groupinstall "Nombre del Grupo" > Instala grupos de

paquetes(servidor web)
# yum -y groupinstall "Nombre del Grupo" > Instala con respuesta positiva a
los modulos que instala(servidor web)
# yum remove nombre-paquete > Desinstala paquetes(cups-pdf)
# yum groupremove "Nombre del Grupo" > Desinstala grupos(servidor web)
# yum update > Actualizacion de base de datos del sistema
# yum -y update > Realiza la actualización resolviendo las preguntas de

instalación.
# yum --skip-broken update > Actualiza la base omitiendo las dependencias

corruptas
# yum update nombre-paquete > Actualiza un solo paquete(cups)
# yum -y update nombre-paquete > Actualiza resolviendo las preguntas de

instalación(cups)
# yum groupupdate "Nombre del Grupo" > Actualiza un grupo(servidor web)
# yum -y groupupdate "Nombre del Grupo" > Actualiza grupo con resolución
de preguntas de instalación(Base de datos MySQL).
# yum clean all > Limpia el cache de YUM
# yum clean metadata > Limpia los metadatos
pág. 114

# yum clean packages > Limpia paquetes descargados
# yum check > Chekear las bases de datos de RPM

Una tarea importante como administrador de sistemas es tener el sistema actualizado, para eso:

Instalamos el aquete PackageKit-cron con el siguiente comando:

# yum -y install PackageKit-cron

Editamos el archivo /etc/sysconfig/packagekit-background:

Active el servicio cambiando el valor de ENABLED a yes y habilite MAILTO=root para enviar a
root un reporte de las actualizaciones aplicadas:

# should we attempt to do this? (valid: yes|no)

ENABLED=yes

# if MAILTO is set, the mail command is used to deliver PackageKit output
# by default MAILTO is unset, so crond mails the output by itself
MAILTO=root

Reiniciamos el servicio “crond”:

# service crond restart
Despues:

Instalamos el paquete yum-updatesd con el siguiente comando:

pág. 115

# yum -y install yum-updatesd

Edite el archivo /etc/yum/yum-updatesd.conf:

# vi /etc/yum/yum-updatesd.conf

Cambiamos los valores de do_update, do_download y do_download_deps a yes.

# automatically install updates

do_update = yes
# automatically download updates
do_download = yes
# automatically download deps of updates
do_download_deps = yes

Activamos el servicio “yum-updatesd” con la siguiente instruccion.

# chkconfig yum-updatesd on

Iniciamos el servicio “yum-updatesd”:

# service yum-updatesd start

Y por ultimo reiniciamos el servicio crond:
# service crond restart
pág. 116

De esta manera estaremos automatizando las actualizaciones del sistema, mandando un

registro de actualizaciones.

Gestion de Servicios

La gestión de servicios consiste en activar o desactivar servicios en los distintos niveles de

ejecución del sistema y en iniciar, detener o activar éstos cuando las circunstancias lo requieran.

El sistema operativo GNU/Linux puede aprovechar los niveles de ejecución a través de los
programas del proyecto sysvinit. Después de que el núcleo Linux ha arrancado, el
programa init lee el archivo /etc/inittab para determinar el comportamiento para cada nivel de
ejecución. A no ser que el usuario especifique otro valor como un parámetro
de autoarranque del núcleo, el sistema intentará entrar (iniciar) al nivel de ejecución por
defecto.

La mayor parte de usuarios de sistemas puede comprobar el nivel de ejecución actual con
cualquiera de los comandos siguientes:
# runlevel # como usuario root
$ who –r # como cualquier usuario

En sistemas GNU/Linux y otras versiones de Unix, init es el programa encargado de llevar la

estación al nivel de ejecución en que se desea que opere. Init es el primer proceso en ejecución
después del la carga del Kernel e implementa dos sistemas de inicio: System V, o BSD-Like. Estos
sistemas especifican los guiones (scripts) de arranque para inicializar los diferentes servicios,
programas o registros que sean necesarios para que el sistema funcione como el usuario quiere
o como el administrador estableció.
Una vez que el sistema inicia y root a montado el file system, se ejecuta el /sbin/init y el ID que
se asigna al proceso es el 1 o monousuario.
En los sistemas GNU/Linux se especifican hasta 7 niveles de ejecución (también conocidos como
runlevels o niveles de corrida). En las distribuciones Red Hat, así como en la gran mayoría de
distribuciones, la especificación de los niveles de ejecución son como sigue:
Nivel de ejecución 0#
Halt. Este nivel de ejecución se encarga de detener todos los procesos activos en el sistema,
enviando a la placa madre una interrupción para el completo apagado del equipo.
pág. 117

Single. Nivel de ejecución monousuario, sin acceso a servicios de red. Este nivel es regularmente
utilizado en tareas de mantenimiento del sistema, y el usuario que ejecuta es root.
Al igual que el nivel de ejecución monousuario, pero con funciones de red y compartición de
datos mediante nfs.
Sistema multiusuario, con capacidades plenas de red, sin entorno gráfico. Este nivel de
ejecución es el recomendado para sistemas de servidor, ya que evita la carga innecesaria de
aplicaciones consumidoras de recursos.
Nivel especificado como nivel de experimentacion, pero no se utiliza.
Al igual que el nivel de ejecución 3, pero con capacidades gráficas. Ideal para entornos de
escritorio.
Reboot. Este nivel de ejecución se encarga de detener todos los procesos activos en el sistema,
enviando a la placa madre una interrupción para el reinicio del equipo.

Con el siguiente comando verificaríamos en que nivel se esta trabajando

# cat /etc/inittab |grep initdefault |grep id

5 es el nivel predeterminado de inicio del sistema. Para cambiar el valor del nivel de ejecución
predeterminado, se edita como root el archivo /etc/inittab:
# vim /etc/inittab

Con el siguiente comando podríamos ver el nivel actual de el sistema
# runlevel
Cuando nos muestra una N antes del nivel quiere decir que el nivel inicial es el actual
pág. 118

# N 5
Cuando se muestran 2 valores distintos quiere decir que se conmuto el nivel inicial
# 3 5
Con el siguiete comando podríamos ver de forma mas detallada la información del nivel de
ejecución:
“ who -r
Con el comando init podremos hacer la conmutación o cambio de nivel de ejecución:
# init 1
Con el siguiente comando cambiaremos al nivel de ejecución 3:
# init 3
Con el siguiente cambiaremos al nivel 6 lo cual probocaria que el sistema reiniciara de manera
inmediata:
# init 6
Con el siguiente el sistema se apagara, pues cambiaria al nivel 0 o apagado:
# init 0

Secuencia de arranque

1.- CentOS arranca ejecutando el programa init. El archivo de configuración de init es
/etc/inittab.

La entrada initdefault determina el nivel de ejecución inicial del sistema.

2.- Edita el fichero /etc/inittab, localiza la entrada initdefault, y determina en que nivel de
ejecución está trabajando el sistema.

3.- También puedes obtener el nivel de ejecución actual ejecutando la instrucción runlevel.
pág. 119

4.- Los primeros scripts que se ejecutan a continuación (indicado en la linea del fichero
/etc/inittab: si::sysinit:/etc/init.d/rcS) son los que se encuentra en el directorio /etc/rcS. Estos
scripts son los encargados de realizar algunas tareas como:

Monta el file system root y /proc.
Elimina temporales y archivos de bloqueo.
Establece el reloj
Inicia scripts de red y activa la partición swap.
Activa el teclado y fuentes.
Carga módulos.
Establece valores a muchas variables del entorno:PATH, HOSTNAME,...
Arranca la swap
Arranca fsck automático, si hace falta.
Activa quotas.
Chequea los argumentos pasados al kernel.
Chequea los filesystems
Inicializa los puertos serie.
Puertos USB.

5.- Lista los ficheros que se encuentran en el directorio /etc/rc.d
6.- Comprueba que son enlaces simbólicos a los scripts que se encuentran en el directorio
/etc/init.d

7.- A continuación se ejecutan los scripts de inicialización de los servicios del nivel de ejecución
por defecto. Estos scripts se encuentran en los directorios /etc/rcn donde n es el nivel de
ejecución.

Ejemplo:

Nivel Script Directorio
0 rc 0 /etc/rc0.d/
1 rc 1 /etc/rc1.d/
2 rc 2 /etc/rc2.d/
3 rc 3 /etc/rc3.d/
pág. 120

Es el script /etc/init.d/rc el que procesa todos los archivos K y S de los directorios /etc/rcn.d
Para ( con el argumento stop ) aquellos procesos que comienzan por K ( kill )
Lanza ( con el argumento start ) los que comienzan por S ( start ).
Después de la letra S o K hay dos dígitos numéricos que indican el orden de ejecución. El
orden es ASCII.
Todos los ficheros K o S son enlaces simbólicos a los scrips de cada servicio que están en el
directorio /etc/init.d

1) Visualiza los ficheros de los distintos directorios /etc/rcn.d.
2) Comprueba los ficheros de ejecución del nivel de ejecución que se ejecuta por defecto en
Debian.
3) Con la instrucción telinit podemos ejecutar otrps niveles de ejecución. Entra en el nivel
monousuario. Entra en el nivel de reinicio. Entra en el nivel de parada del sistema.

pág. 121

De modo esquemático podemos ver:

Un servicio que tenga un enlace simbólico denominado S80XXX, significa que el servicio iniciará
después de todos los demás servicios que tengan un número menor.
Es decir, S80XXX iniciará después de S70YYY.
Un servicio que tenga un enlace simbólico denominado K30XXX, significa que el servicio
terminará antes que todos los demás servicios que tengan un número mayor.
Es decir, K30XXX terminará primero que K40YYY.
¿Qué hacer para eliminar un servicio en un determinado nivel?

Borrar el vínculo simbólico en /etc/rcn.d/
Renombrarlo con algo que no empiece con S o K y dejarlo por si queremos luego activarlo.
Lo que no hay que hacer nunca es eliminar el archivo original en /etc/init.d/
1) Vamos a eliminar el servicio ssh (encargado de iniciar el servidor gráfico) del nivel de
ejecución 2, para ello elimina el fichero que inicia ese servicio.
2) Reinica el sistema y comprueba que el servidor gráfico no se ha iniciado.
3) Para restablecer el enlace simbólico para que podamos iniciar el servicio usamos la
instrucción update-rc.d (busca la página del manual para aprender más sobre esta
instrucción. Ejecuta:

pág. 122

update-rc.d gdm defaults para crear los enlaces simbólicos que ejecutan el script de gdm
4) Vuelve a reiniciar el sistema y comprueba que el servidor gráfico se vuelve a ejecutar.
5) Pregunta: ¿Para qué podríamos utilizar la configuración de distintos niveles de
ejecución?
Tambien podría utilizar el siguiente comando para crear enlaces simbólicos:
# ln –s file1 link-to-file1 ó cp –s file1 link-to-file1 que serian equivalentes
Ahora hay que tener en cuenta que:
Un enlace simbolico puede apuntar a un archivo aunque este en un file system distinto
Si elimina el archivo original, el enlace sigue apuntando, pero a un archivo inexistente.
Arranque y parada de lo servicios

Una vez que se han cargado los servicios que se encuentran en el directorio /etc/rc2.d, podemos
comprobar que los demonios correspondientes a cada servicio se están ejecutando con la
instrucción:
# ps -A

En cualquier momento podemos parar o reiniciar cualquier servicio ejecutando los scripts
del directorio /etc/init.d con las siguientes opciones: start, stop, restart, force-reload,...

1) Comprueba que el servicio ssh se está ejecutando.
2) Para el servicio, y comprueba con la instrucción ps que el proceso no se está ejecutando.
3) Vuelve a reiniciar el servicio.
pág. 123

Envío de señales a los procesos

Es posible el envío de distintas señales a los procesos. La más usada es matar un proceso, si por
ejemplo se queda inactivo. Para ello utilizamos la siguiente instrucción:

kill -9 PID

El PID es el identificador del proceso, y lo puedes obtener mirando la lista de procesos por
ejemplo con ps -A.

Podemos también utilizar la siguiente instrucción

killall nombredelproceso

Del mismo modo puedes ver el nombre del proceso mirando la lista de procesos con ps.

1) Imagínate que el servidor gráfico se queda "colgado". Entra en un terminal de texto con
CTRL+ALT+F1, y tras iniciar sesión como root mata el proceso gdm (Gestor de arranque del
servidor gráfico).

2) Para comprobar que el servidor gráfico no funciona puedes hacer varias cosas: lista los
procesos y comprueba que no existe el proceso gdm ni el Xorg. También puedes intentar
entrar en la consola gráfica con CTRL+ALT+F7.

3) Vuelve a ejecutar el gestor de arranque gráfico gdm.

4) Del mismo modo puedes matar el demonio del servicio ssh, y volver a reiniciarlo
posteriormente.

Servicios.

La gestión de servicios se hace a través de dos herramientas: chkconfig y service. Ambas utilizan
como argumentos los nombres de los archivos de inicio de los servicios, los cuales se localizan
dentro del directorio/etc/init.d
Chkconfig
Chkconfig permite configurar que servicios arrancan/detienen en cada nivel de ejecucción.
Aclaración: chkconfig no inicia ni detiene servicios al momento (excepto aquellos bajo xinetd),
tan solo crea o elimina precisamente los enlaces de los que se habló en el punto anterior de una
pág. 124

manera mas amigable. Si lo que se quiere es iniciar o detener el servicio en tiempo real o
manualmente hay que usar service o directamente el script con su argumento conveniente tal
como se explicó anteriormente.

Veamos ejemplos que muestran como trabajar con chkconfig.
Con la opción --list nos da una lista completa de todos los servicios instalados y para cada nivel si
arrancará (on) al entrar a ese nivel o se detendrá (off) o simplemente no se iniciara. Nótese que
al final de la lista vienen los servicios que dependen del superservidor xinetd.

# chkconfig –list
Con el siguiente comando eliminaremos el servicio del sistema, es decir se eliminara el link del
/etc/init.d
# chkconfig --del sshd

Con el siguiente comando agregaremos el servicio al inicio del sistema, es decir arrancara al
inicio del sistema, añadiéndolo al directorio /etc/init.d
# chkconfig --add sshd

Lo anterior por lo general se ejecuta automáticamente junto con la instalación de los paquetes
RPM correspondientes para cada servicio. Sólo es necesario ejecutarlo cuando se instalan
servicios que fueron compilados a partir de paquetes de código fuente o bien casos donde las
instrucciones de instalación explícitamente solicitan hacerlo.
Al ejecutar chkconfig con el nombre del servicio y on como argumentos para activar un servicio
que ha sido previamente añadido al sistema.
# chkconfig crond on
Con el siguiente comando se detendría el servicio
# chkconfig crond off

Con el siguiente comando podremos ver en que niveles esta activo y desactivo el servicio:
pág. 125

# chkconfig --list network

Ejecutaremos el siguiente comando para verificar que el servicio de crond esta desactivo en
todos los niveles
# chkconfig –list crond
Ahora ejecutaremos el siguiente comando y lo activaremos en el nivel 3 y 5:
# chkconfig --level 35 crond on

Verificamos con el comando nuevamente y veremos que ya esta activo en los niveles que
necesitamos:
# chkconfig –list crond
Si ejecutamos el comando nuevamente con la opción off se desactivara nuevamente
# chkconfig --level 35 crond off
Si ejecutamos el comando con la opción reset los valores que se asignan son los
predeterminados.
chkconfig crond reset

Este proceso se puede trabajar también con una interfaz grafica, esta se denomina ntsysv

pág. 126

Con esta podemos administrar los servicios principales, pudiendo interactuar con ella para la
utilización de los servicios.

Service.
Un daemon (demonio) (nomenclatura usada en sistemas UNIX y UNIX
like), service(servicio) (nomenclatura usada en Windows) o programa residente (nomenclatura
usada en MS-DOS) es un tipo especial de proceso informático no interactivo, es decir, que se
ejecuta en segundo plano en vez de ser controlado directamente por el usuario. Este tipo de
programas continua en el sistema, es decir, que puede ser ejecutado en forma persistente o
reiniciado si se intenta matar el proceso dependiendo de configuración del demonio y políticas
del sistema. La palabra daemon viene de las siglas en inglés D.A.E.MON (Disk And Execution
Monitor).

Iniciar un servicio

Al ejecutar el siguiente comando, iniciaremos un servicio, si esta detenido:

# service network start ó /etc/init.d/ network start

Para un servicio

Al ejecutar el siguiente comando, detendremos el servicio de ser necesario:
pág. 127

# service network stop ó /etc/init.d/network stop

Estado de un servicio

Al ejecutar el siguiente comando, verificaremos el estado del servicio en cuestio:

# service network status ó /etc/init.d/network status

Reinicio de un servicio

# service network restart ó /etc/init.d/network restart

pág. 128

Unidad 4.Gestión de usuarios, grupos y privilegios.

Gestión de cuentas de usuario.

Linux es un sistema multiusuario, por lo tanto, la tarea de añadir, modificar, eliminar y en
general administrar usuarios se convierte en algo no solo rutinario, sino importante, además de
ser un elemento de seguridad que mal administrado o tomado a la ligera, puede convertirse en
un enorme hoyo de seguridad. En este manual aprenderás todo lo necesario para administrar
completamente tus usuarios en GNU/Linux.

Tipos de usuarios

Los usuarios en Unix/Linux se identifican por un número único de usuario, User ID, UID. Y
pertenecen a un grupo principal de usuario, identificado también por un número único de
grupo, Group ID, GID. El usuario puede pertenecer a más grupos además del principal.
Aunque sujeto a cierta polémica, es posible identificar tres tipos de usuarios en Linux:
Usuario root
También llamado superusuario o administrador.
Su UID (User ID) es 0 (cero).
Es la única cuenta de usuario con privilegios sobre todo el sistema.
Acceso total a todos los archivos y directorios con independencia de propietarios y
permisos.
Controla la administración de cuentas de usuarios.
Ejecuta tareas de mantenimiento del sistema.
Puede detener el sistema.
Instala software en el sistema.
Puede modificar o reconfigurar el kernel, controladores, etc.
Usuarios especiales

Ejemplos: bin, adm, lp, sync, shutdown, mail, operator, squid, apache, etc.
Se les llama también cuentas del sistema.
No tiene todos los privilegios del usuario root, pero dependiendo de la cuenta asumen
distintos privilegios de root.
Lo anterior para proteger al sistema de posibles formas de vulnerar la seguridad.
pág. 129

No tienen contraseñas pues son cuentas que no están diseñadas para iniciar sesiones con
ellas.
También se les conoce como cuentas de "no inicio de sesión" (nologin).
Se crean (generalmente) automáticamente al momento de la instalación de Linux o de la
aplicación.
Generalmente se les asigna un UID entre 1 y 100 (definifo en /etc/login.defs)
Usuarios normales
Se usan para usuarios individuales.
Cada usuario dispone de un directorio de trabajo, ubicado generalmente en /home.
Cada usuario puede personalizar su entorno de trabajo.
Tienen solo privilegios completos en su directorio de trabajo o HOME.
Por seguridad, es siempre mejor trabajar como un usuario normal en vez del usuario root,
y cuando se requiera hacer uso de comandos solo de root, utilizar el comando su.
En las distros actuales de Linux se les asigna generalmente un UID superior a 500.
etc/passwd
Cualquiera que sea el tipo de usuario, todas las cuentas se encuentran definidas en el archivo de
configuración 'passwd', ubicado dentro del directorio /etc. Este archivo es de texto tipo ASCII, se
crea al momento de la instalación con el usuario root y las cuentas especiales, más las cuentas
de usuarios normales que se hayan indicado al momento de la instalación.
El nombre que es asignado al grupo que se almacena en /etc/passwd es Primary group
El archivo /etc/passwd contiene una línea para cada usuario, similar a las siguientes:

root:x:0:0:root:/root:/bin/bash
sergio:x:501:500:Sergio González:/home/sergio:/bin/bash

pág. 130

La información de cada usuario está dividida en 7 campos delimitados cada uno por ':' dos
puntos.
/etc/passwd
Campo 1 Es el nombre del usuario, identificador de inicio de sesión (login). Tiene que ser
único.
Campo 2 La 'x' indica la contraseña encriptada del usuario, además también indica que se
está haciendo uso del archivo /etc/shadow, si no se hace uso de este archivo,
este campo se vería algo así como: 'ghy675gjuXCc12r5gt78uuu6R'.
Campo 3 Número de identificación del usuario (UID). Tiene que ser único. 0 para root,
generalmente las cuentas o usuarios especiales se numeran del 1 al 100 y las de
usuario normal del 101 en delante, en las distribuciones mas recientes esta
numeración comienza a partir del 500.
Campo 4 Numeración de identificación del grupo (GID). El que aparece es el número de
grupo principal del usuario, pero puede pertenecer a otros, esto se configura
en/etc/groups.
Campo 5 Comentarios o el nombre completo del usuario.
Campo 6 Directorio de trabajo (Home) donde se sitúa al usuario después del inicio de
sesión.
Campo 7 Shell que va a utilizar el usuario de forma predeterminada.

Nota: Recuerde usted puede ver las características de pasword ejecutando el comando
passwd con la opción –S y el nombre del usuario.

/etc/shadow
Anteriormente (en sistemas Unix) las contraseñas cifradas se almacenaban en el

mismo/etc/passwd. El problema es que 'passwd' es un archivo que puede ser leído por cualquier
usuario del sistema, aunque solo puede ser modificado por root.
Con cualquier computadora potente de hoy en día, un buen programa de descifrado de
contraseñas y paciencia es posible "crackear" contraseñas débiles (por eso la conveniencia de
cambiar periódicamente la contraseña de root y de otras cuentas importantes). El archivo
'shadow', resuelve el problema ya que solo puede ser leido por root. Considérese a 'shadow'
como una extensión de 'passwd' ya que no solo almacena la contraseña encriptada, sino que
tiene otros campos de control de contraseñas.

El archivo /etc/shadow contiene una línea para cada usuario, similar a las siguientes:
pág. 131

root:ghy675gjuXCc12r5gt78uuu6R:10568:0:99999:7:7:-1::
sergio:rfgf886DG778sDFFDRRu78asd:10568:0:-1:9:-1:-1::
La información de cada usuario está dividida en 9 campos delimitados cada uno por ':' dos
puntos.
/etc/shadow
Campo 1 Nombre de la cuenta del usuario.
Campo 2 Contraseña cifrada o encriptada, un '*' indica cuenta de 'nologin'.
Campo 3 Días transcurridos desde el 1/ene/1970 hasta la fecha en que la contraseña fue
cambiada por última vez.
Campo 4 Número de días que deben transcurrir hasta que la contraseña se pueda volver a
cambiar.
Campo 5 Número de días tras los cuales hay que cambiar la contraseña. (-1 significa
nunca). A partir de este dato se obtiene la fecha de expiración de la contraseña.
Campo 6 Número de días antes de la expiración de la contraseña en que se le avisará al
usuario al inicio de la sesión.
Campo 7 Días después de la expiración en que la contraseña se inhabilitara, si es que no se
cambio.
Campo 8 Fecha de caducidad de la cuenta. Se expresa en días transcurridos desde el
1/Enero/1970 (epoch).
Campo 9 Reservado.

/etc/group

Este archivo guarda la relación de los grupos a los que pertenecen los usuarios del sistema,
contiene una línea para cada usuario con tres o cuatro campos por usuario:
root:x:0:root
ana:x:501:
sergio:x:502:ventas,supervisores,produccion
cristina:x:503:ventas,sergio

El campo 1 indica el usuario.

El campo 2 'x' indica la contraseña del grupo, que no existe, si hubiera se mostraría un
'hash' encriptado.
El campo 3 es el Group ID (GID) o identificación del grupo.
El campo 4 es opcional e indica la lista de grupos a los que pertenece el usuario
Actualmente al crear al usuario con useradd se crea también automáticamente su grupo
principal de trabajo GID, con el mismo nombre del usuario. Es decir, si se añade el usuario
pág. 132

'sergio' también se crea el /etc/group el grupo 'sergio'. Aun asi, existen comandos de
administración de grupos que se explicarán más adelante.
/etc/login.defs

En el archivo de configuración /etc/login.defs están definidas las variables que controlan los
aspectos de la creación de usuarios y de los campos de shadow usada por defecto. Algunos de
los aspectos que controlan estas variables son:
Número máximo de días que una contraseña es válida PASS_MAX_DAYS
El número mínimo de caracteres en la contraseña PASS_MIN_LEN
Valor mínimo para usuarios normales cuando se usa useradd UID_MIN
El valor umask por defecto UMASK
Si el comando useradd debe crear el directorio home por defecto CREATE_HOME
Basta con leer este archivo para conocer el resto de las variables que son autodescriptivas
y ajustarlas al gusto. Recúerdese que se usaran principalmente al momento de crear o
modificar usuarios con los comandos useradd y usermod que en breve se explicaran.

pág. 133

Añadir usuarios con useradd

useradd o adduser es el comando que permite añadir nuevos usuarios al sistema desde la línea
de comandos. Sus opciones más comunes o importantes son las siguientes:
-c añade un comentario al momento de crear al usuario, campo 5 de /etc/passwd
-d directorio de trabajo o home del usuario, campo 6 de /etc/passwd
-e fecha de expiración de la cuenta, formato AAAA-MM-DD, campo 8 de /etc/shadow
-g número de grupo principal del usuario (GID), campo 4 de /etc/passwd
-G otros grupos a los que puede pertenecer el usuario, separados por comas.
-r crea una cuenta del sistema o especial, su UID será menor al definido
en/etc/login.defs en la variable UID_MIN, además no se crea el directorio de inicio.
-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 indica esta opción, automáticamente se establece el siguiente
número disponible a partir del último usuario creado.
Ahora bien, realmente no hay prácticamente necesidad de indicar ninguna opción ya que si
hacemos lo siguiente:

#> useradd juan

Se creará el usuario y su grupo, asi como las entradas correspondientes en /etc/passwd,

/etc/shadow y /etc/group. También se creará el directorio de inicio o de trabajo: /home/juan y
los archivos de configuración que van dentro de este directorio y que más adelante se detallan.

Las fechas de expiración de contraseña, etc. Quedan lo más amplias posibles asi que no hay
problema que la cuenta caduque, asi que prácticamente lo único que faltaría sería añadir la
contraseña del usuario y algún comentario o identificación de la cuenta. Como añadir el
password o contraseña se estudiara en un momento y viendo las opciones con '-c' es posible
establecer el comentario, campo 5 de /etc/passwd:

#> useradd -c "Juan Perez Hernandez" juan

Siempre el nombre del usuario es el último parámetro del comando. Asi por ejemplo, si
queremos salirnos del default, podemos establecer algo como lo siguiente:

#> useradd -d /usr/juan -s /bin/csh -u 800 -c "Juan Perez Hernandez" juan
pág. 134

Con lo anterior estamos cambiando su directorio de inicio, su shell por defautl sera csh y su UID
será el 800 en vez de que el sistema tome el siguiente número disponible.

En algunas distribuciones es posible con el siguiente comando:
# useradd –m –p “password” juan

Donde password es el password asignado y juan es el usuario.

Modificar usuarios con usermod

Como su nombre lo indica, usermod permite modificar o actualizar un usuario o cuenta ya

existente. Sus opciones más comunes o importantes son las siguientes:
-c añade o modifica el comentario, campo 5 de /etc/passwd
-d modifica el directorio de trabajo o home del usuario, campo 6 de /etc/passwd
-e cambia o establece la fecha de expiración de la cuenta, formato AAAA-MM-DD, campo 8
de /etc/shadow
-g cambia el número de grupo principal del usuario (GID), campo 4 de /etc/passwd
-G establece otros grupos a los que puede pertenecer el usuario, separados por comas.
-l cambia el login o nombre del usuario, campo 1 de /etc/passwd y de /etc/shadow
-L bloque la cuenta del usuario, no permitiendolé que ingrese al sistema. No borra ni
cambia nada del usuario, solo lo deshabilita.
-s cambia el shell por defecto del usuario cuando ingrese al sistema.
-u cambia el UID del usuario.
-U desbloquea una cuenta previamente bloqueada con la opción -L.

Si quiseramos cambiar el nombre de usuario de 'sergio' a 'sego':

#> usermod -l sego sergio

Casi seguro también cambiará el nombre del directorio de inicio o HOME en /home, pero si no
fuera así, entonces:

#> usermod -d /home/sego sego

Otros cambios o modificaciones en la misma cuenta:

#> usermod -c "supervisor de area" -s /bin/ksh -g 505 sego

pág. 135

Lo anterior modifica el comentario de la cuenta, su shell por defecto que ahora sera Korn shell y
su grupo principal de usuario quedó establecido al GID 505 y todo esto se aplicó al usuario 'sego'
que como se observa debe ser el último argumento del comando.
El usuario 'sego' salió de vacaciones y nos aseguramos de que nadie use su cuenta:

#> usermod -L sego

Eliminar usuarios con userdel

Como su nombre lo indica, userdel elimina una cuenta del sistema, userdel puede ser invocado
de tres maneras:
#> userdel sergio

Sin opciones elimina la cuenta del usuario de /etc/passwd y de /etc/shadow, pero no elimina su
directorio de trabajo ni archivos contenidos en el mismo, esta es la mejor opción, ya que elimina
la cuenta pero no la información de la misma.
#> userdel -r sergio

Al igual que lo anterior elimina la cuenta totalmente, pero con la opción -r además elimina su
directorio de trabajo y archivos y directorios contenidos en el mismo, asi como su buzón de
correo, si es que estuvieran configuradas las opciones de correo. La cuenta no se podrá eliminar
si el usuario esta logueado o en el sistema al momento de ejecutar el comando.

#> userdel -f sergio

La opción -f es igual que la opción -r, elimina todo lo del usuario, cuenta, directorios y archivos
del usuario, pero además lo hace sin importar si el usuario esta actualmente en el sistema
trabajando. Es una opción muy radical, además de que podría causar inestabilidad en el sistema,
asi que hay que usarla solo en casos muy extremos.
pág. 136

Cambiar contraseñas con passwd
Crear al usuario con useradd es el primer paso, el segundo es asignarle una contraseña a ese
usuario. Esto se logra con el comando passwd que permitirá ingresar la contraseña y su
verificación:

#> passwd sergio
Changing password for user prueba.
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
#>

El usuario root es el único que puede indicar el cambio o asignación de contraseñas de cualquier
usuario. Usuarios normales pueden cambiar su contraeña en cualquier momento con tan solo
invocar passwd sin argumentos, y podrá de esta manera cambiar la contraseña cuantas veces lo
requiera.

Password tiene integrado validación de contraseñas comunes, cortas, de diccionario, etc. asi
que si por ejemplo intento como usuario normal cambiar mi contraseña a 'qwerty' el sistema me
mostrará lo siguiente:

$> passwd
Changing password for user prueba.
New UNIX password:
BAD PASSWORD: it is based on a dictionary word
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
$>
Nótese que al ingresar 'qwerty' como contraseña se detectó que es una secuencia ya conocida
como contraseña y me manda la advertencia: "BAD PASSWORD: it is based on a dictionary
word", sin embargo me permite continuar, al ingresar la verificación. Es decir, passwd avisa de
malas o débiles contraseñas pero permite establecerlas si realmente se desea.
pág. 137

Resumiendo entonces, se podría decir que todo este tutorial se reduce a dos líneas de
comandos para crear y dejar listo para trabajar a un usuario en Linux:

#> useradd ana

#> passwd ana

Se crea el usuario 'ana', useradd hace todo el trabajo de establecer el shell, directorio de inicio,
copiar archivos iniciales de configuración de la cuenta, etc. y después passwdestablece la
contraseña. Asi de simple.
passwd tiene varias opciones que permiten bloquear la cuenta '-l', desbloquearla '-u', y varias
opciones más que controlan la vigencia de la contraseña, es decir, es otro modo de establecer
los valores de la cuenta en /etc/shadow. Para más información consulta las páginas del manual:

$> man passwd

Archivos de configuración
Los usuarios normales y root en sus directorios de inicio tienen varios archivos que comienzan
con "." es decir están ocultos. Varían mucho dependiendo de la distribución de Linux que se
tenga, pero seguramente se encontrarán los siguientes o similares:

#> ls -la
drwx------ 2 ana ana 4096 jul 9 09:54 .
drwxr-xr-x 7 root root 4096 jul 9 09:54 ..
-rw-r--r-- 1 ana ana 24 jul 9 09:54 .bash_logout
-rw-r--r-- 1 ana ana 191 jul 9 09:54 .bash_profile
-rw-r--r-- 1 ana ana 124 jul 9 09:54 .bashrc

.bash_profile aquí podremos indicar alias, variables, configuración del entorno, etc. que
deseamos iniciar al principio de la sesión.
.bash_logout aquí podremos indicar acciones, programas, scripts, etc., que deseemos ejecutar al
salirnos de la sesión.
.bashrc es igual que .bash_profile, se ejecuta al principio de la sesión, tradicionalmente en este
archivo se indican los programas o scripts a ejecutar, a diferencia de .bash_profile que configura
el entorno.
pág. 138

Lo anterior aplica para terminales de texto 100%.

Si deseamos configurar archivos de inicio o de salida de la sesión gráfica entonces, en este caso,
hay que buscar en el menú del ambiente gráfico algún programa gráfico que permita manipular
que programas se deben arrancar al iniciar la sesión en modo gráfico. En la mayoría de las
distribuciones existe un programa llamado "sesiones" o "sessions", generalmente esta ubicado
dentro del menú de preferencias. En este programa es posible establecer programas o scripts
que arranquen junto con el ambiente gráfico, sería equivalente a manipular 'bashrc'.

Además Linux permite que el usuario decida que tipo de entorno Xwindow a utilizar, ya sea
algún entorno de escritorio como KDE o Gnome o algún manejador de ventanas como Xfce o
Twm. Dentro del Home del usuario, se creará un directorio o archivo escondido "." , por ejemplo
'.gnome' o '.kde' donde vendrá la configuración personalizada del usuario para ese entorno.
Dentro de este directorio suele haber varios directorios y archivos de configuración. Estos son
sumamente variados dependiendo de la distribución y del entorno. No es recomendable
modificar manualmente (aunque es perfectamente posible) estos archivos, es mucho mas
sencillo modificar vía las interfases gráficas que permiten cambiar el fondo, protector de
pantalla, estilos de ventanas, tamaños de letras, etc.

Resumen de comandos y archivos de administración de usuarios
Existen varios comandos más que se usan muy poco en la administración de usuarios, que sin
embargo permiten administrar aun más a detalle a tus usuarios de Linux. Algunos de estos
comandos permiten hacer lo mismo que los comandos previamente vistos, solo que de otra
manera, y otros como 'chpasswd' y 'newusers' resultan muy útiles y prácticos cuando de dar de
alta a múltiples usuarios se trata.

pág. 139

A continuación te presento un resumen de los comandos y archivos vistos en este tutorial más
otros que un poco de investigación.

Comandos de administración y control de usuarios
adduser Ver useradd
chage Permite cambiar o establecer parámetros de las fechas de control de la
contraseña.
chpasswd Actualiza o establece contraseñas en modo batch, múltiples usuarios a
la vez. (se usa junto con newusers)
id Muestra la identidad del usuario (UID) y los grupos a los que pertence.
gpasswd Administra las contraseñas de grupos (/etc/group y /etc/gshadow).
groupadd Añade grupos al sistema (/etc/group).
groupdel Elimina grupos del sistema.
groupmod Modifica grupos del sistema.
groups Muestra los grupos a los que pertence el usuario.
newusers Actualiza o crea usuarios en modo batch, múltiples usuarios a la vez. (se
usa junto chpasswd)
pwconv Establece la protección shadow (/etc/shadow) al archivo /etc/passwd.
pwunconv Elimina la protección shadow (/etc/shadow) al archivo /etc/passwd.
useradd Añade usuarios al sistema (/etc/passwd).
userdel Elimina usuarios del sistema.
usermod Modifica usuarios.

Archivos de administración y control de usuarios
.bash_logout Se ejecuta cuando el usuario abandona la sesión.
.bash_profile Se ejecuta cuando el usuario inicia la sesión.
.bashrc Se ejecuta cuando el usuario inicia la sesión.
/etc/group Usuarios y sus grupos.
/etc/gshadow Contraseñas encriptadas de los grupos.
/etc/login.defs Variables que controlan los aspectos de la creación de usuarios.
/etc/passwd Usuarios del sistema.
/etc/shadow Contraseñas encriptadas y control de fechas de usuarios del sistema.
pág. 140

Gestion de cuentas de grupos:

Creación de grupos
El comando groupadd permite añadir un grupo indicando como parámetro el nombre del grupo.
Ejemplo, si deseamos crear un grupo llamado 'alumnos' ejecutaremos:
// Añadir un grupo
$ sudo groupadd alumnos

Modificación de grupos
El comando groupmod permite modificar el nombre de un grupo o el gid del mismo. La sintaxis
es: sudo groupmod [-g nuevo-gid] [-n nuevo-nombre] nombre-grupo, ejemplo:
// Cambiar el gid del grupo profesores
$ sudo groupmod -g 2000 profesores
Eliminación de grupos
Se realiza con el comando groupdel seguido del nombre del grupo, ejemplo:
// Eliminación de un grupo
$ sudo groupdel profesores
Eliminaría el grupo profesores. Si algún usuario tuviera dicho grupo como grupo primario, el
comando groupdel no eliminará el grupo.
Añadir usuarios a un grupo
Se utiliza el comando adduser seguido del nombre del usuario y del nombre del grupo al que
queremos añadirle, ejemplo:
// Añadir a 'juan' al grupo 'profesores'
$ sudo adduser juan profesores
Quitar usuarios de un grupo

Se utiliza el comando deluser seguido del nombre del usuario y del nombre del grupo del que
queremos quitarle, ejemplo:
// Quitar a 'juan' del grupo 'profesores'
$ sudo deluser juan profesores
pág. 141

SUDO

El programa sudo (del inglés substitute user do) es una utilidad de los sistemas
operativos tipo Unix, como Linux, BSD, o Mac OS X, que permite a los usuarios ejecutar
programas con los privilegios de seguridad de otro usuario (normalmente el usuario root) de
manera segura. Se instala por defecto en /usr/bin
Sudo fue escrito originalmente por Bob Coggeshall y Cliff Spencer en 1980, en el departamento
de ciencias de la computación de la Universidad estatal de Nueva York. La versión actual la
mantiene el desarrollador de OpenBSD Todd C. Miller y se distribuye bajo una licencia BSD.
En 1985 se publicó en el grupo de noticias net.sources una versión mejorada acreditada a Phil
Betchel, Cliff Spencer, Gretchen Phillips, John LoVerso y Don Gworek. Garth Snyder publicó otra
versión mejorada en el verano de 1986 y durante los siguientes cinco años fue mantenido con la
colaboración de muchas personas, incluyendo Bob Coggeshall, Bob Manchek, y Trent Hein.
En 1991 Dave Hieb y Jeff Nieusma escribieron una nueva versión con un formato mejorado para
el fichero /etc/sudoers bajo contrato con la firma consultora The Root Group, versión que
posteriormente fue publicada bajo los términos de la Licencia Pública General
de GNU (GNU/GPL).
Desde 1996 el proyecto es mantenido por Todd Miller con la colaboración de Chris Jepeway y
Aaron Spangler.
Seguro que todo el mundo ha utilizado o como mínimo ha oído hablar de sudo, el comando que
permite ejecutar sentencias con los privilegios de cualquier usuario -incluidos los privilegios de
superusuario- y que es una medida muy interesante para evitar tener que entrar directamente
como estos usuarios con el más tradicional su.
pág. 142

Ilustración 8 La famosa tira cómica de XKCD deja claro qué es lo que permite hacer sudo

En Linux.com han publicado una fantástica introducción a sudo, que significa “substitute user
do” o “super user do” (según como lo usemos), y que como indican en ese artículo realiza una
tarea importante y crucial en muchas distribuciones Linux. Hay cierta polémica en si el uso de
sudo es bueno o malo para la seguridad, pero sea como fuere, seguro que hay un buen montón
de ocasiones en las que os vendrá bien usar el sudo.

En el artículo nos cuentan la historia de sudo, que comenzó a utilizarse en 1.980 y que poco a
poco se fue popularizando hasta llegar a las distribuciones gracias al trabajo de Todd Miller, que
sigue siendo su desarrollador principal.

Las diferencias entre sudo y su son claras, ya que su permite loguearnos como cualquier otro
usuario o como superusuario, mientras que sudo sólo permite ejecutar comandos con los
privilegios de otros usuarios -incluido el superusuario, como ya hemos comentado-. Los riesgos
para la seguridad son menores -aunque podemos seguir cagándola con sudo, por supuesto- y
por eso es bueno que sepáis cómo configurar y utilizar sudo.

pág. 143

La configuración es clave, y para ello es necesario editar -con mimo y cuidado- el

fichero/etc/sudoers. Precaución, amigo conductor, porque un error en este fichero puede tener
consecuencias graves para el sistema. En el artículo explican cómo añadir nuevos perfiles y
usuarios a la lista de los que pueden realizar sudo y con qué privilegios pueden hacerlo, así que
os recomiendo este artículo (en inglés, pero que puedes leer en un español aceptable gracias a
la magia de servicios como Google Translate) para conocer detalles importantes de esa
configuración y uso del famoso comando sudo.
Visudo

Permite la edición del archivo de configuración de sudo sudoers. Invoca al editor que se tenga
por defecto que generalemente es 'vi'. visudo cuando es usado, bloquea el archivo /etc/sudoers
de tal manera que nadie más lo puede utilizar, esto por razones obvias de seguridad que
evitarán que dos o más usuarios administradores modifiquen accidentalmente los cambios que
el otro realizó.
Otra característica importande de visudo es que al cerrar el archivo, verifica que el archivo este
bien configurado, es decir, detectará si hay errores de sintaxis principalmente en sus múltiples
opciones o reglas de acceso que se tengan. Por esta razón no debe editarse /etc/sudoers
directamente (perfectamente posible ya que es un archivo de texto como cualquier otro) sino
siempre usar visudo.
Si al cerrar visudo detecta un error nos mostrará la línea donde se encuentra, y la pregunta
"What now?":
>>> sudoers file: syntax error, line 15 <<<

What now?
Se tienen tres opciones para esta pregunta:

e - edita de nuevo el archivo, colocando el cursor en la línea del error (si el editor soporta
esta función.)
x - salir sin guardar los cambios.
Q - salir y guarda los cambios.

pág. 144

Por defecto el archivo de configuración es /etc/sudoers pero se pueden editar otros archivos
que no sean ese y que se aplique la sintaxis de sudo, y esto se logra con la opción -f(visudo -f
/otro/archivo).

Si tan solo se desea comprobar que /etc/sudoers esta bien configurado se usa la opción -c, toma
por el archivo de configuración por defecto o si no se indica algún otro.
#> visudo -c
/etc/sudoers file parsed OK
La opción -s activa el modo 'estricto' del uso de visudo, es decir no solo se comprobará lo
sintáctico sino también el orden correcto de las reglas, por ejemplo si se define el alias para un
grupo de comandos y este se usa antes de su definición, con esta opción se detectará este tipo
de errores.
Sudoers

Archivo de configuración de sudo, generalmente ubicado bajo /etc y se modifica a través del uso
de visudo. En este archivo se establece quien (usuarios) puede ejecutar que (comandos) y de
que modo (opciones), generando efectivamente una lista de control de acceso que puede ser
tan detallada como se desee.
Es más fácil entender sudo si dividimos en tres partes su posible configuración, estás son:
Alias
Opciones (Defaults)
Reglas de acceso

Por extraño que parezca ninguna de las secciones es obligatoria, o tienen que estar en algún
orden específico, pero la que al menos debe de existir es la tercera, que es la definción de los
controles o reglas de acceso. Se detallará cada uno de estos en un momento. Para los que les
gusta saber más la cuestión técnica es interesante saber que la construcción de un
archivo sudoers esta basado en la forma BNF (Backus-Naur Form), concretamente en versión
extendida (EBNF), si estudiaste algún curso de informática universitario seguramente sabes de
lo que hablo. EBNF describe de una forma precisa y exacta la gramática de un lenguaje, esta se
va creando a través de reglas de producción que a la vez son la base para ser referenciadas por
otras reglas. Afortunadamente no necesitas saber nada de esto, solo entender como se aplican
estas reglas.
pág. 145

Alias
Un alias se refiere a un usuario, un comando o a un equipo. El alias engloba bajo un solo nombre
(nombre del alias) una serie de elementos que después en la parte de definición de reglas serán
refiridos aplicados bajos cierto criterio. Es decir, regresando a EBNF estamos creando las reglas
de producción inicial. La forma para crear un alias es la siguiente:
tipo_alias NOMBRE_DEL_ALIAS = elemento1, elemento2, elemento3, ... elementoN

tipo_alias NOMBRE1 = elemento1, elemento2 : NOMBRE2 = elemento1, elemento2
En el segundo caso, separado por ":" es posible indicar más de un alias en una misma definción.

El tipo_alias define los elementos, es decir, dependiendo del tipo de alias serán sus elementos.
Los tipo de alias son cuatro y son los siguientes:

Cmnd_Alias - define alias de comandos.
User_Alias - define alias de usuarios normales.
Runas_Alias - define alias de usuarios administradores o con privilegios.
Host_Alias - define alias de hosts o equipos.
El NOMBRE_DEL_ALIAS puede llevar letras, números o guión bajo ( _ ) y DEBE de comenzar con
una letra mayúscula, se acostumbra a usarlos siempre en mayúsculas.
Los elementos del alias varian dependiendo del tipo de alias, asi que veámoslos por partes asi
como varios ejemplos para que comience a quedar claro todo esto.

Cmnd_Alias

Definen uno o más comandos y otros alias de comandos que podrán ser utilizados después en
alias de usuarios. Ejemplos:

Cmnd_Alias WEB = /usr/sbin/apachectl, /usr/sbin/httpd, sudoedit /etc/httpd/

Indica que a quien se le aplique el alias WEB podrá ejecutar los comandos apachectl, httpd y
editar todo lo que este debajo del directorio /etc/httpd/, nótese que debe de terminar con '/'
cuando se indican directorios. También, la ruta completa a los comandos debe ser indicada.

Cmnd_Alias APAGAR = /usr/bin/shutdown -h 23\:00

Al usuario que se le asigne el alias APAGAR podrá hacer uso del comando 'shutdown'
exactamente con los parámetros como están indicados, es decir apagar -h (halt) el equipo a las
23:00 horas. Nótese que es necesario escapar el signo ':', asi como los símbolos ' : , = \
pág. 146

Cmnd_Alias NET_ADMIN = /sbin/ifconfig, /sbin/iptables, WEB

NET_ADMIN es un alias con los comandos de configuración de interfaces de red ifconfig y de
firewall iptables, pero además le agregamos un alias previamente definido que es WEB, asi que a
quien se le asigne este alias podrá hacer uso de los comandos del alias WEB.

Cmnd_Alias TODO_BIN = /usr/bin/, !/usr/bin/rpm
A quien se le asigne este alias podrá ejecutar todos los comandos que estén dentro del
directorio /usr/bin/ menos el comando 'rpm' ubicado en el mismo directorio.
NOTA IMPORTANTE: este tipo de alias con un permiso muy amplios menos '!' algo,
generalmente no son una buena idea, ya que comandos nuevos que se añadan después a ese
directorio también podrán ser ejecutados, es mejor siempre definir específicamente lo que se
requiera.
User_Alias
Definen a uno o más usuarios, grupos del sistema (indicados con %), grupos de red (netgroups
indicados con +) u otros alias de usuarios. Ejemplos:

User_Alias MYSQL_USERS = andy, marce, juan, %mysql
Indica que al alias MYSQL_USERS pertenecen los usuarios indicados individualmente más los
usuarios que formen parte del grupo 'mysql'.
User_Alias ADMIN = sergio, ana

'sergio' y 'ana' pertenecen al alias ADMIN.

User_Alias TODOS = ALL, !samuel, !david

Aqui encontramos algo nuevo, definimos el alias de usuario TODOS que al poner como elemento
la palabra reservada 'ALL' abarcaría a todos los usuarios del sistema, pero no deseamos a dos de
ellos, asi que negamos con '!', que serían los usuarios 'samuel' y 'david'. Es decir, todos los
usuarios menos esos dos.
NOTA IMPORTANTE: este tipo de alias con un permiso muy amplios menos '!' algo,
generalmente no son una buena idea, ya que usuarios nuevos que se añadan después al
sistema también serán considerados como ALL, es mejor siempre definir específicamente a los
usuarios que se requieran. ALL es válido en todos los tipos de alias.

User_Alias OPERADORES = ADMIN, alejandra
Los del alias ADMIN más el usuario 'alejandra'.
pág. 147

Runas_Alias

Funciona exactamente igual que User_Alias, la única diferencia es que es posible usar el ID del
usario UID con el caracter '#'.

Runas_Alias OPERADORES = #501, fabian

Al alias OPERADORES pertenecen el usuario con UID 501 y el usuario 'fabian'
Host_Alias

Definen uno o más equipos u otros alias de host. Los equipos pueden indicarse por su nombre
(si se encuentra en /etc/hosts) por nombre de dominio, si existe un resolvedor de dominios, por
dirección IP, por dirección IP con máscara de red.

Ejemplos:
Host_Alias LANS = 192.168.0.0/24, 192.168.0.1/255.255.255.0
El alias LANS define todos los equipos de las redes locales.

Host_Alias WEBSERVERS = 172.16.0.21, web1 : DBSERVERS = 192.168.100.10, dataserver

Se define dos alias en el mismo renglón: WEBSERVERS y DBSERVERS con sus respectivas listas de
elementos, el separador ':' es válido en cualquier definición de tipo de alias.
Opciones (defaults)
Las opciones o defaults permiten definir ciertas características de comportamiento para los alias
previamente creados, para usuarios, usuarios privilegiados, para equipos o de manera global
para todos. No es necesario definir opciones o defaults, sudo ya tiene establecidas el valor de
cada uno, y es posible conocerlas a través de sudo -V (ver en la sección sudo de este tutorial).
Sin embargo, la potencia de sudo está en su alta granularidad de configuración, asi que es
importante conocer como establecer opciones espécificas.
Las opciones o defaults es posible establecerlos en cuatro niveles de uso:

De manera global, afecta a todos
Por usuario
Por usuario privilegiado
Por equipo (host)
pág. 148

Se usa la palabra reservada 'Defaults' para establecer las opciones y dependiendo del nivel que
deseamos afectar su sintaxis es la siguiente:
Global: Defaults opcion1, opcion2 ...

Usuario: Defaults:usuario opcion1, opcion2 ...
Usuario Privilegiado: Defaults>usuario opcion1, opcion2 ...
Equipo: Defaults@equipo opcion1, opcion2 ...

La lista de opciones es algo extensa, pueden consultarse en las páginas del manual (man
sudoers) o en el excelente manual sobre sudo del sitio web de www.rpublica.net,
http://www.rpublica.net/sudo/indice.html#defaults, está en español y define muy claramente
lo que significa cada opción. En este tutorial de LinuxTotal.com.mx me concretaré a ejemplificar
varios ejemplos del uso de establecer opciones.
Los defaults los divide el manual (man sudoers) en cuatro: flags o booleanos, enteros, cadenas y
listas. Veamos entonces algunos ejemplos de uso para cada uno de ellos:
Listas
Permite establecer/eliminar variables de entorno propias de sudo. Los 'Defaults' para variables
es de los menos usados en las configuraciones de sudo y ciertamente de los más confusos. Para
entender como se aplican es más fácil si primero ejecutas como 'root' el comando sudo -V, y al
final del listado encontrarás en mayúsculas las posibles variables de entorno que se pueden
establecer o quitar y que vienen del shell.
Solo existen tres opciones de listas: env_check, env_delete y env_keep, las listas pueden ser
remplazadas con '=', añadidas con '+=', eliminadas con '-=' o deshabilitadas con '!'. Con un par de
ejemplos quedará más claro.

Defaults env_delete -= HOSTNAME
Elimina la variable de entorno 'HOSTNAME', (pero preserva todas las demás que hubiera) y
comandos que se ejecuten bajo sudo y que requieran de esta variable no la tendrían disponible.

Defaults env_reset
Defaults env_check += DISPLAY, PS1
La primera opción 'env_reset' reinicializa las variables de entorno que sudo utilizará o tendrá
disponibles, y solo quedan disponibles LOGNAME, SHELL, USER y USERNAME. La siguiente línea
indica que agregue (+=) a lo anterior, también la variable de entorno DISPLAY a su valor
establecido antes del reset.
pág. 149

Reglas de acceso
Aunque no es obligatorio declarar alias, ni opciones (defaults), y de hecho tampoco reglas de
acceso, pues el archivo /etc/sudoers no tendría ninguna razón de ser si no se crean reglas de
acceso. De hecho podríamos concretarnos a crear solamente reglas de acceso, sin opciones ni
alias y podría funcionar todo muy bien.
Las reglas de acceso definen que usuarios ejecutan que comandos bajo que usuario y en que
equipos. La mejor y (según yo, única manera) de entender y aprender a configurar sudoers es
con ejemplos, asi que directo al grano:

usuario host = comando1, comando2, ... comandoN

Sintaxis básica, 'usuario' puede ser un usuario, un alias de usuario o un grupo (indicado por %),
'host' puede ser ALL cualquier equipo, un solo equipo, un alias de equipo, una dirección IP o una
definición de red IP/máscara, 'comandox' es cualquier comando indicado con su ruta completa.
Si se termina en '/' como en /etc/http/ entonces indica todos los archivos dentro de ese
directorio.

daniela ALL = /sbin/iptables
Usuario 'daniela' en cualquier host o equipo puede utiliar iptables.
ADMIN ALL = ALL

Los usuarios definifos en el alias 'ADMIN' desde cualquier host pueden ejecutar cualquier
comando.
%gerentes dbserver = (director) /usr/facturacion, (root) /var/log/*
Un ejemplo más detallado. Los usuarios que pertenezcan al grupo del sistema llamado
'gerentes' pueden en el equipo llamado 'dbserver' ejecutar como si fueran el usuario 'director' la
aplicación llamada 'facturacion', además como usuarios 'root' pueden ver el contendido de los
archivos que contenga el directorio /var/log.

Lo anterior intoduce algo nuevo, que en la lista de comandos es posible indicar bajo que usuario
se debe ejecutar el permiso. Por defecto es el usuario 'root', pero no siempre tener que asi.
Además la lista 'hereda' la primera definición de usuario que se indica entre paréntesis ( ), por
eso si se tiene más de alguno hay que cambiar de usuario en el comando conveniente, el
ejemplo anterior también sería válido de la siguiente manera:
%gerentes dbserver = /var/log/*, (director) /usr/facturacion
pág. 150

No es necesario indicar (root) ya que es el usuario bajo el cual se ejecutan los comandos por
defecto. También es válido usar (ALL) para indicar bajo cualquier usuario. El ejemplo siguiente
da permisos absolutos.

sergio ALL = (ALL) ALL
Se establece permiso para el usuario 'sergio' en cualquier host, ejecutar cualquier comando de
cualquier usuario, por supuesto incluyendo los de root.

SUPERVISORES PRODUCCION = OPERACION

Una regala formada solo por alias. En el alias de usuario ‘SUPERVISORES’ los usuarios que esten
indicado en ese alias, tendrán permiso en los equipos definidos en el alias de host
'PRODUCCION', de ejecutar los comandos definidos o listados en el alias de comandos
'OPERACION'.
En este último ejemplo se aprecia lo últil que pueden ser los alias, ya que una vez definida la
regla, solo debemos agregar o eliminar elementos de las listas de alias definidos previamente. Es
decir, se agrega un equipo más a la red, se añade al alias 'PRODUCCION', un usuario renuncia a
la empresa, alteramos el alias 'SUPERVISORES' eliminándolo de la lista, etc.
checo ALL = /usr/bin/passwd *, !/usr/bin/passwd root

Este es un ejemplo muy interesante de la potencia y flexibilidad . Al usuario 'checo', desde
cualquier equipo, tiene permiso de cambiar la contraseña de cualquier usuario (usando el
comando 'passwd'), excepto '!' la contraseña del usuario 'root'. Lo anterior se logra mediante el
uso de argumentos en los comandos. En el primer ejemplo '/usr/bin/passwd *' el asterisco
indica una expansión de comodin (wildcard) que indica cualquier argumento, es decir, cualquier
usuario. En el segundo caso '!/usr/bin/passwd root', si indica un argumento específico 'root', y la
'!' como ya se sabe indica negación, negando entonces el permiso a cambiar la contraseña de
root.

Cuando se indica el comando sin argumentos: /sbin/iptables sudo lo interpreta como 'puede
usar iptables con cualquiera de sus argumentos'.

mariajose ALL = "/sbin/lsmod"
Al estar entre comillas dobles un comando, entonces sudo lo interpreta como 'puede hacer uso
del comando lsmod pero sin argumentos'. En este caso el usuario 'mariajose' podrá ver la lista
de módulos del kernel, pero solo eso.
pág. 151

Tags (etiquetas de comandos)

Cuando se definen reglas, en la lista de comandos, estos pueden tener cero (como en los
ejemplos anteriores) o más tags. Existen 6 de estas etiquetas o tags,
NOPASSWD Y PASSWD
Por defecto sudo requiere que cualquier usuario se identifique o auténtifique con su
contraseña. Aprendimos en la sección de 'Opciones' o 'Defaults' que es posible indicar que un
usuario o alias de usuario no requiera de autentificación. Pero el control granular propio
desudo, permite ir aun más lejos al indicar a nivel de comandos, cuáles requieren contraseña
para su uso y cuáles no.
gerardo webserver = NOPASSWD: /bin/kill, /usr/bin/lprm, /etc/httpd/conf/

Usuario 'gerardo' en el equipo 'webserver' no requerira contraseña para los comandos listados.
El tag se hereda, es decir no solo el primer elemento de la lista de comandos, sino los
subsiguientes. Suponiendo que el último '/etc/httpd/conf/' elemento, que permite modificar
cualquier archivo contenido en el directorio, si deseamos que use contraseña, lo siguiente lo
conseguirá:
gerardo webserver = NOPASSWD: /bin/kill, /usr/bin/lprm, PASSWD: /etc/httpd/conf/

Aunque ya que solicitar contraseña es el default o defecto preestablecido, lo anterior también
funcionará de la siguiente manera:
gerardo webserver = /etc/httpd/conf/, NOPASSWD: /bin/kill, /usr/bin/lprm,
NOEXEC Y EXEC
Este es un tag muy importante a considerar cuando sobre se otorgan permisos sobre programas
que permiten escapes a shell (shell escape), como en el editor 'vi' que mediante el uso de '!' es
posible ejecutar un comando en el shell sin salir de 'vi'. Con el tag NOEXEC se logra que esto no
suceda, aunque no hay que tomarlo como un hecho, ya que siempre existe la posibilidad de
vulnerabilidades no conocidas en los múltiples programas que utilizan escapes a shell. Al igual
que los tags anteriores, el tag se hereda y se deshabilita con su tag contrario (EXEC), en caso de
que en la lista de comandos hubiera varios comandos.
valeria ALL = NOEXEC: /usr/bin/vi
ARCHIVO /ETC/SUDOERS DE EJEMPLO
Para concluir este manual, veamos un pequeño ejemplo de un archivo /etc/sudoers:

# ***********************
# LinuxTotal.com.mx, ejemplo de un archivo sudoers
pág. 152

# sergio.gonzalez.duran@gmail.com
# ***********************
# ***********************
# DEFINCION DE ALIAS
# ***********************
# administradores con todos los privilegios

User_Alias ADMINS = sergio, ana
# administradores de red - network operators

User_Alias NETOPS = marcela, andrea

# webmasters -
User_Alias WEBMAS = cristina, juan

# supervisores de producción (todos los del grupo de sistema supervisores)

User_Alias SUPPRO = samuel, %supervisores
# usuarios que pueden conectarse desde Internet

User_Alias INETUS = NETOPS, ADMINS, samuel

# servidores web
Host_Alias WEBSERVERS = 10.0.1.100, 10.0.1.101
# servidores de aplicaciones
Host_Alias APLICACIONES = WEBSERVERS, 10.0.1.102, 10.0.1.103, mailserver

# comandos de red permitidos

Cmnd_Alias REDCMDS = /sbin/ifconfig, /sbin/iptables
# comandos de apache
Cmnd_Alias APACHECMDS = /usr/sbin/apachectl, /sbin/service httpd *

# ***********************
# DEFINCION DE OPCIONES
# ***********************

# Los usuarios administradores, requieren autentificarse con la contraseña de 'root'

Defaults>ADMINS rootpw

# Para todos los usuarios, tienen hasta dos intentos para ingresar su contraseña y 3 minuto para
pág. 153

que esta expire

Defaults passwd_tries = 4, passwd_timeout = 1

# Los usuarios que se conectan desde Internet, solo tienen una oportunidad y cero timeout lo
que implica
# que cada comando que usen a través de sudo requerira siempre de autentificación.
Defaults:INETUS passwd_tries = 1, passwd_timeout = 0

# Máscara de directorios y archivos por default, para los que ejecuten sudo en los servidores
web
Defaults@WEBSERVERS umask = 022
# ***********************
# DEFINCION DE REGLAS
# ***********************
# administradores todo se les permite en cualquier equipo (¡¡¡¡¡cuidado con esto en la vida
real!!!!!
ADMINS ALL = (ALL) ALL

# administradores de red, en todos los equipos, los comandos de red

NETOPS ALL = REDCMDS
# webmasters, en los servidores web con los comandos indicados en apachecmds y además sin
necesidad
# de contraseña acceder a las bítacoras de apache y reiniciar los servidores.
WEBMAS WEBSERVERS = APACHECMDS, NOPASSWD: /var/log/apache/, /sbin/reboot

# supervisores, pueden ejecutar los comandos indicados en los equipos indicados en el alias
# aplicaciones y además son ejecutados bajo el usuario apps.
SUPPRO APLICACIONES = NOEXEC: (apps) /usr/local/facturacion.exe, /usr/local/ventas.exe,
/usr/local/nomina.exe

# no definidos por alias previos, sino directamente

# regina es de recursos humanos y puede cambiar contraseñas de cualquier usuario menos de

root
regina ALL = /usr/bin/passwd *, !/usr/bin/passwd root

# david, puede apagar los equipos de aplicaciones
pág. 154

david APLICACIONES = /sbin/shutdown, /sbin/halt

# El equipo firewall de la red puede ser reiniciado (no apagado) por fernanda que es asistente
de redes
fernanda firewall = /sbin/shutdown -r now

Sudo

sudo (SUperuser DO) lo ejecuta un usuario normal, al que se supone tiene permisos para
ejecutar cierto comando. Entonces, sudo requiere que los usuarios se autentifiquen a si mismos
a través de su contraseña para permitirles la ejecución del comando. Veamos un ejemplo:
$ sudo /sbin/ifconfig
Password:
eth0 Link encap:Ethernet HWaddr 4C:00:10:60:5F:21
inet addr:200.13.110.62 Bcast:200.13.110.255 Mask:255.255.255.0
inet6 addr: fe80::4e00:10ff:fe60:5f21/64 Scope:Link
...
Como se podrá observar se usa el comando sudo seguido del comando (con toda su ruta si es
que este no esta en el PATH del usuario) al que se tiene permiso. sudo pregunta por la
contraseña del usuario que ejecuta el comando y listo.
Por defecto, después de hacer lo anterior tendrás 5 minutos para volver a usar el mismo
comando u otros a los que tuvieras derecho, sin necesidad de ingresar la contraseña de nuevo.
Si se quiere extender el tiempo por otros 5 minutos usa la opción sudo -v (validate). Por el
contario, si ya terminaste lo que tenías que hacer, puedes usar sudo -k (kill) para terminar con el
tiempo de gracia de validación.
Ahora bien, ¿Qué comandos son los que puedo utilizar?, pues la opción -l es la indicada para
eso:

$ sudo -l
User sergio may run the following commands on this host:
(root) /sbin/ifconfig
(root) /sbin/lspci

En el caso anterior se ejecutó un comando de root, pero no tiene que ser asi, también es posible
pág. 155

ejecutar comandos de otros usuarios del sistema indicando la opción -u:

$ sudo -u ana /comando/de/ana

Una de las opciones más interesantes es la que permite editar archivos de texto de root (claro,
con el permiso otorgado en 'sudoers' como se verá más adelante), y esto se logra con la opción -
e, esta opción esta ligada a otro comando de sudo llamado sudoedit que invoca al editor por
defecto del usuario, que generalmente es 'vi'.

$ sudo -e /etc/inittab
(Permitira modificar el archivo indicado como si se fuera root)

Cuando se configura sudo se tienen múltiples opciones que se pueden establecer, estás se
consultan a través de la opción –L

$> sudo -L
Available options in a sudoers ``Defaults'' line:

syslog: Syslog facility if syslog is being used for logging
syslog_goodpri: Syslog priority to use when user authenticates successfully
syslog_badpri: Syslog priority to use when user authenticates unsuccessfully
long_otp_prompt: Put OTP prompt on its own line
ignore_dot: Ignore '.' in $PATH
mail_always: Always send mail when sudo is run
mail_badpass: Send mail if user authentication fails
mail_no_user: Send mail if the user is not in sudoers
mail_no_host: Send mail if the user is not in sudoers for this host
mail_no_perms: Send mail if the user is not allowed to run a command
tty_tickets: Use a separate timestamp for each user/tty combo
lecture: Lecture user the first time they run sudo
lecture_file: File containing the sudo lecture
authenticate: Require users to authenticate by default
root_sudo: Root may run sudo
...
varias opciones más
pág. 156

Bastante útil, ya que nos muestra las opciones y una pequeña descripción, estás opciones se
establecen en el archivo de configuración 'sudoers'.
Una de las opciones más importantes de consulta es -V, que permite listar las opciones
(defaults) establecidas por defecto para sudo todos los usuarios, comandos, equipos, etc. Más
adelante en este tutorial, aprenderemos como establecer opciones específicas para ciertos
usuarios, comandos o equipos.

Nota: tienes que ser 'root' para usar esta opción.

# sudo -V
Sudo version 1.6.9p5

Sudoers path: /etc/sudoers

Authentication methods: 'pam'
Syslog facility if syslog is being used for logging: local2
Syslog priority to use when user authenticates successfully: notice
Syslog priority to use when user authenticates unsuccessfully: alert
Send mail if the user is not in sudoers
Lecture user the first time they run sudo
Require users to authenticate by default
Root may run sudo
Log the hostname in the (non-syslog) log file
Allow some information gathering to give useful error messages
Visudo will honor the EDITOR environment variable
Set the LOGNAME and USER environment variables
Reset the environment to a default set of variables
Length at which to wrap log file lines (0 for no wrap): 80
Authentication timestamp timeout: 5 minutes
Password prompt timeout: 5 minutes
Number of tries to enter a password: 3
Umask to use or 0777 to use user's: 022
Path to log file: /var/log/sudo.log
...
varias opciones más listadas
pág. 157

Nota: Es importante tener en cuenta que los métodos de autenticación que permite Linux,
tienden a variar dependiendo de la distribución y el para que se utilize, pero la versión de
suse, soporte los más comunes:NIS, LDAP, Windows Domain y Locales.
La configuración predeterminada en distribuciones basadas sobre CentOS utiliza lo siguiente:

%wheel ALL = (ALL) ALL
Con lo anterior sólo los usuarios miembros del grupo wheel podrán hacer uso de sudo. Se
recomienda cambiar esta configuración para hacerla un poco más restrictiva, como se muestra
en los ejemplos citados algunos párrafos arriba.
Si se quiere permitir a un usuario ejecutar sudo lo lo que sea, desde cualquier anfitrión,
utilizando cualquier identidad de usuario del sistema y sin necesidad de autenticar, se puede
definir algo como lo siguiente:
usuario ALL = (ALL) NOPASSWD: ALL
Evite utilizar esta última configuración salvo que sea estrictamente necesario.
Uso de los Aliases

Bash (Bourne again shell) es un programa informático cuya función consiste en interpretar
órdenes.
Está basado en la shell de Unix y es compatible con POSIX.
Fue escrito para el proyecto GNU y es el intérprete de comandos por defecto en la mayoría de
las distribuciones de GNU con Linux. Su nombre es unacrónimo de Bourne-Again Shell (otro
shell bourne) — haciendo un juego de palabras (born - again significa renacimiento)
sobre el Bourne shell (sh), que fue uno de los primeros intérpretes importantes de Unix.
Hacia 1978 Bourne era el intérprete distribuido con la versión del sistema operativo
Unix Versión 7. Stephen Bourne, por entonces investigador de los Laboratorios Bell, escribió
la versión original de Bourne. Brian Fox escribió Bash en 1987. En 1990, Chet Ramey se
convirtió en su principal desarrollador. Bash es el intérprete predeterminado en la mayoría
de sistemas GNU/Linux, además de Mac OS X Tiger, y puede ejecutarse en la mayoría de los
sistemas operativos tipo Unix. También se ha llevado a Microsoft Windows por el proyecto
Cygwin.
Usar los bash aliases acelera tareas usando la terminal.. ya que cómo todos sabemos, la
usamos bastante seguido para ahorrarnos tiempo...bueno con lo siguiente vamos a poder
ahorrar aún mas tiempo escribiendo

pág. 158

Ubicamos un archivo de texto común y corriente llamado . bashrc, tiene que estar en
nuestro home (ej: /home/usuario/)

Luego lo abrimos con cualquier editor de texto y empezamos a crear nuestros alias.........
Los alias pueden ser creados simplemente asignando un valor o nombre a otra orden, por
ejemplo:

alias instalar="sudo apt-get install"
alias remover="sudo apt-get remove"
alias actualizar="sudo apt-get update && sudo apt-get upgrade"

Guardamos los cambios, salimos del sistema, nos logueamos nuevamente y listo.

pág. 159

Unidad 5. Permisos y Atributos del Sistema de Archivos.
Sistema plano de ficheros

La estructura en forma de árbol tiene el inconveniente de que se requiere ir recorriendo

el árbol para ir localizando cada uno de los elementos. Por ello se
hace necesario un sistema mucho más directo.
A cada ficheros se le asocia un número para poder localizarlo directamenta.

Dicho número se llama inodo. Los números de inodos sonel índice del sistema plano de fich
eros, también llamado por ello tabla deinodos. Cada fichero de cada sistema de ficheros tiene u
n inodo distintosalvo que se trate de un enlace rígido (hard link). Sin embargo hay inodos
que no se corresponden con ningún fichero.

Un fichero en sentido estricto indica capacidad de contener una secuencia de bytes.

Un inodo indica básicamente la capacidad de tener un nombre asociado al sistema de
ficheros.

pág. 160

Un fichero tiene asociadas funciones de posición y de lectura y escritura de información

dentro del fichero. Un inodo es una referencia muy directa a un fichero y a grandes
rasgos tiene asociadas funciones que permiten manejar y cosntruir la estrauctura del árbol
del sistema de ficheros.

Tipos de ficheros:
a. Regular: Son meros almacenes de información. Algunos contiene código

ejecutable.
b. Directorios: Son una tabla con números de inodos y nombres de ficheros.
c. Ficheros especiales: Pueden ser dispositivo tipo carácter o dispositivo
de bloques. El manejo de estos ficheros depende del dispositivo en particular.
d. Fifo: son pipes con nombre. Son propios de System V y en BSD no
existen pero en Linux si están disponibles.
e. Enlaces simbólicos (symbolic links): Son ficheros que contiene un puntero a otro
fichero que podría perfectamente estar en un sistema de ficheros distinto.
f. El Soket: es un fichero especial de 4.3 BSD y se utiliza para comunicar
procesos que pueden estar en máquinas distintas.

g. Enlaces rígidos (hard links): Realmente es un único fichero que puede ser
visto con distintos nombres dentro de un mismo sistema
de ficheros. Es decir se pueden observar como si fueran ficheros
idénticos con el mismo inodo. La información reside en un mismo lugar y lo que
ocurra aparentemente en un sitio ocurrirá instantáneamente en el otro lugar.
Los enlaces de este tipo no pueden ocurrir entre sistemas de ficheros distintos.
No todos los visto sistemas de ficheros soportan hard links ya que es un concepto
muy ligado a los SO tipo Unix

Generalmente los diferentes tipos de ficheros son capaces de aceptar operaciones de

apertura, cierre, lectura y escritura de forma similar. Por ello
se puede redirigir una entrada y una salida a diferentes tipos deficheros. Parte de la enorm
e potencia y flexibilidad de los SO tipo Unix
residen en este hecho. Gracias a esto la combinación de entradas salidas entre procesos,
ficheros, dispositivos, etc... resulta muy sencilla y flexible.
pág. 161

Existe una salvedad importante. Los directorios en este sentido son totalmente
especiales y un intento de escribir en un directorio dará siempre un error
siempre aunque sea realizado por 'root'. No tiene sentido permitirlo. Los directorios
se crean, borran, y modifican con comandos específicos para ellos.

Atributos de fecha en ficheros
En Unix y Linux los ficheros en sentido amplio tienen asociadas siempre tres fechas. En
realidad estas fechas están almacenadas internamente como
el número de segundos transcurridos desde el '1 de Enero de 1970'.
Una de ellas indica el tiempo del último acceso realizado sobre ese
fichero. La otra indica la fecha de creación (en realidad es la fecha del ultimo cambio
de estado) de ese fichero y la última y quizás más
importante (es la que vemos al consultar con 'ls -l') indica la fecha de la ultima
modificación.

En realidad si cambiamos el estado de un fichero por ejemplo cambiando permisos
O el propietario se modificará las fechas de creación y del último acceso.
Por eso la fecha que hemos denominado de creación puede ser posterior a la
a la fecha de modificación del fichero.
Cuando se crea un fichero las tres fechas tendrán el mismo valor. Cuando se
lee un fichero se modifica la fecha de acceso del mismo pero acceder al nombre
de un fichero o consultar el estado de un fichero no modifica ninguna fecha.
Su fecha de acceso tampoco ya que en realidad lo que se hace es leer la información del
directorio que lo contiene el cual si que vera modificada su fecha de acceso.

Las fechas de modificación asociadas a los directorios cambian con las altas o bajas de los
elementos dentro del directorio. Esto es debido a que dichas operaciones se consideran
como si fueran escrituras en el ficheroespecial de tipo directorio. Un directorio es al fin y alcabo
una simple tabla. Esto lo recordaremos cuando hablemos de permisos asociados a directorios.

Para modificar las fechas de modificación y de acceso de un fichero se puede usar el
comando touch.

pág. 162

Permisos de ficheros
Usaremos el término fichero en su sentido más amplio. Es decir que el

tema de permisos e aplicable a distintos tipos de ficheros con algunas
matizaciones que explicaremos más adelante. Los ficheros tienen muchos
atributos además de su nombre.

Para ver los más significativos haremos:
$ ls -l

Supongamos que tenemos el siguiente fichero llamado 'kkkkk'
. - r w x r w x r w x 1 root root 14740 abr 15 12:05 kkkkk

l Enlace simbólico
p Fifo con nombre
b Dispositivo de bloques
c Dispositivo de caracteres
d Directorio
En inglés se usan los términos owner , group, y others para designar

respectivamente al propietario, al grupo y a cualquier usuario.
Notación numérica para permisos
Los permisos de los ficheros son almacenados en formato binario y se puede referenciar
numéricamente. Vimos que a cada permiso individual le
asociábamos un número de tres dígitos formado por dos ceros y un tercer número que podía
ser únicamente 1, 2, o 4. Por ejemplo el permiso de
escritura para un usuario cualquiera era 002. Con estos números se puede codificar los
permisos de la forma que indicamos en el siguiente ejemplo:

r w x - - w x - r - x Esto equivaldría a un permiso 735
4 2 1 - 0 2 1 - 4 0 1 ( 4+2+1 , 0+2+1 , 4+0+1 = 7,3,5)
pág. 163

Los permisos también pueden representarse como una secuencia de bits.

Un bit es un valor que solo puede valer 0 o 1. En el caso anterior,
podríamos representarlo de la forma 111 010 101 donde 1 indica que si hay
permiso 0 que no lo hay y la posición de cada 0 y cada 1 representa a cada uno
de los permisos.

Umask
Es un comando interno del bash. Se utiliza cuando se crean ficheros.
No podemos profundizar mucho en temas de matemática binaria porquenos saldríamos del te
ma pero la umask se aplica mediante una operación llamada AND NOT.

Consiste en tomar a umask como una máscara donde los bits a 1
especifican los bits de permisos que se pondrán a cero.

Por ejemplo si queremos abrir un fichero con permisos 664 y tenemos una
umask de 022 obtendremos un fichero 644.
664 110 110 100

022 000 010 010
-----------------
644 110 100 100
pág. 164

Valor octal Valor simbólico Descripción
0 rwx Lectura, escritura y acceso a directorios
1 rw- Lectura y escritura
2 r-x Lectura y acceso a directorios
3 r-- Sólo lectura
4 -wx Escritura y acceso a directorios
5 -w- Sólo escritura
6 --x Sólo acceso a directorios
7 --- Nada
Esto tiene la utilidad de proteger el sistema frente a cierto tipo de

descuidos durante la creación de ficheros.

Por ejemplo supongamos que un administrador de un sistema considera que por
defecto todos los ficheros que el crea deberían carecer de
permisos de ejecución y de escritura para todo el mundo y que para los usuarios
de su mismo grupo deberían de carecer de permiso de ejecución.

Para ello establecerá una 'umask = 023'. Es decir una umask que elimina los permisos
- - - . - w - . - w x

Para un script que genere ficheros que solo deban ser accesibles para el usuario que los ha
generado usaríamos. 'umask = 077'
El valor predeterminado de la máscara de usuario del sistema en CentOS, es 0022, es decir se

asigna permiso 0755 (-rwxr-xr-x) para nuevos directorios y 0644 (-rw-r--r--) para nuevos
archivos. El sistema jamás permite crear nuevos archivos con atributos de ejecución. El valor
predeterminado se define en una variable de entorno del archivo “/etc/profile” y puede ser
cambiado por el que el administrador del sistema considere pertinente. El valor también puede
establecerse por usuario en el archivo “~/.bash_profile” CentOS.
pág. 165

Comando chmod

Este comando sirve para alterar una serie de atributos del fichero.
Existen dos formas de usarlo. Una indicando el tipo de acceso y a quien lo
queremos conceder o eliminar. Existen una serie de atributos que se
pueden modificar usando este comando.

04000 Set uid on execute.
02000 Set gid on execute.
01000 Save text on image after execution.
00400 r Permiso de lectura para el propietario (owner)
00200 w Permiso de escritura para el propietario
00100 x Permiso de ejecución para el propietario
00040 r Permiso de lectura para el grupo (group)
00020 w Permiso de escritura para el grupo
00010 x Permiso de ejecucion para el grupo
00004 r Permiso de lectura para cualquiera (others)
00002 w Permiso de escritura para cualquiera
00001 x Permiso de ejecucion para cualquiera
Consulte las páginas del manual relativas a este comando. Como de costumbre
el manual resulta imprescindible a la hora de recordar la utilización de un
comando pero no a la hora de comprender conceptos nuevos.

No se preocupe con los ejercicios que le proponemos a continuación comprenderá
perfectamente:

$ cd /tmp
$ touch chmod.txt
$ ##################################
$ chmod 777 chmod.txt

$ ls -l kk
-rwxrwxrwx .... .... ......
$ ##################################

pág. 166


$ ls -l kk
-rwx---rwx .... .... ......
$ ##################################

$ ls -l kk
-r---w---x .... .... ......
$ ##################################

$ ls -l kk
---x-w-r-- .... .... ......
$ ##################################
$ # 'chmod 0 chmod.txt ' equivale a 'chmod 000 chmod.txt '

$ chmod 0 chmod.txt
$ ls -l kk
---------- .... .... ......
$ ##################################

$ chmod +r chmod.txt
$ ls -l kk
-r--r--r-- .... .... ......
$ ##################################
$ chmod +x chmod.txt
$ ls -l chmod.txt
-r-xr-xr-x .... .... ......
$ ##################################

$ chmod -r chmod.txt
$ ls -l chmod.txt
---x--x--x .... .... ......
$ ##################################
pág. 167

$ chmod u+r chmod.txt
$ ls -l chmod.txt
-r-x--x--x .... .... ......
$ ##################################

$ chmod a-x chmod.txt
$ ls -l chmod.txt
-r-------- .... .... ......
$ ##################################

$ chmod g+x chmod.txt
$ ls -l chmod.txt
-r----x--- .... .... ......

$ ##################################
$ chmod o+x chmod.txt
$ ls -l chmod.txt
-r----x--x .... .... ......
$ ##################################

$ chmod a+rwx chmod.txt
$ ls -l chmod.txt
-rwxrwxrwx .... .... ......
rm chmod.txt
pág. 168

Opciones de chmod.
-R
Cambia permisos de forma descendente en un directorio dado. Es la única opción de los
estándares POSIX.
-c
Muestra cuáles archivos han cambiado recientemente en una ubicación dada
-f
Omite mostrar errores de archivos o directorios que haya sido imposible cambiar
-v
Descripción detallada de los mensajes generados por el proceso
Para obtener una descripción completa del uso de chmod, ejecute:
man 1 chmod

Comando chown
El comando 'chown' sirve para cambiar el UID y el GID de un fichero. Esto solo se puede
hacer si tenemos los permisos para ello.
Normalmente su uso está reservado a 'root' y por ello no diremos nada más. Es muy
posible que si usted usa Linux en un ordenador personal necesite algunos de estos
conocimientos pero se sale de los propósitos de este curso. Le basta con saber que existe
y para que sirve.

Concesión de acceso por parte del kernel
Explicaremos el funcionamiento de los permisos de la forma más precisa que nos sea posible.

Para ello usaremos unas abreviaturas que ya conocemos.
EUID es el Identificador de usuario efectivo de un proceso
EGID es el Identificador de grupo efectivo de un proceso
UID en un fichero es un atributo que identifica al propietario.
GID en un fichero es un atributo que identifica al grupo del propietario.

pág. 169

En realidad hablamos de propietario como el usuario que creo el fichero.

El Kernel realizará el siguiente test para conceder a un proceso el acceso de cierto tipo a
un fichero.

1. Si el EUID del proceso es 0 se da acceso. (root puede hacer lo que sea).
2. Si el EUID del proceso es igual al UID del owner (propietario del fichero) se concede el
acceso si los permisos de usuario rwx son los adecuados.
3. Si el EUID del proceso es distinto al UID del owner, y si el EGID del proceso es igual al
GID del owner, se concede el acceso si los permisos de grupo rwx son los adecuados.
4.Si el EUID del proceso es distinto al UID del owner, y si el EGID

del proceso es distinto al GID del owner, se concede el acceso si los permisos de los
others rwx son los adecuados.
NOTA : el comando rm permite borrar cualquier fichero sea cual sean los permisos cuando el
proceso tiene un EUID coincidente con el propietario el fichero. Únicamente ocurre que si el
fichero esta protegido contra escritura suele pedir (dependiendo de la configuración)
confirmación antes de borrarlo. El permiso para borrar un fichero no se guarda como atributo
del fichero. Esto se hace a nivel de directorio y pasamos a explicarlo
inmediatamente.

Significado de los permisos en directorios

Para entender como funcionan los permisos aplicados a un directorio hay

que imaginar que un directorio es un fichero normal que solo contiene una
tabla en la que se relacionan los ficheros presentes en ese directorio. En
todos los directorios existen siempre un par de entradas obligadas que son
'.' y '..' para el directorio actual y para el directorio padre respectivamente.

pág. 170

Vamos a explicarlo sobre la marcha a la vez que hacemos el ejercicio.

Recuerde usar un usuario normal (distinto de root) para realizar los ejercicios.

$ cd /tmp
$ mkdir otromas
$ cd otromas
$ echo > k1
$ echo > k2
$ cd /tmp
$ chmod 777 otromas
Para ver como ha quedado los permisos hacemos...

$ ls -ld otromas
Para ver que ficheros contiene el directorio “otromas” hacemos...
$ ls otromas
Si un directorio no tiene permiso de lectura, resultara imposible para

cualquier comando incluido ls averiguar cual es su contenido.

Sin abandonar la sesión anterior continuamos el ejercicio

Eliminamos los premisos de lectura del directorio kk

$ chmod -r otromas
$ ls -ld otromas
Nos dara un resultado, pero si ejecutamos el siguiente codigo
$ ls -l otromas

Esto nos podría mandar un mensaje como este “ls: otromas: Permiso denegado”
En este intante podemos entrar dentro del directorio

Incluso podemos crear un nuevo fichero pero ya no podemos saber cual es el contenido del
directorio.
pág. 171

$ cd otromas
$pwd
Debemos ver lo siguiente;
/tmp/ otromas
Ahora crearemos un tercer archive
$ echo > k3
Y al dar el comando siguiente nos daremos cuenta que ya no tendremos permisos

$ ls -l

ls: .: Permiso denegado

Hemos podido meternos dentro del directorio “otromas” porque aun tenemos permiso para
ello pero seguimos sin poder saber cual es su contenido.

$ cd /tmp

Si no se tiene permiso de ejecución en un directorio no se podrá hacer cd
a ese directorio, ni a ninguno de los directorios que cuelgan de el.
Esto imposibilita todas las operaciones que utilicen ese directorio como parte del camino.

Ahora eliminamos permiso de ejecución

$ chmod -x otromas
$ ls -ld otromas
Nos mostrara algo como lo siguiente;

d-w--w--w- 2 ..... ...... kk

pág. 172

Ahora intentamos entrar

$ cd otromas

Y nos mandara un mensaje parecido al siguiente;

bash: cd: otromas: Permiso denegado

Nos damos cuenta que no hemos podido entrar

$ rm kk/k2
bash: cd: otromas: Permiso denegado

Tampoco nos deja borrar el fichero desde fuera

Recuperamos permiso de ejecución
$ chmod +x otromas
$ ls -ld kk
$ rm kk/k2
$ ls otromas
k1
Si no tiene permiso de escritura no se podra dar altas, baja o

modificaciones en la tabla lo que se traduce en que no se pueden borrar
sus ficheros ni crear otros nuevos, ni renombrar ficheros.

Ahora eliminaremos permisos de escritura

$ chmod 666 otromas

$ ls -ld otromas

Ahora no tenemos permiso de escritura

$ cd otromas
$ ls
pág. 173

rm: ¿borrar `k1'? (s/n) s

rm: k1: Permiso denegado

$ echo > k3
bash: k3: Permiso denegado

$ touch k3
touch: k3: Permiso denegado

Sin permiso de escritura en el directorio no se pueden crear ficheros nuevos dentro de el ni

borrar ficheros pero los ficheros son perfectamente accesibles

$ echo "Mensaje de prueba" > k1

$ cat k1

Vamos a limpiar
$ chmod 777 /tmp/ otromas

$ rm /tmp/ otromas /*
$ rmdir /tmp/ otromas
Uso de las ACLs

Una vez que hemos compilado el kernel con soporte para ACLs y que hemos compilado las
herramientas necesarias para poder trabajar con ellas (además de parchear aquellas utilidades
de gestión de ficheros y sistemas de ficheros para que reconozcan las ACLs y las respeten y
sepan interpretarlas), podemos ya dedicarnos a la gestión de las propias ACLs en si.
Para ello disponemos de dos utilidades principalmente:
getfacl: que nos permite consultar las ACLs de un fichero dado.
setfacl: que nos permite modificar las ACLs de un fichero dado.
Ambas utilidades se hayan perfectamente documentadas en sus respectivas páginas del manual
(setfacl(1) y getfacl(1)), y podemos encontrar una pequeña introducción en la página del manual
de acl(5), vamos a ver aquí algunos ejemplos sencillos que ilustrarán el uso básico de estas
utilidades.
pág. 174

Creación de una ACL básica.

Existen casos en los cuales el tradicional juego de pemisos UGO (User, Group, Others) no es
suficiente. Casos en los que desearíamos que más de un usuario o más de un grupo pudiesen
tener acceso a un fichero, pero con permisos diferenciados. Con el modelo UGO esto no es
posible, puesto que sólo tenemos sitio para los permisos de un único Usuario o un único Grupo.
Todo lo demás cae en el Other (el resto). Con las ACLs esto es sencillo.
Vamos a presuponer que tenemos un directorio que contiene una serie de ficheros y dos
subdirectorios (a su vez con ficheros) como se indica en la siguiente figura:
Tenemos asimismo los siguientes tipos de usuarios diferenciados:
1. Los usuarios del grupo de sistemas de información, que deben tener acceso
completo a todos los directorios y ficheros, para su mantenimiento. Llamaremos a
este grupo sistemas.
2. Los usuarios del grupo de desarrollo (llamaremos a este grupo desarrollo), que
deben tener acceso de lectura y escritura (y ejecución en su caso) en el primer
subdirectorio y todos sus ficheros y subdirectorios. En este directorio es donde se
desarrollan las nuevas versiones del software que usa el tercer grupo.
Asi mismo debe tener acceso de lectura/escritura al segundo de los subdirectorios

para implantar las nuevas versiones estables del software.
3. Los usuarios de explotación. Este grupo debe tener acceso en modo lectura (y
eventualmente ejecucion) sobre los ficheros de la aplicacion. Llamaremos a este
grupo explotacion.
4. El resto de usuarios del sistema no deben tener ningún tipo de acceso a ninguno de
los ficheros o subdirectorios.
Con las condiciones anteriores es imposible usar el modelo de permisos tradicional UGO, puesto
que tenemos tres grupos de usuarios diferentes, sin contar el resto de usuarios del sistema. Eso
significa que con un sólo grupo de usuarios con permisos asignados por directorio o fichero no
es posible acomodar los permisos para los tres grupos.
Utilizando ACLs es fácil resolver el problema, puesto que podemos asignar un juego de permisos
diferente para cada grupo de usuarios. Para ello debemos crear las ACLs necesarias para cada
grupo de usuarios y directorio o fichero.
pág. 175

1.- Tenemos que dar permisos completos al grupo de sistemas sobre todos los ficheros y
directorios implicados. Para ello usamos setfacl de la siguiente forma:

setfacl -b -k -R dir_raiz
setfacl -R -m g:sistemas:rw
Vayamos por partes con la sintaxis de setfacl:

En el primer caso usamos la opcion -b para borrar la ACL que ya pudiera tener el
directorio raíz. Usamos también la opción -k para borrar la ACL por defecto que pudiera
tener el directorio raíz (más sobre esto después), y por último usamos la opción -R para
aplicar los cambios de forma recursiva a todo lo que cuelga del directorio raíz. Con esto
conseguimos tener todo limpio y listo para empezar.
Teóricamente la primere vez no hace falta limpiar la ACL puesto que aún no hemos
asignado ninguna ACE, pero de paso aprovechamos para mostrar como se hace :)
En el segundo caso indicamos de nuevo que queremos aplicar de forma recursiva los
cambios (opción -R) pero esta vez le decimos que queremos modificar (-m) la ACL del
objeto en cuestión. En este caso es necesario además indicar el valor de la ACE que
deseamos añadir o modificar. setfacl distingue entre asignar una ACL (opción -s) en la
cual se eliminan las ACEs existentes y se añade la ACE especificada en la orden, y
modificar una ACL (opción -m) en la cual podemos modificar o añadir una ACE.
En este caso queremos añadir una nueva ACE. Para ello debemos escribimos la ACE que nos
interesa:

g:sistemas:rw
Todas las ACEs tienen tres componentes separadas por ':' (en el caso de las operaciones de
borrado de ACEs el tercer componente es opcional). El primero de los componentes indica si
se trata de un ACE de usuario (valor u) o de grupo (valor g). Incluso es posible asignar ACEs al
grupo de usuarios resto (other), pero esto no suele ser habitual, así que omitiremos la sintaxis
(se pueden encontrar más detalles en la página del manual de setfacl(1)).
El segundo de los componentes es el nombre de usuario o grupo al que se le aplica la ACE. Se

puede dar el nombre simbólico o el valor numérico del uid o gid correspondiente. El tercer
componente es el valor del permiso asociado a esta ACE, y puede ser una combinación
pág. 176

cualquiera de las letras r, w, x y -, o un valor numérico octal (como en chmod).

Por tanto, en nuestro caso tenemos que es una ACE de grupo (g), que se aplica al grupo de
sistemas y que le estamo dando los permisos de lectura y escritura (rw).

A continuacion tenemos que dar permisos al grupo de desarrollo tanto en el directorio
subdir_1 y todo su contenido, como en el directorio subdir_2 y todo su contenido. Sin
embargo no tenemos que dar acceso a los ficheros que cuelgan directamente de dir_raiz. Para
ello usamos setfacl con la sintaxis explicada en el punto anterior:

setfacl -R -m g:desarrollo:rw dir_raiz/subdir_1
setfacl -R -m g:desarrollo:rw dir_raiz/subdir_2

1.- Por último tenemos que dar permisos al grupo de explotación en el directorio subdir_2 y
todo su contenido:

setfacl -R -m g:explotacion:rx dir_raiz/subdir_2
Lo normal en este punto es comprobar cuales son los permisos reales que tienen cada uno de
los ficheros y directorios existentes, para ver si efectivamente se ajustan a los requisitos
planteados.
Para ello podemos usar getfacl para ver cuales son las ACL de cada uno de los directorios o
ficheros implicados. La sintaxis es sencilla:

getfacl fichero ...
Si lo usamos para ver el resultado de las órdenes anteriores tenemos:

# getfacl dir_raiz
# file: dir_raiz
# owner: root
pág. 177

# group: root
user::rwx
group::r-x
group:sistemas:rw-
mask::rwx
other::r-x
El listado de permisos que obtenemos al ejecutar getfacl se compone de entradas de tipo user y
group, además de las entradas para mask y other. En el caso de las entradas user y group,
tendremos siempre una entrada para el propietario del fichero y el grupo del fichero (son las
líneas que no indican un usuario o grupo concreto) y tantas líneas adicionales como ACEs de ese
tipo hayamos asginado al fichero o directorio. La entrada other es la entrada del permiso
tradicional other del modelo UGO.
La entrada mask es especial. Esa entrada, que se puede manipular con setfacl permite
especificar el máximo de permisos que se pueden asignar en dicho fichero con las ACEs de
usuario y grupo.
Veamos ahora las ACL del resto de ficheros y directorios:

# file: dir_raiz/fich_1 # file: dir_raiz/dir_1/fich_4
# owner: root # owner: root
# group: root # group: root
user::rw- user::rw-
group::r-- group::r--
group:sistemas:rw- group:sistemas:rw-
mask::rw- group:desarrollo:rw-
other::r-- mask::rw-
other::r--
# file: dir_raiz/fich_2
pág. 178

# owner: root # getfacl dir_raiz/dir_2

# group: root # file: dir_raiz/dir_2
user::rw- # owner: root
group::r-- # group: root
group:sistemas:rw- user::rwx
mask::rw- group::r-x
other::r-- group:sistemas:rw-
group:desarrollo:rw-
# getfacl dir_raiz/dir_1 group:explotacion:r-x
# file: dir_raiz/dir_1 mask::rwx
# owner: root other::r-x
# group: root
user::rwx # getfacl dir_raiz/dir_2/fich*
group::r-x # file: dir_raiz/dir_2/fich_5
group:sistemas:rw- # owner: root
group:desarrollo:rw- # group: root
mask::rwx user::rw-
other::r-x group::r--
group:sistemas:rw-
# getfacl dir_raiz/dir_1/fich* group:desarrollo:rw-
# file: dir_raiz/dir_1/fich_3 group:explotacion:r-x
# owner: root mask::rw-
# group: root other::r--
user::rw-
group::r-- # file: dir_raiz/dir_2/fich_6
group:sistemas:rw- # owner: root
pág. 179

group:desarrollo:rw- # group: root

mask::rw- user::rw-
other::r-- group::r--
group:sistemas:rw-
group:desarrollo:rw-
group:explotacion:r-x
mask::rw-
other::r--
pág. 180

ACLs por defecto

Todo lo anterior está muy bien, pero tiene un problema: los ficheros y directorios nuevos que se
creen no van a tener todas esas ACLs con los valores adecuados, y por tanto tendremos que
estar cada dos por tres ajustando los valores de las ACLs con las órdenes anteriores.
Evidentemente eso no es operativo en absoluto. En nuestra ayuda llegan las ACLs por defecto
(en realidad habría que hablar de ACEs por defecto, pero la documentación habla de ACLs por
defecto, así que mantendremos la misma terminología para no crear más confusión).
Las ACLs por defecto nos permiten indicar cuál es el juego de ACEs que queremos que se
apliquen automáticamente a los nuevos ficheros y directorios que se creen dentro de un
directorio dado. Se dice en estos casos que los permisos se heredan desde el directorio padre.
La sintaxis es idéntica a la de una ACE normal, con la diferencia de que debemos usar además la
opción -d:

setfacl -d -m g:sistemas:rw dir_raiz
setfacl -d -m g:desarrollo:rw dir_raiz/dir_1
setfacl -d -m g:desarrollo:rw dir_raiz/dir_2
setfacl -d -m g:explotacion:rw dir_raiz/dir_2
Si usamos getfacl para ver la ACL del directorio raíz por ejemplo, tenemos lo siguiente:

# getfacl dir_raiz
# file: dir_raiz
# owner: root
# group: root
user::rwx
group::r-x
group:sistemas:rw-
mask::rwx
other::r-x
pág. 181

default:user::rwx
default:group:sistemas:rwx
default:group::r-x
default:mask::rwx
default:other::r-x

Es decir, se añaden una serie de ACEs especiales, de tipo default que contienen la
información a utilizar para los nuevos ficheros y directorios que se creen dentro de éste.
Nota: Recuerde que es posible montar acl’s de manera manual en algún file system, esto lo
lograríamos conel comando:

# mount -oacl /dev/hda5 /data
Ejercicio:
Para poder realizar el ejercicio y poder ver el tema funcionando es necesario realizar la
instalación de las acl, para lo cual es necesario ejecutar lo siguiente:
# yum -y install acl

Una vez habilitado el soporte para listas de control de acceso en los sistemas de archivos se
pueden utilizar lo siguiente:
Getfacl: Definido para determinar los permisos establecidos en las listas de control de acceso de
un archivo o directorio dado.
Setfacl: Definido para cambiar los permisos en las listas de control de acceso de un archivo o
directorio dado.
Siempre se podrá realizar la consulta de ayuda y opciones ejecutando cualquiera de los dos con
man.
Para obtener una descripción completa del formato de las listas de control de acceso se puede
realizar la misma consulta pero con el comando acl.
Para realizar el ejercicio daremos de alta un usuario nuevo;
# useradd userget
Y le asignaremos un password
pág. 182

# passwd userget
Para obtener los atributos de las “acl” de un archivo o directorio particular, se ejecuta “getfacl”
de la siguiente forma:
getfacl /home/userget

Lo anterior devolvería una salida similar la siguiente:
getfacl: Eliminando '/' inicial en nombres de ruta absolutos
# file: home/userget
# owner: userget
# group: userget
user::rwx
group::---
other::---
Lo anterior muestra que sólo el propietario del directorio tiene permisos de lectura, escritura y
acceso.
Para poder demostrar el uso de las acl, daremos de alta otro usuario mas para dar el acceso de
uno a otro creando las listas de acceso, para tal caso crearemos un usuario nuevo;
# useradd userset
# passwd userset
Para asignar el permiso de acceso a la carpeta del usuario ejecuta “setfacl”, con la opción “-m”
para modificar la lista de control de acceso, [u,g,o]:[usuario,grupo]:[r,w,x] y la ruta del directorio
como argumentos.
Ejemplo:
# setfacl -m u:userset:rX /home/userget
En el ejemplo anterior se utilizó X mayúscula para indicar que sólo se aplicará el bit de acceso de
a directorios evitando aplicar el bit de ejecución a los archivos.
Lo anterior establece que se añaden permisos de lectura y acceso al directorio /home/userget
para el usuario userset.
Para verificar, ejecute de nuevo “getfacl” con la ruta del directorio modificado como argumento:
pág. 183

# getfacl /home/userget
Para demostrar como se pueden hacer crecer o mejorar estas listas asignaremos permisos a
otro usuario, el cual primero crearemos
# useradd usergetset
# passwd usergetset
De igual forma es posible asignarse permisos diferentes para otros usuarios. Ejemplo:
# setfacl -m u:usergetset:rwX /home/userget
Lo anterior establece que se añaden permisos de lectura, escritura y acceso al directorio
/home/userget para el usuario usergetset.
Y validamos nuevamente el cambio:
# getfacl /home/userget
Con la opción “-x” eliminaremos los permisos asignados;
# setfacl -x perengano /home/userget
Con la opción “–k” eliminara los permisos predeterminados en la lista de control de acceso,
también deberemos poner la ruta del directorio como argumento;
# setfacl -k /home/userget
Usando la opción “-b” eliminara todos los permisos de la acl, dejando todo como en el punto
inicial :
# setfacl -b /home/userget
Con el siguiente comando podríamos realizar una copia la acl a aplicarla a otro usuario y la
manera de aserlo es la siguiente;
# getfacl respaldo1 | setfacl --set-file=- respaldo2

Lsattr y chattr: control de atributos de ficheros Linux
El primer comando, lsattr permite listar los atributos asignados a los ficheros de un sistema de
ficheros Linux, mientras que chattr permite modificar dichos atributos, los cuales que utilizamos
como complemento al sistema de ACLs (chmod, chown,setfacl…) permitiendo un control más
férreo sobre los archivos del filesystem.
pág. 184

lsattr
El uso de lsattr no tiene demasiado misterio ya que únicamente nos servirá para listar atributos
de ficheros y directorios, ejemplo:
$ lsattr -a
------------- ./..
------------- ./.bash_history (archive que guarda los commandos tecleados en la consola)
------------- ./.
------------- ./prueba.txt
------------- ./.bashrc
------------- ./.bash_profile
------------- ./.ssh
------------- ./.bash_logout
Algunos parámetros del comando que conviene conocer son, por ejemplo, “-a” utilizado en el
ejemplo anterior que muestra todos los archivos del directorio, incluidos los ocultos. Si
queremos visualizar los atributos de forma recursiva utilizamos -R:
$ lsattr -Ra | more

-----------------e- ./.ike

./.ike:
-----------------e- ./.ike/.
-----------------e- ./.ike/sites

./.ike/sites:
-----------------e- ./.ike/sites/.
-----------------e- ./.ike/sites/..

-----------------e- ./.ike/..
-----------------e- ./.ike/certs

./.ike/certs:
-----------------e- ./.ike/certs/.
-----------------e- ./.ike/certs/..
pág. 185

-----------------e- ./.cisco_mds9000

./.cisco_mds9000:
-----------------e- ./.cisco_mds9000/.
-----------------e- ./.cisco_mds9000/install.log
-----------------e- ./.cisco_mds9000/..

chattr
Hoy toca hablar de chattr, una utilidad para nuestra terminal que sirve para asignar
diferentes atributos a nuestros archivos en Linux. Uno de los objetivos principales de esta
herramienta es el de proteger nuestros archivos de cambios involuntarios o borrados
accidentales y lo mejor de todo, te protegerá incluso aunque ejecutes comandos de
borrado o modificación siendo superusuario (root).
Los atributos de los que vamos a hablar hoy son soportados por los sistemas de archivos de
Linux nativos como ext2, ext3, ext4, btrfs, etc... Uno no podrá eliminar ni modificar los
archivos con los atributos que usemos, aunque tenga todos los permisos para hacerlo.
Cuando es necesario proteger algunos archivos y/o carpetas para que no puedan ser borrados.
Puede ser el caso de pcs compartidas o de sistemas donde se necesite mejorar un poco la
seguridad en caso de posibles penetraciones.

El comando que nos ayudara con la tarea sera chattr (change attribute). Este se utiliza para
cambiar varios atributos de archivos y puede usarse en carpetas de manera recursiva.
El comando es parte del paquete que viene instalado de base en todas las distros de linux.

Se usa asi:
chattr [opciones][operadores][atributos]
En opciones tenemos por ejemplo:

-R: Que es para cambios recursivos. Se usa con carpetas
En los operadores tenemos por ejemplo:

+: Para añadir atributos
-: Para quitar atributos
pág. 186

Y en los atributos podemos poner por ejemplo:

a: Establece que el fichero solo se puede abrir en modo de adjuntar para escritura
s: Los bloques utilizados en el disco duro son escritos con ceros, de modo que los datos no
se puedan recuperar por medio alguno. Es la forma más segura de eliminar datos.
u: Sus contenidos son guardados permitiendo recuperar el fichero con herramientas para
tal fin.
Se pueden encontrar mas de todo eso en la pagina man de chattr pero en concreto a nosotros
nos interesa el atributo ‘i’ que hace que el archivo no pueda ser renombrado, ni eliminado, ni
escribir datos en el. O sea que lo pone en modo de solo lectura.

Atributos;
A Establece que la fecha del último acceso (atime) no se modifica.
a Establece que el archivo sólo se puede abrir en modo de adjuntar para escritura.
c Establece que el archivo es comprimido automáticamente en el disco por el núcleo del
sistema operativo. Al realizar lectura de este archivo, se descomprimen los datos. La
escritura de dicho archivo comprime los datos antes de almacenarlos en el disco.
D Cuando se trata de un directorio, establece que los datos se escriben de forma sincrónica
en el disco. Es decir, los datos se escriben inmediatamente en lugar de esperar la
operación correspondiente del sistema operativo.
d Establece que el archivo no sea candidato para respaldo al utilizar la herramienta dump.
e Indica que el archivo o directorio utiliza extensiones (extents) para la cartografía de
bloques en la unidad de almacenamiento, particularmente de sistemas de archivos Ext4.
Cabe señalar que chattr es incapaz de eliminar este atributo.
i Establece que el archivo será inmutable. Es decir, se impide que el archivo sea eliminado,
renombrado, que se pueden apuntar enlaces simbólicos hacia éste o escribir datos en el
archivo.
j En los sistemas de archivos ext3 y ext4, cuando se montan con las opciones data=ordered
o data=writeback, se establece que el archivo será escrito en el registro por diario
(Journal). Si el sistema de archivos se monta con la opción data=journal (opción
predeterminada), todo el sistema de archivos se escribe en el registro por diario y por lo
tanto el atributo no tiene efecto.
s Cuando un archivo tiene este atributo, los bloques utilizados en el disco duro son escritos
con ceros, de modo que los datos no se puedan recuperar por medio alguno. Es la forma
más segura de eliminar datos.
pág. 187

S Cuando el archivo tiene este atributo, sus cambios son escritos de forma sincrónica en el
disco duro. Es decir, los datos se escriben inmediatamente en lugar de esperar la operación
correspondiente del sistema operativo.
u Cuando un archivo con este atributo es eliminado, sus contenidos son guardados
permitiendo recuperar el archivo con herramientas para tal fin.
Pruebas;

Creamos un archivo para realizar las siguientes pruebas;
# touch prueba.txt
Deshabilitar la modificación de la fecha de acceso al fichero (atime)
Con la asignación del atributo ‘A’ conseguimos que cuando se acceda al fichero no se modifique
el registro atime. De este modo no quedarán registrada la fecha del último acceso al fichero:
# chattr +A prueba.txt
# lsattr prueba.txt
-------A----- prueba.txt
Comprimir automáticamente el fichero en el disco
Si asignamos el atributo ‘c’ activamos que el fichero se comprima automáticamente en el disco
por el kernel. Cuando se lea el fichero se servirá descomprimido:
# chattr +c prueba.txt
# lsattr prueba.txt
--------c---- prueba.txt
Bloquear la modificación o borrado de un archivo
Como veíamos en la entrada que citaba al principio del post sobre evitar que un archivo pueda
ser modificado o borrado (incluso por root). Al asignamos el atributo ‘i’ activamos la flag para
que el fichero no pueda ser modificado, borrado o renombrado:
# chattr +i prueba.txt
# lsattr prueba.txt
----i-------- prueba.txt

pág. 188

Permitir recuperación de archivo aunque sea eliminado

Asignamos el atributo ‘u’ para que cuando el fichero se borre, sus datos permanezcan
guardados y permitan al usuario su recuperación:
# chattr +u prueba.txt
# lsattr prueba.txt
-u----------- prueba.txt
Al eliminar un archivo, sobreescribir con 0 todos sus bloques
Al contrario que con el atributo “u”, el atributo “s” implica que cuando un archivo sea borrado,
automáticamente los bloques utilizados por el mismo sean sobreescritos con ceros (zeroed):

# chattr +e prueba.txt
# lsattr prueba.txt
-----------------e- prueba.txt
Escribir de forma síncrona a disco cambios en los ficheros
El parámetro “S” implica que cuando un fichero es modificado, los cambios se aplican a disco de
forma síncrona y directa. Es lo mismo que tener la flag “sync” en el punto de montaje del
filesystem.
# chattr +S prueba.txt
# lsattr prueba.txt
--S---------------- prueba.txt
Y así podríamos seguir con una gran cantidad de distintos atributos. Como siempre, podéis
revisarlos en la página man de chattr. Por supuesto, los atributos se pueden asignar a la vez:
# chattr +uiAc prueba.txt

# lsattr prueba.txt
-u--i--Ac---- prueba.txt
# man chattr
pág. 189

Ejercicio para proteger un archive;

Generamos un segundo archivo;

# touch prueba2.txt

Como super usuario o root, ejecutamos:

# chattr +i prueba2.txt

Y ya no podran borrarlo con un

# rm prueba2.txt
Ni siquiera con un sudo su rm prueba.txt
Y si fuera un directorio la que queremos proteger de ser borrada, seria asi:

Creamos un directorio
# mkdir MiDirectorio
Le asignamos los atributos:
# sudo chattr -R +i MiDirectorio

Podemos comprobar que el atributo ha sido agregado usando lsattr en la carpeta que contiene
esa otra carpeta o el archivo:
# lsattr –a
Y al igual que el archivo quedara protegido para no ser eliminado accidentalmente.

Y cuando deseemos poder eliminar ese archivo o directorio usaremos;

# chattr -i prueba2.txt

Y después un rm.

pág. 190

Unidad 6. Herramientas básicas del Sistema Operativo.

Mandatos de uso básico, muévete por la consola.
Para realizar el siguiente ejercicio iniciaremos instalando los siguientes paquetes que
complememtaran elementos necesarios para poder realizar las tareas en la consola y poder
hacer uso de los comandos que se demostraran en el ejercicio:
# yum -y install man perl less file man-pages-es finger
El commando makewhatis sirve para generar un índice de las páginas de manual presentes en
el sistema.
# Makewhatis
Una vez ejecutado el comando esperaremos unos segundos o minutos dependiendo del Hw
disponible para la generación de los manuales.

Generaremos un usuario común para poder realizar el siguiente ejercicio:
Ejecutaremos el siguiente comando;
# useradd usuarioconsola
Después asignaremos el password a nuestro usuario;
# passwd usuarioconsola
Le asignaremos un password
Cierre la sesión de root ejecutando el mandato exit:
# Exit
pág. 191

Ejercicio;
Nos loguearemos con nuestro usuario “usuarioconsola” en una terminal para la realización del
ejercicio;
Cambiar de usuario a super-usuario.
Ejecute el mandato “su” sin argumentos e ingrese la clave de acceso de “root” cuando se le
solicite:
$ su
Con el siguiente comando visualizaremos lo que se conoce como variables de entorno:

# echo $USER; echo $LOGNAME; echo $SHELL; echo $PATH; echo $HOME
Observe que aunque se tienen privilegios de “root”, se carece de las variables de entorno de
éste, por lo cual algunos mandatos sólo se podrán ejecutar si se específica la ruta exacta de
éstos (ejemplos: /sbin/service, /sbin/chkconfig, /sbin/fsck y /sbin/fdisk).

Ahora nos sadremos de la consola con el siguiente comando.
# Exit
Ejecutando el comando “su” acompañado de la opción “-l” ingresamos la clave de acceso de

“root” una vez que nos lo ordene:
su –l
Ejecutamos ahora el comando y podremos ver las variables de entorno:

echo $USER; echo $LOGNAME; echo $SHELL; echo $PATH; echo $HOME
Observe que además de los privilegios de “root”, se tienen también de las variables de entorno
de éste, pues en realidad se ha realizado un ingreso (login) como “root”.
Nos volvemos a salir con el siguiente comando para regresar como usuario regular
“usuarioconsola”
Exit
Ejecutando el siguiente comando nos mostrara la informacion del sistema:

$ uname –a
$ hdparm en suse y el centos con parámetros.
pág. 192

Lo anterior nos mostrará el nombre del núcleo, nombre de anfitrión, número de lanzamiento
del núcleo, versión del núcleo de Linux, tipo de microprocesador, plataforma del sistema y
nombre del sistema operativo, algo parecido a lo siguiente:
Linux localhost.localdomain 2.6.32-71.29.1.el6.i686 #1 SMP Mon Jun 27

18:07:00 BST 2011 i686 i686 i386 GNU/Linux
Ejecutando el siguiente comando nos mostrara el nombre de usuario que está usted está
utilizando:
$ whoami
Con el siguiente comando nos mostrara los usuarios que están conectados en el sistema y
dónde lo están haciendo:
$ who
Con el siguiente nos mostrara cuáles usuarios están conectados en el sistema, en qué tipo de
terminal lo están haciendo y qué están haciendo o ejecutando:
$ w
Con el siguiente nos mostrara el grupo al que pertenece en caso de pertenecer a alguno:
$ id
Con el siguiente comando podrá visualizar cuáles usuarios están conectados en el sistema, en
qué tipo de terminal lo están haciendo y mostrar la información de usuario definida en el
archivo /etc/passwd:
$ finger
Ejecutando el siguiente podrá ver bitácora de acceso de los más recientes ingresos a sistema de
todos los usuarios existentes en el sistema;
$ lastlog
Con el siguiente podremos visualizar la bitácora, con los ultimos accesos hacia el sistema;
$ last
Con el siguiente podremos ver los privilegios de root de la bitácora de intentos fallidos de
acceso al sistema;
pág. 193

$ su -l root -c "lastb"
Ejecute lo siguiete, esto devolverá que /etc/hosts es un archivo de texto:
$ file /etc/hosts
Ejecutando lo siguiente, podremos ver que /boot/grub/e2fs_stage1_5 es un archivo que carga el

boot y sus propiedades:
$ file /boot/grub/e2fs_stage1_5
Ejecutando el siguiente, nos mostrara el directorio en el cual estamos ubicados:

$ pwd
Para poder cambiarnos de directorio utilizaremos el comando cd, de la guiente forma:

$ cd /usr/local
Ahora ejecutaremos de nuevo el siguiente comando y podremos ver que el directorio a

cambiado:
$ pwd
Si utilizamos el comando cd sin argumentos, nos devolverá al hogar el usuario que estemos
usando:
$ cd
Ejecute nuevamente el mandato “pwd” para verificar que se encuentra en su directorio de

inicio.
Ahora ejecutamos el comando, el cual listara los archivos contenidos en la ruta que
describamos, sin necesidad de cambiarnos de directorio:
$ ls /usr/local
Ejecutando el comando siguiente listara los archivos directos del directorio donde estemos
ubicados, en este caso no debe mostrar ninguno pues nos encontramos en el home de nuestro
usuario:
$ ls
Ahora si ejecutamos el siguiente, podremos ver los archivos ocultos
$ ls –a
pág. 194

Ejecutando el siguiente nos mostrara los mismos archivos per de manera ordenada por nombre,
los atributos y permisos:
$ ls –la
Ejecutando el siguiente, nos mostrara los archivos en orden inverso:

$ ls -lar
Ejecutando el siguiente nos los mostrara por nombre, en orden inverso y el tamaño de los
archivos:
$ ls -hlar
Ejecutando el siguiente, mostrara los permisos, los atributos además de que los ordenara por
tamaño:
$ ls -Sla
Ejecutando el siguiente mostrara lo mismo que el comando anterior pero en orden inverso:
$ ls –Slar
Ejecutando el siguiente, mostrara los permisos y atributos, pero el orden lo realizara por fecha
de modificacion:
$ ls –tla
Ejecutando el siguiente será lo mismo pero en orden inverso:

$ ls -tlar
Ejecutando el siguiente nos mostrara lo mismo agregando el tamaño de los archivos:

$ ls -htlar
Ejecutando el siguiente mostrara la información del inodo que corresponde a cada archivo:
$ ls -ia
Ejecutando el siguiente, mostrara también el detalle del inodo de cada archivo:

$ ls -lia
pág. 195

El comando touch crea archivos, pero se pueden generar también en cadenas, es decir generar
varios archivos con un comando, ejecuaremos el siguiente para generar archivos vacios:
$ touch texto1 texto2 texto11 texto12 texto136 texto246

$ touch textoA textoB textoaa textoAB textoabc textoABC
Ejecutando el siguiente, nos mostrara como, común el valor 1 y tomando como universo el *, de
esta manera los archivos que mostrara serán todos lo que contenga 1 entre “algo y algo”
$ ls texto*1*
Ejecutando el siguiente comando, nos listara todos los archivos que inicien con la cadena texto1,
pero solo los que carecen de 1 en cualquier parte después de la cadena descrita:
$ ls texto[!*1]*
Ejecutando el siguiente comando nos listara todos los archivos que inician con la cadena texto,
pero solo los que tienen 3 caracteres consecutivamente:
$ ls texto???
Ejecutando el siguiente, nos mostrara todos lo que inician con la cadena texto, pero solo 2
caracteres consecutivos:
$ ls texto??
Ejecutando el siguiente solo listara los archivos que inicien con la cadena texto, pero solo
aquellos que incluyan números después de la cadena antes descrita:
$ ls texto[[:digit:]]*
Ejecutando el siguiente listara solo los archivos que inician con la cadena texto, pero solo
aquellos que terminan con letras minusculas:
$ ls texto[[:lower:]]*
Ejecutando la siguiente nos listara solo los archivos que inicien con la cadena texto y que
terminan con letras mayusculas:
$ ls texto[[:upper:]]*
Ejecutando el siguiente nos mostrara los archivos que contengan la cadena texto y solo los que
terminan con caracteres distintos de numeros:
pág. 196

$ ls texto*[![:digit:]]
Ejecutando lo siguiente nos listara los archivos que inician con la cadena texto, pero solo
aquellos que terminan con la letra c minúscula o C mayuscula:
$ ls texto*[cC]
Ejecutando el siguiente nos listara todos los archivos que contengan la cadena texto, pero solo
aquellos que cualquier carácter distindo de c minúscula o C mayuscula:
$ ls texto*[!cC]
Ejecutando el siguiente comando, listar todos lo archivos con la cadena texto pero solo los
archivos qe incluyan la letra a, A o el número 1 despues de dicha cadena:
$ ls texto[!aA1]*
Con el siguiente comando crearemos un directorio nuevo llamado ejercicios1:

$ mkdir ejercicios1

Ingresamos dentro de la carpeta con el siguiente comando
$ cd ejercicios1
Y dentro creamos otro directorio llamado UNO con el comando siguiente:
$ mkdir UNO
Nos salimos de la carpeta para realizar este proceso pero desde el directorio original es decir
crear un directorio fuera del directorio con el siguiente comando:
$ mkdir ejercicios1/DOS
Ahora ejecutamos lo siguiente para intentar generar otro directorio denominado “UNO”, pero
dentro del directorio «ejercicios2» (el cual es inexistente).
$ mkdir ejercicios2/UNO/
pág. 197

Lo anterior devolverá un mensaje de error como el siguiente:

mkdir: no se puede crear el directorio «ejemplos2/uno»: No existe el archivo
o el directorio
A fin de poder crear el directorio “UNO”, dentro del directorio «ejercicios2», es necesario crear
primero «ejercicios2». Sin embargo puede indicarle a mkdir que genere toda la ruta añadiendo
la opción -p (path):
$ mkdir -p ejercicios2/uno
Para verificar que esta creada podemos ejecutar lo siguiente:

$ ls
Y ver que existe ya el directorio ejercicios2, y después ejecutar;
$ ls ejercicios2
Y verificar que existe UNO destro de ejercicios2.
El comando cp sirve para copiar archivos, con el siguiente comando copiaremos un archivo
dentro del directorio ejercicios2
$ cp /etc/fstab ~/ejercicios1/
Vuelva a utilizar el mandato cp de este modo:

$ cp /etc/passwd ~/ejercicios1/
Con estos dos procedimientos, se habrán copiado dos distintos archivos (/etc/fstab y
/etc/passwd) dentro del directorio ejericicios1
Intente copiar el directorio ~/ejemplos1/ como el nuevo directorio ~/copia1, ejecutando lo
siguiente:
$ cp ~/ejercicios1/ ~/copia1
Lo anterior devolverá un error porque ~/ejemplos1 es un directorio:

$ cp: se omite el directorio «ejercicios1/»
Para poder llevar acabo la tarea de la copia de un directorio con su contenido hay que utilizar la
opción “-r” por la recuisividad. Ejecute la tarea de la siguiente forma:
$ cp -r ~/ejercicios1/ ~/copia1/
pág. 198

Podremos ver el contenido de ambos directorios utilizando el mandato “ls” con la opción “-l”:
$ ls -l ejercicios1/ copia1/
El comando rm sirve para eliminar archivos y directorios, ahora lo usaremos de la siguiente

forma, elimine el directorio copia1, ejecutando lo siguiente:
$ rm -fr ~/copia1/
Se puede lograr una copia de un directorio, conservando todos los atributos y permisos del
contenido del directorio original, utilizando el mandato “cp# con la opción “-a”:
$ cp -a ~/ejercicios1/ ~/copia1/
Podremos realizar una copia de un directorio, conservando todos los atributos y permisos del
contenido del directorio original, pero sólo copiando los archivos que cambiaron respecto de el
directorio de origen y viendo una salida descriptiva, utilice el mandato cp con las opciones -auv:
$ cp -auv ~/ejercicios1/ ~/copia1/
Visualice de nuevo el contenido de ambos directorios utilizando el mandato ls con la opción -l:
$ ls -l ~/ejercicios1/ ~/copia1/
Utilice el mandato “touch” para cambiar la fecha de modificación del archivo ~/ejericios1/fstab:
$ touch ~/ejercicios1/fstab
Con el comando “cp” y la opción “-a” se realiza una copia exacta del directorio de origen con
todo y sus contenidos, “-u” para realizar solo la copia de los contenidos nuevos y “–v” para
visualizar la salida de una manera mas detallada:
$ cp -auv ~/ejercicios1/* ~/copia1/
Ejecutamos nuevamente el comando mkdir y generamos un directorio con el nombre “nuevo”

dentro del directorio de ejercicios1;
$ mkdir ~/ejercicios1/nuevo
Ingresamos al directorio de “ejercicios1”para continuar y ejecutamos lo siguiente:

$ cd ~/ejercicios1/
Listamos el contenido de este directorio, ejecutando lo siguiente:

$ ls
Nos mostrara los archivos “fstab” y “passwd” y el directorio “nuevo”:
pág. 199

$ adicional fstab passwd
Con el comando “mv” moveremos los archivos de lugar, mostrando su funcionamiento con el
siguiente coamando:
$ mv fstab nuevo/
Examine el contenido del directorio “ejercicios1”utilizando de nuevo el mandato “ls”;

$ ls
Ingresamos al directorio “nuevo”con el comando siguiente;

$ cd nuevo
Visualizamos nuevamente el contenido del directorio de trabajo actual ejecutando el siguiente

comando;
$ ls
Regresamos al directorio “ejercicios1”que se encuentra un nivel arriba utilizando el coamando;

$ cd ../

Eliminamos el archivo “passwd” utilizando el comando “rm” de la siguiente forma;
$ rm passwd
Hacemos lo mismo con el archivo “fstab” que esta dentro de directorio “nuevo”;
$ rm nuevo/fstab
Y eliminamos el directorio “nuevo” de la siguiente forma;

$ rmdir nuevo
Creamos un nuevo sub-directorio con el nombre “NuevoDir1”;

$ mkdir NuevoDir1
Accesamos a este nuevo directorio:

$ cd NuevoDir1
Ejecutamos lo siguiente:
$ mkdir Nuevo Directorio
Listamos el contenido actual mostrando una sola columna:
pág. 200

$ ls -1
Lo anterior creó dos nuevos directorios, uno con el nombre “Nuevo” y otro con el nombre
“Directorio”, por lo que mostrara los siguientes archivos o carpetas:
$ Directorio Nuevo
Ejecutando el comando de la siguiente forma, solo que en esta ocasión utilizará una diagonal
inversa antes del espacio:
$ mkdir Nuevo\ Directorio
Listamos de nueva cuenta el contenido del directorio de trabajo actual mostrando una sola
columna:
$ ls -1
Lo anterior creó un nuevo directorio denominado “Nuevo Directorio”, lo que nos mostrara un
listado como la siguiente:
$ Directorio
Nuevo
Nuevo Directorio
La diagonal inversa funciona como carácter de escape para indicar que espacio entre “Nuevo” y
“Directorio” es parte del nombre el directorio que vamos crear.
Una vez que hemor realizado esta tarea borraremos el directorio con todo su contenido desde
el home con un comando, pero regresando al home
$ cd

Y dando un “ls” podremos ver el directorio o dirctorio principales
$ ls

Y para borrar la carpeta le daremos el siguiente comando;

$ rm –r ejercicios1

pág. 201

Lo cual hara un borrado recursivo, lo cual ralizara un borrado completo

Siempre es recomendable pensar de manera detenida cuando se va a realizar un borrado de

archivos o directorios, o tener en cuenta si se tienen respaldos ola vitalidad de los archivos a
los que se les va a aplicar dicha tarea.

Compresión y descompresión de archivos.

En Linux hay diversas herramientas para empaquetar y comprimir archivos, tomando en
cuenta que empaquetar es juntar dos o más archivos en un solo archivo (paquete) y
comprimir es tomar este archivo-paquete y comprimirlo a continuación te muestro un
resumen de las más comunes, de acuerdo a la extensión que comunmente se acostumbra
ponerles.

Ficheros tar
Para poder empaquetar ficheros, utilizamos el siguiente comando:
tar -cvf archivo.tar /dir/a/comprimir/
-c : indica a tar que cree un archivo.
-v : indica a tar que muestre lo que va empaquetando.
-f : indica a tar que el siguiente argumento es el nombre del fichero.tar.
Para poder desempaquetar los ficheros .tar, utilizamos el siguiente comando:
tar -xvf archivo.tar
-x : indica a tar que descomprima el fichero.tar.
-v : indica a tar que muestre lo que va desempaquetando.
-f : indica a tar que el siguiente argumento es el nombre del fichero a desempaquetar.
Si se quiere ver el contenido de un fichero .tar, se utiliza el siguiente comando:
tar -tf archivo.tar
-t : Lista el contenido del fichero .tar
-f : indica a tar que el siguiente argumento es el nombre del fichero a ver.
pág. 202

Ficheros gz
Para comprimir ficheros en formato .gz, se utiliza el siguiente comando:
gzip -9 fichero
-9 : le indica a gz que utilice el mayor factor de compresión posible.
Para descomprimir ficheros .gz, se utilizara el siguiente comando:
gzip -d fichero.gz
-d : indica descompresión
Ficheros bz2
Para comprimir ficheros en formato bz2, se utiliza el siguiente comando:
bzip fichero
Para descomprimir ficheros .bz2, se usa el comando siguiente:
bzip2 -d fichero.bz2
-d : indica descompresión.
Nota: Tanto el compresor gzip como bzip2, solo comprimen ficheros, no directorios, para
comprimir directorios (carpetas), se debe de usar en combinación con tar.

Ficheros tar.gz
Para comprimir ficheros en formato tar.gz, se utiliza el siguiente comando:
tar -czfv archivo.tar.gz ficheros
-c : indica a tar que cree un archivo.
-z : indica que use el compresor gzip
-f : indica a tar que el siguiente argumento es el nombre del fichero.tar
-v : indica a tar que muestre lo que va empaquetando
Para descomprimir ficheros con extensión tar.gz, se usa el siguiente comando:
tar -xzvf archivo.tar.gz
-x : le dice a tar que extraiga el contenido del fichero tar.gz
-z : le indica a tar que esta comprimido con gzip
-v : va mostrando el contenido del fichero
-f : le dice a tar que el siguiente argumento es el fichero a descomprimir.
Para poder ver el contenido de un fichero comprimido en tar.gz, se usa el siguiente comando:
tar -tzf archivo.tar.gz
pág. 203

Ficheros tar.bz2
Para comprimir en tar.bz2, se hace uso del parámetro pipeline ( | ), que consiste en que
“filtra” la salida de un comando a la entrada de otro, como es en este ejemplo: tar
empaqueta los distintos ficheros o directorios y su salida lo pasa al comando bzip2 para que
este lo comprima y el resultado de este, lo redirecciona ( > ) al fichero final tar.bz2
tar -c ficheros | bzip2 > archivo.tar.bz2

Para descomprimir ficheros tar.bz2, se utiliza el siguiente comando:
bzip2 -dc archivo.tar.bz2 | tar -xv
Y para ver el contenido de un fichero tar.bz2, se usa el siguiente comando:
bzip2 -dc archivo.tar.bz2 | tar –t
Ficheros zip
Para poder comprimir en formato zip, se usara el comando siguiente:
zip archivo.zip ficheros a comprimir
Para poder descomprimir los ficheros zip, se usa el siguiente comando:
unzip archivo.zip
Para ver el contenido de un fichero zip, se pone el siguiente comando:
unzip -v archivo.zip
Ficheros rar
Para comprimir en formato rar, se usara el siguiente comando:
rar -a archivo.rar ficheros
Para descomprimir ficheros en formato rar, se utiliza el siguiente comando:
unrar -x archivo.rar
Para ver el contenido de un fichero rar, se usa el siguiente comando:
unrar -v archivo.rar
unrar -l archivo.rar
Tengo que decir que todos estos comandos, es para hacerlo desde terminal una terminal, como
ejemplo os vendría de maravilla si os quedarais sin entorno gráfico y tuvieseis que descomprimir
algún archivo.
Pero para los que no quieran usar la terminal, pueden estar tranquilos, que existen muy buenas
interfaces gráficas. Como lo es File Roller.
pág. 204

Ejercicio;
Lo primero que haremos para llevar acabo esta práctica, será verificar o realizar la instalación de
los paquetes necesarios para llevar acabo la practica, como la instalación que se hizo fue
minima, lo primero que haremos será instalar dichos paquetes que en este caso son los
compresores:

Iniciamos la secion como root, para poder ejecutar el siguiente comando el cual realizara la
instalación
# yum install zip unzip gzip tar bzip2 xz
Una vez que estén instalados los paquete nos salimos para realizar las tareas con un
usuario ordinario, podemos utilizar cualquiera de los usuarios que ya hemos creado o podremos
crear uno nuevo con el siguiente comando;

# useradd compresor

Y le asignamos un password

# passwd compresor

Seguido nos logueamos con este;

Para poder llevar a cabo el ejercicio necesitamos realizar la compresión de alguna carpeta o
algún archivo, para esto realizaremos la copia de una carpeta del mismo sistema, para fines
ilustrativos utilizaremos la carpeta llamada pixmaps, que se encuentra en la ubicación
/usr/shae/pixmaps, para lo cual la copiaremos integra al home del usuario que estemos usando
con el siguiente comando;

$ cp –a /usr/share/pixmaps .
pág. 205

ZIP

Ahora procederemos a realizar la comprension y descompresion utilizando el format zip, que es
el analogo de winzip en windows.

Realizamos la compresión del archivo de la siguiente manera

$ zip -r comprimido.zip pixmaps/

El siguiente mostrara el contenido del archivo comprimido.zip:
$ unzip -l comprimido.zip

Para extraer el contenido del archivo comprimido.zip dentro del directorio ~/archivos/,
ejecutando lo siguiente:
$ unzip comprimido.zip -d ~/archivos/

Si la salida le pregunta si desea sobre-escribir los archivos existentes, responda que si a todo
pulsando la letra A y “enter”.
Para extraer una selección de archivos que están dentro el comprimido, realizaríamos la tarea
de la siguiente forma;
$ unzip comprimido.zip -d ~/archivos/ *.png

Si la salida pregunta nuevamente presione A para sobreescribir:
Para extraer los archivos con la misma extencion pero de segundo nivel tendríamos que hacerla
de la siguiente forma;
$ unzip comprimido.zip -d ~/archivos/ */*.png

Si necesita ayuda con el comando con respecto a sus opciones o el uso, puede hacer la consulta
de ambos, tanto de zip, como de unzip con los siguientes comandos;
$ man 1 zip
$ man 1 unzip

pág. 206

TAR
Compresion y desconpresion de archivos con formato tar.
Para comprimir un archivo o carpeta ejecutaríamos lo siguiente:
$ tar cf comprimido.tar pixmaps/
Para mostrar el contenido el archivo comprimido en formato tar, ejecutaríamos lo siguiente:
$ tar tvf comprimido.tar

Para extraer el contenido del comprimido, necesitaríamos ejecutar el siguiente comando;
$ tar xvf comprimido.tar -C ~/archivostar/
Para extraer una selección de archivos, del archivo comprimido hay que ejecutarlo de la manera
siguiente;
$ tar xvf comprimido.tar -C ~/archivostar/ --wildcards '*.png'
Para consultar la sintaxis o las opciones de tar, puede realizar la siguiente ejecución;
$ man 1 tar

TAR GZIP
Para realizar una compresión de tipo gzip ejecutaríamos el comando de la forma que sigue;

$ tar zcf comprimido.tar.gz pixmaps/
Para poder ver el contenido del archivo comprimido ejecutaremos el comando de la siguiente
forma:
$ tar ztvf comprimido.tar.gz
Para extraer el contenido del archivo, ejecutariamos lo siguiente:
$ tar zxvf comprimido.tar.gz -C ~/archivosgz/
Para realizar una extracción de los archivos de manera selectiva, ejecutaríamos lo siguiente:
$ tar zxvf foo.tar.gz -C ~/ejemplos1/ --wildcards '*.png'
BZ2
Para realizar una compresión en formato BZ2, ejecutaremos lo siguiente:
$ tar jcf comprimido.tar.bz2 pixmaps/

Para poder ver los archivos que están contenidos dentro del archivo, será necesario ejecutar lo
siguiente:
$ tar jtvf comprimido.tar.bz2
pág. 207

Para extraer el contenido del archivo comprimido es necesario ejecutar el comando de

extracción de la siguiente manera:
$ tar jxvf comprimido.tar.bz2 -C ~/archivosbz2/

Para poder realizar una extracción selectiva se ejecutaria de la siguiente manera:
$ tar jxvf comprimido.tar.bz2 -C ~/archivosbz2/ --wildcards '*.png'
XZ
Para realizar una compresión de tipo XZ necesitaríamos ejecutarlo de la siguiente forma:
$ tar Jcf comprimido.tar.xz pixmaps/
Para poder visualizar el contenido del archivo comprimido es necesario ejecutar el comando de
la siguiente forma:
$ tar Jtvf comprimido.tar.xz
Para extraer el contenido del archivo necesitaríamos realizar la ejecución del comando de la
siguiente forma:
$ tar Jxvf comprimido.tar.xz -C ~/archivosXZ/

Para extraer los archivos de manera selectiva, tendríamos que ejecutarlo de la siguiente
manera:
$ tar Jxvf comprimido.tar.xz -C ~/archivosXZ/ --wildcards '*.png'

Respaldos de archivos en Linux

Una de las tareas mas comunes de los administradores de sistemas es el respaldo de
archivos o información generada o acumulada dentro de nuestros servidores, partiendo del
tipo de utilidad que tenga el server podría ser vital, realizar el respaldo de información
contenido dentro de nuestra infraestructura, para tal motivo existen varios tipos de respaldos,
los cuales se describen a continuacion.
Completos:

Se consideran de nivel 0 y es condierado el comprende los respaldos integros de inicio a fin, es

decir del primer archivo al ultimo.
pág. 208

Diferenciales:
Se consideran de nivel 1. Consisten en respaldos que dependen de un respaldo completo

o de nivel 0 para poder restaurar todos los datos, sólo archivando los archivos nuevos o
que cambiaron respecto del último respaldo completo. Es decir, para restaurar los datos se
requiere el último respaldo completo y el respaldo diferencial. Hoy en día se utilizan muy poco,
salvo que el administrador del sistema sea poco experimentado o bien porque así es como
lo prefiere, pues consumen mucho más espacio en el sistema de archivos que los respaldos
incrementales.
Incrementales:
Se considera respaldo diferencial cuando hay un solo respaldo completo antes de éste, de nivel
2 cuando hay un respaldo completo y un respaldo incremental antes de éste, de nivel 3 cuando
hay un respaldo completo y dos incrementales antes de éste y así sucesivamente. Son
similares al respaldo diferencial, pero éstos pueden hacerse a partir de un respaldo completo
y/o un diferencial y/o otros incrementales, restaurando los datos en secuencia, por lo cual
permiten ahorrar el espacio disponible en el sistema de archivos. Es decir, para restaurar los
datos, se requiere el último respaldo completo y uno o más respaldos incrementales.
Un respaldo completo se puede realizar con “tar”, con las opciones cpf, el nombre del archivo
*.tar a crear, la opción “-g” (definir crear un archivo incremental en el nuevo formato de GNU)
y el nombre del archivo con extensión “*.snar”. Éste último es utilizado por el compresor
“tar” para almacenar la información respecto de qué fue lo que se respaldó. La opción “p” es
importante para crear y restaurar los respaldos, pues permite preservar los permisos y
atributos originales de los datos. Si se omite esta opción, todo el contenido almacenado y
restaurado sería propiedad del usuario root.
Recuerde que puede lograr sincornizaciones de archivos también incluyendo archivos ocultos
con el comando rsync, ejemplo:
# rsync –a /home/* /backup
Para realizar el ejercicio es necesario loguaerse como root:

# su -l

Para generar un respaldo lo primero es definir en donde se va a poner el respaldo, o definir la
partición en donde se va a guardar el respaldo; para lo cual crearemos una carpeta dentro
pág. 209

de /var al cual nombraremos respaldos, esta tarea la realizaremos de la siguiente manera;

# mkdir /var/respaldos

Con el siguiente comando crearemos el primer respaldo, que es considerado un repaldo
completo o de nivel 0 /usr/share/pixmaps, guardando los archivos de datos y un
incremental dentro de /var/respaldos.
# tar cpf /var/respaldos/completo.tar \

-g /var/respaldos/registro.snar /usr/share/pixmaps

Para generar el respaldo de manera incremental, se define el nombre el archivo utilizado el
mismo archivo con extencion .snar
# tar cpf /var/respaldos/incremental-1.tar \


De la misma manera crearemos el segundo respaldo incremental:
Ahora crearemos un tercer respaldo incremental:


Con el siguiente comando empezaremos a realizar la restauración de los respaldos:
# tar xpf /var/respaldos/completo.tar \

-g /var/respaldos/registro.snar -C /

Con el siguiente recuperaremos el incremental número 1;
# tar xpf /var/respaldos/incremental-1.tar \


Con el siguiente recuperaremos el incremental número 2;
pág. 210


Con el siguiente acompletariamos el respaldo terminando de hacer el respaldo y restaurandolo

Si se dispone de poco espacio estos pueden hacerse también de volúmenes distintos, y asi
distribuir el espacio que ocupan los respaldos o moviendo a otros volúmenes las fracciones del
respaldo si el espacio asi nos lo permite.
Para realizar un respaldo de esta forma tendríamos que usar la opción “-M” lo cual configura el
respaldo para ubicarlo en distintos volúmenes y la opción “-L” para indicar el tamaño que le
asignaremos al la fracción a generar, este se define en bytes.
El ejemplo generara el respaldo de la misma carpeta usada hasta este momento,
/usr/share/pixmaps en una unidad de almacenamiento externa que podría ser una usb o un
disco duro, en cuatro partes de 4 GiB cada una, asumiendo que /usr/share/pixmaps ocupa
menos de 16 GiB de espacio en el sistema de archivos y que la unidad de almacenamiento
externo está montada en el directorio /media/DISCO/:
# tar cpf /media/DISCO/respaldo01.tar -g /media/DISCO/registro.snar -M -L
4194304 /usr/share/pixmaps



Para llevar acabo la restauración de dicho respaldo se utilizara la opción “-M” para indicar que
se trata de un respaldo de varios volúmenes, y que debe restaurarse en una unidad como un
solo archivo;
# tar xpf /media/DISCO/respaldo01.tar -g /media/DISCO/registro.snar -M -C /


pág. 211


# tar xpf /media/DISCO/respaldo04.tar -g /media/DISCO/registro.snar -M -L -
C /

Una vez terminado el ejercicio tendremos la recuperación del archivo o archivos originales de
manera incremental.

Gestión de procesos y trabajos.

La más simple definición de un proceso podría ser que es una instancia de un programa en
ejecución (corriendo). A los procesos frecuentemente se les refiere como tareas. El contexto de
un programa que esta en ejecución es lo que se llama un proceso. Este contexto puede ser mas
procesos hijos que se hayan generado del principal (proceso padre), los recursos del sistema que
este consumiendo, sus atributos de seguridad (tales como su propietario y permisos de archivos
asi como roles y demás de SELinux), etc.
Linux, como se sabe, es un sistema operativo multitarea y multiusuario. Esto quiere decir que
múltiples procesos pueden operar simultáneamente sin interferirse unos con los otros. Cada
proceso tiene la "ilusión" que es el único proceso en el sistema y que tiene acceso exclusivo a
todos los servicios del sistema operativo.
Programas y procesos son entidades distintas. En un sistema operativo multitarea, múltiples
instancias de un programa pueden ejecutarse sumultáneamente. Cada instancia es un proceso
separado. Por ejemplo, si cinco usuarios desde equipos diferentes, ejecutan el mismo programa
al mismo tiempo, habría cinco instancias del mismo programa, es decir, cinco procesos distintos.
Cada proceso que se inicia es referenciado con un número de identificación único conocido
como Process ID PID, que es siempre un entero positivo. Prácticamente todo lo que se está
ejecutando en el sistema en cualquier momento es un proceso, incluyendo el shell, el ambiente
gráfico que puede tener múltiples procesos, etc. La excepción a lo anterior es el kernel en si, el
cual es un conjunto de rutinas que residen en memoria y a los cuales los procesos a través de
llamadas al sistema pueden tener acceso.

pág. 212

Ps
El comando ps es el que permite informar sobre el estado de los procesos. ps esta basado en el
sistema de archivos /proc, es decir, lee directamente la información de los archivos que se
encuentran en este directorio. Tiene una gran cantidad de opciones, incluso estas opciones
varían dependiendo del estilo en que se use el comando. Estas variaciones sobre el uso
de ps son las siguientes:
Estilo UNIX, donde las opciones van precedidas por un guión -
Estilo BSD, donde las opciones no llevan guión
Estilo GNU, donde se utilizan nombres de opciones largas y van precedidas por doble guión
--
Sea cual sea el estilo utilizado, dependiendo de las opciones indicadas, varias columnas se
mostrarán en el listado de procesos que resulte, estas columnas pueden ser entre muchas otras,
las siguientes (y principales):

Las opciones completas de ps las encuentras en las páginas del manual (man ps), o escribiendo
en la terminal ps L, y para ver un resumen de sus opciones más comunes usaps --help:

#> ps --help
********* simple selection ********* ********* selection by list *********
-A all processes -C by command name
-N negate selection -G by real group ID (supports names)
-a all w/ tty except session leaders -U by real user ID (supports names)
-d all except session leaders -g by session OR by effective group name
-e all processes -p by process ID
T all processes on this terminal -s processes in the sessions given
a all w/ tty, including other users -t by tty
g OBSOLETE -- DO NOT USE -u by effective user ID (supports names)
r only running processes U processes for specified users
x processes w/o controlling ttys t by tty
*********** output format ********** *********** long options ***********
-o,o user-defined -f full --Group --User --pid --cols --ppid
-j,j job control s signal --group --user --sid --rows --info
-O,O preloaded -o v virtual memory --cumulative --format --deselect
pág. 213

-l,l long u user-oriented --sort --tty --forest --version

-F extra full X registers --heading --no-heading --context
********* misc options *********
-V,V show version L list format codes f ASCII art forest
-m,m,-L,-T,H threads S children in sum -y change -l format
-M,Z security data c true command name -c scheduling class
-w,w wide output n numeric WCHAN,UID -H process hierarchy
A continuación algunos cuantos ejemplos de ps con la salida recortada.

El comando siguiente, muestra todos los procesos

# ps –e
El comando siguiente muestra opciones completas

#ps –ef

El siguiente muestra opciones completas extras

# ps –eF

El siguiente comando ,muestra en formato BSD sin guion, usuarios y otras características;

# ps aux

El siguiente muestra un output personalizado, se indican los campos separados por coma
# ps –eo user,pid,tty

El siguiente comando muestra el árbol de procesos;

#ps –eH

El siguiente muestra lo mismo con otro formato

# ps axf

El siguiente se ejecuta cin la ruta, colo con el nombre real
pág. 214

# ps –ec

El siguiente no muestra procesos, lista todos los códigos de formatos

# ps L
Pstree
Muestra los procesos en forma de árbol, pstree --help te da las opciones más comunes.
Recomiendo uses lo uses con la opción -A y -G para que te un árbol con líneas con líneas estilo
ASCII y de terminal VT100 respectivamente, puedes añadir también -u para mostrar entre
paréntesis al usuario propietario del proceso:

# pstree

Kill
El comando kill, que literalmente quiere decir matar, sirve no solo para matar o terminar
procesos sino principalmente para enviar señales (signals) a los procesos. La señal por default
(cuando no se indica ninguna es terminar o matar el proceso), y la sintaxis es kill PID, siendo PID
el número de ID del proceso. Asi por ejemplo, es posible enviar una señal de STOP al proceso y
se detendrá su ejecución, después cuando se quiera mandar una señal de CONTinuar y el
proceso continuara desde donde se quedo.

El siguiente comando muestra todas las posibles señales que puedan enviarse a un proceso;

# kill –l

Es decir todos los procesos que están en un nivel Start.

La lista previa presenta una lista de todas las posibles señales que pueden mandarse a un
proceso y estas pueden ser invocadas a través del número de la señal o de su código, por
ejemplo:

#> kill -9 11428 (termina, mata un proceso completamente)
#> kill -SIGKILL 11428 (Lo mismo que lo anterior)

pág. 215

Las señales más comunes son la 19 y 20 que detienen momentáneamente la ejecución de un

proceso o programa, 18 la continua, 1 que es la señal de hang up que obliga al proceso a releer
sus archivos de configuración estando en ejecución y 9 que termina rotundamente un proceso.

Killall
El comando killall, que funciona de manera similar a kill, pero con la diferencia de en vez de
indicar un PID se indica el nombre del programa, lo que afectará a todos los procesos que
tengan ese nombre. Asi por ejemplo si se tienen varias instancias ejecutándose del proxy server
squid, con killall squid eliminará todos los procesos que se esten ejecutando con el nombre
'squid'

#> killall -l (lista de posibles señales)

#> killall -HUP httpd (manda una señal de "colgar", detenerse releer sus archivos de
configuración y reiniciar)

#> killall -KILL -i squid (manda señal de matar a todos los procesos squid pero pide confirmación
en cada uno)
Nice

Permite cambiar la prioridad de un proceso. Por defecto, todos los procesos tienen una
prioridad igual ante el CPU que es de 0. Con nice es posible iniciar un programa (proceso) con la
prioridad modificada, más alta o más baja según se requiera. Las prioridades van de -20 (la más
alta) a 19 la más baja. Solo root o el superusuario puede establecer prioridades negativas que
son más altas. Con la opción -l de ps es posible observar la columna NI que muestra este valor.

#> nice (sin argumentos, devuelve la prioridad por defecto)
renice
Asi como nice establece la prioridad de un proceso cuando se incia su ejecución, renicepermite
alterarla en tiempo real, sin necesidad de detener el proceso.

#> nice -n -5 yes (se ejecuta el programa 'yes' con prioridad -5)
(dejar ejecutando 'yes' y en otra terminal se analiza con 'ps')
#> ps -el
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
pág. 216

4 S 0 12826 12208 4 75 -5 - 708 write_ pts/2 00:00:00 yes

#> renice 7 12826

12826: prioridad antigua -5, nueva prioridad 7
#> ps -el
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 12826 12208 4 87 7 - 708 write_ pts/2 00:00:15 yes

(obsérvese el campo NI en el primer caso en -5, y en el segundo con renice quedó en 7, en

tiempo real)

nohup y &

Cuando se trata ejecutar procesos en background (segundo plano) se utiliza el comandonohup o

el operador & . Aunque realizan una función similar, no son lo mismo.
Si se desea liberar la terminal de un programa que se espera durará un tiempo considerable
ejecutándose, entonces se usa. Esto funciona mejor cuando el resultado del proceso no es
necesario mandarlo a la salida estándar (stdin), como por ejemplo cuando se ejecuta un
respaldo o se abre un programa Xwindow desde la consola o terminal. Para lograr esto basta
con escribir el comando en cuestión y agregar al final el símbolo & (ampersand).
$> yes > /dev/null &

$> tar czf respaldo /documentos/* > /dev/null/ &
$> konqueror & (con estos ejemplos se ejecuta el comando y se libera la terminal regresando el
prompt)
Sin embargo lo anterior produce que el padre del proceso PPID que se invocó sea el proceso de
la terminal en si, por lo que si cerramos la terminal o salimos de la sesión también se terminaran
los procesos hijos que dependan de la terminal, no muy conveniente si se desea que el proceso
continué en ejecución.
Para solucionar lo anterior, entonces se usa el comando nohup que permite al igual que '&'
mandar el proceso y background y que este quede inmune a los hangups (de ahí su nombre
nohup) que es cuando se cuelga o termina la terminal o consola de la cual se ejecutó el proceso.

$> nohup yes > /dev/null &

$> nohup czf respaldo /documentos/* > /dev/null/
$> nohup konqueror

Asi se evita que el proceso se "cuelgue" al cerrar la consola.
pág. 217

Jobs

Si por ejemplo, se tiene acceso a una única consola o terminal, y se tienen que ejecutar varios
comandos que se ejecutarán por largo tiempo, se pueden entonces como ya se vió previamente
con nohup y el operador '&' mandarlos a segundo plano o background con el objeto de liberar la
terminal y continuar trabajando.
Pero si solo se está en una terminal esto puede ser difícil de controlar, y para eos tenemos el
comando jobs que lista los procesos actuales en ejecución:

#> yes > /dev/null &

[1] 26837
#> ls -laR > archivos.txt &
[2] 26854
#> jobs
[1]- Running yes >/dev/null &
[2]+ Running ls --color=tty -laR / >archivos.txt &

En el ejemplo previo, se ejecutó el comando yes y se envió a background (&) y el sistema
devolvió [1] 26837, indicando asi que se trata del trabajo o de la tarea [1] y su PID, lo mismo con
la segunda tarea que es un listado recursivo desde la raíz y enviado a un archivo, esta es la
segunda tarea.
Con los comandos fg (foreground) y bg background es posible manipular procesos que esten
suspendidos temporalmente, ya sea porque se les envió una señal de suspensión como STOP
(20) o porque al estarlos ejecutando se presionó ctrl-Z. Entonces para reanudar su ejecución en
primer plano usaríamos fg:

#> jobs
[1]- Stopped yes >/dev/null &
[2]+ Stopped ls --color=tty -laR / >archivos.txt &
#> fg %1
#> jobs
[1]+ Running yes >/dev/null &
[2]- Stopped ls --color=tty -laR / >archivos.txt &

Obsérvese como al traer en primer plano al 'job' o proceso 1, este adquirió el símbolo [+] que
indica que esta al frente. Lo mismo sería con bg que volvería a reinicar el proceso pero en
pág. 218

segundo plano. Y también es posible matar los procesos con kill indicando el número que
devuelve jobs: kill %1, terminaría con el proceso en jobs número 1.
Top
Una utilería muy usada y muy útil para el monitoreo en tiempo real del estado de los procesos y
de otras variantes del sistema es el programa llamado top, se ejecuta desde la línea de
comandos, es interactivo y por defecto se actualiza cada 3 segundos.

$> top
top - 13:07:30 up 8 days, 6:44, 4 users, load average: 0.11, 0.08, 0.08
Tasks: 133 total, 1 running, 131 sleeping, 0 stopped, 1 zombie
Cpu(s): 0.0%us, 0.2%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.2%si, 0.0%st
Mem: 497356k total, 472352k used, 25004k free, 21500k buffers
Swap: 1156640k total, 257088k used, 899552k free, 60420k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
26156 sergon 15 0 2160 1016 784 R 1 0.2 0:00.93 top
1 root 15 0 2012 616 584 S 0 0.1 0:00.98 init
2 root RT 0 0 0 0 S 0 0.0 0:00.29 migration/0
3 root 34 19 0 0 0 S 0 0.0 0:00.00 ksoftirqd/0
4 root RT 0 0 0 0 S 0 0.0 0:00.00 watchdog/0
5 root RT 0 0 0 0 S 0 0.0 0:00.38 migration/1
...
Estando adentro de la apliación, presionando 'h' muestra una ayuda de los posibles comandos
que permiten configurar top, por ejemplo, al presionar 's' pregunta por el tiempo en segundos
de actualización, etc.

Estas son algunas de las herramientas, las más importantes y usadas, para adminsitrar procesos,
hay varios programas en ambientes gráficos que en una sola pantalla permiten todo lo anterior
y más, y en línea de comandos te recomiendo htop, que es como un toppero en esteroides.

pág. 219

Ejercicio;
Para desarrollar el ejercicio, primero hay que realizar un par de instalaciones de algunos
paquetes que van a ser necesarios para lo cual nos loguearemos como root y realizarlas con el
siguiente comando:
# yum -y install procps top util-linux-ng
Una vez realizadala instalación, nos salimos de la secion o nos logueamos en otra terminal, con
cualquiera de los usuarios antes creados para poder llevar acabo el ejercicio.
Ejecutamos un proceso sleep con un tiempo estimado de 700 segundos, esto lo lograremos con
el siguiente comando;
$ sleep 700
Pulsaremos las teclas CTRL+Z, lo cual pondrá el proceso en segundo plano:

Ejecutamos el comando “jobs” o trabajos, para visualizar el trabajo detenido:
$ jobs
Ejecutando el comando bg reactivaremos el trabajo 1 que esta en backgroud o en segundo

plano:
$ bg 1

Ejecute nuevamente sleep con el valor 900 y un signo “&” al final, para generar otro proceso
mas:
$ sleep 900 &
Con esto lo que haremos será enviar el trabajo a segundo plano.

Ejecutamos nuevamente el comando de Jobs para poder ver los trabajos que hemos ejecutado:
$ jobs
[1]- Ejecutando sleep 600 &

[2]+ Ejecutando sleep 700 &
Ejecutando el comando “fg” con 1 como argumento podremos enviar al primer plano el primer
trabajo:
$ fg 1
Realizando esto, hará que el proceso o trabajo sleep 700 regrese a primer plano.
Para terminar este último trabajo, pulse CTRL+C.
pág. 220

Acontinuacion ejecutaremos el comando ps aux, que en la parte de ps, dice que mostrara todas
las terminales, incluyendo los procesos, pero a diferencia del otro agregaremos una pipa, y un
atributo llamado less el cual nos mostrara toda la información de manera pausada según se
requiera;
$ ps aux |less
Si realizamos la conbinacion de la pipa junto con grep, nos realizara una búsqueda selectiva de
los procesos que incluyan el nombre de “sleep”;
$ ps aux |grep sleep
En este caso deberemos de ver aun uno de los procesos sleep que declaramos anteriormente.
Ahora de lo que estamos viendo el proceso sleep debe de mostrar un numero de proceso, si
ejecutamos el comando kill seguido del proceso se terminara con esta tarea;
$ kill No.de proceso
Si ejecutamos de nuevo el comando sleep, pero ahora con un tiempo de 300, como argumento,
con un signo “&” al final, se generar otro trabajo en segundo plano;
$ sleep 300 &
Como sabemos que el trabajo es el único y esta en proceso 1, podríamos terminarlo con el
siguiente comando:
$ kill %1
Generaremos otro proceso pero ahora con un tiempo de 500 segundo pasándolo a segundo
plano también;
$ sleep 500 &
Si ejecutamos el ps con la pipa y el argumento sleep podremos ver el proceso que acabamos de
generar.
$ ps aux |grep sleep
Observaremos cual el numero de PID o numero de indentidad, y lo terminaremos con el

comando kill, pero en esta ocacion agregaremos el argumento -9
$ kill -9 No.de Proceso
Para poder ver mejor el funcionamiendo de “jobs” agregaremos dos tareas al mismo tiempo de
la siguiente forma:
pág. 221

$ sleep 500 & sleep 900 &
Correremos de nuevo el comando para poder visualizar los trabajos que están corriendo:
$ jobs
Si ejecutamos nuevamente “ps”, pero con la opción “-j”, podremos visualizar los números de
proceso o de ID de estos:
$ ps -j
Ejecutaremos el comando “killall” con la cadena “sleep” como argumento, a fin de terminar de
manera normal de todos los procesos denominados sleep.
$ killall sleep
Repetimos el proceso de dar de alta dos tareas al mismo tiempo, las visualizamos con ps, pero
ahora los terminaremos con un comando killall, agregando la opción –s y el valos 9, con la
misma cadena como argumento y veremos que termina todos los procesos
$ killall -s 9 sleep
Comandos nice y renice.
Realizaremos la compresión de los archivos que están en la carpeta /lib/modules, en español los
modulos de las libreras en un archivo tar llamado comprimidonice
# tar jcf comprimidonice.tar.bz2 /lib/modules
Al terminar utilice time para cuantificar la ejecución del compresor con las opciones “jxf”, para
descomprimir el archivo comprimidonice.tar.bz2. Esto con la finalidad de cuantificar la
descompresión con la prioridad de planificación 0 (valor predeterminado del sistema), la cual
permite utilizar los recursos que regularmente permite utilizar el sistema al usuario.
# time tar jxf comprimidonice.tar.bz2
La salida nos debe mostrar unas medidas de tiempo.

Para darle prioridad a esta tarea utilizaremos el comando “nice”, esto le dara una planificación a
10(valor predeterminado de nice), esto con el objetivo de utilizar menos recursos de sistema,
para ello ejecutaremos el comando del la siguiente manera:
# time nice -n +10 tar jxf comprimidonice.tar.bz2
pág. 222

Los resultados deberán ser ligeramente mayores, en cuanto a tiempo de ejecución pues la
prioridad fue aumentada.
El usuario ordinario solo puede definir valores de prioridad de planificación del 0 al 19,
prioridad de planificación predeterminada a prioridad de planificación menos favorable. Los
valores negativos, del -1 al -20, que son los más favorables, sólo los pude utilizar “root”.
Para verificar lo descrito anteriormente podríamos ejecutar “su” con la opción “-c”, con la cual
se indicará entre comillas cualquier cosa para ser ejecutada como “root”, de la siguiente forma.
$ su -c "time nice -n -20 tar jxf cmprimidonice.tar.bz2"
Los resultados deberán ser sensiblemente inferiores que la ejecución con el valor
predeterminado de prioridad de planificación (0).
La ejecución del comando anterior, creara un directorio denominado lib dentro del directorio de
inicio del usuario, pero éste le pertenece de root, por lo cual el usuario regular será incapaz de
borrarlo. Borrelo para evitar tener que realizar nuevamente el procedimiento, para esto es
recoemndable tener 2 terminales abiertas y poder realizar las tareas de manera mas fluida.
$ su -c "rm -fr /home/fulano/lib"

Ulitizaremos “renice” para cambiar la prioridad de planificación de procesos en ejecución. Para

poder demostrar de forma mas clara este comando, iniciaremos utilizando “ps” con las opciones
“alx” las cuales nos mostrarn todos los procesos de todas las terminales:
$ ps alx |less
Con el siguiente comando cambiaremos la prioridad de planificación a un valor de -10, al

proceso que en el ejemplo corresponde al PID que elija:
$ su -c "renice -n -10 -p PID"
Con el siguiente cambiaremos la prioridad de planificación a -10 a todos los procesos del usuario
con el que estemos trabajando:
$ su -c "renice -n -10 -u user"
El siguiente ejemplo cambia la prioridad de planificación a -10 a todos los procesos del grupo
desarrollo:
$ su -c "renice -n -10 -g desarrollo"
pág. 223

Top.
Top es una herramienta que proporciona una visualización continua y en tiempo real de los
procesos activos en un sistema, como una lista que de modo predeterminado lo hace de
acuerdo al uso del CPU. Puede ordenar la lista por uso de memoria y tiempo de ejecución.
Para ordenar la lista de procesos por orden de uso de memoria, pulse SHIFT+M. Para ordena la
lista de procesos por orden de tiempo de ejecución, pulse SHIFT+T. Para invertir el orden de la
lista, pulse SHIFT+R. Para activar o bien desactivar, la visualización por hilos, pulse SHIFT+H. Para
ordenar de nuevo la lista de procesos por orden de uso de CPU, pulse SHIFT+P.
Para mostrar los procesos de un usuario en específico, pulse la tecla u y defina a continuación el
nombre del usuario.

Para terminar o aniquilar cualquier proceso, pulse la tecla k y defina a continuación el número
de identidad de proceso que corresponda y luego la señal a utilizar (9 o 15).
Para cambiar la prioridad de planificación de cualquier proceso, pulse la tecla r y a continuación
defina el número de identidad de proceso que corresponda y luego el valor de prioridad de
planificación deseado.

Pulse la tecla h para ver el la ayuda completa de top.

La ejecución es;
$ top

lsof.
Lsof significa «listar archivos abiertos» (list open files). Es utilizado ampliamente en sistemas
operativos tipo POSIX para hacer reportes de archivos y los procesos que están utilizando a
éstos. Se puede utilizar para revisar que procesos están haciendo uso de directorios, archivos
ordinarios, tuberías (pipes), zócalos de red (sockets) y dispositivos. Uno de los principales usos
de determinar que procesos están haciendo uso de archivos en una partición cuando esta no se
puede desmontar. Lsof fue desarrollado por Vic Abell, quien alguna vez fue director del Centro
de Cómputo de la Universidad de Purdue.

Lo primero que tenemos que hacer s instalar el paquete, para instalar lsof, ejecute lo siguiente:

yum -y install lsof
pág. 224

Ejercicio;

Utilizando lsof podremos ver todos los procesos que utilizan el sistema de archivos en general,
ejecute lsof:

# lsof

Si lo ejecutamos de la siguiente manera podremos visualizar más cómodamente esta salida:

# lsof | more

Usted podría especificar que se muestren todos los procesos desde un directorio en particular,
de la siguiente manera podríamos solicitar, que se muestren los procesos que están
conpartiendo o haciendo uso de /var.

# lsof /var

Si se necesita mostrar solamente el archivo utilizado por un proceso en particular, podría usar
con la opción -p seguida del número del proceso en el cual tuviéramos interes:

# lsof -p PID

Con la opción -i podrá mostrar todos los archivos de red utilizados por procesos de red. Si
deseara mostrar los archivos de red en uso por algún proceso de red en particular, se utilizan las
opciones -i seguido de la opcion grep y el nombre de algún servicio. En el siguiente ejemplo se
pide a lsof mostrar solamente los archivos de red utilizados por los procesos de red derivados de
named:

# lsof -i | grep named

Si tiene dudas y desea consultar el manual de lsof puede consultarse ejecutando lo siguiente:

# man 8 lsof
pág. 225

Introducción a sed.

Sed: es un editor de flujos basado en ed. Puede editar archivos sin intervención del
usuario. Los comandos de edición pueden ser pasados como argumentos de linea de
comandos. Los argumentos de linea de comandos son aquellos que se proporcionan
junto con un comando, antes de que el comando sea ejecutado. Estos argumentos van
como entradas sobre las cuales el programa puede trabajar para producir cierta salida.
Sed se utiliza extensivamente en los sistemas Linux.

Proporciona mecanismos poderosos para editar flujos de datos pasados a el como entrada

Ejercicio;
Utilizando el editor vi crearemos el archivo pruebased.txt:
# vi pruebased.txt
Ingrese lo siguiente:
Hector Rodriguez
Calle Aldama 1234
Colonia Centro Aldama
Ciudad de Mexico, C.P. 123456
Guardamos el archivo y salimos de vi.
Ejecutando el coamando cat podremos visualizar el contenido del archivo:

# cat pruebased.txt
Ejecutando lo siguiente podremos convertir a doble espacio la salida del archivo:

# sed G pruebased.txt
Ejecutando lo siguiente para guardar esta salida en el archivo pruebased2.txt:

# sed G pruebased.txt > pruebased2.txt
Ejecutando lo siguiente podremos convertir a doble espacio la salida del archivo:

# sed 'G;G' pruebased.txt
Ejecute lo siguiente para guardar esta salida en el archivo usuario2.txt:
pág. 226

# sed 'G;G' pruebased.txt > pruebased3.txt
Lo anterior mostrará que el contenido de pruebased3.txt con un triple espacio entre líneas.
Ejecutando lo siguiente podremos convertir un archivo a doble espacio, pero sin que exista más
de una línea vacía entre cada línea con datos:
# sed '/^$/d;G' pruebased3.txt
Ejecutando el comando de la siguiente forma podremos eliminar el doble espacio del archivo
pruebased2.txt:
# sed 'n;d' pruebased2.txt
Ejecutando el comando de la siguiente forma agregaremos una línea en blanco arriba de toda
línea que contenga la expresión regular ama:
# sed '/dama/{x;p;x;}' pruebased.txt
Ejecutando lo siguiente podremos agregar una línea en blanco debajo de toda línea que
contenga la expresión regular 3:
# sed '/3/G' pruebased.txt
Ejecutando el comando de la siguiente forma podremos agregar una línea en blanco arriba y
debajo de toda línea que contenga la expresión regular 1:
# sed '/1/{x;p;x;G;}' pruebased.txt
Para realizar un reenplazo de texto se utiliza el modelo 's/textoantiguo/nuevo-texto/' donde

textonuevo puede ser también una expresión regular. En el siguiente ejemplo se reemplazarán
las incidencias del número por el número 9:
# sed 's/1/6/g' pruebased.txt
De la siguiente forma se reemplazaran los espacios por tabuladores a todo lo largo de todos los
renglones:
# sed 's/\ /\t/g' pruebased.txt
En la siguiente ejecucion se reemplazará sólo el primer espacio de cada línea por un tabulador:
# sed 's/\ /\t/' pruebased.txt
Ejecutandolo de la siguienteforma podremos añadir 5 espacios al inicio de cada renglon:

# sed 's/^/ /' pruebased.txt
pág. 227

Ejecutando el comando de la siguiente mostrara en pantalla sólo la primera línea del archivo:
# sed q pruebased.txt
Ejecutando lo siguiente mostrara en pantalla sólo las primeras tres líneas del archivo:
# sed 3q pruebased.txt
Ejecutando el comando de la siguiente forma, mostrara en pantalla sólo las últimas tres líneas
del archivo:
# sed -e :a -e '$q;N;4,$D;ba' pruebased.txt
Ejecutando lo siguiente mostrara sólo las líneas que incluyen 2;

# sed '/2/!d' pruebased.txt
Ejecutando lo siguiente mostrara sólo las líneas que no contengan el numero 3;

# sed '/3/d' pruebased.txt
Ejecutando el comando de la siguiente forma mostrara la línea que está inmediatamente

después de la expresión Hector pero excluyendo la línea que incluye Hector:
# sed -n '/Hector/{n;p;}' pruebased.txt
Ejecutando el comando de la siguiente forma, mostrara la línea que está inmediatamente antes
de la expresión Calle, pero excluyendo la línea que incluye esta misma;
# sed -n '/Calle/{g;1!p;};h' pruebased.txt
Esto nos mostrara otra expression, de esta forma se concluye el ejercicio de sed.
Introducción a GnuPG.
GnuPG es una compleja herramienta que no está exenta de polémica técnica, social y legal. En el
plano técnico, ha sido diseñada para su uso en situaciones con diversos requerimientos de
seguridad. Esto complica la gestión de claves. En el plano social, el uso de GnuPG no es
estricatamente una decisión de tipo personal. Para que su uso tenga efectividad, GnuPG
requiere que todas las partes en una comunicación sean usuarios del programa. En el plano
legal, desde 1.999, las leyes que contemplan el uso de productos informáticos criptológicos, y en
particular si el uso de GnuPG es legal, son diferentes según los países y están siendo
actualmente debatidas por muchos gobiernos.
pág. 228

Este capítulo tratará sobre estos temas. Se intentará dar consejos prácticos sobre el uso de
GnuPG de cara a los requerimientos de seguridad del usuario. También se sugerirán vías para
promocionar el uso de GnuPG con vistas a la comunicación segura entre el usuario y las
personas con las que éste se comunique, aun cuando éstos no sean usuarios de GnuPG.
Finalmente, se resaltará el estado legal de GnuPG conforme con el estado actual de las leyes
sobre criptología y cifrado en el mundo.
Definiendo los requerimientos en seguridad

GnuPG es una herramienta que utiliza el usuario para proteger su privacidad. La protección
existe sólo si el usuario puede comunicarse con otros sin «escuchas» que puedan leer los
mensajes.
El modo en que se deba usar GnuPG dependerá de la determinación y de los recursos de
aquéllos que intenten, o puedan intentar, leer los mensajes cifrados del usuario. Un «escucha»
podría ser un administrador de sistemas sin escrúpulos, que se encuentre, «por casualidad»,
escaneando el correo del usuario, o podría ser un espía industrial que intentara acceder a los
secretos de una compañía, o incluso podría ser un organismo legal que quisiera llevarnos a
juicio. El uso de GnuPG para protegernos contra «intromisiones casuales», será diferente de su
uso para protegernos contra un adversario determinado. Nuestro fin último debe ser el de que
el conseguir los datos no cifrados resulte más caro que el valor de los datos en sí.
La personalización del uso de GnuPG se basa en los siguientes aspectos:

la elección del tamaño del par de claves público y privado.
la protección de la clave privada,
la selección de la fecha de caducidad y el uso de subclaves, y la gestión del anillo de
confianza.
Selección del tamaño de la clave
La selección del tamaño de la clave depende de la clave en sí. En OpenPGP, un par de claves
pública y privada contienen generaralmente claves múltiples. Como mínimo tiene una clave de
firmado maestra, y probablemente una o más subclaves de cifrado adicionales. Si usamos para
la generación de claves los parámetros por defecto en GnuPG, la clave maestra será una clave
DSA, y las subclaves serán claves ElGamal.
DSA nos permite un tamaño de clave de hasta 1024 bits. Dada la tecnología de factorización de
hoy en día, esto no es demasiado bueno, pero es lo que especifica el estándar. Sin duda alguna,
debemos usar claves DSA de 1024 bits.
pág. 229

Por otra parte, las claves ElGamal pueden ser de cualquier tamaño. Ya que GnuPG es un sistema
de clave pública híbrido, la clave pública se usa para cifrar una clave de sesión de 128 bits, y la
clave privada se usa para descifrarla. Sin embargo el tamaño de la clave afecta a la velocidad del
cifrado y descifrado, ya que el valor de estos algoritmos lleva como exponente el tamaño de la
clave. Una clave de mayor tamaño también tarda más en ser generada, y ocupa más espacio.
Además, cuanto mayor tamaño tenga una clave, la seguridad extra que nos ofrece, aumenta
pero con una marcha decreciente. También hay que tener en cuenta que un «escucha» que se
encuentre con una clave lo suficientemente grande como para resistir un ataque de fuerza
bruta, se limitará a cambiar de método para poder obtener los datos no cifrados. Por lo tanto,
1024 bits es el tamaño de clave recomendado. Si nuestros requerimientos de seguridad fueran
tan grandes como para necesitar claves de gran tamaño, entonces deberíamos consultar a un
experto en seguridad de datos.
Protección de la clave privada

La protección de la clave privada es la parte más importante en el uso de GnuPG. Si alguien
obtuviera nuestra clave privada, todos los datos que hubieran sido cifrados para esa clave
podrían ser descifrados y se podría firmar documentos bajo nuestro nombre. Si perdiéramos la
clave privada, ya no podríamos descifrar los documentos cifrados que nos hubieran enviado o
que nos enviaran en un futuro, y no podríamos firmar los documentos. La pérdida de posesión
de nuestra clave privada podría ser una catástofre.
Sea cual fuere el uso que hagamos de GnuPG, deberíamos guardar siempre un certificado de
revocación de nuestras claves públicas, y una copia de seguridad de nuestra clave privada en un
disco protegido contra la escritura, y en un lugar seguro. Por ejemplo, podríamos grabarlo en un
CD-ROM y guardar éste en un cofre de depósito de un banco, dentro de un sobre sellado.
Alternativamente, podríamos guardarlo en un disquete y esconderlo en nuestra casa. Hagamos
lo que hagamos, los certificados de revocación de las claves públicas y las copias de seguridad de
la clave privada deberíamos tenerlos guardados en un medio lo suficientemente seguro, mucho
más que la clave privada que utilizamos a diario.
Como medida de seguridad, GnuPG no guarda nuestra clave privada «en bruto» en el disco
duro, sino que la cifra mediante un algoritmo de cifrado simétrico. Por esta razón, para acceder
a nuestra clave, necesitamos una contraseña. Por lo tanto, existen dos barreras que un atacante
debe cruzar para poder acceder a nuestra clave privada: (1) debe conseguir la clave; (2) debe ser
capaz de descifrarla.
pág. 230

Esconder nuestra clave privada en un sitio seguro es importante, pero todo tiene un precio. Lo
ideal sería que guardáramos la clave en un disco que fuera portátil y que tuviera protección
contra la escritura, como un disquete, y que sólo lo usáramos en una máquina con un solo
usuario que no estuviera conectada a una red. Esto puede que no sea convenient o posible para
nosotros. Por ejemplo, es posible que no tengamos nuestra propia máquina, y que debamos
usar la de la universidad o la de la oficina, o puede significar que para ello tengamos que
desconectar el modem cada vez que queramos usar GnuPG.
Esto no quiere decir que no podamos o no debamos usar GnuPG. Tan sólo significa que
debemos decidir si los datos que estamos protegiendo son lo suficientemente importantes para
cifrarlos, pero no tan importantes como para tomar medidas extra de seguridad. La elección es
nuestra.
Una buena contraseña es absolutamente crítica para el uso de GnuPG.

Cualquier atacante que logre acceder a nuestra clave privada, deberá sobrepasar el cifrado de
nuestra clave privada. En lugar de usar un ataque de fuerza bruta, es casi seguro que un
atacante intentará adivinar la contraseña.
El motivo por el que intentaría adivinarla, es que la mayoría de personas escogen contraseñas
que son más fáciles de adivinar que de sobrepasar una clave aleatoria de 128 bits. Si la
contraseña es una palabra ("password"), es mucho más fácil probar con todas las palabras
existentes en los diccionarios de todas las lenguas del mundo. Aun cuando la palabra sea
permutada, v.g. k3wldood, será más fácil probar palabras de diccionario con un catálogo de
permutaciones. Lo mismo ocurre con las citas. Aunque sea una contraseña formada por frases
("passphrase"), si ésta tiene como base un lenguaje natural, será una contraseña débil, ya que
existirá poca aleatoriedad y muchas redundancias. Si es posible, debemos evitar contraseñas
basadas en lenguajes naturales.
Una buena contraseña es aquélla que podemos recordar, pero que es difícli que otro pueda
adivinar. Debería incluir todos los carácteres imprimibles de nuestro teclado posibles. Esto
incluye carácteres alfabéticos en mayúsculas y minúsculas, números, y carácteres especiales
como } o ¦. Debemos ser creativos y perder un poco de tiempo inventando una contraseña; una
buena elección es importante para asegurar nuestra privacidad.
pág. 231

Selección de las fechas de caducidad y uso de subclaves

Por defecto, una clave de firmado maestra DSA y una subclave de cifrado ElGamal son
generadas al crear un nuevo par de claves. Esto es conveniente porque cada clave juega un
papel diferente, y por lo tanto es posible que necesitemos que las claves tengan fechas de
caducidad diferentes. La clave de firmado maestra se usa para las firmas digitales, y también
recolectan las firmas de otras personas que hayan confirmado nuestra identidad. La clave de
cifrado se usa sólo para descifrar los documentos cifrados que nos hayan enviado. Por lo
general, una firma digital tiene una larga vida, v.g., para siempre, y tampoco queremos perder
las firmas que tanto nos ha costado recolectar en nuestra clave. Por otra parte, la subclave de
cifrado puede cambiar periódicamente por cuestiones de seguridad, ya que si una clave de
cifrado es descifrada, el atacante puede leer todos los documentos que sean cifrados para esa
clave.
Suele ocurrir que no queramos que nuestra clave maestra caduque. Existen dos razones por las
que debamos escoger una fecha de caducidad. La primera es que tengamos la intención de que
la clave tenga una vida limitada. Por ejemplo, si la usamos para una campaña política y no nos
será útil una vez pasada la campaña. La segunda es que si perdemos el control de la clave, y no
tenemos un certificado de revocación con el que revocarla, una fecha de caducidad sobre la
clave maestra asegura que la clave caerá finalmente en desuso.
Cambiar las subclaves de cifrado puede ser sencillo, pero puede que no sea del todo
conveniente. Si generamos un nuevo par de claves con una fecha de caducidad en la subclave,
ésta caducará en su momento. Poco antes de la caducidad añadiremos una nueva subclave y
publicaremos nuestra clave pública actualizada. Una vez que la subclave haya caducado,
aquellos que deseen comunicarse con nosotros deberán encontrar antes la clave actualizada,
pues ya no podrán enviar datos cifrados para esa clave. El inconveniente depende de cómo
distribuyamos la clave. Por fortuna, no es necesario firmas extras ya que la nueva clave habrá
sido firmada con con nuestra clave de firmado maestra, la cual ya había sido validada por
nuestros corresponsales.
Todo depende de que queramos o no tener una seguridad extra. Al igual que nosotros, un
atacante todavía podrá leer todos los documentos que hayan sido cifrados para una clave
caducada. Cambiar las subclaves sólo protege los futuros documentos. Para poder leer
documentos cifrados para la nueva subclave, el atacante necesitaría organizar un nuevo ataque,
usando cualquier técnica que hubiera usado la primera vez.
Al final sólo tiene sentido tener una sola subclave de cifrado en un anillo de claves. No hay se
gana seguridad adicional teniendo dos o más subclaves activas. Por supuesto, puede existir
pág. 232

cualquier número de claves caducadas en un anillo de claves, para que los datos que hubieran
sido cifrados en el pasado puedan todavía ser descifrados, pero sólo es necesario activar una
sola subclave en un momento dado.
Gestión del anillo de confianza

Al igual que con la protección de nuestra clave privada, la gestión de nuestro anillo de confianza
es otro aspecto del uso de GnuPG que requiere equilibrar la seguridad y la facilidad de uso. Si
estamos usando GnuPG para protegernos contra la posibilidad de una simple interceptación
casual o de una falsificación, entonces nos podemos permitir ser algo confiados con las firmas
de otros. Si, por el contrario, nos preocupa que pueda haber un atacante determinado
interesado en invadir nuestra privacidad, entonces deberíamos confiar mucho menos en otras
firmas, e invertir más tiempo en verificarlas.
Aparte de nuestras propias necesidades de seguridad, deberíamos tener siempre cuidado al
firmar las claves de otras personas. Firmar una clave sin el suficiente grado de confianza en la
validez de la clave, sólo para satisfacer nuestras propias necesidades de seguridad, es una
actitud egoísta. Otros, con otras necesidades de seguridad más grandes, podrían fiarse de una
clave que llevara nuestra firma. Si no pueden confiar en nosotros, entonces se debilita el anillo
de confianza y se hace más difícil la comunicación para todos los usuarios de GnuPG. Así pues,
debemos poner el mismo cuidado al firmar una clave que el que nos gustaría que pusieran otras
personas cuando dependamos de sus firmas.
En la práctica, la gestión de nuestro anillo de claves evita el tener que ajustar las opciones --
marginals-needed y --completes-needed. Cualquier clave que firmemos personalmente será
considerada válida, pero con la excepción de grupos reducidos, no es práctico firmar la clave de
cada persona con la que nos comuniquemos. Por lo tanto, tendremos que dejar que otros
asignen el nivel de confianza.
Es aconsejable ser precisos cuando asignemos el nivel de confianza y cuando usemos las
opciones para configurar el cuidado con que GnuPG debe ir con la validación de claves. Por
ejemplo, es posible que tengamos plena confianza con unos pocos amigos íntimos, que sabemos
que serán lo suficientemente cuidadosos cuando firmen una clave, y que otorguemos un nivel
de confianza marginal al resto en nuestro anillo de claves. Desde esta perspectiva, podemos
tener --completes-needed como 1 y --marginals-needed como 2. Si estuviéramos más
preocupados por la seguridad, podríamos escoger valores de 1 y 3, o 2 y3 respectivamente.
pág. 233

Pero si no estamos tan preocupados por los posibles ataques sobre la privacidad, y simplemente
queremos una fiabilidad razonable sobre la validez, escogeremos los valores 1 y 1. Por regla
general, los números más altos para estas opciones suponen que sería necesario que hubiera
más gente conspirando contra nosotros para poder validar una clave que no pertenezca a la
persona que nosotros creemos.

Ejercicio;
Para empezar iniciaremos instalando el paquete necesario para poder realizar el ejercicio,
ejecutando el comando de la siguiente forma;
# yum -y install gnupg

Iniciaremos generando el par de llaves desde el intérprete de mandatos, ejecutando el comando

de la siguiente forma.
# gpg --gen-key
Lo anterior solicitará:
Un tipo de llave. Predeterminado y recomendado es RSA y RSA.
Tamaño de la llave. Predeterminado es 2048 bits. Se recomienda 4096 bits para
producción. Seleccione 1024 sólo para pruebas.
Caducidad de la llave. Predeterminado es sin caducidad.
Confirmación de la caducidad.
Nombre y apellidos.
pág. 234

Dirección de correo electrónico primaria.

Comentario descriptivo para e par de llaves.
Confirmación de los datos del usuario.
Contraseña y frase de acceso con confirmación.

El proceso puede demorar varios minutos —incluso horas— dependiendo del tamaño de la
firma.
Ejecutando el siguiente comando podra ver la lista de llaves.
# gpg --list-keys
Es conveniente generar un certificado de revocación en caso de extraviar la frase de acceso o
que la seguridad de las llaves se haya visto comprometida. En el siguiente ejemplo se crea el
certificado de revocación para la llave con identidad F08846B8.
# gpg --output revocacion.asc --gen-revoke F08846B8
Esta llave se debe enviar a todos los involucrados en caso de requerirse revocar la llave original.

Ejecutando lo siguiente comando exportaremos la firma en formato binario:
# gpg --output fulano.gpg --export F08846B8
Ejecutandolo de la siguiente forma podremos exportar la firma en formato legible:
# gpg --output fulano.asc --armor --export F08846B8

IMPLEMENTAR Y ADMINISTRAR CUOTAS DE DISCO (DISK QUOTAS) EN
LINUX

Sistemas Linux con gran cantidad de usuarios, como servidores de correo, servidores samba,
etc., tarde o temprano tienen el problema de usuarios que almacenan demasiada información
en sus directorios de trabajo, pudiendo incluso en casos extremos llenar completamente discos
duros haciendo el sistema inservible. Con el uso de cuotas de disco (disk quotas) es posible
limitar la cantidad de espacio disponible para cada usuario o de manera global para todos. En
este manual de LinuxTotal.com.mx conocerás a fondo como implementar y administrar cuotas
de disco para control de los usuarios.

pág. 235

Tipos de cuota
Por Bloques (blocks): Un bloque corresponde a 1 kb y una cuota por bloques correspondería al
total de bloques que un usuario puede utilizar en el sistema. Recuerda que los archivos se
guardan en bloques de disco. Asi un archivo de 100 bytes, ocupará un un bloque de 1kb en el
disco duro.
Por Inodos (inodes): Un inodo o inode en inglés (Index Node) es un número que actua como
apuntador para el sistema de archivos de Linux y le indica en que bloques específicos del disco
duro se encuentran los datos de un archivo. También el inodo en su referencia guarda
información sobre permisos, propietario, atributos, etc. Se podría ver en una analogía simple
que un inodo es como un número de serie único para cada archivo del sistema y a través de este
número el sistema recupera sus datos (bloques) y sus atributos (permisos, propietario, fechas,
etc.).

En el caso de las cutoas, una cuota por inodos indicaría el total de indos a los que el usuario
tiene derecho, casi representaría el total de archivos que el usuario puede crear y digo "casi"
porque los usuarios podemos crear enlaces simbólicos (ln -s) sobre archivos ya existentes que
no aumentan las cantidad de inodos. Pero por simplicidad puedes verlo como un 1 inodo = 1
archivo.

Límites
Tanto las cuotas por bloques o por inodos, tienen límites de uso y son de dos tipos:
HARD: (Duro) Cuando se establece (para bloques o inodos), es el límite absoluto. El usuario no
podrá exceder este límite.

SOFT: (Suave) Este límite (para bloques o inodos) que es siempre menor al HARD, puede ser
excedido por el usuario, pero será constantemente advertido que el límite de uso para bloques
o inodos ya ha sido excedido. Podría verse como un límite de advertencia que le estará
indicando al usuario que su límite ya se excedió y tome medidas.

Cuando se usa el límite SOFT, dos situaciones pueden ocurrir. La primera es que NO se tenga
establecido un tiempo de gracia, y entonces el usuario podrá seguir usando bloques o inodos
hasta llegar al límite HARD que será su límite absoluto de uso.
La segunda situación es que SI se tenga establecido el tiempo de gracia, que puede ser en días,
horas, minutos o segundos. En este caso, el usuario podrá seguir usando bloques o inodos hasta
que termine el tiempo de gracía o llegue al límite HARD, cualquiera que ocurra primero.
El tiempo de gracias se puede establecer por usuario o globalmente y más adelante veremos
como establecerlo.
pág. 236

¿Donde se implementan?
Las cuotas se establecen por filesystem o sistema de archivos, es decir, debes de decidir en
donde es más conveniente instalar un sistema de cuotas, pero no hay ningún problema si se
instala en todos. Las cuotas pueden establecerse por usuario, por grupos o ambos.
En el siguiente ejemplo:

#> mount
/dev/sda1 on /boot type ext3 (rw,noatime)
/dev/sda2 on / type ext3 (rw,noatime)
/dev/sda3 on /home type ext3 (rw,noatime)
none on /proc type proc (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)

Lo anterior es un ejemplo típico de un equipo Linux con varios sistemas de archivos (/boot, / y
/home). Como se sabe en /home es donde los usuarios tienen sus directorios de trabajo
(HOME), asi que solo en este sistema de archivos crearemos cuotas, en los otros dos no tiene
caso.
Configuración
Todo debe hacerse como root, y lo primero que haremos es editar el archivo "/etc/fstab" y
añadiremos "usrquota" o "grpquota", dependiendo si se desea cuotas por usuario o grupos, o
incluso ambas.

#> vi /etc/fstab
/dev/sda2 / ext3 noatime 1 1
/dev/sda1 /boot ext3 noatime 1 2
/dev/sda3 /home ext3 noatime 1 2
....

(Añadimos en la cuarta columna el tipo de cuotas que deseamos)
/dev/sda2 / ext3 noatime 1 1
/dev/sda1 /boot ext3 noatime 1 2
/dev/sda3 /home ext3 noatime,usrquota,grpquota 1 2
...

Algo similar a lo anterior deberá tener tu archivo de configuración, y como ya se indicó solo
pág. 237

agregamos el soporte para cuotas en el sistema de archivos que nos interese. Lo anterior por si
solo, es obvio que no hace nada, habría que reiniciar el sistema para que se apliquen los
cambios pero realmente no es necesario, lo siguiente re-monta el sistema de archivos "/home":

#> mount -o remount /home
#> mount
/dev/sda1 on /boot type ext3 (rw,noatime)
/dev/sda2 on / type ext3 (rw,noatime)
/dev/sda3 on /home type ext3 (rw,noatime,usrquota,grpquota)
none on /proc type proc (rw)

El sistema de archivos "/home" esta listo ahora para soportar cuotas de disco. El siguiente paso
es verificar con el comando quotacheck por sistemas de archivos que soporten cuotas. Este
comando crea, verifica o repara el control de cuotas en los sistemas que lo soporten, en este
caso creara el soporte:

#> quotacheck -augmv
quotacheck: Scanning /dev/sda3 [/home] done
quotacheck: Cannot stat old user quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old group quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old user quota file: No existe el fichero o el directorio
quotacheck: Cannot stat old group quota file: No existe el fichero o el directorio
quotacheck: Checked 2539 directories and 35556 files
quotacheck: Old file not found.
quotacheck: Old file not found.

Los errores que envía es precisamente porque no existía un sistema de cuotas previo, es normal
que los envíe. Cuando las cuotas esten en pleno uso, es conveniente
ejecutarquotacheck periódicamente para que verifique inconsistencias y se corrijan a tiempo.
En cuanto a las opciones estas indican lo siguiente:

a - all, es decir verifica todos los sistemas de archivos por cuotas.
u - user, verifica por soporte de cuotas para usuarios.
g - group, verifica por soporte de cuotas para grupos.
m - no-remount, evita que el sistema se remonte como de solo lectura.
v - verboso, reporta lo que hace conforme progresa, son los mensajes que salen a la
terminal.
pág. 238

Como ves, la opción -a en este caso no era necesario puesto que solo tenemos "/home"
con cuotas, asi que el comando anterior también pudiera ser invocado de esta manera:

#> quotacheck -ugmv /home

Pues el sistema esta listo para manipular cuotas de usuario, esto lo podemos comprobar porque
en la raíz del sistema de archivos soportado con cuotas deben existir los archivos "aquota.user"
y "aquota.group" que son binarios, no trates de modificarlos o manipularlos:

#> cd /home
#> ls -l
total 72
-rw------- 1 root root 8192 2008-05-17 21:38 aquota.group
-rw------- 1 root root 8192 2008-05-17 21:38 aquota.user
drwx--x--x 4 user1 user1 4096 2008-05-12 16:13 user1/

(obsérvese los dos archivos de control de cuotas, para usuarios y grupos)

Si se tuvieran más sistemas de archivos con soporte para cuotas en la raíz de cada uno estarían
estos archivos, o solo uno dependiendo lo que se pidió, usuarios, grupos o ambos. Por cierto, en
sistemas con kernel 2.2 o anterior se usaba la versión 1 de cuotas y sus archivos de control se
nombraban "quota.user" y "quota.group", del kernel 2.4 y posteriores con la versión 2 y 3, se
utiliza los mostrados anteriormente.
Ahora bien, lo anterior deja listo el sistema para el soporte de cuotas pero estás siguen sin ser
activadas se requiere activar el soporte de cuotas, para lo cual invocamos el comandoquotaon:

#> quotaon -ugv /home
/dev/sda3 [/home]: group quotas turned on
/dev/sda3 [/home]: user quotas turned on

Activamos para "/home" cuotas de usuario y grupos. Cuando por alguna razón sea necesario
desactivar las cuotas, entonces utiliza la contraparte, que es el comando quotaoff:

pág. 239

#> quotaoff -v /home

/dev/sda3 [/home]: group quotas turned off
/dev/sda3 [/home]: user quotas turned off

Muy bien, hasta aqui ya tienes el sistema de archivos "/home" o el que hayas elegido (o todos)
para trabajar con soporte de cuotas para los usuarios y grupos, ahora veremos como aplicar
estas cuotas con los usuarios.

Aplicando la cuota a usuarios

Ahara 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. Asi que para iniciar
habrá que administrar cada usuario a través del comando edquota, que abrirá el editor de texto
que se tenga por defecto y mostrará lo siguiente:

#> edquota -u user1
Disk quotas for user user1 (uid 502):
Filesystem blocks soft hard inodes soft hard
/dev/sda3 56 0 0 14 0 0

Las columnas "blocks" e "inodes" son informativas, es decir nos indican la cantidad de bloques o
inodos utilizados actualmente por el usuario, y las que podemos editar son las columnas "soft" y
"hard" de cada caso. Como ya se explicó en la primera parte de este artículo, se puede indicar
libremente cualquiera de los cuatro valores, es perfectamente posible establecer valores por
bloques, por inodos o ambos, solo recuerda que el límite soft debe ser menor al hard.
Si se establece solo el hard, no habrá advertencias previas y el usuario ya no podrá guardar
archivos cuando se llegue al valor. Si se establece soft y hard, avisará cuando se rebase el límite
soft y entrará en juego el periodo de gracia. Si se acaba el tiempo de gracias o se llega al har (lo
que sea primero) ya no se podrán crear más archivos hasta que no se eliminen algunos de los
que se tengan actualmente.
Para modificar cuotas a nivel grupo, se usa el mismo comando pero con la opción -g(edquota -g
ventas).
pág. 240

En el ejemplo previo se modifica la cuota del usuario "user1" en el sistema de archivos "/home"
que es el que se ha usado de ejemplo en este artículo de LinuxTotal.com.mx, el comportamiento
por default es modificar cuotas para ese usuario en todos los sistemas de archivos que tengan
activo el control de cuotas (quotaon). Si se desea control de cuotas para un filesystem en
específico entonces se agrega la opción -f:

#> edquota -u user1 -f /home
(solo aplica la cuota en el sistema de archivos indicado)

Verificando el uso de las cuotas
Como usuario administrador 'root' puedes ver el uso de cuotas de cualquier usuario, ya sea
individualmente o por medio de un reporte global.
Por usuario o individualmente se usa el comando quota, estando como "root":

#> quota -u user1
Filesystem blocks quota limit grace files quota limit grace
/dev/sda3 56 70 100 14 0 0

Con usuarios que manejan cantidades muy grandes de cuota, es un poco dificil calcular en
términos de megas o gigas el espacio usuado y los límites de cuotas:

#> quota -u sergio
Disk quotas for user sergio (uid 500):
/dev/sda3 42578888 0 50000000 34895 0 0

Usando la opción -s se mejora el informe:

#> quota -s -u sergon
Disk quotas for user sergon (uid 500):
/dev/sda3 41582M 0 48829M 34905 0 0

Como usuario individual del sistema, puedes observar tus cuotas con el mismo comandoquota,
sin argumentos.
Ahora bien, si se desea un reporte global de las cuotas de todos los usuarios o por grupos,
pág. 241

siendo "root" utiliza el comando repquota:

#> repquota /home
*** Report for user quotas on device /dev/sda3
Block grace time: 7days; Inode grace time: 7days
Block limits File limits
User used soft hard grace used soft hard grace
----------------------------------------------------------------------
root -- 184280 0 0 11 0 0
sergio -- 42579852 0 50000000 34902 0 0
user1 -- 56 70 100 14 0 0
user2 -- 52 0 0 13 0 0
user3 -- 28 0 0 7 0 0
user4 -- 28 0 0 7 0 0

Con repquota es también posible utilizar la opción -s para observar los tamaños en formato
legible. Si se usa la opción -a (all) en vez del sistema de archivos "/home", el reporte será para
todos los sistemas de archivos en el equipo que soporten cuotas. Asi mismo este reporte por
defecto es por usuarios, si se requiere que repquota reporte por grupos, añade entonces la
opción -g.
Obsérvese en la segunda línea del reporte el tiempo de gracia (grace time), que es de 7 días
tanto para cuotas por bloque como para cuotas por archivos o inodos. Esto aplica para todos los
usuarios en global, como se aprecia en el listado que ninguno tiene establecido un tiempo de
gracia diferente al global.

Estableciendo el tiempo de gracia

A nivel global, un periodo de gracia para todos, utiliza la opción -t del comando edquota, como
en el siguiente ejemplo, recuerda que debes ser "root":

#> edquota -t
Grace period before enforcing soft limits for users:
Time units may be: days, hours, minutes, or seconds
Filesystem Block grace period Inode grace period
/dev/sda3 7days 7days

7 días es el periodo por defecto, si lo cambias a digamos 12 horas, sería "12hours". El tiempo de
gracia puede ser distinto para el límite soft por bloques o por inodos.
Por usuario específico se realiza con la opción -T del mismo comando e indicando el usuario:
pág. 242

#> edquota -u user1 -T
Times to enforce softlimit for user user1 (uid 502):
Time units may be: days, hours, minutes, or seconds
Filesystem block grace inode grace
/dev/sda3 unset unset

Lo único que hay que considerar es que los tiempos de gracias por usuario deben ser menores al
global. Y que este empieza a correr una vez que se ha llegado al límite soft. Cuando esto suceda,
si entras a editar de nuevo el tiempo de gracia del usuario (edquota -u user -T) se reflejara en
segundos el tiempo que le queda, pudiéndolo aumentar de nuevo si eres "root". O dejarlo en
cero y entonces el global será el que se utilice.
Fijar cuotas de manera global a todos los usuarios

En sistemas Linux con pocos usuarios, establecer las cuotas usuario por usuario no representa
ningún problema. Pero si hablamos por ejemplo de una universidad donde pudieran existir
miles de cuentas entonces si es un problema establecer cuentas individualmente.

Realmente no existe una manera "oficial" de establecer cuotas masivamente, sin embargo, no
hay problema, usaremos un pequeño script que te permitira realizarlo.

Establece la cuota que deseas globalmente en un solo usuario:

#> edquota -u user1
Filesystem blocks soft hard inodes soft hard
/dev/sda3 68 300 400 17 0 0
:wq

Veamos el reporte de cuotas con repquota:

[root@segolap ~]# repquota /home
----------------------------------------------------------------------
pág. 243

user1 -- 68 300 400 17 0 0

user2 -- 352 0 0 13 0 0
user3 -- 28 0 0 7 0 0
user4 -- 28 0 0 7 0 0

Solo el usuario "user1" tiene cuotas, las columnas de "grace" tendrán valores una vez que se
llegue al límite soft o suave. Usaremos entonces la opción -p (protptype) para hacer duplicados
a partir del ya establecido.

#> edquota -p user1 user2

Con lo anterior "copias" la información de límites de cuotas del "user1" al "user2", no hay límite
de cuantos usuarios puedes colocar como argumentos asi que lo siguiente es válido:

#> edquota -p user1 user2 user3 user4

Práctico para unos cuantos usuarios pero inútil si necesitamos duplicarlo en cientos de usuarios,
asi que hagamos un comando compuesto que nos extraiga los nombres de los usuarios, se
puede usar por ejemplo gawk para realizar lo anterior:

#> gawk -F: '$3 > 499 {print $1}' /etc/passwd
user1
user2
user3
user4

Usamos el separador ":" de campos (-F), e indicamos como acción que en el campo 3 ($3)
busquemos todos los UID mayores a 499 y que los imprima ({print $1}). Ahora solo tenemos que
usar este comando junto con edquota -p:
#> edquota -p user1 `gawk -F: '$3 > 499 {print $1}' /etc/passwd`

(importante: nota el uso de acento grave que abarca al comando gawk, esto para que el
shell lo ejecute primero y el resultado serán los argumentos, uno o cientos de usuarios
cuyo UID es mayor a 499)

pág. 244

Haciendo uso de repquota de nuevo veamos que pasó:

#> repquota /home
----------------------------------------------------------------------
user1 -- 68 300 400 17 0 0
user2 -- 352 300 400 7days 13 0 0
user3 -- 28 300 400 7 0 0
user4 -- 28 300 400 7 0 0

Primero, todos los usuarios tienen las mismas cuotas que el "user1" que fue el prototipo para
los demás y segundo se observa que el "usuario" que tiene 352 bloques utilizados al pasar el
límite suave entro al periodo de gracia automáticamente que el global es de 7 días. A partir del
instante que el límite cambió de 0 a 300, comenzó el periodo de gracia. Ahora solo podrá crear
más archivos durante 7 días o cuando llegue a 400, lo primero que ocurra, claro, asumiendo que
no borre archivos primeros para recuperar espacio.

Para fines practicos realice el siguiente ejercicio;

Daremos de alta un usuario;

# useradd usuarioquota

Le asignamos un password;

# passwd usuarioquota

Ahora a este usuario le asignaremos una cuota de gracias de 50Mb(51200) y una cuota definitiva
de 100Mb(102400).

Nos logueamos como usuarioquota

Una vez en el perfil copiaremos los archivos que están en la carpeta /usr/lib a un directorio en el
home del usuarioquota

$ cp -r /usr/lib ~/prueba-cuotas

Notará que llegará un momento en el que el sistema indicará que ya es imposible continuar
copiando contenido dentro de ~/prueba-cuotas debido a que se agotó el espacio disponible
para el usuario en el sistema de archivos.
pág. 245

Ejecute de nuevo quota y observe con detenimiento la salida. En ésta aparecerá un asterisco
junto a la cantidad mostrada en las columnas de bloques o bien inodos en los casos donde se
hayan excedido las cuotas.
Verificamos con el comando quota
$ quota
Para solucionar el problema, borramos la carpeta y después verificamos de nuevo.

Configuración de red.

Primero nos tenemos que identificar como root para ejecutar los comandos. Para esto
colocamos en la línea de comandos:

# su -

Para ver cuales son las interfaces de red que tienes disponibles ejecutamos:
# ifconfig | less
La opción de less te permite ver pagina por página las interfaces (en caso de que tengas muchas
o una ventana de comandos pequeña), este comando sólo te muestra las interfaces que están
arriba (up). Te debe aparecer algo como eth0, eth1 y lo (esta interfaz es la de loopback y es la
del propio servidor).

Si queremos mostrar todas las interfaces esten arriba (o levantadas) ejecutamos el siguiente
comando:
# ifconfig –a

Y nos debería mostrar algo como esto:

eth0 Link encap:Ethernet HWaddr 00:0C:29:97:XX:XX
inet addr:10.21.9.70 Bcast:10.21.11.255 Mask:255.255.252.0
inet6 addr: fe80::20c:29ff:fe97:24e3/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:491604 errors:0 dropped:0 overruns:0 frame:0
TX packets:3856 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
pág. 246

RX bytes:57073655 (54.4 MiB) TX bytes:506213 (494.3 KiB)

Interrupt:185 Base address:0x1400

eth1 Link encap:Ethernet HWaddr 00:11:25:29:XX:XX
BROADCAST MULTICAST MTU:1500 Metric:1
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)
Interrupt:19

lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX bytes:3804398 (3.6 MiB) TX bytes:3804398 (3.6 MiB)

En este caso tenemos dos interfaces eth0 y eth1, y sólo eth0 esta arriba, ya que como
podemos ver eth1 no tiene ninguna dirección IP asignada y no tiene ninguna configuración.Por
último tenemos la interfaz lo, que es la interfaz de loopback es decir nuestra propia máquina y
que podemos acceder a través de la dirección 127.0.0.1 (o cualquier rango de 127.0.0.X), y sirve
para comprobar que por lo menos nos responde nuestro propio ordenador o computadora.

Ahora que ya sabemos identificar nuestras tarjetas de red pasemos a lo que podemos hacer con
ellas.
Para asignar direcciones IP manualmente esto ejecutamos el siguiente comando:

# ifconfig eth0 192.168.1.100 255.255.255.0 up

Con broadcast

pág. 247

# ip addr add 192.168.0.10/24 dev eth0 brd +

Cambiando eth0 por el nombre de la interfaz que necesitamos. Si queremos deshabilitar una
interfaz ejecutamos:

# ifconfig eth0 down

Recuerde que si agrega direcciones con rutas lo haría de la siguiente manera:

#route add 169.155.0.0/16 dev eth0

Y la información de las rutas agregadas esta en el archivo routes ubicado en:

/etc/sysconfig/network/routes

Además hay un programa interactivo de consola que nos deja configurar la red mucho más fácil,
incluyendo dhcp, direcciones estáticas puerta de enlace (gateway) ejecutamos el siguiente
comando:
Red Hat:

# redhat-config-network

CentOS y Fedora:

#system-config-network

Te aparecerá un diálogo donde tendras que escoger la interfaz de red que quieres configurar y
luego de seleccionarla verás las distintas opciones.

Una vez que cambies los parámetros de tu interfaz de red siempre es bueno reiniciar el
servicio de red para que se reflejen los cambios:

# service network restart

Archivos de configuración

Si quieres manualmente cambiar los archivos de configuración de tus interfaces de red debes
editar los archivos dentro de /etc/sysconfig/network-scripts/ por ejemplo para la interfaz eth0
sería:

pág. 248

# vim /etc/sysconfig/network-scripts/ifcfg-eth0

Nota: No olvides hacer un backup del archivo en caso de falla antes de hacer cualquier cambio
con:

# cp /etc/sysconfig/network-scripts/ifcfg-eth0 /root/ifcfg-eth0.backup

Puedes utilizar el editor que quieras (nano, emac, etc) Debes ver una configuración como la
siguiente:

DEVICE=eth0
BOOTPROTO=static
BROADCAST=192.168.1.255
HWADDR=00:0C:29:97:XX:XX
IPADDR=192.168.1.100
NETMASK=255.255.255.0
NETWORK=192.168.1.0
ONBOOT=yes
TYPE=Ethernet
Una vez realizados los cambios reiniciamos los servicios de red:


Puedes cambiar los parámetros según lo que necesites, por ejemplo si necesitas se configure
por DHCP deberías tener algo como:

DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
HWADDR=00:0c:29:97:24:e3
TYPE=Ethernet

Una vez realizados los cambios reiniciamos los servicios de red:


Configurando DNS

Para hacer que tu computadora u ordenador busque en un servidor DNS específico tienes que
modificar el archivo /etc/resolv.conf ejecuntado
pág. 249

# vim /etc/resolv.conf

Ahí puedes agregar los servidores que quieras por ejemplo con:

nameserver 10.50.50.130
nameserver 10.50.50.131

Utilizando las direcciones IP de los servidores DNS que quieras.

Configuración del fichero resolv.conf
Cuando se configura la biblioteca de resolución para utilizar los servicios de BIND, tiene que
indicarse también qué servidores utilizar. El fichero resolv.conf contiene una lista de servidores,
que si está vacía hará considerar al sistema que el servidor está en su máquina.

Si ejecuta un servidor de nombres en su máquina local, tendrá que configurarlo por separado,
como se explicará después. Si se encuentra en una red local y puede usar un servidor de
nombres existente, mejor. Si estamos conectados a Internet por módem, lo habitual es
especificar en resolv.conf el servidor de nombres que nos diga nuestro proveedor de servicios.
La opción más importante del fichero resolv.conf es nameserver, que tiene la dirección IP del
servidor de nombres a usar. Si especifican varios servidores poniendo varias líneas nameserver,
se intentarán usar en el orden dado; por lo que debería poner en primer lugar el servidor de
nombres más rápido o cercano. Actualmente, puede ponerse un máximo de tres servidores
distintos. Si no se pone ninguno, intentará buscar un servidor de nombres en la máquina local.
Otras dos opciones, domain y search, nos permiten usar nombres cortos (sin dominio) para
máquinas que estén en nuestro dominio. Normalmente, para conectarnos a una máquina de la
misma red, no queremos poner el dominio completo, sino su nombre. Por ejemplo, gauss en
lugar de gauss.mathematics.groucho.edu.
Para esto sirve la palabra domain. Nos permite especificar un dominio predeterminado que se
añade a las peticiones cuando su búsqueda inicial falla. Por ejemplo, al buscar gauss y fallar el
servidor de nombres buscándolo en Internet, le añade automáticamente su dominio
predeterminado y ya sí puede resolverlo.
Esto está bien, pensaremos, pero tan pronto como nos refiramos a una máquina que esté fuera
del Departamento de Matemáticas, tendremos que volver a teclear el dominio completo. A lo
mejor queremos teclear solo quark.physics para referirnos a una máquina del Departamento de
Físicas.
Para esto podemos usar la lista de búsqueda, que puede especificarse con la opción search. En
pág. 250

esta lista se especifica una lista de dominios donde resolver nombres cortos. Los elementos de
la lista deben especificarse separándolos por espacios o tabuladores.
Las opciones search y domain son mutuamente excluyentes y no pueden aparecer más de una
vez. Si ninguna de las dos se pone, el sistema intentará asignar a los nombres cortos el dominio
de la máquina local, que averiguará usando la llamada al sistema getdomainname (2). Si el nodo
local no tiene dominio, se asumirá que el dominio predeterminado es la raíz.
Si decidimos poner una opción search en el fichero resolv.conf, habrá que ser cuidadosos con los
dominios que añadimos a la lista. Las bibliotecas de resolución anteriores a BIND 4.9 solían
construir una lista de búsqueda predeterminada para el dominio cuando no se proporciona otra
lista. Esta lista predeterminada se hacía con el dominio del nodo, más todos los dominios padre
hasta llegar a la raíz. Esto daba lugar a búsquedas innecesarias a los servidores de nombres
externos.
Asumamos que estamos en la Cervecera Virtual y queremos conectarnos al
sistema foot.groucho.edu. Por un error tecleamos el nombre foo, que no existe. El servidor de la
universidad nos responderá que no existe el nodo. Con la búsqueda antigua, intentará buscar
ese nombre en los dominios vbrew.com y com. Este último es problemático porque causa una
búsqueda innecesaria y además podría existir. Al final nos habremos intentado conectar a una
máquina totalmente ajena.
En algunos casos, esto es un potencial problema de seguridad. De hecho las listas de búsqueda
deben limitarse a dominios de la organización local o algo similar. La lista en el Departamento de
Matemáticas debe limitarse a los dominios maths.groucho.edu y groucho.edu.
Como lo anterior puede resultar confuso, sea el siguiente ejemplo de fichero resolv.conf para la
Cervecera Virtual:
# /etc/resolv.conf
# Nuestro dominio
domain vbrew.com
#
# Nuestro servidor principal va a ser vlager:
name server 172.16.1.1
Cuando se trate de traducir el nombre vale, el sistema empezará por buscar directamente vale y
si falla, probará con vale.vbrew.com.

pág. 251

Configuración y uso de crond.

Esta es una introducción a cron, cubre lo básico de lo que cron puede hacer y la manera de
usarse.

¿Qué es cron?
Cron es el nombre del programa que permite a usuarios Linux/Unix ejecutar automáticamente
comandos o scripts (grupos de comandos) a una hora o fecha específica. Es usado normalmente
para comandos de tareas administrativas, como respaldos, pero puede ser usado para ejecutar
cualquier cosa. Como se define en las páginas del manual de cron (#> man cron) es un demonio
que ejecuta programas agendados.
Recuerde que si no tiene lo que busca dentro del manual de cron, podría encontrar mas
información utilizando los comandos:
# whatis crontab
# man –kcrontab
Dependiendo de la distribución que este utilizando.

En prácticamente todas las distribuciones de Linux se usa la versión Vixie Cron, por la persona
que la desarrolló, que es Paul Vixie, uno de los grandes gurús de Unix, también creador, entre
otros sistemas, de BIND que es uno de los servidores DNS más populares del mundo.

Iniciar cron
Cron es un demonio (servicio), lo que significa que solo requiere ser iniciado una vez,
generalmente con el mismo arranque del sistema. El servicio de cron se llama crond. En la
mayoría de las distribuciones el servicio se instala automáticamente y queda iniciado desde el
arranque del sistema, se puede comprobar de varias maneras:

#> /etc/rc.d/init.d/crond status
#> /etc/init.d/crond status Usa cualquiera de los dos dependiendo de tu distro
crond (pid 507) is running...

o si tienes el comando service instalado:

#> service crond status
crond (pid 507) is running...

se puede también revisar a través del comando ps:
pág. 252

# ps -ef | grep crond

si por alguna razón, cron no esta funcionando:
#> /etc/rc.d/init.d/crond start
Starting crond: [ OK ]

Si el servicio no estuviera configurado para arrancar desde un principio, bastaría con agregarlo
con el comando chkconfig:

#> chkconfig --level 35 crond on

Con esto lo estarías agregando al nivel de ejecución 3 y 5, para que inicie al momento del
arranque del sistema.

Usando cron
Hay al menos dos maneras distintas de usar cron:
La primera es en el directorio etc, donde muy seguramente encontrarás los siguientes
directorios:
cron.hourly
cron.daily
cron.weekly
cron.monthly

Si se coloca un archivo tipo script en cualquiera de estos directorios, entonces el script se

ejecutará cada hora, cada día, cada semana o cada mes, dependiendo del directorio.
Para que el archivo pueda ser ejecutado tiene que ser algo similar a lo siguiente:

#!/bin/sh
#script que genera un respaldo
cd /usr/documentos
tar czf * respaldo
cp respaldo /otra_directorio/.

pág. 253

Nótese que la primera línea empieza con #!, que indica que se trata de un script shell de bash,
las demás líneas son los comandos que deseamos ejecute el script. Este script podría nombrarse
por ejemplo respaldo.sh y también debemos cambiarle los permisos correspondientes para que
pueda ser ejecutado, por ejemplo:

#> chmod 700 respaldo.sh
#> ls -l respaldo.sh
-rwx------ 1 root root 0 Jul 20 09:30 respaldo.sh

La "x" en el grupo de permisos del propietario (rwx) indica que puede ser ejecutado.
Si este script lo dejamos en cron.hourly, entonces se ejecutará cada hora con un minuto de
todos los días, en un momento se entenderá el porque.

Como segundo modo de ejecutar o usar cron es a través de manipular directamente el
archivo /etc/crontab. En la instalación por defecto de varias distribuciones Linux, este archivo se
verá a algo como lo siguiente:

#> cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly

Las primeras cuatro líneas son variables que indican lo siguiente:
SHELL es el 'shell' bajo el cual se ejecuta el cron. Si no se especifica, se tomará por defecto el
indicado en la línea /etc/passwd correspondiente al usuario que este ejecutando cron.
PATH contiene o indica la ruta a los directorios en los cuales cron buscará el comando a
pág. 254

ejecutar. Este path es distinto al path global del sistema o del usuario.

MAIL TO es a quien se le envía la salida del comando (si es que este tiene alguna salida). Cron
enviará un correo a quien se especifique en este variable, es decir, debe ser un usuario válido
del sistema o de algún otro sistema. Si no se especifica, entonces cron enviará el correo al
usuario propietario del comando que se ejecuta.

HOME es el directorio raíz o principal del comando cron, si no se indica entonces, la raíz será la
que se indique en el archivo /etc/passwd correspondiente al usuario que ejecuta cron.
Los comentarios se indican con # al inicio de la línea.

Después de lo anterior vienen las líneas que ejecutan las tareas programadas propiamente. No
hay límites de cuantas tareas pueda haber, una por renglón. Los campos (son 7) que forman
estas líneas están formados de la siguiente manera:

Minuto Hora DiaDelMes Mes DiaDeLaSemana Usuario Comando
Campo Descripción
Controla el minuto de la hora en que el comando será ejecutado, este valor

Minuto
debe de estar entre 0 y 59.
Controla la hora en que el comando será ejecutado, se especifica en un

Hora formato de 24 horas, los valores deben estar entre 0 y 23, 0 es
medianoche.
Día del mes en que se quiere ejecutar el comando. Por ejemplo se indicaría
Día del Mes
20, para ejecutar el comando el día 20 del mes.
Mes en que el comando se ejecutará, puede ser indicado numéricamente

Mes
(1-12), o por el nombre del mes en inglés, solo las tres primeras letras.
Día en la semana en que se ejecutará el comando, puede ser numérico (0-

Día de la
7) o por el nombre del día en inglés, solo las tres primeras letras. (0 y 7 =
semana
domingo)
Usuario Usuario que ejecuta el comando.
Comando, script o programa que se desea ejecutar. Este campo puede

Comando
contener múltiples palabras y espacios.
pág. 255

Un asterisco * como valor en los primeros cinco campos, indicará inicio-fin del campo, es decir
todo. Un * en el campo de minuto indicará todos los minutos.

Para entender bien esto de los primeros 5 campos y el asterisco usaré mejor varios ejemplos:

Ejemplo Descripción
01 * * * * Se ejecuta al minuto 1 de cada hora de todos los días
15 8 * * * A las 8:15 a.m. de cada día
15 20 * * * A las 8:15 p.m. de cada día
00 5 * * 0 A las 5 a.m. todos los domingos
* 5 * * Sun Cada minuto de 5:00a.m. a 5:59a.m. todos los domingos
45 19 1 * * A las 7:45 p.m. del primero de cada mes
01 * 20 7 * Al minuto 1 de cada hora del 20 de julio
10 1 * 12 1 A la 1:10 a.m. todos los lunes de diciembre
00 12 16 *
Al mediodía de los días 16 de cada mes y que sea Miércoles
Wen
30 9 20 7 4 A las 9:30 a.m. del dia 20 de julio y que sea jueves
30 9 20 7 * A las 9:30 a.m. del dia 20 de julio sin importar el día de la semana
20 * * * 6 Al minuto 20 de cada hora de los sábados
20 * * 1 6 Al minuto 20 de cada hora de los sábados de enero

Ejecutando Cron con múltiples usuarios, comando crontab

Linux es un sistema multiusuario y cron es de las aplicaciones que soporta el trabajo con varios
usuarios a la vez. Cada usuario puede tener su propio archivo crontab, de hecho
el/etc/crontab se asume que es el archivo crontab del usuario root, aunque no hay problema
que se incluyan otros usuarios, y de ahí el sexto campo que indica precisamente quien es el
usuario que ejecuta la tarea y es obligatorio en /etc/crontab.
pág. 256

Pero cuando los usuarios normales (e incluso root) desean generar su propio archivo de
crontab, entonces utilizaremos el comando crontab.
En el directorio /var/spool/cron (puede variar según la distribución), se genera un archivo cron

para cada usuario, este archivo aunque es de texto, no debe editarse directamente.
Se tiene entonces, dos situaciones, generar directamente el archivo crontab con el comando:

$> crontab -e

Con lo cual se abrira el editor por default (generalemente vi) con el archivo llamado crontab
vacio y donde el usuario ingresará su tabla de tareas y que se guardará automáticamente como
/var/spool/cron/usuario.
El otro caso es que el usuario edite un archivo de texto normal con las entradas de las tareas y
como ejemplo lo nombre 'mi_cron', después el comando $> crontab mi_cron se encargará de
establecerlo como su archivo cron del usuario en /var/spool/cron/usuario:

$> vi mi_cron
# borra archivos de carpeta compartida
0 20 * * * rm -f /home/sergio/compartidos/*
# ejecuta un script que realiza un respaldo de la carpeta documentos el primer día de cada mes
0 22 1 * * /home/sergio/respaldomensual.sh
# cada 5 horas de lun a vie, se asegura que los permisos sean los correctos en mi home
1 *5 * * * 1-5 chmod -R 640 /home/sergio/*
:wq (se guarda el archivo)
$> ls
mi_cron
$>
mi_cron
(se establece en /var/spool/cron/usuario)

Resumiendo lo anterior y considerando otras opciones de crontab:

$> crontab archivo.cron (establecerá el archivo.cron como el crontab del usuario)
$> crontab -e (abrirá el editor preestablecido donde se podrá crear o editar el archivo
crontab)
$> crontab -l (lista el crontab actual del usuario, sus tareas de cron)
pág. 257

$> crontab -r (elimina el crontab actual del usuario)
En algunas distribuciones cuando se editan crontabs de usuarios normales es necesario reiniciar

el servicio para que se puedan releer los archivos de crontab en /var/spool/cron.

#> service crond restart

Para entender mejor como iniciar/detener/reiniciar servicios, en este artículo encontrarás más
información.

Controlando el acceso a cron

Cron permite controlar que usuarios pueden o no pueden usar los servicios de cron. Esto se
logra de una manera muy sencilla a través de los siguientes archivos:
/etc/cron.allow
/etc/cron.deny
Para impedir que un usuario utilice cron o mejor dicho el comando crontab, basta con agregar
su nombre de usuario al archivo /etc/cron.deny, para permitirle su uso entonces sería agregar
su nombre de usuario en /etc/cron.allow, si por alguna razón se desea negar el uso de cron a
todos los usuarios, entonces se puede escribir la palabra ALL al inicio de cron.deny y con eso
bastaría.
#> echo ALL >>/etc/cron.deny

o para agregar un usuario mas a cron.allow
#> echo juan >>/etc/cron.allow

Si no existe el archivo cron.allow ni el archivo cron.deny, en teoría el uso de cron esta entonces
sin restricciones de usuario. Si se añaden nombres de usuarios en cron.allow, sin crear un
archivo cron.deny, tendrá el mismo efecto que haberlo creado con la palabra ALL. Esto quiere
decir que una vez creado cron.allow con un solo usuario, siempre se tendrán que especificar los
demás usuarios que se quiere usen cron, en este archivo.
Por último y no menos importante:
Administracion de trabajos en cron
crontab archivo
pág. 258

Remplaza el existente archivo crontab con un archivo definido por el usuario

crontab -e
Editar el archivo crontab del usuario, cada linea nueva sera una nueva tarea de crontab.
crontab -l
Lista todas las tareas de crontab del usuario
crontab -d
Borra el crontab del usuario
crontab -c dir
Define el directoriod e crontab del usuario (este debe tener permisos de escritura y ejecucion
del usuario)
crontab -u usuario
prefijo para manejar el crontab de otro usuario, ejemplos:
$ sudo crontab -l -u root
$ sudo crontab -e usuario2
#crontab -d -u usuario

Ejercicio;

Para iniciar comenzaremos instalando el paquete necesarios;

# yum –y install cronie

# yum –y install anacron

El formato del archivo /etc/crontab.
Cualquier usuario que sea definido para ejecutar un programa en el archivo /etc/crontab, podrá
ejecutar todo aquello para lo cual tenga privilegios, siempre y cuando se defina un intérprete de
mandatos válido (por ejemplo /bin/bash o /bin/sh) en la variable de entorno SHELL, así como las
rutas de binarios ejecutables que sean necesarias, sin importar lo que esté definido en el archivo
/etc/passwd o las variables de entorno definidas en el archivo ~/.bashrc del usuario a utilizar.
SHELL=/bin/bash
MAILTO=root

pág. 259

El archivo /etc/crontab permite además definir a cuál usuario enviar un mensaje de correo
electrónico con los resultados de las salidas de los programas que las generen y el intérprete de
mandatos a utilizar.
SHELL=/bin/bash
MAILTO=alguien@gmail.com
El archivo utiliza un formato de 7 campos, donde se define, respectivamente, minuto, hora, día
del mes, mes, día de la semana, usuario a utilizar y el programa a ejecutar.
.-----------------------· Minuto (0 - 59)

| .--------------------· Hora (0 - 23)
| | .-----------------· Día del mes (1 - 31)
| | | .--------------· Mes (1 - 12)
| | | | .-----------· Día de la semana (0 - 6) (domingo=0 o 7), y
| | | | | también acepta como valores:
| | | | | mon, tue, wed, thu, fri, sat y sun
| | | | | .--------· Usuario
| | | | | | .-· Programa a ejecutar
↓ ↓ ↓ ↓ ↓ ↓ ↓
1 14 * * * hector /home/hector/bin/tarea.sh > /dev/null 2>&1
Formato exclusivo de cronie.
A diferencia de vixie-cron, con cronie se pueden omitir los primeras 5 campos y en su lugar
utilizar las siguientes opciones:
@reboot (ejecutar una vez después de reiniciar el sistema)
@yearly y @annually (ejecutar anualmente, es decir: «0 0 1 1 *»)
@monthly (ejecutar mensualmente, es decir: «0 0 1 * *»)
@weekly (ejecutar semanalmente, es decir: «0 0 * * 0»)
@daily (ejecutar diariamente, es decir: «0 0 * * *»)
@hourly (ejecutar cada hora, es decir: «0 * * * *»)

pág. 260

Formato para utilizar con crontab -e.

Todos los usuarios del sistema pueden ejecutar crontab con la opción -e, a excepción de
aquellos quienes tengan /dev/null (dispositivo nulo) como intérprete de mandatos o bien que se
encuentren listados en el archivo /etc/cron.deny.
Para los usuarios que tengan /sbin/nologin como intérprete de mandatos, será necesario se
defina /bin/bash o /bin/sh en la variable de entorno SHELL al inicio del archivo cron
correspondiente. Con este tipo de usuarios, habría que ejecutar lo siguiente para poder hacer
uso de crontab.
# su -l usuario -s /bin/bash -c "crontab -e"
ATD
El At tiene basicamente la misma funcionalidad, solo cambia el formato con el que se especifica
un 'momento'. Tiene una sintaxis muy parecida al ingles. Dare ejemplos para que se entienda,
pero antes debemos comprender que el At no ejecuta un comando o script, sino una serie de
comandos, que At nos solicitara interactivamente. Tambien podemos especificar un script (y NO
un binario) para que sea ejecutado, mediante el parametro '-f', que ahora veremos.
Veamos unos ejemplos, para comprender mejor el uso de at:
at midnight - Ejecutara a la medianoche el script que ingresemos interactivamente al ejecutar el
comando. Tambien podemos usar noon (mediodia) o teatime (4pm). Por otra parte, podemos
agregar today (hoy) o tomorrow (maniana) como sufijo. Ejemplo: at 8:30am tomorrow (8.30 am
de maniana).
at 3:15pm - Ejecutara a las 3:15 de la tarde.
at now + 2 days - Ejecutara dentro de dos dias.
at 10am + 1 week - Ejecutara a las 10am dentro de una semana.
at 11pm Jul 22 - Ejecutara a las 23hs del 22 de Julio.
Y usando el parametro '-f', podriamos hacer: at -f ~/algun_script now + 10 minutes (ejecutar el
script ~/algun_script dentro de 10 minutos a partir de ahora).
En vez de usar day[s], week[s], tambien podemos usar minute[s], hour[s]. El now indica
"AHORA".
Fecha u hora se pueden especificar con los siguientes formatos: HH:MM (hora:minutos),
MMDDYY o MM/DD/YY o DD.MM.YY (mes dia anio).
Los diferentes comandos que hacen al paquete AT son:
atd - El AT Daemon - Como cron, se debe cargar desde un script de /etc/rc.d
at - El at propiamente dicho. Ver los ejemplos.
atq - Ver la lista de trabajos ('jobs') pendientes.
pág. 261

atrm - Para eliminar un trabajo pendiente de la cola (queue).

batch - Como at, pero ejecutara el script cuando el nivel de carga del sistema haya bajado
lo suficiente. (default, 0.8).
El atq es el at con el parametro '-l', y el atrm es el at, pero con el parametro '-d'.
El at tambien admite el parametro '-m', que enviara un eMail al usuario una vez realizado el
trabajo.
Para permitir o denegar el uso de at podemos hacer lo mismo que con cron, y los archivos Allow
y Deny se encuentran en /etc/at.allow y /etc/at.deny, y se respeta el mismo esquema que en
Cron.
IPTABLES
Red Hat Enterprise Linux contiene herramientas avanzadas para el filtrado de paquetes de red
— el proceso dentro del kernel de controlar los paquetes de red al entrar, mientras se mueven y
cuando salen de la red. Los kernels anteriores al 2.4 confiaban en ipchains para el filtrado de
paquetes y usaban listas de reglas aplicadas a los paquetes en cada paso del proceso de filtrado.
La introducción de kernel 2.4 trajo consigo iptables (también llamado netfilter), lo cual es similar
a ipchains pero expande enormemente el ámbito y el control disponible para el filtrado de
paquetes de red.
Este capítulo se centra en las bases del filtrado esencial de paquetes, define las diferencias
entre ipchains e iptables, explica las diferentes opciones disponibles con comandos iptables y
muestra cómo se pueden preservar las reglas de filtrado durante reinicios del sistema.
Filtrado de paquetes
El kernel de Linux tiene incorporado la característica interna de filtrar paquetes, permitiendo
aceptar algunos de ellos en el sistema mientras que intercepta y para a otros. El netfilter del
kernel tiene tres tablas o listas de reglas incorporadas. Son las siguientes:
filter — La tabla por defecto para el manejo de paquetes de red.
nat — Usada para alterar paquetes que crean una nueva conexión y utilizada para
la Traducción de direcciones de red (Network Address Translation, NAT).
mangle — Usada por tipos específicos de alteración de paquetes.

Cada una de estas tablas tiene un grupo de cadenas incorporadas que corresponden a las
acciones llevadas a cabo por el filtro de la red.
Las cadenas internas para la tabla filtro son las siguientes:
INPUT — Aplica a los paquetes recibidos a través de una interfaz de red.
pág. 262

OUTPUT — Esta cadena sirve para paquetes enviados por medio de la misma interfaz de
red que recibió los paquetes.
FORWARD — Esta cadena sirve para paquetes recibidos en una interfaz de red y enviados
en otra.
Las cadenas internas para la tabla nat son las siguientes:
PREROUTING — Altera los paquetes de red cuando estos llegan.
POSTROUTING — Esta cadena altera paquetes antes de que sean enviados por medio de
una interfaz de red.
POSTROUTING — Altera los paquetes de red cuando estos son enviados.
PREROUTING — Esta cadena altera paquetes recibidos por medio de una interfaz de red cuando
llegan.
OUTPUT — Esta cadena altera paquetes generados localmente antes de que sean dirigidos
por medio de una interfaz de red.
POSTROUTING — Esta cadena altera paquetes antes de que sean enviados por medio de
una interfaz de red.
Las cadenas internas para la tabla mangle son las siguientes:
PREROUTING — Esta cadena altera paquetes recibidos por medio de una interfaz de red
antes de que sean dirigidos.
POSTROUTING — Altera los paquetes de red cuando estos son enviados.
Cada paquete de red recibido o enviado desde un sistema Linux está sujeto a al menos una
tabla. Sin embargo, un paquete puede estar sometido a múltiples reglas dentro de cada tabla
antes de emerger al final de la cadena. La estructura y propósito de estas reglas puede variar,
pero normalmente buscan identificar un paquete que viene de o se dirige hacia una dirección IP
en particular, o un conjunto de direcciones, cuando utiliza un determinado protocolo y servicio
de red.
Independientemente de su destino, cuando un paquete cumple una regla en particular en una
de las tablas, se les aplica un objetivo (target) o acción a ellos. Si la regla especifica un
objetivo ACCEPT para un paquete que coincida, el paquete se salta el resto de las verificaciones
de la regla y se permite que continúe hacia su destino. Si una regla especifica un objetivo DROP,
a ese paquete se le niega el acceso al sistema y no se envía nada de vuelta al servidor que envió
el paquete. Si una regla especifica un objetivo QUEUE, el paquete se pasa al espacio del usuario.
Si una regla especifica el objetivo opcional REJECT, el paquete es descartado, pero se envía un
paquete de error al que envió el paquete.

pág. 263

Cada cadena tiene una política por defecto de ACCEPT, DROP, REJECT, o QUEUE. Si ninguna de
estas reglas en la cadena se aplica al paquete, entonces el paquete es tratado de acuerdo a la
política por defecto.
El comando iptables configura estas tablas, así como también configura nuevas tablas si es
necesario.
Diferencias entre iptables e ipchains

A primera vista, ipchains e iptables parecen ser bastante similares. Ambos métodos de filtrado
de paquetes usan cadenas de reglas operando dentro del kernel de Linux para decidir qué hacer
con los paquetes que cumplen determinadas reglas. Sin embargo, iptables proporciona un
método mucho más extensible de filtrado de paquetes, proporcionando al administrador un
nivel de control mucho más refinado sin tener que aumentar la complejidad del sistema entero.
Más concretamente, los usuarios que se encuentren cómodos con ipchains deberían tener
cuidado con las siguientes diferencias significativas entre ipchains e iptables antes de
utilizar iptables:
Bajo iptables, cada paquete filtrado se procesa únicamente usando las reglas de una
cadena solamente, en lugar de hacerse con múltiples. Por ejemplo, un paquete FORWARD
que llega al sistema usando ipchains tendrá que pasar por las cadenas INPUT, FORWARD, y
OUTPUT para llegar a su destino. Sin embargo, iptables sólo envía paquetes a la cadena
INPUT si su destino es el sistema local y tan sólo los envía a la cadena OUTPUT si el sistema
local es quien genera los paquetes. Por esta razón, es importante que coloque la regla
designada para capturar un paquete particular dentro de la regla que en verdad maneja el
paquete.
El objetivo DENY ha sido cambiado a DROP. En ipchains, los paquetes que coincidan una
regla en una cadena podrían ser dirigidos al objetivo DENY. Este objetivo debe ser
cambiado a DROP bajo iptables.
El orden es importante cuando se estén colocando opciones en una regla. Anteriormente,
con ipchains, el orden de las opciones de una regla no importaba. El comando iptables usa
una sintaxis más estricta. En comandos iptables, el protocol (ICMP, TCP o UDP) debe ser
especificado antes del puerto fuente o destino.
Cuando especificamos las interfaces de red que vamos a usar en una regla, deberemos
utilizar sólo interfaces de entrada (opción -i) con cadenas INPUT o FORWARD y las de salida
(opción -o) con cadenas FORWARD o OUTPUT. Esto es necesario debido al hecho de que
las cadenas OUTPUT no se utilizan más con las interfaces de entrada, y las cadenas INPUT
no son vistas por los paquetes que se mueven hacia las interfaces de salida.
pág. 264

Opciones usadas en comandos iptables

Las reglas para el filtrado de paquetes se ponen en funcionamiento ejecutando el
comando iptables. Con frecuencia se utilizan los aspectos siguientes del paquete como el
criterio:
Tipo de paquete — Dicta qué tipo de paquetes filtra el comando.
Fuente/Destino del paquete — Especifica cuáles paquetes filtra el comando basándose en
el origen o destino del paquete.
Objetivo — Indica qué acción es tomada en paquetes que cumplen los criterios
mencionados anteriormente.
Las opciones usadas con las reglas iptables dadas deben estar agrupadas lógicamente,
basándose en el propósito y en las condiciones de la regla general, para que la regla sea válida.
El resto de esta sección explica las opciones usadas comúnmente para el comando iptables.
Estructura de las opciones iptables

Muchos comandos iptables tienen la siguiente estructura:
iptables [-t <table-name>] <command> <chain-name> <parameter-1> \

<option-1> <parameter-n> <option-n>
La opción <table-name> permite al usuario seleccionar una tabla diferente a la tabla

predeterminada filter a usar con el comando. La opción <command> indica una acción
específica a realizar, tal como anexar o eliminar la regla especificada por la opción <chain-
name>. Luego de la opción <chain-name> se encuentran un par de parámetros y opciones que
definen qué pasará cuando un paquete coincide con la regla.
Cuando miramos la estructura de un comando iptables, es importante recordar que, al contrario
que la mayoría de los comandos, la longitud y complejidad de un comandoiptables puede
cambiar en función de su propósito. Un comando para borrar una regla de una cadena puede
ser muy corto, mientras que un comando diseñado para filtrar paquetes de una subred
particular usando un conjunto de parámetros específicos y opciones puede ser mucho más
largo. Al crear comandos iptables puede ser de ayuda reconocer que algunos parámetros y
opciones pueden crear la necesidad de utilizar otros parámetros y opciones para especificar más
aún la petición de la opción anterior. Para construir una regla válida, esto deberá continuar
hasta que todos los parámetros y opciones que requieran otro conjunto de opciones hayan sido
satisfechos.
Escriba iptables -h para ver una lista detallada de la estructura de los comandos iptables.
pág. 265

Opciones de comandos
Las opciones de comandos le dicen a iptables que realice una acción específica. Solamente una
opción de comando se permite por comando iptables. Excepto el comando de ayuda, todos los
comandos se escriben en mayúsculas.
Los comandos de iptables son los siguientes:
-A — Añade la regla iptables al final de la cadena especificada. Este es el comando utilizado
para simplemente añadir una regla cuando el orden de las reglas en la cadena no importa.
-C — Verifica una regla en particular antes de añadirla en la cadena especificada por el
usuario. Este comando puede ser de ayuda para construir reglas iptables complejas
pidiéndole que introduzca parámetros y opciones adicionales.
-D — Borra una regla de una cadena en particular por número (como el 5 para la quinta
regla de una cadena). Puede también teclear la regla entera e iptables borrará la regla en
la cadena que corresponda.
-E — Renombra una cadena definida por el usuario. Esto no afecta la estructura de la tabla.
-F — Libera la cadena seleccionada, que borra cada regla de la cadena. Si no se especifica
ninguna cadena, este comando libera cada regla de cada cadena.
-h — Proporciona una lista de estructuras de comandos, así como también un resumen
rápido de parámetros de comandos y opciones.
-I — Inserta una regla en una cadena en un punto especificado por un valor entero
definido por el usuario. Si no se especifica ningún número, iptables colocará el comando en
el tope de la cadena.
-L — Lista todas las reglas de la cadena especificada tras el comando. Para ver una lista de
todas las reglas en todas las cadenas en la tabla por defecto filter, no especifique ninguna
cadena o tabla. De lo contrario, la sintaxis siguiente deberá utilizarse para listar las reglas
en una cadena específica en una tabla en particular:
iptables -L <chain-name> -t <table-name>
-N — Crea una nueva cadena con un nombre especificado por el usuario.

-P — Configura la política por defecto para una cadena en particular, de tal forma que,
cuando los paquetes atraviesen la cadena completa sin cumplir ninguna regla, serán
enviados a un objetivo en particular, como puedan ser ACCEPT o DROP.
-R — Reemplaza una regla en una cadena particular. El número de la regla debe ser
especificado después del nombre de la cadena. La primera regla en una cadena
corresponde a la regla número uno.
pág. 266

-X — Borra una cadena especificada por el usuario. No se permite borrar ninguna de las
cadenas predefinidas para cualquier tabla.
-Z — Pone ceros en los contadores de byte y de paquete en todas las cadenas de una tabla
en particular.
Opciones de parámetros de iptables
Una vez que se especifiquen ciertos comandos iptables, incluyendo aquellos para añadir,
anexar, eliminar, insertar o reemplazar reglas dentro de una cadena, se requieren parámetros
para construir una regla de filtrado de paquetes.
-c — Resetea los contadores de una regla en particular. Este parámetro acepta las
opciones PKTS y BYTES para especificar qué contador hay que resetear.
-d — Configura el nombre de la máquina destino, dirección IP o red de un paquete que
coincide con la regla. Cuando se coincida una red, se soportan los siguientes formatos de
direcciones IP o máscaras de red:
N.N.N.N/M.M.M.M — Donde N.N.N.N es el rango de direcciones IP y M.M.M.M es la
máscara de la red.
N.N.N.N/M — Donde N.N.N.N es el rango de direcciones IP y M es la máscara de bit.
-f — Aplica esta regla sólo a los paquetes fragmentados.
Usando la opción ! después de este parámetro, únicamente se harán coincidir los paquetes
no fragmentados.
-i — Configura la interfaz de red entrante, tal como eth0 o ppp0. Con iptables, este
parámetro opcional puede ser usado solamente con las cadenas INPUT y FORWARD
cuando es usado con la tabla filter y la cadena PREROUTING con las tablas nat y mangle.
Este parámetro también soporta las siguientes opciones especiales:
El carácter de exclamación ! — Invierte la directriz, es decir, se excluye de esta regla
cualquier interfaz especificada.
El caráter de suma + — Un caracter tipo comodín utilizado para coincidir todas las
interfaces con una cadena de caracteres especificada. Por ejemplo, el parámetro -i
eth+aplicará esta regla a cualquier interfaz Ethernet pero excluirá cualquier otra interfaz,
tal como, ppp0.
Si el parámetro -i se utiliza sin especificar ninguna interfaz, todas las interfaces estarán
afectadas por la regla.
-j — Salta a un objetivo particular cuando un paquete coincide con una regla particular. Los
objetivos válidos a usar después de la opción -j incluyen las opciones estándar
(ACCEPT, DROP, QUEUE y RETURN) así como también las opciones extendidas que están
disponibles a través de los módulos cargados por defecto con el paquete RPM de Red Hat
pág. 267

Enterprise Linux iptables, como LOG, MARK y REJECT, entre otros. Consulte la página del
manual de iptables para más información sobre esto y otros objetivos.
Puede también dirigir un paquete coincidiendo esta regla a una cadena definida por el
usuario fuera de la cadena actual, para aplicar otras reglas al paquete.
Si no especifica ningún objetivo, el paquete pasa la regla sin llevar a cabo ninguna acción.
A pesar de todo, el contador para esta regla se sigue incrementando en uno.
-o — Configura la interfaz de red de salida para una regla y puede ser usada solamente con
las cadenas OUTPUT y FORWARD en la tabla de filtro y la cadena POSTROUTING en las
tablas nat y mangle. Estos parámetros de opciones son los mismos que aquellos de la
interfaz de entrada (-i).
-p — Configura el protocolo IP para la regla, el cual puede ser icmp, tcp, udp, o all, para
coincidir todos los protocolos soportados. Además, se puede usar cualquier protocolo
listado en /etc/protocols. Si esta opción es omitida cuando se esté creando una regla, la
opción all es la opción por defecto.
-s — Configura la fuente para un paquete particular usando la misma sintaxis que el
parámetro (-d).
Opciones de coincidencia para iptables
Diferentes protocolos de red proporcionan opciones especializadas las cuales se pueden
configurar para coincidir un paquete particular usando ese protocolo. Sin embargo, primero se
debe especificar el protocolo en el comando iptables. Por ejemplo, -p tcp <protocol-
name> (donde <protocol-name> es el protocolo objetivo), hace disponibles las opciones para
ese protocolo especificado.
Protocolo TCP
Estas opciones de identificación están disponibles en el protocolo TCP (opción -p tcp):
--dport — Configura el puerto de destino para el paquete. Use bien sea un nombre de
servicio (tal como www o smtp), número de puerto, o el rango de números de puertos
para configurar esta opción. Para hojear los nombres y alias de los servicios de red y los
números que ellos usan, visualice el archivo /etc/services. La opción --destination-portes
sinónimo con --dport.
Para especificar un rango de números de puertos, separe los dos números con dos
puntos (:), tal como -p tcp --dport 3000:3200. El rango más grande aceptable es0:65535.
Use un caracter de exclamación (!) después de la opción --dport para coincidir todos los
paquetes que no utilizan el servicio de red o puerto.
pág. 268

--sport — Configura el puerto fuente del paquete usando las mismas opciones que --dport.
La opción --source-port es sinónimo con --sport.
--syn — Provoca que todos los paquetes designados de TCP, comúnmente
llamados paquetes SYN, cumplan esta regla. Cualquier paquete que esté llevando un
payload de datos no será tocado. Si se sitúa un punto de exclamación (!) como bandera
tras la opción --syn se provoca que todos los paquetes no-SYN sean seleccionados.
--tcp-flags — Permite a los paquetes TCP con bits específicos o banderas, ser coincididos
con una regla. La opción --tcp-flags acepta dos parámetros. El primer parámetro es la
máscara, la cual configura banderas a ser examinadas en el paquete. El segundo parámetro
se refiere a la bandera que se debe configurar para poder coincidir.
Las banderas posibles son:
ACK
FIN
PSH
RST
SYN
URG
ALL
NONE
Por ejemplo, una regla iptables que contenga -p tcp --tcp-flags ACK,FIN,SYN SYN tan sólo
seleccionará los paquetes TCP que tengan la bandera SYN activo y las banderas ACK y FIN sin
activar.
Usando el caracter de exclamación (!) después de --tcp-flags reversa el efecto de la opción de
coincidencia.
--tcp-option — Intenta seleccionar con opciones específicas de TCP que pueden estar
activas en un paquete en particular. Esta opción se puede revertir con el punto de
exclamación (!).

pág. 269

Protocolo UDP
Estas opciones de selección están disponibles para el protocolo UDP (-p udp):
--dport — Especifica el puerto destino del paquete UDP, usando el nombre del servicio,
número de puerto, o rango de números de puertos. La opción de coincidencia --
destination-port es sinónimo con --dport.
--sport — Configura el puerto fuente del paquete UDP, usando el nombre de puerto,
número de puerto o rango de números de puertos. La opción --source-port es sinónimo
con --sport.
Protocolo ICMP
Las siguientes opciones de coincidencia están disponibles para el Protocolo de mensajes de
Internet (ICMP) (-p icmp):
--icmp-type — Selecciona el nombre o el número del tipo ICMP que concuerde con la regla.
Se puede obtener una lista de nombres válidos ICMP tecleando el comandoiptables -p
icmp -h.
Módulos con opciones de coincidencias adicionales
Opciones adicionales de coincidencia están disponibles a través de los módulos por el
comando iptables. Para usar un módulo de opciones de coincidencia, cargue el módulo por
nombre usando la opción -m, tal como -m <module-name> (reemplazando <module-name> con
el nombre del módulo).
Un gran número de módulos están disponibles por defecto. Hasta es posible crear sus módulos
para proporcionar funcionalidades de opciones de coincidencia adicionales.
Lo siguiente, es una lista parcial de los módulos usados más comúnmente:
limit module — Permite colocar un límite en cuántos paquetes son coincididos a una regla
particular. Esto es especialmente beneficioso cuando se usa en conjunto con el
objetivo LOG, pues puede prevenir que una inundación de paquetes coincidentes
sobrecarguen el registro del sistema con mensajes repetitivos o usen los recursos del
sistema.
El módulo limit habilita las opciones siguientes:
--limit — Configura el número de coincidencias en un intervalo de tiempo, especificado con
un número y un modificador de tiempo ordenados en el formato<número>/<tiempo>. Por
ejemplo, si usamos --limit 5/hour sólo dejaremos que una regla sea efectiva cinco veces a
la hora.
Si no se utiliza ningún número ni modificador de tiempo, se asume el siguiente valor por
defecto: 3/hour.
pág. 270

--limit-burst — Configura un límite en el número de paquetes capaces de cumplir una regla

en un determinado tiempo. Esta opción deberá ser usada junto con la opción--limit, y
acepta un número para configurar el intervalo de tiempo (threshold).
Si no se especifica ningún número, tan sólo cinco paquetes serán capaces inicialmente de
cumplir la regla.
módulo state — Habilita la coincidencia de estado.
El módulo state tiene las siguientes opciones:
--state — coincide un paquete con los siguientes estados de conexión:
ESTABLISHED El paquete seleccionado se asocia con otros paquetes en una conexión
establecida.
INVALID El paquete seleccionado no puede ser asociado a una conexión conocida.
NEW El paquete seleccionado o bien está creando una nueva conexión o bien forma parte
de una conexión de dos caminos que antes no había sido vista.
RELATED El paquete seleccionado está iniciando una nueva conexión en algún punto de la
conexión existente.
Estos estados de conexión se pueden utilizar en combinación con otros separándolos mediante
comas como en -m state --state INVALID, NEW.
módulo mac — Habilita la coincidencia de direcciones MAC de hardware.
El módulo mac activa las opciones siguientes:
--mac-source — Coincide una dirección MAC a la tarjeta de red que envió el paquete. Para
excluir una dirección MAC de la regla, coloque un símbolo de exclamación (!) después de la
opción --mac-source.
Para visualizar otras opciones disponibles a través de los módulos, consulte la página del manual
de iptables.
Opciones del objetivo
Una vez que un paquete ha coincidido con una regla, la regla puede dirigir el paquete a un
número de objetivos diferentes que deciden su suerte y, posiblemente, toman acciones
adicionales. Cada cadena tiene un objetivo por defecto, el cual es usado si ninguna de las reglas
en esa cadena coinciden con un paquete o si ninguna de las reglas que coinciden con el paquete
especifica un objetivo.
Los siguientes son los objetivos estándar:
<user-defined-chain> — Reemplace <user-defined-chain> con el nombre de una cadena
definida por el usuario dentro de la tabla. Este objetivo pasa el paquete a la cadena
objetivo.
pág. 271

ACCEPT — Permite que el paquete se mueva hacia su destino (o hacia otra cadena, si no ha
sido configurado ningún destino para seguir a esta cadena).
DROP — Deja caer el paquete sin responder al solicitante. El sistema que envia el paquete
no es notificado de esta falla.
QUEUE — El paquete se pone en una cola para ser manejado por una aplicación en el
espacio de usuario.
RETURN — Para la verificación del paquete contra las reglas de la cadena actual. Si el paquete
con un destino RETURN cumple una regla de una cadena llamada desde otra cadena, el paquete
es devuelto a la primera cadena para retomar la verificación de la regla allí donde se dejó. Si la
regla RETURN se utiliza en una cadena predefinida, y el paquete no puede moverse hacia la
cadena anterior, el objetivo por defecto de la cadena actual decide qué acción llevar a cabo.
Además de estos objetivos standard, se pueden usar otros más con extensiones
llamadas módulos de objetivos (target modules).
Existen varios módulos extendidos de objetivos, la mayoría de los cuales tan sólo se aplican a
tablas o situaciones específicas. Un par de estos módulos, de los más populares e incluidos por
defecto en Linux son:
LOG — Registra todos los paquetes que coinciden esta regla. Puesto que los paquetes son
registrados por el kernel, el archivo /etc/syslog.conf determina dónde estas entradas de
registro serán escritas. Por defecto, son colocadas en el archivo /var/log/messages.
Se pueden usar varias opciones adicionales tras el objetivo LOG para especificar la manera
en la que tendrá lugar el registro:
--log-level — Configura el nivel de prioridad del registro de eventos. Una lista de los niveles
de prioridad se puede encontrar en la página del manual de syslog.conf.
--log-ip-options Cualquier opción en la cabecera de un paquete IP se guarda en el registro.
--log-prefix — Coloca una cadena de hasta 29 caracteres antes de la línea de registro
cuando es escrita. Esto es muy útil para la escritura de filtros de syslog para usarlos en
conjunto con el registro de paquetes.
--log-tcp-options — Cualquier opción colocada en la cabecera de un paquete TCP es
registrada.
--log-tcp-sequence Escribe el número de secuencia TCP del paquete en el registro del
sistema.
Recuerde que la administración de Logs es vital en este tipo de administración, por esta razón se
encuentra el archivo logrotate, que sirve para hacer una rotación de logs, el arhivo de
configuración se encuentra en /etc/logrotate.conf, pero….
pág. 272

Que es Logrotate?
Los logs o ficheros de registro están pensados para guardar la información de las actividades del
sistema. Estos ficheros pueden crecer hasta llenar la partición donde se encuentran y bloquear
el sistema, pero tienen muchísimos usos y son algo imprescindible, ya que con la experiencia
nos aportan una inmensa cantidad de información.
Hoy vamos a ver una herramienta llamada logrotate, encargada de rotar estos ficheros y más
características interesantes para poderlos gestionar con facilidad y tener un control casi
completo sobre ellos. Es importante conservar durante un tiempo bastante largo esta
información, de ahí que “rotemos” los logs, ya que cada cierto tiempo o condiciones, se creará
un fichero sobre el que se escribirá y el que teníamos pasará a ser un histórico.
Sus datos nos proporcionan desde estadísticas, para a poder afinar el sistema, hasta información
de seguridad, como accesos no permitidos o lo que se ha hecho cuando se ha accedido ya que
mucha gente puede saber como acceder a un sistema leyendo un par de manuales en internet,
pero lo verdaderamente difícil es burlar estas pruebas para que no dejar huella, pues un buen
administrador de sistemas hace siempre un buen uso de estos ficheros y los suele monitorizar
para buscar fallos en sus sistema de cualquier tipo, tanto de configuración, como de accesos,
rendimiento y una larga lista más…
La ruta por defecto donde están los logs es /var/log que en muchos sistemas se suele montar en
un partición separada para que al llenarse, aunque no se puedan registrar mas logs el sistema
siga funcionando. En esa misma ruta los ficheros rotados tendrán una nomenclatura como :
secure
secure.1
secure.2
En donde el primero que no tiene número es sobre el que estamos escribiendo actualmente, el
siguiente secure.1 es el anterior, y el secure.2 es el anterior a secure.1 con lo que lo leemos del
más reciente al más viejo. Es importante saber que nunca se deben editar con editores de texto
como vi, nano, gedit y demás, podemos cometer algún fallo y borrar información, siempre con
herramientas para visualizarlo sin escritura, los más comunes son tail y less.
El fichero de configuración principal es /etc/logrotate.conf
cat /etc/logrotate.conf
pág. 273

De las entradas que nos salen tenemos estas:
weekly -> Por defecto se rotará cada semana, otras opciones son daily y monthly.
rotate 4 -> Cuanto tiempo se conservan los antiguos, por defecto son cuatro semanas, algunos
ficheros pueden ser muy importantes y que los conservemos todos.
create -> Para que se cree un fichero al rotar, en donde se guardará la información otra vez.
La configuración de este fichero es una principal, y luego como vemos tiene un include al
fichero /etc/logrotate.d
root@localhost# ls /etc/logrotate.d/
acpid mgetty samba tux conman named sa-update vsftpd.log cups ppp snmpd wpa_supplicant
httpd psacct squid yum kdm rpm syslog
En donde se encuentran más configuraciones específicas de servicios, es decir si por ejemplo
para cups pone monthly y en el logrotate.conf es weekly, siempre se tomará en cuenta lo
específico del servicio, de esa forma al ser modular tiene una configuración sencilla pero muy
buena. Es importante saber que en esta ruta se ejecuta todo con lo que hay que tener cuidado
de lo que dejamos aqui.
pág. 274

Otras opciones interesantes para poner son:

Compress -> Hace que logrotate comprima los ficheros de registro para ahorrar espacio,
size -> Los ruta cuando el tamaño máximo de un fichero sea la cantidad que se ponga, en
formato size 4096k , size 256M.
prerotate/postrotate -> antes o después de rotar, puede hacer alguna acción como ejecutar un
script o unos comandos.
Al rotar los logs los iria renombrando añadiendo números.

De momento esto es todo, espero que os haya gustado esta magnífica herramienta
imprescindible para un administrador Linux.
REJECT — Envia un paquete de error de vuelta al sistema remoto y deja caer el paquete.
El objetivo REJECT acepta --reject-with <tipo> (donde <tipo> es el tipo de rechazo) el cual
permite devolver información más detallada con el paquete de error. El mensajeport-
unreachable es el <tipo> de error por defecto dado si no se usa otra opción. Para una lista
completa de los <tipo>s de opciones que se pueden usar, consulte la página del manual
de iptables.
Otras extensiones de objetivos, incluyendo muchas que son útiles para el enmascaramiento de
IP usando la tabla nat o con alteración de paquetes usando la tabla mangle, se puede encontrar
en la página del manual de iptables.

Opciones de listado
El comando predeterminado para listar, iptables -L, proporciona una vista muy básica de los
filtros por defecto de las cadenas actuales de la tabla. Las opciones adicionales proporcionan
más información:
-v — Muestra la salida por pantalla con detalles, como el número de paquetes y bytes que
cada cadena ha visto, el número de paquetes y bytes que cada regla ha encontrado y qué
interfaces se aplican a una regla en particular.
-x Expande los números en sus valores exactos. En un sistema ocupado, el número de
paquetes y bytes vistos por una cadena en concreto o por una regla puede estar abreviado
usando K (miles), M (millones), y G (billones) detrás del número. Esta opción fuerza a que
se muestre el número completo.
pág. 275

-n Muestra las direcciones IP y los números de puertos en formato numérico, en lugar de

utilizar el nombre del servidor y la red tal y como se hace por defecto.
--line-numbers — Proporciona una lista de cada cadena junto con su orden numérico en la
cadena. Esta opción puede ser útil cuando esté intentando borrar una regla específica en
una cadena o localizar dónde insertar una regla en una cadena.
-t — Especifica un nombre de tabla.
Guardar reglas iptables
Las reglas creadas con el comando iptables son almacenadas en memoria. Si el sistema es
reiniciado antes de guardar el conjunto de reglas iptables, se perderán todas las reglas. Para que
las reglas de filtrado de red persistan luego de un reinicio del sistema, estas necesitan ser
guardadas. Para hacerlo, conéctese como root y escriba:
#/sbin/service iptables save
Esto ejecuta el script de inicio iptables, el cual ejecuta el programa /sbin/iptables-save y escribe
la configuración actual de iptables a /etc/sysconfig/iptables. El
archivo /etc/sysconfig/iptables existente es guardado como /etc/sysconfig/iptables.save.
La próxima vez que se inicie el sistema, el script de inicio de iptables volverá a aplicar las reglas
guardadas en /etc/sysconfig/iptables usando el comando /sbin/iptables-restore.
Aun cuando siempre es una buena idea probar una regla de iptables antes de confirmar los
cambios al archivo /etc/sysconfig/iptables, es posible copiar reglas iptables en este archivo
desde otra versión del sistema de este archivo. Esto proporciona una forma rápida de distribuir
conjuntos de reglas iptables a muchas máquinas.
Scripts de control de iptables
Hay dos métodos básicos para controlar iptables:

Herramienta de configuración de nivel de seguridad (system-config-securitylevel) — Una
interfaz gráfica para crear, activar y guardar reglas básicas de cortafuegos.
/sbin/service iptables <opcion> — Un comando ejecutado por el usuario root capaz de
activar, desactivar y llevar a cabo otras funciones de iptables a través de su script de inicio.
Reemplace <opcion> en el comando con alguna de las directivas siguientes:
start — Si se tiene un cortafuegos o firewall (es decir, /etc/sysconfig/iptables existe), todos
los iptables en ejecución son detenidos completamente y luego arrancados usando el
comando /sbin/iptables-restore. La directriz start sólo funcionará si no se carga el módulo
del kernel ipchains.
pág. 276

stop — Si el cortafuegos está en ejecución, se descartan las reglas del cortafuegos que se
encuentran en memoria y todos los módulos iptables y ayudantes son descargados.
Si se cambia la directiva IPTABLES_SAVE_ON_STOP dentro del archivo de
configuración /etc/sysconfig/iptables-config de su valor por defecto a yes, se guardan las
reglas actuales a /etc/sysconfig/iptables y cualquier regla existente se moverá al
archivo /etc/sysconfig/iptables.save.
restart — Si el cortafuegos está en ejecución, las reglas del mismo que se encuentran en
memoria se descartan y se vuelva a iniciar el cortafuegos si está configurado
en/etc/sysconfig/iptables. La directriz restart sólo funcionará si no está cargado el módulo
del kernel ipchains.
Si la directiva IPTABLES_SAVE_ON_RESTART dentro del archivo de
configuración /etc/sysconfig/iptables-config se cambia de su valor por defecto a yes, las
reglas actuales son guardadas a /etc/sysconfig/iptables y cualquier regla existente se
moverán al archivo /etc/sysconfig/iptables.save.
status — Imprime el estado del cortafuegos una lista de todas las reglas activas al indicador
de comandos. Si no se cargan o configuran reglas del cortafuegos, también indica este
hecho.
Una lista de las reglas activas, conteniendo direcciones IP dentro de listas de reglas a
menos que el valor por defecto para IPTABLES_STATUS_NUMERIC sea cambiado
ano dentro del archivo de configuración /etc/sysconfig/iptables-config.
panic — Descarta todas las reglas del cortafuegos. La política de todas las tablas
configuradas está establecida a DROP.
save — Guarda las reglas del cortafuegos a /etc/sysconfig/iptables usando iptables-save.

Archivo de configuración de scripts de control de iptables
El comportamiento de los scripts de inicio de iptables es controlado por el archivo de
configuración /etc/sysconfig/iptables-config. A continuación se presenta una lista de las
directivas contenidas dentro de este archivo:
IPTABLES_MODULES — Especifica una lista separada por espacios de
módulos iptables adicionales a cargar cuando se activa un cortafuegos. Esto puede incluir
seguimiento de conexiones y ayudantes NAT.
IPTABLES_MODULES_UNLOAD — Limpia los módulos al iniciar o detenerse. Esta directiva
acepta los valores siguientes:
pág. 277

yes — El valor por defecto. Esta regla se debe configurar para que alcance un estado
correcto para el inicio o parada del cortafuegos.
no — Esta opción solamente debería ser configurada si hay problemas para limpiar los
módulos de filtrado de paquetes de red.
IPTABLES_SAVE_ON_STOP — Guarda las reglas del cortafuegos actuales
a /etc/sysconfig/iptables cuando se detiene el cortafuegos. Esta directiva acepta los
valores siguientes:
yes — Guarda las reglas existentes a /etc/sysconfig/iptables cuande se detiene el
cortafuegos, moviendo la versión anterior al archivo/etc/sysconfig/iptables.save.
no — El valor por defecto. No guarda las reglas existentes cuando se detiene el
cortafuegos.
IPTABLES_SAVE_ON_RESTART — Guarda las reglas actuales del cortafuegos cuando este se
reinicia. Esta directiva acepta los valores siguientes:
yes — Guarda las reglas existentes a /etc/sysconfig/iptables cuando se reinicia el
cortafuegos, moviendo la versión anterior al archivo/etc/sysconfig/iptables.save.
no — El valor por defecto. No guarda las reglas existentes cuando se reinicia el
cortafuegos.
IPTABLES_SAVE_COUNTER — Guarda y restaura todos los paquetes y contadores de bytes
en todas las cadenas y reglas. Esta directiva acepta los valores siguientes:
yes — Guarda los valores del contador.
no — El valor por defecto. No guarda los valores del contador.
IPTABLES_STATUS_NUMERIC — Muestra direcciones IP en una salida de estado en vez de
dominios y nombres de host. Esta directiva acepta los valores siguientes:
yes — El valor por defecto. Solamente devuelve direcciones IP dentro de una salida de
estado.
no — Devuelve dominios o nombres de host en la salida de estado.
SELinux
Security-Enhanced Linux o SELinux, es una arquitectura de seguridad integrada en el kernel
2.6.x usando los módulos de seguridad linux (o linux security modules, LSM). Este es un proyecto
de la Agencia de Seguridad Nacional (NSA) de los Estados Unidos y de la comunidad SELinux. La
integración de SELinux en Red Hat Enterprise Linux fue un esfuerzo conjunto entre al NSA y Red
Hat.
pág. 278

Introducción a SELinux
SELinux proporciona un sistema flexible de control de acceso obligatorio (mandatory access
control, MAC) incorporado en el kernel. Bajo el Linux estándar se utiliza el control de acceso a
discreción (discretionary access control, DAC), en el que un proceso o aplicación ejecutándose
como un usuario (UID o SUID) tiene los permisos y de ese usuario en los objetos, archivos,
zócalos y otros procesos. Al ejecutar un kernel SELinux MAC se protege al sistema de
aplicaciones maliciosas o dañadas que pueden perjudicar o destruir el sistema. SELinux define el
acceso y los derechos de transición de cada usuario, aplicación, proceso y archivo en el sistema.
SELinux gobierna la interacción de estos sujetos y objetos usando una política de seguridad que
especifica cuán estricta o indulgente una instalación de Red Hat Enterprise Linux dada debería
de ser.
En su mayor parte, SELinux es casi invisible para la mayoría de los usuarios. Solamente los
administradores de sistemas se deben de preocupar sobre lo estricto que debe ser una política a
implementar en su entorno de servidores. La política puede ser tan estricta o tan indulgente
como se requiera, y es bastante detallada. Este detalle le da al kernel SELinux un control total y
granular sobre el sistema completo.
Cuando un sujeto, tal como una aplicación, intenta acceder a un objeto tal como a un archivo, el
servidor de aplicación de políticas verifica un caché de vector de acceso (AVC), donde se
registran los permisos de objeto y del sujeto. Si no se puede tomar una decisión basado en los
datos en el AVAC, la petición continua al servidor de seguridad, el cual busca el contexto de
seguridad de la aplicación y del archivo en una matriz. Los permisos son entonces otorgados o
negados, con un mensaje deavc: denied detallado en /var/log/messages. Los sujetos y objetos
reciben su contexto de seguridad a partir de la política instalada, que también proporciona
información para llenar la matriz de seguridad del servidor.
Además de ejecutarse en un modo impositivo, SELinux puede ejecutarse en un modo permisivo,
donde el AVC es verificado y se registran los rechazos, pero SELinux no hace cumplir esta
política.
Archivos relacionados con SELinux

Las secciones siguientes describen los archivos de configuración y sistemas de archivos
relacionados con SELinux.
El pseudo sistema de archivos /selinux/
El pseudo-sistema de archivos /selinux/ contiene los comandos que son utilizados más a
menudo por el subsistema del kernel. Este tipo de sistema de archivos es similar al pseudo
sistema /proc/.
pág. 279

En la mayoría de los casos, los administradores y usuarios no necesitan manipular este

componente, en comparación con otros archivos y directorios SELinux.
El ejemplo siguiente presenta contenidos de muestra del directorio /selinux/:
-rw-rw-rw- 1 root root 0 Sep 22 13:14 access

dr-xr-xr-x 1 root root 0 Sep 22 13:14 booleans
--w------- 1 root root 0 Sep 22 13:14 commit_pending_bools
-rw-rw-rw- 1 root root 0 Sep 22 13:14 context
-rw-rw-rw- 1 root root 0 Sep 22 13:14 create
--w------- 1 root root 0 Sep 22 13:14 disable
-rw-r--r-- 1 root root 0 Sep 22 13:14 enforce
-rw------- 1 root root 0 Sep 22 13:14 load
-r--r--r-- 1 root root 0 Sep 22 13:14 mls
-r--r--r-- 1 root root 0 Sep 22 13:14 policyvers
-rw-rw-rw- 1 root root 0 Sep 22 13:14 relabel
-rw-rw-rw- 1 root root 0 Sep 22 13:14 user

Por ejemplo, al ejecutar el comando cat en el archivo enforce revela un 1, para el modo
impositivo, o un 0, para el modo permisivo.
Archivos de configuración de SELinux

Las secciones siguientes describen los archivos de configuración y de políticas para SELinux, y los
sistemas de archivos relacionados localizados en el directorio /etc/.
El archivo de configuración /etc/sysconfig/selinux

Hay dos formas de configurar SELinux bajo Red Hat Enterprise Linux: usando el Herramienta de
configuración de nivel de seguridad (system-config-securitylevel), o manualmente editando el
archivo de configuración (/etc/sysconfig/selinux).
El archivo /etc/sysconfig/selinux es el archivo de configuración principal para habilitar o
inhabilitar SELinux, así como también para configurar cuál política de debe imponer en el
sistema y cómo hacerlo.
pág. 280

A continuación se explica el subconjunto completo de opciones disponibles para la

configuración:
SELINUX=<enforcing|permissive|disabled> — Define el estado superior para SELinux en un
sistema.
enforcing o 'impositivo' — Se impone la política de seguridad SELinux.
permissive o 'permisivo' — El sistema SELinux advierte pero no impone la política. Esto es
útil para propósitos de depuración o de resolución de problemas. En modo permisivo, se
registrarán más rechazos, pues los sujetos podrán continuar con acciones que de lo
contrario serían rechazadas en el modo impositivo. Por ejemplo, navegar en un árbol de
directorios producirá varios mensajes de avc: denied para cada nivel de directorio leído,
pero un kernel en modo impositivo habría detenido la primera acción de este tipo,
previniendo que se produjeran más mensajes de rechazo.
SELINUXTYPE=<targeted|strict> — Especifica cuál política está siendo implantada
actualmente por SELinux.
targeted (objetivo) — Solamente se protegen ciertos demonios particulares. La imposición
de políticas para estos demonios se puede activar y desactivar, utilizando valores boléanos
controlados por Herramienta de configuración de nivel de seguridad (system-config-
securitylevel). Al activar un valor boleano para un demonio objetivo se desactiva la
transición de políticas para ese demonio, lo que previene, por ejemplo, que init pase
a dhcpd desde el dominio unconfined_t (ilimitado) al dominio especificado en dhcpd.te. El
dominio unconfined_t permite a los sujetos y objetos con ese contexto de seguridad a
ejecutarse bajo la seguridad estándar de Linux.
strict (estricta) — Protección SELinux completa, para todos los demonios. Se definen los
contextos de seguridad para todos los sujetos y objetos y cada simple acción es procesada
por el servidor de aplicación de políticas.

El directorio /etc/selinux/
El directorio /etc/selinux/ es la ubicación principal para todos los archivos de políticas así
como también para el archivo de configuración principal.
El ejemplo siguiente presenta contenidos de muestra del directorio /etc/selinux/:
-rw-r--r-- 1 root root 448 Sep 22 17:34 config
drwxr-xr-x 5 root root 4096 Sep 22 17:27 strict
drwxr-xr-x 5 root root 4096 Sep 22 17:28 targeted
pág. 281

Los dos subdirectorios, strict/ y targeted/, son los directorios específicos donde se contienen los
archivos de políticas del mismo nombre (por ejemplo, strict y targeted).
Para más información sobre las políticas de SELinux y su configuración, consulte el Guía para
escribir políticas SELinux de Red Hat.
Utilidades para SELinux

Los siguientes son algunos de los programas de utilidades usados más a menudo por SELinux
/usr/bin/setenforce — Modifica en tiempo real el modo en que se ejecuta SELinux. Al
ejecutar setenforce 1, se coloca SELinux en modo impositivo. Al ejecutar setenforce 0,
SELinux se coloca en modo permisivo. Para desactivar SELinux, se necesita que configure el
parámetro en /etc/sysconfig/selinux o que pase el parámetro selinux=0 al kernel, bien sea
en /etc/grub.conf o al momento del arranque.
/usr/bin/sestatus -v — obtiene el estado detallado de un sistema ejecutando SELinux. El
ejemplo siguiente muestra un extracto de la salida sestatus:

SELinux status: enabled
SELinuxfs mount: /selinux
Current mode: enforcing
Policy version: 18

/usr/bin/newrole — Ejecuta un nuevo shell en un nuevo contexto o papel. La política debe
permitir la transición al nuevo papel.
/sbin/restorecon — Configura el contexto de seguridad de uno o más archivos, marcando
los atributos extendidos con el archivo apropiado o contexto de seguridad.
/sbin/fixfiles — Verifica o corrige la base de datos del contexto de seguridad en el sistema
de archivos.
Consulte la página man asociada con estas utilidades para más información.
Para más información sobre todas las utilidades binarias disponibles, refiérase a los contenidos
del paquete setools opolicycoreutils, ejecutando rpm -ql <package-name>, donde <package-
name> es el nombre del paquete específico.

pág. 282

SSH
SSH™ (o Secure SHell) es un protocolo que facilita las comunicaciones seguras entre dos
sistemas usando una arquitectura cliente/servidor y que permite a los usuarios conectarse a un
host remotamente. A diferencia de otros protocolos de comunicación remota tales como FTP o
Telnet, SSH encripta la sesión de conexión, haciendo imposible que alguien pueda obtener
contraseñas no encriptadas.
SSH está diseñado para reemplazar los métodos más viejos y menos seguros para registrarse
remotamente en otro sistema a través de la shell de comando, tales como telnet o rsh. Un
programa relacionado, el scp, reemplaza otros programas diseñados para copiar archivos entre
hosts como rcp. Ya que estas aplicaciones antiguas no encriptan contraseñas entre el cliente y el
servidor, evite usarlas mientras le sea posible. El uso de métodos seguros para registrarse
remotamente a otros sistemas reduce los riesgos de seguridad tanto para el sistema cliente
como para el sistema remoto.
Seguridad
SSH trabaja de forma similar a como se hace con telnet. La diferencia principal es que SSH usa
técnicas de cifrado que hacen que la información que viaja por el medio de comunicación vaya
de manera no legible, evitando que terceras personas puedan descubrir el usuario y contraseña
de la conexión ni lo que se escribe durante toda la sesión; aunque es posible atacar este tipo de
sistemas por medio de ataques de REPLAY y manipular así la información entre destinos.
Historia
Al principio sólo existían los r-commands, que eran los basados en el programa rlogin, el cual
funciona de una forma similar a telnet.
La primera versión del protocolo y el programa eran libres y los creó un finlandés llamado Tatu
Ylönen, pero su licencia fue cambiando y terminó apareciendo la compañía SSH
Communications Security, que lo ofrecía gratuitamente para uso doméstico y académico, pero
exigía el pago a otras empresas. En el año 1997 (dos años después de que se creara la primera
versión) se propuso como borrador en la IETF.
A principios de 1999 se empezó a escribir una versión que se convertiría en la implementación
libre por excelencia, la de OpenBSD, llamada OpenSSH.
Versiones
Existen 2 versiones de SSH, la versión 1 de SSH hace uso de muchos algoritmos de cifrado
patentados (sin embargo, algunas de estas patentes han expirado) y es vulnerable a un agujero
de seguridad que potencialmente permite a un intruso insertar datos en la corriente de
comunicación. La suite OpenSSH bajo Red Hat Enterprise Linux utiliza por defecto la versión 2 de
pág. 283

SSH, la cual tiene un algoritmo de intercambio de claves mejorado que no es vulnerable al

agujero de seguridad en la versión 1. Sin embargo, la suite OpenSSH también soporta las
conexiones de la versión 1.

Características de SSH
El protocolo SSH proporciona los siguientes tipos de protección:
Después de la conexión inicial, el cliente puede verificar que se está conectando al mismo
servidor al que se conectó anteriormente.
El cliente transmite su información de autenticación al servidor usando una encriptación
robusta de 128 bits.
Todos los datos enviados y recibidos durante la sesión se transfieren por medio de
encriptación de 128 bits, lo cual los hacen extremamente difícil de descifrar y leer.
El cliente tiene la posibilidad de reenviar aplicaciones X11 desde el servidor. Esta técnica,
llamada reenvío por X11, proporciona un medio seguro para usar aplicaciones gráficas
sobre una red.
Ya que el protocolo SSH encripta todo lo que envía y recibe, se puede usar para asegurar
protocolos inseguros. El servidor SSH puede convertirse en un conducto para convertir en
seguros los protocolos inseguros mediante el uso de una técnica llamada reenvío por puerto,
como por ejemplo POP, incrementando la seguridad del sistema en general y de los datos.
Red Hat Enterprise Linux contiene el paquete general de OpenSSH (openssh) así como también
los paquetes del servidor OpenSSH (openssh-server) y del cliente (openssh-clients). Observe que
los paquetes OpenSSH requieren el paquete OpenSSL (openssl). OpenSSL instala varias
bibliotecas criptográficas importantes, permitiendo que OpenSSH pueda proporcionar
comunicaciones encriptadas.
¿Por qué usar SSH?
Los usuario nefarios tienen a su disposición una variedad de herramientas que les permiten
interceptar y redirigir el tráfico de la red para ganar acceso al sistema. En términos generales,
estas amenazas se pueden catalogar del siguiente modo:
Intercepción de la comunicación entre dos sistemas — En este escenario, existe un tercero
en algún lugar de la red entre entidades en comunicación que hace una copia de la
información que pasa entre ellas. La parte interceptora puede interceptar y conservar la
información, o puede modificar la información y luego enviarla al recipiente al cual estaba
destinada.
pág. 284

Este ataque se puede montar a través del uso de un paquete sniffer — una utilidad de red
muy común.
Personificación de un determinado host — Con esta estrategia, un sistema interceptor
finge ser el recipiente a quien está destinado un mensaje. Si funciona la estrategia, el
sistema del usuario no se da cuenta del engaño y continúa la comunicación con el host
incorrecto.
Esto se produce con técnicas como el envenenamiento del DNS o spoofing de IP (engaño
de direcciones IP).
Ambas técnicas interceptan información potencialmente confidencial y si esta intercepción se
realiza con propósitos hostiles, el resultado puede ser catastrófico.
Si se utiliza SSH para inicios de sesión de shell remota y para copiar archivos, se pueden
disminuir estas amenazas a la seguridad notablemente. Esto es porque el cliente SSH y el
servidor usan firmas digitales para verificar su identidad. Adicionalmente, toda la comunicación
entre los sistemas cliente y servidor es encriptada. No servirán de nada los intentos de falsificar
la identidad de cualquiera de los dos lados de la comunicación ya que cada paquete está cifrado
por medio de una llave conocida sólo por el sistema local y el remoto.
Secuencia de eventos de una conexión SSH
La siguiente serie de eventos lo ayudan a proteger la integridad de la comunicación SSH entre

dos host.
Se lleva a cabo un 'handshake' (apretón de manos) encriptado para que el cliente pueda
verificar que se está comunicando con el servidor correcto.
La capa de transporte de la conexión entre el cliente y la máquina remota es encriptada
mediante un código simétrico.
El cliente se autentica ante el servidor.
El cliente remoto interactúa con la máquina remota sobre la conexión encriptada.

SSH-Agent permite recordar mientras dure la sesión, cada una de las claves privadas del
usuario, de modo que él se encargue de realizar la autenticación.
En cualquier ambiente informático, donde se requiera trabajar con múltiples servidores, es
necesario contar con una comunicación segura como SSH. Para conectarse a un servidor
remoto, basta con teclear el comando seguido del usuario y host destino, y de la contraseña del
usuario remoto en cuestión. Este proceso de login en máquinas remotas puede ser molesto en
pág. 285

los casos en que sea necesario realizar conexiones cada poco período de tiempo, debido a que
hay que ingresar la contraseña cada vez.
De igual manera, cuando se desean utilizar discos remotos, puede ser beneficioso (sobre todo
para los usuarios) que dichos discos sean montados automáticamente al momento de login, y
que puedan ser utilizados transparentemente por los usuarios. Con este fin fue creado el ssh-
agent.
Capa de transporte
El papel principal de la capa de transporte es facilitar una comunicación segura entre los dos
hosts durante la autenticación yla subsecuente comunicación. La capa de transporte lleva esto a
cabo manejando la encriptación y decodificación de datos y proporcionando protección de
integridad de los paquetes de datos mientras son enviados y recibidos. Además, la capa de
transporte proporciona compresión de datos, lo que acelera la transmisión de información.
Al contactar un cliente a un servidor por medio del protocolo SSH, se negocian varios puntos
importantes para que ambos sistemas puedan construir la capa de transporte correctamente.
Durante el intercambio se producen los siguientes pasos:
Intercambio de claves
Se determina el algoritmo de encriptación de la clave pública
Se determina el algoritmo de la encriptación simétrica
Se determina el algoritmo autenticación de mensajes
Se determina el algoritmo de hash que hay que usar
Durante la primera fase, el cliente y el servidor negocian qué algoritmos criptográficos se van a
usar. Las implementaciones actuales proporcionan las siguientes opciones:
Para criptografía de clave pública: RSA, Diffie-Hellman, DSA (Digital Signature Algorithm)
o Fortezza.
Para cifrado simétrico: RC2, RC4, IDEA (International Data Encryption Algorithm), DES (Data
Encryption Standard), Triple DES y AES (Advanced Encryption Standard).
Para este cifrado se utiliza la misma llave para encriptar y para desencriptar.
Con funciones hash: MD5 o de la familia SHA.

pág. 286

El servidor se identifica ante el cliente con una llave de host única durante el intercambio de
llaves. Obviamente si este cliente nunca se había comunicado antes con este determinado
servidor, la llave del servidor le resultará desconocida al cliente y no lo conectará. OpenSSH
evita este problema permitiendo que el cliente acepte la llave del host del servidor después que
el usuario es notificado y verifica la aceptación de la nueva llave del host. Para las conexiones
posteriores, la llave del host del servidor se puede verificar con la versión guardada en el cliente,
proporcionando la confianza de que el cliente se está realmente comunicando con el servidor
deseado. Si en el futuro, la llave del host ya no coincide, el usuario debe eliminar la versión
guardada antes de que una conexión pueda ocurrir.
SSH fue ideado para funcionar con casi cualquier tipo de algoritmo de clave pública o formato
de codificación. Después del intercambio de claves inicial se crea un valor hash usado para el
intercambio y un valor compartido secreto, los dos sistemas empiezan inmediatamente a
calcular claves y algoritmos nuevos para proteger la autenticación y los datos que se enviarán a
través de la conexión en el futuro.
Después que una cierta cantidad de datos haya sido transmitida con un determinado algoritmo
y clave (la cantidad exacta depende de la implementación de SSH), ocurre otro intercambio de
claves, el cual genera otro conjunto de valores de hash y un nuevo valor secreto compartido. De
esta manera aunque un agresor lograse determinar los valores de hash y de secreto compartido,
esta información sólo será válida por un período de tiempo limitado.
Autenticación
Cuando la capa de transporte haya construido un túnel seguro para transmitir información entre
los dos sistemas, el servidor le dirá al cliente de los diferentes métodos de autenticación
soportados, tales como el uso de firmas privadas codificadas con claves o la inserción de una
contraseña. El cliente entonces intentará autenticarse ante el servidor mediante el uso de
cualquiera de los métodos soportados.
Los servidores y clientes SSH se pueden configurar para que permitan varios tipos de
autenticación, lo cual le concede a cada lado la cantidad óptima de control. Luego el servidor
podrá decidir qué métodos de encriptación soportará basado en su pauta de seguridad, y el
cliente puede elegir el orden en que intentará utilizar los métodos de autenticación entre las
opciones a disposición. Gracias a la naturaleza segura de la capa de transporte de SSH, hasta
métodos de autenticación que parecen inseguros, como la autenticación basada en contraseñas,
son en realidad seguros para usar.
Cuando se conecta a un servidor ssh con su cliente ssh , se compara la clave pública del servidor
pág. 287

a las claves almacenadas en un archivo en el equipo cliente , esta conexión se logra mediante el
archivo known_hosts.
Canales
Luego de una autenticación exitosa sobre la capa de transporte SSH, se abren
múltiples canales a través de la técnica llamada multiplexar. Cada uno de estos canales manejan
la conexión para diferentes sesiones de terminal y para sesiones de reenvió X11.
Ambos clientes y servidores pueden crear un canal nuevo. Luego se le asigna un número
diferente a cada canal en cada punta de la conexión. Cuando el cliente intenta abrir un nuevo
canal, los clientes envían el número del canal junto con la petición. Esta información es
almacenada por el servidor y usada para dirigir la comunicación a ese canal. Esto es hecho para
que diferentes tipos de sesión no afecten una a la otra y así cuando una sesión termine, su canal
pueda ser cerrado sin interrumpir la conexión SSH primaria.
Los canales también soportan el control de flujo, el cual les permite enviar y recibir datos
ordenadamente. De esta manera, los datos no se envían a través del canal sino hasta que el host
haya recibido un mensaje avisando que el canal está abierto y puede recibirlos.
El cliente y el servidor negocian las características de cada canal automáticamente, dependiendo
del tipo de servicio que el cliente solicita y la forma en que el usuario está conectado a la red.
Esto otorga una gran flexibilidad en el manejo de diferentes tipos de conexiones remotas sin
tener que cambiar la infraestructura básica del protocolo.
Instalacion y Configuracion:

Lo primero es instalar el servicio de ssh, esto lo realizaremos con el siguiente comando:
# yum –y install openssh-server openssh-client
Terminara una vez que nos mande la pantalla con el mensaje de instalación complete
pág. 288

Una vez realizado esto realizaremos una conexión de prueba, para esto necesitaremos
descargar un cliente de ssh de Windows, para lo cual nos dirigiremos a google y descargaremos
la aplicación llamada putty

Una vez descargado lo ejecutaremos:
pág. 289

Pondremos la ip de nuestro servidor:

Le daremos en open y cuando la conexión sea por primera vez nos mandara una alerta de
seguridad, y le daremos que “Si”

pág. 290

Validaremos con un usuario y un password valido, dentro del server:

Una vez realizado esto, estaremos en la consola como si estuviéramos en la terminal física,
pudiendo realizar cualquier tarea desde el cliente.

Con exit podremos cerrar la sesión cuando ya no sea necesaria.
pág. 291

FTP
El Protocolo de transferencia de archivos (FTP) es uno de los protocolos más viejos y populares
que se encuentran en la Internet hoy día. Su objetivo es el de transmitir archivos exitosamente
entre máquinas en una red sin que el usuario tenga que iniciar una sesión en el host remoto o
que requiera tener conocimientos sobre cómo utilizar el sistema remoto. FTP permite a los
usuarios acceder a archivos en sistemas remotos usando un conjunto de comandos estándar
muy simples.
Este capítulo describe los elementos básicos de este protocolo, así como también las opciones
de configuración para el servidor FTP primario que se entrega con Red Hat Enterprise
Linux, vsftpd.
El Protocolo de Transferencia de Archivos

FTP utiliza una arquitectura cliente/servidor para transferir archivos usando el protocolo de red
TCP. Puesto que FTP es un protocolo más antiguo, no utiliza una autenticación de usuarios y
contraseña encriptada. Por esta razón, se considera un protocolo inseguro y no se debería
utilizar a menos que sea absolutamente necesario. sftp, del conjunto de herramientas OpenSSH,
es un buen sustituto para FTP.
Sin embargo, puesto que FTP está tan extendido en la Internet, se requiere a menudo para
compartir archivos con el público. Por lo tanto, los administradores de sistemas deberían estar
conscientes de las características únicas del protocolo FTP.
pág. 292

Puertos múltiples, modos múltiples

A diferencia de la mayoría de los protocolos utilizados en Internet, FTP requiere de múltiples
puertos de red para funcionar correctamente. Cuando una aplicación cliente FTP inicia una
conexión a un servidor FTP, abre el puerto 21 en el servidor — conocido como el puerto de
comandos. Se utiliza este puerto para arrojar todos los comandos al servidor. Cualquier petición
de datos desde el servidor se devuelve al cliente a través del puerto de datos. El número de
puerto para las conexiones de datos y la forma en la que las conexiones son inicializadas varía
dependiendo de si el cliente solicita los datos en modo activo o en modo pasivo.
A continuación se describen estos modos:

Modo activo
El modo activo es el método original utilizado por el protocolo FTP para la transferencia de
datos a la aplicación cliente. Cuando el cliente FTP inicia una transferencia de datos, el servidor
abre una conexión desde el puerto 20 en el servidor para la dirección IP y un puerto aleatorio sin
privilegios (mayor que 1024) especificado por el cliente. Este arreglo implica que la máquina
cliente debe poder aceptar conexiones en cualquier puerto superior al 1024. Con el crecimiento
de las redes inseguras, tales como Internet, es muy común el uso de cortafuegos para proteger
las máquinas cliente. Debido a que estos cortafuegos en el lado del cliente normalmente
rechazan las conexiones entrantes desde servidores FTP en modo activo, se creó el modo
pasivo.
Modo pasivo
La aplicación FTP cliente es la que inicia el modo pasivo, de la misma forma que el modo activo.
El cliente FTP indica que desea acceder a los datos en modo pasivo y el servidor proporciona la
dirección IP y el puerto aleatorio, sin privilegios (mayor que 1024) en el servidor. Luego, el
cliente se conecta al puerto en el servidor y descarga la información requerida.
Mientras que el modo pasivo resuelve el problema de la interferencia del cortafuegos en el lado
del cliente con las conexiones de datos, también puede complicar la administración del
cortafuegos del lado del servidor. Una de las formas de limitar el número de puertos abiertos en
el servidor y de simplificar la tarea de crear reglas para el cortafuegos del lado del servidor, es
limitando el rango de puertos sin privilegios ofrecidos para las conexiones pasivas.
pág. 293

Servidores FTP
Red Hat Enterprise Linux se entrega con dos servidores FTP diferentes:
Acelerador de Contenidos Red Hat — Un servidor Web basado en el kernel que ofrece un
servidor web y servicios FTP de alto rendimiento. Puesto que la velocidad es su objetivo
principal de diseño, su funcionalidad es limitada y solamente se ejecuta como FTP
anónimo.
vsftpd — un demonio FTP rápido y seguro, preferido para Red Hat Enterprise Linux. El
resto de este capítulo se enfoca en vsftpd.
Vsftpd
El demonio FTP vsftpd (o Very Secure FTP Daemon) está diseñado desde la base para ser rápido,
estable y lo más importante, seguro. Su habilidad para manejar grandes números de conexiones
de forma eficiente y segura es lo que hace que vsftpd sea el único FTP independiente distribuido
con Red Hat Enterprise Linux.
El modelo de seguridad utilizado por vsftpd tiene tres aspectos principales:
Clara separación de procesos privilegiados y sin privilegios — Procesos separados manejan
tareas diferentes y cada uno de estos procesos se ejecuta con los privilegios mínimos
requeridos para la tarea.
Las tareas que requieren altos privilegios son manejadas por procesos con los mínimos
privilegios necesarios — Influenciando las compatibilidades encontradas en la biblioteca
libcap, las tareas que usualmente requieren privilegios de súper usuario se pueden
ejecutar de forma más segura desde un proceso menos privilegiado.
La mayoría de los procesos se ejecutan enjaulados en un ambiente chroot — Siempre que
sea posible, se cambia la raíz de los procesos al directorio compartido; este directorio se
considera luego como la jaula chroot. Por ejemplo, si el directorio /var/ftp/ es el directorio
compartido principal, vsftpd reasigna /var/ftp/ al nuevo directorio raíz, conocido como /.
Esto previene actividades maliciosas de cualquier hacker potencial en algún directorio que
no estén por debajo del nuevo directorio root.
El uso de estas prácticas de seguridad tiene el efecto siguiente en cómo vsftpd trata con las
peticiones:
El proceso padre se ejecuta con el mínimo de privilegios requerido — El proceso padre
calcula dinámicamente el nivel de privilegios requerido para minimizar el nivel de riesgos.
Los procesos hijo manejan la interacción directa con los clientes FTP y se ejecutan casi sin
ningún privilegio.
Todas las operaciones que requieren altos privilegios son manejadas por un pequeño
proceso padre — Similar a Servidor Apache HTTP, vsftpd lanza procesos hijos sin privilegios
pág. 294

para manejar las conexiones entrantes. Esto permite al proceso padre privilegiado, ser tan
pequeño como sea posible y manejar relativamente pocas tareas.
El proceso padre no confía en ninguna de las peticiones desde procesos hijos sin
privilegios — Las comunicaciones con procesos hijos se reciben sobre un socket y la validez
de cualquier información desde un proceso hijo es verificada antes de proceder.
La mayor parte de la interacción con clientes FTP la manejan procesos hijo sin privilegios
en una jaula chroot. — Debido a que estos procesos hijo no tienen privilegios y solamente
tienen acceso al directorio que está siendo compartido, cualquier proceso fallido
solamente permitirá al atacante acceder a los archivos compartidos.
Archivos instalados con vsftpd
El RPM vsftpd instala el demonio (/usr/sbin/vsftpd), su archivo de configuración y otros archivos
relacionados, así como también directorios FTP en el sistema. La siguiente es una lista de los
archivos y directorios considerados más a menudo cuando se configura vsftpd:
/etc/rc.d/init.d/vsftpd — El script de inicialización (initscript) utilizado por el
comando /sbin/service para iniciar, detener o volver a cargar vsftpd.
/etc/pam.d/vsftpd — El archivo de configuración de los Pluggable Authentication Modules
(PAM) para vsftpd. Este archivo define los requerimientos que debe cumplir un usuario
para conectarse a un servidor FTP.
/etc/vsftpd/vsftpd.conf — El archivo de configuración para vsftpd.
/etc/vsftpd.ftpusers — Una lista de los usuarios que no tienen permitido conectarse
a vsftpd. Por defecto esta lista incluye a los usuarios root, bin y daemon, entre otros.
/etc/vsftpd.user_list — Este archivo se puede configurar para negar o permitir el acceso a
los usuarios listados, dependiendo de si la directriz userlist_deny está configurada
a YES (por defecto) o a NO en /etc/vsftpd/vsftpd.conf. Si se
utiliza /etc/vsftpd.user_list para permitir acceso a los usuarios, los nombres de usuarios
listados no deben aparecer en /etc/vsftpd.ftpusers.
El directorio /var/ftp/ — El directorio que contiene los archivos servidos por vsftpd.
También contiene el directorio /var/ftp/pub/ para los usuarios anónimos. Ambos
directorios están disponibles para la lectura de todos, pero sólo el superusuario o root
puede escribir en el.
pág. 295

Iniciar y detener vsftpd
El RPM vsftpd instala el script /etc/rc.d/init.d/vsftpd, al cual se puede acceder usando el

comando /sbin/service.

Para iniciar el servidor, escriba como usuario root, lo siguiente:
# /sbin/service vsftpd start
Para detener el servidor, como root escriba:
# /sbin/service vsftpd stop
La opción restart es un atajo para detener y volver a iniciar vsftpd. Esta es la forma más efectiva
para que los cambios de configuración tomen efecto luego de modificar el archivo de
configuración para vsftpd.
Para reiniciar el servidor, escriba como root:
# /sbin/service vsftpd restart
La opción condrestart (reinicio condicional) solamente arranca vsftpd si está ejecutándose en

ese momento. Esta opción es muy útil para scripts, puesto que no arranca el demonio si este no
se está ejecutando.
Para reiniciar el servidor de forma condicional, escriba como usuario root:
# /sbin/service vsftpd condrestart
Por defecto, el servicio vsftpd no se inicia automáticamente al momento del arranque. Para
configurar el servicio vsftpd para que se inicie al momento del arranque, utilice una utilidad
initscript, tal como /sbin/chkconfig, /sbin/ntsysv o el programa Herramienta de configuración de
servicios.
pág. 296

Intalacion y Configuracion de FTP.
Para comenzar primero instalaremos el servicio de ftp con el siguiente comando:
# yum –y install vsftpd ftp

La instalación estará completa cuando nos mande el mensaje de complete

Posterior a esto, nos dirigimos al archivo de configuración de ftp que está en la ruta
# vi /etc/vsftpd/vsftpd.conf
Verificaremos en el archivo que este activa la regla de permitir usuarios anónimos
anonymous_enable=YES
Para activarlo solo le quitamos el símbolo “#” para activarlo
Y la regla de enjaulamiento de usuarios locales:
chroot_local_user=YES
De igual manera lo activamos de ser necesario
Después, la regla de habilitar usuarios locales:
Local_enable=YES
Y por último la regla de escritura en server usando FTP:
write_enable=YES
Y guardamos los cambios.
pág. 297

Despues reiniciamos el servidor de Ftp:

# service vsftpd restart
Ahora nos cambiamos a la carpeta de ftp que da por defecto para los usuarios anónimos
# cd /var/ftp
Y Creamos una carpeta
# mkdir /var/ftp/ejemplo
Si se tiene un firewall instalado se deshabilita
# system-config-firewall
Ahora deshabilitamos SELINUX, para que los clientes puedan utilizar el servicio
# vi /etc/sysconfig/selinux

Reiniciamos el servicio de FTP
# service vsftpd restart
pág. 298

Una vez realizado esto modificaremos el archivo de host para indicar la dirección de nuestro
servidor ftp
# vi /etc/hosts

Ejecutaremos el siguiente comando para iniciar el servicio en todos los niveles
# chkconfig vsftpd on
Una vez realizado esto agregaremos la ip a las tablas para establecer los puertos de conexión
con los siguientes comandos:
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 20 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 30300:30309 -j ACCEPT
Guadamos los cambios en las tablas:
# service iptables save
Reiniciamos el servicio:
#service iptables restart
Otro paso importante es verificar que la carpeta local no está lista para ser validad por ftp:

Esto lo revisaremos con el siguiente comando
# getsebool –a | grep ftp
Esto nos desplegara una lista en la cual podremos ver que la opción ftp_home_dir estará en off,
pág. 299

esto quiere decir que cualquier usuario anónimo o asignado no podrá navegar en la carpeta
para ftp, por tal la activaremos con el siguiente comando:
# setsebool –P ftp_home_dir on
Esto podrá tardar algunos minutos, una vez realizado esto podremos verificar con el comando
anterior y nos deberá mostrar algo parecido a esto:

Ahora realizamos una prueba de conexión por FTP:
Este lo realizaremos utilizando un usuario anónimo por ejemplo:
USR: ftp
Passwd: ftp
Esto lo realizaremos desde el mismo servidor con el comando siguiente:
# ftp dirección del server
Nos deberá pedir el usuario y el password y colocaremos los antes mencionados:
pág. 300

Y después tendremos acceso a este:

Y si listamos el contenido podremos ver la carpeta antes creada, lo que indica que estamos
dentro del server:
pág. 301

Otra manera de verificar que hemos conseguido el acceso es hacerlo desde el navegador de
nuestro equipo de la siguiente forma:
Abriremos el navegador de internet de nuestro equipo y pondremos en la url la dirección de la
siguiente forma:
ftp://direccion del server

Y al presionar enter podremos ver el contenido antes mencionado
pág. 302

Ahora que ya hemos logrado la conexión con un usuario anónimos, realizaremos la
configuración para realizar una conexión más segura con un usuario asignado y que pida
autenticación, para esto procedemos a realizar lo siguiente:
Nos cambiamos a la carpeta de configuración de ftp y ahí crearemos un usuario
# cd /etc/vsftpd
Agregamos el usuario con el siguiente comando
# adduser adminftp
Y le asignamos una contraseña
# passwd adminftp
Después podremos realizar una prueba con autenticación de la misma manera que el el caso
anterior por línea de comando
pág. 303

Ponemos el password asignado

Y si listamos veremos que está vacía a diferencia de la prueba anterior
pág. 304

Para verificar la conexión por ftp con autenticación podremos realizarlo de manera gráfica
también de la siguiente forma:
En la Url ahora podremos validarnos pero de la siguiente manera
ftp://adminftp@direccion del servidor
Lo cual nos mandara una interface de la siguiente manera:

Validaremos con los datos que tenemos
pág. 305

Lo cual nos dará acceso y veremos que esta vacío pues en esta no tenemos archivo alguno.

De esta manera ya podríamos utilizar clientes ftp para poder subir o descargar archivos al
servidor, como FileZilla y muchos otros que están en el mercado.

Para subir o descargar archivos del servidor podríamos realizar una conexión desde el
explorador de Windows:
pág. 306

pág. 307

Y de esta forma esta implementado un servidor FTP.
Samba
Samba es una implementación de código abierto del protocolo Server Message Block (SMB).
Permite la interconexión de redes Microsoft Windows®, Linux, UNIX y otros sistemas operativos
juntos, permitiendo el acceso a archivos basados en Windows y compartir impresoras. El uso de
Samba de SMB lo hace parecer como un servidor Windows a clientes Windows.
Introducción a Samba
El tercer lanzamiento principal de Samba, versión 3.0.0, introduce varias mejoras con respecto a
las versiones previas, incluyendo:
La habilidad para unirse a un dominio Active Directory a través de LDAP y Kerberos
Soporte incorporado de Unicode para la internacionalización
Soporte para las conexiones de clientes Microsoft Windows XP Professional a servidores Samba
sin la necesidad de hacer hacking del registro local
Dos documentos desarrollados por el equipo de desarrollo Samba.org el cual incluye un manual
de referencia de más de 400 páginas y un manual de implementación e integración de más de
300 páginas.
pág. 308

Características de Samba
Samba es una aplicación de servidor poderosa y versátil. Hasta los administradores bien
empapados deben conocer sus habilidades y limitaciones antes de intentar una instalación y
configuración.
Lo que Samba puede hacer:
Sirve árboles de directorios e impresoras a clientes Linux, UNIX y Windows
Asiste en la navegación de la red (con o sin NetBIOS)
Autentifica las conexiones a dominios Windows
Proporciona resolución de nombres de Windows Internet Name Service (WINS)
Actúa como un Controlador de Dominio Primario (Primary Domain Controller, PDC) estilo
Windows NT®
Actúa como un Backup Domain Controller (BDC) para un PDC basado en Samba
Actúa como un miembro servidor de dominio de Active Directory
Une un Windows NT/2000/2003 PDC
Lo que Samba no puede hacer:
Actúa como un BDC para un Windows PDC (y viceversa)
Actúa como un controlador de dominio de Active Directory
Demonios Samba y Servicios relacionados
Lo siguientes es una breve introducción a los demonios individuales y servicios de Samba, así
como también detalles sobre cómo arrancarlos y detenerlos.
Descripción general de los demonios
Samba está compuesto por tres demonios (smbd, nmbd y winbindd). Dos servicios
(smb y windbind) controlan los demonios son detenidos arrancados y otras funcionalidades
relacionadas a servicios. Cada demonio se lista en detalle, así como también qué servicio
específico tiene control sobre él.
El demonio smbd
El demonio de servidor smbd suministra servicios para compartir archivos e impresión a clientes
Windows. Además, es responsable por la autenticación de usuarios, el bloqueo de recursos y
compartir datos a través del protocolo SMB. Los puertos predeterminados en los cuales el
servidor escucha por tráfico SMB, son los puertos TCP 139 y 445.
El demonio smbd es controlado por el servicio smb.
pág. 309

El demonio nmbd
El demonio del servidor nmbd entiende y responde a las peticiones de servicio de nombres
NetBIOS tales como aquellas producidas por SMB/CIFS en sistemas basados en Windows. Estos
sistemas incluyen clientes 95/98/ME, Windows NT, Windows 2000, Windows XP y LanManager.
También participa en los protocolos de navegación que forman la vista Entorno de red de
Windows. El puerto predeterminado en el que el servidor escucha por tráfico NMB es el puerto
UDP 137.
El demonio nmbd es controlado por el servicio smb.
Arrancar y detener el Samba

Para arrancar el servidor Samba, escriba el comando siguiente en un intérprete de comandos
conectado como root:
# /sbin/service smb start

Para detener el servidor, escriba el comando siguiente en un intérprete de comandos mientras
está conectado como root:
# /sbin/service smb stop
La opción restart es una forma fácil de detener y luego arrancar Samba. Esta es la forma más
confiable de hacer que los cambios tomen lugar después de editar el archivo de configuración
Samba. Observe que la opción de reinicio arranca el demonio aún si no estaba ejecutándose
originalmente.
Para reiniciar el servidor, escriba el comando siguiente en un intérprete de comandos mientras
está conectado como usuario root:
# /sbin/service smb restart
La opción condrestart (reinicio condicional) solamente arranca smb con la condición de que se
esté ejecutando actualmente. Esta opción es útil para los scripts, debido a que no arranca el
demonio si este no se está ejecutando.
Para reiniciar condicionalmente el servidor, desde el indicador de comandos, escriba el
comando siguiente como root:
# /sbin/service smb condrestart
pág. 310

Una recarga manual del archivo smb.conf puede ser útil en caso de que una recarga automática
del servicio smb falle. Para asegurarse de que el archivo de configuración del servidor Samba es
recargado sin reiniciar el servicio, escriba el comando siguiente como usuario root:
# /sbin/service smb reload
Por defecto, el servicio smb no se inicia automáticamente al momento del arranque. Para
configurar Samba para que inicie al momento del arranque, utilice una utilidad de initscript tal
como /sbin/chkconfig, /sbin/ntsysv o el programa Herramienta de configuración de servicios.
Tipos de servidores Samba y el archivo smb.conf
La configuración de Samba es bien directa. Todas las modificaciones a Samba se realizan en el

archivo de configuración/etc/samba/smb.conf. Aunque el archivo
predeterminado smb.conf está bien documentado, no menciona tópicos complejos como LDAP,
Active Directory y numerosas implementaciones de controladores de dominio.
Las secciones siguientes describen las diferentes formas en que se puede configurar un servidor
Samba. Tenga en cuenta sus necesidades y los cambios requeridos al archivo smb.conf para una
configuración exitosa.
Servidor independiente
Un servidor independiente puede ser un servidor de un grupo de trabajo o un miembro de
entorno de grupo de trabajo. Un servidor independiente no es un controlador de dominio y no
participa en un dominio de ninguna manera. Los ejemplos siguientes incluyen varias
configuraciones de seguridad a nivel de recursos compartidos anónimas y una configuración de
seguridad a nivel de usuario.
Anónimo de sólo lectura

El archivo smb.conf siguiente muestra una configuración de ejemplo necesaria para
implementar compartir recursos de archivos de forma anónima y de sólo lectura. El
parámetro security = share hace el recurso compartido anónimo. Observe que, los niveles de
seguridad para un servidor Samba único no se pueden mezclar. La directriz security es un
parámetro Samba global localizado en la sección [global] del archivo de configuración smb.conf.
[global]
workgroup = DOCS
netbios name = DOCS_SRV
pág. 311

security = share
[data]
comment = Documentation Samba Server
path = /export
read only = Yes
guest only = Yes

Anónimo Lectura/Escritura
El siguiente archivo smb.conf muestra una configuración de muestra necesaria para
implementar compartir recursos de archivos de lectura/escritura de forma anónima. Para
activar compartir archivos de lectura/escritura anónimos, configure la directriz read only a no.
Las directrices force user y force group también se añaden para reforzar la propiedad de
cualquier archivo nuevo especificado en el recurso compartido.

[global]
workgroup = DOCS
security = share
[data]
comment = Data
path = /export
force user = docsbot
force group = users
read only = No
guest ok = Yes

Servidor de impresión anónimo
El siguiente archivo smb.conf muestra una configuración de muestra necesaria para
implementar un servidor de impresión anónimo. Configurando browseable a no como se
muestra, no lista la impresora en el Entorno de red. Aunque está oculto para propósitos de
navegación, se puede configurar la impresora explícitamente. Al conectar DOCS_SRV usando
NetBIOS, el cliente puede tener acceso a la impresora si el cliente también es parte del grupo de
trabajo DOCS. También se asume que el cliente tiene el controlador de impresora correcto, pues
la directriz de use client driver está configurada a Yes. En este caso, el servidor Samba no tiene
responsabilidad de compartir los controladores de impresora con el cliente
pág. 312

[global]
workgroup = DOCS
security = share
printcap name = cups
disable spools= Yes
show add printer wizard = No
printing = cups
[printers]
comment = All Printers
path = /var/spool/samba
guest ok = Yes
printable = Yes
use client driver = Yes
browseable = Yes

Archivo seguro de lectura/escritura y servidor de impresión.
El archivo siguiente smb.conf muestra una configuración de ejemplo necesaria para
implementar un servidor de impresión seguro de lectura/escritura. Configurando la
directriz security a user obliga a Samba a autenticar las conexiones de clientes. Observe que el
recurso compartido [homes] no tiene una directriz force user o force group como si lo tiene el
recurso [public]. El recurso compartido [homes] utiliza los detalles del usuario autenticado para
cualquier archivo al contrario deforce user y force group en [public].

[global]
workgroup = DOCS
security = user
printcap name = cups
disable spools = Yes
show add printer wizard = No
printing = cups
[homes]
comment = Home Directories
pág. 313

valid users = %S
read only = No
browseable = No
[public]
comment = Data
path = /export
force group = users
guest ok = Yes
[printers]
comment = All Printers
path = /var/spool/samba
printer admin = john, ed, @admins
create mask = 0600
guest ok = Yes
printable = Yes
use client driver = Yes
browseable = Yes

Nota: Recuerde que los comando vitales para controlar impresoras desde línea de comando
son:
# lp –d impresora documento (para mandar a imprimir)
# lprm –P impresora numero de ttrabajo (para cancelar una impresion)
# lpq –P imoresora (para ver los trabajos pendientes en la cola de impresión)
La información de impresoras o configuraciones puedes consultarlas en el archivo que esta

ubicado en:
/etc/cups/printers.conf
Y cuando se hacen cambios en las propiedades de las impresoras se guardan los cambios el el
archivo .lpoptions que se encuentra en el home de cada usuario.
pág. 314

Servidor miembro de dominio
Un miembro de dominio, aunque es similar a un servidor independiente, es conectado a un

controlador de dominio (bien sea Windows o Samba) y está sujeto a las reglas de seguridad del
dominio. Un ejemplo de un servidor miembro de dominio podría ser un servidor departamental
ejecutando Samba que tiene una cuenta de máquina en el Controlador de Dominio Primario
(PDC). Todos los clientes del departamento todavía se autentifican con el PDC y se incluyen los
perfiles del escritorio y todas los archivos de políticas. La diferencia es que el servidor
departamental tiene la habilidad de controlar las impresoras y recursos de red compartidos.
Servidor miembro de dominio Active Directory

El archivo siguiente smb.conf muestra una configuración de ejemplo necesaria para
implementar un servidor miembro de dominio Active Directory. En este ejemplo, Samba
autentifica usuarios para servicios que se ejecutan localmente pero también es un cliente del
Active Directory. Asegúrese de que su parámetro realm se muestra en mayúsculas (por
ejemplo realm = EXAMPLE.COM). Puesto que Windows 2000/2003 requiere de Kerberos para la
autenticación de Active Directory, se requiere de la directriz realm. Si Active Directory y
Kerberos se están ejecutando en servidores diferentes, se puede necesitar la directrizpassword
server para ayudar a diferenciar.
[global]
realm = EXAMPLE.COM
security = ADS
encrypt passwords = yes
# Optional. Use only if Samba cannot determine the Kerberos server
automatically.
password server = kerberos.example.com
Para poder unir un servidor miembro a un dominio de Active Directory, se deben completar los
pasos siguientes:
Configuración del archivo smb.conf en el servidor miembro
Configuración de Kerberos, incluyendo el archivo /etc/krb5.conf file, en el servidor
miembro
Creación de la cuenta de la máquina en el servidor de dominio Active Directory
Asociación del servidor miembro al dominio Active Directory
Para la cuenta de la máquina y unirse al Active Directory de Windows 2000/2003, primero
Kerberos se debe inicializar para el servidor miembro que desea unirse al dominio Active
pág. 315

Directory. Para crear un tíquet administrativo Kerberos, escriba el comando siguiente como root
en el servidor miembro:
root# kinit administrator@EXAMPLE.COM
El comando kinit es un script de inicialización que hace referencia a la cuenta administrativa del
Active Directory y el reino Kerberos. Puesto que Active Directory requiere de los tíquets
Kerberos, kinit obtiene y coloca en caché los tíquets de Kerberos para la autenticación
cliente/servidor.
Para unir un servidor Active Directory (windows1.example.com), escriba el comando siguiente
como root en el servidor miembro:
root# net ads join -S windows1.example.com -U administrator%password
Puesto que la máquina windows1 se encontró automáticamente en el reino Kerberos
correspondiente (el comando kinit fue exitoso), el comando net se conecta al servidor Active
Directory usando su cuenta administrativa y contraseña requerida. Esto crea la cuenta de la
máquina en el Active Directory y otorga los permisos para que el servidor miembro Samba se
una al dominio.
Servidor miembro de dominio basado en Windows NT4

El archivo smb.conf siguiente muestra una configuración de ejemplo necesaria para
implementar un servidor miembro de dominio basado en Windows NT4. Convertirse en un
servidor miembro de un dominio basado en Windows NT4 es similar a conectarse a un Active
Directory. La principal diferencia es que los dominios basados en Windows NT4 no utilizan
Kerberos en su método de autentificación, haciendo que el archivo smb.conf más sencillo. En
este caso, el servidor miembro Samba sirve como un pase al servidor de dominio basado en
NT4.
[global]
workgroup = DOCS
security = domain
[homes]
comment = Home Directories
valid users = %S
read only = No
browseable = No
[public]
pág. 316

comment = Data
path = /export
force group = users
guest ok = Yes

Tener un servidor miembro Samba puede ser útil en muchas situaciones. Hay veces en donde el
servidor Samba puede tener otros usos además de compartir archivos e impresoras. Puede ser
útil hacer Samba un servidor miembro de dominio en casos en los que se requiere utilizar
aplicaciones puramente Linux en el entorno del dominio. A los administradores les gusta llevar
un seguimiento de todas las máquinas en el dominio, aún si no están basadas en Windows. En el
caso de que el hardware del servidor basado Windows esté descontinuado, es fácil modificar el
archivo smb.conf para convertir el servidor a un PDC basado en Samba. Si los servidores basados
en Windows NT son actualizados a Windows 2000/2003, es fácil modificar el
archivo smb.conf para incorporar el cambio de infraestructura a un Active Directory si se
necesita.
Observe que la opción -S, que especifica el nombre de host para el servidor de dominio, no
necesita especificarse en el comando net rpc join. Samba utiliza el nombre de host especificado
por la directriz en el archivo smb.conf en vez de este especificarlo explícitamente.
Domain Controller
Un controlador de dominio en Windows NT es similar funcionalmente a un servidor NIS, Servicio
de Información de Red (Network Information Service), en un entorno Linux. Los controladores
de dominio y los servidores NIS ambos hospedan bases de datos de información sobre
usuarios/grupos así como también servicios relacionados. Los controladores de dominio son
utilizados principalmente por seguridad, incluyendo la autenticación de usuarios accediendo a
recursos del dominio. El servicio que mantiene la integridad de la base de datos de
usuarios/grupos se llama Administrador de Cuentas de Seguridad (Security Account Manager,
SAM). La base de datos SAM es almacenada de forma diferente entre sistemas Windows y
sistemas Linux basados en Samba, por lo tanto la replicación SAM no se puede lograr y las
plataformas no se pueden mezclar en un entorno PDC/BDC.
En un ambiente Samba, solamente pueden existir un PDC y cero o más BDCs.
pág. 317

Modos de seguridad Samba

Solamente hay dos tipos de modos de seguridad para Samba, share-level y user-level, que se
conocen de forma colectiva como niveles de seguridad. Solamente se puede implementar la
seguridad a nivel de recurso compartido de una forma, mientras que la seguridad a nivel de
usuario se puede implementar en una de cuatro formas diferentes. Las diferentes formas de
implementar un nivel de seguridad se llama modos de seguridad.
Seguridad a nivel de usuario

La seguridad a nivel de usuario es la configuración predeterminada para Samba. Aún si la
directriz security = user no está listada en el archivo smb.conf, es utilizada por Samba. Si el
servidor acepta la combinación de nombre de usuario/contraseña del cliente, el cliente puede
montar múltiples recursos compartidos sin tener que especificar una contraseña para cada
instancia. Samba también puede aceptar solicitudes de nombre de usuario/contraseña basadas
en la sesión. El cliente mantiene múltiples contextos de autenticación usando un único UID por
cada inicio de sesión.
En smb.conf, la directiva security = user que configura la seguridad a nivel del usuarios es:
[GLOBAL]
...
security = user
...

pág. 318

Seguridad a nivel de usuarios

Con la seguridad a nivel de recurso compartido o servicio, el servidor acepta solamente una
contraseña sin un nombre de usuario explícito desde el cliente. El servidor espera una
contraseña para cada recurso compartido, independientemente del nombre de usuario. Han
surgido informes recientes de clientes Microsoft Windows con problemas de compatibilidad con
servidores de seguridad a nivel de recurso compartido. Los desarrolladores de Samba no
recomiendan el uso de la seguridad a este nivel.
En smb.conf, la directiva security = share que configura la seguridad a nivel de directorio
compartido es:

[GLOBAL]
...
security = share
...

Modo de seguridad de dominio (seguridad a nivel del usuario)
En un modo de seguridad de dominio, el servidor Samba tiene una cuenta de máquina (cuenta
confiable de seguridad del dominio) y hace que todas las solicitudes de autenticación se pasen a
través de los controladores de dominio. El servidor Samba se convierte en un servidor miembro
de dominio usando las directrices siguientes en smb.conf:
[GLOBAL]
...
security = domain
workgroup = MARKETING
...

pág. 319

Modo de seguridad de Active Directory (seguridad a nivel de usuario)

Si tiene un entorno Active Directory, es posible unirse al dominio como un miembro nativo de
Active Directory. Aún si una política de seguridad limita el uso de protocolos de autenticación
compatibles con NT, el servidor Samba se puede unir al ADS utilizando Kerberos. Samba en un
modo de miembro de Active Directory puede aceptar tíquets Kerberos.
En smb.conf, las directivas siguientes hacen a Samba un servidor miembro de Active Directory:
[GLOBAL]
...
security = ADS
realm = EXAMPLE.COM
password server = kerberos.example.com
...

Modo de seguridad de servidor (seguridad a nivel de usuario)

Se utilizó el modo de seguridad de servidor previamente cuando Samba no fue capaz de actuar
como un servidor miembro de dominio.
En smb.conf, las directrices siguientes permiten que Samba opere en modo de seguridad de
servidor:
[GLOBAL]
...
encrypt passwords = Yes
security = server
password server = "NetBIOS_of_Domain_Controller"
...

Bases de datos de información de cuentas Samba
La última versión de Samba ofrece varias funcionalidades incluyendo nuevos motores de bases
de datos de contraseñas que antes no estaban disponibles. La versión 3.0.0 de Samba es
completamente compatible con las versiones anteriores de Samba. Sin embargo, aunque sean
compatibles, hay muchos motores que no son convenientes para ser utilizados en producción.
pág. 320

Motores con compatibilidad ascendente
Texto plano
Los motores de texto plano son simplemente motores del tipo /etc/passwd. Con un motor de
texto plano, todos los nombres de usuarios y contraseñas son enviados sin encriptar entre el
cliente y el servidor Samba. Este método es muy inseguro y no se recomienda su uso de ninguna
manera. Es posible que diferentes clientes Windows conectándose al servidor Samba con
contraseñas en texto plano no puedan soportar este método de autenticación.
smbpasswd
Un motor popular utilizado en los paquetes previos de Samba, el motor smbpasswd, utiliza un
formato de texto ASCII que incluye el MS Windows LanMan y la cuenta NT e información
encriptada de contraseñas. Al motor smbpasswd le falta el almacenamiento de los controles
extendidos NT/2000/2003 SAM. No se recomienda el motor smbpasswd porque no escala bien
ni guarda información de Windows, tal como RIDs para grupos basados en NT. El
motor tdbsam resuelve estos problemas para el uso en una base de datos más pequeña (250
usuarios), pero no es una solución de clase empresarial.
ldapsam_compat
El motor ldapsam_compat permite el soporte continuo de OpenLDAP para ser utilizado con las
versiones actualizadas de Samba. Esta opción es ideal para la migración, pero no se requiere.
Eventualmente se descontinuará esta herramienta.
Nuevos motores
tdbsam
El motor tdbsam proporciona un motor de base de datos ideal para los servidores locales, para
servidores que no necesitan una replicación de bases de datos incorporada y para servidores
que no requieren la escalabilidad o complejidad de LDAP. El motor tdbsam incluye toda la
información de bases de datos de smbpasswd así como también la información SAM
anteriormente excluida. La inclusión de los datos extendidos SAM permite a Samba
implementar la misma cuenta y controles de acceso a sistema como se ve en los sistemas
basados en Windows NT/2000/2003.
Se recomienda el motor tdbsam para no más de 250 usuarios. Las organizaciones más grandes
deberían optar por la integración de Active Directory o LDAP debido a la estabilidad y a posibles
consideraciones relacionadas a la infraestructura.
pág. 321

ldapsam
El motor ldapsam proporciona un método óptimo de instalación de cuentas distribuídas para
Samba. LDAP es óptimo por su habilidad de replicar su base de datos a cualquier número de
servidores usando el demonio de OpenLDAP slurpd. Las bases de datos LDAP son ligeras y
escalables, perfectas para la mayoría de las organizaciones, especialmente grandes
corporaciones. LDAP es definitivamente "la tendencia futurística" con respecto a Samba.
Constantemente se añaden mejoras de LDAP en Samba tales como para facilitar la instalación o
para resolver problemas de configuración.
mysqlsam
mysqlsam utiliza un motor de base de datos basado en MySQL. Esto es muy útil para los sitios
que ya tienen implementado MySQL.
xmlsam
El motor xmlsam utiliza una cuenta y contraseña de datos almacenadas en un archivo de
formato XML. Este método puede ser útil para la migración de diferentes motores de bases de
datos o respaldos.
Navegación de red con Samba
El explorar la red es un concepto que permite a los servidores Windows y Samba aparecer en
el Entorno de red de Windows. Dentro del Entorno de red, los iconos son representados como
servidores y si se abren, se mostrarán los recursos compartidos disponibles.
Las capacidades de explorar la red requieren NetBIOS sobre TCP/IP. La interconexión basada en
NetBIOS utiliza difusión de mensajes (UDP) para lograr la administración de exploración de
listas. Sin NetBIOS y WINS como los métodos principales para la resolución TCP/IP de nombres
de host, se deben utilizar otros métodos tales como archivos estáticos (/etc/hosts) o DNS.
Un explorador maestro de dominios compagina las listas de exploración desde los navegadores
maestros locales en todas las subredes para que se pueda realizar la navegación entre grupos de
trabajo y subredes. Preferiblemente, el explorador maestro de dominios debería ser el
explorador maestro local para su propia subred.
Navegación de grupos de trabajo

Para cada grupo de trabajo, debe haber uno y sólo un explorador maestro de dominios. Puede
tener un explorador maestro local por subred sin un explorador maestro de dominio, pero esto
resulta en grupos de trabajo aislados incapaces de verse entre ellos. Para resolver nombres
NetBIOS en grupos de trabajo de subredes cruzadas, se requiere de WINS.
pág. 322

Solamente puede existir un explorador maestro de dominios por nombre de grupo de trabajo.
He aquí un ejemplo del archivosmb.conf en el cual el servidor Samba es un explorador maestro
de dominios:

[global]
domain master = Yes
local master = Yes
preferred master = Yes
os level = 35
Luego, se muestra un ejemplo del archivo smb.conf en el cual el servidor Samba es un
explorador maestro local:
[global]
domain master = no
local master = Yes
preferred master = Yes
os level = 35
La directriz os level opera como un sistema de prioridades para exploradores maestros en una
subred. Configurando diferentes valores se asegura de que los exploradores maestros no entren
en conflicto por la autoridad.
Hay ocasiones en que una máquina Windows NT en la subred puede ser el explorador maestro
local. Lo siguiente es una configuración de ejemplo smb.conf en la cual el servidor Samba no
está sirviendo ninguna capacidad como explorador.
[global]
domain master = no
local master = no
preferred master = no
os level = 0

Navegaciòn de Dominios
Por defecto, un PDC de Windows NT para un dominio es también el explorador maestro de
dominio para ese dominio. Se debe configurar un servidor Samba como un servidor maestro de
dominio en este tipo de situación. La exploración de redes puede fallar si el servidor Samba está
ejecutando WINS junto con otros controladores de dominio en operación.

pág. 323

Para las subredes que no incluyen el PDC de Windows NT, se puede implementar un servidor
Samba como un explorador maestro local. Configurando smb.conf para un explorador maestro
local (o ningún tipo de navegación) en un entorno de controlador de dominio es lo mismo que la
configuración de grupos de trabajo.
WINS (Windows Internetworking Name Server)

Un servidor Samba o un servidor Windows NT pueden Afuncionar como servidor WINS. Cuando
se utiliza un servidor WINS con NetBIOS activado, se pueden enrutar los unicasts UDP lo que
permite la resolución de nombres a través de la red. Sin un servidor WINS, la difusión UDP está
limitada a la subred local y por lo tanto no tiene que ser enrutada a otras subredes, grupos de
trabajo o dominios. Si se necesita la replicación WINS, no utilice Samba como su servidor WINS
primario pues actualmente Samba no soporta la replicación WINS.
En un entorno mezclado de servidores NT/2000/2003 y Samba, se recomienda que utilice las
capacidades de Microsoft WINS. En un entorno de Samba, se recomienda que utilice solamente
un servidor Samba para WINS.
Lo siguiente es un ejemplo de un archivo smb.conf en el cual el servidor Samba está sirviendo
como un servidor WINS:

[global]
wins support = Yes

Instalación y configuración:
Lo primero que hay que hacer es instalar los paquetes necesarios para hacer funcionar samba
esto lo conseguimos ejecutando el siguiente comando:
# yum –y install samba samba-client samba-common
La instalación quedara completa cuando nos mande el mensaje de complete!
pág. 324

Una vez que está instalado hay que habilitar las tablas para abrir los puertos con las siguientes
instrucciones:

# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 135:139 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m udp -p udp --dport 135:139 -j ACCEPT

Después procedemos a salvar los cambios de las tablas con el siguiente comando:

# service iptables save

Y reiniciamos el servicio:
# servce iptables restart
Se realiza la misma configuración en SELINUX que en FTP deshabilitarlo si lo está.
Después procedemos a revisar el archivo de configuración de samba que está en la siguiente

ruta
# cd /etc/samba/smb.conf
Para evitar conflictos o problemas es recomendable hacer un respaldo de este archivo

# cp /etc/samba/smb.conf smb.old
pág. 325

Una vez hecho esto, entramos al archivo y borramos todo el contenido que tiene y anexamos las
siguientes líneas:
[global]
workgroup = WORKGROUP (define un grupo de trabajo)
secure = share (define la seguridad global)
map to guest = bad user (define el alojamiento de los usuarios)

[Publico]
path = /home/Publico (Directorio donde se alojara la carpeta)
browseable = yes (se define que va a ser buscable)
writable = yes (se define que va a ser modificable)
guest ok = yes (define que permite cualquier usuario)
read only = no (se define que es de solo lectura)

pág. 326

El archivo debe de quedar de la siguiente forma:

Después creamos la carpeta que acabamos de configurar:
# mkdir /home/Publico
Después le damos todos los permisos a la carpeta
# chmod 777 /home/Publico

Después reiniciamos el servidor
# service smb restart

Ahora procedemos a realizar la prueba de conexión desde un cliente con Windows:
Nos vamos a ejecutar en Windows y ponemos la dirección del servidor samba en Linux de la
siguiente forma:

Tenga cuidado de poner las diagonales invertidas:
pág. 327

Le damos en aceptar y nos debe de mostrar la carpeta Publica creada anteriormente:

Acceso a la carpeta y debe estar vacía, pero si creo un documento se debe de ver reflejado en
Linux de manera inmediata.

De esta manera ya tenemos una carpeta compartida de manera pública, lo siguiente será
configurar una privada, es decir que nos pida autenticación:
Para esto agregaremos las configuraciones correspondientes en el archivo de configuración de
samba.
pág. 328

Editaremos el archivo de samba nuevamente:
# vi /etc/samba/smb.conf
Agregaremos los parámetros siguientes para la conexión de manera privada:
[Privado]
path = /home/Privado
browseable = yes
writable = yes
guest ok = no
read only = no
valid users = @GrupoSamba (Usuarios que serán validos, solo los que estén
dentro del grupo Samba)
Este debe quedar de la siguiente manera:

Ahora procedemos a realizar el alta de los usuarios validos:
# useradd UsuarioSAMBA
Creamos el grupo para samba
# groupadd GrupoSamba
Agregamos al usuario al grupo
# usermod –a –G GrupoSamba UsuarioSAMBA

Le asignamos el password al usuario pero con la definición del grupo o del aplicativo de smb
pág. 329

# smbpasswd –a UsuarioSAMBA
Una vez realizado esto, procedemos a crear la carpeta privada que definimos en la configuración
de samba
# mkdir /home/Privado
Le damos permisos de usuario propietario y de grupo propietario
# chmod 770 /home/Privado

# chown –R UsuarioSAMBA:GrupoSamba /home/Privado

Reiniciamos el servicio:
# service smb restart

# service nmb restart
Y realizamos la prueba de verificación, nuevamente ejecutamos para ver el mapeo de la carpeta
pág. 330

Pulsamos en el botón aceptar

Y podremos ver la carpeta compartida, pero si damos click en esta:
pág. 331

Nos pedirá una validación, la cual la vamos a realizar con el usuario que dimos de alta:

Y de esta manera podremos ingresar al recurso
pág. 332

Creamos un archivo

Y lo verificamos en el server con Linux:

De esta manera tendremos un recurso privado funcionando, con samba.
pág. 333

CONCLUSIONES

Hoy en día los sistemas operativo sean hecho parte importante en nuestra vida como también
hay una gran diversidad de sistemas operativos hoy en día como Windows, Apple, y Linux es un
sistema operativo muy popular es propiamente el núcleo de un sistema operativo es decir el
conjunto de programas que controla los aspectos más básicos del funcionamiento pero Linux
tiene una amplia distribución de sistemas operativos como centOS, Fedora, Debian, Mandriva
entre otros más, pero sin el sistema operativo de la computadora solo sería un más que un
montón de metal pero con el sistema operativo él tiene una responsabilidad se asegura de que
los programas y usuarios que estén funcionando al mismo tiempo no interfieran entre ellos
tambien conocimos su historia como fue que surgió quien es mejor sistema operativo Linux y
sus distribuciones como es la estructura de Linux con ella permitir al software conocer la
ubicación de directorios y archivos instalados pero con lo comandos la terminal es la interfaz
gráfica que permite que el usuario se comunique con el kernel de Linux se pude entrar de modo
gráfico hay se puede ver los directorios crear cambiar archivos siendo el superusuario (root ) o
un usuario normal o tambien crear nuevos usuarios o instalar software que es necesario utiliza
repositorios tambien para intalar se puede utilizar el comando yum
pág. 334

CIBERGRAFIA

http://www.authorstream.com/Presentation/alandramirez-1854509-centos/
http://www.centosni.net/comandos-basicos-en-gnulinux-centos/
http://www.fing.edu.uy/inco/cursos/sistoper/recursosLaboratorio/tutorial0.pdf
http://www.debian.org/
http://asorufps.wikispaces.com/CENTOS
http://www.debian.org/doc/manuals/project-history/ch-intro.es.html
http://www.debian.org/doc/manuals/project-history/ch-detailed.es.html

pág. 335

Linux Administrator

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Linux Administrator

Cargado por

Copyright:

Formatos disponibles

LINUX ADMINISTRATOR

Características del Sistema Linux ...................................................................... 26

Instalacion Centos ........................................................................................... 36

Unidad 2 Administración del Sistema de Archivos. ............................................. 88

Límites de tamaño ........................................................................................................................................... 89

Unidad 3. Administración de Sofware y servicios. ............................................ 107

Unidad 4.Gestión de usuarios, grupos y privilegios. ....................................... 129

Añadir usuarios con useradd ......................................................................................................................... 134

SUDO ........................................................................................................... 142

Unidad 5. Permisos y Atributos del Sistema de Archivos. .................................. 160

Unidad 6. Herramientas básicas del Sistema Operativo. ................................... 191

Introducción a sed. ........................................................................................................................................ 226

IMPLEMENTAR Y ADMINISTRAR CUOTAS DE DISCO (DISK QUOTAS) EN LINUX ...... 235

Configuración y uso de crond. ........................................................................ 252

Introducción a SELinux .................................................................................. 279

El archivo de configuración /etc/sysconfig/selinux ....................................................................................... 280

Seguridad ..................................................................................................... 283

El Protocolo de Transferencia de Archivos ...................................................... 292

Introducción a Samba .................................................................................... 308

Servidor independiente ................................................................................. 311

Bases de datos de información de cuentas Samba ....................................................................................... 320

Motores con compatibilidad ascendente ......................................................... 321

Formación de la comunidad de aprendizaje:

Presentación del instructor:

• Se anotarán los acuerdos en hojas de rotafolio y se colocarán en un espacio en el que sean

Unidad 1.- Instalación del SistemaOperativo y Ajustes posteriores

El sistema operativo controla todo el trabajo de la computadora. Sin el, la computadora

Programa de Sistema Programas que

Ilustración 1 Rol de un Sistema Operativo

Los siguientes son algunos de los usos del sistema operativo:

Proporciona diferentes recursos a los usuarios, tales como: calculo, almacenamiento,

Inicio de un Sistema Operativo

Los sistemas operativos son clasificados en dos tipos:

Sistema Operativo Linux

Ilustración 2 “TUX”, la mascota de Linux

Requerimientos de Hardware de Linux

Unidades de CD-ROM Sistema estándar de archivo ISO 9660 para CD-ROMS

Unidades de Cinta SCSI

3 Tabla: Requerimientos de Hardware de Linux

Mandrake Linux, desarrollado por MandrakeSoft.

Ilustración 4 Partes Principales del Sistema Operativo Linux

En el sistema Linux existe un cierto número de herramientas disponibles. Las herramientas

A continuación se aprenderá acerca de la organización del sistema de archivos en el

Todos los programas de usuario, documentos, herramientas, aplicaciones, etc son

Algunos ejemplos de editores son:

Características del Sistema Linux

Software disponible en Linux

Existen muchas y variadas distribuciones creadas por diferentes empresas y organizaciones a

UBUNTU.-Distribución basada en Debian, con lo que esto conlleva y

REDHAT ENTERPRISE.-Esta es una distribución que tiene muy buena

FEDORA.-Esta es una distribución patrocinada por RedHat y soportada

DEBIAN.- Otra distribución con muy buena calidad. El proceso de

OpenSuSE.-Otra de las grandes. Facil de instalar. Version libre de la

SuSE LINUX ENTERPRISE.-Otra de las grandes. Muy buena calidad,

SLACKWARE.- Esta distribución es de las primeras que existio. Tuvo un

GENTOO.-Esta distribución es una de las unicas que incorporaron un

KUBUNTU.-Distribución basada en Ubuntu, con lo que esto conlleva y

MANDRIVA.-Esta distribución fue creada en 1998 con el objetivo de

Estándar de Jerarquía de Sistema de Archivos.

A principios de 1996, con la ayuda de miembros de la comunidad de desarrolladores de BSD, se

Estructura de los directorios general

Ilustración 7 Contenido del directorio /etc

Datos referidos al kernel, bus, dispositivos, firmware, fs (filesystem) y otros.

/boot Requiere de 200 MiB a 512 MiB.