Latest Publications

Seguridad en el directorio tmp

La mayoría de los ataques mediante protocolo web se apoya en la ejecución de código maligno desde el directorio /tmp de nuestro server, una buena solución de seguridad es quitar los permisos de ejecución a nuestro directorio /tmp y asi evitar muchos problemas. A continuación veremos paso a paso lo que tenemos que hacer en nuestro server para evitar problemas potenciales:

Lo primero de haremos será crear un fichero que emulará la partición /tmp, por ejemplo de 500 MB.

#dd if=/dev/zero of=/dev/tmpTL bs=1024 count=500000

A continuación lo formateamos con nuestro sistema de archivos en mi caso etx3.

#/bin/mke2fs -j /dev/tmpTL

Luego hacemos un backup de nuestro actual /tmp, por si tuviésemos algún dato importante ahí (aunque no deberiamos tener gran cosa):

#mkdir /backup && cp -R /tmp /backup

Luego montamos nuestro nuevo archivo /tmp:

#mount -o loop,noexec,nosuid,rw /dev/tmpTL /tmp

Y lo agregamos en el /etc/fstab para que la proxima vez que reiniciemos todo siga funcionando.

/dev/tmpTL /tmp ext2 loop,noexec,nosuid,rw 0 0

Luego de montarlo y que todo este bien vamos a otorgar los permisos adecuados al archivo recien creado /tmp creado:

#chmod 1777 /tmp

Copiamos el contenido que teniamos en el antiguo /tmp

#cp -R /backup/* /tmp/

Crear una particion y transformarla en LVM usando fdisk

Crear una particion LVM usando fdisk

¿Que es particionar?

Las particiones de un disco duro son “trozos” del mismo cuyo principal fin debiera ser la de albergar distintos sistemas de archivos, incompatibles entre sí, que no pueden convivir en la misma partición.
Particionar un disco duro consiste en dividir al mismo en distintos “trozos”. Existen dos tipos de particiones, particiones primarias y particiones extendidas. Las particiones primarias sirven para albergar sistemas operativos y datos de programa, todo disco duro tiene al menos una partición primaria para contener datos y la mayor parte de los usuarios disponen de una única partición con el tamaño total del disco duro. El número máximo de particiones primarias es 4. Fué este número tan pequeño el que originó la aparición de las particiones extendidas, las cuales se utilizan para alargar el número máximo de particiones hasta el infinito (en la práctica no se aconseja un número de particiones superior a 12), puesto que una partición extendida puede contener tantas particiones primarias (denominadas en esta caso unidades lógicas) como se quiera.
Aveces aún poseyendo un único sistema operativo, si el disco duro tiene una gran capacidad, entonces, bien por antiguas exigencias del propio sistema operativo incapaz de crear particiones primarias tan grandes tales como la capacidad total de un disco duro grande, bien por razones de optimización (se obtiene mayor rendimiento de un disco duro particionado en varios trozos, tanto por velocidad de acceso como por un mejor aprovechamiento del espacio disponible).
En nuestro ejemplo vamos a ver cuales son los pasos para crear una particion primaria y darle el formato de LVM

1.- Nos conectamos a fdisk y observamos las particiones del dispositivo sda.

xendom0:/home/xen# fdisk /dev/sda

El número de cilindros para este disco está establecido en 19457.
No hay nada malo en ello, pero es mayor que 1024, y en algunos casos
podría causar problemas con:
1) software que funciona en el inicio (p.ej. versiones antiguas de LILO)
2) software de arranque o particionamiento de otros sistemas operativos
(p.ej. FDISK de DOS, FDISK de OS/2)

Orden (m para obtener ayuda): p

Disco /dev/sda: 160.0 GB, 160041885696 bytes
255 heads, 63 sectors/track, 19457 cylinders
Units = cilindros of 16065 * 512 = 8225280 bytes
Disk identifier: 0x4bf771ed

Disposit. Inicio Comienzo Fin Bloques Id Sistema
/dev/sda1 1 2432 19535008+ 83 Linux
/dev/sda2 2433 2675 1951897+ 82 Linux swap / Solaris

2.- Vamos a crear una nueva particion para eso presionamos la letra n que nos pregunta si es una particion primaria o extendida en este caso use particion primaria despues nos pregunta cual es el numero de particion en este caso la tres el tamaño de la particion es de 5G.


Orden (m para obtener ayuda): n
Acción de la orden
e Partición extendida
p Partición primaria (1-4)
p
Número de partición (1-4): 3
Primer cilindro (2676-19457, valor predeterminado 2676):
Se está utilizando el valor predeterminado 2676
Último cilindro o +tamaño o +tamañoM o +tamañoK (2676-19457, valor predeterminado 19457): +5G

4.- Ahora vamos a darle el tipo de particion. Antes de seguir presionamos la letra p para ver como esta el dispositivo.
Observemos que el disco tiene 160G y vemos tambien que el nuevo dispositivo creado es sda3 formateado en ext3.


Orden (m para obtener ayuda): p

Disco /dev/sda: 160.0 GB, 160041885696 bytes
255 heads, 63 sectors/track, 19457 cylinders
Units = cilindros of 16065 * 512 = 8225280 bytes
Disk identifier: 0x4bf771ed

Disposit. Inicio Comienzo Fin Bloques Id Sistema
/dev/sda1 1 2432 19535008+ 83 Linux
/dev/sda2 2433 2675 1951897+ 82 Linux swap / Solaris
/dev/sda3 2676 3284 4891792+ 83 Linux

5.- Vamos a cambiar el tipo de particion antes ext3 ahora lvm (e8).

Orden (m para obtener ayuda): t
Número de partición (1-4): 3
Código hexadecimal (escriba L para ver los códigos): L

0 Vacía 1e Hidden W95 FAT1 80 Old Minix be arranque de Sol
1 FAT12 24 NEC DOS 81 Minix / old Lin bf Solaris
2 XENIX root 39 Plan 9 82 Linux swap / So c1 DRDOS/sec (FAT-
3 XENIX usr 3c PartitionMagic 83 Linux c4 DRDOS/sec (FAT-
4 FAT16 <32M 40 Venix 80286 84 Unidad C: ocult c6 DRDOS/sec (FAT-
5 Extendida 41 PPC PReP Boot 85 Linux extendida c7 Syrinx
6 FAT16 42 SFS 86 Conjunto de vol da Datos sin SF
7 HPFS/NTFS 4d QNX4.x 87 Conjunto de vol db CP/M / CTOS / .
8 AIX 4e QNX4.x segunda 88 Linux plaintext de Utilidad Dell
9 AIX bootable 4f QNX4.x tercera 8e Linux LVM df BootIt
a OS/2 Boot Manag 50 OnTrack DM 93 Amoeba e1 DOS access
b W95 FAT32 51 OnTrack DM6 Aux 94 Amoeba BBT e3 DOS R/O
c W95 FAT32 (LBA) 52 CP/M 9f BSD/OS e4 SpeedStor
e W95 FAT16 (LBA) 53 OnTrack DM6 Aux a0 Hibernación de eb BeOS fs
f W95 Ext'd (LBA) 54 OnTrackDM6 a5 FreeBSD ee EFI GPT
10 OPUS 55 EZ-Drive a6 OpenBSD ef EFI (FAT-12/16/
11 FAT12 oculta 56 Golden Bow a7 NeXTSTEP f0 inicio Linux/PA
12 Compaq diagnost 5c Priam Edisk a8 UFS de Darwin f1 SpeedStor
14 FAT16 oculta <3 61 SpeedStor a9 NetBSD f4 SpeedStor
16 FAT16 oculta 63 GNU HURD o SysV ab arranque de Dar f2 DOS secondary
17 HPFS/NTFS ocult 64 Novell Netware b7 BSDI fs fd Linux raid auto
18 SmartSleep de A 65 Novell Netware b8 BSDI swap fe LANstep
1b Hidden W95 FAT3 70 DiskSecure Mult bb Boot Wizard hid ff BBT
1c Hidden W95 FAT3 75 PC/IX
Código hexadecimal (escriba L para ver los códigos): 8e
Se ha cambiado el tipo de sistema de la partición 3 por 8e (Linux LVM)

Orden (m para obtener ayuda): p

Disco /dev/sda: 160.0 GB, 160041885696 bytes
255 heads, 63 sectors/track, 19457 cylinders
Units = cilindros of 16065 * 512 = 8225280 bytes
Disk identifier: 0x4bf771ed

Disposit. Inicio Comienzo Fin Bloques Id Sistema
/dev/sda1 1 2432 19535008+ 83 Linux
/dev/sda2 2433 2675 1951897+ 82 Linux swap / Solaris
/dev/sda3 2676 3284 4891792+ 8e Linux LVM

Orden (m para obtener ayuda):

6.- Ya tenemos una particion lvm para usar.

Instalacion de maquinas virtuales con XEN (debian lenny) Parte 2

sigue de la parte 1

Tambien podemos obtener informacion del bridge con el comando ifconfig:

Vamos a notar que se crea una nueva interface pth0 que hara de bridge.

xendom0:~# ifconfig
eth0 Link encap:Ethernet HWaddr 00:19:66:f0:71:db
inet addr:192.168.1.100 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::219:66ff:fef0:71db/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:747 errors:0 dropped:0 overruns:0 frame:0
TX packets:497 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:89852 (87.7 KiB) TX bytes:87676 (85.6 KiB)


lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:50 errors:0 dropped:0 overruns:0 frame:0
TX packets:50 errors:0 dropped:0 overruns:0 carrier:0
collisions:


peth0 Link encap:Ethernet HWaddr 00:19:66:f0:71:db
inet6 addr: fe80::219:66ff:fef0:71db/64 Scope:Link
UP BROADCAST RUNNING PROMISC MULTICAST MTU:1500 Metric:1
RX packets:29439 errors:0 dropped:0 overruns:0 frame:0
TX packets:20716 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:40756396 (38.8 MiB) TX bytes:1785957 (1.7 MiB)
Interrupt:21 Base address:0xe000

Tambien podemos listar los dispositivos de loop que se crearon durante el arranque para esto simplemente
vamos a usar el comando


xendom0:/etc/xen# ls /dev/loo*
/dev/loop0 /dev/loop16 /dev/loop23 /dev/loop30 /dev/loop38 /dev/loop45 /dev/loop52 /dev/loop6
/dev/loop1 /dev/loop17 /dev/loop24 /dev/loop31 /dev/loop39 /dev/loop46 /dev/loop53 /dev/loop60
/dev/loop10 /dev/loop18 /dev/loop25 /dev/loop32 /dev/loop4 /dev/loop47 /dev/loop54 /dev/loop61
/dev/loop11 /dev/loop19 /dev/loop26 /dev/loop33 /dev/loop40 /dev/loop48 /dev/loop55 /dev/loop62
/dev/loop12 /dev/loop2 /dev/loop27 /dev/loop34 /dev/loop41 /dev/loop49 /dev/loop56 /dev/loop63
/dev/loop13 /dev/loop20 /dev/loop28 /dev/loop35 /dev/loop42 /dev/loop5 /dev/loop57 /dev/loop7
/dev/loop14 /dev/loop21 /dev/loop29 /dev/loop36 /dev/loop43 /dev/loop50 /dev/loop58 /dev/loop8
/dev/loop15 /dev/loop22 /dev/loop3 /dev/loop37 /dev/loop44 /dev/loop51 /dev/loop59 /dev/loop9

9.- Crear maquina virtual (domU)

Este es el momento mas importante es el momento de crear la maquina virtual.
En el ejemplo vamos a crear una maquina virtual llamada: alumno1 , esta maquina virtual va a terner
una particion de 4GB para el punto de montaje “/” formateado en ext3, una swap de 256M , la memoria de la
maquina virtual va a ser de 92MB, el sistema operativo a instalar va a ser lenny , el directorio
donde van a estar las imagenes va a ser el /home/xen.
Tenemos que tener en cuenta que: Para cada maquina virtual creada se va a crear un subdirectorio en este casos llamando alumno1
dentro de este directorio vamos a tener dos archivos: disk1.img y swap.img. Con los tamaños que nosotros configuremos.

xendom0:~# xen-create-image --hostname alumno1 --size 4GB --fs ext3 --swap 256Mb --dhcp --force --memory 92Mb --dist=lenny --dir /home/xen

General Information
--------------------
Hostname : alumno1
Distribution : lenny
Partitions : swap 256Mb (swap)
/ 4GB (ext3)
Image type : sparse
Memory size : 92Mb
Kernel path : /boot/vmlinuz-2.6.26-2-xen-amd64
Initrd path : /boot/initrd.img-2.6.26-2-xen-amd64

Networking Information
----------------------
IP Address : DHCP [MAC: 00:16:3E:85:B6:74]


Creating partition image: /home/xen/domains/alumno1/swap.img
Done

Creating swap on /home/xen/domains/alumno1/swap.img
Done

Creating partition image: /home/xen/domains/alumno1/disk.img
Done

Creating ext3 filesystem on /home/xen/domains/alumno1/disk.img
Done
Installation method: debootstrap


Running hooks

Done

No role scripts were specified. Skipping

Creating Xen configuration file
Done
All done
t

Logfile produced at:
/var/log/xen-tools/alumno1.log

10.- Verificacion sencilla.

Para hacer una verificacion rapida de los archivos basta con un ls.

xendom0:~# ls -lh /home/xen/domains/alumno1/
total 905M
-rw-r–r– 1 root root 4,0G jul 7 17:00 disk.img
-rw-r–r– 1 root root 256M jul 7 17:00 swap.img

Podemos ver los dos archivos un de 4G que corresponde a la maquina virtual y el otro de 256M que corresponde a la swap.

Tambien podemos ver el archivo de configuracion que usa xen para levantar la vm.
Este archivo es leido cuando se levanta la vm.


xendom0:~# cat /etc/xen/alumno1.cfg
#
# Configuration file for the Xen instance alumno1, created
# by xen-tools 3.9 on Wed Jul 7 17:09:49 2010.
#
#
# Kernel + memory size
#
kernel = '/boot/vmlinuz-2.6.26-2-xen-amd64'
ramdisk = '/boot/initrd.img-2.6.26-2-xen-amd64'
memory = '92'
#
# Disk device(s).
#
root = '/dev/sda2 ro'
disk = [
'file:/home/xen/domains/alumno1/swap.img,sda1,w',
'file:/home/xen/domains/alumno1/disk.img,sda2,w',
]
#
# Hostname
#
name = 'alumno1'
#
# Networking
#
dhcp = 'dhcp'
vif = [ 'mac=00:16:3E:85:B6:74' ]
#
# Behaviour
#
on_poweroff = 'destroy'
on_reboot = 'restart'
on_crash = 'restart'

11.- Tunning

Ahora vamos a tener que retocar la maquina virtual para que levante desde el dom0

Montaje de la maquina virtual.

xendom0:~# mount -o loop /home/xen/domains/alumno1/disk.img /mnt

Este comando lo que hace es montar la maquina virtual en el directorio /mnt.

Modificacion de la terminal tty por una terminal virtual
Para que podamos trabajar con la maquina virtual tenemos que cambiar el dispositivo tty por un dispositivo de tipo virtual.
Si no ejecutamos este paso no vamos a poder acceder a la terminal de la vm asi como tampoco vamos a poder iniciar correctamente el arranque
del domU.

Una vez montada la particion accedemos al archivo inittab. Y lo modificamos de la siguiente manera.
Editar el archivo /mnt/etc/inittab, comentar la linea de tty1 por hvc0

#1:2345:respawn:/sbin/getty 38400 tty1
1:2345:respawn:/sbin/getty 38400 hvc0

Esto es todo ahora desmontamos.

xendom0:~# umount /mnt

12.- Ahora estamos en condiciones de levantar la vm y seguir con el tunning.

Para levantar la vm desde el dom0 usamos el comando:

xendom0:~# xm create /etc/xen/alumno1.cfg
Using config file "/etc/xen/alumno1.cfg".
Started domain alumno1

Vamos a ver cuales son las maquinas virtuales que estan levantadas hasta este momento.


xendom0:~# xm list
Name ID Mem VCPUs State Time(s)
Domain-0 0 773 1 r----- 130.6
alumno1 1 92 1 -b---- 1.5

13.- Conectandonos desde el dom0 (hypervisor) al domU (vm).

En este ejemplo vemos como conectarnos a la maquina virtual. Vamos a acceder con un usuario root sin password!!!!!
De mas esta decir que hay que colocarle un password a root.


xendom0:~# xm console alumno1

Para salir tenemos que presionar

14.- Para poder conectarnos por via ssh.

Tenemos que seguir tuneando la maquina virtual ahora para poder conectarnos por ssh.

Veamos lo que pasa si no lo hacemos.

Me voy a parar en una tercera maquina y voy a hacer ssh a la maquina virtual cuya ip es 192.168.1.101.

usuario@server2:~$ ssh -l root 192.168.1.101
root@192.168.1.101's password:
PTY allocation request failed on channel 0
stdin: is not a tty

Se quedo ahi muerto se frizo no podemos hacer nada.

Por esto es que tenemos que seguir tocando la maquina virtual para que no ocurran estas cosas raras

Primero nos conectamos desde el dom0


xendom0:~# xm console alumno1

Una vez adentro usamos nuestro querido apt-get update.


alumno1:~# apt-get update


alumno1:~# apt-get install udev
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following extra packages will be installed:
libvolume-id0
The following NEW packages will be installed:
libvolume-id0 udev
0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.
Need to get 345kB of archives.
After this operation, 864kB of additional disk space will be used.
Do you want to continue [Y/n]?


0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.
Need to get 345kB of archives.
After this operation, 864kB of additional disk space will be used.
Do you want to continue [Y/n]? Y
Get:1 http://ftp.us.debian.org lenny/main libvolume-id0 0.125-7+lenny3 [78.2kB]
Get:2 http://ftp.us.debian.org lenny/main udev 0.125-7+lenny3 [267kB]
Fetched 345kB in 31s (10.9kB/s)
Preconfiguring packages ...
Can not write log, openpty() failed (/dev/pts not mounted?)
Selecting previously deselected package libvolume-id0.
(Reading database ... 11287 files and directories currently installed.)
Unpacking libvolume-id0 (from .../libvolume-id0_0.125-7+lenny3_amd64.deb) ...
Selecting previously deselected package udev.
Unpacking udev (from .../udev_0.125-7+lenny3_amd64.deb) ...
Processing triggers for man-db ...
Can not write log, openpty() failed (/dev/pts not mounted?)
Setting up libvolume-id0 (0.125-7+lenny3) ...
Setting up udev (0.125-7+lenny3) ...
[ 1069.801276] udevd version 125 started
Populating the new /dev filesystem temporarily mounted on /tmp/udev.2lwMgt/...
[ 1070.118587] udevd version 125 started
rmdir: failed to remove `/tmp/udev.2lwMgt': Directory not empty
WARNING: /tmp/udev.2lwMgt is not empty!
/tmp/udev.2lwMgt:
total 12
drwxr-xr-x 3 root root 4096 Jul 7 22:44 .
drwxrwxrwt 5 root root 4096 Jul 7 22:44 ..
drwxr-xr-x 3 root root 4096 Jul 7 22:44 .udev

/tmp/udev.2lwMgt/.udev:
total 12
drwxr-xr-x 3 root root 4096 Jul 7 22:44 .
drwxr-xr-x 3 root root 4096 Jul 7 22:44 ..
drwxr-xr-x 2 root root 4096 Jul 7 22:44 rules.d

/tmp/udev.2lwMgt/.udev/rules.d:
total 8
drwxr-xr-x 2 root root 4096 Jul 7 22:44 .
drwxr-xr-x 3 root root 4096 Jul 7 22:44 ..
Stopping enhanced syslogd: rsyslogd.
Starting enhanced syslogd: rsyslogd

Despues de esto tenemos que modificar el archivo /etc/fstab agregandole la siguientes linea:


none /dev/pts devpts defaults 0 0
none /dev/shm tmpfs defaults 0 0

Bueno eso es todo ahora podemos disfrutar de la maquina virtual al full.

Despues de esto salimos de la vm y probamos que nos podamos conectar via ssh.

Y despues de esto lo mas importante instalar el paquete udev sin esto es imposible conectarse por ssh.

Instalacion de maquinas virtuales con XEN (debian lenny) Parte 1

Instalando maquinas virtuales debian en un sevidor xen

Aclaracion: El hostname del hypervisor es: xendom0

1.- Instalando los paquetes necesarios.


xendom0:~# apt-get install linux-image-2.6.26-2-xen-amd64

Cuando hayamos instalado estos paquetes vamos a tener una nueva entrada en el archivo /boot/grub/menu.lst

title Debian GNU/Linux, kernel 2.6.26-2-xen-amd64
root (hd0,0)
kernel /boot/vmlinuz-2.6.26-2-xen-amd64 root=/dev/sda1 ro quiet
initrd /boot/initrd.img-2.6.26-2-xen-amd64


title Debian GNU/Linux, kernel 2.6.26-2-xen-amd64 (single-user mode)
root (hd0,0)
kernel /boot/vmlinuz-2.6.26-2-xen-amd64 root=/dev/sda1 ro single
initrd /boot/initrd.img-2.6.26-2-xen-amd64

2.- Instalacion de las herramientas xen.

Esto va a tardar un rato dependiendo del ancho de banda de internet. Quisiera mensionar como interesante que se van a instalar como dependencias las bridge-tools estas herramientas van a permitir que el dom0 (hypervisor), sea bridge de las domU (maquinas virtuales).


xendom0:~# apt-get install xen-tools

3.- Aumentar el numero de loops del equipo
Dado que el número máximo de dispositivos loop que existen en el sistema es por defecto 8 y que cada máquina virtual usa 2, para arrancar más de 4 máquinas virtuales tenemos que incrementar este valor. Para hacer esto vamos a modificar el archivo /etc/modules modificando la linea que dice loop, observar que comente con varios “#” la linea original del archivo.

xendom0:~# cat /etc/modules
# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with "#" are ignored.
# Parameters can be specified after the module name.

### loop max_loop=64

4.- Reiniciar el equipo.

Simplemente

xendom0:~# reboot

4.- Verificamos si el kernel con el que arranco el equipo es el adecuado.


xendom0:~# uname -r
2.6.26-2-xen-amd64

5.- Configurando la red Bridge en XEN

# Configurar la red: para que dom0 funcione en modo puente (paquete bridge-utils) editaremos
/etc/xen/xend-config.sxp, comentaremos la línea:

# (network-script network-dummy)

y verificar que las siguientes líneas esten descomentadas:

(network-script network-bridge)
(vif-script vif-bridge)
(dom0-min-mem 196)
(dom0-cpus 0)

6.- Reiniciar el servicio de xen:

xendom0:~# /etc/init.d/xend stop
xendom0:~# /etc/init.d/xend start

7.- Verificar que el servicio de xen este corriendo.


xendom0:~# xm list
Name ID Mem VCPUs State Time(s)
Domain-0 0 811 1 r----- 15.4

Vamos a verificar ahora el kernel del dom0


xendom0:~# xm dmesg
(XEN) Xen version 3.2-1 (Debian 3.2.1-2) (waldi@debian.org) (gcc version 4.3.1 (Debian 4.3.1-2) ) Sat Jun 28 09:32:18 UTC 2008
(XEN) Command line:
(XEN) Video information:
(XEN) VGA is text mode 80x25, font 8x16
(XEN) VBE/DDC methods: none; EDID transfer time: 0 seconds
(XEN) EDID info not retrieved because no DDC retrieval method detected
(XEN) Disc information:
(XEN) Found 1 MBR signatures
(XEN) Found 1 EDD information structures
(XEN) Xen-e820 RAM map:
(XEN) 0000000000000000 - 000000000009f800 (usable)
(XEN) 000000000009f800 - 00000000000a0000 (reserved)
(XEN) 00000000000e7000 - 0000000000100000 (reserved)
(XEN) 0000000000100000 - 0000000037fb0000 (usable)
(XEN) 0000000037fb0000 - 0000000037fc0000 (ACPI data)
(XEN) 0000000037fc0000 - 0000000037ff0000 (ACPI NVS)
(XEN) 0000000037ff0000 - 0000000038000000 (reserved)
(XEN) 00000000fec00000 - 00000000fec01000 (reserved)
(XEN) 00000000fee00000 - 00000000fef00000 (reserved)
(XEN) 00000000fff80000 - 0000000100000000 (reserved)
(XEN) System RAM: 895MB (916796kB)
(XEN) Xen heap: 14MB (15048kB)
(XEN) Domain heap initialised: DMA width 32 bits
(XEN) Processor #0 0:6 APIC version 16
(XEN) IOAPIC[0]: apic_id 1, version 17, address 0xfec00000, GSI 0-23
(XEN) Enabling APIC mode: Flat. Using 1 I/O APICs
(XEN) Using scheduler: SMP Credit Scheduler (credit)
(XEN) Detected 2712.343 MHz processor.
(XEN) AMD SVM: ASIDs enabled.
(XEN) HVM: SVM enabled
(XEN) HVM: Hardware Assisted Paging detected and enabled.
(XEN) CPU0: AMD Sempron(tm) Processor 140 Processor stepping 02
(XEN) Total of 1 processors activated.
(XEN) ENABLING IO-APIC IRQs
(XEN) -> Using new ACK method
(XEN) ..MP-BIOS bug: 8254 timer not connected to IO-APIC
(XEN) works.
(XEN) Platform timer overflows in 234 jiffies.
(XEN) Platform timer is 3.579MHz ACPI PM Timer
(XEN) Brought up 1 CPUs
(XEN) AMD IOMMU: Disabled
(XEN) *** LOADING DOMAIN 0 ***
(XEN) Xen kernel: 64-bit, lsb, compat32
(XEN) Dom0 kernel: 64-bit, lsb, paddr 0x200000 -> 0x631918
(XEN) PHYSICAL MEMORY ARRANGEMENT:
(XEN) Dom0 alloc.: 0000000032000000->0000000034000000 (199618 pages to be allocated)
(XEN) VIRTUAL MEMORY ARRANGEMENT:
(XEN) Loaded kernel: ffffffff80200000->ffffffff80631918
(XEN) Init. ramdisk: ffffffff80632000->ffffffff81bd2200
(XEN) Phys-Mach map: ffffffff81bd3000->ffffffff81d68e10
(XEN) Start info: ffffffff81d69000->ffffffff81d694a4
(XEN) Page tables: ffffffff81d6a000->ffffffff81d7d000
(XEN) Boot stack: ffffffff81d7d000->ffffffff81d7e000
(XEN) TOTAL: ffffffff80000000->ffffffff82000000
(XEN) ENTRY ADDRESS: ffffffff80200000
(XEN) Dom0 has maximum 1 VCPUs
(XEN) Initrd len 0x15a0200, start at 0xffffffff80632000
(XEN) Scrubbing Free RAM: done.
(XEN) Xen trace buffers: disabled
(XEN) Std. Loglevel: Errors and warnings
(XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings)
(XEN) Xen is relinquishing VGA console.
(XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen)
(XEN) Freed 104kB init memory.
(XEN) ioapic_guest_write: apic=0, pin=2, old_irq=-1, new_irq=0
(XEN) ioapic_guest_write: old_entry=00010000, new_entry=000009f0
(XEN) ioapic_guest_write: Installing bogus unmasked IO-APIC entry!

Tambien podemos seguir obteniendo informacion de xen con el comando:


xendom0:~# xm info
host : xendom0
release : 2.6.26-2-xen-amd64
version : #1 SMP Wed May 12 18:37:58 UTC 2010
machine : x86_64
nr_cpus : 1
nr_nodes : 1
cores_per_socket : 1
threads_per_core : 1
cpu_mhz : 2712
hw_caps : 078bf3ff:efd3fbff:00000000:00000110:00802001:000037fd:000037fd
total_memory : 895
free_memory : 54
node_to_cpu : node0:0
xen_major : 3
xen_minor : 2
xen_extra : -1
xen_caps : xen-3.0-x86_64 xen-3.0-x86_32p hvm-3.0-x86_32 hvm-3.0-x86_32p hvm-3.0-x86_64
xen_scheduler : credit
xen_pagesize : 4096
platform_params : virt_start=0xffff800000000000
xen_changeset : unavailable
cc_compiler : gcc version 4.3.1 (Debian 4.3.1-2)
cc_compile_by : waldi
cc_compile_domain : debian.org
cc_compile_date : Sat Jun 28 09:32:18 UTC 2008
xend_config_format : 4

Ejemplo de LVM

Resumen de creacion de LVM paso a paso

1.- crear los volumenes fisicos:

[root@rh ~]# pvcreate /dev/hda8
Physical volume "/dev/hda8" successfully created
[root@rh ~]# pvcreate /dev/hda9
Physical volume "/dev/hda9" successfully created
[root@rh ~]# pvcreate /dev/hda10
Physical volume "/dev/hda10" successfully created

2.- Juntar los volumenes fisicos en un Grupo de Volumenes

Todos forman una misma unidad.

[root@rh ~]# vgcreate VG0 /dev/hda8 /dev/hda9 /dev/hda10
Volume group "VG0" successfully created

3.- Vamos a verificar cual es el tamaño del VG podemos observar que es de 1.49G
Tambien vemos que esta compuesto por tres volumenes fisicos /dev/hda8, /dev/hda9 y /dev/hda10

[root@rh ~]# vgdisplay -v VG0
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 1
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 0
Open LV 0
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 0 / 0
Free PE / Size 381 / 1,49 GB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2
--- Physical volumes ---
PV Name /dev/hda8
PV UUID H8j2q7-1vIl-NsYO-FS6f-QiII-eM4a-I2lFY0
PV Status allocatable
Total PE / Free PE 127 / 63

PV Name /dev/hda9
PV UUID QIH2Ac-2Kk0-rf9Q-TZkZ-aLEp-TTV0-jS8m7n
PV Status allocatable
Total PE / Free PE 127 / 127

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127

4.- Vamos a tomar una porcion de 256M y le vamos a llamar datos.

[root@rh ~]# lvcreate -L 256M VG0 -n datos
Logical volume "datos" created

5.- vamos a ver como se creo este volumen lògico.

[root@rh ~]# vgdisplay VG0 -v
Using volume group(s) on command line
Finding volume group "VG0"
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 6
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 1
Open LV 0
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 64 / 256,00 MB
Free PE / Size 317 / 1,24 GB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2

--- Logical volume ---
LV Name /dev/VG0/datos
VG Name VG0
LV UUID 0wvyAZ-42J0-Q8TY-oye0-h6uv-2Zap-DG1SNU
LV Write Access read/write
LV Status available
# open 0
LV Size 256,00 MB
Current LE 64
Segments 1
Allocation inherit
Read ahead sectors auto
- currently set to 256
Block device 253:0

--- Physical volumes ---
PV Name /dev/hda8
PV UUID H8j2q7-1vIl-NsYO-FS6f-QiII-eM4a-I2lFY0
PV Status allocatable
Total PE / Free PE 127 / 63

PV Name /dev/hda9
PV UUID QIH2Ac-2Kk0-rf9Q-TZkZ-aLEp-TTV0-jS8m7n
PV Status allocatable
Total PE / Free PE 127 / 127

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127

6.- Vamos a formatear ese volumen de datos

[root@rh ~]# mkfs.ext3 /dev/VG0/datos
mke2fs 1.39 (29-May-2006)
Etiqueta del sistema de ficheros=
Tipo de SO: Linux
Tamaño del bloque=1024 (bitácora=0)
Tamaño del fragmento=1024 (bitácora=0)
65536 nodos i, 262144 bloques
13107 bloques (5.00%) reservados para el súper usuario
Primer bloque de datos=1
Maximum filesystem blocks=67371008
32 bloque de grupos
8192 bloques por grupo, 8192 fragmentos por grupo
2048 nodos i por grupo
Respaldo del súper bloque guardado en los bloques:
8193, 24577, 40961, 57345, 73729, 204801, 221185
Mientras se escribían las tablas de nodos i: terminado
Creando el fichero de transacciones (8192 bloques): hecho
Escribiendo superbloques y la información contable del sistema de ficheros:
hecho
Este sistema de ficheros se revisará automáticamente cada 39 meses o
180 dias, lo que suceda primero. Utilice tune2fs -c o -i para cambiarlo.

7.- Crear el punto de montaje.

mkdir /mnt/datos

8.- Montar el Volumen Logico.

mount -t ext3 /dev/VG0/datos /mnt/datos

9.- Crear la entrada en /etc/fstab

En debian vamos a usar esta sintaxis:

/dev/VG0/datos /mnt/datos ext3 defaults 0 0

En rh vamos a usar el Label de la particion en vez del dispositivo.

LABEL=DATOS /mnt/datos ext3 defaults 0 0

11.- Supongamos ahora que queremos extender el volumen logico en 512M.


[root@rh ~]# lvextend -L +500M /dev/VG0/datos
Extending logical volume datos to 756,00 MB
Logical volume datos successfully resized

12.- Todavia no terminamos tenemos que ejecutar el comando que cambia el
tamaño del LV.

[root@rh ~]# resize2fs -p /dev/VG0/datos
resize2fs 1.39 (29-May-2006)
Filesystem at /dev/VG0/datos is mounted on /mnt/datos; on-line resizing
required
Performing an on-line resize of /dev/VG0/datos to 774144 (1k) blocks.
The filesystem on /dev/VG0/datos is now 774144 blocks long.

13.- Verificamos los cambios.

[root@rh ~]# vgdisplay VG0 -v
Using volume group(s) on command line
Finding volume group "VG0"
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 7
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 1
Open LV 1
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 189 / 756,00 MB
Free PE / Size 192 / 768,00 MB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2

--- Logical volume ---
LV Name /dev/VG0/datos
VG Name VG0
LV UUID 0wvyAZ-42J0-Q8TY-oye0-h6uv-2Zap-DG1SNU
LV Write Access read/write
LV Status available
# open 1
LV Size 756,00 MB
Current LE 189
Segments 2
Allocation inherit
Read ahead sectors auto
- currently set to 256
Block device 253:0

--- Physical volumes ---
PV Name /dev/hda8
PV UUID H8j2q7-1vIl-NsYO-FS6f-QiII-eM4a-I2lFY0
PV Status allocatable
Total PE / Free PE 127 / 0

PV Name /dev/hda9
PV UUID QIH2Ac-2Kk0-rf9Q-TZkZ-aLEp-TTV0-jS8m7n
PV Status allocatable
Total PE / Free PE 127 / 65

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127

14.- Reducir el tamaño de una particion en este ejemplo la reducciòn va a ser
de 56M.

Antes que nada desmontar

[root@rh ~]# umount /mnt/datos


[root@rh ~]# resize2fs /dev/VG0/datos 700M
resize2fs 1.39 (29-May-2006)
Por favor corra primero 'e2fsck -f /dev/VG0/datos'.


[root@rh ~]# e2fsck -f /dev/VG0/datos
e2fsck 1.39 (29-May-2006)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
DATOS: 11/194560 files (9.1% non-contiguous), 35331/774144 blocks

Ahora si podemos reducir


[root@rh ~]# resize2fs /dev/VG0/datos 700M
resize2fs 1.39 (29-May-2006)
Resizing the filesystem on /dev/VG0/datos to 716800 (1k) blocks.
The filesystem on /dev/VG0/datos is now 716800 blocks long.

Tambien podemos usar el comando:

[root@rh ~]# lvreduce -L 56M /dev/VG0/datos
WARNING: Reducing active logical volume to 56,00 MB
THIS MAY DESTROY YOUR DATA (filesystem etc.)
Do you really want to reduce datos? [y/n]: y
Reducing logical volume datos to 56,00 MB
Logical volume datos successfully resized

15.- Tambien podemos ahora quitar un volumen fisico del grupo de volumenes.


[root@rh ~]# pvmove /dev/hda10
No data to move for VG0
[root@rh ~]# vgreduce VG0 /dev/hda10
Removed "/dev/hda10" from volume group "VG0"

Esto es todo.

Instalación de OOo (openoffice.org) en debian Lenny

Como instalar OOo en debian Lenny

Aclaración: tenemos que instalar OOo en modo gráfico.

1. Descargar el paquete de openoffice teniendo en cuenta que es una paquete (archivo tar.gz) dentro de este se encuentran los archivos .deb para instalar todo el OOo
Vamos a trabajar en el modo gráfico para poder instalar OOo

2. Tenemos que loguearnos como root en una terminal de texto gráfica.
Teniendo en cuenta que debian no nos deja loguearnos con el usuario root en el modo gráfico tenemos que ejecutar los siguientes comandos.

Con el usuario de trabajo levantamos una terminal de texto. En esta terminal de texto ejecutar el comando

$ xhost + (este comando permite que desde cualquier otro equipo o usuario se pueda usar el entorno gráfico)

El siguiente comando nos permite transformarnos en root sin las variables de entorno.

$ su

Tipear la clave de root. Muy bien ahora podemos seguir con la instalacion de OpenOffice.org

3. Si tenemos instalada la versión 2.4 la desinstalamos usando el siguiente comando:

apt-get –purge remove -y openoffice.org openoffice.org-base openoffice.org-base-core openoffice.org-common openoffice.org-core lp-solve openoffice.org-impress openoffice.org-filter-mobiledev openoffice.org-draw libgfortran3 openoffice.org-report-builder-bin libsuitesparse-3.1.0 ttf-liberation openoffice.org-math libblas3gf openoffice.org-officebean liblapack3gf openoffice.org-calc

4. Descomprimir el archivo descargado en el directorio /opt (ahi es donde va a quedar instalado OOo)

cd /opt
tar xzvf OOo.....tar.gz

5. Ahora vamos a instalar OOo con el siguiente comando:


cd OOO300_m9_native_packed-1_es.9358/DEBS/ && dpkg -i *.deb

6. Ahora vamos a instalar la integracion con el escritorio para esto ejecutamos:


cd desktop-integration

5. Instalamos el paquete que hay en ese directorio con el siguiente comando:

dpkg -i openoffice.org3.0-debian-menus_3.0-9354_all.deb

Todo esta ahora instalado

Saludos

Actualizaciones y descargas usando apt-proxy

Como instalar las actualizaciones y nuevos programas sin recargar la red.

En distintos ambientes oportunidades tenemos muchos equipos con el sistema GNU/debian instalados ya sea en casa o en nuestro trabajo y sabemos que debian tiene actualizaciónes constantes, si conectamos todas las maquinas a la vez para actualizar o descargar un software vamos a notar que el ancho de banda de nuestra red decae de manara alarmante. Es por eso es que quiero presentarles a apt-proxy.

apt-proxy es un proxy de paquetes, más sencillo imposible. Con él, cada vez que nos descargamos un paquete, se queda almacenado en su repositorio local, así cuando una máquina pide ese paquete, se lo entregará directamente sin necesidad de descargarlo desde el repositorio original (repositorio debian en internet).

Instalación:

# apt-get install apt-proxy

Una vez que está instalado, tenemos que modificar ver el archivo de configuración, ubicado en /etc/apt-proxy con el nombre apt-proxy-v2.conf. Este se divide en secciones, la sección [DEFAULT] proporciona la configuración de apt-proxy (puerto de escucha, timeouts, tiempo máximo de vida de un paquete,…) Aquí poco nada habrá que tocar, como verémos está todo muy bien comentado y sobra explicar esta sección.

Las secciones que vienen a continuación son las más interesantes. Definen los repositorios. Por ejemplo, vemos que hay una sección que se llama [debian].


[debian]
;; The main Debian archive
;; You can override the default timeout like this:
;timeout = 30
;; Rsync server used to rsync the Packages file (NOT YET IMPLEMENTED)
;;rsyncpackages = rsync://ftp.de.debian.org/debian
;; Backend servers, in order of preference
backends =

http://ftp.us.debian.org/debian

http://ftp.de.debian.org/debian

http://ftp2.de.debian.org/debian

ftp://ftp.uk.debian.org/debian

En esta sección tenemos que poner los repositorios donde apt-proxy buscará los paquetes que las demás máquinas (clientes) le piden al servidor bajo el directorio debian. Para entenderlo mejor un ejemplo de sources.list:

deb http://192.168.1.1:9999/debian stable main non-free contrib

Como vemos, esta ip pertenece a mi servidor de apt-proxy y la raíz que pido es la de debian. Entonces apt-proxy buscará una sección que se llame así y mirará qué repositorios puede usar para descargar esos paquetes. Ahora solo nos queda ir máquina por máquina cambiando las sources.list y poniendo nuestro servidor de apt-proxy como fuente única. También es una muy buena idea que nuestro propio servidor tuviera en sus sources.list la dirección del proxy, así cualquier actualización de cualquier máquina pasará por el proxy.

Otra aplicación que se puede usar y que es muy útil se llama apt-move.

Sirve para generar repositorios locales moviendo y generando la estructura de un repositorio.
Lo bueno de esta es que podemos crear un repositorio local en equipos que no tienen internet.

Podemos encontrar un articulo en:
apt-move

Espero que sea de utilidad.

Listas de Control de acceso

Cuando por razones organizativas tenemos que trabajar solo con los permisos que nos ofrece linux y necesitamos generar recursos accesibles a distintos grupos nuestro trabajo comienza a complicarse, de tal manera que empezamos a tener muchos grupos y muchos directorios y un lio barbaro para administrar.

La solucion que linux nos ofece es ACL, listas de control de acceso. Veamos de que se trata.

¿Qué es una ACL?

Es una ACL es una lista de usuarios o grupos Linux que tienen derecho a usar un directorio o un archivo.

1.- Instalando y activando las ACL:

Para garantizar que el sistema acepte acls tenemos que tener en cuenta las siguientes premisas:

  1. El nucleo debe soportar y estar compilado para soportar atributos extendidos y ACL.
  2. Debemos montar el file system (partición) con atributos extendidos y ACL.
  3. Tenemos que instalar las utilidades de espacio de usuario (chacl,getfacl y setfacl) para establecer ACL.

2.- Activación de las ACL.

Soporte ACL del núcleo de sistema:

La gran mayoría de distros actuales ya soportan ACL podemos comprobarlo ejecutando el siguiente comando.

# grep POSIX_ACL /boot/config-`uname -r`
CONFIG_EXT2_FS_POSIX_ACL=y
CONFIG_EXT3_FS_POSIX_ACL=y
CONFIG_REISERFS_FS_POSIX_ACL=y
CONFIG_JFS_POSIX_ACL=y
CONFIG_FS_POSIX_ACL=y
CONFIG_XFS_POSIX_ACL=y
# CONFIG_TMPFS_POSIX_ACL is not set

Como vemos tenemos el soporte de ACLs activado en el kernel. De lo contrario tenemos que recompilarlo teniendo el cuenta marcando estas opciones.
Las ACL pueden aplicarse sobre sistemas de archivos ReiserFS, XFS, Ext3 y otros.

3.- Soporte ACL en /etc/fstab:

Una vez que tenemos soporte ACL necesitamos configurar el archivio /etc/fstab. Los sistemas de archivos montados con acl tienen la palabra clave “acl” en las opciones de montaje de sus entradas en el archivo.

/dev/hda1 /opt ext3 defaults 0 0

Como vemos el dispositivo /dev/hda1 no tiene soporte acl en el punto de montaje , si queremos activarlo cambiamos el archivo como sigue:

/dev/hda1 /opt ext3 defaults,acl 0 0

Una vez que hemos actualizado el archivo /etc/fstab tenemos que remontar el file system .

Ejemplo para hda1:

# mount -o remount /dev/hda1

4.- Soporte ACL en el espacio de usuario:

El último paso para usar ACL es asegurarse de que las aplicaciones de espacio de usuario estén presentes en el sistema. En Debian podemos comprobarlo de esta manera:


# dpkg -l |grep acl
ii acl 2.2.42-1ubuntu1
Access control list utilities
ii libacl1 2.2.42-1ubuntu1

También podemos comprobarlo buscando las herramientas:

# type -a getfacl
getfacl is /usr/bin/getfacl

Si el control de ACLs no esta instalado podemos instalarlo con el comando apt ejecutando:

# apt-get install acl

5.- Formato ACL:

Linux soporta 2 tipos básicos de ACL:

  • ACL de control de directorios y archivos.
  • ACL de directorio (máscaras) ACL que toman por defecto los archivos creados en ese directorio.

La ACL se representa por tres campos separados por “:”.

Campo 1:
Entrada

  • “u” Usuario
  • “g” Grupo
  • “o” Otro
  • “m” Máscara

Campo 2:

  • UID (ID numérico de usuario)
  • GID (ID numérico de grupo)
  • Vacío (Asume UID,GID del Creador)

Campo 3:

El tercer campo es el de acceso y puede ser representado de 2 maneras.

  • Cadena estandar RWX (las cadenas se pueden remplazar por “-” si no queremos dar acceso de ese tipo)
  • Cadena simbólica + ^

6.- Herramientas:

  • chacl: Permite cambiar, examinar o eliminar ACL.
  • getfacl: Permite examinar acl para encontrar archivos o directorios.
  • setfacl: Establece ACL a fichero o directorio.

7.- Mostrar ACL:

Para el ejemplo usaremos un directorio con archivos que hemos creado usando el comando touch.

$ ls -l
total 0
-rw-r--r-- 1 prueba prueba 0 2008-01-26 03:03 archivo.txt
-rw-r--r-- 1 root root 0 2008-01-26 03:03 pass
-rw-r--r-- 1 root root 0 2008-01-26 03:02 user

La acl para el directorio siguiente es:

$ getfacl .
# file: .
# owner: root
# group: root
user::rwx
group::rwx
other::rwx

La acl por defecto para el archivo archivo.txt es esta:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rw-
group::r--
other::r--

La acl para el directorio el cual no se le ha asignado toma los valores de umask.

8.- Establecer ACL:

Tenemos varias maneras de establecer un ACL:

  1. Usando el comando setfacl el cual sobrescribe cualquier ACL anterior.
  2. Usando el comando setfacl con la opción -m (Modifica ACL).
  3. Usando chacl para modificar una ACL existente.

Veamos entonces como podemos las acl con chacl, este comando sobrescribe la existente, y además proporciona algo más de información acerca del funcionamiento de las listas de acceso.

Ejemplo:

Añadiremos al usuario fab como alguien que puede leer el archivo archivo.txt, y usaremos chacl (cambiar la ACL) ejecutando:

$ chacl u::rw-,g::r--,o::---,u:fab:r--,m::rw- archivo.txt

Esta es la forma en la que colocamos una acl en la vida real, el hecho de que este sea un comando demasiado largo es que se debemos definir en los puntos ya nombrados anteriormente el propietario de archivo, grupo propietario y otros.

Para que podamos entender mejor, la porción u::rw,g::r–,o::— es la ACL existente y la porción u:fab:r–,m::rw- especifica el nuevo usuario que quiero añadir a dicha acl y la máscara de permisos cuando sea añadida dicha acl.

La máscara de permisos nos muestra la unión de todos los permisos ya existentes de User,Group,Others para un archivo o directorio.

Podemos hacer la siguiente comprobación:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rwx group::r-- other::--- user:fab:r-- mask::rw-

Ahora que ya sabemos como funciona acl podriamos poner que fab tenga permisos de lectura y escritura a archivo.txt:

$ chacl u::rw-,g::r--,o::---,u:fab:rr-,m::rw- archivo.txt

Como vemos en el ejemplo hemos agregado permisos de escritura:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rwx group::r-- other::---user:fab:rw-

A trabajar.

Ejemplos del comando cpio

1.- Para copiar archivos en un diskette:


$cpio -ov < archivos.txt > /dev/fd0

Esto copia los archivos que estan en el archivo llamado archivos.txt en un dkt.
El parámetro v hace que el comando muestre el nombre de cada archivo copiado. Este comando es muy util para hacer backups copiado los archivos. El diskette debe estar formateado pero no debe estar montado.

2.- Para copiar archivos del directorio actual a un diskette ejecutar:


$ls *.c cpio -ov > /dev/fd0

Este comando copia los archivos que terminan en .c al dispositivo /dev/fd0.

3.- Para copiar los directorios y subdirectorios a un diskette


find . -print cpio -ov > /dev/rfd0

Este comando guarda el arbol de directorios incluidos en “.” directorio actual incluyendo los archivos en el dispositivo /dev/fd0.

Para hacer esto mas rápido ejecutar:

find . -cpio /dev/fd0 -print

El parámetro print muestra el nombre de cada uno de los archivos copiados.

4.- Para listar los archivos que han sido copiados al diskette con el comando cpio ejecutar:

cpio -itv

Este comando muestra el contenido de los datos guardados previamente en el dispositivo /dev/fd0 usando el comando cpio. El listado es parecido al que se muestra al ejecutar el comando ls -l en un directorio.

5.- Para restaurar los archivos previamente guardados con cpio en un diskette, ejecutar:


cpio -idmv < /dev/fd0

Este comando restaura los archivos previamente guardados en /dev/fd0 por medio del comando cpio en el directorio actual (parámetro -i). El parámetro d activa al comando cpio para que cree los directorios que estan en el dispositivo. El parámetro m mantiene fecha de actualización. El parámetro v nos muestra los archivos que se estan restaurando.

6.- Para restaurar algunos archivos seleccionados, ejecutar:


$cpio -i "*.c" "*.o" < /dev/fd0

Este parámetro restaura los archivos que terminan en ".c" ó ".o" desde el dispositivo la doble comilla hace que el asterisco solo sea visible dentro de las mismas de lo contrario se aplicaría a todo.

Metodos de compresión y descompresión

Comandos utilizados para la compresión y descompresión de archivos

Comando tar

El comando tar es utilizado normalmente para empaquetar archivos. El comando tar no comprime
automáticamente los archivos mientras los empaqueta. El formato del comando tar es:

tar ...

donde es la lista de comandos y opciones para tar, y hasta es
la lista de archivos a añadir o extraer del archivo empaquetado. Por ejemplo, el comando

# tar cvf backup.tar /etc

empaquetará todos los archivos de /etc en el archivo backup.tar.

En el primer argumento de tar (“cvf”), la opción “c” le dice a tar que cree un nuevo archivo
(create). La opción “v” fuerza a tar en el modo verbose, imprimiendo los nombres de los archivos
según se empaquetan. La opción “f” le dice a tar que el siguiente argumento (backup.tar) es el
nombre del archivo a crear. El resto de los argumentos de tar son los nombres de archivos y
directorios a añadir al archivo empaquetado.

Descomprimir archivos con tar

# tar xvf backup.tar

Esto, extraerá el archivo backup.tar en el directorio actual. Esto puede ser peligroso, porque si el
archivo ya existía se sobrescribirá. Por otra parte, antes de extraer archivos tar es importante
conocer donde se deben desempaquetar.

Por ejemplo, digamos que se empaquetaron los siguientes archivos: /etc/hosts, /etc/group, y
/etc/passwd. Si se usó:


# tar cvf backup.tar /etc/hosts /etc/group /etc/passwd

el nombre de directorio /etc se añadió al principio de cada nombre de archivo. Para poder extraer
los archivos en el directorio correcto, se necesitará utilizar los siguientes comandos:

# cd /
# tar xvf backup.tar

Ya que los archivos se extraen con el nombre de camino almacenado. Sin embargo, si se
empaquetaron los archivos con los comandos:

# cd /etc
# tar cvf hosts group passwd

Los nombres de directorio no se salvaron en el archivo empaquetado. Por esto se necesitara hacer
“cd /etc” antes de extraer los archivos. Como se puede ver, el cómo haya sido creado un archivo
tar marca una gran diferencia en como se extrae. Se puede usar el comando:

# tar tvf backup.tar

para mostrar un “índice” del archivo tar antes de desempaquetarlo. De esta forma se puede ver que
directorio se utilizó como origen de los nombres de los archivos, y se puede extraer el archivo
desde la localización correcta.
Además agregando el switch ’z’ utiliza el gzip y el gunzip para comprimir / descomprimir.

Comando gzip

El comando gzip se utiliza para comprimir un archivo. El formato del comando gzip es:
gzip archivo

(archivo se convierte en archivo.gz comprimido)

gzip −c archivo > archivo.gz

(Se crea archivo.gz, archivo no se modifica)

Por ejemplo:

# gzip −9 backup.tar

Comprimirá backup.tar y lo dejará como backup.tar.gz, que es la versión comprimida del archivo
tar. La opción −9 le dice a gzip que utilice el mayor factor de compresión.

Descomprimir archivos con gunzip o con gzip

El comando gunzip se utiliza para descomprimir un archivo comprimido con gzip.

Equivalentemente, se puede utilizar “gzip −d”.

El formato del comando gunzip es:


gunzip archivo.gz (descomprime archivo.gz)
gunzip −c archivo.gz > nuevo (descomprime archivo.gz y se redirecciona la salida al archivo nuevo).

Comprimir y empaquetar

Por lo tanto, para empaquetar un grupo de archivos y comprimir el resultado, se pueden utilizar los

comandos:

# tar cvf backup.tar /etc
# gzip −9 backup.tar

El resultado será backup.tar.gz.

Para desempaquetar este archivo, se usan los comandos contrarios:

# gunzip backup.tar.gz
# tar xvf backup.tar

Comando zcat

Es similar al cat, pero pasando el archivo a través del gunzip. Con zcat podemos, ver el contenido
de una archivo comprimido sin descomprimirlo, similar al cat. El formato del comando zcat es:

# zcat

Comandos zip y unzip

Este comando es una utilidad para empaquetar y comprimir archivos. Para una descripción de los
parámetros de zip o unzip se puede ejecutarlos sin parámetros en el shell.

El formato del comando zip es:

# zip

Si se quieren comprimir todos los archivos de un directorio se debe usar * en
.

Para descomprimirlos se debe usar el comando unzip. El formato del comando unzip es:

# unzip

Algunas opciones útiles de estos comandos:

−r: comprime todos los subdirectorios y archivos bajo el directorio donde estamos, o
donde le indicamos.
−i: Incluye solo los archivos que especificamos, por ejemplo:
# zip todo * −i \*.txt (solo comprimiría los archivos que finalicen con .txt).
−f: Si ya hemos creado un .zip de nuestros archivos, pero periódicamente modificamos
estos, con este argumento no hace falta crear el .zip de nuevo, este agrega los cambios de
nuestros archivos en el zip, basándose en la fecha de creación de estos. Esta
opción no funciona como −u, no agrega archivos nuevos a nuestro zip, solo actualiza los
que ya están.
−q: Trabaja en modo silencioso, es decir, elimina todos los mensajes informativos.
−u: Actualiza los archivos que hemos modificado, y también agrega archivos a nuestro
.zip.
# zip −u
−x: Esta opción sirve para excluir uno o varios archivos en nuestro .zip.
Taller de GNU/Linux 2002− TP9 − hoja 4/6
# zip * −x \*.Z (se excluyen los archivos Z de nuestro .zip)
−y : Esta opción sirve para guardar los links en el zip como links en vez de guardar el
archivo al que apunta el link.

Comandos bzip2/bunzip2/bzcap/bzip2recover

El comando bzip2 comprime archivos usando el algoritmo Burrows−Wheeler block−sorting text
compression y Huffman coding. La línea de comandos es similar al GNU gzip pero no es idéntica.
Tiene un poco mas de capacidad de compresión que otros compresores mas convencionales
basados en LZ77/LZ78. Este genera archivos de la forma archivo_original.bz2.
El comando bunzip2 se utiliza para descomprimir los archivos generados con bzip2.

Con bzcat se puede consultar el contenido de un archivo de texto comprimido con bzip2.
El comando bzip2 comprime los archivos en bloques de 900kbytes aproximadamente y cada
bloque se maneja de manera independiente lo que posibilita que si un bloque está corrupto se
puedan recuperar los datos de los bloques que están correctos. El programa bzip2recover se utiliza
para buscar bloques correctos dentro de un archivo bzip2 dañado, el único argumento que
necesita este es el nombre del archivo dañado, generando un salida similar a "rec0001fichero.bz2",
"rec0002fichero.bz2", etc. bzip2recover es de mas provecho cuanto mas bloques tiene el archivo
bz2. Es inútil utilizarlo con archivos de un solo bloque pues este no repara bloques sino que extrae
los bloques correctos. Si se desea minimizar la perdida de información por un error del medio
físico o de la transmisión se debería achicar el tamaño de los bloques en el momento de la
compresión.

Comando cpio

Si bien cpio no sirve para comprimir, nos ayudará a empaquetar todos nuestros archivos en uno
solo para después comprimirlo con alguna utilidad. Con cpio se puede empaquetar archivos y
mandarlos al estándar output, a un archivo, o a un dispositivo.

El comando cpio tiene tres modos de operación.

El modo copia−afuera, cpio copia varios archivos de entrada hacia otro único de salida. Este modo
funciona leyendo una lista de archivos, uno por línea de la entrada estándar, escribiendo el archivo
en la salida estándar, este modo se representa utilizando el argumento −o.

El modo copia−adentro cpio copia archivos desde un archivo de entrada. Lee el archivo desde la
entrada estándar, este modo se representa utilizando el argumento −i.

El modo copia−de−paso cpio copia archivos desde un árbol de directorio a otro, sin utilizar utilizar
ningún archivo, este modo se representa utilizando el argumento −p.

Nota: El comando ls genera la lista que es mandada a través de un pipe para que cpio la reciba, y
empaquete los archivos.

Cuando queremos sacar los archivos ejecutamos el siguiente comando:

# cpio −iv < archivo.cpio

Si ya hubiese archivos con el mismo nombre y quisiéramos sobreescribirlos utilizaríamos el
argumento u.

# cpio −iuv < archivo.cpio

Para ver solamente el contenido del archivo cpio el comando será:

# cpio −tv < archivo.cpio

Comando unrar

El comando unrar permite descomprimir archivos comprimidos con la aplicación rar. El
mecanismo de compresión del rar es propietario, razón por la cual no existen compresores tipo rar
de libre uso.

El texto anterior es una adaptacion de:

http://lucas.hispalinux.es/Manuales−LuCAS/LIPP/lipp−1.1−html−2/lipp.htm

Ejercicios

1)Buscar algún archivo de texto comprimido con gzip (*.gz);
Ayuda: para buscar archivos, utilizar el comando "locate" Archivo elegido o find:
2) Utilizar cat para ver el contenido. (Si la terminal queda mal configurada, comando “reset”)
3)Utilizar zcat para ver el contenido. Si es muy largo el texto pasarlo a través de less o more.
4)descomprimir el archivo ( en /tmp)
5)Verificar que esté sin compresión y comprimirlo nuevamente en el mismo formato .
6)Hacer un .tar.gz de todos los archivos en /bin. Utilizar los comandos tar y gzip unidos con un
pipe.
7)descomprimirlos en /tmp
8) Obtener una salida equivalente a la que se obtendría realizando:
# tar cvf backup.tar /etc
# gzip backup.tar
pero en una sóla línea y utilizando sólo el comando tar.
9) comprimir todos los archivos de /etc en un archivo llamado backup_etc utilizando el comando
zip. Descomprimirlo en ~/etc usando el comando unzip
10)Generar un archivo cpio que contenga todos los archivos del directorio /sbin.
11) Extraer los archivos desde el archivo cpio creado en el punto anterior en el directorio ~/sbin.
12) Generar un archivo bzip2 que contenga todos los archivos del directorio /sbin.
Generar un archivo zip que contenga todos los archivos del directorio /sbin.
Generar un archivo tar.gz que contenga todos los archivos del directorio /sbin.
Anotar los tamaños de los archivos resultantes
Nota: Si los tamaños difieren demasiado, puede deberse a la inclusión o no de "links" en la
compresión. Para que la comparación sea válida, incluir los archivos apuntados con links dentro de
los archivos comprimidos. (El significado de links o enlaces se verá mas adelante en el curso)
Sbin.cpio Sbin.zip
Sbin.bz2 Sbin.tar.gz