Programming

Servers package difference => “dpkg-diff”

0
7 months ago
by olafrv in , ,
Share|

Problem

You have two linux servers A and B, you want to know what installed packages are not in both servers (A-B joined with B-A).

Solution

The following script (dpkg-diff.sh, tested on GNU/Linux Debian Lenny/Squeeze).

dpkg-query command and a ssh server must be installed on both servers.

?View Code BASH
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

###
# FILE: dpkg-diff.sh
# AUTHOR: Olaf Reitmaier <olafrv@gmail.com>
# LICENSE: GNU/GPL v3 (Visit www.gnu.org for more info)
# USAGE: Servers package difference => "dpkg-diff"
# WARNING: Modify header vars according to your needs.
##
 
# Header variables
 
s1=server1.example.com
s2=server2.example.com
u1=testuser
u2=$u1
# Exclude lib* packages
ft="-v ^lib"
f1=/tmp/dpkg-diff.1
f2=/tmp/dpkg-diff.2
 
# Do not edit this lines unless you know what your doing!
 
ssh $u1@$s1 "dpkg-query --list" | grep '^ii' | awk '{print $2}' > $f1
ssh $u2@$s2 "dpkg-query --list" | grep '^ii' | awk '{print $2}' > $f2
 
clear
 
echo "Only in $s1"
 
cat $f1 | grep $ft | sort | while read package
do
	if [ $(cat $f2  | grep $package | wc -l) -eq 0 ]
	then
		echo -n "$package "
	fi
done
echo
echo
 
echo "Only in $s2"
 
cat $f2 | grep $ft | sort | while read package
do
	if [ $(cat $f1 | grep $package | wc -l) -eq 0 ]
	then
		echo -n "$package "
	fi
done
echo
echo

DKIM en Postfix con GNU/Linux Debian

0
1 year ago
by olafrv in , ,
Share|

Introducción

DKIM (Domain Key Identified Email) es un mecanismo de seguridad que permite la autenticación de mensajes de correo electrónico, descrito en el RFC-5585 disponible en http://www.dkim.org/specs/rfc5585.html.

El mecanismo DKIM consiste en utilizar una infraestructura de claves públicas (certificados) y privadas para en principio firmar y posteriomente autenticar un mensaje de correo electrónico.

Los certificados están asociados a dominio (@example.com) o para direcciones de correo electrónico específicas (*@example.com, me@example.com).

Los mensajes salientes son firmados por el emisor, tomando un conjunto de encabezados (headers) aplicando un algoritmo hash con una clave privada para generar una encabezado (DKIM-Signature) que se añade al mensaje.

Los mensajes entrantes son verificados si contienen un encabezado de firma donde se especifica que clave pública consultar vía DNS para realizar la verificación.

Instalación y configuración de Debian para uso con Postfix

Para empezar suponemos que tenemos instalado y configurado en un servidor el servicio Postfix para el dominio “example.com”, en ese mismo servidor se configurará el servicio DKIM aunque esto no es obligatorio.

Instalar el paquete dkim-filter:

?View Code BASH
1

apt-get install dkim-filter

Si no se han generado las claves publicas y privadas, se debe generar una clave de prueba (test) que sirve para depurar y omitir error sin rechazar los correo electrónico, y una clave para producción (“default” en nuestro caso, aunque pueden generarse cuantas sean necesarias).

Primero creamos una carpeta que contendrá las claves públicas y privadas de nuestro dominio “example.com”:

?View Code BASH
1
2

mkdir -p /etc/dkim/keys/example.com
cd /etc/dkim/keys/example.com

Gereramos la clave de prueba y de producción respectivamente:

?View Code BASH
1
2

dkim-genkey -d example.com -r -s test -t
dkim-genkey -d example.com -r

El parametro -s indica que la clave de prueba será nominada con el selector “test” y la clave de producción como se especificó será nominada con el selector “default”.

Las claves públicas y privadas generadas en el directorio:

?View Code BASH
1
2
3
4
5
6

$ ls -l 
total 16
-rw------- 1 root root 887 Sep 21  2011 default.private
-rw------- 1 root root 308 Sep 21  2011 default.txt
-rw------- 1 root root 887 Sep 21  2011 test.private
-rw------- 1 root root 307 Sep 21  2011 test.txt

Se almacenan con la extensión “.private” mientras que los registros DNS en formato para bind9 se almacenan en los archivos “.txt” con el siguiente formato:

v=DKIM1; g=*; k=rsa; p=

Para publicar los certificados se deben crear dos (2) registros DNS tipo TXT para los nombres de servidores siguientes:

  1. El nombre “test._domainkey” del dominio “example.com” con el contenido del
    archivo “test.private”.
  2. El nombre “default._domainkey” del dominio “example.com” con el contenido
    del archivo “default.private”.

Una vez creado los registros DNS anteriores, la consulta DNS (usando el comando nslookup) para los nombres “default._domainkey” y “test._domainkey” del dominio “example.com” debe arrojar los siguientes resultados:

?View Code BASH
1
2
3
4
5
6
7
8
9

$ nslookup -type=txt test._domainkey.tsj-dem.gob.ve 200.44.32.12
Server:  200.44.32.12
Address: 200.44.32.12#53
test._domainkey.tsj-dem.gob.ve text = "v=DKIM1\; g=*\; k=rsa\; t=y\; p=<clave>"
 
$ nslookup -type=txt default._domainkey.tsj-dem.gob.ve 200.44.32.12
Server:  200.44.32.12
Address: 200.44.32.12#53
default._domainkey.tsj-dem.gob.ve text = "v=DKIM1\; g=*\; k=rsa\; p=<clave>"

Es importante indicar que la expresión es sensible a mayúsculas y minúsculas tanto en el archivo como en la consulta DNS el resultado debe ser el mismo.

Pero para garantizar que los selectores funcionen correctamente deben eliminarse la extensión “.private” o crear link simbólicos porque los nombres contentivos de la clave pública deben ser iguales a los nombres de los selectores:

?View Code BASH
1
2
3
4
5
6
7
8

$ ls -l 
total 16
lrwxrwxrwx 1 root root  15 Apr  9 16:32 default -> default.private
-rw------- 1 root root 887 Sep 21  2011 default.private
-rw------- 1 root root 308 Sep 21  2011 default.txt
lrwxrwxrwx 1 root root  12 Apr  9 16:32 test -> test.private
-rw------- 1 root root 887 Sep 21  2011 test.private
-rw------- 1 root root 307 Sep 21  2011 test.txt

En el archivo de configuración del servicio DKIM en la ruta /etc/dkim-keys.conf:

*@example.com:example.com:/etc/dkim/keys/example.com/test

En el archivo principal de configuración del servicio DKIM /etc/dkim-filter.conf:

Syslog yes
X-Header yes
LogWhy yes
#On-BadSignature accept
#On-DNSError accept
#On-InternalError accept
#On-NoSignature accept
#On-Security accept
On-Default accept

En Debian es modificar el archivo /etc/default/dkim-filter:

SOCKET=”inet:8891@localhost”

Finalmente, activamos el servicio DKIM:

?View Code BASH
1

/etc/init.d/dkim start

Verificar los registros:

?View Code BASH
1

/var/log/syslog | grep -i dkim

Para indicarle a Postfix que debe firmar los correos simplemente colocamos
en el archivo configuración /etc/postfix/main.cf:

# Firma Electrónica – DKIM
milter_default_action = accept
# Postfix ≥ 2.6
milter_protocol = 6
# 2.3 ≤ Postfix ≤ 2.5
#milter_protocol = 2
smtpd_milters = inet:localhost:8891
non_smtpd_milters = inet:localhost:8891

Ahora debemos reiniciar Postfix y realizar algunas pruebas:

  • Enviar un correo a GMAIL y verificar los encabezados DKIM-Signature y Authentication-Result.
  • Seguir las instrucciones del siguiente asisten de verificación de correo electrónico: http://www.brandonchecketts.com/emailtest.php

Para entender mejor el funcionamiento y procedimiento descritos sobre DKIM a continuación consulte y utilice los recursos siguientes:

- Página Principal del Proyecto DKIM (www.dkim.org)
- Fork del Proyecto DKIM (www.opendkim.org)
- http://www.dkim.org/specs/rfc5585.html
- http://www.debiantutorials.com/setup-domainkeys-identified-mail-dkim-in-postfix/
- http://staff.blog.ui.ac.id/jp/2009/04/07/creating-dkim-on-debian-50/
- http://www.brandonchecketts.com/emailtest.php

Enviar correo electrónico desde PostgreSQL con PERL

0
1 year ago
by olafrv in ,
Share|

Para poder enviar correos desde PostgreSQL en GNU/Linux existe una forma sencilla de hacerlo, un script PERL disponible dentro del manejador de base de datos a través de una función.

Requerimientos

  • Todo esto ha sido probado en GNU/Linux Debian Squeeze 6.0
  • Instalar el módulo de PERL “Mail::Sender”: apt-get install libmail-sender-perl
  • Instalar “PLPERL” apt-get install postgresql-plperl-8.3. Para mayor información visite: http://www.postgresql.org/docs/8.3/static/plperl.html
  • Un servidor de correos local (opcional si tenemos otro servidor) instalado y configurado (por defecto): sendmail, exim4 o postfix.

Manos a la obra

Debemos cargar el contenido del archivo pgmail.sql y pgmailt.sql que se muestan debajo, para crear la función de envío de correo y hacer pruebas, respectivamente.

?View Code BASH
1
2
3

root# su - postgres
postgres$ psql < pgmail.sql 
postgres$ psql < pgmailt.sql

Creación de la función “pgmail”

El archivo pgmail.sql contiene lo siguiente:

?View Code SQL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

\c A;
-- CREATE LANGUAGE plperlu;
CREATE OR REPLACE FUNCTION pgmail(text, text, text, text) RETURNS INTEGER AS $$
 
$from_address = $_[0];
$to_address = $_[1];
$subject = $_[2];
$body = $_[3];
 
#$reply_to = 'no-reply@localhost.localdomain';
$server = 'localhost';
 
use Mail::Sender;
$sender = new Mail::Sender
	{
		smtp => $server, 
		from => $from_address
	};
$rc = $sender->MailMsg(
	{
	#	replyto => $reply_to,
		to => $to_address,
		subject => $subject,
		msg => $body
	}
);
 
if(ref($rc)){
        return 0;
}else{
	elog(ERROR, $sender->{'error_msg'});
	return $sender->{'error'};
}
 
$$ LANGUAGE plperlu VOLATILE STRICT;

Prueba de “pgmail”

El archivo pgmailt.sql contiene lo siguiente:

?View Code SQL
1
2

\c A;
select pgmail('me@localhost.localdomain', 'olafrv@gmail.com,olafrv@cantv.net','Mail desde postgres', 'Test!!!');
Go to Top
?>