postfwd1 - Online en la nube

PROGRAMA:

NOMBRE

postfwd - demonio de firewall postfix

SINOPSIS

postfwd [OPCIONES] [FUENTE1, FUENTE2, ...]

Conjunto de reglas: (al menos uno, se permite el uso múltiple):
-f, --archivo lee las reglas de
-r, --regla agrega configurar

Puntuación:
-s, --puntajes = devoluciones cuando la puntuación supera

Controlar:
-d, --daemon ejecuta postfwd como demonio
-k, --kill detiene al demonio
--recargar recarga la configuración
--dumpstats muestra estadísticas de uso
--dumpcache muestra el contenido de la caché
--delcache elimina un elemento de la caché de solicitudes
--delrate elimina un elemento del caché de tarifas

Networking:
-i, --interfaz escuchar en la interfaz
-p, --port escuchar en el puerto
--proto tipo de socket (tcp o unix)
-u, --usuario establecer uid en usuario
-g, --grupo establecer gid en grupo
--umask establecer umask para permisos de archivo
-R, --chroot chroot el demonio para
--pidfile crear pidfile bajo
--instalaciones instalación de syslog
--socktype syslog socktype
-l, - etiqueta de nombre de registro para mensajes de syslog
--loglen trunca los registros del sistema después de caracteres

Almacenamiento en caché:
-c, --caché establece el tiempo de espera de la caché de solicitud en segundos
--cache-no-size ignora el atributo de tamaño para el almacenamiento en caché
--cache-no-sender ignora la dirección del remitente en la caché
--cache-rdomain-only ignora la parte local de la dirección del destinatario en la caché
--cache-rbl-timeout tiempo de espera rbl predeterminado, si no se especifica en el conjunto de reglas
--cache-rbl-default patrón de respuesta rbl predeterminado para que coincida (regexp)
--cacheid , .. lista de atributos para el identificador de caché de solicitud
--cleanup-solicita el intervalo de limpieza en segundos para la caché de solicitudes
--cleanup-rbls intervalo de limpieza en segundos para la caché rbl
- intervalo de limpieza de tasas de limpieza en segundos para la caché de tasas

Opcional:
-t, --test testing, siempre devuelve "no sé"
-v, --logging verbose verbose, use dos veces (-vv) para aumentar el nivel
-S, --resumen mostrar algunas estadísticas de uso cada segundos
--norulelog deshabilita el registro de reglas
--norulestats inhabilita las estadísticas por regla
--noidlestats deshabilita las estadísticas cuando está inactivo
-n, --nodns deshabilitar dns
--nodnslog deshabilitar el registro de dns
--dns_async_txt realiza búsquedas de dnsbl A y TXT simultáneamente
--dns_timeout tiempo de espera en segundos para consultas dns asincrónicas
--dns_timeout_max máximo de tiempos de espera de dns hasta que se desactive un dnsbl
--dns_timeout_interval intervalo en segundos para el contador máximo de tiempo de espera dns
--dns_max_ns_lookups nombres máximos para buscar con sender_ns_addrs
--dns_max_mx_lookups nombres máximos para buscar con sender_mx_addrs
-I, --instantcfg vuelve a leer los archivos de reglas para cada nueva solicitud
--config_timeout
--keep_rates no borra los contadores de límite de velocidad en la recarga
--save_rates guardar y cargar límites de velocidad en el disco
--fast_limit_evaluation evalúa los límites de velocidad antes de analizar el conjunto de reglas
(tenga en cuenta las limitaciones)

plugins:
--enchufes carga los complementos de postfwd desde el archivo

Informativo (¡utilícelo solo en la línea de comandos!):
-C, --showconfig muestra el resumen del conjunto de reglas, -v para verbose
-L, --stdoutlog redirige los mensajes de syslog a stdout
-P, --perfmon sin syslogging, sin stdout
-V, --version muestra la versión del programa
-h, --help muestra el uso
-m, --manual muestra el manual del programa

DESCRIPCIÓN

INTRODUCCIÓN
postfwd está escrito para combinar restricciones de postfijo complejas en un conjunto de reglas similar a los
de la mayoría de los cortafuegos. El programa utiliza el protocolo de delegación de políticas postfix para controlar
acceder al sistema de correo antes de que se acepte un mensaje (visite
<http://www.postfix.org/SMTPD_POLICY_README.html> para más información).

postfwd le permite elegir una acción (por ejemplo, rechazar, no sé) para una combinación de varias
parámetros smtp (como la dirección del remitente y del destinatario, el tamaño o la huella dactilar TLS del cliente).
También ofrece macros / acls simples que deberían permitir una lectura sencilla y sencilla.
configuraciones.

Características:

* Combinaciones complejas de parámetros smtp

* Búsquedas combinadas de RBL / RHSBL con acciones arbitrarias según los resultados

* Sistema de puntuación

* Reglas basadas en fecha / hora

* Macros / ACL, grupos, negación

* Comparar los atributos de la solicitud (por ejemplo, client_name y helo_name)

* Almacenamiento en caché interno para solicitudes y búsquedas de dns

* Estadísticas integradas para el análisis de la eficiencia de las reglas

CONFIGURACIÓN
Una línea de configuración consta de pares opcionales elemento = valor, separados por punto y coma (`;`)
y la acción deseada apropiada:

[ = ; = ; ...] acción =

Ejemplo:

dirección_cliente = 192.168.1.1; remitente ==[email protected] ; acción = RECHAZAR

Esto negará todo el correo de 192.168.1.1 con el remitente del sobre. [email protected]. El orden de
los elementos no son importantes. Entonces, lo siguiente conduciría al mismo resultado que el
ejemplo anterior:

acción = RECHAZAR; dirección_cliente = 192.168.1.1; remitente ==[email protected]

La forma en que se comparan los elementos de la solicitud con el conjunto de reglas se puede influir en lo siguiente
camino:

================================================== ==================
ARTÍCULO == VALOR verdadero si ARTÍCULO es igual a VALOR
ARTÍCULO => VALOR verdadero si ARTÍCULO> = VALOR
ARTÍCULO = <VALOR verdadero si ARTÍCULO <= VALOR
ELEMENTO> VALOR verdadero si ELEMENTO> VALOR
ARTÍCULO <VALOR verdadero si ARTÍCULO <VALOR
ELEMENTO = ~ VALOR verdadero si ELEMENTO ~ = / ^ VALOR $ / i
ARTÍCULO! = VALOR falso si ARTÍCULO es igual a VALOR
ELEMENTO!> VALOR falso si ELEMENTO> = VALOR
ELEMENTO! <VALOR falso si ELEMENTO <= VALOR
ELEMENTO! ~ VALOR falso si ELEMENTO ~ = / ^ VALOR $ / i
ARTÍCULO = VALOR comportamiento predeterminado (consulte la sección ARTÍCULOS)
================================================== ==================

Para identificar reglas únicas en sus archivos de registro, puede agregar un identificador único para cada uno de
ella:

id = R_001; acción = RECHAZAR; dirección_cliente = 192.168.1.1; remitente ==[email protected]

Puede utilizar estos identificadores como destino para el `salto()`comando (ver sección ACCIONES
debajo). Se ignorarán los espacios en blanco iniciales o finales. Utilice '#' para comentar su
configuración. Otros lo agradecerán.

Un conjunto de reglas consta de una o varias reglas, que se pueden cargar desde archivos o pasar como
argumentos de la línea de comandos. Consulte la sección LÍNEA DE COMANDOS a continuación para obtener más información sobre
este tema.

Dado que postfwd versión 1.30, las reglas que abarcan varias líneas se pueden definir mediante el prefijo
las siguientes líneas con uno o varios caracteres de espacio en blanco (o '}' para macros):

id = RULE001
dirección_cliente = 192.168.1.0 / 24
remitente ==[email protected]
acción = RECHAZAR sin acceso

Las versiones de postfwd anteriores a la 1.30 requieren el final de ';' y '\' - caracteres:

id = RULE001; \
dirección_cliente = 192.168.1.0 / 24; \
remitente ==[email protected]; \
acción = RECHAZAR sin acceso

ARTÍCULOS
id: una identificación de regla única, que se puede utilizar para el análisis de registros
Los identificadores también sirven como objetivos para el comando "saltar".

fecha, hora: una hora o un rango de fechas dentro de la regla especificada debe coincidir
# FORMATO:
# 29 de febrero
fecha = 29.02.2008
# 24 al 26 de diciembre
fecha = 24.12.2008-26.12.2008
# desde hoy hasta el 23 de noviembre
fecha = -23.09.2008
# desde el 1 de abril hasta hoy

fecha = 01.04.2008-
días, meses: un rango de días de la semana (dom-sáb) o meses (enero-diciembre)
dentro de la regla especificada debe acertar

puntuación: cuando se alcanza la puntuación especificada (consulte la sección ACCIONES)
la acción especificada será devuelta a postfix
¡las puntuaciones se establecen a nivel mundial hasta que se redefinen!

request_score: este valor permite acceder a la puntuación de una solicitud. eso
se puede utilizar como variable ($$ request_score).

rbl, rhsbl, - consulta los RBL / RHSBL especificados, los valores posibles son:
rhsbl_client, [/ / , / / ]
rhsbl_sender, (valores predeterminados: respuesta = ^ 127 \ .0 \ .0 \. \ d + $ maxcache = 3600)
rhsbl_reverse_client los resultados de todas las consultas rhsbl_ * se combinarán
en rhsbl_count (ver más abajo).

rblcount, rhsblcount: recuentos mínimos de aciertos de RBL / RHSBL para que coincida. si no se especifica
un solo golpe RBL / RHSBL coincidirá con los elementos rbl / rhsbl.
puede especificar 'todos' para evaluar todos los elementos y utilizar
como variable en una acción (ver sección ACCIONES)
(predeterminado: 1)

sender_localpart, - la parte local / dominio de la dirección del remitente
remitente_dominio

destinatario_localpart, - la parte local- / dominio de la dirección del destinatario
destinatario_dominio

helo_address - postfwd intenta buscar el helo_name. usar
helo_address = !! (0.0.0.0/0) para buscar desconocido.
No utilice esto para un control de acceso positivo
(lista blanca), ya que podría estar falsificado.

sender_ns_names, - postfwd intenta buscar los nombres / direcciones IP
sender_ns_addrs de los servidores de nombres para la parte del dominio del remitente.
No utilice esto para un control de acceso positivo
(lista blanca), ya que podría estar falsificado.

sender_mx_names, - postfwd intenta buscar los nombres / direcciones IP
sender_mx_addrs de los registros mx para la parte del dominio del remitente.
No utilice esto para un control de acceso positivo
(lista blanca), ya que podría estar falsificado.

versión - versión postfwd, contiene "postfwd n.nn"
esto permite verificaciones basadas en versiones en sus conjuntos de reglas
(por ejemplo, para la migración). también funciona con versiones antiguas,
porque un elemento no existente siempre devuelve falso:
# versión> = 1.10
id = R01; versión ~ = 1 \. [1-9] [0-9]; sender_domain == some.org \
; acción = RECHAZAR lo siento, no hay acceso

ratecount: solo está disponible para las acciones rate (), size () y rcpt ().
contiene el contador de límite real:
id = R01; action = rate (remitente / 200/600 / REJECT límite de 200 excedido [$$ ratecount hits])
id = R02; action = rate (remitente / 100/600 / límite de WARN de 100 excedido [$$ ratecount hits])

Además de estos, puede especificar cualquier atributo del protocolo de delegación de políticas de postfix.
Siéntase libre de combinarlos de la manera que lo necesite (eche un vistazo a la sección de EJEMPLOS a continuación).

La mayoría de los valores se pueden especificar como expresiones regulares (PCRE). Consulte la tabla siguiente para
detalles:

# =============================================== =========
# ARTÍCULO = TIPO DE VALOR
# =============================================== =========
id = algo máscara = cadena
fecha = 01.04.2007-22.04.2007 máscara = fecha (DD.MM.YYYY-DD.MM.YYYY)
tiempo = 08: 30: 00-17: 00: 00 máscara = tiempo (HH: MM: SS-HH: MM: SS)
días = máscara de lunes a miércoles = días de la semana (lunes a miércoles) o numérico (1-3)
meses = máscara de febrero a abril = meses (febrero a abril) o numérico (1-3)
puntuación = 5.0 máscara = valor máximo de punto flotante
rbl = zen.spamhaus.org máscara = / / [, ...]
rblcount = 2 mask = numérico, coincidirá si rbl golpea> = 2
helo_address = máscara = CIDR [, CIDR, ...]
sender_ns_names = some.domain.tld mask = PCRE
sender_mx_names = some.domain.tld mask = PCRE
sender_ns_addrs = máscara = CIDR [, CIDR, ...]
sender_mx_addrs = máscara = CIDR [, CIDR, ...]
#------------------------------
# Postfix versión 2.1 y posterior:
#------------------------------
dirección_cliente = máscara = CIDR [, CIDR, ...]
nombre_cliente = otro.dominio.tld máscara = PCRE
reverse_client_name = otro.dominio.tld máscara = PCRE
helo_name = some.domain.tld mask = PCRE
remitente =[email protected] máscara = PCRE
destinatario =[email protected] máscara = PCRE
recuento_recipiente = 5 máscara = numérico, coincidirá si los destinatarios> = 5
#------------------------------
# Postfix versión 2.2 y posterior:
#------------------------------
sasl_method = máscara simple = PCRE
sasl_username = tu máscara = PCRE
sasl_sender = máscara = PCRE
tamaño = 12345 máscara = numérico, coincidirá si el tamaño> = 12345
ccert_subject = blackhole.nowhere.local mask = PCRE (solo si tls verificado)
ccert_issuer = John + 20Doe mask = PCRE (solo si tls verificado)
ccert_fingerprint = AA: BB: CC: DD: EE: ... mask = PCRE (NO use "..." aquí)
#------------------------------
# Postfix versión 2.3 y posterior:
#------------------------------
encryption_protocol = TLSv1 / máscara SSLv3 = PCRE
cifrado_encriptado = DHE-RSA-AES256-SHA máscara = PCRE
encryption_keysize = 256 mask = numérico, coincidirá si el tamaño de la clave> = 256
...

la lista actual se puede encontrar enhttp://www.postfix.org/SMTPD_POLICY_README.html>. Por favor
lea atentamente qué atributo se puede utilizar en qué nivel de la transacción smtp
(por ejemplo, el tamaño solo funcionará de manera confiable en el nivel de FIN DE MENSAJE). La coincidencia de patrones es
realizado sin distinción entre mayúsculas y minúsculas.

Se permite el uso múltiple del mismo elemento y se comparará como OR lógico, lo que significa que
esto funcionará como se esperaba:

id = TRUST001; acción = OK; tamaño_de_cifrado = 64
ccert_fingerprint=11:22:33:44:55:66:77:88:99
ccert_fingerprint=22:33:44:55:66:77:88:99:00
ccert_fingerprint=33:44:55:66:77:88:99:00:11
remitente = @ dominio \ .local $

Los elementos client_address, rbl y rhsbl también se pueden especificar como espacios en blanco o separados por comas
valores:

id = SKIP01; acción = no sé
dirección_cliente = 192.168.1.0 / 24, 172.16.254.23
id = SKIP02; acción = no sé
dirección_cliente = 10.10.3.32 10.216.222.0/27

Actualmente, los siguientes elementos deben ser únicos:

id, valores mínimos y máximos, rblcount y rhsblcount

Cualquier elemento se puede negar anteponiendo '!!' a eso, por ejemplo:

id = HOST001; nombre de host == !! secure.trust.local; action = RECHAZAR solo secure.trust.local por favor

o usando el operador de comparación correcto:

id = HOST001; nombre de host! = secure.trust.local; action = RECHAZAR solo secure.trust.local por favor

Para evitar confusiones con las expresiones regulares o simplemente para una mejor visibilidad, puede usar '!! (...)':

id = USER01; sasl_username = !! ((bob | alice)); acción = RECHAZAR ¿quién es ese?

Los atributos de solicitud se pueden comparar con los caracteres '$$' anteriores, por ejemplo:

id = R-003; nombre_cliente = !! $$ helo_name; action = WARN helo no coincide con DNS
# o
id = R-003; nombre_cliente = !! ($$ (nombre_helo)); action = WARN helo no coincide con DNS

Esto solo es válido para los valores de PCRE (consulte la lista anterior). La comparación se realizará como
coincidencia exacta que no distingue entre mayúsculas y minúsculas. Utilice la opción '-vv' para depurar.

Estos elementos especiales se restablecerán para cualquier regla nueva:

rblcount: contiene el número de respuestas RBL
rhsblcount: contiene el número de respuestas RHSBL
coincidencias: contiene la cantidad de elementos coincidentes
dnsbltext: contiene la parte dns TXT de todas las respuestas RBL y RHSBL en el formulario
rbltype: rblname: ; rbltype: rblname: ; ...

Estos elementos especiales se cambiarán para cualquier regla coincidente:

request_hits: contiene los identificadores de todas las reglas coincidentes

Esto significa que puede ser necesario guardarlos, si planea usar estos valores en
reglas posteriores:

# establecer valores
id = RBL01; rhsblcount = todos; rblcount = todo
action = set (HIT_rhls = $$ rhsblcount, HIT_rbls = $$ rblcount, HIT_txt = $$ dnsbltext)
rbl = list.dsbl.org, bl.spamcop.net, dnsbl.sorbs.net, zen.spamhaus.org
rhsbl_client = rddn.dnsbl.net.au, rhsbl.ahbl.org, rhsbl.sorbs.net
rhsbl_sender = rddn.dnsbl.net.au, rhsbl.ahbl.org, rhsbl.sorbs.net

# comparar
id = RBL02; HIT_rhls> = 1; HIT_rbls> = 1; action = 554 5.7.1 bloqueado usando $$ HIT_rhls RHSBLs y $$ HIT_rbls RBLs [INFO: $$ HIT_txt]
id = RBL03; HIT_rhls> = 2; action = 554 5.7.1 bloqueado usando $$ HIT_rhls RHSBLs [INFO: $$ HIT_txt]
id = RBL04; HIT_rbls> = 2; action = 554 5.7.1 bloqueado usando $$ HIT_rbls RBLs [INFO: $$ HIT_txt]

ARCHIVOS
Desde postfwd1 v1.15 y postfwd2 v0.18, las listas de elementos largas se pueden almacenar en archivos separados:

id = R001; ccert_fingerprint == archivo: / etc / postfwd / wl_ccerts; acción = DUNNO

postfwd leerá una lista de elementos (un elemento por línea) de / etc / postfwd / wl_ccerts.
se permiten comentarios:

# cliente1
11:22:33:44:55:66:77:88:99
# cliente2
22:33:44:55:66:77:88:99:00
# cliente3
33:44:55:66:77:88:99:00:11

Para usar tablas existentes en formato clave = valor, puede usar:

id = R001; ccert_fingerprint == tabla: / etc / postfwd / wl_ccerts; acción = DUNNO

Esto ignorará el valor de la derecha. Los artículos se pueden mezclar:

id = R002; acción = RECHAZAR
nombre_cliente == desconocido
nombre_cliente == archivo: / etc / postfwd / lista negra

y para elementos no pcre (separados por comas):

id = R003; acción = RECHAZAR
dirección_cliente == 10.1.1.1, archivo: / etc / postfwd / blacklisted

id = R004; acción = RECHAZAR
rbl = myrbl.home.local, zen.spamhaus.org, archivo: / etc / postfwd / rbls_changing

Puede verificar su configuración con la opción --show_config en la línea de comando:

# postfwd --showconfig --rule = 'acción = DUNNO; dirección_cliente = 10.1.0.0 / 16, archivo: / etc / postfwd / wl_clients, 192.168.2.1 '

debería dar algo como:

Regla 0: id -> "R-0"; acción -> "DUNNO"; dirección_cliente -> "=; 10.1.0.0/16, =; 194.123.86.10, =; 186.4.6.12, =; 192.168.2.1"

Si un archivo no se puede leer, se ignorará:

# postfwd --showconfig --rule = 'acción = DUNNO; dirección_cliente = 10.1.0.0 / 16, archivo: / etc / postfwd / wl_clients, 192.168.2.1 '
[Advertencia de registro]: error: archivo / etc / postfwd / wl_clients no encontrado - ¿el archivo se ignorará?
Regla 0: id -> "R-0"; acción -> "DUNNO"; dirección_cliente -> "=; 10.1.0.0/16, =; 192.168.2.1"

Los elementos del archivo se evalúan en la etapa de configuración. Por lo tanto, es necesario volver a cargar postfwd si
un archivo ha cambiado.

Si desea especificar un archivo, que se volverá a cargar para cada solicitud, puede usar lfile:
y tabla:

id = R001; dirección_cliente = lfile: / etc / postfwd / client_whitelist; acción = no sé

Esto comprobará la hora de modificación de / etc / postfwd / client_whitelist cada vez que la regla
se evalúa y se vuelve a cargar según sea necesario. Por supuesto, esto podría aumentar la carga del sistema, por lo que
utilícelo con cuidado.

La opción --showconfig ilustra la diferencia:

## evaluados en la etapa de configuración
# postfwd2 --nodaemon -L --rule = 'dirección_cliente = tabla: / etc / postfwd / clients; acción = no sé '-C
Regla 0: id -> "R-0"; acción -> "no sé"; dirección_cliente -> "=; 1.1.1.1, =; 1.1.1.2, =; 1.1.1.3"

## evaluado para cualquier regla
# postfwd2 --nodaemon -L --rule = 'dirección_cliente = ltable: / etc / postfwd / clients; acción = no sé '-C
Regla 0: id -> "R-0"; acción -> "no sé"; dirección_cliente -> "=; ltable: / etc / postfwd / clients"

Los archivos pueden hacer referencia a otros archivos. Lo siguiente es válido.

- ARCHIVO /etc/postfwd/rules.cf -
id = R001; dirección_cliente = archivo: /etc/postfwd/clients_master.cf; acción = DUNNO

- ARCHIVO /etc/postfwd/clients_master.cf -
192.168.1.0/24
archivo: /etc/postfwd/clients_east.cf
archivo: /etc/postfwd/clients_west.cf

- ARCHIVO /etc/postfwd/clients_east.cf -
192.168.2.0/24

- ARCHIVO /etc/postfwd/clients_west.cf -
192.168.3.0/24

Tenga en cuenta que actualmente no hay detección de bucle (/ a / file calls / a / file) y que este
La función solo está disponible con postfwd1 v1.15 y postfwd2 v0.18 y versiones posteriores.

ACCIONES
General

Las acciones se ejecutarán cuando todos los elementos de la regla hayan coincidido con una solicitud (o al menos una de las
cualquier lista de elementos). Puede hacer referencia a los atributos de la solicitud precediendo los caracteres $$, como:

id = R-003; nombre_cliente = !! $$ nombre_helo; action = WARN helo '$$ helo_name' no coincide con el DNS '$$ client_name'
# o
id = R-003; nombre_cliente = !! $$ nombre_helo; action = WARN helo '$$ (helo_name)' no coincide con el DNS '$$ (client_name)'

sufijo acciones

Las acciones serán respondidas a postfix como resultado de las solicitudes de delegación de políticas. Cualquier acción
que el sufijo entiende que está permitido - ver "acceso man 5" o
<http://www.postfix.org/access.5.html> para una descripción. Si no se especifica ninguna acción, el
La acción postfix WARN que simplemente registra el evento se utilizará para la regla correspondiente.

postfwd devolverá dunno si ha llegado al final del conjunto de reglas y ninguna regla ha
emparejado. Esto se puede cambiar colocando una última regla que contenga solo una declaración de acción:

...
acción=no sé; [email protected] # remitente está bien
acción = rechazar # denegar por defecto

posfwd acciones

Las acciones de postfwd controlan el comportamiento del programa. Actualmente puede especificar el
siguientes:

salto ( )
salta a gobernar con id , use esto para omitir ciertas reglas.
puedes saltar hacia atrás, pero recuerda que no hay bucle
detección en este momento! se omitirán los saltos a identificadores no existentes.

puntaje ( )
la puntuación de la solicitud será modificada por el especificado ,
que debe ser un valor de coma flotante. el modificador puede ser
+ n.nn agrega n.nn a la puntuación actual
-n.nn resta n.nn de la puntuación actual
* n.nn multiplica la puntuación actual por n.nn
/n.nn divide la puntuación actual entre n.nn
= n.nn establece la puntuación actual en n.nn
si el puntaje excede el máximo establecido por la opción `--scores` (ver
LÍNEA DE COMANDOS) o el elemento de puntuación (consulte la sección ARTÍCULOS), la acción
definido para este caso será devuelto (por defecto: 5.0 => "RECHAZAR puntuación postfwd excedida").

colocar ( = , = , ...)
este comando le permite insertar o anular atributos de solicitud, que luego pueden ser
en comparación con su conjunto de reglas adicional. utilícelo para acelerar las comparaciones repetidas con listas de artículos grandes.
consulte la sección EJEMPLOS para obtener más información. puede separar varios pares clave = valor
por "," caracteres.

calificar ( / / / )
este comando crea un contador para el dado , que se incrementará cada vez que una solicitud
que lo contiene llega. si excede dentro segundos volverá postfix.
Los contadores de tasas son muy rápidos, ya que se ejecutan antes de analizar el conjunto de reglas.
tenga en cuenta que estaba limitado a acciones postfix (no acciones postfwd) para versiones postfwd <1.33!
# no más de 3 solicitudes por 5 minutos
# del mismo cliente "desconocido"
id = RATE01; nombre_cliente == desconocido
action = rate (client_address / 3/300/450 4.7.1 lo siento, máximo 3 solicitudes por 5 minutos)
Tenga en cuenta también que el orden de los límites de tarifas en su conjunto de reglas es importante, lo que significa
que este:
# funciona como se esperaba
id = R001; action = rcpt (sender / 500/3600 / REJECT límite de 500 destinatarios por hora para el remitente $$ remitente excedido)
id = R002; action = rcpt (sender / 200/3600 / WARN state AMARILLO para remitente $$ remitente)
conduce a resultados diferentes a este:
# la regla R002 nunca se ejecuta
id = R001; action = rcpt (sender / 200/3600 / WARN state AMARILLO para remitente $$ remitente)
id = R002; action = rcpt (sender / 500/3600 / REJECT límite de 500 destinatarios por hora para el remitente $$ remitente excedido)

Talla ( / / / )
este comando funciona de manera similar al comando rate () con la diferencia de que el contador de tasa es
aumentado por el atributo de tamaño de la solicitud. para hacer esto de manera confiable, debe llamar a postfwd desde
smtpd_end_of_data_restrictions. si quiere estar seguro, puede verificarlo dentro del conjunto de reglas:
# límite de tamaño de 1.5 MB por hora por cliente
id = TAMAÑO01; protocol_state == FIN DE MENSAJE; dirección_cliente! = 10.1.1.1
action = size (client_address / 1572864/3600/450 4.7.1 lo siento, máximo 1.5mb por hora)

rcpt / / / )
este comando funciona de manera similar al comando rate () con la diferencia de que el contador de tasa es
incrementado por el atributo recuento_destinatario de la solicitud. para hacer esto de manera confiable, debe llamar a postfwd
de smtpd_data_restrictions o smtpd_end_of_data_restrictions. si quieres estar seguro, podrías
compruébalo dentro del conjunto de reglas:
# límite de recuento de destinatarios 3 por hora por cliente
id = RCPT01; protocol_state == FIN DE MENSAJE; dirección_cliente! = 10.1.1.1
action = rcpt (client_address / 3/3600/450 4.7.1 lo siento, máximo 3 destinatarios por hora)

rate5321, size5321, rcpt5321 ( / / / )
igual que las funciones no 5321 correspondientes, con la diferencia de que la parte local de
Las direcciones del remitente o del destinatario se evalúan con distinción entre mayúsculas y minúsculas de acuerdo con rfc5321. Ese
significa que las solicitudes de [email protected] y [email protected] será tratado de manera diferente

preguntar ( : [: ])
permite delegar la decisión de política a otro servicio de política (por ejemplo, postgrey). la primera
y el segundo argumento (dirección y puerto) son obligatorios. un tercer argumento opcional puede ser
especificado para decirle a postfwd que ignore ciertas respuestas y continúe analizando el conjunto de reglas:
# example1: consulta postgrey y devuelve su respuesta a postfix
id = GRIS; dirección_cliente == 10.1.1.1; acción = preguntar (127.0.0.1:10031)
# example2: consulta postgrey pero ignora la respuesta, si coincide con 'DUNNO'
# y continúe analizando el conjunto de reglas de postfwd
id = GRIS; dirección_cliente == 10.1.1.1; acción = preguntar (127.0.0.1:10031:^dunno$)

correo (servidor / helo / desde / hasta / asunto / cuerpo)
Este comando está en desuso. Debería intentar usar la acción sendmail () en su lugar.
Comando de correo muy básico, que envía un mensaje con los argumentos dados. LIMITACIONES:
Esto básicamente realiza un telnet. No hay autenticación ni TLS disponibles. Además lo hace
no rastrea el estado de notificación y le notificará en cualquier momento, la regla correspondiente golpea.

sendmail (sendmail-path :: from :: to :: subject :: body)
Comando de correo, que usa un binario de sendmail existente y envía un mensaje con los argumentos dados.
LIMITACIONES: El comando no rastrea el estado de notificación y le notificará en cualquier momento, el
coincidencias de reglas correspondientes (lo que podría significar 100 correos para un correo con 100 destinatarios en la etapa RCPT).

Espere ( )
pausa la ejecución del programa para segundos. usa esto para
retrasar o estrangular las conexiones.

Nota ( )
simplemente registra la cadena dada y continúa analizando el conjunto de reglas.
si la cadena está vacía, no se registrará nada (noop).

salir ( )
termina el programa con el código de salida dado. postfix no
me gusta demasiado, así que úselo con cuidado.

Puede hacer referencia a atributos de solicitud, como

id = R-HELO; helo_name = ^ [^ \.] + $; acción = RECHAZAR helo inválido '$$ helo_name'

MACROS / ACLS
Los macros pueden abreviar el uso múltiple de elementos largos o combinaciones de ellos. Aquellos
debe tener el prefijo '&&' (dos caracteres '&'). Primero, las macros deben definirse como
manera:

&& RBLS {rbl = zen.spamhaus.org, list.dsbl.org, bl.spamcop.net, dnsbl.sorbs.net, ix.dnsbl.manitu.net; };

Entonces estos pueden usarse en sus reglas, como:

&& RBLS; nombre_cliente = ^ desconocido $; acción = RECHAZAR
&& RBLS; nombre_cliente = (\ d + [\.-_]) {4}; acción = RECHAZAR
&& RBLS; nombre_cliente = [\.-_] (adsl | dinámico | ppp |) [\.-_]; acción = RECHAZAR

Las macros también pueden contener acciones:

# definición
&& GONOW {action = RECHAZAR su solicitud hizo que nuestra política de detección de spam rechazara este mensaje. Más info en http://www.domain.local; };
# reglas
&&VE AHORA ; && RBLS; nombre_cliente = ^ desconocido $
&&VE AHORA ; && RBLS; nombre_cliente = (\ d + [\.-_]) {4}
&&VE AHORA ; && RBLS; nombre_cliente = [\.-_] (adsl | dinámico | ppp |) [\.-_]

Las macros también pueden contener macros:

# definición
&& RBLS {
rbl = zen.spamhaus.org
rbl = list.dsbl.org
rbl = bl.spamcop.net
rbl = dnsbl.sorbs.net
rbl = ix.dnsbl.manitu.net
};
&&DINÁMICA{
nombre_cliente = ^ desconocido $
nombre_cliente = (\ d + [\.-_]) {4}
nombre_cliente = [\.-_] (adsl | dinámico | ppp |) [\.-_]
};
&& GOAWAY {&& RBLS; &&DINÁMICA; };
# reglas
&&IRSE ; acción = RECHAZAR cliente dinámico y listado en RBL

Básicamente, las macros son sustituciones de texto simples; consulte la sección "PARSER" para obtener más información.


PLUGINS
Descripción

La interfaz del complemento le permite definir sus propias comprobaciones y mejorar las
funcionalidad. ¡Siéntete libre de compartir cosas útiles!

advertencia

Tenga en cuenta que la interfaz del complemento aún se encuentra en etapa de desarrollo. Pruebe sus complementos
con cuidado, porque los errores pueden hacer que postfwd se rompa. También se permite anular
atributos o funciones integradas, pero asegúrese de saber lo que hace porque algunos de
se utilizan internamente.

Tenga en cuenta la seguridad cuando acceda a recursos sensibles y nunca ejecute
postfwd como usuario privilegiado! Además, nunca confíe en su entrada (especialmente los nombres de host y el correo electrónico).
direcciones).

ARTÍCULOS

Los complementos de elementos son subrutinas de Perl que integran atributos adicionales a las solicitudes antes
se evalúan contra el conjunto de reglas de postfwd como cualquier otro elemento de la delegación de políticas
protocolo. Esto le permite crear sus propios cheques.

Los elementos de complemento no se pueden utilizar de forma selectiva. estas funciones se ejecutarán para cada solicitud
postfwd recibe, así que tenga en cuenta el rendimiento.

SINOPSIS:% result = postfwd_items_plugin { }(%solicitud)

significa que tu subrutina, llamada , tiene acceso a un hash llamado% request, que
contiene todos los atributos de la solicitud, como $ request {client_name} y debe devolver un valor en el
siguiente forma:

guardar: $ resultado { } =

esto crea el nuevo artículo conteniendo , que se integrará en el
solicitud de delegación de políticas y, por lo tanto, puede usarse en el conjunto de reglas de postfwd.

# NO elimine la siguiente línea
% postfwd_items_plugin = (

# EJEMPLOS - integrado en postfwd. no es necesario activarlos aquí.

# permite verificar la versión de postfwd en el conjunto de reglas
"versión" => sub {
mi (% solicitud) = @_;
mi (% resultado) = (
"version" => $ NAME. "". $ VERSION,
);
return% result;
},

# sender_domain y receiver_domain
"address_parts" => sub {
mi (% solicitud) = @_;
mi (% resultado) = ();
$ solicitud {remitente} = ~ / @ ([^ @] *) $ /;
$ resultado {dominio_remitente} = ($ 1 || '');
$ solicitud {destinatario} = ~ / @ ([^ @] *) $ /;
$ resultado {dominio_receptor} = ($ 1 || '');
return% result;
},

# NO elimine la siguiente línea
);

COMPARAR

Los complementos de comparación le permiten definir cómo se deben comparar sus nuevos elementos con el conjunto de reglas.
Son opcionales. Si no especifica uno, el valor predeterminado (== para coincidencia exacta, = ~ para
PCRE, ...) se utilizará.

SINOPSIS: => sub {return & {$ postfwd_compare { }} (@_); },

# NO elimine la siguiente línea
% postfwd_compare_plugin = (

EJEMPLOS - integrado en postfwd. no es necesario activarlos aquí.

# Ejemplo simple
# SINOPSIS: = (return & {$ postfwd_compare { }} (@_))
"client_address" => sub {return & {$ postfwd_compare {cidr}} (@_); },
"tamaño" => sub {return & {$ postfwd_compare {numeric}} (@_); },
"destination_count" => sub {return & {$ postfwd_compare {numeric}} (@_); },

# Ejemplo complejo
# SINOPSIS: = ( , , , )
"numérico" => sub {
my ($ cmp, $ val, $ myitem,% request) = @_;
my ($ myresult) = undef; $ myitem || = "0"; $ val || = "0";
if ($ cmp eq '==') {
$ myresult = ($ myitem == $ val);
} elsif ($ cmp eq '= <') {
$ myresult = ($ myitem <= $ val);
} elsif ($ cmp eq '=>') {
$ myresult = ($ myitem> = $ val);
} elsif ($ cmp eq '<') {
$ myresult = ($ myitem <$ val);
} elsif ($ cmp eq '>') {
$ myresult = ($ myitem> $ val);
} elsif ($ cmp eq '! =') {
$ myresult = not ($ myitem == $ val);
} elsif ($ cmp eq '! <') {
$ myresult = not ($ myitem <= $ val);
} elsif ($ cmp eq '!>') {
$ myresult = not ($ myitem> = $ val);
} Else {
$ myresult = ($ myitem> = $ val);
};
return $ myresult;
},

# NO elimine la siguiente línea
);

ACCIONES

Los complementos de acción permiten definir nuevas acciones postfwd. Al establecer el $ stop-flag puede
decide continuar o dejar de analizar el conjunto de reglas.

SINOPSIS: ( , , , , ) =
( , , , , , )

# NO elimine la siguiente línea
% postfwd_actions_plugin = (

# EJEMPLOS - integrado en postfwd. no es necesario activarlos aquí.

# Nota( ) comando
"nota" => sub {
my ($ índice, $ ahora, $ mycmd, $ myarg, $ myline,% solicitud) = @_;
my ($ myaction) = 'no sé'; mi ($ parada) = 0;
log_info "[REGLAS]". $ myline. "- nota:". $ myarg if $ myarg;
return ($ stop, $ index, $ myaction, $ myline,% request);
},

# salta el siguiente reglas
"saltar" => sub {
my ($ índice, $ ahora, $ mycmd, $ myarg, $ myline,% solicitud) = @_;
my ($ myaction) = 'no sé'; mi ($ parada) = 0;
$ índice + = $ myarg if ($ myarg y no (($ índice + $ myarg)> $ # Reglas));
return ($ stop, $ index, $ myaction, $ myline,% request);
},

# vuelca el contenido de la solicitud actual a syslog
"dumprequest" => sub {
my ($ índice, $ ahora, $ mycmd, $ myarg, $ myline,% solicitud) = @_;
my ($ myaction) = 'no sé'; mi ($ parada) = 0;
map {log_info "[DUMP] rule = $ index, Atributo: $ _ = $ request {$ _}"} (claves% solicitud);
return ($ stop, $ index, $ myaction, $ myline,% request);
},

# NO elimine la siguiente línea
);

COMANDO LÍNEA
Conjunto de reglas

Los siguientes argumentos se utilizan para especificar la fuente del conjunto de reglas postfwd. Esto significa
que se requiere al menos uno de los siguientes para que postfwd funcione.

-f, --archivo
Lee reglas de . Consulte la sección CONFIGURACIÓN
a continuación para más información.

-r, --regla
Agrega al conjunto de reglas. Recuerda que es posible que debas cotizar
cadenas que contienen espacios en blanco o caracteres de shell.

Scoring

-s, --puntajes =
Devoluciones a postfix, cuando el puntaje de la solicitud excede

Se permite el uso múltiple. Simplemente encadena tus argumentos, como:

postfwd -r " = ; acción = "-f -F ...
or
postfwd --scores 4.5 = "WARN puntaje alto" --scores 5.0 = "RECHAZAR puntaje postfwd demasiado alto" ...

En caso de múltiples puntuaciones, se contará la coincidencia más alta. El orden de los argumentos
reflejarse en el conjunto de reglas de postfwd.

Control:

-d, --daemon
postfwd se ejecutará como demonio y escuchará en la red las entradas
consultas (predeterminado 127.0.0.1:10040).

-k, - matar
Detiene un demonio postfwd en ejecución.

--recargar
Recarga la configuración.

--dumpstats
Muestra estadísticas de uso del programa.

--volcado de caché
Muestra el contenido de la caché.

--delcache
Elimina un elemento de la caché de solicitudes. Utilice --dumpcache para identificar objetos.
P.ej:
# postfwd --dumpcache
...
% rate_cache ->% sender =[email protected] ->% RATE002 + 2_600 -> @count -> '1'
% rate_cache ->% sender =[email protected] ->% RATE002 + 2_600 -> @maxcount -> '2'
...
# postfwd --delrate = "sender =[email protected]"
puntuar elemento de caché 'sender =[email protected]'eliminado

--delrate
Elimina un elemento del caché de tarifas. Utilice --dumpcache para identificar objetos.

Networking

postfwd se puede ejecutar como demonio para que escuche en la red las solicitudes entrantes. El
Los siguientes argumentos controlarán su comportamiento en este caso.

-i, --interfaz
Enlaza postfwd a la interfaz especificada (por defecto 127.0.0.1).

-p, --port
postfwd escucha en el puerto especificado (predeterminado tcp / 10040).

--proto
El tipo de protocolo para el socket de postfwd. Actualmente puede usar 'tcp' o 'unix' aquí.
Para usar postfwd con un socket de dominio Unix, ejecútelo de la siguiente manera:
postfwd --proto = unix --port = / en algún lugar / postfwd.socket

-u, --usuario
Cambia usuario real y efectivo a .

-g, --grupo
Cambia grupo real y efectivo a .

--umask
Cambia la máscara de usuario para permisos de archivo (sockets de dominio Unix, archivos pid).
Atención: esto es umask, no chmod; debe especificar los bits que
NO debe aplicarse. Por ejemplo: umask 077 es igual a chmod 700.

-R, --chroot
Chroot el proceso a la ruta especificada.
Pruebe esto antes de usarlo; es posible que necesite algunas bibliotecas allí.

--pidfile
La identificación del proceso se guardará en el archivo especificado.

--instalaciones
establece la función de syslog, el valor predeterminado es 'correo'

- tipo de calcetín
establece el tipo de sockSys :: Syslog en 'native', 'inet' o 'unix'.
El valor predeterminado es detectar automáticamente esto según la versión del módulo y el sistema operativo.

-l, --nombre de registro
Etiqueta los mensajes de syslog. Útil cuando se ejecutan múltiples
instancias de postfwd.

--loglen
Trunca cualquier mensaje de syslog después caracteres.

Plugins

--enchufes
Carga los complementos de postfwd desde el archivo. Por favor mira http://postfwd.org/postfwd.plugins
o el plugins.postfwd.sample que está disponible en el tarball para obtener más información.

Opcional argumentos

Estos parámetros influyen en la forma en que funciona postfwd. Cualquiera de ellos se puede combinar.

-v, --detallado
El registro detallado muestra mucha información útil, pero puede causar
sus archivos de registro para que crezcan notablemente. Así que utilícelo con precaución. Establecer la opción
dos veces (-vv) para obtener más información (registra todos los atributos de la solicitud).

-c, --caché (predeterminado = 600)
Tiempo de espera para la caché de solicitudes, los resultados para solicitudes idénticas serán
almacenado en caché hasta que se vuelva a cargar la configuración o este tiempo (en segundos) expire.
Un valor de 0 desactiva esta función.

--caché-sin-tamaño
Ignora el atributo de tamaño para las comparaciones de caché que conducirán a mejores
tasas de aciertos en caché. Debe configurar esta opción, si no usa el tamaño
elemento en su conjunto de reglas.

--caché-sin-remitente
Ignora la dirección del remitente para las comparaciones de caché que conducirán a una mejor
tasas de aciertos en caché. Debe configurar esta opción, si no usa el remitente
elemento en su conjunto de reglas.

--cache-rdominio-solo
Esto quitará la parte local de la dirección del destinatario antes de completar la
cache. Esto puede aumentar considerablemente las tasas de aciertos de caché.

--cache-rbl-timeout (predeterminado = 3600)
Este valor predeterminado se utilizará como tiempo de espera en segundos para los elementos de la caché rbl,
si no se especifica en el conjunto de reglas.

--cache-rbl-default (predeterminado = ^ 127 \ .0 \ .0 \. \ d + $)
Partidos a rbl / rhsbl responde (regexp) si no se especifica en el conjunto de reglas.

--cacheid , ...
Esta lista de atributos de solicitud separados por csv se utilizará para construir
el identificador de caché de solicitud. Use esto solo, si sabe exactamente lo que
estás haciendo. Si, por ejemplo, usa postfwd solo para control RBL / RHSBL,
puedes configurar esto para
postfwd --cache = 3600 --cacheid = nombre_cliente, dirección_cliente
Esto aumenta la eficiencia del almacenamiento en caché y mejora el rendimiento de postfwd.
Advertencia: ¡Debería enumerar todos los elementos aquí, que se utilizan en su conjunto de reglas!

- solicitudes de limpieza (predeterminado = 600)
Se buscará en la caché de solicitudes los elementos que hayan agotado el tiempo de espera después de esto. en
segundos. Es un valor mínimo. El proceso de limpieza solo se llevará a cabo cuando
llega una nueva solicitud.

--cleanup-rbls (predeterminado = 600)
Se buscará en la caché rbl los elementos que hayan agotado el tiempo de espera después de esto. en
segundos. Es un valor mínimo. El proceso de limpieza solo se llevará a cabo cuando
llega una nueva solicitud.

- tarifas de limpieza (predeterminado = 600)
Se buscará en la caché de tasas los elementos que hayan agotado el tiempo de espera después de esto. en
segundos. Es un valor mínimo. El proceso de limpieza solo se llevará a cabo cuando
llega una nueva solicitud.

-S, --resumen (predeterminado = 600)
Muestra algunas estadísticas de uso (tiempo de actividad del programa, contador de solicitudes, reglas de coincidencia)
cada segundos. Esta opción está incluida en el modificador -v.
Esta función utiliza la señal de alarma, por lo que puede forzar a postfwd a volcar las estadísticas
usando `kill -ALRM `(donde es el ID de proceso de postfwd).

Ejemplo:
19 de agosto 12:39:45 mail1 postfwd [666]: [STATS] Contadores: 213000 segundos de tiempo de actividad, 39 reglas
19 de agosto 12:39:45 mail1 postfwd [666]: [STATS] Solicitudes: 71643 en general, 49 último intervalo, 62.88% de aciertos de caché
19 de agosto 12:39:45 mail1 postfwd [666]: [ESTADÍSTICAS] Promedios: 20.18 en general, 4.90 último intervalo, 557.30 arriba
19 de agosto 12:39:45 mail1 postfwd [666]: [ESTADÍSTICAS] Contenido: 44 solicitudes en caché, 239 resultados de dnsbl en caché
19 de agosto 12:39:45 mail1 postfwd [666]: [ESTADÍSTICAS] ID de regla: R-001 coincide: 2704 veces
19 de agosto 12:39:45 mail1 postfwd [666]: [ESTADÍSTICAS] ID de regla: R-002 coincide: 9351 veces
19 de agosto 12:39:45 mail1 postfwd [666]: [ESTADÍSTICAS] ID de regla: R-003 coincide: 3116 veces
...

--no-reglas
Desactiva las estadísticas por regla. Mantiene su registro limpio, si no los usa.
Esta opción no tiene ningún efecto sin los conjuntos --summary o --verbose.

-L, --stdoutlog
Redirige todos los mensajes de syslog a stdout para su depuración. ¡Nunca use esto con postfix!

-t, --prueba
En el modo de prueba, postfwd siempre devuelve "no sé", pero registra de acuerdo
a su conjunto de reglas. -v se configurará automáticamente con esta opción.

-n, --asiente
Desactiva todas las comprobaciones basadas en DNS como las comprobaciones RBL. Reglas que contienen
estos elementos serán ignorados.

-n, --nodnslog
Desactiva el registro de eventos dns.

--dns_timeout (predeterminado: 14)
Establece el tiempo de espera para consultas DNS asincrónicas en segundos. Este valor se aplicará a
todos los elementos dns en una regla.

--dns_timeout_max (predeterminado: 10)
Establece el contador de tiempo de espera máximo para las búsquedas de dnsbl. Si los tiempos de espera superan este valor
el dnsbl correspondiente se desactivará por un tiempo (ver --dns_timeout_interval).

--dns_timeout_interval (predeterminado = 1200)
El contador de tiempo de espera dnsbl se limpiará después de este intervalo en segundos. Utilizar este
junto con el parámetro --dns_timeout_max.

--dns_async_txt
Realice búsquedas de dnsbl A y TXT simultáneamente (de lo contrario, solo para listados con at
al menos un registro A). Esto necesita más ancho de banda de red debido al aumento de consultas, pero
podría aumentar el rendimiento porque las búsquedas se pueden paralelizar.

--dns_max_ns_lookups (predeterminado = 0)
número máximo de ns para buscar con el elemento sender_ns_addrs. use 0 para no tener un máximo.

--dns_max_mx_lookups (predeterminado = 0)
nombres mx máximos para buscar con el elemento sender_mx_addrs. use 0 para no tener un máximo.

-Yo, --instantcfg
Los archivos de configuración, especificados por -f, se volverán a leer para cada solicitud
postfwd recibe. Esto permite cambios de configuración sobre la marcha
sin reiniciar. Aunque los archivos se leerán solo si es necesario
(lo que significa que sus tiempos de acceso cambiaron desde la última lectura) esto podría
aumentar significativamente la carga del sistema.

--config_timeout (predeterminado = 3)
tiempo de espera en segundos para analizar una sola línea de configuración. si se excede, la regla
ser omitido. esto se usa para evitar problemas debido a archivos grandes o bucles.

--keep_rates (predeterminado = 0)
Con esta opción configurada, postfwd no borra los contadores de límite de velocidad al recargar. Por favor
tenga en cuenta que debe reiniciar (no recargar) postfwd con esta opción si cambia
cualquier regla de límite de tasa.

--save_rates (predeterminado = ninguno)
Con esta opción, postfwd guarda los contadores de límite de velocidad existentes en el disco y los vuelve a cargar
al inicio del programa. Esto permite límites de frecuencia persistentes en los reinicios o reinicios del programa.
Tenga en cuenta que postfwd necesita acceso de lectura y escritura al archivo especificado.

--fast_limit_evaluation (predeterminado = 0)
Una vez que el conjunto de reglas estableció un límite de velocidad, las solicitudes futuras se evaluarán en función de él.
antes de consultar el conjunto de reglas. Este modo era el comportamiento predeterminado hasta la v1.30.
Con este modo, los límites de velocidad serán más rápidos, pero también se establecerán eventualmente
Es posible que las reglas de lista blanca dentro del conjunto de reglas no funcionen como se esperaba.
LIMITACIONES: Esta opción no permite comandos postfwd anidados como
acción = tasa (remitente / 3/60 /esperar(3))
Esta opción no funciona con las funciones estrictas-rfc5321 rate ().

Informativo argumentos

Estos argumentos son solo para uso de la línea de comandos. ¡Nunca los uses con el spawn de postfix!

-C, --showconfig
Muestra el conjunto de reglas actual. Utilice -v para una salida detallada.

-P, --perfmon
Esta opción desactiva cualquier salida y registro del sistema. Está incluido
para pruebas de rendimiento.

-V, --versión
Muestra la versión del programa.

-h, --ayuda
Muestra el uso del programa.

-m, --manual
Muestra el manual del programa.

REFRESH
En modo demonio, postfwd recarga su conjunto de reglas después de recibir una señal HUP. Por favor vea el
descripción del interruptor '-I' para que su configuración se actualice para cada solicitud
postfwd recibe.

EJEMPLOS
## lista blanca
# 1. redes 192.168.1.0/24, 192.168.2.4
# 2. nombres_cliente * .gmx.net y * .gmx.de
# 3. remitente *@someshop.tld de 11.22.33.44
id = WL001; acción = no sé; dirección_cliente = 192.168.1.0 / 24, 192.168.2.4
id = WL002; acción = no sé; nombre_cliente = \. gmx \. (net | de) $
id = WL003; acción = no sé; remitente = @ someshop \ .tld $; dirección_cliente = 11.22.33.44

## Control TLS
# 1. *@authority.tld solo con la huella dactilar TLS correcta
# 2. *@secret.tld solo con tamaños de clave> = 64
id = TL001; acción = no sé; remitente = @ autoridad \ .tld $; ccert_fingerprint = AA: BB: CC ..
id = TL002; action = RECHAZAR huella dactilar TLS incorrecta; remitente = @ autoridad \ .tld $
id = TL003; acción = RECHAZAR tls keylength <64; remitente = @ secreto \ .tld $; tamaño_de_cifrado = 64

## Controles RBL combinados
# Esto rechazará el correo si
# 1. listado en ix.dnsbl.manitu.net
# 2. enumerado en zen.spamhaus.org (sbl y xbl, tiempo de espera de caché dns 1200 s en lugar de 3600 s)
# 3. listado en el mínimo 2 de bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
# 4. listado en bl.spamcop.net y uno de rhsbl.ahbl.org, rhsbl.sorbs.net
id = RBL01; action = REJECT listado en ix.dnsbl.manitu.net; rbl = ix.dnsbl.manitu.net
id = RBL02; action = REJECT listado en zen.spamhaus.org; rbl = zen.spamhaus.org / 127.0.0. [2-8] / 1200
id = RBL03; action = REJECT aparece en demasiadas RBL; rblcount = 2; rbl = bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
id = RBL04; acción = RECHAZAR control combinado RBL + RHSBL; rbl = bl.spamcop.net; rhsbl = rhsbl.ahbl.org, rhsbl.sorbs.net

## Tamaño del mensaje (requiere que message_size_limit se establezca en 30000000)
# 1. 30 MB para sistemas en * .customer1.tld
# 2. 20 MB para joejob de usuario SASL
# 3. 10 MB por defecto
id = SZ001; protocol_state == FIN DE MENSAJE; acción = DUNNO; tamaño <= 30000000; nombre_cliente = \. cliente1.tld $
id = SZ002; protocol_state == FIN DE MENSAJE; acción = DUNNO; tamaño <= 20000000; sasl_username == joejob
id = SZ002; protocol_state == FIN DE MENSAJE; acción = DUNNO; tamaño <= 10000000
id = SZ100; protocol_state == FIN DE MENSAJE; action = REJECT mensaje demasiado grande

## Lista gris selectiva
##
## Tenga en cuenta que postfwd no incluye listas grises. Esta configuración requiere un servicio postgrey en ejecución
## en el puerto 10031 y la siguiente clase de restricción de sufijo en su main.cf:
##
## smtpd_restriction_classes = check_postgrey, ...
## check_postgrey = check_policy_service inet: 127.0.0.1: 10031
#
# 1. si aparece en zen.spamhaus.org con resultados 127.0.0.10 o .11, tiempo de espera de caché dns 1200 s
# 2. El cliente no tiene rDNS
# 3. El cliente proviene de varios dominios de marcación
id = GR001; action = check_postgrey; rbl = dul.dnsbl.sorbs.net, zen.spamhaus.org/127.0.0.1[01]/1200
id = GR002; action = check_postgrey; nombre_cliente = ^ desconocido $
id = GR003; action = check_postgrey; nombre_cliente = \. (t-ipconnect | alicedsl | ish) \. de $

## Fecha y hora
fecha = 24.12.2007-26.12.2007; action = 450 4.7.1 oficina cerrada durante navidad
tiempo = 04: 00: 00-05: 00: 00; action = 450 4.7.1 mantenimiento en curso, inténtelo de nuevo más tarde
tiempo = -07: 00: 00; sasl_username = jim; acción = 450 4.7.1 hasta temprano para ti, jim
hora = 22: 00: 00-; sasl_username = jim; acción = 450 4.7.1 hasta tarde ahora, jim
meses = -Abr; action = 450 4.7.1 nos vemos en mayo
días = !! Lunes a viernes; action = check_postgrey

## Uso de salto
# Lo siguiente permite un tamaño de mensaje de 30 MB para diferentes
# usuarios / clientes, mientras que otros solo tendrán 10 MB.
id = R001; acción = saltar (R100); sasl_username = ^ (Alice | Bob | Jane) $
id = R002; acción = saltar (R100); dirección_cliente = 192.168.1.0 / 24
id = R003; acción = saltar (R100); ccert_fingerprint = AA: BB: CC: DD: ...
id = R004; acción = saltar (R100); ccert_fingerprint = AF: BE: CD: DC: ...
id = R005; acción = saltar (R100); ccert_fingerprint = DD: CC: BB: DD: ...
id = R099; protocol_state == FIN DE MENSAJE; acción = mensaje de RECHAZO demasiado grande (máx. 10 MB); tamaño = 10000000
id = R100; protocol_state == FIN DE MENSAJE; acción = mensaje de RECHAZO demasiado grande (máx. 30 MB); tamaño = 30000000

## Uso de la puntuación
# Lo siguiente rechaza un correo, si el cliente
# - aparece en 1 RBL y 1 RHSBL
# - aparece en 1 RBL o 1 RHSBL y no tiene rDNS correcto
# - otros clientes sin rDNS correctos serán seleccionados en la lista gris
#: algunas listas blancas se utilizan para reducir la puntuación
id = S01; puntuación = 2.6; action = check_postgrey
id = S02; puntuación = 5.0; action = REJECT postfwd puntuación demasiado alta
id = R00; acción = puntuación (-1.0); rbl = exetions.ahbl.org, list.dnswl.org, query.bondedsender.org, spf.trusted-forwarder.org
id = R01; acción = puntuación (2.5); rbl = bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
id = R02; acción = puntuación (2.5); rhsbl = rhsbl.ahbl.org, rhsbl.sorbs.net
id = N01; acción = puntuación (-0.2); nombre_cliente == $$ nombre_helo
id = NO02; acción = puntuación (2.7); nombre_cliente = ^ desconocido $
...

## Uso de tarifa y tamaño
# El siguiente temporal rechaza solicitudes de clientes "desconocidos", si
# 1. superó las 30 solicitudes por hora o
# 2. intenté enviar más de 1.5 MB en 10 minutos
id = RATE01; nombre_cliente == desconocido; protocol_state == RCPT
action = rate (client_address / 30/3600/450 4.7.1 lo siento, máximo 30 solicitudes por hora)
id = TAMAÑO01; nombre_cliente == desconocido; protocol_state == FIN DE MENSAJE
action = size (client_address / 1572864/600/450 4.7.1 lo siento, máximo 1.5mb por 10 minutos)

## macros
# definición
&& RBLS {rbl = zen.spamhaus.org, list.dsbl.org, bl.spamcop.net, dnsbl.sorbs.net, ix.dnsbl.manitu.net; };
&& GONOW {action = RECHAZAR su solicitud hizo que nuestra política de detección de spam rechazara este mensaje. Más info en http://www.domain.local; };
# reglas
&&VE AHORA ; && RBLS; nombre_cliente = ^ desconocido $
&&VE AHORA ; && RBLS; nombre_cliente = (\ d + [\.-_]) {4}
&&VE AHORA ; && RBLS; nombre_cliente = [\.-_] (adsl | dinámico | ppp |) [\.-_]

## Grupos
# definición
&& RBLS {
rbl = zen.spamhaus.org
rbl = list.dsbl.org
rbl = bl.spamcop.net
rbl = dnsbl.sorbs.net
rbl = ix.dnsbl.manitu.net
};
&& RHSBLS {
...
};
&&DINÁMICA{
nombre_cliente == desconocido
nombre_cliente ~ = (\ d + [\.-_]) {4}
nombre_cliente ~ = [\.-_] (adsl | dinámico | ppp |) [\.-_]
...
};
&& BAD_HELO {
helo_name == my.name.tld
helo_name ~ = ^ ([^ \.] +) $
nombre_helo ~ = \. (local | lan) $
...
};
&&MANTENIMIENTO{
fecha = 15.01.2007
fecha = 15.04.2007
fecha = 15.07.2007
fecha = 15.10.2007
time=03:00:00 - 04:00:00
};
# reglas
id = COMBINADO; && RBLS; && DYNAMIC; acción = RECHAZAR cliente dinámico y listado en RBL
id = MANTENIMIENTO; &&MANTENIMIENTO ; action = Aplazar el tiempo de mantenimiento; inténtelo de nuevo más tarde

# ahora con el comando set (), tenga en cuenta que el elemento largo
# listas no tienen que compararse dos veces
id = RBL01; && RBLS; acción = establecer (HIT_rbls = 1)
id = HELO01; && BAD_HELO; acción = establecer (HIT_helo = 1)
id = DYNA01; && DYNAMIC; acción = establecer (HIT_dyna = 1)
id = RECHAZO01; HIT_rbls == 1; HIT_helo == 1; action = RECHAZAR por favor vea http://some.org/info? rechazar = 01 para más información
id = RECHAZO02; HIT_rbls == 1; HIT_dyna == 1; action = RECHAZAR por favor vea http://some.org/info? rechazar = 02 para más información
id = REJECT03; HIT_helo == 1; HIT_dyna == 1; action = RECHAZAR por favor vea http://some.org/info? rechazar = 03 para más información

## combinado con características mejoradas de rbl
#
id = RBL01; rhsblcount = todos; rblcount = todo; && RBLS; && RHSBLS
action = set (HIT_dnsbls = $$ rhsblcount, HIT_dnsbls + = $$ rblcount, HIT_dnstxt = $$ dnsbltext)
id = RBL02; HIT_dnsbls> = 2; action = 554 5.7.1 bloqueado usando $$ HIT_dnsbls DNSBLs [INFO: $$ HIT_dnstxt]

analizador
Configuration

El conjunto de reglas postfwd se puede especificar en la línea de comandos (opción -r) o se puede leer desde archivos
(-F). Se mantendrá el orden de sus argumentos. Debería comprobar el analizador con la opción -C |
--showconfig cambiar en la línea de comando antes de aplicar una nueva configuración. La siguiente convocatoria:

postfwd --showconfig\
-r "id = PRUEBA; cuenta_recipiente = 100; acción = correo ADVERTENCIA con más de 100 destinatarios" \
-f /etc/postfwd.cf\
-r "id = PREDETERMINADO; acción = no sé";

producirá la siguiente salida:

Regla 0: id -> acción "TEST" -> "WARN mail con más de 100 destinatarios"; cuenta_recibidor -> "100"
...
... ...
...
Regla : id -> acción "DEFAULT" -> "no sé"

Se agregarán varios elementos del mismo tipo a las listas (consulte la sección "ARTÍCULOS" para obtener más
información):

postfwd --showconfig\
-r "dirección_cliente = 192.168.1.0 / 24; dirección_cliente = 172.16.26.32; acción = no sé"

resultará en:

Regla 0: id -> "R-0"; acción -> "no sé"; dirección_cliente -> "192.168.1.0/24, 172.16.26.32"

Las macros se evalúan en la etapa de configuración, lo que significa que

postfwd --showconfig\
-r "&& RBLS {rbl = bl.spamcop.net; nombre_cliente = ^ desconocido $;};" \
-r "id = RBL001; && RBLS; action = REJECT listado en spamcop y bad rdns";

resultará en:

Regla 0: id -> "RBL001"; acción -> "REJECT aparece en spamcop y bad rdns"; rbl -> "bl.spamcop.net"; nombre_cliente -> "^ desconocido $"

Solicitar retiro tratamiento

Cuando llegue una solicitud de delegación de políticas, se comparará con el conjunto de reglas de postfwd. A
inspeccione el procesamiento en detalle, debe aumentar la verboridad usando el uso de "-v" o "-vv"
cambiar. "-L" redirige los mensajes de registro a stdout.

Manteniendo el orden del conjunto de reglas en general, los elementos se compararán en orden aleatorio, lo que
básicamente significa que

id = R001; acción = no sé; dirección_cliente = 192.168.1.1; remitente =[email protected]

igual a

id = R001; remitente =[email protected]; dirección_cliente = 192.168.1.1; acción = no sé

Las listas se evaluarán en el orden especificado. Esto permite colocar más rápido
expresiones al principio:

postfwd -vv -L -r "id = RBL001; rbl = localrbl.local zen.spamhaus.org; action = RECHAZAR" /some/where/request.sample

produce lo siguiente

[Información de LOGS]: compare rbl: "remotehost.remote.net [68.10.1.7]" -> "localrbl.local"
[Información de LOGS]: count1 rbl: "2" -> "0"
[Información de LOGS]: consulta rbl: localrbl.local 7.1.10.68 (7.1.10.68.localrbl.local)
[Información de LOGS]: count2 rbl: "2" -> "0"
[Información de LOGS]: match rbl: FALSE
[Información de LOGS]: compare rbl: "remotehost.remote.net [68.10.1.7]" -> "zen.spamhaus.org"
[Información de LOGS]: count1 rbl: "2" -> "0"
[Información de LOGS]: consulta rbl: zen.spamhaus.org 7.1.10.68 (7.1.10.68.zen.spamhaus.org)
[Información de LOGS]: count2 rbl: "2" -> "0"
[Información de LOGS]: match rbl: FALSE
[Información de LOGS]: Acción: no sé

¡¡El operador de negación !! ( ) tiene la máxima prioridad y, por lo tanto, se evaluará
primero. Luego se realizan sustituciones de variables:

postfwd -vv -L -r "id = TEST; action = REJECT; client_name = !! ($$ heloname)" /some/where/request.sample

daré

[Información de LOGS]: comparar client_name: "unknown" -> "!! ($$ helo_name)"
[Información de LOGS]: negate client_name: "unknown" -> "$$ helo_name"
[Información de LOGS]: sustituto client_name: "unknown" -> "english-breakfast.cloud8.net"
[Información de LOGS]: coincide con client_name: TRUE
[Información de LOGS]: Acción: RECHAZAR

Conjunto de reglas evaluación

Una regla se aplica cuando todos los elementos (o al menos un elemento de una lista para cada elemento) coinciden.
Tan pronto como un elemento (o todos los elementos de una lista) no se comparen con la solicitud
atributo, el analizador saltará a la siguiente regla en el conjunto de reglas postfwd.

Si una regla coincide, hay dos opciones:

* La regla devuelve la acción de sufijo (no sé, rechazar, ...) El analizador detiene el procesamiento de la regla y
devuelve la acción a postfix. No se evaluarán otras reglas.

* La regla devuelve la acción postfwd (salto(), Nota(), ...) El analizador evalúa la acción dada
y continúa con la siguiente regla (a excepción de la salto() or dejar() acciones - por favor vea el
Sección "ACCIONES" para más información). No se enviará nada a postfix.

Si ninguna regla ha coincidido y se llega al final del conjunto de reglas, postfwd devolverá no sé
sin registrar nada a menos que esté en modo detallado. Simplemente puede colocar un último `catch-allAX
regla para cambiar ese comportamiento:

... ...
id = PREDETERMINADO; acción = no sé

registrará cualquier solicitud que pase el conjunto de reglas sin haber alcanzado una regla previa.

INTEGRACIÓN
Integración: vía demonio modo

La forma común de usar postfwd es iniciarlo como demonio, escuchando en un puerto tcp específico.
Como postfwd se ejecutará en una sola instancia (modo de multiplexación), se beneficiará al máximo de
es el almacenamiento en caché interno en ese caso. Inicie postfwd con los siguientes parámetros:

postfwd -d -f /etc/postfwd.cf -i 127.0.0.1 -p 10040 -u nadie -g nadie -S

Para un almacenamiento en caché eficiente, debe verificar si puede usar las opciones --cache-rdomain-only,
--cache-no-sender y --cache-no-size.

Ahora revise sus syslogs (instalación predeterminada "mail") para una línea como:

9 de agosto 23:00:24 correo postfwd [5158]: postfwd n.nn listo para entrada

y use `netstat -an | grep 10040` para buscar algo como

tcp 0 0:127.0.0.1 10040:* ESCUCHAR

Si todo funciona, abra su postfix main.cf e inserte lo siguiente

127.0.0.1:10040_time_limit = 3600 <--- integración
smtpd_recipient_restrictions = permit_mynetworks <--- recomendado
rechazar_unauth_destino <--- recomendado
check_policy_service inet: 127.0.0.1: 10040 <--- integración

Vuelva a cargar su configuración con `postfix reload` y observe sus registros. En eso trabaja usted
Debería ver líneas como las siguientes en su registro de correo:

9 de agosto 23:01:24 correo postfwd [5158]: rule = 22, id = ML_POSTFIX, client = english-breakfast.cloud9.net [168.100.1.7], sender =[email protected], destinatario =[email protected], helo = english-breakfast.cloud9.net, proto = ESMTP, state = RCPT, action = no sé

Si desea verificar el tamaño o los elementos de rcpt_count, debe integrar postfwd en
smtp_data_restrictions o smtpd_end_of_data_restrictions. Por supuesto, también puede especificar un
clase de restricción y utilícela en sus tablas de acceso. Primero crea un archivo
/ etc / postfix / policy que contiene:

dominio1.local postfwdcheck
dominio2.local postfwdcheck
...

Luego mapee ese archivo (`hash de postmap: / etc / postfix / policy`), abra su main.cf e ingrese

# Clases de restricción
smtpd_restriction_classes = postfwdcheck, ... <--- integración
postfwdcheck = check_policy_service inet: 127.0.0.1: 10040 <--- integración

127.0.0.1:10040_time_limit = 3600 <--- integración
smtpd_recipient_restrictions = permit_mynetworks, <--- recomendado
rechazar_unauth_destino, <--- recomendado
... <--- opcional
check_recipient_access hash: / etc / postfix / policy, <--- integración
... <--- opcional

Vuelva a cargar postfix y observe sus registros.

Integración: vía xinetd

Puede haber varias razones para que use postfwd a través de un paquete de envoltura tcp como
xinetd (verhttp://www.xinetd.org/>). No discutiré eso aquí. Si planeas hacerlo,
simplemente agregue la siguiente línea a su / etc / services archivo:

# puerto postfwd
postfwd 10040 / tcp

Luego cree un archivo '/etc/xinetd.d/postfwd':

{
interfaz = 127.0.0.1
socket_type = flujo
protocolo = tcp
esperar = no
usuario = nadie
servidor = / usr / local / bin / postfwd
argumentos_servidor = -f /etc/postfwd.cf
deshabilitar = no
}

y reinicie el demonio xinetd (normalmente un SIGHUP debería estar bien). Si experimentas
problemas, es posible que desee comprobar el registro de su sistema en busca de errores xinetd como "socket ya
en uso".

La integración con postfix es similar a la Integración: vía demonio modo la sección de arriba.
Vuelva a cargar postfix y observe sus registros para ver si todo funciona.

Servicios
Primero debe crear un conjunto de reglas (consulte la sección Configuración). Compruébalo con

postfwd -f /etc/postfwd.cf -C

Hay una solicitud de política de ejemplo distribuida con postfwd, llamada 'request.sample'.
Simplemente cámbielo para cumplir con sus requisitos y use

postfwd -f /etc/postfwd.cf

Deberías obtener una respuesta como

acción =

Para las pruebas de red utilizo netcat:

nc 127.0.0.1 10040

para enviar una solicitud a postfwd. Si no recibe nada, asegúrese de que se esté ejecutando postfwd
y escucha en la configuración de red especificada.

ACTUACIÓN
Es posible que algunas de estas propuestas no coincidan con su entorno. Por favor verifique sus requisitos
¡y pruebe las nuevas opciones con cuidado!

- usar opciones de almacenamiento en caché
- use el operador de coincidencia correcto ==, <=,> =
- use ^ y / o $ en expresiones regulares
- utilizar listas de elementos (más rápido que las reglas individuales)
- use la acción set () en listas de elementos repetidos
- utilizar saltos y límites de velocidad
- use una regla de búsqueda previa para rbl / rhsbls con la acción note () vacía

VEA O
Verhttp://www.postfix.org/SMTPD_POLICY_README.html> para obtener una descripción de cómo Postfix
los servidores de políticas funcionan.

Utilice postfwd1 en línea utilizando los servicios de onworks.net