sábado, 22 de junio de 2013

Conectar dos localidades usando asterisk

El protocolo IAX2 nos permite unificar varios servidores asterisk haciendo posible que pueda marcar desde un grupo de extensiones de una localidad a otra de manera transparente.
Vamos a suponer que tenemos dos servidores y queremos que desde una extension registrada en el sitio A se pueda marcar a una extension del sitio B:

Servidor IP Extensiones
AsteriskA 192.168.0.1 100 a 199
AsteriskB 192.168.1.1 200 a 299

Para lograr nuestro cometido necesitamos crear una troncal IAX2 para el servidor remoto en cada localidad.
Empezamos con AsteriskA:
En /etc/asterisk/iax.conf

[servidorb]
type=friend
username=servidora
secret=password
auth=plaintext
host=192.168.1.1
context=entrantes
trunk=yes
requirecalltoken=no

En /etc/asterisk/extensions.conf

[entrantes]
exten => 2XX,1,Dial(IAX2/servidorb/${EXTEN},90,tr)
exten => 2XX,2,HangUp()

En servidorB:
Editamos /etc/asterisk/iax.conf

[servidora]
type=friend
username=servidorb
secret=password
auth=plaintext
host=192.168.0.1
context=entrantes
trunk=yes
requirecalltoken=no

En /etc/asterisk/extensions.conf:

[entrantes]
exten => 1XX,1,Dial(IAX2/servidora/${EXTEN},90,tr)
exten => 1XX,2,HangUp()

Por ultimo ejecutamos:

asterisk -r -x "reload"

Ahora es posible marcar desde ServidorA hacia las extensiones 2XX de ServidorB y viceversa :)

Revisando problemas con DNS

Muchas veces los clientes se nos quejan porque no se ve el sitio web. Sabemos que hay una falla en el dns, pero cuando miramos la configuración, no nos muestra nada anormal... qué estará mal? Para eso está
 http://www.squish.net/dnscheck


squish nos permite realizar chequeos rigurosos de dns, se basa en la información qeu brindan los root servers y si es un dominio ecuatoriano, nos indicará qué respuesta dá cada dns de nic.ec (que de paso tienen punto de falla común y son recursivos y... varias fallas más, pero no hacen caso)
Así podrás saber quién es el que está dando una respuesta equivocada a tu query, si es un dns tuyo, o uno que hay puesto en nic.ec sin tu conocimiento o aprobación o en realidad algún dns tuyo tiene un problema.
Lo bueno que tiene squish es que es independiente de la red donde estás (está en internet y te mostrará lo que vé cualquiera desde internet) y que te dice exactamente dónde está el fallo.
He notado que muchas empresas e instituciones tienen graves falencias en el manejo de dns, y esto les podría ayudar a mejorar la velocidad de los queries y por lo tanto toda referencia a su dominio sería más rápida o sencillamente sería posible
Saludos

Migrando una base de datos en Mysql de un servidor a otro

Así que paseando por internet me encontré este comando que me ayudo a migrar las bases de datos via SSH en línea sin necesidad de hacer un DUMP al disco duro y luego tener que restaurarlo en el destino, Este comando lo hace por tí directamente.
Se los comparto:

mysqldump -ux -px database | ssh yo@nuevo_server "mysql -ux -px database"



Espero les sea útil

Como configurar Postfix en Elastix/CentOS con Google Apps

Este pequeño manual, les indicara como configurar POSTFIX sobre Elastix/ Centos 5 con un dominio configurado con Google Apps (www.google.com/a)
Vamos a establecer los siguientes supuestos:
Dominio: www.christancho.com
Nombre del servidor: elastix
Configurando el servidor
La configuración principal del postfix se encuentra en el archivo /etc/postfix/main.cf por tanto:

cd /etc/postfix
nano main.cf

Luego cambiamos las siguientes líneas:
#myhostname = host.domain.tld
#myhostname = virtual.domain.tld
Por:
myhostname = elastix.christancho.com
#myhostname = virtual.domain.tld
Luego cambiamos:
#mydomain = domain.tld
Por:
mydomain = christancho.com
Luego establecemos el servidor SMTP por el cual se enviara el correo, recuerda que gmail utiliza SSL:
#relayhost = $mydomain
#relayhost = [gateway.my.domain]
#relayhost = [mailserver.isp.tld]
#relayhost = uucphost
#relayhost = [an.ip.add.ress]
Por:
#relayhost = $mydomain
#relayhost = [gateway.my.domain]
relayhost = smtp.gmail.com:587
#relayhost = uucphost
#relayhost = [an.ip.add.ress]
Guardamos los cambios realizados a main.cf, luego recargamos la configuración de POSTFIX.

postfix reload

Luego necesitas modificar otra vez el archivo main.cf con los siguientes cambios, estos estan al final del archivo.
################################
#Ingresado por yb-webadmin
mydomain =christancho.com
myhostname = elastix.christancho.local
Configurando la cuenta de correo
Creamos el archivo sasl_passwd (sin extension)

nano /etc/postfix/sasl_passwd

Dentro del archivo registramos la cuenta de correo (existente) y su respectiva clave, esta es la cuenta desde la cual se enviaran los correos.
smtp.gmail.com:587
usuario@christancho.com:miclave
Grabamos el archive sasl_passwd.
Luego lo ciframos:

postmap hash:/etc/postfix/sasl_passwd

Luego editamos el archive main.cf

nano /etc/postfix/main.cf

Agregamos las siguientes lineas al final
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options =
grabamos el archive y recargamos la configuracion del POSTFIX.

postfix reload

Habilitando el TLS
Recuerda que gmail usa SSL, por tanto, necesitamos un certificado SSL, no necesariamente establecido por una empresa, así que creamos uno propio, el cual será usado por el TLS

mkdir /etc/postfix/tls
cd /etc/postfix/tls
openssl genrsa -des3 -rand /etc/hosts -out smtpd.key 1024


Dejar el 'challenge password' vacio:

openssl req -new -key smtpd.key -out smtpd.csr
openssl x509 -req -days 3650 -in smtpd.csr -signkey smtpd.key -out smtpd.crt
openssl rsa -in smtpd.key -out smtpd.key.unencrypted
mv -f smtpd.key.unencrypted smtpd.key
openssl req -new -x509 -extensions v3_ca -keyout cakey.pem -out cacert.pem -days 3650


Agregar las siguientes lineas en el archivo /etc/postfix/main.cf:
smtpd_tls_auth_only = no
smtp_use_tls = yes
smtpd_use_tls = yes
smtp_tls_note_starttls_offer = yes
smtpd_tls_key_file = /etc/postfix/tls/smtpd.key
smtpd_tls_cert_file = /etc/postfix/tls/smtpd.crt
smtpd_tls_CAfile = /etc/postfix/tls/cacert.pem
smtpd_tls_loglevel = 1
smtpd_tls_received_header = yes
smtpd_tls_session_cache_timeout = 3600s
tls_random_source = dev:/dev/urandom
tls_daemon_random_source = dev:/dev/urandom
Reiniciamos los servicios:

service saslauthd restart
service postfix restart

Para que inicien en el boot:

chkconfig postfix on
chkconfig saslauthd on

Casi listo, hagamos una prueba:
1. Revisemos el log del correo:
tail -f /var/log/maillog

2. Abre otra consola y envia un correo (recuerda que con el punto y enter termina el correo):

mail

destinatario@dominio.com Subject: test
hello
.
Cc:

3. Luego de esto en el log debe salir algo parecido a esto y lo que importa es la palabra SENT:

elastix postfix/smtp[3257]: 08EAE21566: to=, relay=smtp.gmail.com[74.125.45.109]:587, delay=9.2, delays=0.21/0.06/6.8/2.1, dsn=2.0.0, status=sent (250 2.0.0 OK 1227557334 34sm10144335yxl.8) Nov 4 12:50:26 elastix postfix/qmgr[3250]: 08EAE21566: removed

Espero les sirva.
Conversamos luego,
Christancho
Ps. Esto es tomado desde el libro 'Elastix without tears' y la parte de TLS desde un blog, solo uni todo y lo puse en contexto.

como recuperar contraseña de root

este pequeño "como", es una vivencia propia y una gran necesidad, por lo que la e puesto a consideracion de ustedes; para realizar estos cambios se debera tomar en cuenta que distro usas, ya que lo explico solo para red hat linux y sus clones.
A) por medio del cd de instalacion:
1.- asegurate que la bios de la computadora arranque desde el cd-rom.
2.- metemos el cd numero1 de red hat o sus clones.
3.- cuando arranque y nos aparezca en el prompt la palabra boot: tecleamos "linux rescue" sin las comillas, obviamente.
4.- empezara a cargar nuestro sistema y llegaremos a ANACONDA (el instalador de red hat y clones). nos pedirá el idioma y el idioma del teclado.eliges español o el que uses.
5.- te dirá que va a intentar montar el linux que exista en tu maquina , y lo hará en /mnt/sysimage así mismo te pondrá tres opciones para elegir: "continuar","montar en modo lectura" Y "saltar". eliges "CONTINUAR".
6.- ahora tu sistema estara montado en /mnt/sysimage. presiona la tecla enter. aparece un shell, y con el el prompt #. recuerda que estas corriendo desde el cd, lo que importa es entrar como root a la particion montada por anaconda. teclea "chroot /mnt/sysimage" (sin las comillas).
7.- estamos bien, teclea "vi /etc/passwd"(sin las comillas)
8.- te saldra algo parecido a esto:
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
9.- vamos a una breve explicacion solo de la primera linea:
root ..............nombre de usuario (login name)
x ..............contraseña cifrada
0 ..............identificador UID
0 ..............identificador grupo primario al que pertenece el usuario GID
root ..............descripcion del usuario
/root ..............directorio de conexion inicial del usuario
/bin/bash ..........programa interprete de ordenes (shell)
10.- presionamos i para editar en vi
11.- borramos la letra x
12.- presionamos la tecla "esc" y digitamos ":wq!", para salir y gusrdar los cambios. sin las comillas
13.- digita exit.
14.- digita nuevamente exit. Sí nuevamente, es para reiniciar.
15.- retira el cd de la unidad para que intente arrancar desde el disco duro.
16.- en el shell (X, gnome, kde, etc)te pedira el nombre de usuario y digita root
17.- por lo pronto no te pedira contraseña, por lo que deberas colocar una contraseña como tu gustes.
B)por medio de modo recuperacion del sistema.
1.- encencemos el pc
2.- una vez que este en el grub presionar la barra espaciadora.
3.- digitar la letra "e", sin comillas para editar
4.- escoger el modo de kernel
5.- digitar nuevamente la letra "e", sin comillas para editar.
7.- dejar un espacio y digitar la "s", sin comillas.
8.- presionar la letra b para bootear o reiniciar el sistema.
9.- en el shell (X, gnome, kde, etc)te pedira el nombre de usuario y digita root
17.- por lo pronto no te pedira contraseña, por lo que deberas colocar una contraseña como tu gustes.
espero que te funcione como a mi.

Limitar el consumo de ancho de banda de descarga de diferentes sitios y archivos con Squid

Este resumen no está disponible. Haz clic en este enlace para ver la entrada.

conectando 2 asterisk con iax2

Supongamos que tenemos dos localidades y en cada una un Asterisk. Podemos interconectar estas a través de Internet con este sencillo procedimiento.
Voy a llamar al servidor de la LocalidadA como ServidorA y al de la localidadB ServidorB

Servidor IP Extensiones
ServidorA 192.168.0.1 100 a 199
ServidorB 192.168.1.1 200 a 299

Creamos una nueva troncal IAX2 desde FreePBX:
En ServidorA:

TRUNK NAME: servidorb
host=192.168.1.1
username=servidora
secret=123456
encryption=aes128
auth=md5
type=friend
context=from-internal
trunk=yes
requirecalltoken=no

En ServidorB:

TRUNK NAME: servidora
host=192.168.0.1
username=servidorb
secret=123456
encryption=aes128
auth=md5
type=friend
context=from-internal
trunk=yes
requirecalltoken=no

Creamos las rutas salientes en ServidorA:

Route Name: LocalidadB
Dial Patterns: 2XX
Trunk Sequence: IAX2/servidorb

Creamos las rutas salientes en ServidorB:

Route Name: LocalidadA
Dial Patterns: 1XX
Trunk Sequence: IAX2/servidora

Ahora podemos llamar desde LocalidadA hacia LocalidadB y viceversa :)
Si queremos ahorrar ancho de banda se pueden agregar estas dos líneas en la configuración de cada troncal:

disallow=all
allow=gsm&ilbc

Instalación de Servidor Firewall con Proxys transparentes

Copyright (c) 2007 Luis Miguel Armendáriz
Está permitido copiar, distribuir y/o modificar los documentos bajo los términos de la GNU Free Documentation License, Version 1.2
Para obtener una copia de la licencia "GNU Free Documentation License" visite http://www.fsf.org/licenses/fdl.txt
Índice

Resumen
El objetivo del documento es conseguir instalar un servidor que haga las veces de enrutador, cortafuegos, pasarela y proxy transparente de web y POP3, entre una red local (LAN) e Internet.
Es decir que sin tocar nada en los equipos clientes de la red local, podamos disponer de un cortafuegos que ademas filtre el tráfico http y analice la descarga de correo (POP3) en busca de spam y virus.
Todos los manuales que he encontrado para filtrar spam y antivirus se basan en instalar un servidor de correo y filtrar el protocolo SMTP. Eso te obliga a tener cuentas de correo, usuarios... Mi intención era únicamente analizar el tráfico en busca de virus y spam en los correos de los clientes, independientemente de cual sea su servidor (direcciones personales, empresariales...).
La solución es p3scan, un proxy transparente de POP3. Pero ni siquiera en su web he encontrado un manual de instalación.
El documento que estas leyendo pretende ser esa guía que yo no encontré que permita instalar y configurar un proxy transparente de POP3 integrado en un cortafuegos e integrado, por el mismo precio, con un proxy transparente de web y redireccionamientos NAT.
Para ello vamos a utilizar Debian GNU/Linux con, principalmente, iptables, squid, p3scan, clamav y spampd (SpamAssassin).

Notas sobre el documento
La mayoría de los ficheros de configuración se muestran incompletos. Generalmente las lineas aquí mostradas son únicamente las que ha sido necesario modificar.
Las versiones de los paquetes Debian utilizadas al realizar este documento han sido:
  • Debian Etch RC1 (2006-11-13)
  • kernel linux 2.6.18-3-686
  • iptables 1.3.6.0debian1-5
  • squid 2.6.5-2
  • p3scan 2.1-2
  • clamav 0.88.7-1
  • spampd 2.30-15
  • spamassassin 3.1.7-1
  • spamc 3.1.7-1

Instalación del sistema base
Vamos a utilizar un CD de netinstall de Debian Etch RC1 (2006-11-13) que nos permitirá de forma facil y sencilla instalar un sistema básico.
Recordemos que puesto que vamos a instalar un cortafuegos, es mejor no instalar paquetes innecesarios.

Realizamos una instalación minima arrancando desde el CD (sin utilizar repositorios en red) instalando solo el sistema base.

Generamos tres particiones:
  • una para el sistema
  • otra para swap
  • otra de respaldo en /copia
    en esta guardamos una imagen del sistema instalado datos de configuración que queramos conservar y copias de seguridad.
Una vez instalado el sistema desde el CD, configuramos algunos detalles.

Activación de framebuffer en consola (OPCIONAL)
# vi /boot/grub/menu.lst
(...)
kernel /boot/vmlinuz-2.6.18-3-686 root=/dev/hda3 ro vga=791
(...)

Configuración de la red
Configuramos las interfaces.
# vi /etc/network/interfaces
# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
#allow-hotplug eth0
#iface eth0 inet dhcp
### Interfaz EXTERNA
iface eth0 inet static
address 280.280.280.280 # Aquí debe ir la IP pública del equipo
# Esta es una IP ficticia. De hecho no es una IP válida.
# Es la que usaremos como ejemplo en el documento
netmask 255.255.255.0
gateway 280.280.280.1
up route add default gw 280.280.280.1
### Interfaz INTERNA
iface eth1 inet static
address 192.168.0.10
netmask 255.255.255.0
auto eth0
auto eth1

Configuramos la resolucion DNS.
Tengo disponible una lista de servidores de DNS. Aquí pongo un par de servidores de Telefónica de ejemplo.
# vi /etc/resolv.conf
#Telefonica
nameserver 80.58.0.33
nameserver 80.58.32.97

Actualización del sistema
Configuramos los repositorios utilizando el mirror de Francia, ya que el de España sigue dando problemas de vez en cuando (y van un montón de años...)
# vi /etc/apt/sources.list
#
# deb cdrom:[Debian GNU/Linux testing _Etch_ - Official Snapshot i386 Binary-1 (20061111)]/ etch main
#deb cdrom:[Debian GNU/Linux testing _Etch_ - Official Snapshot i386 Binary-1 (20061111)]/ etch main
deb http://ftp.fr.debian.org/debian/ etch main
deb-src http://ftp.fr.debian.org/debian/ etch main
deb http://security.debian.org/ etch/updates main
deb-src http://security.debian.org/ etch/updates main

Insertamos la clave del repositorio
# gpg --keyserver keyring.debian.org --recv-key 6070d3a1
# gpg --armor --export 6070d3a1 | apt-key add -

Actualizamos el sistema
# aptitude update
# aptitude upgrade
# aptitude dist-upgrade

Instalamos algunos paquetes utiles y/o necesarios
# aptitude install less vim lynx telnet tofrodos
# aptitude install openssh-server nmap iptables
... y el entorno grafico si lo deseamos (NO SE RECOMIENDA)
# aptitude install xserver-xorg xserver-common xfonts-base gnome

Quitamos servicios innecesarios
(El servicio portmap puede ser necesario matarlo con kill -9)
# /etc/init.d/portmap stop
# update-rc.d -f portmap remove
# update-inetd --disable chargen
# update-inetd --disable ident
# update-inetd --disable discard
Opcionalmente y según lo que hayamos instalado (RECOMENDADO)
# /etc/init.d/cups stop
# update-rc.d -f cups remove
# update-rc.d -f gdm remove

Servicios a quitar si no se ha realizado la instalación básica indicada
# /etc/init.d/lpd stop
# update-rc.d -f lpd remove
# /etc/init.d/nfs-common stop
# update-rc.d -f nfs-common remove
# /etc/init.d/pcmcia stop
# update-rc.d -f pcmcia remove
# /etc/init.d/ppp stop
# update-rc.d -f ppp remove
# /etc/init.d/exim4 stop
# update-rc.d -f exim4 remove
# /etc/init.d/bittorrent stop
# update-rc.d -f bittorrent remove
# update-rc.d -f ntpdate remove
# update-inetd --disable time
# update-inetd --disable daytime
# update-inetd --disable echo

Configuración de ssh
Para mayor seguridad cambiamos el puerto, reducimos el tiempo de login y no permitimos conexiones de root
# vi /etc/ssh/sshd_config
Port 2222
LoginGraceTime 45
PermitRootLogin no
Solo permitimos acceder por ssh a los usuarios indicados en el fichero /etc/loginusers
# vi /etc/pam.d/ssh
#auth required pam_env.so # [1]
auth required pam_listfile.so sense=allow onerr=fail item=user file=/etc/loginusers
Creamos el fichero /etc/loginusers
# vi /etc/loginusers
servi3
Como usuario (servi3 en el ejemplo) generamos las claves dsa y asignamos una passphrase
$ ssh-keygen -t dsa

Para cambiar (o des/asignar) una passphrase
$ ssh-keygen -p -f .ssh/id_dsa
Se recomienda cambiar la passphrase regularmente.

Autorizamos la clave publica
$ cat .ssh/id_dsa.pub > .ssh/authorized_keys
La clave privada (id_dsa) se tiene que copiar en los clientes de ssh a través de algún medio seguro. Por ejemplo en un disco de 2'5", pero NO a través de correo-e normal.
En este momento es posible conectarse desde otra maquina utilizando login y contraseña como siempre ($ ssh usuario@maquina -p 2222) o usando el fichero de clave privada y conociendo la passphrase ($ ssh usuario@maquina -p 2222 -i id_dsa_copiada).

Para permitir solo el uso de certificados reconfiguramos sshd desautorizando las autentificaciones por contraseña
# vi /etc/ssh/sshd_config
PasswordAuthentication no
Reiniciamos el servicio
# /etc/init.d/ssh restart

Para usar la clave en PuTTY (Windows):
  1. Copiamos la clave al equipo
  2. Usamos PuTTYGen para importar la clave y guardarla como .ppk
  3. Al hacer la conexión, en el menú SSH->Auth seleccionamos nuestro fichero .ppk

Instalación de la pasarela -gateway- con enrutador y cortafuegos
Copiamos los archivos para gestionar iptables en el directorio /etc/network/iptables.
# mkdir /etc/network/iptables
# cd /etc/network/iptables
# wget http://www.guimi.net/datos/tec-docs/firewall/guimi_iptables.tgz
# tar xzf guimi_iptables.tgz

Tendremos los siguientes ficheros:
  • ipflush.sh anula cortafuegos y enrutador. Es el script que se ejecuta al hacer "iptables stop".
  • ipgw_flush.sh activa el enrutador sin cortafuegos (permitiendo todo el tráfico). MUY PELIGROSO. Utilizar solo en entornos de prueba protegidos y controlados.
  • iprules.sh activa el enrutador y cortafuegos. Es el más importante y al que más tiempo habrá que dedicar para adaptarlo a nuestras necesidades. Es el script que se ejecuta al hacer "iptables start".
  • iptables utilizado para des/activar enrutador y cortafuegos.
  • iptables-check muestra las reglas de iptables activas en el sistema.
  • iptables.flush contiene la salida de iptables-save > iptables.flush tras ejecutar ipflush.sh
A continuación se puede ver el contenido de iprules.sh que nos permite:
  • generar un cortafuegos con todas las acciones por omisión a "DROP" (si un paquete no se ha aceptado explícitamente, se descarta)
  • hacer DNAT para un par de servidores FTP y web (redirige peticiones FTP y web de la dirección pública a servidores internos)
  • hacer NAT de salida para la intranet (los equipos de la LAN pueden navegar con la ip pública del servidor)
  • utilizar un par de proxys transparentes de web y POP3 redireccionando las peticiones de los equipos clientes (cuando un cliente pretende navegar o leer un correo el servidor "secuestra" la conexión y la analiza antes de permitirla)
#!/bin/bash
#
# Por Guimi 2007/01 - http://www.guimi.net
#
# Para guardar las reglas
#+ iptables-save > reglas
#+ iptables-restore < reglas
#
# Miramos si tenemos un parametro en linea de comando
if [ -n "$1" ] && [ "$1" = "q" ]
then
QUIET="1"
else
QUIET="0"
fi
# Registramos el inicio del firewall
#FECHA=$(date +"%C%y-%m-%d %H:%M")
#echo $FECHA
#/usr/bin/logger -p kern.notice -t NETFILTER \
# "====== Iniciado Cortafuegos: $FECHA ========="
if [ $QUIET = "0" ]; then
echo " Realizado por Guimi (http://www.guimi.net)"
echo " ------------------------------------------"
fi
# PARAMETRIZACION DEL SCRIPT
##########################################
### Definimos constantes para usar en el
###+ script
if [ $QUIET = "0" ]; then
echo " Cargando parametros..."
fi
# Binario de iptables
IPTABLES=/sbin/iptables
# INTERFACES
# eth0 - conectado a internet con IP FIJA
EXT_IF=eth0
EXT_IP=280.280.280.280
# eth1 - conectado a LAN
LAN_IF=eth1
LAN_IP=192.168.0.1
LAN_RED=192.168.0.0/24
# lo - interfaz de loopback
LOO_RED=127.0.0.0/8
# cualquier red
ANY_RED=0.0.0.0/0
# MAQUINAS INTERNAS
IP_SERVIDOR_FTP=192.168.0.2
if [ $QUIET = "0" ]; then
echo " Cargando modulos..."
fi
##########################################
### Nos aseguramos que tenemos cargados
###+ los modulos necesarios
modprobe ip_conntrack_irc
modprobe ip_conntrack_ftp
modprobe ip_nat_irc
modprobe ip_nat_ftp
if [ $QUIET = "0" ]; then
echo " Limpiando FW..."
fi
##########################################
### Limpiamos la configuracion existente
# Limpiamos (flush) las reglas
$IPTABLES -F
# Borramos 'cadenas' de usuario
$IPTABLES -X
# Ponemos a cero paquetes y contadores
$IPTABLES -Z
# Limpiamos las reglas de NAT
$IPTABLES -t nat -F
# Borramos 'cadenas' de usuario de NAT
$IPTABLES -t nat -X
if [ $QUIET = "0" ]; then
echo " Estableciendo politicas..."
fi
##########################################
### Establecemos las politicas por omision
###+ de las 'cadenas'
# Por omision descartamos los paquetes
$IPTABLES -P INPUT DROP
$IPTABLES -P OUTPUT DROP
$IPTABLES -P FORWARD DROP
# PREROUTING - NAT sobre la IP destino: normalmente desde inet hacia LAN
# POSTROUTING - NAT sobre la IP origen: normalmente desde LAN hacia inet
$IPTABLES -t nat -P PREROUTING DROP
$IPTABLES -t nat -P POSTROUTING DROP
# Relajamos la politica de salida
#+ Dejamos salir paquetes de LAN_IP por LAN_IF
$IPTABLES -A OUTPUT -o $LAN_IF -s $LAN_IP -j ACCEPT
#+ Dejamos salir paquetes de EXT_IP por EXT_IF
$IPTABLES -A OUTPUT -o $EXT_IF -s $EXT_IP -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> Denegacion de redes invalidas..."
fi
##########################################
# No admitimos desde el exterior redes locales (RFC 1918)
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 192.168.0.0/16 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 10.0.0.0/8 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 172.16.0.0/12 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 224.0.0.0/4 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 240.0.0.0/5 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s $LOO_RED -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 0.0.0.0/8 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 169.254.0.0/16 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s 255.255.255.255 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -s $EXT_IP -j DROP
# Desde el interior solo admitimos nuestra red LAN
$IPTABLES -t nat -A PREROUTING -i $LAN_IF -s ! $LAN_RED -j DROP
if [ $QUIET = "0" ]; then
echo " -> Denegacion de broadcast de NetBIOS..."
fi
##########################################
# Bloquear paquetes broadcast de NetBios salientes
iptables -A FORWARD -p tcp --sport 137:139 -o $EXT_IF -j DROP
iptables -A FORWARD -p udp --sport 137:139 -o $EXT_IF -j DROP
iptables -A OUTPUT -p tcp --sport 137:139 -o $EXT_IF -j DROP
iptables -A OUTPUT -p udp --sport 137:139 -o $EXT_IF -j DROP
if [ $QUIET = "0" ]; then
echo " Activando NAT..."
fi
##########################################
# Activamos el bit de forward
echo 1 > /proc/sys/net/ipv4/ip_forward
# Enmascaramos la salida de la LAN
$IPTABLES -t nat -A POSTROUTING -s $LAN_RED -o $EXT_IF -j MASQUERADE
if [ $QUIET = "0" ]; then
echo " Accesos a la maquina local permitidos..."
fi
##########################################
### Permitimos ciertos accesos a la maquina
if [ $QUIET = "0" ]; then
echo " -> loopback..."
fi
# Permitimos todas las conexiones del interfaz loopback
#$IPTABLES -A INPUT -i lo -j ACCEPT
#$IPTABLES -A OUTPUT -o lo -j ACCEPT
$IPTABLES -A INPUT -i lo -s $LOO_RED -d $LOO_RED -j ACCEPT
$IPTABLES -A OUTPUT -o lo -s $LOO_RED -d $LOO_RED -j ACCEPT
# Permitimos el PostEnrutado de paquetes enviados localmente
$IPTABLES -t nat -A POSTROUTING -o lo -s $LOO_RED -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> LAN..."
fi
# Damos acceso desde la red local
$IPTABLES -A INPUT -s $LAN_RED -i $LAN_IF -j ACCEPT
$IPTABLES -A OUTPUT -d $LAN_RED -o $LAN_IF -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> DNS..."
fi
# Aceptamos conexiones DNS
$IPTABLES -A INPUT -s $ANY_RED -i $EXT_IF -p udp -m udp --sport 53 --dport 1024:65535 -j ACCEPT
$IPTABLES -A OUTPUT -d $ANY_RED -o $EXT_IF -p udp -m udp --dport 53 --sport 1024:65535 -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> ntpd..."
fi
# Aceptamos conexiones ntpd
$IPTABLES -A INPUT -p udp -m udp --dport 123 -i $EXT_IF -s $ANY_RED -j ACCEPT
$IPTABLES -A OUTPUT -p udp -m udp --sport 123 -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> icmp..."
fi
# Permitimos paquetes ICMP (ping, traceroute...)
#+ con limites para evitar ataques de DoS
# Aceptamos ping y pong
$IPTABLES -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/s -j ACCEPT
$IPTABLES -A OUTPUT -p icmp --icmp-type echo-request -m limit --limit 2/s -j ACCEPT
$IPTABLES -A INPUT -p icmp --icmp-type echo-reply -m limit --limit 2/s -j ACCEPT
$IPTABLES -A OUTPUT -p icmp --icmp-type echo-reply -m limit --limit 2/s -j ACCEPT
# Aceptamos redirecciones
$IPTABLES -A INPUT -p icmp --icmp-type redirect -m limit --limit 2/s -j ACCEPT
$IPTABLES -A OUTPUT -p icmp --icmp-type redirect -m limit --limit 2/s -j ACCEPT
# Aceptamos tiempo excedido
$IPTABLES -A INPUT -p icmp --icmp-type time-exceeded -m limit --limit 2/s -j ACCEPT
$IPTABLES -A OUTPUT -p icmp --icmp-type time-exceeded -m limit --limit 2/s -j ACCEPT
# Aceptamos destino inalcanzable
$IPTABLES -A INPUT -p icmp --icmp-type destination-unreachable -m limit --limit 2/s -j ACCEPT
$IPTABLES -A OUTPUT -p icmp --icmp-type destination-unreachable -m limit --limit 2/s -j ACCEPT
if [ $QUIET = "0" ]; then
echo " -> ssh..."
fi
# Abrimos el puerto 2222 para ssh
#$IPTABLES -A INPUT -p tcp -i $EXT_IF -s $ANY_RED -m tcp --dport 2222 --sport 1024:65535 -j ACCEPT
$IPTABLES -A INPUT -p tcp -s $ANY_RED -m tcp --dport 2222 --sport 1024:65535 -m state --state NEW -j LOG --log-prefix "[FW - SSH] "
$IPTABLES -A INPUT -p tcp -s $ANY_RED -m tcp --dport 2222 --sport 1024:65535 -j ACCEPT
# ...y conexiones salientes relacionadas
$IPTABLES -A OUTPUT -p tcp -m tcp --sport 2222 -m state --state RELATED,ESTABLISHED -j ACCEPT
if [ $QUIET = "0" ]; then
echo " Redirecciones..."
fi
##########################################
### Generamos redireccionamientos
###+ transparentes para el resto de maquinas
if [ $QUIET = "0" ]; then
echo " -> Proxy web transparente (Squid)..."
fi
#+ Con la redireccion activa (primera linea)
#+ no se llega a la segunda linea
#+ Para bloquear todo acceso a la web comentar
#+ solo la primera linea
#+ Para anular el proxy comentar las dos reglas
$IPTABLES -t nat -A PREROUTING -i $LAN_IF -s $LAN_RED -p tcp --dport 80 -j REDIRECT --to-port 3128
$IPTABLES -A FORWARD -i $LAN_IF -p tcp --dport 80 -j DROP
if [ $QUIET = "0" ]; then
echo " -> Filtro de correo (P3Scan)..."
fi
#+ Con la redireccion activa (primera linea)
#+ no se llega a la segunda linea
#+ Para bloquear todo acceso a POP comentar
#+ solo la primera linea
#+ Para anular el filtrado comentar las dos reglas
$IPTABLES -t nat -A PREROUTING -i $LAN_IF -s $LAN_RED -p tcp --dport 110 -j REDIRECT --to-port 8110
$IPTABLES -A FORWARD -i $LAN_IF -p tcp --dport 110 -j DROP
###$IPTABLES -t nat -A OUTPUT -p tcp --dport 110 -m owner --owner-id p3scan -j ACCEPT
###$IPTABLES -t nat -A OUTPUT -p tcp --dport 110 -j REDIRECT --to-port 8110
if [ $QUIET = "0" ]; then
echo " -> DNAT (21 y 20)..."
fi
# Redirigimos "$EXT_IP":2220-1 a "$IP_SERVIDOR_FTP":20-1
###$IPTABLES -t nat -A PREROUTING -i $EXT_IF -d $EXT_IP -p tcp --dport 21 -j LOG --log-prefix "[FW - FTP] "
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -d $EXT_IP -p tcp --dport 220 -j DNAT --to "$IP_SERVIDOR_FTP":20
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -d $EXT_IP -p tcp --dport 221 -j DNAT --to "$IP_SERVIDOR_FTP":21
# ...y conexiones salientes relacionadas (ftp pasivo)
$IPTABLES -t nat -A PREROUTING -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos postruteos a "$IP_SERVIDOR_FTP":20-1
$IPTABLES -t nat -A POSTROUTING -o $LAN_IF -d $IP_SERVIDOR_FTP -p tcp --dport 20 -j ACCEPT
$IPTABLES -t nat -A POSTROUTING -o $LAN_IF -d $IP_SERVIDOR_FTP -p tcp --dport 21 -j ACCEPT
# Permitimos reenvios desde el exterior a "$IP_SERVIDOR_FTP":20-1
$IPTABLES -A FORWARD -i $EXT_IF -d $IP_SERVIDOR_FTP -p tcp --dport 20 -j ACCEPT
$IPTABLES -A FORWARD -i $EXT_IF -d $IP_SERVIDOR_FTP -p tcp --dport 21 -j ACCEPT
if [ $QUIET = "0" ]; then
echo " Reenvios..."
fi
##########################################
### Aceptamos algunos reenvios
if [ $QUIET = "0" ]; then
echo " -> icmp..."
fi
# Permitimos paquetes ICMP (ping, traceroute...)
#+ con limites para evitar ataques de DoS
# Aceptamos ping y pong
$IPTABLES -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 2/s -j ACCEPT
$IPTABLES -A FORWARD -p icmp --icmp-type echo-reply -m limit --limit 2/s -j ACCEPT
# Aceptamos redirecciones
$IPTABLES -A FORWARD -p icmp --icmp-type redirect -m limit --limit 2/s -j ACCEPT
# Aceptamos tiempo excedido
$IPTABLES -A FORWARD -p icmp --icmp-type time-exceeded -m limit --limit 2/s -j ACCEPT
# Aceptamos destino inalcanzable
$IPTABLES -A FORWARD -p icmp --icmp-type destination-unreachable -m limit --limit 2/s -j ACCEPT
# Aceptamos todas en LAN_IF
$IPTABLES -t nat -A PREROUTING -i $LAN_IF -p icmp --icmp-type any -m limit --limit 2/s -j ACCEPT
$IPTABLES -t nat -A POSTROUTING -o $LAN_IF -p icmp --icmp-type any -m limit --limit 2/s -j ACCEPT
if [ $QUIET = "0" ]; then
echo " Salida general..."
fi
##########################################
### Aceptamos conexiones salientes
# Permitimos cualquier salida tcp desde la propia maquina
$IPTABLES -A OUTPUT -o $EXT_IF -p tcp -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
# ...y conexiones entrantes relacionadas
$IPTABLES -A INPUT -i $EXT_IF -p tcp -m state --state ESTABLISHED,RELATED -j ACCEPT
# Permitimos el reenvio de paquetes enviados desde la LAN
$IPTABLES -A FORWARD -i $LAN_IF -j ACCEPT
# ...y conexiones salientes relacionadas
$IPTABLES -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos el NAT de paquetes enviados desde la LAN
$IPTABLES -t nat -A PREROUTING -i $LAN_IF -j ACCEPT
# ...y conexiones salientes relacionadas
$IPTABLES -t nat -A PREROUTING -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos el NAT de paquetes enviados desde inet hacia la IP publica
$IPTABLES -t nat -A PREROUTING -i $EXT_IF -d $EXT_IP -j ACCEPT
# ...y conexiones salientes relacionadas
$IPTABLES -t nat -A PREROUTING -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos el NAT de paquetes enviados desde la IP publica hacia inet
$IPTABLES -t nat -A POSTROUTING -o $EXT_IF -s $EXT_IP -j ACCEPT
# ...y conexiones salientes relacionadas
$IPTABLES -t nat -A POSTROUTING -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos el PostEnrutado de paquetes enviados localmente
$IPTABLES -t nat -A POSTROUTING -o $LAN_IF -s $LAN_RED -j ACCEPT
if [ $QUIET = "0" ]; then
echo " Cerrando puertos restringidos..."
fi
##########################################
### Puertos restringidos (telnet, ftp, imap, pop3, etc.)
###+ Reiterativo: para pruebas
$IPTABLES -A INPUT -p tcp --dport 1:1024 -j DROP
$IPTABLES -A INPUT -p udp --dport 1:1024 -j DROP
###echo " ACTIVADO DEBUG..."
##########################################
### Reglas utilizadas en debug para detectar
#+ paquetes no tratados todavia
#+ -j LOG --log-prefix "--PR> "
###$IPTABLES -t nat -A PREROUTING -j LOG --log-prefix "[FW - PR] "
###$IPTABLES -t nat -A POSTROUTING -j LOG --log-prefix "[FW - PO] "
###$IPTABLES -A FORWARD -j LOG --log-prefix "[FW - FW] "
###$IPTABLES -A INPUT -j LOG --log-prefix "[FW - IN] "
###$IPTABLES -A OUTPUT -j LOG --log-prefix "[FW - OU] "
if [ $QUIET = "0" ]; then
echo " Configuracion FW terminada."
echo ""
echo " A continuacion podria desear:"
echo " - verificar reglas: iptables -nvL && iptables -nvL -t nat"
echo " - guardar reglas: iptables-save > reglas"
echo " - restaurar reglas: iptables-restore < reglas"
fi
##########################################
exit 0
Para dejar iptables perfectamente configurado aplicamos y guardamos las reglas del cortafuegos
# cd /etc/network/iptables
# ./iprules.sh
# iptables-save > iptables.rc
Configuramos la red para que active y desactive la pasarela cuando se levante o se tumbe la tarjeta de red conectada con internet.
# vi /etc/network/interfaces
(...)
### Interfaz EXTERNA
iface eth0 inet static
(...)
pre-up /etc/network/iptables/iptables start
post-down /etc/network/iptables/iptables stop
### Interfaz INTERNA
(...)

Configuración de proxy web transparente (Squid)
Para que funcione debe existir una redirección del puerto 80 al squid.
Esa redirección la hemos realizado con el fichero iprules.sh.
Nótese que en el ejemplo solo se utiliza el proxy para las conexiones al puerto 80, es decir, las conexiones de https (puerto 443) se reenvían directamente.

# aptitude install squid
# vi /etc/squid/squid.conf
http_port 3128 transparent
# proxy icp
# hostname type port port options
# -------------------- -------- ----- ----- -----------
#cache_peer 1.2.3.4 parent 8080 0 no-query
cache_dir aufs /var/spool/squid 600 16 256
visible_hostname mi_pasarela
acl our_networks src 192.168.0.0/16
http_access allow our_networks
#nonhierarchical_direct off

Reiniciamos el servicio
# /etc/init.d/squid restart

Si se desea hacer pruebas, un modo sencillo es comentar en /etc/squid/squid.conf la linea que dice http_access allow our_networks y probar a navegar por la web desde la intranet.
El navegador debería mostrarnos una página generada por Squid indicándonos que no tenemos permiso para navegar.

Este manual nos permite añadir análisis antivirus a squid.

Configuración de antivirus (ClamAV)
Realizamos una instalación manteniendo la configuración por omisión
# aptitude install clamav

Comprobamos los permisos de la base de datos y los logs
# ls -al /var/lib/clamav/
total 8216
drwxr-xr-x 2 clamav clamav 4096 2006-12-30 09:55 .
drwxr-xr-x 45 root root 4096 2006-12-29 12:29 ..
-rw-r--r-- 1 clamav clamav 1460245 2006-12-30 09:55 daily.cvd
-rw-r--r-- 1 clamav clamav 6924820 2006-12-29 12:30 main.cvd
# ls -al /var/log/clamav/
total 28
drwxr-xr-x 2 clamav clamav 4096 2006-12-29 12:30 .
drwxr-xr-x 12 root root 4096 2006-12-30 10:02 ..
-rw-r----- 1 clamav adm 12287 2006-12-30 11:25 clamav.log
-rw-r----- 1 clamav adm 5233 2006-12-30 11:29 freshclam.log

Probamos el antivirus
Para hacer pruebas utilizamos el test eicar de eicar.org.
El test eicar es una firma utilizada para probar los antivirus. No hace absolutamente nada pero todos los antivirus la reconocen.
Podemos crear un fichero de texto detectable haciendo que contenga unicamente la siguiente linea:
X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
Tambien podemos utilizar estos ficheros con la firma eicar.

Por ejemplo, utilizando el usuario ya visto (servi3):
$ cd /home/servi3
$ wget http://www.guimi.net/datos/tec-docs/firewall/guimi_eicar.tgz
$ tar xzf guimi_eicar.tgz

# clamscan /home/servi3/eicar/
/home/servi3/eicar/eicar.com.txt: Eicar-Test-Signature FOUND
/home/servi3/eicar/eicar.com: Eicar-Test-Signature FOUND
/home/servi3/eicar/eicar_com.zip: Eicar-Test-Signature FOUND
----------- SCAN SUMMARY -----------
Known viruses: 85898
Engine version: 0.88.7
Scanned directories: 1
Scanned files: 3
Infected files: 3
Data scanned: 0.00 MB
Time: 2.684 sec (0 m 2 s)

Configuración de SpamPd (Usa SpamAssasin)
SpamPD es un filtro contra spam que utiliza spamassasin. Configuraremos p3scan para que utilice el cliente spamc.
# aptitude install spampd

Configuramos spampd para que utilice el mismo usuario del antivirus.
Al usar un usuario para todo lo que tiene que ver con correo (p3scan, clamav, spampd) simplificamos los permisos
# vi /etc/default/spampd
USERID=clamav
GRPID=clamav

Activamos SA
# vi /etc/default/spamassassin
ENABLED=1

Configuramos SA
# vi /etc/spamassassin/local.cf
### Indicamos en la cabecera del mensaje que es probable spam
rewrite_header Subject *****SPAM*****
### El mensaje original lo incluimos como un anexo en MIME
report_safe 1
### Marcamos el umbral de puntuacion para que un mensaje sea
###+ considerado spam
required_score 3.0
### Utilizamos el filtro bayesiano
use_bayes 1
### Activamos el autoaprendizaje del filtro bayesiano
bayes_auto_learn 1
### Aceptamos mensajes en frances y espanyol
###+ El resto puntua como posible spam
ok_languages fr es
### Aceptamos el juego de caracteres occidental
###+ El resto puntua como posible spam
ok_locales en
### Anyadimos cabeceras a los mensajes
### Solo a los que son spam
add_header spam Flag _YESNOCAPS_
### A todos
add_header all Status _YESNO_, score=_SCORE_ required=_REQD_ autolearn=_AUTOLEARN_ version=_VERSION_ bayes=_BAYES_
add_header all Level _STARS(*)_
add_header all Checker-Version SpamAssassin _VERSION_ (_SUBVERSION_) on _HOSTNAME_

Preparamos un script que mantenga las reglas de SA actualizadas
# vi /root/bin/actualiza_sa.sh
#!/bin/bash
#
# Script para actualizar las reglas de SpamAssassin
#
# Guimi - http://guimi.net
# 2007-01
#
# Cambiamos al directorio adecuado
cd /etc/spamassassin/
# Actualizamos las reglas
wget http://mywebpages.comcast.net/mkettler/sa/antidrug.cf
wget http://www.nospamtoday.com/download/mime_validate.cf
wget http://www.rulesemporium.com/rules/70_sare_adult.cf
wget http://www.rulesemporium.com/rules/70_sare_bayes_poison_nxm.cf
wget http://www.rulesemporium.com/rules/70_sare_evilnum0.cf
wget http://www.rulesemporium.com/rules/70_sare_genlsubj0.cf
wget http://www.rulesemporium.com/rules/70_sare_genlsubj_eng.cf
wget http://www.rulesemporium.com/rules/70_sare_header0.cf
wget http://www.rulesemporium.com/rules/70_sare_header_eng.cf
wget http://www.rulesemporium.com/rules/70_sare_html0.cf
wget http://www.rulesemporium.com/rules/70_sare_html_eng.cf
wget http://www.rulesemporium.com/rules/70_sare_obfu0.cf
wget http://www.rulesemporium.com/rules/70_sare_oem.cf
wget http://www.rulesemporium.com/rules/70_sare_random.cf
wget http://www.rulesemporium.com/rules/70_sare_specific.cf
wget http://www.rulesemporium.com/rules/70_sare_spoof.cf
wget http://www.rulesemporium.com/rules/70_sare_stocks.cf
wget http://www.rulesemporium.com/rules/70_sare_unsub.cf
wget http://www.rulesemporium.com/rules/70_sare_uri0.cf
wget http://www.rulesemporium.com/rules/72_sare_bml_post25x.cf
wget http://www.rulesemporium.com/rules/72_sare_redirect_post3.0.0.cf
wget http://www.rulesemporium.com/rules/88_FVGT_body.cf
wget http://www.rulesemporium.com/rules/88_FVGT_headers.cf
wget http://www.rulesemporium.com/rules/88_FVGT_rawbody.cf
wget http://www.rulesemporium.com/rules/88_FVGT_subject.cf
wget http://www.rulesemporium.com/rules/88_FVGT_uri.cf
wget http://www.rulesemporium.com/rules/99_FVGT_DomainDigits.cf
wget http://www.rulesemporium.com/rules/99_FVGT_meta.cf
wget http://www.rulesemporium.com/rules/99_FVGT_Tripwire.cf
wget http://www.rulesemporium.com/rules/99_sare_fraud_post25x.cf
wget http://www.stearns.org/sa-blacklist/random.current.cf
wget http://www.timj.co.uk/linux/bogus-virus-warnings.cf
wget http://www.yackley.org/sa-rules/evilnumbers.cf
# Reiniciamos los servicios
/etc/init.d/spamassassin restart
/etc/init.d/spampd restart
Programamos el sistema para que actualice al menos una vez a la semana (NO más de una vez al día para no contravenir la política de descarga de SARE)
# crontab -e
#m h dom mon dow command
00 05 * * 1 /root/bin/actualiza-sa.sh

Configuración de proxy POP3 (p3scan)
# aptitude install p3scan

Utilizamos el mensaje de virus en español
# cd /etc/p3scan/
# rm p3scan.mail
# ln -s p3scan-sp.mail p3scan.mail

Configuramos p3scan
# vi /etc/p3scan/p3scan.conf
targetip = 0.0.0.0
targetport = 8110
user = clamav
scannertype = basic
scanner = /usr/bin/clamscan --no-summary
virusregexp = .*: (.*) FOUND
demime
checkspam
spamcheck = /usr/bin/spamc
subject = [Virus - mi_pasarela] Un mensaje enviado para usted contenia virus:

Hacemos todos los usuarios de los tres grupos aunque en realidad solo utilizamos el usuario clamav
# vi /etc/group
clamav:x:110:spamc,spampd,p3scan
p3scan:x:111:clamav,spamc,spampd
spampd:x:112:clamav,spamc,p3scan

Damos permisos al usuario
# chown clamav:clamav -R /var/spool/p3scan
# chown clamav:clamav -R /var/run/p3scan
# /etc/init.d/p3scan restart
# /etc/init.d/spamassassin restart
# /etc/init.d/spampd restart
Si no arranca p3scan automaticamente:
update-rc.d p3scan defaults

Algunas comprobaciones
# lsof -i | grep LISTEN
p3scan xxxx clamav 3u IPv4 xxxx TCP *:8110 (LISTEN)
sshd xxxx root 3u IPv6 xxxx TCP *:2222 (LISTEN)
squid xxxx proxy 13u IPv4 xxxx TCP *:3128 (LISTEN)
spampd xxxx clamav 5u IPv4 xxxxx TCP localhost:10025 (LISTEN)
spampd xxxx clamav 5u IPv4 xxxxx TCP localhost:10025 (LISTEN)
spampd xxxx clamav 5u IPv4 xxxxx TCP localhost:10025 (LISTEN)
spampd xxxx clamav 5u IPv4 xxxxx TCP localhost:10025 (LISTEN)
spamd xxxx root 5u IPv4 xxxxx TCP localhost:spamd (LISTEN)
spamd xxxx clamav 5u IPv4 xxxxx TCP localhost:spamd (LISTEN)
spamd xxxx root 5u IPv4 xxxxx TCP localhost:spamd (LISTEN)
# nmap localhost -p 1-5000,8110,10024-10026
Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2007-01-02 17:12 CET
Interesting ports on localhost (127.0.0.1):
Not shown: 4999 closed ports
PORT STATE SERVICE
783/tcp open spamassassin
2222/tcp open unknown
3128/tcp open squid-http
8110/tcp open unknown
10025/tcp open unknown
Nmap finished: 1 IP address (1 host up) scanned in 0.362 seconds

Si todo parece correcto, enviar mensajes de spam y/o con la firma eicar a cuentas que despues sean accedidas por pop3 desde la intranet. Verificar en las cabeceras que se usa el antispam.

BONO EXTRA - Configuración de OpenVPN
SIN TERMINAR
Instalación básica de OpenVPN basada en clave pre-compartida.

# modprobe tun
# ls /dev/net/tun -l
crw-rw-rw- 1 root root 10, 200 2006-12-30 09:55 /dev/net/tun
# openvpn --genkey --secret /etc/openvpn/key
# vi /etc/openvpn/config.ovpn
dev tap
secret /etc/openvpn/key
ping 10
verb 1
mute 10
ifconfig 10.0.1.1 255.255.255.252
lport 5002
# openvpn --config /etc/openvpn/config.ovpn --log-append /var/log/openvpn.log --daemon

Configuración del cliente
remote the.ip.public.address
rport 5002
dev tap
ifconfig 10.0.1.2 255.255.255.252
secret c:\openvpn\config\key # el mismo fichero key que el servidor
ping 10
verb 1
mute 10
route-gateway 10.0.1.1
redirect-gateway

Para contactar con nosotros escríbe a contacto_ARROBA_guimi.net
Web Original (http://guimi.net/)

Rarcrack: recupera las contraseñas de archivos comprimidos



Rarcrack es un programa que nos permitirá averiguar la contraseña de archivos comprimidos. Concretamente, soporta archivos .rar, .zip y .7z. Rarcrack es un programa que no ha tenido hasta el momento un largo desarrollo, encontrándose en la actualidad en su versión 0.2. No obstante, es totalmente eficaz en la recuperación de contraseñas, tarea que realiza mediante fuerza bruta. Es esto último un dato a tener en cuenta ya que la velocidad de trabajo variará en función de la potencia de nuestro equipo y la complejidad de la contraseña.

(*) Nota inicial: Los pasos descritos a continuación se explican, como siempre, con el único ánimo de compartir conocimiento.
Supuesto: hemos creado un archivo .txt con los apuntes anuales de la universidad, los hemos comprimido en un .zip y lo hemos protegido mediante contraseña para enviarlos por e-mail a un/una compañer@. Pero se nos olvida la contraseña… ¿Cómo recuperarla? El archivo en cuestión es éste (descargad para nuestra primera prueba).

1) Descargamos rarcrack 0.2 desde su página oficial. Descomprimimos el archivo y abrimos una terminal en el directorio creado al descomprimir rarcrack.
En el site del proyecto leemos que necesitaremos la librería libxml2, además de habituales programas para descomprimir. Antes de proceder a instalar rarcrack, deberemos comprobar que la tenemos instalada.
Seguimos… Situados en ese directorio, ejecutamos como root los comandos habituales para instalar:
make
make install
2) Ya tenemos rarcrack instalado. Tan sólo nos queda probarlo:
En la terminal, nos situamos en el directorio donde hemos descargado el .zip “apuntes.txt.zip”. Y ejecutamos la orden
rarcrack apuntes.txt.zip –type zip
(Antes de la palabra/variable “type”, hay 2 guiones; disculpad, el editor los junta en uno sólo).
El proceso de averiguación del password mediante rarcrack no debería consumir mucho tiempo ya que el password empleado es muy simple en este caso. Si se tratase de una contraseña de numerosos caracteres y/o una contraseña complicada, el proceso consumiría mucho más tiempo pero puede sacarnos de alguna que otra situación complicada. Sería una mera cuestión de tiempo…
En este caso, tras unos instantes (apenas segundos si contáis con un equipo potente), os debería aparecer en la terminal un mensaje como éste:
GOOD: password cracked: ‘aquí_aparece_la_contraseña’
Nos informará de la contraseña y, además, genera un archivo xml en la se conservará.
La orden básica de rarcrack es la ya comentada. No obstante, podemos definir el número de hilos de ejecución de rarcrack para adecuar el proceso a la potencia de nuestro equipo. Este número puede variar entre 1 y 12. En el mismo site oficial nos definen las instrucciones para definir en la orden los ‘threads’ que deseemos.
Homesite: rarcrack.sourceforge.net

Instalación de Prey en GNU/Linux



Ya os hemos hablado anteriormente sobre esta aplicación. Recordemos que se trata de una utilidad multiplataforma (GNU/Linux, Android, Windows, Mac OS) que, tras su instalación y configuración, nos permite rastrear nuestro equipo (hasta 3, de modo gratuito) en caso de robo o pérdida. La mecánica que utiliza Prey se compone de una aplicación local, a instalar en el equipo, y de una web, donde se encuentran las opciones de configuración del servicio y el origen de la información que obtendremos al activar el modo desaparecido para el dispositivo.
(*) Apunte inicial: los pasos descritos a continuación son los seguidos en un sistema GNU/Linux. Sin embargo, veréis que no hay problema alguno en seguirlos si también usáis otros sistemas.

Para empezar, deberemos descargar la aplicación desde la zona de descarga de la web oficial del proyecto. Para GNU/Linux, podemos descargar el .zip para compilar el programa o descargar el paquete .deb preparado para Ubuntu, si utilizáis esta distro.
La primera vez que ejecutemos Prey, nos solicitará nuestra contraseña de root y que configuremos una serie de parámetros para configurar el método de comunicación, de acceso a la red, etc.
It seems this is the first time you run this setup. Please set up your reporting method now, otherwise Prey won’t work!
(Clic para ampliar)
Como veis en la captura, sobre estas letras, hemos marcado dos de las tres opciones: “Enable guest account” y “Wifi autoconnect”.
La primera, tal como leemos en la misma ventana de configuración, aumenta las posibilidades de que Prey trabaje y obtengamos éxito para rastrear nuestro equipo. Imaginemos: tenemos un portátil protegido con un login (usuario + password), como es habitual en sistemas GNU/Linux. En caso de robo, el ladrón lo tendría difícil para usar nuestro sistema, ¿no? Al habilitar la opción “Enable guest account”, le ofrecemos a ese ladrón la posibilidad de usar el sistema y, por tanto, posibilidad de que le rastreemos gracias a Prey.
La segunda opción, “Wifi autonnect”, obligará al sistema a rastrear las redes wifi cercanas al equipo para conectarse a la Red, plataforma que utilizará para que sea localizado por el propietario original del equipo.
En la pestaña “Reporting mode”, el usuario deberá seleccionar el método de comunicación que prefiera. En este caso, seleccionamos el que viene recomendado, “Prey + Control Panel”.
(Clic para ampliar)
Clicamos en “Adelante” (“Forward”, si lo tenéis en inglés) para encontrarnos con lo siguiente:
(Clic para ampliar)
¿Tenemos cuenta en Prey? Si no tenemos cuenta, seleccionamos la opción “New user” y clicamos en “Adelante”. En la siguiente ventana de opciones, tan sólo deberemos rellenar los campos del formulario para crear la cuenta y clicar en “Aplicar”.
Si todo ha ido bien, deberíamos recibir un mail en nuestro correo electrónico para confirmar la creación de la cuenta en Prey. Lo habitual en estos casos: nos dirigimos a nuestra bandeja de entrada del correo para clicar en el link de activación de cuenta. Recibiremos, a continuación, otro correo en el que nos informarán de que el proceso de creación de la cuenta ha sido finalizado con éxito.
(Clic para ampliar)
La captura que veis sobre estas letras es la interfaz principal de nuestra cuenta web en Prey, en el que aparecerán listados todos los dispositivos monitoreados. Al clicar en uno de ellos, encontraremos diferentes opciones, en función del dispositivo en que se encuentra instalada la aplicación. En el caso que ocupa a este tutorial, encontramos las opciones ofrecidas a un portátil.
Obviamente, queda a elección del usuario la configuración del servicio. ¿Queréis que suene una alarma cuando cambiemos el estado del dispositivo a “desaparecido”? Si estáis seguros de que os han robado el portátil, ¿queréis lanzarle mensajes que le informen de que está siendo rastreado? ¿Queréis bloquear el equipo hasta que la contraseña de desbloqueo sea introducida? ¿Queréis ocultar contraseñas, emails, etc? ¿Queréis conocer las conexiones a la Red establecidas? ¿Queréis saber las redes wifi cercanas detectadas? ¿Queréis geolocalizar vuestro equipo gracias al gps interno o gracias a las redes wifi detectadas?
Todas y otras opciones pueden ser configuradas con un par de clics de ratón. Tan sólo debemos pensar muy bien lo que nos conviene, es decir, imaginar un supuesto caso de robo o pérdida y las acciones que llevaríamos a cabo: ¿qué necesitaríamos para intentar recuperar nuestro equipo?
Si queréis hacer una prueba del servicio, tan sólo debéis marcar el equipo como “desaparecido”. Recibiréis inmediatamente un correo parecido al que véis bajo estas letras.
Your device hp-laptop has been marked as missing. Sorry to hear the bad news.
Well, now is the time to keep your eyes open! A new report should arrive in about 20 minutes from now, as long as the device is connected to the Internet.
Deberemos esperar los reportes que serán enviados a vuestra cuenta de correo electrónico. ¡Buena suerte!
Un ejemplo de reporte tras activar el modo “desaparecido”:
(Clic para ampliar)

Autentificación mediante claves públicas en SSH


¿Qué son las claves públicas?

Wikipedia
En criptografía, se denomina una infraestructura de clave pública a una combinación de hardware, software y procedimientos de seguridad que permiten la ejecución con garantías de operaciones criptográficas como el cifrado, la firma digital o el no rechazo de transacciones electrónicas. Para un correcto funcionamiento es necesario que intervengan las siguientes partes:
  • Un usuario iniciador de la operación.
  • Sistemas servidores que dan ocurrencia de la operación y garantizan la validez de los certificados implicados en la operación.
  • Un destinatario de los datos cifrados/firmados/enviados garantizados por parte del usuario iniciador de la operación.

¿Qué objetivo nos marcamos?

El propósito de usar la autentificación mediante claves públicas es sacar el mayor partido posible a SSH mediante el uso de clave privada y pública. De forma que al compartir esta última con el servidor, podamos identificarnos automáticamente, sin necesidad de utilizar el esquema clásico de usuario y contraseña, al que estamos acostumbrados.

¿Qué algoritmos de cifrado usar?

SSH permite usar los algoritmos RSA y DSA, pero… ¿cuál de ellos nos conviene más?
  • RSA – Es un algoritmo asimétrico cifrador de bloques, que utiliza una clave pública, la cual se distribuye y otra privada, guardada en secreto por su propietario.Su funcionamiento reside en el uso de expresiones exponenciales dentro de la aritmética modular. Obteniendo una completa seguridad, debido a que aún no se conocen formas óptimas de factorizar  un número grande en sus factores primos utilizando ordenadores personales.El RSA se basa en dos problemas matemáticos: el problema de factorizar números grandes y el problema RSA. El descifrado completo de un texto cifrado con RSA es computacionalmente intratable.
    Por otro lado la factorización de números grandes proponen métodos para longitudes de 600-700 bits de longitud. Y generalmente, las claves RSA usan entre 1024-2048 bits.
  • DSA – (Digital Signature Algorithm o Algoritmo Estándar de Firmado) es el algoritmo de firmado digital incluido en el DSS (Digital Signature Standard o Estándar de Firmas Digitales) del NIST Norteamericano. Está basado en el problema de los logaritmos discretos y únicamente puede emplearse para las firmas digitales. A diferencia del RSA, que puede emplearse también para encriptar.La elección de este algoritmo como estándar de firmado generó multitud de críticas puesto que perdía bastante flexibilidad respecto al RSA.
La diferencia entre ambos reside en los tiempos obtenidos para la generación, firmado y comprobación de las claves públicas. Usando este benchmark (podéis usar cualquier IDE con la última versión del JDK) se obtuvieron los siguientes tiempos:
Algoritmo
Generación de llaves * 1(ms.)
Firmado * 100 (ms.)
Verificación*100(ms.)
RSA 512 544.61 915 160
RSA 1024 1120.46 4188 263
DSA 512 6.62 634 988
DSA 1024 17.87 1775 3397
El algoritmo DSA es más rápido para generar la firma que para verificarla, al contrario de lo que sucede con RSA. Por lo que para realizar la autentificación en nuestro servidor SSH usaremos este último.
Además, si comparamos el tamaño de las llaves generadas por ambos algoritmos, comprobaremos cómo las utilizadas por RSA son superiores a las de DSA.
Dicho esto, usaremos RSA.

Configuración del servidor

Comprobamos si el equipo donde tenemos instalado sshd tiene activada la versión 2 del protocolo SSH y que esté habilitada la opción para utilizar claves RSA. Para ello buscamos las siguientes directivas en el fichero /etc/ssh/sshd_config:
Protocol 2
RSAAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

Para cada usuario que vaya a conectarse, debe existir el directorio /home/usuario/.ssh y en él el archivo authorized_keys. En caso de no ser así deberemos crearlo de forma manual y posteriormente iniciar el servidor.
cd ~
mkdir .ssh
touch .ssh/authorized_keys
sudo /etc/init.d/sshd start

Generación de los pares de claves RSA

Como antes comentamos, SSH nos permite generar indistintamente claves RSA o DSA (en nuestro caso usaremos la mencionada en primer lugar), creándose para ambas una clave pública y una clave privada.
Dichas claves, pueden generarse en el propio servidor, en el ordenador cliente, o en cualquier otra máquina.
Al final sólo la clave pública debe aparecer en el fichero .ssh/authorized_keys del servidor al que queremos conectarnos.
El usuario interesado en generar el par de claves usará ssh-keygen. En el proceso, se nos pedirá introducir un passphrase, lo que viene a ser una contraseña para poder generar unas claves más fuertes y seguras.
En nuestro caso, vamos a usarla y a explicar posteriormente como indicarle al sistema que sólo nos la pida una vez por sesión, y no cada vez que nos autentifiquemos en el sistema.
$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/sebas/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/sebas/.ssh/id_rsa.
Your public key has been saved in /home/sebas/.ssh/id_rsa.pub.
The key fingerprint is:
63:de:92:6d:00:fa:d9:17:55:45:ce:bc:25:42:8b:4c sebas@TheWorkstation
The key's randomart image is:
+--[ RSA 2048]----+
| E . .oo|
| o o o + |
| . o + . =|
| . . . . .o|
| . S . . |
| . = * . |
| o = = |
| + |
| |
+-----------------+

El anagrama que produce esta versión de ssh-keygen, se denomina randomart y se trata de una representación visual de la huella
Notebookcheck- AMD ATI Mobility Radeon HD 4570_1245224146636
digital de nuestra clave, para que sea más legible para el ojo humano y para dispositivos ópticos.
Si lo deseas, puedes usar la herramienta visprint que a través de técnicas de fractales, te permitirá obtener otro tipo de randomart.

Instalación de clave pública y protección de la clave privada

Para validar todo este proceso es necesario colocar nuestra clave pública en el servidor donde tenemos pensado autentificarnos.
Existen varias posibilidades de hacerlo, una de ellas es por ejemplo hacer uso del siguiente comando (Cliente):
[usuario1@localhost usuario1]$ ssh usuario @host_remoto \'cat >> .ssh/authorized_keys' < .ssh/id_dsa.pub
Con este comando añadimos directamente la clave al fichero authorized_keys del servidor remoto de forma automática, ahorrándonos así un poco de trabajo.
También podemos usar (Cliente):
$ ssh-copy-id usuario_remoto@host_remoto
Pero ya que estamos haciendo todo con paso firme y decidido, continuemos haciendo las cosas con buen pie. Así que vamos a usar el comando scp, que trae incluido OpenSSH para hacer una transacción de ficheros entre el cliente y el servidor remoto de la forma más segura posible. Así que usaremos la siguiente orden (Cliente)
$ cd ~/.ssh
$ scp id_rsa.pub usuario@host_remoto/

Recuerda que la clave pública debe ser incluída en el fichero ~/.ssh/authorized_keys de cada máquina donde queramos usar dicha autentificación.
Ahora que ya tenemos la clave pública en el servidor, falta añadirla al fichero authorized_keys de éste (algo que comentamos anteriormente que se podría conseguir de forma directa utilizando el primer comando) (Servidor).
$ cd ~/.ssh
$ cat id_rsa.pub >> authorized_keys
$ shred -v  --remove id_rsa.pub

Conclusión

Si has realizado correctamente todos los pasos que se han ido indicando, ahora podrás conectarte a tu servidor SSH (Si no tienes uno, visita ésta entrada donde te explicamos cómo montar uno) sin necesidad de identificarte, tan sólo haciendo uso de las claves RSA que has generado.
También puedes incrementar un poco la seguridad modificando las siguientes directivas de tu fichero de configuración sshd_config:
PasswordAuthentication no
PermitRootLogin no

Con las que impedirás la conexión como administrador y la autentificación mediante password para los usuarios.

Ubuntu limpio, con un script

Os dejo este script que nos a pasado un zonero, para automatizar la limpieza en Ubuntu.

Lo que hace este script, básicamente es:
Limpiar residuos de programas instalados o desinstalados y borrar sus antiguas configuraciones. También borra todas las entrada antiguas de tu Kernel, y por ultimo limpia tu papelera.
Para crearlo, solo tienes que copiar las lineas de abajo, y ponerlas en tu editor preferido. En el nombre pones el que quieras, con la extensión .sh, es este caso, limpia.sh, como ejemplo .


Cita:


#!/bin/bash

OLDCONF=$(dpkg -l|grep "^rc"|awk '{print $2}')
CURKERNEL=$(uname -r|sed 's/-*[a-z]//g'|sed 's/-386//g')
LINUXPKG="linux-(image|headers|ubuntu-modules|restricted-modules)"
METALINUXPKG="linux-(image|headers|restricted-modules)-(generic|i386|server|common|rt|xen)"
OLDKERNELS=$(dpkg -l|awk '{print $2}'|grep -E $LINUXPKG |grep -vE $METALINUXPKG|grep -v $CURKERNEL)
YELLOW="\033[1;33m"
RED="\033[0;31m"
ENDCOLOR="\033[0m"

if [ $USER != root ]; then
echo -e $RED"Error: must be root"
echo -e $YELLOW"Exiting..."$ENDCOLOR
exit 0
fi

echo -e $YELLOW"Cleaning apt cache..."$ENDCOLOR
aptitude clean

echo -e $YELLOW"Removing old config files..."$ENDCOLOR
sudo aptitude purge $OLDCONF

echo -e $YELLOW"Removing old kernels..."$ENDCOLOR
sudo aptitude purge $OLDKERNELS

echo -e $YELLOW"Emptying every trashes..."$ENDCOLOR
rm -rf /root/.local/share/Trash/*/** &> /dev/null

echo -e $YELLOW"Script Finished!"$ENDCOLOR




Para ejecutarlo, primero tienes que darle permisos de ejecución, tienes dos formas de hacerlo:

En modo gráfico; Click derecho con el ratón, al archivo, /Propiedades, pestaña permisos, y marcar la casilla ejecutar el archivo como un programa.
Una vez hecho esto, podemos ejecutar el archivo:
Arrastra el archivo hasta una consola abierta, o bien, botón derecho del ratón sobre el archivo, y ejecutar, o ejecutar en consola.

En consola:
En la linea de comandos, nos situamos en el directorio del archivo, y para darle permisos tecleamos:
chmod -c 744 limpia.sh
Y para su ejecución:
sudo ./limpia.sh

convertir ficheros .flv a mpeg o .avi

Cuando nos descargamos videos desde YouTube y otras webs del estilo, vemos que vienen en el formato .flv, formato que no es muy amigable al momento de editar video. Pues lo que hacemos normalmente es convertir el video a uno “más amigable” como mpeg o avi. Las opciones para convertir archivos de un formato a otro son variadas, pero nada comparado con la sencillez y potencia del terminal.
Primero deberiamos de asegurarnos que tenemos lo necesario para convertir los archivos, tecleando:
$ sudo apt-get install ffmpeg
Una vez instalado el ffmpeg vamos a convertir los archivos .flv en .mpeg y .avi.
Abrimos un terminal en el lugar donde tienes el archivo .flv y tecleamos:
$ ffmpeg -i tu_archivo.flv tu_nuevo_archivo.mpeg
$ ffmpeg -i tu_archivo.flv tu_nuevo_archivo.avi

Conectate a tu WiFi desde la terminal en Ubuntu

Cuando falla la parte gráfica, siempre nos queda la terminal, así que con estos sencillos pasos podemos ver como conectarnos a una red wifi:

Se desactiva el siguiente servicio por que si no tendremos problemas:


Código:
#/etc/init.d/NetworkManager stop



Escanear puntos de acceso:

Código:
#iwlist wlan0 scan


Código:
wlan0 Scan completed :
Cell 01 – Address: 00:02:CF:CE:BB:9D
ESSID:”WLAN_43″
Mode:Master
Encryption key:on
Channel:9
Quality:32/100 Signal level:-78 dBm Noise level:-91 dBm
Cell 02 – Address: 00:1F:C6:18:4E:85
ESSID:”Net Casa”
Mode:Master
Encryption key:off
Channel:6
Quality:100/100 Signal level:-47 dBm Noise level:-89 dBm
Cell 03 – Address: 00:24:01:E6:F2:4F
ESSID:”ONOF250″
Mode:Master
Encryption key:on
Channel:3
Quality:7/100 Signal level:-87 dBm Noise level:-90 dBm


Ya tenemos la lista, ejecutándolo en el la terminal viene tabulado y queda más bonito.

Si tenemos WEP

Código:
#iwconfig wlan0 essid mi_wifi


Código:
#iwconfig wlan0 key clave-de-acceso


Si tenemos WPA

Código:
#wpa_passphrase mi_wifi clave-de-acceso > /home/usuario/wpa.conf

(cambiar el usuario por el nombre que tengas)


Código:
#wpa_supplicant -B -Dwext -iwlan0 -c/home/usuario/wpa.conf


Asignamos DHCP y a correr:

Código:
#dhclient -r (limpiar)


Código:
#dhclient wlan0

Controla tu ventilador con Lm-sensors en Ubuntu



 
 

Lm-sensors, en su modo grafico, como ya es bien conocido, tiene varias opciones para monitorear tus temperaturas y uso de Cpu, e incluso hacer un pequeño "reescalado" de tu procesador.
Lo que no es tan conocido, es que tambien puedes cambiar el comportamiento de tu ventilador o ventiladores.


sudo apt-get install lm-sensors - para instalarlo
sudo sensors-detect - para configurarlo
sensors - para ver las temperaturas

Una vez echo esto, controla tus ventiladores:

sudo pwmconfig - para crear el archivo de configuración
sudo fancontrol - para ejecutar el programa

Hay que tener cuidado en la configuración, y no no bajar de la temperatura mínima que marque tu procesador.

sudo fancontrol - Cargamos el archivo de configuración /etc/fancontrol ...

Common settings:
INTERVAL=10

Settings for 0-0290/pwm2:
Depends on 0-0290/temp2_input
Controls 0-0290/fan2_input
MINTEMP=30
MAXTEMP=55
MINSTART=120
MINSTOP=100

Con esto activamos PWM o modulación por ancho de pulso en los ventiladores...

De nuevo...
sensors
w83627thf-isa-0290
Adapter: ISA adapter
VCore: +1.49 V (min = +1.30 V, max = +1.44 V) ALARM
+12V: +12.22 V (min = +10.82 V, max = +13.19 V)
+3.3V: +3.39 V (min = +3.14 V, max = +3.47 V)
+5V: +5.07 V (min = +4.75 V, max = +5.25 V)
-12V: -14.91 V (min = -10.80 V, max = -13.18 V)
V5SB: +5.13 V (min = +4.76 V, max = +5.24 V)
VBat: +0.00 V (min = +2.40 V, max = +3.60 V)
fan1: 2163 RPM (min = 168750 RPM, div = 4)
CPU Fan: 0 RPM (min = -1 RPM, div = 4)
fan3: 0 RPM (min = -1 RPM, div = 8 )
M/B Temp: +27°C (high = +0°C, hyst = +2°C) sensor = thermistor
CPU Temp: +37.5°C (high = +80°C, hyst = +75°C) sensor = thermistor
temp3: -48.0°C (high = +80°C, hyst = +75°C) sensor = thermistor
vid: +1.375 V (VRM Version 9.0)
alarms:
beep_enable:
Sound alarm enabled

Nota: Esta es una salida de muestra, con los sensores mas probables.

si queremos que se ejecute cada vez que arrancamos el sistema:

sudo vi /etc/init.d/fancontrol - para crear el archivo

#!/bin/bash
fancontrol&

sudo chmod +x /etc/init.d/fancontrol - para darle permisos de ejecución

sudo update-rc.d /etc/init.d/fancontrol - para ejecutarlo al inicio

sudo rm /etc/rc0.d/K20fancontrol && sudo rm /etc/rc6.d/K20fancontrol
- para que se desactive al apagar y reiniciar el sistema

En el caso de tener algún problema con este tipo de instalación, en: ubuntuforums.org ,dan otra solución, basada en powersaved, que aunque parezca antigua, funciona!!. Cosas de Linux. Tranquilo

SOLUCION AL BUG DE LMSENSORS.

Muchos usuarios, al lanzar el comando pwmconfig , reciben el siguiente mensaje, There are no pwm-capable sensor modules installed , y no pueden seguir. La solucion es añadir acpi_enforce_resources=lax a nuestro Grub.

Ejecutamos:
sudo gedit /etc/default/grub

y en la linea

GRUB_CMDLINE_LINUX=""

ponemos entre las comillas

acpi_enforce_resources=lax

actualizamos el Grub

sudo update-grub

Y ya podemos seguir con la configuración. Guiño

Saludos.

Conectar iPhone o iPad a una VPN IPsec con FortiGate

En este documento veremos las configuraciones necesarias para poder conectar un dispositivo iPad o iPhone a una VPN con IPsec de FortiGate, con esto podremos hacer que las aplicaciones corporativas de nuestros iPad/iPhone funcionen directamente, ideal para ponerle alguna aplicación tipo softphone y llamar (o recibir llamadas) directamente desde dichos dispositivos, ahorrando los costos de las llamadas o estando 100% disponibles,

Podremos apoyarnos si necesitamos en estos documentos anteriores, ya que en este documento describiremos unicamente la parte de VPN y no hablaremos si son usuarios locales del FortiGate o autenticamos contra un LDAP:
i) Hacer una VPN con IPSEC en Fortigate y conectarse con FortiClient – AKI.
ii) Uso de autenticación de un Fortigate contra Directorio Activo usando LDAP – AKI.
Requisitos: necesitaremos cualquier FortiGate con FortiOS superior o igual a 4.0 MR1 Patch 1 y cualquier dispositivo iPad o iPhone con conectividad Wifi o 3G.


Deberemos crear la fase 1 y la fase 2 desde “VPN” > “IPsec” > “Auto Key (IKE)”, primero desde “Create Phase 1″ & a posteriori “Create Phase 2″,


En la Phase 1 deberemos indicarle un nombre, indicar que el ‘Remote Gateway’ será “Dialup User”, indicaremos en ‘Local Interface’ la WAN desde la que se accederá, el ‘Mode’ seleccionamos “Main (ID protection)” en ‘Authentication Method’ indicaremos con “Preshared Key” e indicamos la clave que nos interesará. En ‘Peer Options’ marcamos “Accept any peer ID”. En las opciones avanzadas indicaremos ‘IKE version’ a “1″, en ‘Local Gateway IP’ marcamos “Main Interface IP”, en las primera encriptación marcaremos “AES256″ & en la autenticación “MD5″; en el segundo método de encriptación “AES256″ y en la autenticación “SHA1″; en ‘DH Group’ será “2″, el ‘Keylife’ “28800″ segundos. En XAUTH marcamos “Enable as Server”, ‘Server Type’ será “AUTO”, agregamos el grupo de usuarios que queremos que se conecte a dicha VPN, habilitamos el ‘NAT Traversal’ y el ‘Dead Peer Detection’.


Creamos la Phase 2, seleccionaremos la fase 1 que acabamos de configurar. En las opciones avanzadas marcaremos de igual forma la encriptación y la autenticación, primero será “AES256″ con “MD5″ y segundo “AES256 con “SHA1″, habilitamos ‘Replay detection’ y ‘Perfect forward secrecy (PFS), en el ‘DH Group’ marcamos “2″, indicamos “1800″ segundos para el ‘Keylife’, habilitamos ‘Autokey Keep Alive’ y en ‘Quick mode selector’ en ‘Source address’ y en ‘Destionation Address’ indicaremos “0.0.0.0/0″.


Como de costumbre una vez configurada la VPN deberemos crear una regla de firewall en “Policy” > “Policy”, especificaremos en ‘Source Interface/Zone’ la VPN recién creada, así como en ‘Source Address’ la red que tengamos definida para la VPN; en ‘Destination Interface/Zone’ indicaremos a donde queremos que se conecten y en ‘Destination Address’ la red a la que se conectarán. Indicaremos cuándo queremos que se conecten en ‘Schedule’ y en ‘Service’ los servicios/puertos que querramos permitir, finalmente en ‘Action’ marcaremos “ACCEPT” & “OK” para guardar.


Si tenemos más reglas de FW, ésta la tendremos que colocar arriba del todo para darle más prioridad.


Y configuramos el DHCP para la red VPN por línea de comandos, con:
config vpn ipsec phase1-interface
edit NOMBRE_PHASE_1
set mode-cfg enable
set ipv4-start-ip IP_ORIGEN
set ipv4-end-ip IP_DESTINO
set ipv4-netmask MASCARA_DE_RED


Ahora, desde un iPhone o iPad, desde “Ajustes” > “General” > “Red” > “VPN” configuraremos la nueva conexión desde “Añadir configuración VPN…”


E introducimos los datos necesarios para conectarnos, una descripción, el servidor VPN (nombre público) al que nos conectaremos, un usuario con permisos para conectarse en la VPN junto a su contraseña y en el ‘Secreto’ indicaremos la Preshared key introducida en la config de la VPN.