Tp Final Aso

93
Trabajo Final de Arquitectura de los Sistemas Operativos Tema: Un simple análisis del sistema operativo FreeBSD. Profesor: Costello Rodriguez, Alejandro. Alumnos: Bacelli Julián. Dominguez Jacobo. Fecha: 08/08/2012

description

Trabajo Final de Arquitectura de los Sistemas Operativos Tema: Un simple análisis del sistema operativo FreeBSD. Profesor: Costello Rodriguez, Alejandro. Alumnos: Bacelli Julián. Dominguez Jacobo. Fecha: 08/08/2012ÍndiceIntroducción: .................................................................................................................................... 5 ¿Qué es FreeBSD? ..............................................................................................................

Transcript of Tp Final Aso

Page 1: Tp Final Aso

Trabajo Final de Arquitectura de los Sistemas Operativos

Tema: Un simple análisis del sistema operativo FreeBSD.

Profesor: Costello Rodriguez, Alejandro.

Alumnos:

Bacelli Julián.

Dominguez Jacobo.

Fecha: 08/08/2012

Page 2: Tp Final Aso

1

Índice Introducción: .................................................................................................................................... 5

¿Qué es FreeBSD? ..................................................................................................................... 5

Características: ............................................................................................................................ 5

Otras características: ................................................................................................................. 5

Arquitectura:................................................................................................................................. 6

Kernel: ......................................................................................................................... 7

Configurar un Kernel Personalizado: ............................................................................ 7

Compilación del kernel ............................................................................................ 10

Comando pmcstat: ................................................................................................................... 10

PAPI ............................................................................................................................................... 11

Instalación de FreeBSD: .............................................................................................................. 12

Instalando nuestra Interfaz Gráfica: ........................................................................................ 33

Instalación de XORG: ............................................................................................................... 33

Instalación de GNOME 2 en FreeBSD: ................................................................................ 33

Administración de usuarios: ...................................................................................................... 37

Chpass .......................................................................................................................................... 38

Passwd .......................................................................................................................................... 39

Login y Logout ........................................................................................................................... 40

Usuarios activos ........................................................................................................................ 40

Ttys ............................................................................................................................................... 40

Sudoers y permisos ................................................................................................................. 41

PAM ............................................................................................................................................... 41

Procesos: ........................................................................................................................................ 42

Tipos de procesos: ................................................................................................................... 42

Loader .......................................................................................................................................... 42

Utilidades para ver Procesos en ejecución: ...................................................................... 43

PS ............................................................................................................................... 44

TOP ............................................................................................................................ 46

Dæmons, señales y cómo matar procesos ............................................................................. 47

Opciones para el comando Kill: ............................................................................................ 48

Administracion de recursos: .......................................................................................................... 50

Permisos en archivos ................................................................................................................. 50

Ver un archivo. ............................................................................................................................. 50

Page 3: Tp Final Aso

2

Cat .............................................................................................................................. 51

More more <fichero>, realiza la misma opción de cat carta.txt |more, pero evidentemente tendremos que escribir menos, bastará con el comando de la siguiente manera: more carta.txt Less ....................................................................... 51

Ver un archivo comprimido. ................................................................................................... 51

Copiar un Archivo ..................................................................................................................... 51

Mover un Archivo ...................................................................................................................... 52

Renombrar un Archivo. ........................................................................................................... 52

Borrar un Archivo ...................................................................................................................... 52

Borrar un DIRECTORIO ........................................................................................................... 52

Ls ................................................................................................................................................... 53

Opciones más comunes .......................................................................................................... 53

Impresoras .................................................................................................................................... 55

Dispositivos .................................................................................................................................. 55

Creación de un sistema de archivos ............................................................................................ 55

Procmail ........................................................................................................................................ 56

Loop devices ................................................................................................................................ 57

Cdrom ............................................................................................................................................ 58

Herramientas de Desarrollo: .......................................................................................................... 59

VI .................................................................................................................................................... 59

Invocación de vi ........................................................................................................ 61

Vim ................................................................................................................................................. 61

Modos ......................................................................................................................... 61

Modo comandos ......................................................................................................... 62

Modo inserción ........................................................................................................... 62

Modo línea de órdenes ............................................................................................... 62

Modo visual ................................................................................................................ 62

Modo selección ........................................................................................................... 62

Modo Ex ..................................................................................................................... 63

Nano .............................................................................................................................................. 63

Emacs ........................................................................................................................................... 63

Uso de emacs ............................................................................................................. 63

GNU Compiler Collection ........................................................................................................... 64

Uso ............................................................................................................................. 65

GDB ............................................................................................................................ 65

Page 4: Tp Final Aso

3

Invocación del Debugger ........................................................................................................... 66

Comandos más Frecuentemente Usados: .............................................................................. 66

Guía de compilación de un programa realizado en C en FreeBSD .................................... 68

Lenguajes ..................................................................................................................................... 69

BASIC ......................................................................................................................... 69

Lisp ............................................................................................................................. 69

Perl ............................................................................................................................. 70

Icon ............................................................................................................................. 70

Logo ............................................................................................................................ 70

Python ........................................................................................................................ 70

Servicios:......................................................................................................................................... 71

Daemons: .................................................................................................................................... 71

Inetd: ........................................................................................................................... 71

Configuraciones ........................................................................................................................... 71

Opciones de línea de órdenes .................................................................................................. 71

inetd.conf: ................................................................................................................... 73

Xinetd: ....................................................................................................................... 75

Servicio FTP: .............................................................................................................................. 76

Servicio de Correo Electrónico: ............................................................................................ 77

El Agente de Usuario .................................................................................................. 77

Agente de Transporte de Correo ................................................................................ 77

Correo electrónico y DNS ........................................................................................... 77

Recepción de correo ................................................................................................... 78

Acceso a carpetas de correo locales .......................................................................... 79

Seguridad: ....................................................................................................................................... 79

Conceptos de seguridad ............................................................................................................ 79

Sistema físico y consola ............................................................................................................. 79

Programas setuid y Daemons ................................................................................................... 79

Daemons....................................................................................................................................... 80

Programas setuid ........................................................................................................................ 80

Sistemas de ficheros................................................................................................................... 80

Monitorizando el sistema de ficheros ....................................................................................... 81

Monitorización avanzada con tripwire ...................................................................................... 81

rhosts y hosts.equiv .................................................................................................................... 82

Page 5: Tp Final Aso

4

Ficheros de dispositivos especiales ......................................................................................... 82

Protocolos de red ........................................................................................................................ 83

Características de FreeBSD ...................................................................................................... 83

Niveles de seguridad .................................................................................................................. 83

IP Firewall ..................................................................................................................................... 84

One-Time Passwords ................................................................................................................. 85

Desactivación de cuentas .......................................................................................................... 86

Sendmail ....................................................................................................................................... 87

Jails:............................................................................................................................................... 88

Introducción ................................................................................................................ 88

Qué es una jaula......................................................................................................... 88

Creación y gestión de jaulas ....................................................................................... 89

Administración y personalización a fondo ................................................................... 91

Herramientas del sistema para la personalización de jaulas en FreeBSD ................. 91

Herramientas para tareas administrativas de alto nivel en la Colección de Ports ...... 92

Page 6: Tp Final Aso

5

Introducción: ¿Qué es FreeBSD? FreeBSD es un avanzado sistema operativo para arquitecturas x86 compatibles (incluyendo Pentium® y Athlon™), amd64 compatibles (incluyendo Opteron™, Athlon™64 y EM64T), Alpha/AXP, IA-64, PC-98 y UltraSPARC®. FreeBSD es un derivado de BSD, la versión de UNIX® desarrollada en la Universidad de California, Berkeley. FreeBSD es desarrollado y mantenido por un numeroso equipo de personas. El soporte para otras arquitecturas está en diferentes fases de desarrollo. Características: FreeBSD ofrece altas prestaciones en comunicaciones de red, rendimiento, seguridad y compatibilidad, todavía inexistentes en otros sistemas operativos, incluyendo los comerciales de mayor renombre. Es un sistema operativo multiusuario, capaz de efectuar multitarea con apropiación y multiproceso en plataformas compatibles con múltiples procesadores; el funcionamiento de FreeBSD está inspirado, como dijimos arriba, en BSD, la versión de UNIX desarrollada en Berkeley. Aunque FreeBSD no puede ser propiamente llamado UNIX, al no haber adquirido la debida licencia de The Open Group. FreeBSD sí está hecho para ser compatible con la norma POSIX, al igual que varios otros sistemas "clones de UNIX". El SO incluye el núcleo, la estructura de ficheros del sistema, bibliotecas de la API de C, y algunas utilidades básicas. La versión 9.0 incluyó actualizaciones como:

Un nuevo instalador, bsdinstall fue agregado, y es el instalador usado en los cd/dvd lanzados.

El rápido sistema de ficheros ahora soporta actualizaciones a diario.

ZFS se actualizó a la version 28.

SSH (HPN-SSH) de alta performance.

Highly Available Storage (HAST) framework Otras características: Potentes Soluciones de Internet: FreeBSD es el servidor ideal para servicios de Internet o Intranet. Proporciona unos servicios de red robustos, incluso en situaciones de alta carga, haciendo un uso eficaz de la memoria para mantener buenos tiempos de respuesta con cientos o miles de procesos simultáneos de usuarios. Ejecuta una gran variedad de aplicaciones: La calidad de FreeBSD conbinada con el hoy en día bajo coste del hardware de alta velocidad para PC's hace de este sistema una alternativa muy económica sobre las estaciones de trabajo UNIX® comerciales. Existe gran cantidad de aplicaciones tanto a nivel servidor como usuario.

Page 7: Tp Final Aso

6

Compatibilidad GNU/Linux: FreeBSD es compatible con binarios de varios sistemas operativos de tipo Unix, incluyendo GNU/Linux. La razón de esto es la necesidad de ejecutar algunas aplicaciones desarrolladas para ser ejecutadas en sistemas con el nucleo Linux en las que el código fuente no se distribuye públicamente y, por tanto, no pueden ser portadas a FreeBSD. Algunas de las aplicaciones usadas bajo esta compatibilidad son la versión de GNU/Linux de Adobe Flash Player, Linux-Firefox, Linux-Opera, Netscape, Adobe Acrobat, RealPlayer, VMware, Oracle, WordPerfect, Skype, Doom 3, Quake 4, Unreal Tournament, SeaMonkey y varias más. Arquitectura:

1. Un módulo de kernel que gestiona los contadores de rendimiento de CPU y recopi-la datos de rendimiento. Este módulo también se conectará con otras partes del kernel para recoger los otros datos necesarios.

2. Un demonio de espacio de usuario (pmcstat ) que gestiona el proceso de recopila-ción de datos.

3. Herramientas de usuario que analizan los datos capturados y presentará los resul-tados del análisis para el usuario. Los análisis simples se pueden ejecutar utilizan-do pmcstat.

4. Apoyo a la API como PAPI que miden el rendimiento por proceso.

Page 8: Tp Final Aso

7

Kernel: El kernel de FreeBSD es el corazón del sistema operativo. Es el responsable de la gestión y control de la memoria, reforzamiento de los controles de seguridad, gestión de redes, acceso a dispositivos y muchas cosas más. FreeBSD es un sistema dinámico y configurable, pero a veces sigue siendo necesario reconfigurar y recompilar un kernel hecho a la medida de nuestras necesidades.

Tradicionalmente FreeBSD ha contado con lo que se conoce como un kernel “monolítico”.

Esto quiere decir que el kernel era un gran y único programa que se comunicaba con una

lista previa de dispositivos, y que si se deseaba modificar el comportamiento del kernel se

debía compilar un nuevo kernel y reiniciar el sistema con el nuevo kernel.

Hoy en día FreeBSD evoluciona muy rápidamente hacia un modelo donde la funcionali-

dad del kernel se basa en módulos, los cuales pueden cargarse y descargarse dinámica-

mente de acuerdo a las necesidades del kernel. Esto permite al kernel adaptarse al nuevo

hardware que sale al mercado (como las tarjetas PCMCIA en sistemas portátiles), o bien

añadir nuevas funcionalidades al kernel. Esto es lo que conocemos como kernel modular.

A pesar de lo dicho aún es necesario llevar a cabo cierta configuración estática en la con-

figuración del kernel. A veces se debe a que la funcionalidad del sistema está tan ligada al

kernel que no puede hacerse mediante carga dinámica de módulos. En otros casos puede

tratarse simplemente de que nadie ha programado un módulo para esa funcionalidad con-

creta que pueda cargarse dinámicamente en el kernel.

Configurar un Kernel Personalizado:

Compilar un kernel personalizado es uno de los ritos de iniciación más importantes a los

que los usuarios de casi todos los BSD han de enfrentarse. Este proceso lleva su tiempo,

pero le aportará grandes beneficios a su sistema FreeBSD. A diferencia del ker-

nel GENERIC, con el que puede funcionar una cantidad apabullante de hardware disponi-

ble en el mercado, un kernel personalizado contiene únicamente lo necesario para que

funcione el hardware de su sistema. Obviamente esto tiene sus ventajas:

Mayor rapidez en el arranque del sistema. Dado que el kernel sólo tiene que probar

el hardware que realmente está en el sistema el tiempo que necesitará para

arrancar se reducirá visiblemente.

Menor uso de memoria. Generalmente un kernel personalizado utiliza menos me-

moria que un kernel GENERIC, lo cual es importante ya que el kernel debe encon-

trarse siempre en memoria real. Por ésta razón un kernel personalizado puede ser

de gran utilidad en sistemas con una cantidad limitada de memoria RAM.

Hacer funcionar hardware específico. Un kernel personalizado le permite añadir al

sistema dispositivos como tarjetas de sonido, que no están incluidas en el kernel-

GENERIC.

Page 9: Tp Final Aso

8

Antes de compilar un kernel personalizado conviene pensar antes los motivos. Si lo

que se necesita es añadir hardware específico al sistema es posible que sea posi-

ble utilizarlo mediante un módulo.

Los módulos del kernel están en el directorio /boot/kernel y se pueden cargar di-

námicamente en un kernel en funcionamiento con kldload. La mayoría, por no decir

todos, los controladores del kernel tienen un módulo específico y una página de

manual. Por ejemplo, el controlador Ethernet inalámbrico ath. La página de manual

de este dispositivo contiene la siguiente información:

Alternatively, to load the driver as a module at boot time, place the

following line in loader.conf:

if_ath_load="YES"

Si hace lo que dice ahí, es decir, añadir la línea if_ath_load="YES" al fiche-

ro /boot/loader.conf hará que el módulo se cargue dinámicamente cada vez que el

sistema arranque.

Hay casos, no obstante, en los que no existe el módulo correspondiente. Esto su-

cede con ciertos subsistemas y con controladores muy importantes, como por

ejemplo el de FFS, que necesita el kernel. Igual sucede con la posibilidad de utilizar

redes (INET). Por desgracia, en estos casos la única forma de saber si hace falta

un controlador es buscar el módulo.

En primer lugar, hagamos un breve recorrido por el directorio donde se lleva a cabo la

compilación del kernel. Todos los directorios mencionados hacen referencia al directorio

principal, que es /usr/src/sys, al que también podemos acceder desde /sys. Existen gran

cantidad de subdirectorios que representan diferentes partes del kernel, pero el más importante para lo que deseamos hacer son arch y /conf, que es donde se llevara a cabo

la edición del fichero de configuración y la compilación propiamente dicha del mismo, el

punto de partida para la personalización del kernel. El directorio arch representa la

arquitectura del sistema, por lo que puede

ser i386, alpha, amd64, ia64, powerpc, sparc64 opc98 (una arquitectura alternativa,

similar a PC y muy popular en Japón). Todo lo que existe dentro de un directorio de una

arquitectura en particular, es específico para dicha arquitectura; el resto del código es

común para todas las plataformas en las que FreeBSD puede funcionar. Observe la

organización lógica de la estructura de los directorios, con cada dispositivo utilizable en el

sistema, sistema de ficheros y opciones, cada cosa en su propio subdirectorio.

Asumiremos que estamos utilizando la arquitectura i386, puesto que sobre ella son los

ejemplos que vamos a ir exponiendo. Para otros casos se deben hacer los cambios

adecuados a la arquitectura de hardware en las rutas que vayamos utilizando.

Page 10: Tp Final Aso

9

Nota: Si no existe el directorio /usr/src/sys en el sistema quiere decir que no están instaladas las fuentes del kernel. La forma más sencilla de tenerlas es mediante /stand/sysinstall. Como usuario root seleccione Configure, luego Distributions, después src y finalmente sys. Si no le gusta mucho sysinstall y tiene acceso a un CDROM “oficial” de FreeBSD puede instalar las fuentes por medio de la siguiente línea de órdenes:

# mount /cdrom # mkdir -p /usr/src/sys # ln -s /usr/src/sys /sys # cat /cdrom/sys/ssys.[a-d]* | tar -xzvf

Ahora vamos al directorio arch/conf y copiamos el fichero de configuración GENERIC con

el nombre que deseemos. Por ejemplo:

# cd /usr/src/sys/i386/conf

# cp GENERIC MIKERNEL

Por tradición el nombre se escribe con mayúsuculas y si se tienen varias máquinas

FreeBSD, con diferente hardware es recomendable darle a cada kernel el mismo nombre

que la máquina en la que va a ejecutarse. En este ejemplo usaremos el nombre

de MIKERNEL.

Sugerencia: Guardar el fichero de configuración directamente bajo el directorio /usr/src, puede que no sea una idea muy astuta. Si se empiezan a tener problemas puede ser muy tentador borrar /usr/src y comenzar desde cero. Cinco segundos después de haber hecho esto nos daremos cuenta de que hemos eliminado el fichero de configuración de nuestro kernel, en el que quizás llevabamos horas trabajando.

Una alternativa: guardar el fichero de configuración en cualquier otro lugar y crear un enlace simbólico al fichero que hay en el directorio i386.

Por ejemplo:

# cd /usr/src/sys/i386/conf

# mkdir /root/kernels

# cp GENERIC /root/kernels/MIKERNEL

# ln -s /root/kernels/MIKERNEL

Ahora editamos el fichero de configuración MIKERNEL con algún editor de textos.

FreeBSD dispone de un editor de uso muy sencillo, llamado ee. Cambiamos los

comentarios al principio del fichero con algo que refleje los cambios realizados o al menos

para diferenciarlo del fichero GENERIC.

Page 11: Tp Final Aso

10

Ahora es momento de llevar a cabo la compilación del código fuente del kernel.

Compilación del kernel

1. Vamos al directorio /usr/src:

# cd /usr/src

2. Compilamos el kernel:

# make buildkernel KERNCONF=MIKERNEL

3. Instalamos el nuevo kernel:

# make installkernel KERNCONF=MIKERNEL

Comando pmcstat: Nombre: pmcstat -- medición del desempeño con el hardware de control de rendimiento. Descripción: La utilidad pmcstat puede medir tanto los eventos de hardware detectados por el sistema en conjunto, como aquellos vistos cuando un grupo especificado de procesos están siendo ejecutados. Si un grupo específico de procesos está en la mira (por ejemplo, si la opción –t process-spec es especificada, o si una linea de commando es especificada usando command), entonces la medición ocurre hasta que el command exista, o hasta que todos los procesos seleccionados especificados por la opción –t process-spec termine, o hasta que la utilidad pmcstat es interrumpida por el usuario. Si un grupo específico de procesos no es seleccionado para medición, el comando pmcstat producirá una larga medición por todo el sistema hasta que se interrumpla por el usuario. Una invocación de pmcstat puede mezclar alocaciones PMC en modo sistema y modo proceso. Los valores de todos los conteos de PMC son impresos en pantalla de forma legible para el humano en intervalos por el pmcstat. Algunas Opciones: Las siguientes opciones están disponibles: -D pathname Crea archivos con muestras por programa en el directorio llamado por el pathname. Por default se crean estos archivos en el directorio actual. -O logfilename

Page 12: Tp Final Aso

11

Envía la salida de registro al archivo: logfilename. Si logfilename es de la forma: hostname:port, donde hostname no empieza con ‘’-” o un “/”, entonces pmcstat abrirá una conexión de red al host: hostname en el puerto: port. -R logfilename Realiza un análisis offline con los datos de maestro en el archive: logfilename. Ejemplo: Para recopilar información de los perfiles para un proceso específico con pid 1234 sobre la base de caché de instrucciones se pierde vista por usarlo: $pmcstat -P ic-misses -t 1234 -O /tmp/sample.out

PAPI

Performance Application Programming Interface: Tiene como objetivo proporcionar el diseñador de la herramienta y el ingeniero de aplicación una interfaz consistente y una metodología para el uso del contador de rendimiento de hardware encontrado en la mayoría de los microprocesadores más importantes. PAPI permite a los ingenieros de software ver, en tiempo casi real, la relación entre el rendimiento del software y los eventos del procesador.

Page 13: Tp Final Aso

12

Instalación de FreeBSD: La versión seleccionada es FreeBSD 9.0x86, la cual fue obtenida libre y gratuitamente de la web oficial del proyecto FreeBSD¹. La instalación del Sistema Operativo, se realizó en una Máquina Virtual provista por el software de Oracle: VM VirtualBox bajo 2 entornos Linux, específicamente: Fedora 15 y Linux Mint. También se probó en Windows 7 Ultimate. A continuación se detallará paso a paso el momento de instalación del Sistema Operativo incluyendo la adaptación del escritorio Gnome 2 mediante repositorios propios del proyecto FreeBSD: Primeramente se creó una máquina virtual con las siguientes características: Disco Rígido de 10GB, memoria RAM de 2048MB, memoria de Video: 128MB, se habilitó el conector de red inalámbrica para obtener información de los repositorios y se estipuló que la máquina utilice solo un procesador para un SO de 32 bits:

Page 14: Tp Final Aso

13

El paso siguiente fue configurar la máquina virtual para que pudiese bootear el instalador del Sistema Operativo desde una imagen ISO descargada de la web oficial de FreeBSD. Una vez realizado esto, el VirtualBox comenzará a ejecutar el instalador:

El instalador ofrece varias alternativas para la instalación: <Install>, que se refiere a directamente comenzar la instalación; <Shell> que nos ofrece una interfaz de terminal para efectuar comandos y <Live CD> que nos permite probar el SO pero sin guardar los datos permanentemente. La opción que le elegimos fue Install para efectivamente introducirnos en la configuración de la instalación del SO.

Page 15: Tp Final Aso

14

Luego el instalador consulta al usuario si desea establecer una distribución de teclado específica:

Page 16: Tp Final Aso

15

En esta pantalla elegiremos la opción acorde al teclado que tengamos, ya sea el de una Notebook o una Desktop:

Page 17: Tp Final Aso

16

En la pantalla siguiente se tiene que ingresar un nombre apropiado para el Host, es decir, el nombre que recibe la Red de computadoras a las cuales esté acoplada (en el caso que lo esté) la computadora donde se está instalando FreeBSD:

Page 18: Tp Final Aso

17

Luego el instalador nos ofrecerá de manera opcional, adherir a nuestra instalación base del Sistema Operativo, algunos componentes opcionales dentro del mismo:

Page 19: Tp Final Aso

18

Terminada la elección, aparecerá una pantalla donde se nos solicita de que forma gestionaremos la o las particiones de nuestro disco rígido para instalar el SO. Una de las opciones está relacionada con una forma guiada de instalación, en la cuál el instalador creará las particiones pertinentes. Otra opción es la de seleccionar uno mismo el tamaño y el formato de las particiones donde se instalará el SO mediante una herramienta que provee el instalador. Por último, se puede también configurar las particiones mediante el Shell.

Page 20: Tp Final Aso

19

Seleccionamos la opción automática y vemos que el programa detecta nuestro disco rígido y nos pide confirmación para instalar el SO en todo el disco o si queremos particionarlo para instalar otros sistemas operativos:

Page 21: Tp Final Aso

20

A continuación se nos pide que confirmemos la configuración selecta por el SO:

Page 22: Tp Final Aso

21

Así entonces se comenzará a instalar el SO con todos sus componentes:

Page 23: Tp Final Aso

22

Una vez que se cumplimente el paso anterior, se le pide al usuario establecer la contraseña para el Root:

Page 24: Tp Final Aso

23

El paso siguiente es la configuración de la interfaz de red, resumidamente, el programa instalador nos dará la información paso a paso para poder lograr con éxito la conexión a la red local:

Antes de finalizar la instalación, tenemos que establecer la región y la zona horaria para nuestro Sistema:

Page 25: Tp Final Aso

24

Page 26: Tp Final Aso

25

También, el instalador solicita al usuario que determine que servicios arrancarán al inicio del SO:

Page 27: Tp Final Aso

26

Una de las herramientas que nos ofrece el programa instalador es la de agregar usuarios:

Page 28: Tp Final Aso

27

Para dichos nuevos usuarios, estableceremos datos como: Username (nombre de usuario), Grupo al que pertenecerá el usuario, forma de autenticar al usuario (contraseña automática o ingresada), etc:

Page 29: Tp Final Aso

28

Agregamos otro usuario más y luego continuaremos con la instalación:

Page 30: Tp Final Aso

29

Luego aparecerá un panel para hacer modificaciones a los componentes previamente instalados y comenzará a actualizarse el sistema. Después de esos pasos ya tendremos nuestro sistema FreeBSD completamente instalado, solo tendremos que rebootear el disco y entrar al SO:

Page 31: Tp Final Aso

30

Se nos presenta entonces la pantalla principal de booteo de FreeBSD:

Page 32: Tp Final Aso

31

Antes que nada el sistema nos pide que ingresemos en modo root:

Page 33: Tp Final Aso

32

Con los datos ingresados de forma correcta ya estamos en condiciones de empezar a trabajar con FreeBSD:

Page 34: Tp Final Aso

33

Instalando nuestra Interfaz Gráfica: Instalación de XORG: Una vez que tenemos nuestro SO FreeBSD preparado, lo que haremos es instalar y configurar una interfaz gráfica de usuario para poder movernos a través del sistema de una forma mucho más práctica, intuitiva y disfrutable. Para ello, antes que seleccionar el entorno de escritorio acorde a nuestras preferencias, debemos instalar el sistema de ventanas X http://www.x.org/wiki/). Lo hacemos con el siguiente comando: # pkg_add -r xorg Una vez que termine de instalarse hay que generar el archivo xorg.conf de la siguiente manera:

# Xorg -configure

Este comando nos va a crear un archivo llamado xorg.conf.new el cual puede ser probado

para ver si todo funciona correctamente bien de la siguiente manera:

# Xorg -config xorg.conf.new -retro

Si aparece una pantalla con cuadrícula con el puntero del ratón enmedio entonces

significa que el archivo fue generado correctamente. Para salir de esta pantalla tecleamos

Ctrl + Alt + F1. Una vez generado el archivo procedemos a renombrarlo y a ubicarlo

dentro del directorio /etc/X11:

# cp xorg.conf.new /etc/X11/xorg.conf

Instalación de GNOME 2 en FreeBSD:

Luego de que finalizamos la instalación de Xorg, nos disponemos a instalar nuestro

entorno de escritorio, el elegido en este caso es GNOME 2. Para ello, con un simple

comando accedemos a los ports del SO y se instala automáticamente:

# pkg_add -r gnome2 Luego de apretar la tecla Enter, comenzará una larga instalación en el cuál no solo se instalaran los componentes básicos del escritorio sino algunas aplicaciones como Evolution (cliente de correo) o Epiphany (navegador web). Una vez que la misma termine,

Page 35: Tp Final Aso

34

lo que hay que hacer es determinar que se va a arrancar con el ambiente gráfico de nuestro gusto cuando se llame al comando “startx” y para eso hacemos lo siguiente: Primero: tenemos que abrir el archivo rc.conf ubicado en el directorio /etc y agregar unas líneas. Para ello, utilizaremos el editor de texto VI de la siguiente manera: # vi /etc/rc.conf Este comando nos abrirá una pantalla en la cual figura el contenido del documento y en el cual podremos agregar nuevas líneas. Las líneas a agregar son: • gnome_enable=”YES” • gdm_enable=”YES” • hald_enable=”YES” • dbus_enable=”YES”

Permite que Gnome se

cargue al inicio del SO.

El sistema reconoce el

teclado y el mouse al

inicio..

Page 36: Tp Final Aso

35

Una vez realizados estos cambios, guardamos el documento apretando SHIFT+ZZ. Terminada dicha labor, indicamos al SO que realice un reinicio, para ello escribimos en la terminal: # reboot

Page 37: Tp Final Aso

36

Esperamos a que realice el reboot y cuando termine podremos disfrutar de nuestra nueva interfaz gráfica de usuario, la cual nos ofrecerá elegir entre los usuarios que agregamos al inicio de la instalación:

Page 38: Tp Final Aso

37

Administración de usuarios: Para crear usuarios y grupos hay que estar en modo root. El grupo es simple, porque sólo hay que especificar el nombre del grupo.Para crear un grupo llamado AlumnosUAI se pone lo siguiente en linea de comandos. # pw groupadd AlumnosUAI Ahora, para crear un nuevo usuario, que pertenece a este grupo, se pone lo siguiente:

# pw useradd Jacobo_Julian -c "Algun comentario" -m -d /home/Jacobo_Julian -s /usr/local/bin/bash -g AlumnosUAI

Donde:

-c es para dejar algún comentario del nuevoUsuario.

-m es para que todos los archivos que este usuario deje en su directorio queden a nombre de él.

-d es el directorio raiz del nuevoUsuario

-s shell del nuevoUsuario

-g grupo del nuevoUsuario

Finalmente, asignarle una clave.

# passwd Jacobo_Julian

También se pueden agregar un usuario con el comando: # adduser -v Para eliminar un usuario simplemente ingresamos: # rmuser Luego ingresamos el nombre de usuario, y nos preguntara si queremos eliminarlo, ingresamos “yes” y el usuario es automáticamente eliminado.

Page 39: Tp Final Aso

38

Chpass

chpass cambia información de los usuarios en base de datos como contraseñas, shells y datos personales. Los administradores del sistema, como el superusuario, son los únicos que pueden modificar la información y contraseñas de otros usuarios con chpass. Cuando no le pasamos más opciones, salvo un nombre de usuario opcional, chpass muestra un editor con información de usuario. Cuando se sale del editor la base de datos de usuarios se actualiza con la nueva información.

Ejemplo de chpass interactivo ejecutado por el superusuario

Chpass Julian #Changing user database information for Julian. Login: Julian Password: * Uid [#]: 1000 Gid [# or name]: 1000 Change [month day year]: Expire [month day year]: Class: Home directory: /home/Julian Shell: /usr/local/bin/tcsh Full Name: J. Bacelli Office Location: Office Phone: Home Phone: Other information:

Un usuario normal puede modificar un pequeño subconjunto de esta información, y sólo para sí mismo.

Ejemplo de chpass interactivo ejecutado por un usuario normal

#Changing user database information for Jacobo. Shell: /usr/local/bin/tcsh Full Name: J. Dominguez Office Location: Office Phone: Home Phone: Other information:

Page 40: Tp Final Aso

39

Passwd

passwd es el comando que usamos normalmente para cambiar nuestra propia contraseña como usuario o, como superusuario, la de otros usuarios.

Ejemplo de cambio de nuestra contraseña

% passwd Changing local password for Julian. Old password: New password: Retype new password: passwd: updating the database... passwd: done

Ejemplo de cambio de la contraseña de otro usuario como superusuario

# passwd Jacobo Changing local password for Jacobo. New password: Retype new password: passwd: updating the database... passwd: done

Cambiar a un usuario de grupo

Si no queremos editar /etc/group manualmente, puodemos usar el comando pw para añadir y

modificar grupos. Por ejemplo, para añadir un grupo llamado UAI y luego confirmar que existe

podemos usar:

Ejemplo añadir un grupo usando pw

# pw groupadd UAI # pw groupshow UAI teamtwo:*:1100:

El número 1100 en el ejemplo anterior es el ID de grupo del grupo UAI. Ahora mismo UAI no tiene

miembros, y es por tanto bastante inútil. Cambiemos eso invitando a Julian a formar parte del

grupo UAI.

Ejemplo añadir a alguien a un grupo usando pw

# pw groupmod UAI -M Julian # pw groupshow UAI UAI:*:1100:Julian

Page 41: Tp Final Aso

40

Login y Logout La pantalla de login muestra una línea pidiendo nombre de usuario, y luego contraseña, en caso de que ingresemos los datos correctos, accederemos al sistema, en caso contrario nos informa que los datos ingresados son invalidos, y nos devuelve a la misma pantalla de login. Para desloguear, y ver nuevamente la pantalla de login, ingresamos el comando: # exit Para apagar la máquina: # shutdown -h now Para rebootear la máquina: # shutdown -r now o # reboot Usuarios activos Se utilizan los siguientes comandos: id # Muestra id de usuarios activos, grupo y login. last # muestra los últimos logins al sistema. who # Quién está activo en el sistema. Ttys El fichero /etc/ttys lista todos los puertos en su sistema FreeBSD donde queremos permitir logins. Por ejemplo, la primera consola virtual ttyv0 tiene una entrada en este fichero. Puede firmarse en la consola utilizando esta entrada. Este fichero también contiene entradas para las otras consolas virtuales, puertos serie y pseudo-ttys. Para una terminal conectada por cable, solo listamos la entrada /dev del puerto serie sin la parte de /dev (por ejemplo, /dev/ttyv0 debería estar listado como ttyv0). Una instalación por omisión de FreeBSD incluye un fichero /etc/ttys con soporte para los primeros cuatro puertos serie: ttyd0 hasta ttyd3. Si está conectando una terminal a uno de esos puertos, no necesita agregar otra entrada.

Page 42: Tp Final Aso

41

Sudoers y permisos Por defecto, FreeBSD sólo permite acceso root a usuarios incluidos en el grupo wheel, un grupo reservado para tareas de administración al que inicialmente sólo pertenece el propio root. Por tanto, si queremos que nuestro usuario "Julian" pueda tener permisos de superusuario, una buena manera es "loguearnos" como root y agregar "Julian" al grupo wheel. En primer lugar comprobamos si ya está incluido: # pw showgroup wheel

wheel:*:root No, no está. Para añadirlo: # pw user mod Julian -G wheel Comprobamos de nuevo si "Julian" está en el grupo wheel: # pw showgroup wheel

wheel:*:root,Julian Ahora sí; ya podemos usar nuestra cuenta "pepe" y con un simple su (+contraseña) obtener privilegios de root cuando los necesitemos. Al finalizar las operaciones debemos abandonar la cuenta root tecleando exit (o Ctrl-D). PAM Igual que Linux, FreeBSD ofrece soporte para PAM (Pluggable Authentication Modules). Con PAM el administrador puede reforzar el modelo tradicional de autentificación usuario/contraseña. FreeBSD dispone de módulos para integrar PAM en una amplia gama de mecanismos de autenticación. Estos son algunos de ellos:

Kerberos 5

OPIE

RADIUS

TACACS+ También es posible configurar normas que se encarguen de problemas de control de autentificación como la calidad de las contraseñas que los usuarios puedan elegir.

Page 43: Tp Final Aso

42

Procesos: FreeBSD es un sistema operativo multitarea. Esto significa que parece como si más de un programa se estuviera ejecutando al mismo tiempo. Cada programa uno de esos programas que se está ejecutando en un momento dado se denomina proceso. Cada orden que ejecuta iniciará al menos un proceso nuevo, y hay muchos procesos que se están que se están ejecutando en todo momento, manteniendo el sistema en funcionamiento. Tipos de procesos: • Los procesos de usuario son aquellos procesos asociados a un determinado usuario. Se ejecutan en modo usuario excepto cuando realizan llamadas al sistema para acceder a los recursos del sistema, en ese momento pasan a ser ejecutados en modo núcleo.

• Los procesos demonio no están asociados a ningún usuario. Al igual que los proceso de usuario, son ejecutados en modo usuario excepto cuando realizan llamadas al sistema. En ese momento pasan a ser ejecutados en modo núcleo. Los procesos demonio realizan tareas periódicas relacionadas con la administración del sistema, como por ejemplo: la administración y control de redes, la ejecución de actividades dependientes del tiempo, la administración de trabajos en las impresoras en línea, etc.

• Los procesos del núcleo no están asociados a ningún usuario. Se ejecutan exclusivamente en modo núcleo. Son similares a los procesos demonio en el sentido de que realizan tareas de administración del sistema, como por ejemplo, el intercambio de procesos (proceso intercambiador) o de páginas (proceso ladrón de páginas) a memoria secundaria. Su principal ventaja respecto a los procesos demonio es que poseen un mayor control sobre sus prioridades de planificación puesto que su código es parte del núcleo. Por ello pueden acceder directamente a los algoritmos y estructuras de datos del núcleo sin hacer uso de las llamadas al sistema, en consecuencia son extremadamente potentes. Sin embargo no son tan flexibles como los procesos demonio, ya que para modificarlos se debe de recompilar el núcleo.

Loader

Un Loader es la parte del Sistema Operativo responsable de la carga de programas. Es una de las etapas esenciales en el proceso de inicializar un programa, se encarga de localizar los programas en la memoria y los prepara para su ejecución. Cargar un programa consiste en leer el contenido del archivo ejecutable, el archivo que contiene el texto del programa, en la memoria, y luego llevar a cabo otras tareas necesarias para preparar el ejecutable y así correrlo. Una vez que la carga se completa, el Sistema Operativo inicia el programa traspasándole el control al código del programa cargado. En los sistemas Unix, el cargador es el manejador para la llamada del sistema execve().

Page 44: Tp Final Aso

43

Comando ld

• Nombre:

ld – Usando LD, el enlazador GNU.

• Sinópsis:

ld [opciones] ArchivoObjeto ...

• Descripción:

Cuando se requiere que un archivo que se encuentra, por ejemplo, en lenguaje C, sea compilado y luego esté listo para ejecutarse, es necesario que luego de estar ensamblado, incorpore las funciones que tienen algunas de sus instrucciones que están ubicadas en librerías especiales (por ejemplo: printf, se encuentra en la librería stdio.h). Para lograr esto, se utiliza el comando ld, cuya función es la de enlazar el contenido de las librerías que se utilicen en las instrucciones del archivo objeto. Se obtiene de esta forma un archivo ejecutable.

Ejemplo:

Se tiene un archivo escrito en C que se encarga de calcular el área de un círculo cuyo radio se ingresa por teclado.

$ ld -o area_circulo /usr/lib/gcc-lib/i386-linux/2.95.2/collect2 -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o circulo /usr/lib/crt1.o /usr/lib/crti.o /usr/lib/gcc -lib/i386-linux/2.95.2/crtbegin.o-L/usr/lib/gcc-lib/i386-linux/2.95.2 circulo.o -lgcc -lc -lgcc /usr/lib/gcc-lib/i386-linux/2.95.2/crtend.o/usr/lib/crtn.o Se puede observar como se incluyen los componentes antes nombrados.

Utilidades para ver Procesos en ejecución:

Cada proceso tiene un identificador individual consistente en un número llamado ID del proceso, o PID, y al igual que sucede con los ficheros, cada proceso tiene un propietario y un grupo. La información de propietario y grupo se usa para determinar qué ficheros y dispositivos puede abrir el proceso mediante los permisos de fichero. La mayoría de los procesos también tiene un proceso padre. El proceso padre es el proceso que los inició. Por ejemplo, si se está tecleando órdenes en la shell, la shell es un proceso, y cualquier orden que se ejecute también lo será. De este modo cada proceso que se ejecute tendrá como proceso padre a su shell. La excepción es un proceso especial llamado init. Init es siempre el primer proceso, así que su PID siempre es 1. El kernel arranca automáticamente init en el arranque de FreeBSD.

Page 45: Tp Final Aso

44

Utilidades para ver Procesos:

Hay dos órdenes particularmente útiles para ver los procesos en el sistema, ps y top.

PS

Se usa para mostrar una lista estática de los procesos que se ejecutan en el sistema en el

momento que se ejecuta la orden, y puede mostrar sus PID, cuánta memoria está usando,

la línea de órdenes con la que fueron iniciados y demás aspectos.

Como se puede ver en el ejemplo la salida de ps está organizada en columnas.PID es el

ID de proceso anteriormente expuesto. Los PIDs se asignan a partir del 1 y hasta 99999,

y vuelven a comenzar desde el 1 otra vez cuando se terminan los números. La columna

TT muestra la tty en la que el programa se está ejecutando. STAT muestra el estado del

programa; de momento también podemos ignorarlo. TIME es la cantidad de tiempo que el

programa ha se ha estado ejecutando en la CPU (generalmente no es el tiempo

transcurrido desde que se inició el programa, ya que la mayoría de los programas pasan

mucho tiempo esperando antes de que necesiten gastar tiempo en la CPU). Finalmente,

COMMAND es la línea de órdenes que se empleó para ejecutar el programa.

Ps admite muchas opciones sobre la información que se desea ver. Uno de los conjuntos

más útiles es auxww; a muestra información acerca de todos los procesos ejecutándose,

no solamente los suyos; u despliega el nombre de usuario del propietario del proceso, así

como el uso de memoria; x despliega información acerca de los procesos dæmon y ww

hace que ps despliegue la línea de órdenes completa, en lugar de truncarla cuando es

demasiado larga para caber en la pantalla.

Page 46: Tp Final Aso

45

Algunas opciones para utilizar con el comando ps:

-a Muestra información acerca de procesos de otros usuarios además de los

propios. -c Cambia la columna COMMAND para solo contener el nombre del ejecutable en vez de toda la linea de comando. -d Ordena procesos de forma descendente y prefija cada comando con sangría de texto, mostrando las relaciones de Hermano y Padre/Hijo. Si las opciones -m y -r son también usadas, se controla cómo los procesos de hermanos se ordenan uno respecto al otro.

-f Muestra información del commandline y el environment acerca de los procesos que fueron intercambiados (swap). Esta opción es válida solo si el UID del usuario es 0. -G Muestra información sobre los procesos que se ejecutan con los ID's de grupo reales especificados. -H Muestra todos los hilos del núcleo visibles asociados a cada proceso. Dependiendo del threading package que está en uso, esto puede mostrar sólo el proceso, sólo las entidades del núcleo programadas, o la totalidad de hilos del proceso. -m Ordena por uso de la memoria, en lugar de la combinación de control de Identificación del terminal y del proceso. -p Muestra información sobre los procesos que coinciden con los identificadores de proceso especificados.

-r Ordena por uso de la CPU actual, en lugar de la combinación de control de Identificación del terminal y del proceso. -T Muestra información acerca de los procesos vinculados al dispositivo asociado a la entrada estándar.

Page 47: Tp Final Aso

46

TOP

Despliega todos los procesos que se están ejecutando y actualiza la pantalla cada pocos

segundos para que pueda ver lo que está haciendo su sistema.

La salida está dividida en dos secciones. La cabecera (las primeras cinco líneas) muestra el PID del último proceso en ejecutarse, la carga promedio del sistema (una medida de la carga del sistema), el «uptime» del sistema (tiempo desde el último reinicio) y la hora actual. Las otras cifras en la cabecera se relacionan con cuántos procesos hay en ejecución en el sistema (69 en este caso), cuánta memoria y espacio de intercambio (swap) está en uso, y cuánto tiempo está el sistema en diferentes estados de CPU.

Más abajo hay una serie de columnas con información similar a la salida de ps. Igual que

antes, se puede ver el PID, el nombre de usuario, la cantidad de tiempo de CPU en uso y

la orden que se ejecutó. También se mostrará por omisión la cantidad de espacio de

memoria que emplea cada proceso. Está dividido en dos columnas, una para el tamaño

total y otra para el tamaño residente (el tamaño total es cuánta memoria ha necesitado la

aplicación y el tamaño residente es cuánta se está usando en ese momento concreto). En

este ejemplo puede verse que el proceso referido a Nautilus ha requerido casi 56MB de

RAM, pero actualmente solo está usando 32MB.

Page 48: Tp Final Aso

47

Opciones:

-S Muestra los procesos del sistema en la pantalla, normalmente, procesos de sistema como el paginador o el intercambiador no son mostrados. Esta opción los hace visibles. -H Muestra cada hilo de un proceso multihilo de forma individual. Por defecto, solo una linea resumen es mostrada por cada proceso.

-I No muestra los procesos inactivos. Por defecto, el comando top muestra ambos, activos e inactivos.

-stime Determina el delay en las actualizaciones de pantalla a time segundos. Por defecto, este valor es de 2 segundos.

-Uusername Muestra solamente aquellos procesos adquiridos por username. Esta opción solo acepta nombres de usuario y no entiende números.

Dæmons, señales y cómo matar procesos

Cuando se ejecuta por ejemplo un editor, es fácil controlarlo, decirle que cargue ficheros y

demás. Puede hacerse porque el editor permite ese control y porque el editor depende de una terminal. Algunos programas no están diseñados para que se ejecuten entradas

continuas por parte del usuario, así que se desconectan de la terminal a la primera

oportunidad. Por ejemplo, un servidor web pasa todo el día respondiendo peticiones web

y normalmente no necesita que usted le haga caso. Los programas que transportan

correo electrónico de un sitio a otro son otro ejemplo de esta clase de

aplicación.Llamamos a estos programas dæmons.

Hay una norma según la cual se da nombre a los programas que suelen ejecutarse como

dæmons con una «d» final. BIND es el dæmon de nombres de Berkeley (y el programa

que en realidad se ejecuta se llama named); el servidor web Apache se llama httpd, el

dæmon de «spool» de impresora de línea es lpd y así sucesivamente. Se trata de un

acuerdo, no una ley férrea; por ejemplo el dæmon principal de correo de Sendmail se

llama sendmail, y no maild, como podría suponerse visto lo precedente.

Algunas veces necesitaremos comunicarnos con un dæmon. Estas comunicaciones se

denominan señales; es posible comunicarse con un dæmon (o con cualquier otro proceso

ejecutándose) mandándole una señal. Existen diversos tipos de señales diferentes que

podemos mandar: algunas tienen un significado especial, otras son interpretadas por la

aplicación y la documentación de la aplicación nos dirá cómo interpreta la señal esa

aplicación). Solamente podemos enviar una señal a un proceso del que seamos

propietarios. Si mandamos una señal a un proceso de otro usuario con kill veremos un

mensaje del sistema en el que se nos comunica que no tenemos permiso para hacer tal

cosa. La excepción a esto es el usuario root, que puede mandar señales a los procesos

de cualquier usuario del sistema.

Page 49: Tp Final Aso

48

FreeBSD también enviará señales de aplicación en determinados casos. Si una aplicación

está mal escrita y trata de acceder a memoria a la que no está previsto que acceda

FreeBSD, el sistema envía al proceso la señal Violación de segmento (SIGSEGV). Si una

aplicación ha utilizado la llamada de sistema alarm para ser avisada después de que un

periodo de tiempo haya transcurrido se le mandará la señal de alarma (SIGALRM), y así

sucesivamente.

Hay dos señales que pueden usarse para detener un proceso, SIGTERM y SIGKILL.

SIGTERM es la manera amable de matar un proceso; el proceso puede recibir la señal,

darse cuenta que queremos que se apague, cerrar cualquier fichero de log que pueda

tener abierto y generalmente terminar cualquier tarea que esté realizando en ese

momento antes de apagarse. En algunos casos un proceso puede incluso ignorar

SIGTERM si se encuentra inmerso en una tarea que no puede ser interrumpida.

Por el contrario, un proceso no puede ignorar una señal SIGKILL. Esta es la señal “No me

importa lo que estás haciendo, terminalo ya!”. Si manda un SIGKILL a un proceso

FreeBSD detendrá ese proceso inmediatamente.

Otras señales que puede usar: SIGHUP, SIGUSR1 y SIGUSR2. Son señales de propósito

general, y aplicaciones diferentes pueden hacer cosas diferentes cuando se utilicen.

Supongamos que cambiamos el fichero de configuración de su servidor web; es un buen

momento para decirle al servidor web que lea y aplique la configuración. Podríamos

detener y reiniciar httpd, pero esto implicaría un período breve de suspensión del servicio

de nuestro servidor web, lo cual puede no ser asumible. La mayoría de los dæmons

fueron creados pensando en que fueran capaces de responder a la señal SIGHUP

releyendo su fichero de configuración. En lugar de matar y reiniciar httpd le podríamos

mandar la señal SIGHUP. Dado que no hay una manera estándar para responder a estas

señales, diferentes dæmons tendrán diferente comportamiento.

Opciones para el comando Kill:

-s signal_name El nombre de una señal simbólica especificando la señal que va a ser enviada en vez de la que está por defecto: TERM. -l [exit_status] Si no damos ningún operando, lista los nombres de las señales; en otro caso, escribimos el nombre de la señal correspondiente en exit_status. -signal_name El nombre de una señal simbólica especificando la señal que va a ser enviada en vez de la que está por defecto: TERM. -signal_number Un número no negativo entero especificando la señal que va a ser enviada en vez de la que está por defecto: TERM.

Page 50: Tp Final Aso

49

Los siguientes PIDs tienen significados especiales: -1 Si somos superusuario, se transmite la señal a todos los procesos; de otra manera, se transmite la señal a todos los procesos que pertenecen al usuario que emitió la instrucción. Algunas de las señales comúnmente usadas: 1 HUP (colgar): vuelve a cargar y analizar los ficheros de configuración y se reconfigura de acuerdo a los cambios. 2 INT (interrumpir): interrumpe el proceso en ejecución. 3 QUIT (salir): sale del proceso en ejecución. 6 ABRT (abortar): aborta el proceso en ejecución. 9 KILL (no capturable, no ignorable kill): mata el proceso en ejecución cuando este termine de hacer la tarea que está realizando. 14 ALRM (alarma de reloj): activa una alarma cada un intervalo definido. 15 TERM (señal de terminación de software): termina inmediatamente un proceso u aplicación. EXIT STATUS La utilidad kill arroja 0 si no hubo conflictos, y arroja un número mayor que 0 si ocurrió un error. Ejemplos Terminar el proceso con los PIDs 142 y 157 $ kill 142 157 Envía la señal de colgar al proceso con el PID 507: $ kill -s HUP 507 Terminar el grupo de procesos con el PGID 117: $ kill -- -117

Page 51: Tp Final Aso

50

Administracion de recursos:

Permisos en archivos

Cada archivo tiene un conjunto de permisos asociados con él, los cuales determinen que hacerse con el archivo y quien puede hacerlo. Existe un usuario especial en cada sistema, llamado superusuario, quien puede leer o modificar cualquier archivo en el sistema. La clase de acceso especial root posee privilegios de superusuario: esta la emplean los administradores del sistema cuando llevan a cabo el mantenimiento del mismo. Existe también un comando llamado su que otorga un status de superusuario si se conoce la contraseña de root. Por eso no es recomendable guarda ningún material confidencial en el sistema de archivos. Si el usuario requiere mayor seguridad, puede cambiar los datos en un archivo de manera que ni aun el superusuario puede leerla (o al menos entenderla ) usando el comando crypt. Cuando un usuario entra en sesión, teclea un nombre y después confirma que efectivamente es esa persona tecleando una contraseña (password) El nombre es la identificación para iniciar la sesión del usuario, o login-id. Pero el sistema en realidad reconoce al usuario por medio de un número, llamado su “identificación (o identificación) de usuario ” o uid. El sistema de archivos y por tanto el sistema UNIX en general determinan lo que el usuario hace mediante los permisos otorgados a su uid y a su group-id. El archivo es texto ordinario, pero las definiciones de los campos y los separadores son una convención reconocida por los programas que usan la información del archivo. Existen tres tipos de permisos para cada archivo: leer, escribir y ejecución. Además, se puede aplicar un permiso diferente a cada persona. Como dueño de un archivo, el lector posee un conjunto de permisos de lectura, escritura y ejecución. Su grupo tiene otro conjunto. Los demás tienen un tercer conjunto. El bit de set-uid es una idea simple pero elegante que resuelve varios problemas de seguridad. Es particularmente serio para un programa con atributo set-uid ya que root tiene permisos de acceso a cualquier archivo en el sistema. (Algunos sistemas UNIX apagan el bit-uid cuando un archivo se modifica, para reducir el peligro de una falla de seguridad). Existen llamadas al sistema que crean y borran archivos, y solo a través de ellas es posible cambiar el contenido de un directorio. Sin embargo, la idea de los permisos aun se aplica. Los permisos para borrar archivos son independientes del archivo mismo. Si el usuario tiene permiso de escritura en un directorio, puede borrar archivos de él, aun los que estén protegidos contra escritura.

Ver un archivo.

Para ver el contenido de un archivo podemos escribir: o cat o more o less

Page 52: Tp Final Aso

51

Cat cat <fichero>, y veremos el contenido de un fichero, por ejemplo cat carta.txt veremos el contenido de la carta, pero si la carta es demasiado grande deberemos escribir un parámetro para poder leer detenidamente el contenido, es "|more", entonces, para cartas largas escribimos: cat carta.txt |more

More more <fichero>, realiza la misma opción de cat carta.txt |more, pero evidentemente tendremos que escribir menos, bastará con el comando de la siguiente manera: more carta.txt Less Ya que con cat, perderemos el contenido del fichero por la parte superior de la pantalla, con less, podremos navegar por el fichero, y con los cursores podremos ir para arriba y para abajo dentro del mismo fichero: less carta.txt Ver un archivo comprimido. Para ver un archivo comprimido, y sin quererlo descomprimir utilizamos los comandos zcat, zmore y zless, que realizan las mismas cosas que cat, more y less respectivamente, pero en ficheros comprimidos. Copiar un Archivo Para copiar un archivo utilizaremos el comando cp, este comando es muy potente, su funcionamiento es el siguiente:

cp <origen> <destino>

Así, por ejemplo, si queremos copiar la carta "carta.txt" como "MiCarta.txt", escribimos:

$ cp carta.txt MiCarta.txt

También indicaremos la ruta de origen y destino (directorios en el que está situado), por ejemplo, supongamos que escribimos pwd, y nos dicen que estamos en:

/home/JulianJacobo

Queremos copiar el archivo FAQ que hay en /usr/doc/HOWTO/ a nuestro directorio MisDocumentos, que se encuentra en /home/JulianJacobo/MisDocumentos, podremos escribir:

$ cp /usr/doc/HOWTO/FAQ MisDocumentos/ o

Page 53: Tp Final Aso

52

$ cp /usr/doc/HOWTO/FAQ /home/JulianJacobo/MisDocuementos/ Mover un Archivo Mover un archivo, significa, quitarlo de su posición actual para fijarlo donde se le indique, esta operación, se hace con mv de la siguiente manera:

$ mv fichero_o_directorio_a_mover ruta_donde_moverlo

Supongamos que nos encontramos en: /home/JulianJacobo Por ejemplo para mover el fichero "mbox" que está en mi directorio al directorio MisDocumentos/JulianJacobo/ que está en /usr, escribimos:

$ mv mbox /usr/MisDocumentos/

Ahora, el fichero mbox, se encuentra en el directorio JulianJacobo, que está en MisDocumentos que está en usr, es decir: "/usr/MisDocumentos/JulianJacobo” Renombrar un Archivo. Para renombrar un archivo utilizamos el comando mv de la siguiente manera:

mv NombreOrinal NuevoNombre

Por ejemplo, renombrar el fichero mbox, a EmailSaved

$ mv mbox EmailSaved Borrar un Archivo Para borrar un archivo, es tan fácil como utilizar el comando rm de la siguiente manera:

rm fichero_a_borrar

Ejemplo:

$ rm mbox Borrar un DIRECTORIO Para borrar un directorio utilizamos el comando rmdir. Esto es un ejemplo: Creamos un directorio que se llame ParaBorrar, con el comando mkdir

$ Mkdir ParaBorrar

Page 54: Tp Final Aso

53

Vemos los ficheros que tenemos con el comando ls $ ls

y lo borramos con rmdir $ rmdir ParaBorrar

Ya sabemos, que también podemos crear un directorio o borrarlo, sin necesidad de acceder a él, simplemente indicando su ruta:

$ Mkdir /usr/doc/HOWTO/EstoEsMio $ rmdir /usr/doc/HOWTO/EstoEsMio

Ls

ls (del inglés list) muestra un listado con los archivos y directorios de un determinado directorio. Los resultados se muestran ordenados alfabéticamente.

Los archivos y directorios cuyo nombre comienza con . (punto) no se muestran con la instrucción ls, por lo que se suelen denominar "archivos ocultos". La opción -a de ls inhibe este comportamiento, mostrando todos los archivos y subdirectorios, incluso los que comienzan con punto.

ls : sin argumentos muestra el listado del directorio actual

ls archivo1 archivo2 archivo3 ... subdir1 subdir2 subdir3 ... : muestra un listado de los archivos y subdirectorios especificados en la línea de órdenes. Para los ar-chivos muestra el nombre solamente (o más información si se emplea alguna op-ción como -l ) y para los subdirectorios muestra todos los archivos incluidos en el subdirectorio. Este comportamiento distinto de ls ante archivos y subdirectorios puede igualarse usando el parámetro -d, que hace que se trate a los subdirectorios como archivos. Nótese que pueden ponerse directorios y archivos en la línea de órdenes en cualquier orden.

Opciones más comunes

-l muestra un listado en el formato largo, con información de permisos, número de enlaces asociados al archivo, usuario, grupo, tamaño y fecha de última modifica-ción además del nombre.

-h con -l imprime el tamaño de los archivos de forma entendible (ej. 1K 234M 2G).

-d muestra solamente el nombre del subdirectorio, sin entrar en él ni dar un listado del contenido.

Page 55: Tp Final Aso

54

-t muestra ordenado por la fecha de última modificación.

-c muestra ordenado por la fecha de última modificación del estado del archivo.

-r cuando el listado se hace por orden temporal, los archivos más recientes van al principio. Si se indica la -r se invierte el orden, mostrando los más recientes al final.

-L en los enlaces simbólicos, muestra los datos del archivo referenciado en vez de los del link.

-1 muestra el listado en una sola columna. Sin la opción -1 el listado se muestra en varias columnas, tantas como permita el ancho de la terminal (generalmente con-trolado con la variable de entorno $COLUMNS).

-i muestra el número de i-nodo antes del nombre de archivo.

-m muestra los archivos en una línea y separados por comas.

-R hace un listado recursivo. Lista primero los archivos del directorio en curso, lue-go los de los subdirectorios de éste, luego los de los subdirectorios contenidos en ellos (nietos) y así sucesivamente.

-s muestra delante del nombre del fichero el tamaño en kilobytes del mismo.

--color muestra cada tipo de archivo de un color distinto: un color para los directo-rios, otro para los archivos regulares, otro para los enlaces simbólicos, otro para los sockets, otro para las tuberías FIFO, etc. Este parámetro no se acepta en todas las versiones de ls y, por supuesto, requiere que la terminal sea capaz de mostrar dis-tintos colores o intensidades.

- a muestra los archivos ocultos.

Al igual que en la mayoría de las órdenes unix, las opciones se pueden agrupar, de manera que es lo mismo poner ls -li que ls -l -i . O también es lo mismo ls -ltra que ls -l -t -r -a

Ejemplo:

Un listado del directorio actual se obtendría así:

$ ls Manual.txt.gz archivo1.txt hosts servidores syslog.0

Page 56: Tp Final Aso

55

Impresoras

Para imprimir un fichero, tecleamos:

$ lpr fichero

Lo anterior imprimirá los ficheros nombrados, en la impresora por default. Si no indicamos

el nombre del fichero, lpr leerá los datos a imprimir de la entrada estandar. Por ejemplo,

este comando imprime algunos ficheros importantes del sistema:

$ lpr /etc/host.conf /etc/hosts.equiv

Para seleccionar una impresora, tecleamos:

$ lpr -P nombre-de-la-impresora fichero

Este ejemplo imprime una larga lista del directorio actual, en la impresora

nombrada julian_imp:

$ ls -l | lpr -P julian_imp

En virtud de que no se le paso fichero alguno para imprimir a lpr, lpr toma los datos de la

entrada estandar, que en este caso es la salida del comando ls -l.

El comando lpr también puede aceptar gran variedad de opciones para controlar el

formato, aplicar conversiones a los ficheros, generar copias múltiples, etc.

Dispositivos

Como lo indica su nombre, /dev contiene archivos de dispositivos.

Una de las mejores ideas del sistema UNIX es la manera en que trata los periféricos (discos, unidades de cinta, impresoras, terminales, etc.).Por ejemplo, en lugar de tener rutinas del sistema especiales para leer cintas magnéticas, existe u archivo llamado /dev/mt0 (dependiendo esto también de las costumbres locales) Dentro del núcleo, las referencias a ese archivo se convierten en comandos de hardware para acceder la cinta, así, si un programa lee /dev/mt0. Obtiene el contenido de una cinta montada en una unidad de cinta. Creación de un sistema de archivos

La creación de un SF puede hacerse en 6 etapas: 1- Dar fromato al soporte físico con el mandato iv o format. 2- Crear al SF con mkfs. 3- Montar el SF con el mandato mount. 4- Crear al directorio /lost+found. 5- Dar nombre al SF con el mandato labelit. 6- Dar formato a un volumen.

Page 57: Tp Final Aso

56

Procmail

procmail es una aplicación increíblemente potente que se utiliza para filtrar el correo de

entrada. Permite a los usuarios definir “reglas” que se asocian con correos entrantes y

que realizan funciones concretas, como reencaminar el correo a carpetas o direciones

alternativas. procmail se puede instalar utilizando el port mail/procmail. Una vez

instalado, se puede integrar directamente en la mayoría de los MTAs. Por otro lado

procmail se puede integrar con el MTA que prefiera de una forma sencilla añadiendo la

siguiente línea al fichero .forward dentro del directorio home del usuario que desée usar

procmail:

"|exec /usr/local/bin/procmail || exit 75"

La siguiente sección muestra algunas reglas básicas de procmail, junto con una breve

descripción de las acciones que realizan. Estas reglas, y muchas otras se deben insertar

dentro del fichero .procmailrc ubicado en el directorio home del usuario.

Reenvío de todo el correo proveniente de [email protected] hacia la dirección

externa [email protected]:

:0

* ^From.*[email protected]

! [email protected]

Reenvío de todos los correos que ocupen menos de 1000 bytes a la

dirección [email protected]:

:0

* < 1000

! [email protected]

Envío de todos los correos dirigidos a [email protected] hacia una carpeta de correo

llamada opcional:

:0

* ^[email protected]

opcional

Envío de todos los correos con un asunto que contenga la palabra “Spam” al

dispositivo /dev/null:

:0 ^Subject:.*Spam /dev/null

Page 58: Tp Final Aso

57

Loop devices

En sistemas operativos como Unix, un loop device, VND (disco vnode), o lofi (interfaz de bucle invertido de archivos) es un pseudo-dispositivo que hace a un archivo accesible como un dispositivo de bloques. Antes del uso, un dispositivo de circuito debe estar conectado a un archivo existente en el sistema de ficheros. La asociación proporciona al usuario una API que permite que el archivo se utilice en lugar de un archivo especial de bloques (cf. dispositivo de sistema de archivos). Así, si el archivo contiene un sistema de archivo completo, el archivo a continuación, se puede montar como si se tratara de un dispositivo de disco. Ejemplo:

Para montar un archivo que contenga una imagen, en un directorio, se necesitan 2 pasos:

1. Asociar el archivo con un nodo loop device,

2. Montar el loop device en un directorio de punto de montaje.

Estas dos operaciones se pueden realizar usando dos comandos separados o a través de

una bandera especial al comando. La primer operación debe ser realizada por programas

como aslosetu o lofiad. Como por ejemplo, si ejemplo.img es un archive regular

conteniendo un file system y /home/JulianJacobo/dir es un directorio de un usuario,

el superuser (root) monta la imagen en el directorio ejecutando los siguientes comandos:

$ losetup /dev/loop0 ejemplo.img

$ mount /dev/loop0 /home/JulianJacobo/dir

El Segundo comando monta el dispositivo en /home/JulianJacobo/dir. El efecto global de

la ejecución de estos dos comandos es que el contenido del archivo se utiliza como un

sistema de archivos raíz en el punto de montaje.

La utilidad de montaje suele ser capaz de manejar todo el procedimiento:

$ mount -o loop ejemplo.img /home/JulianJacobo/dir

El dispositivo puede ser desmontado con el siguiente commando:

umount /home/JulianJacobo/dir # o, despues de encontrar el numero loop asociado por ejemplo mount | grep "/home/JulianJacobo/dir" # o losetup -a | grep ejemplo.img umount /dev/loop<N>

Page 59: Tp Final Aso

58

Cdrom

El programa mkisofs (que forma parte del port sysutils/cdrtools) genera un sistema de

ficheros ISO 9660 que es una imagen de un árbol de directorios en el espacio de nombres

del sistema de ficheros UNIX. Esta es la forma más simple de usarlo:

# mkisofs -o ficherodeimagen.iso /ruta/del/árbol

Este comando creará un ficherodeimagen.iso que contenga un sistema de ficheros ISO

9660 que es una copia del árbol ubicado en /ruta/al/árbol. En el proceso, mapeará los

nombres de fichero a nombres que se ajusten a las limitaciones del estándar del sistema

de ficheros ISO 9660, y excluirá ficheros que posean nombres no característicos de

sistemas de ficheros ISO.

Si tenemos una grabadora ATAPI podemos usar burncd para grabar una imagen ISO en

un CD. burncd forma parte del sistema base, y está en /usr/sbin/burncd. Su uso es muy

sencillo, ya que tiene pocas opciones:

# burncd -f unidaddecd data ficheroimagen.iso fixate

Esto grabará una copia de ficheroimagen.iso en unidadcd. El dispositivo por defecto

es /dev/acd0 .

Si no disponemos de una grabadora ATAPI de cd, tendremos que usar cdrecord para grabar CDs.

Aunque cdrecord tiene muchas opciones, el uso básico es incluso más simple que el

de burncd. Así se graba una imagen ISO 9660:

# cdrecord dev=dispositivo ficheroimagen.iso

Podemos copiar un CD de datos a un fichero de imagen que será funcionalmente

equivalente al fichero de imagen creado con mkisofs, y podemos usarlo para duplicar

cualquier CD de datos. El ejemplo dado aquí asume que nuestro dispositivo CDROM

es acd0.

# dd if=/dev/acd0 of=fichero.iso bs=2048

Hecha la imagen podemos garbarla en un CD como se describió anteriormente.

Uso de CD de datos:

Podemos hacerlo mediante la opción -t cd9660. Por ejemplo, si queremos montar el

dispositivo CDROM /dev/cd0 en /mnt ejecutamos:

# mount -t cd9660 /dev/cd0 /mnt

Page 60: Tp Final Aso

59

Herramientas de Desarrollo:

VI

Vi (Visual) a diferencia de un procesador de texto no ofrece herramientas para determinar visualmente cómo quedará el documento impreso. Es por esto que carece de opciones, como centrado 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 es un editor con diferentes modos. En el modo de edición el texto que ingresemos será agregado al texto, en modo de comandos las teclas que oprimamos pueden representar algún comando de vi. Cuando comencemos a editar un texto estará en modo para dar comandos. Por ejemplo, el comando para salir es: seguido de q y ENTER; con ese comando saldrá si no hicimos cambios al archivo o los cambios ya están salvados, para salir ignorando cambios :q! seguido de ENTER.

Podemos insertar texto (pasar a modo edición) con varias teclas:

i

Inserta texto antes del carácter sobre el que está el cursor.

a

Inserta texto después del carácter sobre el que está el cursor.

I

Inserta texto al comienzo de la línea en la que está el cursor.

A

Inserta texto al final de la línea en la que está el cursor.

o

Abre espacio para una nueva línea después de la línea en la que está el cursor y permite insertar texto en la nueva línea.

O

Igual al anterior, pero abre espacio en la línea anterior.

Page 61: Tp Final Aso

60

ESC

Abandonar el modo de inclusión de texto para volver al modo de comandos; también se usa para cancelar comandos. (Usarlo en caso de duda)

Cntl-F

Avanzar una página hacia adelante

Cntl-B

Avanzar una página hacia atrás

Cntl-L

Refrescar la pantalla

G

Cursor al final del fichero

1G

Cursor al principio del fichero

$

Cursor al final de la línea

0 (cero)

Cursor al principio de la línea

dd

Borra una línea entera.

Para pasar de modo edición a modo de comandos se emplea la tecla ESC, para desplazarnos sobre el archivo se emplean las teclas j (abajo), k (arriba), h (izquierda) y l (derecha). También podemos emplear las flechas si nuestra terminal lo permite, Ctrl+U (PgUp), Ctrl+D (PgDn).

Para ir a una línea específica podemos escribir el número de la línea seguido de gg o G, por ejemplo 25G o también podemos utilizar : seguido del número de línea y ENTER. Para mostrar el número de las líneas, se podemos ejecutar : set number, y para quitar los números : set nonumber. Para ir al final de la línea en la que está el cursor $, para ir

Page 62: Tp Final Aso

61

al comienzo 0. Para llegar al inicio del archivo 1G o gg y para llegar al final del archivo G. Para buscar un texto: / texto seguido del texto que desea buscar y ENTER. Luego podemos presionar n o N para el siguiente o anterior resultado de la búsqueda. Después de hacer cambios podemos salvarlos con :w o para salvar y salir puede emplear ZZ. Para ejecutar un comando del intérprete de comandos podemos emplear :! seguido del comando y ENTER (e.g :!ls). Podemos teclear :set all para ver las opciones disponibles.

Una de las utilidades más comunes es el uso de :wq que corresponde a la unión de las opciones guardar (w) y salir (q), o bien el modo forzado es :q! que sale de vi sin guardar cambios.

Invocación de vi

$ vi Abre la ventana de edición sin abrir ningún archivo. $vi arch1 Edita el archivo arch1 si existe; si no, lo crea. $vi arch1 arch2 Edita sucesivamente los archivos arch1 y luego arch2. $vi +45 arch1 Edita el archivo arch1 posicionando el cursor en la línea 45. $vi +$ arch1 Edita el archivo arch1 posicionando el cursor al final del archivo. $vi +/Habia arch1 Edita el archivo arch1 en la primera ocurrencia de la palabra "Habia".

Vim

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 sólo modo en el que se introducen los órdenes mediante combinaciones de teclas o interfaces gráficas.

Modos

Vim es un editor modal, lo que significa que se puede trabajar en diferentes modos para realizar una tarea determinada. Para ver en qué modo se encuentra Vim se debe de tener activada la opción showmode. A continuación se describen los seis modos de Vim. Los tres primeros son los modos del vi original.

Page 63: Tp Final Aso

62

Modo comandos

Vim empieza en modo comando, también conocido como modo normal. En este modo se pueden emplear combinaciones de teclas para, por ejemplo, copiar líneas y trabajar en el formato del texto. Éste es el modo central, desde el que se cambia a los otros modos. Si no se sabe qué se está haciendo, pulsando dos veces la tecla Escape siempre se puede volver al modo normal. Si ya se estaba en modo normal y tanto la configuración de Vim como la del terminal lo permiten, Vim emite un pitido.

Modo inserción

En modo inserción cuando se pulsan las teclas se edita el texto como en otros editores. Se puede cambiar del modo comandos al modo inserción pulsando la tecla i. Hay un gran abanico de comandos para pasar al modo inserción, que difieren sustancialmente, pues permiten por ejemplo editar al final de la línea, en un punto concreto del texto, editar borrando una palabra, entre muchas otras. Un usuario experto puede sacar un gran provecho de la existencia de esta variedad de órdenes.

En el modo inserción todas las teclas tienen alguna función además de la mera inserción, que se activan pulsando simultáneamente las teclas Tecla control o Mayúsculas. La tecla Esc es muy importante en modo inserción, pues permite cambiar de modo inserción a modo comandos.

Cambiando al modo comandos para realizar ciertas tareas se incrementa en gran medida la eficiencia en la edición, y se puede aprovechar la potencia completa de Vim.

Modo línea de órdenes

A este modo se accede pulsando la tecla dos puntos :. Tras los dos puntos se pueden introducir órdenes complejas, como por ejemplo buscar y reemplazar con expresiones regulares. Pulsando la tecla Esc se puede volver al modo órdenes. Las búsquedas se pueden realizar con la orden / (hacia adelante) .También se pueden filtrar líneas mediante !.

Modo visual

Este modo es una mejora respecto a vi. Mediante unas ciertas combinaciones de teclas en combinación con las teclas de movimiento del cursor, se puede marcar un área de texto, ya sea un grupo de líneas o un bloque. Una vez se tiene el texto marcado se pueden usar órdenes del modo comandos para manipularlo. Las operaciones que se pueden realizar en este modo son más simples que las del modo comandos.

Modo selección

Este modo empieza como el modo visual, pues hay que seleccionar un bloque de texto. Tras la selección, se puede cambiar al modo selección mediante Control-G. Una vez en el modo, si se pulsa una tecla imprimible, el texto seleccionado se borra, se termina el modo selección y aparece el símbolo correspondiente a la tecla pulsada. La selección se puede extender pulsando mayúsculas y las teclas de flechas, el comportamiento habitual en los programas de Microsoft Windows. Este modo se puede finalizar pulsando la tecla Escape.

Page 64: Tp Final Aso

63

Modo Ex

Este modo se asemeja al modo línea de órdenes, con la diferencia de que tras la ejecución de una orden no se vuelve al modo comandos. Se entra en este modo pulsando Q y se termina con vi. En este modo Vim imita al editor de UNIX ex, que manipulaba el texto línea a línea debido a las limitaciones de la época, en lugar de editar toda la página.

Nano

Nano es un editor de texto para sistemas Unix basado en curses. Es un clon de Pico, el editor del cliente de correo electrónico Pine. nano trata de emular la funcionalidad y la interfaz de fácil manejo de Pico, pero sin la integración con Pine. Liberado bajo los términos de la GNU General Public License, nano es software libre. Con la liberación de la versión 2.0.7 la licencia se cambió de GPLv2 a GPLv3.

Nano, como Pico, está orientado a un manejo desde teclado específicamente a combinaciones de la tecla Control. Por ejemplo, Control-O guarda el archivo actual y Control-W abre el menú de búsqueda. La barra de accesos directos de nano tiene dos filas colocadas en la parte baja de la pantalla, que lista algunos de los comandos disponibles en función del contexto. Para ver una lista completa basta con presionar Control-G y se obtiene una pantalla de ayuda.

A diferencia de Pico, nano utiliza metateclas para modificar su comportamiento. Por ejemplo, Meta-S permite alternar entre activar el desplazamiento vertical suave y desactivarlo. Casi todas las características que se pueden indicar desde la línea de comandos pueden ser modificados dinámicamente.

Emacs

Emacs es un editor de texto con una gran cantidad de funciones, muy popular entre programadores y usuarios técnicos. Es parte del proyecto GNU, activamente desarrollado. Es la versión más popular de Emacs. El manual de GNU Emacs lo describe como "un editor extensible, personalizable, auto-documentado y de tiempo real." El EMACS original significa, Editor MACroS para el TECO. Fue escrito en 1975 por Richard Stallman junto con Guy Steele. Fue inspirado por las ideas de TECMAC y TMACS, un par de editores TECO-macro escritos por Guy Steele, Dave Moon, Richard Greenblatt, Charles Frankston, y otros. Se han lanzado muchas versiones de EMACS hasta el momento, pero actualmente hay dos que son usadas comúnmente: GNU Emacs, iniciado por Richard Stallman en 1984, y XEmacs, un fork de GNU Emacs, que fue iniciado en 1991. Ambos usan una extensión de lenguaje muy poderosa, Emacs Lisp, que permite manejar tareas distintas, desde escribir y compilar programas hasta navegar en Internet. GNU Emacs es mantenido por el Proyecto GNU Emacs, el cual cuenta entre sus miembros a Richard Stallman.

Uso de emacs Desde el shell de Unix, un fichero se puede abrir para ser editado escribiendo "emacs [nombre del fichero]". Si el fichero cuyo nombre se ha introducido no existe, se creará un nuevo fichero con este nombre. Por ejemplo, escribiendo "emacs xorg.conf" se editará el fichero xorg.conf en el directorio actual, si existe. No obstante, la documentación de Emacs recomienda iniciar el programa sin introducir un nombre de fichero, para evitar el

Page 65: Tp Final Aso

64

mal hábito de iniciar un proceso separado para cada fichero a editar. La manera de sacarle partido completamente a Emacs es abrir todos los ficheros desde una única instancia del programa. En el modo de edición normal, Emacs se comporta como otros editores de texto: Las teclas de caracteres (a, b, c, 1, 2, 3, etc.) sirven para insertar los caracteres correspondientes, las teclas de flecha mueven el punto de edición, la tecla backspace borra texto, etc. Otros comandos pueden ser invocados mediante teclas modificadoras, presionando Control o Meta (equivalente a la actual tecla Alt) o ambas, junto con otra tecla. Cada comando de edición es en realidad una llamada a una función en el entorno de Emacs Lisp. Incluso un comando tan simple como escribir a para insertar el carácter a implica una llamada a una función. En este caso, la función sería self-insert-command. Más abajo se muestran algunos de los comandos básicos. Se pueden encontrar más en la lista de comandos de Emacs. La tecla de control se representa con una C mayúscula y la tecla de alternativa (Alt) o meta se representa con una M mayúscula. Comando Tecla Descripción

forward-word M-f Avanzar una palabra. search-word C-s Buscar una palabra en el buffer. undo C-/ Deshacer el último cambio, y cambios anteriores si se pulsa repetidamente. keyboard-quit C-g Abortar el comando actual. fill-paragraph M-q Wrap text in ("fill") a paragraph. find-file C-x C-f Visitar un fichero (del cual se especifica el

nombre) en su propio buffer de edición. save-buffer C-x C-s Guardar el buffer de edición actual en su

fichero visitado. save-with C-x C-w Guardar el buffer de edición actual como -newname fichero cuyo nombre se ha de especificar. set-marker C-[space]/C-@ Colocar un marcador en el lugar donde se

quiere cortar o copiar. cut C-w Cortar todo el texto entre el marcador y el

cursor. copy M-w Copiar todo el texto entre el marcador y el

cursor. paste C-y Pegar texto del portapapeles de Emacs. kill buffer C-x k Cerrar el buffer actual.

GNU Compiler Collection

El GNU Compiler Collection (colección de compiladores GNU) es un conjunto de compiladores creados por el proyecto GNU. GCC es software libre y lo distribuye la FSF bajo la licencia GPL. Estos compiladores se consideran estándar para los sistemas operativos derivados de

Page 66: Tp Final Aso

65

UNIX, de código abierto y también de propietarios, como Mac OS X. GCC requiere el conjunto de aplicaciones conocido como binutils para realizar tareas como identificar archivos objeto u obtener su tamaño para copiarlos, traducirlos o crear listas, enlazarlos, o quitarles símbolos innecesarios. Originalmente GCC significaba GNU C Compiler (compilador GNU para C), porque sólo compilaba el lenguaje C. Posteriormente se extendió para compilar C++, Fortran, Ada y otros. En su versión 4.6 incluye front ends para C (gcc), C++ (g++), Java (gcj), Ada (GNAT), Objective-C (gobjc), Objective-C++ (gobjc++) y Fortran (gfortran). También está disponible, aunque no de forma estándar, soporte para Go (gccgo), Modula-2, Modula-3, Pascal (gpc), PL/I, D (gdc), Mercury, y VHDL (ghdl).

Uso En modo texto C y C++ Para empezar a escribir el código, primero hay que abrir el editor de textos. Para ello, escribimos lo siguiente:

$ vi nombre_de_archivo.c Y ya podemos empezar a escribir el código del programa que vayamos a crear. Una vez escrito, salimos del editor guardando el archivo (no olvidar que la instrucción para salir es :wq) Ya guardado, procedemos a compilarlo con la siguiente instrucción

$ gcc nombre_de_archivo.c Hay que tener en cuenta que ésta instrucción solo compila, para que además cree el ejecutable, escribimos esto:

$ gcc nombre_de_archivo.c -o nombre_ejecutable Cuando ya esté compilado y se haya creado el ejecutable (siempre y cuando no haya habido errores de compilación), para abrir el ejecutable hay que escribimos lo siguiente:

$ ./nombre_ejecutable Y así ya está todo hecho.

GDB GDB es el source debugger de GNU. Es un poderoso debugger que permite "ver" que está sucediendo dentro de programas escritos en C, C++ y Modula-2. Entre las capacidades más notorias que este debugger posee están:

Debugging de programas complejos con múltiples archivos.

Capacidad para detener el programa o ejecutar un comando en un punto específico

(breakpoints), según una condición (watchpoints) o al llegar un signal (catchpoints).

Capacidad para mostrar valores de expresiones cuando el programa se detiene au-

tomáticamente (displays).

Page 67: Tp Final Aso

66

Es posible examinar la memoria y/o variables de diversas formas y tipos, incluyen-

do estructuras, arreglos y objetos.

Es posible igualmente cambiar los valores de las variables para estudiar el compor-

tamiento del programa sin necesidad de recompilar.

Posibilidad de realizar debugging a programas en ejecución (procesos).

Posibilidad de realizar debugging a programas que han finalizado.

Múltiples formas de entrar al debugger.

Invocación del Debugger

El debugger se puede ejecutar de una de las siguientes formas: $ gdb

Para entrar al modo interactivo. $ gdb programa Para cargar el programa y entrar en el modo interactivo. El programa no comienza hasta que sea indicado con un comando. $ gdb programa core Para realizar debugging de un programa que ha finalizado con un 'core'. El debugger carga el programa y su ambiente exactamente como termino. Útil para verificar porque un programa termino mal o para ver donde un programa se colgó (usando CTRL-\ para cortar el programa y obtener un core). $ gdb programa pid Para depurar un programa en ejecución con el pid indicado. El proceso se detiene y el debugger lo controla en otro terminal. Sumamente útil para depurar programas con interfaz desde otro terminal virtual. Una vez que se entra al modo interactivo. GDB acepta comandos hasta que se le indique que se desea salir con el comando 'quit'. La presión de ENTER solo en una línea siempre invoca el último comando introducido.

Comandos más Frecuentemente Usados:

Los comandos más frecuentemente usados son: $ list [archivo:]funcion $ list [archivo:]linea[,linea] $ list $ list – Para listar el fuente a partir de una función o una línea. 'list' solo continua el listado previo (page down). 'list -' lista las líneas anteriores (page up). $ break [archivo:]funcion $ break [archivo:]linea

Page 68: Tp Final Aso

67

Para colocar un breakpoint al comienzo de la función o al comienzo de la línea indicada. $ run [argumentos] Para comenzar la ejecución del programa desde el principio. Los argumentos son los pasados al ejecutable. $ bt (backtrace) Para mostrar el stack del programa, indicando las funciones invocadas y en qué lugares fueron llamadas. $ print expr Para mostrar el valor de una expresión. $ c Para continuar la ejecución del programa después de que ha sido detenido con un signal o un breakpoint. $ next Ejecuta la próxima línea del programa sin entrar dentro de las funciones. Se puede aprovechar el hecho que GDB repite el último comando con ENTER para ejecutar varias líneas seguidas. $ step Ejecuta la próxima línea del programa entrando en funciones. Se puede aprovechar el hecho que GDB repite el último comando con ENTER para ejecutar varias líneas seguidas. $ jump línea Salta los comandos siguientes y comienza la ejecución a partir de 'línea'. Útil para continuar un programa que ha terminado con 'core', arreglando la situación y saltando las líneas defectuosas. $ help [item] Ayuda en línea. $ quit Sale de GDB.

Page 69: Tp Final Aso

68

Guía de compilación de un programa realizado en C en FreeBSD

En esta guía utilizaremos un programa generado en la materia Arquitectura de los Sistemas Operativos, my_ls(cuyo código se encuentra disponible como anexo), cuya descripción es la siguiente: Muestra en pantalla una lista con todos los directorios y archivos contenidos en X directorio, se pueden filtrar los resultados: • -e : lista todos los archivos contenidos en <directorio>. • -d : lista sólo los directorios contenidos en <directorio>. • -i : lista el número de i-nodo y el nombre de los archivos contenidos en <directorio>. Ejemplos: ./my_ls Documentos //Muestra todo lo contenido en Documentos ./my_ls -e Documentos //Muestra todos los archivos contenidos en Documentos ./my_ls -d Documentos //Muestra todos los directorios en Documentos ./my_ls -i Documentos //Muestra el i-nodo continuado del nombre de los archivos

contenidos en Documentos ./my_ls //Muestra todo lo contenido en el directorio en el directorio

actual Para compilar un programa utilizamos el compilador por defecto de FreeBSD, gcc. Para ello basta con llamar al programa, seguido de algunos argumentos:

$ gcc my_ls.c Hay que tener en cuenta que ésta instrucción solo compila, para que además cree el ejecutable, escribimos esto:

$ gcc my_ls.c -o my_ls Cuando ya esté compilado y se haya creado el ejecutable (siempre y cuando no haya habido errores de compilación), para abrir el ejecutable que escribimos lo siguiente:

$ ./my_ls

Esto es lo que se obtiene en Terminal al ejecutar los commandos nombrados:

$./my_ls El directorio Actual es: /root/Desktop/ /root/Desktop/. /root/Desktop/.. /root/Desktop/Downloads /root/Desktop/my_cat.c /root/Desktop/my_chmod.c

Page 70: Tp Final Aso

69

/root/Desktop/my_ls.c /root/Desktop/my_ps.c /root/Desktop/my_cat /root/Desktop/my_chmod /root/Desktop/my_ls /root/Desktop/my_ps

Lenguajes

BASIC

BASIC, siglas de Beginner's All-purpose Symbolic Instruction Code, es una familia de lenguajes de programación de alto nivel. El BASIC original, el Dartmouth BASIC, fue diseñado en 1964 por John George Kemeny y Thomas Eugene Kurtz en el Dartmouth College en New Hampshire, Estados Unidos, como un medio para facilitar programar computadores a estudiantes (y profesores) que no fueran de ciencias. En ese tiempo, casi todo el uso de los computadores requería codificar software hecho a la medida, lo cual era algo bastante restringido a personas con formación como científicos y matemáticos. BASIC originalmente fue desarrollado como una herramienta de enseñanza. El lenguaje y sus variantes llegaron a estar ampliamente disponibles en los microcomputadores a finales de los años 1970 y en los años 1980. El BASIC sigue siendo popular hasta el día de hoy en un puñado de dialectos altamente modificados, y en nuevos lenguajes, influenciados por BASIC tales como Microsoft Visual Basic, Gambas en GNU/Linux o The Bywater Basic y the Phil Cockroft’s Basic en Unix. Por el año 2006, el 59% de los desarrolladores para la plataforma .NET usaban Visual Basic .NET como su único lenguaje.

The Bywater Basic Interpreter puede ser encontrado en los puertos de colecciones como lang/bwbasic y the Phil Cockroft's Basic Interpreter (formerly Rabbit Basic) está disponible como lang/pbasic.

Lisp

El nombre LISP deriva del "LISt Processing" (Proceso de LIStas). Las listas encadenadas son una de las estructuras de datos importantes del Lisp, y el código fuente del Lisp en sí mismo está compuesto de listas. Como resultado, los programas de Lisp pueden manipular el código fuente como una estructura de datos, dando lugar a los macro sistemas que permiten a los programadores crear una nueva sintaxis de lenguajes de programación de dominio específico empotrados en el Lisp.

La intercambiabilidad del código y los datos también da a Lisp su instantáneamente reconocible sintaxis. Todo el código del programa es escrito como expresiones S, o

Page 71: Tp Final Aso

70

listas entre paréntesis. Una llamada de función o una forma sintáctica es escrita como una lista, con la función o el nombre del operador en primer lugar, y los argumentos a continuación; por ejemplo, una función f que toma tres argumentos puede ser llamada usando (f x y z)

Varias implementaciones de Lisp que pueden correr en sistemas UNIX, están disponibles en los puertos de colección para FreeBSD. GNU Common Lisp puede ser encontrado como lang/gcl. CLISP por Bruno Haible y Michael Stoll está disponible como lang/clisp. Para CMUCL, que incluye un compilador altamente optimizado, o simples implementaciones Lisp como SLisp, que implementa la mayoría de los constructores comunes de Lisp en unas pocas líneas de código C, lang/cmucl y lang/slisp están disponibles respectivamente.

Perl

Muy popular con administradores de sistemas para la escritura de scripts; también usado en servidores de internet para escribir scripts CGI.

Perl está disponible en los puertos de colecciones como lang/perl15.8 para todas las distribuciones de FreeBSD.

Icon

Icon es un lenguaje de muy alto nivel con facilidades extensivas para procesar cadenzas y estructuras. La versión de Icon en FreeBSD puede ser encontrada en los puertos de colección como lang/icon.

Logo

Logo es un lenguaje fácil de aprender, y fue usado como una introducción a la programación en varios cursos. Es una herramienta excelente para enseñar a programar en edades tempranas.

La última versión de Logo para FreeBSD está disponible en los puertos de colecciones en lang/logo.

Python

Python es un lenguaje intérprete orientado a objetos. Sus defensores argumentan que es uno de los mejores lenguajes de programación para comenzar, ya que es relativamente fácil para empezar, pero no está limitado en comparación con otros lenguajes populares interpretes que se utilizan para el desarrollo de aplicaciones grandes y complejas (Perl es un lenguaje popular para las tareas de este tipo).

La última versión de Python está disponible en los puertos de colecciones en lang/python.

Page 72: Tp Final Aso

71

Servicios: Daemons: Inetd: Se conoce como el “Super Servidor de Internet” debido a que gestiona las conexiones de varios dæmones que proporcionan servicios de red. inetd actúa como un servidor de gestión de otros dæmones. Cuando inetd recibe una conexión se determina qué dæmon debería responder a dicha conexión, se lanza un proceso que ejecuta dicho dæmon y se le entrega el “socket”. La ejecución de una única instancia de inetd reduce la carga del sistema en comparación con lo que significaría ejecutar cada uno de los dæmones que gestiona de forma individual.

inetd se utiliza principalmente para lanzar procesos que albergan a otros dæmones pe-

ro inetd también se utiliza para gestionar determinados protocolos triviales como char-

gen, auth y daytime.

Configuraciones

inetd se inicializa a través del fichero /etc/rc.conf en tiempo de arranque. La

opción inetd_enable posee el valor NO por defecto, pero a menudo la aplicación

sysinstall la activa cuando se utiliza la configuración de perfil de seguridad medio.

Estableciendo

inetd_enable="YES"

o

inetd_enable="NO"

Dentro de /etc/rc.conf se puede activar o desactivar la ejecución de inetd en el arranque del sistema. Se pueden además aplicar distintas opciones de línea de órdenes mediante la opción inetd_flags.

Opciones de línea de órdenes

Sinópsis:

inetd [-d] [-l] [-w] [-W] [-c máximo] [-C tasa] [-a dirección | nombre_de_host] [-p

nombre_de_fichero] [-R tasa] [fichero de configuración ]

-d

Activa la depuración.

Page 73: Tp Final Aso

72

-l

Activa el “logging” de las conexiones efectuadas.

-w

Activa el recubrimiento de TCP para servicios externos (activado por defecto).

-W

Activa el recubrimiento de TCP para los servicios internos, ejecutados directamente por el dæmon inetd (activado por defecto).

-c máximo

Especifica el máximo número de invocaciones simultáneas de cada servicio; el valor por defecto es ilimitado. Se puede sobreescribir para cada servicio utilizando la opción max-child.

-C tasa

Especifica el máximo número de veces que se puede llamar a un servicio desde un dirección IP determinada por minuto; el valor por defecto es ilimitado. Se puede redefinir para cada servicio utilizando la opción max-connections-per-ip-per-minute.

-R tasa

Especifica el máximo número de veces que se puede invocar un servicio en un minuto; el valor por defecto es 256. Un valor de 0 permite un número ilimitado de llamadas.

-a

Especifica una dirección IP a la cual se asocia y sobre la cual se queda esperando recibir conexiones. Puede declararse también un nombre de máquina, en cuyo caso se utilizará la dirección (o direcciones si hay más de una) IPv4 o IPv6 que estén tras dicho nombre. Normalmente se usa un nombre de máquina cuando inetd se ejecuta dentro de un jail, en cuyo caso el nombre de máquina se corresponde con el entorno jail.

Cuando se desea asociarse tanto a direcciones IPv4 como a direcciones IPv6 y se utiliza un nombre de máquina se necesita una entrada para cada protocolo (IPv4 o IPv6) para cada servicio que se active a través de /etc/inetd.conf. Por ejemplo un servicio basado en TCP necesitaría dos entradas, una utilizando tcp4 para el protocolo IPv4 y otra con tcp6 para las conexiones a través del procolo de red IPv6.

-p

Especifica un fichero alternativo en el cual se guarda el ID del proceso.

Estas opciones se pueden declarar dentro de las variables inetd_flags del

fichero /etc/rc.conf. Por defecto inetd_flags tiene el valor -wW, lo que activa el

Page 74: Tp Final Aso

73

recubrimiento de TCP para los servicios internos y externos de inetd. Los usuarios

inexpertos no suelen introducir estos parámetros y por ello ni siquiera necesitan

especificarse dentro de /etc/rc.conf.

Nota: Un servicio externo es un dæmon que se ejecuta fuera de inetd y que se lanza cuando se recibe un intento de conexión. Un servicio interno es un servicio que inetd puede servir directamente sin necesidad de lanzar nuevos procesos.

inetd.conf:

La configuración de inetd se realiza a través del fichero de configuración /etc/inetd.conf.

Cuando se realiza una modificación en el fichero /etc/inetd.conf se debe obligar a inetd a

releer dicho fichero de configuración, lo cual se realiza enviando una señal “HANGUP” al

proceso inetd como se muestra a continuación:

Ejemplo 29-4. Envío de una señal HANGUP a inetd

# kill -HUP `cat /var/run/inetd.pid`

Cada línea del fichero de configuración especifica un dæmon individual. Los comentarios

se preceden por el caracter “#”. El formato del fichero de configuración/etc/inetd.conf es el

siguiente:

service-name

socket-type

protocol

{wait|nowait}[/max-child[/max-connections-per-ip-per-minute]]

user[:group][/login-class]

server-program

server-program-arguments

A continuación se muestra una entrada de ejemplo para el dæmon ftpd para IPv4:

ftp stream tcp nowait root /usr/libexec/ftpd ftpd -l

service-name

Este es el nombre del servicio que proporciona un determinado dæmon. Se debe corresponder con el nombre del nombre de servicio que se declara en el fichero/etc/services. Este fichero determina sobre qué puerto debe ponerse a

Page 75: Tp Final Aso

74

escuchar inetd. Si se crea un nuevo servicio se debe especificar primero en/etc/services.

socket-type

Puede ser stream, dgram, raw o seqpacket. stream se debe utilizar obligatoriamente para dæmones orientados a conexión (dæmones TCP) mientras que dgramse utiliza en dæmones basados en el protocolo de transporte UDP.

protocol

Uno de los siguientes:

Protocolo Explicación

tcp, tcp4 TCP IPv4

udp, udp4 UDP IPv4

tcp6 TCP IPv6

udp6 UDP IPv6

tcp46 TCP IPv4 e IPv6 al mismo tiempo

udp46 UDP IPv4 e IPv6 al mismo tiempo

{wait|nowait}[/max-child[/max-connections-per-ip-per-minute]]

wait|nowait indica si el dæmon puede gestionar su propio “socket” o no. Los “ sockets” de tipo dgram deben utilizar obigatoriamente la opción wait mientras que los dæmones basados en “sockets” de tipo “stream”, los cuales se implementan normalmente mediante hilos, debería utilizar la opción nowait. La opción waitnormalmente entrega varios “ sockets” a un único dæmon, mientras que la opción nowait lanza un dæmon “hijo” por cada nuevo “ socket”.

El número máximo de dæmones “ hijo” que puede lanzar inetd se puede especificar mediante la opción max-child. Si se necesita por ejemplo un límite de diez instancias para un dæmon en particular se puede especificar el valor 10 justo después de la opción nowait.

Además de max-child se puede activar otra opción para limitar en número máximo de conexiones que se aceptan desde un determinado lugar mediante la opciónmax-connections-per-ip-per-minute. Esta opción hace justo lo que su nombre indica. Un valor de, por ejemplo, diez en esta opción limitaría cualquier máquina remota a un máximo de diez intentos de conexión por minuto. Esto resulta útil para prevenir un consumo incontrolado de recursos y ataques de Denegación de Servicio (“Denial of Service” o DoS) sobre nuestra máquina.

Cuando se especifica este campo las opciones wait o nowait son obligatorias max-child y max-connections-per-ip-per-minute son opcionales.

Un dæmon de tipo “stream” sin la opción max-child y sin la opción max-connections-per-ip-per-minute simplemente especificaría la opción nowait.

El mismo dæmon con el límite máximo de diez dæmones “hijos” sería: nowait/10.

Page 76: Tp Final Aso

75

La misma configuración con un límite de veinte conexiones por dirección IP por minuto y un máximo total de diez dæmones “hijos” sería: nowait/10/20.

Todas estas opciones son utilizadas por el dæmon fingerd que se muestra a continuación a modo de ejemplo:

finger stream tcp nowait/3/10 nobody /usr/libexec/fingerd fingerd -s

user

Este es el nombre de usuario con el que debería ejecutarse un determinado dæmon. Normalmente los dæmones se suelen ejectar con permisos de root. Por motivos de seguridad, resulta bastante común encontrarse con algunos servidores que se ejecutan bajo el usuario daemon o incluso por el usuario menos privilegiado de todos que es el usuario nobody.

server-program

La ruta completa de la localización del dæmon que se quiere ejecutar cuando se recibe un intento de conexión. Si el dæmon es un servicio proporcionado por el propio inetd se debe utilizar la opcion internal en su lugar.

server-program-arguments

Esto funciona en conjunción con server-program, ya que especifica los argumentos, comenzando por argv[0], que se pasan al dæmon cuando se le invoca. Si la línea de órdenes es mydaemon -d, midæmon -d debería ser el valor de la opción server-program-arguments. Si el dæmon es un servicio interno se debe utilizar la utilizar la opción internal en lugar de la que estamos comentando.

Xinetd:

xinetd (eXtended InterNET Daemon), Demonio EXtendido de Internet, es un servicio o

demonio que usan gran parte de los sistemas Unix dedicado a administrar la conectividad

basada en Internet. xinetd es una extensión más segura del servicio de Internet inetd.

xinetd contiene mecanismos de control de acceso como Wrappers TCP, Listas de Control

de Acceso, y la posibilidad de habilitar los Servicios_de_red basándose en el tiempo.

Puede limitar la cantidad de servicios que se ejecutan, y contiene un sistema de

protección contra escaneos de puertos.

Page 77: Tp Final Aso

76

Servicio FTP: El sistema operativo FreeBSD trae por defecto muchos programas y entre ellos se encuentra un pequeño y ligero servidor ftp para poder subir y bajar archivos remotamente. Para configurarlo primero editamos el archivo inetd.conf para activar el servidor ftp por defecto que vienen en todas las distribuciones FreeBSD.

root# vi /etc/inetd.conf Y descomentamos las siguientes lineas :

#ftp stream tcp nowait root /usr/libexec/ftpd ftpd -l #ftp stream tcp6 nowait root /usr/libexec/ftpd ftpd -l

Cuando estemos listos pulsamos la tecla “ESC” escape y seguidamente introducimos los caracteres :wp! Ahora editaremos el rc.conf para decirle al sistema que carge el cargador de demonios inetd.

root# vi /etc/rc.conf A continuación insertamos esta linea:

inetd_enable=”YES” Cuando estemos listos pulsamos la tecla “ESC” escape y seguidamente introducimos los caracteres :wp! Reiniciamos la maquina para que los cambios surjan efecto.

root# reboot Una vez este reiniciada la maquina vamos a comprobar que todo ha funcionado.

root# netstat -a Si vemos estas dos líneas en pantalla es que todo ha resultado:

tcp6 0 0 *.ftp *.* LISTEN tcp4 0 0 *.ftp *.* LISTEN

Page 78: Tp Final Aso

77

Servicio de Correo Electrónico: Existen varios elementos relacionados con el intercambio de correo electrónico. A saber: El agente de usuario (Mail User Agent o MUA), El agente de transporte de correo (Mail Transport Agent o MTA), El DNS, Las carpetas de correo (Mailboxes), y por supuesto, la máquina servidora de correo (mail host).

El Agente de Usuario Entre las opciones más conocidas tenemos: mutt, pine, elm, y mail, junto con programas con interfaz gráfica del estilo de balsa o xfmail por nombrar unos pocos. También existen lectores de correo basados en navegadores web. Los programas de correo basados en navegadores web actúan de pasarela para las transacciones de correo electrónico, entregando dichas transacciones al “servidor de correo” local, llamando a uno de los agentes de transporte de correo disponibles en la máquina local, o entregando dichas transacciones a un agente de transporte remoto utilizando el protocolo TCP.

Agente de Transporte de Correo

FreeBSD viene con sendmail por defecto, pero también se soportan otros dæmones,

entre los cuales se encuentran:

exim;

postfix;

qmail.

El agente de transporte de correo normalmente posee dos funcionalidades, por un lado se

responsabiliza de la recepción y por otro se encarga de entregar el correo de salida. No es responsable de la recolección automática de correo mediante la utilización

de protocolos como POP o IMAP, ni se utiliza para que el usuario pueda acceder a las

carpetas de correo locales. Para realizar estas otras tareas, se

necesitan dæmons adicionales.

Correo electrónico y DNS

El Sistema de Nombres de Dominio (en inglés DNS) y su correspondiente dæmon (llama-

do named) constituyen una parte fundamental del procedimiento de entrega de correo

electrónico. Para entregar el correo electrónico al destinatario adecuado el dæmon servi-

dor de correo busca el sitio remoto dentro del sistema de DNS.

El DNS es la entidad responsable de asociar nombres con direcciones IP, pero además

se encarga de almacenar información específica relacionada con la entrega de correo

mediante registros de tipo MX. Los registros MX (Mail eXchanger) especifican qué máqui-

na o máquinas están encargadas de recibir correo electrónico para un determinado nom-

bre de dominio. En caso de no existir ningún registro MX para el dominio del destinatario,

Page 79: Tp Final Aso

78

se busca información almacenada en registros de tipo A para enviar el correo al destino

final.

Se pueden consultar los registros MX para cualquier dominio utilizando el comando host,

como se puede observar en el siguiente ejemplo:

% host -t mx FreeBSD.org

FreeBSD.org mail is handled (pri=10) by mx1.FreeBSD.org

Recepción de correo

La recepción de correo electrónico para su dominio se realiza mediante lo que se conoce

como la máquina de correo (mail host). Ésta máquina recoge todo el correo dirigido a su

dominio y lo almacena en mbox (el método por defecto para el almacenamiento de correo)

o en formato Maildir, dependiendo de la configuración de la máquina. Una vez que el

correo ha sido almacenado con éxito se puede leer en local utilizando aplicaciones

como mail o como mutt, o de forma remota mediante un conjunto de protocolos tales

como POP o IMAP. Esto significa que si se va a leer el correo de forma local no se

necesita instalar ningún servidor de POP o IMAP.

Para poder acceder a carpetas de correo de forma remota se necesita tener acceso a un

servidor de POP o IMAP. Estos protocolos permiten a los usuarios conectarse a sus car-

petas de correo desde ubicaciones remotas de una forma sencilla. Aunque am-

bos, POP y IMAP, permiten este acceso remoto IMAP ofrece algunas ventajas añadidas,

algunas de las cuales son:

El acceso mediante IMAP permite almacenar los correos en el servidor remoto sin

necesidad de extraerlos y tener que almacenarlos en local.

IMAP soporta actualizaciones concurrentes.

IMAP resulta ser extremadamente útil bajo enlaces de baja velocidad puesto que

permite a los usuarios recuperar la estructura de los mensajes sin necesidad de

bajarse todo el contenido. Además puede realizar tareas tales como búsquedas di-

rectas en el servidor con el fin de minimizar la utilización de la red.

Page 80: Tp Final Aso

79

Para instalar un servidor de POP o de IMAP se deben dar los siguientes pasos:

1. Seleccionar el servidor IMAP o POP que mejor cumpla a sus necesidades. Los si-guientes servidores POP e IMAP son bien conocidos y son firmes candidatos para ello:

o qpopper; o teapop; o imap-uw; o courier-imap;

2. Instalar el dæmon POP o IMAP de su elección desde el árbol de “ports”. 3. Modifique donde sea necesario /etc/inetd.conf para que el servidor POP o IMAP se

ejecute automáticamente.

Acceso a carpetas de correo locales

Las carpetas de correo pueden abrirse de forma local utilizando un agente de correo de

usuario (MUA) en el servidor donde reside la carpeta. Se suelen usar los

programas mutt o mail.

Seguridad:

Conceptos de seguridad

En general, un sistema debe ser tan seguro físicamente como sea necesario, y el sistema solo debe tener los servicios y programas privilegiados que sean estrictamente necesarios para el nivel de operaciones deseado.

Sistema físico y consola

Con acceso físico al sistema, un atacante puede seleccionar la opción -s en el prompt de arranque y obtener un shell con privilegios de root en modo monousuario. Para evitar esto, si el sistema no está físicamente en un lugar seguro, es una buena idea marcar la consola como insegura en /etc/ttys para que el sistema requiera el password de root al entrar en modo monousuario. Si, como decimos, el sistema no se encuentra en un lugar seguro, no debería tener disquetera. Un atacante puede usar el boot prompt para arrancar un kernel retocado o montar el floppy como la partición raíz, pasando por alto cualquier protección establecida en /etc/ttys.

Programas setuid y Daemons

Los problemas con demonios y programas setuid son explotados habitualmente por los crackers para obtener privilegios de root en los sistemas. Es aconsejable tener instalados el menor número posible de daemons y programas setuid en los sistemas para reducir los posibles problemas en caso de que se descubra algún tipo de vulnerabilidad en éstos.

Page 81: Tp Final Aso

80

Daemons

La idea con los daemons es desactivar todos y cada uno de ellos que no sean estrictamente necesarios. Hay que editar los ficheros /etc/rc.conf y /etc/inetd.conf para desactivar los servicios no usados. Por ejemplo, si los servicios rlogin o rsh no son necesarios, pueden ser desactivados en /etc/inetd.conf comentándolos con el símbolo #. De la misma manera, si el daemon de impresión lpr no es necesario, hay que poner la opción lpd_enable en el fichero /etc/rc.conf a "NO". Otra estrategia es reemplazar los daemons que son conocidos por haber tenido problemas de seguridad por otros que nos provean de los mismos servicios pero que hayan sido desarrollados teniendo en cuenta la seguridad. Por ejemplo, mientras en FreeBSD se mantiene el sendmail relativamente actualizado, podríamos reemplazarlo por el programa qmail, diseñado y escrito enteramente pensando en la seguridad.

Programas setuid

Los programas setuid son programas especiales en el sistema que se ejecutan con los privilegios del propietario del programa, sea cual sea el usuario que lo esté ejecutando. Por ejemplo el programa PPP /usr/sbin/ppp realiza algunas operaciones que solo están permitidas al usuario root, por lo que tiene activado el bit de setuid, y su propietario es root. Como resultado, cuando cualquier usuario ejecuta ppp, éste se ejecuta con los permisos de seguridad del usuario root. Los programas setuid son un problema de seguridad, por que algunos programas tienen bugs que permiten a los crackers aprovecharse de ellos. Provocar problemas de overrun y sobreescribir el stack con código maligno es un sistema común de ataque en programas setuid. Desde el momento en que el programa se está ejecutando con privilegios de root, el código del cracker se ejecuta con los privilegios de root. La manera más sencilla de revisar los programas setuid y setgid en el sistema es ejecutar los comandos:

find / -perm -4000 -print find / -perm -2000 –print

Usando la lista generada de ficheros setuid y setgid, puedes determinar los que no son necesarios para tu sistema. Usa el comando "chmod gu-s nombre_fichero" para desactivar los bits de setuid y setgid.

Sistemas de ficheros

Un sistema donde los sistemas de ficheros de los usuarios están separados de los sistemas de ficheros que contienen los programas ejecutables y ficheros de dispositivos pueden parar ataques potenciales o "back doors". Un método de obtener acceso de root o dejar una "back door" para obtener ese acceso posteriormente es crear un ejecutable setuid o crear un fichero especial de dispositivo que permita acceso de escritura a la memoria del sistema. Las opciones nosuid y nodev pueden ser usadas en /etc/fstab en sistemas de ficheros que no deban contener setuid o ficheros de dispositivos. Estas opciones pueden ser usadas en sistemas de ficheros en los cuales los usuarios

Page 82: Tp Final Aso

81

pueden crear ficheros. Es muy buena idea separar los directorios que contengan ficheros de usuarios, como /home, /tmp, /var/tmp en un sistema de ficheros separado del /usr. Las opciones nosuid y nodev son especialmente importantes en sistemas que monten unidades NFS de sistemas inseguros o no fiables. Un usuario avanzado del otro sistema podría crear un ejecutable setuid-root o un dispositivo /dev/kmem-equivalent en el servidor, y usar a continuación ese fichero en el cliente para obtener privilegios de root. La opción noexec puede ser muy útil en un sistema de ficheros montado desde un servidor no fiable.

Monitorizando el sistema de ficheros

Algunos ataques a sistemas se realizan mediante el sistema de ficheros Unix, normalmente abusando de daemons o programas setuid. Típicamente estos programas crean o cambian ficheros de configuración, como el fichero de usuario .rhosts, permitiendo el acceso al sistema. Estos ataques se previenen cerrando "agujeros" en los daemon y programas setuid, pero estos agujeros deben ser encontrados primero. Es recomendable reducir la posibilidad de estos ataques o su detección inmediata monitorizando el sistema. FreeBSD envía diariamente un informe de seguridad al usuario root. Chequea los posibles nuevos o modificados programas setuid y ficheros de dispositivos. Si aparece un nuevo programa setuid, la hora o el tamaño cambia misteriosamente, o aparece un nuevo UID 0 (root), es probablemente el momento de investigar. Pero, si un sistema ha sido sabiamente crackeado, los informes no indicarán ningún problema, por que el script de seguridad y sus ficheros de datos son vulnerables a ser falseados. Solo tripwire, cuando está correctamente instalado y usado, puede detectar de manera fiable que un sistema ha sido comprometido. Desafortunadamente, debido a la manera en la que el sistema es escaneado por programas setuid, es posible que el resultado del informe cambie, causando una falsa alarma ocasional en la sección de "setuid files and devices" del informe de seguridad.

Monitorización avanzada con tripwire

Tripwire es un package que monitoriza el sistema de ficheros para prevenir los cambios en ficheros y permisos. Las instrucciones de instalación del programa nos dan una excelente visión del package y del procedimiento correcto de instalación. Esencialmente, tripwire debería ser instalado e inicializado en un sistema totalmente seguro y no comprometido. El fichero ejecutable de tripwire, linkado como un ejecutable estático para evitar el uso de las librerías compartidas del sistema, y su fichero de base de datos, que contiene las firmas digitales que verifican la integridad de los ficheros del sistema, deberían ser escritos en un soporte de solo lectura. Después, cuando tripwire es usado para verificar la integridad de un sistema, debería ser invocado directamente desde su ejecutable en el soporte de solo lectura. Una posibilidad es instalar el ejecutable y la base de datos en un floppy de 3.5" y de solo lectura.

Page 83: Tp Final Aso

82

rhosts y hosts.equiv

Si los servicios de red de shell remota (rshell) o login remoto (login) están activados en /etc/inetd.conf, los ficheros /etc/hosts.equiv y .rhosts son importantes para la seguridad. El fichero hosts.equiv define los sistemas que tienen usuarios reconocidos por nuestro sistema para que no les sea requerido el password al realizar la conexión. Cada fichero $HOME/.rhosts define los sistemas remotos y usuarios que pueden usar esta cuenta sin tener que dar un password. Esencialmente, ningún nombre de sistema debería figurar en estos ficheros a no ser que los hosts y redes sean de total y absoluta confianza. Hay que tener en cuenta que si la línea + + aparece en estos ficheros, el sistema es totalmente inseguro y cualquier usuario de cualquier sistema puede hacer un login a tu sistema sin necesidad de password. Algunas formas de ataque se basan en crear un fichero .rhosts en el directorio de usuario o añadir datos a un fichero .rhosts ya existente. Parece que este tipo de ataque se lleva a cabo cada vez con menor frecuencia desde que se han mejorado las comprobaciones de propietarios y permisos que realizan rlogin y rsh antes de permitir el acceso. Aun así, este ataque es aun posible. Un método que elimina completamente este problema es desactivar los servicios rlogin y rsh comentando o borrando las líneas referentes a login y shell en /etc/inetd.conf aunque a veces, la desactivación de estos servicios no es lo más apropiado. Por ejemplo, el protocolo shell es usado por otros servicios como rdump. Un método más aceptable de limitar la exposición de servicios es limitar los sistemas a los cuales permitimos realizar rlogin y rsh. Esta limitación está implementada en el daemon TCP wrappers de Weitse Venema. Otra solución es añadir la opción -l a los servicios rlogind y rshd en las entradas apropiadas de /etc/inetd.conf para forzar la autenticación usando cualquier fichero .rhosts diferente al de root.

Ficheros de dispositivos especiales

Los ficheros de dispositivos especiales dan acceso directo al hardware del sistema a través de nombres en el sistema de ficheros, como /dev/mem para acceso a la memoria del sistema. El acceso al hardware crítico debería ser fuertemente restringido. Por ejemplo, si /dev/mem fuese de libre lectura para todo el mundo, el password de un usuario podría ser observado leyendo el segmento de datos del programa de login mientras este está funcionando. Un ataque a través de ficheros de dispositivos puede realizarse usando una vulnerabilidad en un daemon o en un programa setuid para crear un dispositivo /dev/kmem-equivalent, y a continuación escribir en el kernel a través del nuevo dispositivo creado y así poder incrementar el nivel de privilegio del shell del intruso. Si el fichero de dispositivo no está protegido correctamente, el trabajo del intruso para aumentar sus privilegios es realmente sencillo. Los ficheros de dispositivos son correctamente protegidos durante la instalación de FreeBSD, pero deberíamos verificarlos.

Page 84: Tp Final Aso

83

Protocolos de red

Existen diferentes tareas a realizar en los protocolos de servicios de red y en el propio TCP/IP.

Desactivar los servicios innecesarios en los ficheros /etc/inetd.conf y /etc/rc.conf. Filtrado de los paquetes que entran en nuestra red desde el exterior y que contengan direcciones internas en el campo origen. Estos paquetes son obviamente originados por un equipo mal configurado o por un intento de spoofing. Usar el daemon TCP wrappers en los servicios TCP arrancados vía inetd para comprobar y filtrar el origen de las peticiones. Verificar la dirección IP de origen y el nombre del host remoto, e implementar restricciones de acceso basadas en las direcciones IP de origen. El package "ssh secure shell" ofrece para los logins remotos y transferencia de ficheros la encriptación de todos los datos que viajan por la red. Solo por esta razón, ssh ya es una gran alternativa para telnet, rlogin y ftp, especialmente para la administración remota. La encriptación de todos los datos entre el origen y el destino nos previenen de los posibles sniffers instalados en la red. El protocolo "Netwok File System" (NFS), que permite compartir sistemas de ficheros entre sistema remotos, tiene diferentes vacíos de seguridad. Si es usado, es aconsejable usarlo a través de un firewall (hay que tener en cuenta que FreeBSD puede funcionar como filtro de paquetes). Si NFS es usado en entorno hostil (por ejemplo, conectado a Internet sin filtrado de paquetes vía router o firewall), el comando fsirand debería ser usado para hacer aleatoria la creación de números de i-nodos. Como NFS, el "Network Information Service" (NIS, también conocido como "Paginas amarillas") tiene diferentes vacíos de seguridad. NIS es útil para la distribución de información de cuentas en una red de sistemas Unix. Al contrario que NFS, NIS no usa un rango particular de puertos, por lo que no puede ser ocultado tras un firewall. El NIS de FreeBSD usa el fichero de configuración /var/yp/securenets para limitar el acceso de clientes a la información.

Características de FreeBSD

FreeBSD ofrece diferentes características no habituales en el resto de sistemas Unix.

Niveles de seguridad

Los sistemas Unix sufren con el todo poderoso acceso concedido al usuario root. Una vez un cracker obtiene privilegios de root, el sistema completo se vuelve vulnerable al cracker. Los sistemas derivados de 4.4BSD ofrecen una nueva característica de seguridad llamada "niveles de seguridad del sistema" . Usada correctamente, esta característica puede prevenir la introducción de caballos de Troya y back doors en los ejecutables del sistema y la modificación de los ficheros de configuración. Los niveles de seguridad del sistema son: -1, modo permanentemente inseguro; 0, modo inseguro - no hay protecciones adicionales activadas; 1, modo seguro - ficheros protegidos contra la modificación y ficheros de dispositivos no abiertos para escritura; 2, modo altamente seguro - protección de nivel 1 más dispositivos de disco no abiertos para escritura; 3, modo de seguridad extendida - protección de nivel 2 más filtrado de paquetes IP. El nivel de seguridad por defecto -1 es llamado "modo de inseguridad permanente".

Page 85: Tp Final Aso

84

Los niveles por encima de 0 causan la desactivación en el kernel de las siguientes operaciones:

Activación de los flags de ficheros "immutable" y "append-only". Acceso directo de escritura a los dispositivos de disco montados en el nivel 1 de

seguridad, o a los dispositivos de disco en nivel de seguridad 1 o superiores. Escritura a los ficheros de dispositivo /dev/mem y /dev/kmem Modificaciones a cualquier fichero con el flag "immutable" activado. Cargar cualquier modulo de kernel. Cambios a las listas de filtrado de paquetes IP (en nivel 2 o superiores).

Cuando un sistema FreeBSD es instalado usando la opción make world en el código fuente, una serie de ficheros son instalados con el flag "immutable" activado. En general, los ficheros ejecutables setuid de root son instalados con el flag "immutable". En cualquier momento, el flag schg puede ser activado con el comando chflags, pero el flag solo puede ser eliminado cuando el sistema está en el nivel de seguridad \0001 o 0. Durante el funcionamiento en modo multiusuario, el nivel de seguridad debería ser aumentado. El comando para aumentar el nivel de seguridad a 1 es:

sysctl -w kern.securelevel 1

El nivel de seguridad del sistema puede ser aumentado automáticamente en el arranque del sistema incluyendo el correspondiente comando sysctl en el fichero /etc/rc.local. El aumento de los niveles de seguridad comporta una limitación en las actividades de gestión de los ficheros, por lo que no es aconsejable usar esta opción en sistemas frecuentemente cambiantes. Una vez el nivel de seguridad ha sido aumentado, la única manera de disminuirlo es rearrancar el sistema. Si se necesita realizar tareas de mantenimiento importantes en el sistema, éste puede ser arrancado en modo monousuario, donde el nivel de seguridad por defecto es de -1.

IP Firewall

Muchos de los protocolos TCP/IP incluidos en FreeBSD, como NFS y NIS, son mucho más seguros si no pueden ser accedidos desde el exterior de la parte segura de la red. Para protocolos que no puedan ser restringidos de ninguna otra manera, un filtro de paquetes que solo permita pasar los protocolos especificados puede ser una buena idea para bloquear el acceso externo. La opción del kernel de FreeBSD IPFIREWALL activa la opción de IP firewalling, la cual aplica reglas de filtrado sobre los paquetes entrantes o salientes de la máquina. Cuando un kernel compilado con IPFIREWALL arranca, por defecto descarta todos los paquetes IP. Reglas de filtrado adicionales deben ser establecidas para aceptar el tráfico deseado en los dos sentidos (entrada y salida). El script de arranque /etc/rc.firewall contiene diferentes ejemplos de filtrado. Los tipos de filtrado son seleccionados con la opción firewall en /etc/rc.conf, la cual incluye:

Page 86: Tp Final Aso

85

Open - Sin limitación de ningún tipo. Cualquier paquete IP puede entrar y salir por cualquiera de las interfaces del sistema.

Client - Protege un sistema que sea cliente en la red. Dado el nombre de la máqui-na, dirección IP y máscara, un filtro básico se establece para permitir todo el tráfico originado desde o destinado a la red local, permite paquetes para cualquier cone-xión TCP establecida, permite email entrante y cualquier conexión TCP saliente, y permite peticiones DNS y NTP por UDP. Cualquier otra cosa es denegada.

Simple - Creación de un filtro de paquetes en un sistema que ruta entre diferentes redes. Dados los números de red, máscaras, y direcciones IP de la red externa (in-segura) e interna (segura), esta opción en rc.firewall crea un filtro que:

- Previene la entrada de paquetes externos con el campo origen de la red interna, y evita la salida de paquetes que en su campo origen no contengan una dirección de la red interna.

- Permite todos los paquetes para conexiones tcp establecidas.

- Permite conexiones TCP para correo entrante, DNS y peticiones HTTP.

- Rechaza y "loguea" (vía syslogd(8)) todos los intentos de conexiones a servicios TCP diferentes de los permitidos anteriormente.

- Permite todas las peticiones y respuestas de DNS y NTP UDP.

- Deniega cualquier cosa no explícitamente permitida.

Si el nivel de seguridad del sistema es inferior a 2, no se permiten cambios en la lista de filtrado de paquetes. Esto permite al administrador de sistemas prevenir las posibles modificaciones en el listado de filtro de paquetes en el caso de que un sistema se vea comprometido. La opción IP firewall nos puede ayudar a monitorizar los posibles ataques que se produzcan a nuestro sistema. La opción del kernel IPFIREWALL_VERBOSE activa el log del filtrado de paquetes vía syslogd(8). La información recogida puede ser útil en la detección de escaneos de puertos o intentos de entrada no autorizados del sistema.

One-Time Passwords

El sniffing de passwords ha sido uno de los constantes problemas que se encuentran los administradores de red y sistemas. Los usuarios que realizan telnet o ftp remotos a través de Internet deberían ser avisados para que usen el sistema de "one-time password" para evitar que su password "reusable" pueda ser capturado y usado ilícitamente. FreeBSD usa el software S/Key para proveer el servicio de "one-time password". Los usuarios pueden configurarse su "one-time password" en FreeBSD usando el comando :

keyinit

Page 87: Tp Final Aso

86

El cual preguntará por un password privado que solo conoce el usuario. Este password debería ser diferente del password usado regularmente, pero no es obligatorio. El keyinit mostrará algo como:

ID fred s/key is 99 sp99609

BUY OUR BOLD LEER YOKE COW

El usuario puede ahora generar una serie de one-time passwords para usar en sus accesos remotos usando el comando:

key -n 10 98 sp99609

El cual preguntará por el password privado usado en el comando keyinit anterior, generando los passwords para los próximos 10 logins. El usuario puede imprimir estos passwords y llevárselos consigo (por supuesto, la impresión de estos passwords comporta otra serie de implicaciones de seguridad). Un sistema FreeBSD puede requerir el uso de passwords S/Key para todos los logins remotos. El fichero /etc/skey.access define cuando debe ser usado el sistema S/Key. Por ejemplo, si el administrador confía en los sistemas de su propia red (172.16.xxx.xxx), pero quiere que todos los usuarios se vean obligados a usar S/Key desde cualquier sistema externo, podría usar un fichero /etc/skey.access como este:

permit 172.16.0.0 255.255.0.0

deny

Hay que tener en cuenta que /etc/skey.access no afecta a todos los métodos de acceso remoto, solo a telnet, ftp y rlogin. Por ejemplo, ssh, pop daemons e imap daemons ignoran las restricciones S/Key.

Desactivación de cuentas

Si un password llega a manos de un cracker, el cracker intentará acceder a la cuenta comprometida a través de protocolos como telnet y ftp, lo que puede comprometer la seguridad global del sistema o sistemas donde resida la cuenta comprometida. Un administrador puede restringir completamente el acceso telnet o ftp desde una cuenta determinada o host, ajustando el fichero /etc/login.access. Esta opción puede reducir el peligro de passwords o cuentas comprometidas limitando los lugares desde los que esta cuenta es accesible. De todas maneras, la mejor solución, si es posible, es dar de baja la cuenta comprometida. Si esto no es posible por cualquier motivo, el paso mínimo a realizar es el cambio de password de dicha cuenta. Hay que tener en cuenta que login.access no afecta a todos los métodos de acceso remoto, solo a telnet, ftp y rlogin. Por ejemplo, ssh, pop daemons e imap daemons ignoran las restricciones establecidas en login.access. Por ejemplo, si un administrador quiere permitir logins para todas sus cuentas desde dos

Page 88: Tp Final Aso

87

redes, 172.16 y 192.168.32, y permitir a todos los usuarios incluidos en el grupo wheel hacer login desde la máquina con dirección 192.168.2.2, este es el fichero /etc/login.access que puede ser usado:

+:ALL:172.16.

+:ALL:192.168.32.

+:wheel:192.168.2.2

-:ALL:ALL

Sendmail

Desgraciadamente, durante los últimos tiempos se están produciendo ataques indiscriminados, que si bien no afectan a la propia seguridad del sistema, si afectan al rendimiento de éstos y al uso de recursos propios de manera no autorizada. Me estoy refiriendo a la nefasta técnica del spam, que se basa en usar servidores smtp ajenos para envíos masivos de correo no solicitado. Esta técnica empezó como algo anecdótico (de hecho, hasta hace poco tiempo, no se solía instalar ningún filtro en los servidores smtp confiando en la buena intención de los usuarios de Internet y administradores de sistemas conectados a ella), pero se está convirtiendo en una auténtica plaga. La política a seguir se basa en limitar el acceso a los servidores smtp de la siguiente manera:

Aceptamos correo para cualquier destino con origen en nuestra/s red/es. Aceptamos correo de redes remotas con destino solo a nuestros usua-

rios/dominios. Si hacemos mail backup, aceptamos relay solo para dominios autorizados.

Gracias al equipo de desarrollo, FreeBSD es un sistema sólido que puede ser configurado para aguantar ataques de seguridad importantes. Mientras que la instalación por defecto es todavía relativamente abierta y amigable para los usuarios, FreeBSD contiene muchos mecanismos de seguridad y packages añadidos que permiten aumentar la resistencia del sistema. Estos aumentos de seguridad pueden asegurar una operación y viabilidad del sistema, así como la confidencialidad de la información contenida en él.

Page 89: Tp Final Aso

88

Jails:

Introducción

Dado lo dificil y desconcertante de la tarea de administrar sistemas se han ido desarrollando poderosas herramientas con el fin de hacer la vida del administrador más sencilla. Dichas herramientas suelen facilitar cierto tipo de mejoras en la instalación, configuración o mantenimiento de los sistemas. Una de las tareas que se espera que cumpla un administrador de sistemas es la configuración adecuada de la seguridad, de modo que pueda dar el servicio para el que se ha destinado sin que pueda verse comprometido.

Una de las herramientas disponibles para mejorar los niveles de seguridad de un sistema FreeBSD es el uso de jaulas (jails). Las jaulas fueron introducidas en FreeBSD 4.X por Poul-Henning Kamp, pero en FreeBSD 5.X sus capacidades fueron aumentadas hasta hacer de ellas un subsistema poderoso y flexible. Su desarrollo sigue avanzando, aumentando así su utilidad, rendimiento, fiabilidad y seguridad.

Qué es una jaula

Los sistemas tipo BSD disponen de chroot desde la época de 4.2BSD. chroot nos permite restringir el directorio raiz de un conjunto de procesos, creando un entorno seguro y separado del resto del sistema. Los procesos creados dentro de un entorno chroot no pueden acceder a ficheros o recursos ubicados fuera del mismo. Por esta razón, si un atacante logra comprometer un servicio que se ejecuta en un entorno chroot no debería automáticamente poder acceder al resto del sistema. chroot es una buena herramienta para tareas sencillas que no requieran mucha flexibilidad o características complejas o muy avanzadas. Por desgracia, desde la invención de chroot se han ido encontrando muchas formas de saltarse las barreras que chroot impone y, aunque estén corregidas en las versiones más modernas del kernel de FreeBSD, era evidente que chroot no era la solución ideal para ejecutar servicios con seguridad. Había que implementar un nuevo subsistema.

Este es uno de los principales motivos por los que se crearon las jaulas.

Las jaulas llevan más allá en muchos sentidos el concepto tradicional de entorno chroot. En un entorno chroot tradicional los procesos solo ven limitada la parte del sistema de ficheros a la que pueden acceder. El resto de recursos del sistema, es decir, el conjunto de usuarios del sistema, los procesos en ejecución o el subsistema de red están compartidos entre el sistema alojado y el servidor. Las jaulas extienden este modelo virtualizando no solamente el acceso al sistema de ficheros, sino al conjunto de usuarios, al subsistema de red del kernel de FreeBSD y unas cuantas cosas más. Una jaula se caracteriza por disponer de cuatro elementos:

Page 90: Tp Final Aso

89

Un “subárbol” de directorios: el punto desde el que se entra a una jaula. Una vez dentro de la jaula un proceso no puede escapar de dicho “subárbol”. Los típicos problemas de seguridad que aparecían una y otra vez en el diseño del chroot origi-nal no afectan a las jaulas de FreeBSD.

Un nombre de máquina (“JacJulHOST”), que definirá a la jaula. Las jaulas se usan principalmente para albergar servicios de red, por lo que disponer de un nombre de máquina descriptivo ayuda enormemente al administrador de sistemas.

Una dirección IP: debe asignarse a la jaula y no cambiarse durante el ciclo de vida de la jaula. La dirección IP de una jaula suele ser un alias de un interfaz de red, aunque no es imprescindible que así sea.

Un comando: La ruta de un ejecutable ubicado dentro de la jaula. La ruta es relati-va al directorio raíz de la jaula, por lo que puede ser muy diferentes según el en-torno.

Además, las jaulas pueden tener sus propios usuarios e incluso su propio root. Es obvio que este usuario root tiene su poder para hacer circunscrito a la jaula y, desde el punto de vista del servidor, el usuario root de la jaula no es omnipotente. El usuario root de la jaula no puede ejecutar tareas críticas fuera de la jaula (jail) a la que pertenece.

Creación y gestión de jaulas

Algunos administradores dividen las jaulas en dos tipos: jaulas “completas”, que recrean un sistema FreeBSD real, y jaulas “de servicio”, que son aquellas que están dedicadas a una sola aplicación o servicio, en muchos casos ejecutándose sin privilegios. Se trata de una división exclusivamente conceptual, por lo que el proceso de generación de una jaula no se ve afectado por ella. Procedimiento a seguir para generar una jaula:

# setenv D /aquí/está/la/jaula # mkdir -p $D # cd /usr/src # make world DESTDIR=$D # cd etc/ # make distribution DESTDIR=$D # mount_devfs devfs $D/dev

El mejor punto de partida es la elección del punto del sistema de ficheros del servidor donde estará físicamente ubicada la jaula. /usr/jail/nombredelajaula es un buen sitio. nombredelajaula es el nombre de máquina que identifica a la jaula. El sistema de ficheros /usr/ suele tener espacio suficiente para albergar el sistema de ficheros de la jaula que, cuando se trata de jaulas “completas”, es esencialmente lo necesario para alojar todos y cada uno de los sistemas de ficheros en una instalación del sistema base por omisión de FreeBSD.

Este comando creará el contenido necesario (binarios, bibliotecas, páginas de manual, etc.) y lo copiará al “subárbol” elegido como ubicación física de la jaula. Todo se hace al típico estilo FreeBSD: se compila todo y luego se instala en la ruta de destino.

Page 91: Tp Final Aso

90

Al pasar el “target” distribution a make se instalan todos los ficheros de configuración necesarios. En pocas palabras, instala cada fichero instalable que haya en /usr/src/etc/ en el directorio /etc de la jaula, es decir, en $D/etc/.

No es imprescindible montar el sistema de ficheros devfs dentro de la jaula aunque por otra parte (casi) todas las aplicaciones necesitan acceso al menos a un dispositivo, dependiendo esto del propósito de la aplicación. Es muy importante el control del acceso a dispositivos desde la jaula, puesto que una configuración descuidada puede permitir que un atacante haga de las suyas. El control sobre devfs.

Una vez instalada la jaula puede arrancarla mediante jail. Podemos pasarle otros argumentos además de estos, por ejemplo para ejecutar procesos enjaulados bajo los permisos de un usuario específico. El argumento comando depende del tipo de jaula; si se trata de un virtual system /etc/rc es una buena elección, puesto que ejecutará la secuencia de arranque de un sistema FreeBSD real. Si se trata de una jaula de servicio depende del servicio o aplicación que se quiera ejecutar mediante la jaula.

Con frecuencia las jaulas se arrancan durante el arranque del servidor que las aloja; el sistema rc de FreeBSD permite hacerlo de un modo muy sencillo.

1. Podemos crear una lista de jaulas que queramos arrancar en el inicio del sistema en el fichero rc.conf:

2. jail_enable="YES" # Ponemos NO si queremos desactivar el arranque de jaulas 3. jail_list="JJJail" # Lista de nombres de jaulas separados por espacios 4. Tendremos que añadir parámetros específicos para cada jaula al fichero rc.conf: 5. jail_JJJail_rootdir="/usr/jail/JJJail" # directorio raiz de la jaula 6. jail_JJJail_hostname="www.UAI.edu.ar" # nombre de máquina de la jaula 7. jail_JJJail_ip="192.168.0.10" # dirección IP de la jaula 8. jail_JJJail_devfs_enable="YES" # montar devfs en la jaula 9. jail_JJJail_devfs_ruleset="JJJail_ruleset" # reglas a aplicar a devfs dentro de la jau-

la

El arranque de jaulas por omisión que se configure en rc.conf ejecutará el script /etc/rc de la jaula y asumirá que es un sistema virtual completo. Si se trata de una jaula de servicio el comando de arranque por omisión tendrá que cambiarse configurando la opción jail_nombredejaula_exec_start según convenga.

Podemos arrancar o parar a mano una jaula mediante el script /etc/rc.d/jail siempre y cuando la jaula aparezca en rc.conf:

# /etc/rc.d/jail start JJJail # /etc/rc.d/jail stop JJJail

De momento no hay una forma limpia de apagar una jaula debido a que los comandos que se usan normalmente para producir un apagado limpio del sistema no pueden usarse

Page 92: Tp Final Aso

91

dentro de una jaula. La mejor forma de parar una jaula es ejecutar el siguiente comando desde dentro de la propia jaula o bien mediante jexec desde fuera:

# sh /etc/rc.shutdown

Administración y personalización a fondo

Hay diversas opciones que pueden usarse en las jaulas y varios tipos de formas de combinar un sistema FreeBSD servidor y las jaulas y poder disponer de aplicaciones de alto nivel. Mostraremos lo siguiente:

Algunas de las opciones disponibles para personalizar el comportamiento y las res-tricciones de seguridad que pueden aplicarse en una jaula.

Algunas de las aplicaciones de alto nivel creadas para la administración de jaulas. Estas aplicaciones están en la colección de ports y pueden utilizarse en conjunto para implementar productos basados en jaulas.

Herramientas del sistema para la personalización de jaulas en FreeBSD

La personalización a fondo de las jaulas se hace en su mayor parte mediante la configuración de variables sysctl. Hay una subcategoría especial de sysctl para que sea más sencillo organizar las opciones más importantes: se trata de las opciones de la jerarquía security.jail.* del kernel de FreeBSD. A continuación veremos una lista de las principales sysctl relacionadas con las jaulas y los valores que tienen por omisión. Los nombres deberían describir por sí mismos qué función tienen:

security.jail.set_hostname_allowed: 1 security.jail.socket_unixiproute_only: 1 security.jail.sysvipc_allowed: 0 security.jail.enforce_statfs: 2 security.jail.allow_raw_sockets: 0 security.jail.chflags_allowed: 0 security.jail.jailed: 0

El administrador del servidor puede usar estas variables para añadir o quitar limitaciones impuestas por omisión al usuario root. Tengamos en cuenta que hay ciertas limitaciones que no pueden quitarse. El usuario root no puede montar o desmontar sistemas de ficheros desde su jaula. El usuario root no puede cargar o descargar reglas de devfs, configurar reglas de cortafuegos ni ejecutar muchas otras tareas administrativas que requieran modificaciones o acceso a datos internos del kernel, como cambiar el nivel de seguridad securelevel del kernel.

El sistema base de FreeBSD contiene un conjunto básico de herramientas que permiten el acceso a información sobre jaulas activas en el sistema, así como la conexión a una jaula para ejecutar comandos administrativos. jls y jexec forman parte del sistema base de FreeBSD y permiten ejecutar las siguientes tareas:

Mostrar una lista de jaulas activas y sus correspondientes identificadores de jaula (JID), dirección IP, nombre de máquina y ruta.

Page 93: Tp Final Aso

92

Conectarse a una jaula en ejecución desde el servidor y ejecutar un comando den-tro de la jaula o realizar tareas administrativas dentro de dicha jaula. Esto es muy útil cuando el usuario root quiere apagar la jaula de forma limpia. La herramienta jexec permite también arrancar una shell dentro de la jaula para realizar tareas ad-ministrativas. Veamos un ejemplo:

# jexec 1 tcsh

Herramientas para tareas administrativas de alto nivel en la Colección de Ports

Entre las variadas aplicaciones ajenas al Proyecto FreeBSD que han ido apareciendo para administrar jaulas una de las más completas y útiles es sysutils/jailutils. Es un conjunto de pequeñas aplicaciones de mucha ayuda en la gestión de una jaula.