postfwd2 - En ligne dans le Cloud

PROGRAMME:

Nom

postfwd2 - démon de pare-feu postfix

SYNOPSIS

postfwd2 [OPTIONS] [SOURCE1, SOURCE2, ...]

Ensemble de règles : (au moins une, une utilisation multiple est autorisée) :
-f, --fichier lit les règles de
-r, --règle ajoute à configurer
-s, --scores = Retour lorsque le score dépasse

Serveur:
-i, --interface écouter sur l'interface
-p, --port écouter sur le port
--proto type de socket (tcp ou unix)
--server_socket par exemple tcp:127.0.0.1:10045
-u, --user définir l'uid sur l'utilisateur
-g, --groupe définir gid sur groupe
--umask umask pour les autorisations de fichier principal
--server_umask umask pour les autorisations de fichiers du serveur
--pidfile créer un fichier pid sous
--min_servers génère
--max_servers
--min_spare_servers
--max_spare_servers nombre

Cache:
-c, --cache définit le délai d'expiration du cache de la demande sur secondes
--cleanup-requests intervalle de nettoyage en secondes pour le cache de requêtes
--cache_interface écouter sur l'interface
--cache_port écouter sur le port
--cache_proto type de socket (tcp ou unix)
--cache_socket par exemple tcp:127.0.0.1:10043
--cache_umask umask pour les autorisations de fichier de cache
--cacheid liste des éléments de demande pour cache-id
--cache-rdomain-only ignore la partie locale du destinataire pour l'identifiant du cache
--cache-no-sender ignore l'adresse de l'expéditeur pour le cache-id
--cache-no-size ignore la taille du cache-id
--no_parent_request_cache désactive le cache des requêtes parentales
--no_parent_rate_cache désactiver le cache de taux parent
--no_parent_dns_cache désactiver le cache DNS parent (par défaut)
--no_parent_cache désactive tous les caches parents

Tarifs:
--nettoyage-taux intervalle de nettoyage en secondes pour le cache de taux

Contrôle:
-k, --kill, --stop terminer postfwd2
--reload, --hup recharger postfwd2
--chien de garde minuteur de surveillance en secondes
--respawn délai de réapparition en secondes
--les échecs compteur d'échecs de réapparition max
--démons liste des démons à démarrer
--dumpcache afficher le contenu du cache
--dumpstats affiche les statistiques
-R, --chroot chrooter à avant de commencer
--delcache supprime un élément du cache de requêtes
--delrate supprime un élément du cache de taux

DNS:
-n, --nodns ignore tout test basé sur DNS
--dns_timeout
--dns_timeout_max
--dns_timeout_interval
--cache-rbl-timeout
--cache-rbl-default modèle DNS par défaut s'il n'est pas spécifié dans l'ensemble de règles
--cleanup-rbls
--dns_async_txt effectue les recherches dnsbl A et TXT simultanément
--dns_max_ns_lookups max noms à rechercher avec sender_ns_addrs
--dns_max_mx_lookups max noms à rechercher avec sender_mx_addrs

Optionnel:
-t, --test testing, renvoie toujours "je ne sais pas"
-S, --summary
--noidlestats désactive les statistiques en cas d'inactivité
--norulestats désactive les statistiques par règle
-I, --instantcfg recharge l'ensemble de règles à chaque nouvelle requête
--config_timeout
--keep_rates n'efface pas les compteurs de limite de débit lors du rechargement
--save_rates limites de taux de sauvegarde et de chargement sur le disque
--fast_limit_evaluation évalue les limites de débit avant que l'ensemble de règles ne soit analysé
(veuillez noter les limites)

Plugins:
--plugins charge les plugins postfwd à partir du fichier

Enregistrement:
-l, --logname étiquette pour les messages syslog
--facility utilise la fonction syslog
--socktype utilise syslog socktype
--nodnslog n'enregistre pas les résultats DNS
--anydnslog enregistre tous les résultats DNS (même mis en cache)
--norulelog n'enregistre pas les actions de règle
--nolog|--perfmon aucune journalisation du tout
-v, --verbose verbose logging, utiliser deux fois pour augmenter
--debug liste des classes de débogage

Informations (à utiliser uniquement en ligne de commande !) :
-h, --help affiche cette aide et quitte
-m, --manual affiche le manuel du programme
-V, --version affiche les informations de version et quitte
-D, --defaults affiche les paramètres postfwd2 et quitte
-C, --showconfig affiche l'ensemble de règles postfwd2 et quitte (-v autorisé)
-L, --stdout redirige les messages syslog vers stdout
-q, --quiet pas de journalisation système, pas de sortie standard (-P fonctionne pour la compatibilité)

Obsolète (uniquement pour compatibilité avec postfwd v1) :
-d|--daemon, --shortlog, --dns_queuesize, --dns_retries

DESCRIPTION

INTRODUCTION
postfwd2 est écrit pour combiner des restrictions postfix complexes dans un ensemble de règles similaires à celles
de la plupart des pare-feu. Le programme utilise le protocole de délégation de politique de postfix pour contrôler
accès au système de messagerie avant qu'un message ne soit accepté (veuillez visiter
<http://www.postfix.org/SMTPD_POLICY_README.html> pour plus d'informations).

postfwd2 vous permet de choisir une action (par exemple rejeter, je ne sais pas) pour une combinaison de plusieurs
paramètres smtp (comme l'adresse de l'expéditeur et du destinataire, la taille ou l'empreinte TLS du client).
Il propose également des macros/acls simples qui devraient permettre une lecture simple et facile
configurations.

Caractéristiques :

* Combinaisons complexes de paramètres smtp

* Recherches RBL/RHSBL combinées avec des actions arbitraires en fonction des résultats

* Système de notation

* Règles basées sur la date/heure

* Macros/ACL, groupes, négation

* Comparer les attributs de demande (par exemple client_name et helo_name)

* Mise en cache interne pour les requêtes et les recherches DNS

* Statistiques intégrées pour l'analyse de l'efficacité des règles

CONFIGURATION
Une ligne de configuration se compose de paires optionnelles élément=valeur, séparées par des points-virgules (`;`)
et l'action souhaitée appropriée :

[ = ; = ; ... ] action=

Exemple :

adresse_client=192.168.1.1 ; expéditeur==[email protected] ; action=REJETER

Cela refusera tous les courriers de 192.168.1.1 avec l'expéditeur de l'enveloppe [email protected]. L'ordre de
les éléments ne sont pas importants. Ainsi, ce qui suit conduirait au même résultat que le
exemple précédent :

action=REJETER ; adresse_client=192.168.1.1 ; expéditeur==[email protected]

La manière dont les éléments de demande sont comparés à l'ensemble de règles peut être influencée dans les éléments suivants
façon:

================================================== ==================
ITEM == VALUE true si ITEM est égal à VALUE
ITEM => VALUE vrai si ITEM >= VALUE
ITEM =< VALUE vrai si ITEM <= VALUE
ITEM > VALUE vrai si ITEM > VALUE
ITEM < VALUE vrai si ITEM < VALUE
ITEM =~ VALUE vrai si ITEM ~= /^VALUE$/i
ITEM != VALUE false si ITEM est égal à VALUE
ITEM !> VALUE false si ITEM >= VALUE
ITEM !< VALUE false si ITEM <= VALUE
ITEM !~ VALUE false si ITEM ~= /^VALUE$/i
ITEM = VALUE comportement par défaut (voir la section ARTICLES)
================================================== ==================

Pour identifier des règles uniques dans vos fichiers journaux, vous pouvez ajouter un identifiant unique pour chacun des
il:

identifiant=R_001 ; action=REJETER ; adresse_client=192.168.1.1 ; expéditeur==[email protected]

Vous pouvez utiliser ces identifiants comme cible pour le `saut()` (voir la section ACTIONS
au dessous de). Les espaces blancs de début ou de fin seront ignorés. Utilisez '#' pour commenter votre
configuration. Les autres apprécieront.

Un ensemble de règles se compose d'une ou plusieurs règles, qui peuvent être chargées à partir de fichiers ou transmises comme
arguments de ligne de commande. Veuillez consulter la section LIGNE DE COMMANDE ci-dessous pour plus d'informations sur
ce sujet.

Depuis la version 1.30 de postfwd, les règles couvrant plusieurs lignes peuvent être définies en préfixant
les lignes suivantes avec un ou plusieurs caractères d'espacement (ou '}' pour les macros) :

identifiant=RULE001
adresse_client=192.168.1.0/24
expéditeur==[email protected]
action=REJECT pas d'accès

Les versions postfwd antérieures à la 1.30 nécessitent un ';' de fin et les caractères '\' :

identifiant=RULE001 ; \
adresse_client=192.168.1.0/24 ; \
expéditeur==[email protected]; \
action=REJECT pas d'accès

ARTICLES
id - un identifiant de règle unique, qui peut être utilisé pour l'analyse des journaux
Les identifiants servent également de cibles pour la commande "jump".

date, heure - une heure ou une plage de dates dans la règle spécifiée doit atteindre
#FORMAT :
# 29 février
date = 29.02.2008/XNUMX/XNUMX
# 24 - 26 décembre
date=24.12.2008-26.12.2008
# à partir d'aujourd'hui jusqu'au 23 novembre
date=-23.09.2008
# du 1er avril à aujourd'hui

date=01.04.2008-
jours, mois - une plage de jours de la semaine (dim-sam) ou de mois (jan-déc)
dans la règle spécifiée doit frapper

score - lorsque le score spécifié est atteint (voir la section ACTIONS)
l'action spécifiée sera retournée à postfix
les scores sont définis globalement jusqu'à ce qu'ils soient redéfinis !

request_score - cette valeur permet d'accéder au score d'une requête. ce
peut être utilisé comme variable ($$request_score).

rbl, rhsbl, - interroge les RBL/RHSBL spécifiés, les valeurs possibles sont :
rhsbl_client, [/ / , / / ]
rhsbl_sender, (par défaut : reply=^127\.0\.0\.\d+$ maxcache=3600)
rhsbl_reverse_client les résultats de toutes les requêtes rhsbl_* seront combinés
dans rhsbl_count (voir ci-dessous).

rblcount, rhsblcount - nombre d'accès RBL/RHSBL minimum pour correspondre. si non spécifié
un seul coup RBL/RHSBL correspondra aux éléments rbl/rhsbl.
vous pouvez spécifier « all » pour évaluer tous les éléments et utiliser
comme variable dans une action (voir la section ACTIONS)
(par défaut : 1)

sender_localpart, - le local-/domainpart de l'adresse de l'expéditeur
domaine_expéditeur

destinataire_localpart, - le local-/domainpart de l'adresse du destinataire
domaine_destinataire

helo_address - postfwd2 essaie de rechercher le helo_name. utilisation
helo_address=!!(0.0.0.0/0) pour vérifier les inconnus.
Veuillez ne pas l'utiliser pour un contrôle d'accès positif
(liste blanche), car il pourrait être falsifié.

sender_ns_names, - postfwd2 essaie de rechercher les noms/adresses IP
sender_ns_addrs des serveurs de noms pour la partie domaine de l'expéditeur.
Veuillez ne pas l'utiliser pour un contrôle d'accès positif
(liste blanche), car il pourrait être falsifié.

sender_mx_names, - postfwd2 essaie de rechercher les noms/adresses IP
sender_mx_addrs des enregistrements mx pour la partie domaine de l'expéditeur.
Veuillez ne pas l'utiliser pour un contrôle d'accès positif
(liste blanche), car il pourrait être falsifié.

version - version postfwd2, contient "postfwd2 n.nn"
cela permet des vérifications basées sur la version dans vos ensembles de règles
(par exemple pour les migrations). fonctionne aussi avec les anciennes versions,
car un élément inexistant renvoie toujours false :
# version >= 1.10
identifiant=R01; version~=1\.[1-9][0-9] ; sender_domain==some.org \
; action=REJECT désolé pas d'accès

ratecount - disponible uniquement pour les actions rate(), size() et rcpt().
contient le compteur limite réel :
identifiant=R01; action=rate(sender/200/600/REJECT limite de 200 dépassée [$$ratecount hits])
identifiant=R02 ; action=rate(sender/100/600/WARN limite de 100 dépassée [$$ratecount hits])

En plus de cela, vous pouvez spécifier n'importe quel attribut du protocole de délégation de politique de postfix.
N'hésitez pas à les combiner comme vous en avez besoin (consultez la section EXEMPLES ci-dessous).

La plupart des valeurs peuvent être spécifiées en tant qu'expressions régulières (PCRE). Veuillez consulter le tableau ci-dessous pour
détails:

# ================================================= =========
# ARTICLE=TYPE DE VALEUR
# ================================================= =========
id=quelque chose masque = chaîne
date=01.04.2007-22.04.2007 masque = date (JJ.MM.AAAA-JJ.MM.AAAA)
heure=08:30:00-17:00:00 masque = heure (HH:MM:SS-HH:MM:SS)
jours=Lun-Mer masque = jours de la semaine (Lun-Mer) ou numérique (1-3)
mois=Fév-Avr masque = mois (Fév-Avr) ou numérique (1-3)
score = 5.0 masque = valeur maximale en virgule flottante
rbl=zen.spamhaus.org masque = / / [,...]
rblcount=2 mask = numérique, correspondra si rbl atteint >= 2
helo_address= masque = CIDR[,CIDR,...]
sender_ns_names=some.domain.tld masque = PCRE
sender_mx_names=some.domain.tld masque = PCRE
sender_ns_addrs= masque = CIDR[,CIDR,...]
sender_mx_addrs= masque = CIDR[,CIDR,...]
# -------------------------------
# Postfix version 2.1 et supérieure :
# -------------------------------
adresse_client= masque = CIDR[,CIDR,...]
client_name=another.domain.tld masque = PCRE
reverse_client_name=another.domain.tld masque = PCRE
helo_name=some.domain.tld masque = PCRE
expéditeur=[email protected] masque = PCRE
destinataire =[email protected] masque = PCRE
destinataire_compte=5 masque = numérique, correspondra si destinataires >= 5
# -------------------------------
# Postfix version 2.2 et supérieure :
# -------------------------------
sasl_method=masque simple = PCRE
sasl_username=vous masque = PCRE
sasl_sender=masque = PCRE
size=12345 mask = numérique, correspondra si size >= 12345
ccert_subject=blackhole.nowhere.local mask = PCRE (uniquement si tls vérifié)
ccert_issuer=John+20Doe mask = PCRE (uniquement si tls vérifié)
ccert_fingerprint=AA:BB:CC:DD:EE:... mask = PCRE (NE PAS utiliser "..." ici)
# -------------------------------
# Postfix version 2.3 et supérieure :
# -------------------------------
cryptage_protocol=masque TLSv1/SSLv3 = PCRE
cryptage_cipher=Masque DHE-RSA-AES256-SHA = PCRE
cryptage_keysize=256 mask = numérique, correspondra si keysize >= 256
...

la liste actuelle peut être trouvée àhttp://www.postfix.org/SMTPD_POLICY_README.html>. S'il te plaît
lire attentivement quel attribut peut être utilisé à quel niveau de la transaction smtp
(par exemple, la taille ne fonctionnera de manière fiable qu'au niveau FIN DE MESSAGE). La correspondance des motifs est
effectué insensible à la casse.

L'utilisation multiple du même élément est autorisée et sera comparée à un OU logique, ce qui signifie que
cela fonctionnera comme prévu:

identifiant=CONFIANCE001; action=OK ; cryptage_keysize=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
expéditeur=@domaine\.local$

les éléments client_address, rbl et rhsbl peuvent également être spécifiés comme étant séparés par des espaces ou des virgules
valeurs:

id=SKIP01; action=je ne sais pas
adresse_client=192.168.1.0/24, 172.16.254.23
id=SKIP02; action=je ne sais pas
adresse_client= 10.10.3.32 10.216.222.0/27

Les éléments suivants doivent être uniques :

id, valeurs minimales et maximales, rblcount et rhsblcount

Tout élément peut être annulé en précédant « !! » à celui-ci, par exemple :

id=HOST001 ; nom d'hôte == !!secure.trust.local ; action=REJET uniquement secure.trust.local s'il vous plaît

ou en utilisant le bon opérateur de comparaison :

id=HOST001 ; nom d'hôte != secure.trust.local ; action=REJECT only secure.trust.local s'il vous plaît

Pour éviter toute confusion avec les expressions régulières ou simplement pour une meilleure visibilité, vous pouvez utiliser '!!(...)' :

identifiant=UTILISATEUR01 ; sasl_username =~ !!( /^(bob|alice)$/ ) ; action=REJETER qui est-ce ?

Les attributs de requête peuvent être comparés en précédant les caractères '$$', par exemple :

identifiant=R-003 ; nom_client = !! $$nom_hélicoptère ; action=WARN helo ne correspond pas au DNS
# ou
identifiant=R-003 ; client_name = !!($$(helo_name)) ; action=WARN helo ne correspond pas au DNS

Ceci n'est valable que pour les valeurs PCRE (voir liste ci-dessus). La comparaison sera effectuée comme
correspondance exacte insensible à la casse. Utilisez l'option '-vv' pour déboguer.

Ces objets spéciaux seront réinitialisés pour toute nouvelle règle :

rblcount - contient le nombre de réponses RBL
rhsblcount - contient le nombre de réponses RHSBL
matchs - contient le nombre d'éléments correspondants
dnsbltext - contient la partie DNS TXT de toutes les réponses RBL et RHSBL sous la forme
rbltype:rblname: ; rbltype:rblname: ; ...

Ces objets spéciaux seront modifiés pour toute règle de correspondance :

request_hits - contient les identifiants de toutes les règles de correspondance

Cela signifie qu'il peut être nécessaire de les enregistrer si vous prévoyez d'utiliser ces valeurs dans
règles ultérieures :

# valeurs définies
identifiant=RBL01 ; rhsblcount=all ; rblcount=tous
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

# comparer
identifiant=RBL02 ; HIT_rhls>=1 ; HIT_rbls>=1 ; action=554 5.7.1 bloqué à l'aide des RHSBL $$HIT_rhls et des RBL $$HIT_rbls [INFO : $$HIT_txt]
identifiant=RBL03 ; HIT_rhls>=2 ; action=554 5.7.1 bloqué à l'aide des RHSBL $$HIT_rhls [INFO : $$HIT_txt]
identifiant=RBL04 ; HIT_rbls>=2 ; action=554 5.7.1 bloqué à l'aide des RBL $$HIT_rbls [INFO : $$HIT_txt]

DES DOSSIERS
Depuis postfwd1 v1.15 et postfwd2 v0.18, les longues listes d'éléments peuvent être stockées dans des fichiers séparés :

identifiant=R001 ; ccert_fingerprint==fichier:/etc/postfwd/wl_ccerts ; action=SAUVE

postfwd2 lira une liste d'éléments (un élément par ligne) à partir de /etc/postfwd/wl_ccerts.
les commentaires sont autorisés :

#client1
11:22:33:44:55:66:77:88:99
#client2
22:33:44:55:66:77:88:99:00
#client3
33:44:55:66:77:88:99:00:11

Pour utiliser des tables existantes au format clé=valeur, vous pouvez utiliser :

identifiant=R001 ; ccert_fingerprint==table:/etc/postfwd/wl_ccerts ; action=SAUVE

Cela ignorera la valeur de droite. Les articles peuvent être mélangés :

identifiant=R002 ; action=REJETER
client_name==inconnu
nom_client==fichier :/etc/postfwd/liste noire

et pour les éléments non pcre (séparés par des virgules) :

identifiant=R003 ; action=REJETER
client_address==10.1.1.1, fichier :/etc/postfwd/blacklisted

identifiant=R004 ; action=REJETER
rbl=myrbl.home.local, zen.spamhaus.org, fichier :/etc/postfwd/rbls_changing

Vous pouvez vérifier votre configuration avec l'option --show_config sur la ligne de commande :

# postfwd2 --showconfig --rule='action=DUNNO; adresse_client=10.1.0.0/16, fichier :/etc/postfwd/wl_clients, 192.168.2.1'

devrait donner quelque chose comme :

Règle 0 : id->"R-0" ; action->"NE SAIS PAS" ; adresse_client->"=;10.1.0.0/16, =;194.123.86.10, =;186.4.6.12, =;192.168.2.1"

Si un fichier ne peut pas être lu, il sera ignoré :

# postfwd2 --showconfig --rule='action=DUNNO; adresse_client=10.1.0.0/16, fichier :/etc/postfwd/wl_clients, 192.168.2.1'
[avertissement LOG] : erreur : fichier /etc/postfwd/wl_clients introuvable - le fichier sera ignoré ?
Règle 0 : id->"R-0" ; action->"NE SAIS PAS" ; adresse_client->"=;10.1.0.0/16, =;192.168.2.1"

Les éléments de fichier sont évalués au stade de la configuration. Par conséquent, postfwd2 doit être rechargé
si un fichier a changé

Si vous souhaitez spécifier un fichier, qui sera rechargé à chaque requête, vous pouvez utiliser lfile :
et ltable :

identifiant=R001; client_address=lfile:/etc/postfwd/client_whitelist ; action=je ne sais pas

Cela vérifiera l'heure de modification de /etc/postfwd/client_whitelist à chaque fois que la règle
est évalué et rechargez-le si nécessaire. Bien sûr, cela pourrait augmenter la charge du système, donc
veuillez l'utiliser avec précaution.

L'option --showconfig illustre la différence :

## évalué au stade de la configuration
# postfwd2 --nodaemon -L --rule='client_address=table:/etc/postfwd/clients; action=sais pas' -C
Règle 0 : id->"R-0" ; action->"je ne sais pas" ; adresse_client->"=;1.1.1.1, =;1.1.1.2, =;1.1.1.3"

## évalué pour toute règle atteinte
# postfwd2 --nodaemon -L --rule='client_address=ltable:/etc/postfwd/clients; action=sais pas' -C
Règle 0 : id->"R-0" ; action->"je ne sais pas" ; adresse_client->"=;ltable:/etc/postfwd/clients"

Les fichiers peuvent faire référence à d'autres fichiers. Ce qui suit est valable.

-- FICHIER /etc/postfwd/rules.cf --
identifiant=R01; adresse_client=fichier :/etc/postfwd/clients_master.cf ; action=SAUVE

-- FICHIER /etc/postfwd/clients_master.cf --
192.168.1.0/24
fichier :/etc/postfwd/clients_east.cf
fichier :/etc/postfwd/clients_west.cf

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

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

Notez qu'il n'y a actuellement aucune détection de boucle (/a/file appelle /a/file) et que cette
La fonctionnalité n'est disponible qu'avec postfwd1 v1.15 et postfwd2 v0.18 et supérieur.

ACTIONS
Général

Les actions seront exécutées lorsque tous les éléments de règle correspondent à une requête (ou au moins à l'un des
n'importe quelle liste d'articles). Vous pouvez faire référence aux attributs de requête en précédant les caractères $$, comme :

identifiant=R-003 ; client_name = !!$$helo_name; action=WARN helo '$$helo_name' ne correspond pas au DNS '$$client_name'
# ou
identifiant=R-003 ; client_name = !!$$helo_name; action=WARN helo '$$(helo_name)' ne correspond pas au DNS '$$(client_name)'

postfix actes

Les actions recevront une réponse à postfix en tant que résultat des demandes de délégation de politique. N'importe quelle action
que postfix comprend est autorisé - voir "man 5 access" ou
<http://www.postfix.org/access.5.html> pour une description. Si aucune action n'est spécifiée, le
L'action WARN postfix qui enregistre simplement l'événement sera utilisée pour la règle correspondante.

postfwd2 retournera je ne sais pas s'il a atteint la fin de l'ensemble de règles et qu'aucune règle n'a
assorti. Cela peut être modifié en plaçant une dernière règle contenant uniquement une instruction d'action :

...
action = je ne sais pas ; [email protected] # l'expéditeur est ok
action=rejeter # refuser par défaut

postfwd2 actes

Les actions postfwd2 contrôlent le comportement du programme. Actuellement, vous pouvez spécifier le
Suivante à la suite:

saut ( )
saute à la règle avec id , utilisez-le pour ignorer certaines règles.
vous pouvez sauter en arrière - mais rappelez-vous qu'il n'y a pas de boucle
détection en ce moment ! les sauts vers des identifiants inexistants seront ignorés.

But ( )
le score de la demande sera modifié par le ,
qui doit être une valeur à virgule flottante. le modificateur peut être soit
+n.nn ajoute n.nn au score actuel
-n.nn soustrait n.nn du score actuel
*n.nn multiplie le score actuel par n.nn
/n.nn divise le score actuel par n.nn
=n.nn définit le score actuel sur n.nn
si le score dépasse le maximum fixé par l'option `--scores` (voir
LIGNE DE COMMANDE) ou l'élément de score (voir la section ÉLÉMENTS), l'action
défini pour ce cas sera retourné (par défaut : 5.0=>"REJECT postfwd2 score dépassé").

ensemble ( = , = ,...)
cette commande vous permet d'insérer ou de remplacer des attributs de demande, qui peuvent alors être
par rapport à votre autre ensemble de règles. utilisez-le pour accélérer les comparaisons répétées avec de grandes listes d'articles.
veuillez consulter la section EXEMPLES pour plus d'informations. vous pouvez séparer plusieurs paires clé=valeur
par "," caractères.

taux ( / / / )
cette commande crée un compteur pour le donné , qui sera augmentée chaque fois qu'une demande
le contenant arrive. s'il dépasse dans secondes il reviendra à postfixer.
les compteurs de taux sont très rapides car ils sont exécutés avant que l'ensemble de règles ne soit analysé.
veuillez noter que était limité aux actions postfix (pas d'actions postfwd) pour les versions postfwd <1.33 !
# pas plus de 3 requêtes toutes les 5 minutes
# du même client "inconnu"
id=RATE01 ; client_name==inconnu
action=rate(client_address/3/300/450 4.7.1 désolé, max 3 requêtes par 5 minutes)

Taille ( / / / )
cette commande fonctionne de manière similaire à la commande rate() avec la différence que le compteur de taux est
augmenté de l'attribut size de la requête. pour le faire de manière fiable, vous devez appeler postfwd2 depuis
smtpd_end_of_data_restrictions. si vous voulez être sûr, vous pouvez le vérifier dans l'ensemble de règles :
# taille limite 1.5 Mo par heure et par client
id=TAILLE01 ; protocol_state==END-OF-MESSAGE ; adresse_client==!!(10.1.1.1)
action=size(client_address/1572864/3600/450 4.7.1 désolé, max 1.5 Mo par heure)

rcpt ( / / / )
cette commande fonctionne de manière similaire à la commande rate() avec la différence que le compteur de taux est
augmenté de l'attribut receiver_count de la demande. pour le faire de manière fiable, vous devez appeler postfwd
depuis smtpd_data_restrictions ou smtpd_end_of_data_restrictions. si vous voulez être sûr, vous pouvez
vérifiez-le dans l'ensemble de règles :
Nombre de destinataires limité à 3 par heure et par client
identifiant=RCPT01 ; protocol_state==END-OF-MESSAGE ; adresse_client==!!(10.1.1.1)
action=rcpt(client_address/3/3600/450 4.7.1 désolé, max 3 destinataires par heure)

taux5321,taille5321,rcpt5321 ( / / / )
identique aux fonctions non-5321 correspondantes, à la différence que la partie locale de
Les adresses d'expéditeur ou de destinataire sont évaluées en tenant compte de la casse conformément à la rfc5321. Cette
signifie que les demandes de [email protected] et [email protected] sera traité différemment

interroger ( : [: ])
permet de déléguer la décision de politique à un autre service de politique (par exemple postgrey). la première
et le deuxième argument (adresse et port) sont obligatoires. un troisième argument facultatif peut être
spécifié pour dire à postfwd2 d'ignorer certaines réponses et de continuer à analyser l'ensemble de règles :
# exemple1 : interroge postgrey et renvoie sa réponse à postfix
id=GRIS; adresse_client==10.1.1.1; action=demander (127.0.0.1:10031)
# exemple2 : interrogez postgrey mais ignorez sa réponse, si elle correspond à 'DUNNO'
# et continuez l'analyse du jeu de règles de postfwd
id=GRIS; adresse_client==10.1.1.1; action=demander(127.0.0.1:10031:^dunno$)

mail(serveur/helo/de/vers/sujet/corps)
Cette commande est obsolète. Vous devriez essayer d'utiliser l'action sendmail() à la place.
Commande de messagerie très basique, qui envoie un message avec les arguments donnés. LIMITES:
Cela exécute essentiellement un telnet. Aucune authentification ou TLS n'est disponible. De plus il fait
pas suivre l'état de notification et vous informera à tout moment, la règle correspondante est appliquée.

sendmail(sendmail-path::from::to::subject::body)
Commande Mail, qui utilise un binaire sendmail existant et envoie un message avec les arguments donnés.
LIMITATIONS : La commande ne suit pas l'état de la notification et vous avertira à tout moment, le
hits de règle correspondants (ce qui pourrait signifier 100 mails pour un mail avec 100 destinataires au stade RCPT).

attendre ( )
suspend l'exécution du programme pendant secondes. utiliser ceci pour
retarder ou étrangler les connexions.

Remarque ( )
enregistre simplement la chaîne donnée et continue d'analyser l'ensemble de règles.
si la chaîne est vide, rien ne sera enregistré (noop).

quitter ( )
termine le programme avec le code de sortie donné. le suffixe ne
comme ça trop, alors utilisez-le avec précaution.

Vous pouvez faire référence à des attributs de demande, comme

id=R-HELO ; helo_name=^[^\.]+$ ; action=REJETER l'hélicoptère invalide '$$helo_name'

MACROS/ACLS
L'utilisation multiple d'éléments longs ou de combinaisons d'entre eux peut être abrégée par des macros. Celles
doit être préfixé par '&&' (deux caractères '&'). Tout d'abord, les macros doivent être définies comme
suit:

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

Ensuite, ceux-ci peuvent être utilisés dans vos règles, comme :

&&RBLS ; nom_client=^inconnu$ ; action=REJETER
&&RBLS ; nom_client=(\d+[\.-_]){4} ; action=REJETER
&&RBLS ; client_name=[\.-_](adsl|dynamic|ppp|)[\.-_] ; action=REJETER

Les macros peuvent également contenir des actions :

# définition
&&GONOW { action=REJECT votre demande a entraîné le rejet de ce message par notre politique de détection des spams. Plus d'infos sur http://www.domain.local; } ;
# règles
&&GONOW ; &&RBLS ; client_name=^inconnu$
&&GONOW ; &&RBLS ; nom_client=(\d+[\.-_]){4}
&&GONOW ; &&RBLS ; client_name=[\.-_](adsl|dynamic|ppp|)[\.-_]

Les macros peuvent également contenir des macros :

# définition
&&RBLS{
rbl=zen.spamhaus.org
rbl=list.dsbl.org
rbl=bl.spamcop.net
rbl=dnsbl.sorbs.net
rbl=ix.dnsbl.manitu.net
};
&&DYNAMIQUE{
client_name=^inconnu$
nom_client=(\d+[\.-_]){4}
nom_client=[\.-_](adsl|dynamique|ppp|)[\.-_]
};
&&GOAWAY { &&RBLS; &&DYNAMIQUE; } ;
# règles
&&VA-T'EN ; action=REJECT client dynamique et répertorié sur RBL

Fondamentalement, les macros sont de simples substitutions de texte - voir la section "PARSER" pour plus d'informations
</br>L’Information.

PLUGINS
Description

L'interface du plugin vous permet de définir vos propres vérifications et d'améliorer celles de postfwd
Fonctionnalité. N'hésitez pas à partager des choses utiles !

Avertissement

Notez que l'interface du plugin est encore au stade de développement. Merci de tester vos plugins
avec précaution, car des erreurs peuvent entraîner la rupture de postfwd ! Il est également permis de passer outre
attributs ou fonctions intégrées, mais assurez-vous de savoir ce que vous faites car certains
elles sont utilisées en interne.

Veuillez garder à l'esprit la sécurité lorsque vous accédez à des ressources sensibles et que vous n'exécutez jamais
postfwd en tant qu'utilisateur privilégié ! Ne vous fiez pas non plus à vos entrées (en particulier les noms d'hôtes et les adresses e-mail
adresses).

ARTICLES

Les plugins d'élément sont des sous-routines perl qui intègrent des attributs supplémentaires aux requêtes avant
ils sont évalués par rapport à l'ensemble de règles de postfwd comme tout autre élément de la délégation de politique
protocole. Cela vous permet de créer vos propres chèques.

plugin-items ne peut pas être utilisé de manière sélective. ces fonctions seront exécutées pour chaque demande
postfwd reçoit, alors gardez à l'esprit les performances.

SYNOPSIS : %result = postfwd_items_plugin{ }(%demander)

signifie que votre sous-programme, appelé , a accès à un hachage appelé %request, qui
contient tous les attributs de requête, comme $request{client_name} et doit renvoyer une valeur dans le
forme suivante :

enregistrer : $résultat{ } =

cela crée le nouvel élément contenant , qui sera intégré dans le
demande de délégation de politique et peut donc être utilisé dans l'ensemble de règles de postfwd.

# ne supprime PAS la ligne suivante
%postfwd_items_plugin = (

# EXEMPLES - intégré dans postfwd. pas besoin de les activer ici.

# permet de vérifier la version postfwd dans l'ensemble de règles
"version" => sous {
ma(%requête) = @_;
mon(%résultat) = (
"version" => $NOM." ".$VERSION,
);
renvoie %résultat ;
},

# domaine_expéditeur et domaine_destinataire
"address_parts" => sous {
ma(%requête) = @_;
mon(%résultat) = ();
$demande{expéditeur} =~ /@([^@]*)$/ ;
$result{sender_domain} = ($1 || '');
$request{destinataire} =~ /@([^@]*)$/;
$result{recipient_domain} = ($1 || '');
renvoie %résultat ;
},

# ne supprime PAS la ligne suivante
);

COMPARER

Les plugins de comparaison vous permettent de définir comment vos nouveaux éléments doivent être comparés à l'ensemble de règles.
Ceux-ci sont facultatifs. Si vous n'en spécifiez pas, la valeur par défaut (== pour une correspondance exacte, =~ pour
PCRE, ...) sera utilisé.

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

# ne supprime PAS la ligne suivante
%postfwd_compare_plugin = (

EXEMPLES - intégré dans postfwd. pas besoin de les activer ici.

# Exemple simple
# SYNOPSIS : = (retourner &{$postfwd_compare{ }}(@_))
"client_address" => sub { return &{$postfwd_compare{cidr}}(@_); },
"size" => sub { return &{$postfwd_compare{numeric}}(@_); },
"recipient_count" => sub { return &{$postfwd_compare{numeric}}(@_); },

# Exemple complexe
# SYNOPSIS : = ( , , , )
"numérique" => sous {
mon($cmp,$val,$monarticle,%requête) = @_;
mon($monrésultat) = undef; $monélément ||= "0" ; $val ||= "0" ;
if ($cmp eq '==') {
$monrésultat = ($monélément == $val);
} elsif ($cmp eq '=<') {
$monrésultat = ($monélément <= $val);
} elsif ($cmp eq '=>') {
$myresult = ($myitem >= $val);
} elsif ($cmp eq '<') {
$monrésultat = ($monélément < $val);
} elsif ($cmp eq '>') {
$monrésultat = ($monélément > $val);
} elsif ($cmp eq '!=') {
$monrésultat = not($monélément == $val);
} elsif ($cmp eq '!<') {
$myresult = not($myitem <= $val);
} elsif ($cmp eq '!>') {
$myresult = not($myitem >= $val);
} Else {
$myresult = ($myitem >= $val);
};
renvoie $monrésultat ;
},

# ne supprime PAS la ligne suivante
);

ACTIONS

Les plugins d'action permettent de définir de nouvelles actions postfwd. En définissant le $stop-flag, vous pouvez
décider de continuer ou d'arrêter l'analyse du jeu de règles.

RÉSUMÉ : ( , , , , ) =
( , , , , , )

# ne supprime PAS la ligne suivante
%postfwd_actions_plugin = (

# EXEMPLES - intégré dans postfwd. pas besoin de les activer ici.

# Remarque( ) commande
"note" => sous {
mon($index,$maintenant,$mycmd,$myarg,$myline,%request) = @_;
mon($monaction) = 'je ne sais pas'; mon($stop) = 0;
log_info "[REGLES] ".$maligne." - note : ".$monarg if $myarg;
return ($stop,$index,$monaction,$maligne,%request);
},

# passe au suivant règles
"sauter" => sous {
mon($index,$maintenant,$mycmd,$myarg,$myline,%request) = @_;
mon($monaction) = 'je ne sais pas'; mon($stop) = 0;
$index += $myarg if ( $myarg and not(($index + $myarg) > $#Rules) );
return ($stop,$index,$monaction,$maligne,%request);
},

# vide le contenu de la requête actuelle dans syslog
"dumprequest" => sous {
mon($index,$maintenant,$mycmd,$myarg,$myline,%request) = @_;
mon($monaction) = 'je ne sais pas'; mon($stop) = 0;
map { log_info "[DUMP] rule=$index, Attribut : $_=$request{$_}" } (clés %request);
return ($stop,$index,$monaction,$maligne,%request);
},

# ne supprime PAS la ligne suivante
);

COMMAND LINE
Ensemble de règles

Les arguments suivants sont utilisés pour spécifier la source de l'ensemble de règles postfwd2. Ça signifie
qu'au moins l'un des éléments suivants est requis pour que postfwd2 fonctionne.

-f, --fichier
Lit les règles de . Veuillez consulter la section CONFIGURATION
ci-dessous pour plus d'informations.

-r, --règle
Ajoute à l'ensemble de règles. N'oubliez pas que vous devrez peut-être citer
des chaînes contenant des espaces ou des caractères shell.

Scoring

-s, --scores =
Retour à postfix, lorsque le score de la requête dépasse

L'utilisation multiple est autorisée. Enchaînez simplement vos arguments, comme :

postfwd2 -r " = ;action= " -F -F ...
or
postfwd2 --scores 4.5="AVERTISSEMENT score élevé" --scores 5.0="REJET postfwd2 score trop élevé" ...

En cas de scores multiples, le match le plus élevé comptera. L'ordre des arguments sera
être reflété dans le jeu de règles postfwd2.

Networking

postfwd2 peut être exécuté en tant que démon afin qu'il écoute sur le réseau les requêtes entrantes.
Les arguments suivants contrôleront son comportement dans ce cas.

-d, --démon
postfwd2 s'exécutera en tant que démon et écoutera sur le réseau les informations entrantes
requêtes (par défaut 127.0.0.1:10045).

-i, --interface
Liez postfwd2 à l'interface spécifiée (par défaut 127.0.0.1).

-p, --port
postfwd2 écoute sur le port spécifié (tcp/10045 par défaut).

--proto
Le type de protocole pour la socket de postfwd. Actuellement, vous pouvez utiliser 'tcp' ou 'unix' ici.
Pour utiliser postfwd2 avec un socket de domaine unix, exécutez-le comme suit :
postfwd2 --proto=unix --port=/quelque part/postfwd.socket

-u, --user
Change l'utilisateur réel et effectif en .

-g, --groupe
Change le groupe réel et efficace en .

--umask
Modifie l'umask pour les permissions de fichiers du processus maître (pidfile).
Attention : Ceci est umask, pas chmod - vous devez spécifier les bits qui
ne devrait PAS s'appliquer. Ex : umask 077 équivaut à chmod 700.

--cache_umask
Modifie l'umask pour les permissions de fichiers du processus de cache (socket de domaine unix).

--server_umask
Modifie l'umask pour les permissions de fichiers du processus serveur (socket de domaine unix).

-R, --chroot
Chrootez le processus sur le chemin spécifié.
Regardez s'il vous plaît http://postfwd.org/postfwd2-chroot.html Avant utilisation!

--pidfile
L'identifiant du processus sera enregistré dans le fichier spécifié.

--établissement
définit la fonction syslog, la valeur par défaut est 'mail'

--type de chaussette
définit le socktype Sys::Syslog sur 'native', 'inet' ou 'unix'.
La valeur par défaut est de détecter automatiquement cela en fonction de la version du module et du système d'exploitation.

-l, --logname
Étiquete les messages syslog. Utile lors de l'exécution de plusieurs
instances de postfwd.

--loglen
Tronque tout message syslog après personnages.

Plugins

--plugins
Charge les plugins postfwd à partir du fichier. S'il te plait regarde http://postfwd.org/postfwd.plugins
ou le plugins.postfwd.sample qui est disponible à partir de l'archive pour plus d'informations.

Optionnel arguments

Ces paramètres influencent le fonctionnement de postfwd2. N'importe lequel d'entre eux peut être combiné.

-v, --verbeux
La journalisation détaillée affiche de nombreuses informations utiles mais peut
vos fichiers journaux de croître sensiblement. Utilisez-le donc avec prudence. Définir l'option
deux fois (-vv) pour obtenir plus d'informations (consigne tous les attributs de la demande).

-c, --cache (par défaut=600)
Délai d'expiration pour le cache des requêtes, les résultats pour les requêtes identiques seront
mis en cache jusqu'à ce que la configuration soit rechargée ou cette fois (en secondes) expirée.
Un paramètre de 0 désactive cette fonction.

--cache-pas de taille
Ignore l'attribut de taille pour les comparaisons de cache, ce qui conduira à une meilleure
taux d'accès au cache. Vous devez définir cette option, si vous n'utilisez pas la taille
élément dans votre ensemble de règles.

--cache-no-expéditeur
Ignore l'adresse de l'expéditeur pour les comparaisons de cache, ce qui conduira à une meilleure
taux d'accès au cache. Vous devez définir cette option, si vous n'utilisez pas l'expéditeur
élément dans votre ensemble de règles.

--cache-rdomain-uniquement
Cela supprimera la partie locale de l'adresse du destinataire avant de remplir le
cache. Cela peut augmenter considérablement les taux d'accès au cache.

--cache-rbl-timeout (par défaut=3600)
Cette valeur par défaut sera utilisée comme délai d'attente en secondes pour les éléments de cache rbl,
s'il n'est pas spécifié dans le jeu de règles.

--cache-rbl-default (par défaut=^127\.0\.0\.\d+$)
Allumettes aux réponses rbl/rhsbl (regexp) si non spécifié dans l'ensemble de règles.

--cacheid , , ...
Cette liste d'attributs de requête séparés par csv sera utilisée pour construire
l'identifiant du cache de requêtes. N'utilisez ceci que si vous savez exactement ce que vous
faites. Si, par exemple, vous n'utilisez postfwd2 que pour le contrôle RBL/RHSBL,
vous pouvez régler ceci sur
postfwd2 --cache=3600 --cacheid=nom_client,adresse_client
Cela augmente l'efficacité de la mise en cache et améliore les performances de postfwd.
Avertissement : Vous devez lister ici tous les éléments qui sont utilisés dans votre ensemble de règles !

--cleanup-requests (par défaut=600)
Le cache des demandes sera recherché pour les éléments expirés après cette dans
secondes. C'est une valeur minimale. Le processus de nettoyage n'aura lieu que lorsque
une nouvelle demande arrive.

--cleanup-rbls (par défaut=600)
Le cache rbl sera recherché pour les éléments expirés après cette dans
secondes. C'est une valeur minimale. Le processus de nettoyage n'aura lieu que lorsque
une nouvelle demande arrive.

--nettoyage-taux (par défaut=600)
Le cache de taux sera recherché pour les éléments expirés après cette dans
secondes. C'est une valeur minimale. Le processus de nettoyage n'aura lieu que lorsque
une nouvelle demande arrive.

-S, --résumé (par défaut=600)
Affiche des statistiques d'utilisation (temps de fonctionnement du programme, compteur de demandes, règles de correspondance)
tous secondes. Cette option est incluse par le commutateur -v.
Cette fonctionnalité utilise le signal d'alarme, vous pouvez donc forcer postfwd2 à vider les statistiques
en utilisant `kill -ALRM ` (où est l'identifiant du processus de postfwd).

Exemple :
19 août 12:39:45 mail1 postfwd[666] : [STATS] Compteurs : 213000 secondes de disponibilité, 39 règles
19 août 12:39:45 mail1 postfwd[666] : [STATS] Requêtes : 71643 au total, 49 dernier intervalle, 62.88 % d'accès au cache
19 août 12:39:45 mail1 postfwd[666] : [STATS] Moyennes : 20.18 au total, 4.90 au dernier intervalle, 557.30 en haut
19 août 12:39:45 mail1 postfwd[666] : [STATS] Contenu : 44 requêtes mises en cache, 239 résultats dnsbl mis en cache
19 août 12:39:45 mail1 postfwd[666] : [STATS] ID de règle : R-001 correspondant : 2704 fois
19 août 12:39:45 mail1 postfwd[666] : [STATS] ID de règle : R-002 correspondant : 9351 fois
19 août 12:39:45 mail1 postfwd[666] : [STATS] ID de règle : R-003 correspondant : 3116 fois
...

--pas de règles
Désactive les statistiques par règle. Maintient votre journal propre, si vous ne les utilisez pas.
Cette option n'a aucun effet sans --summary ou --verbose défini.

-L, --stdout
Redirige tous les messages syslog vers stdout pour le débogage. Ne l'utilisez jamais avec postfix !

-t, --test
En mode test, postfwd2 renvoie toujours "je ne sais pas", mais se connecte en fonction
à son ensemble de règles. -v sera défini automatiquement avec cette option.

-n, --nodns
Désactive toutes les vérifications basées sur DNS comme les vérifications RBL. Règles contenant
ces éléments seront ignorés.

-n, --nodnslog
Désactive la journalisation des événements DNS.

--dns_timeout (par défaut : 14)
Définit le délai d'attente pour les requêtes DNS asynchrones en secondes. Cette valeur s'appliquera à
tous les éléments DNS d'une règle.

--dns_timeout_max (par défaut : 10)
Définit le compteur de délai d'attente maximal pour les recherches dnsbl. Si les temporisations dépassent cette valeur
le dnsbl correspondant sera désactivé pendant un certain temps (voir --dns_timeout_interval).

--dns_timeout_interval (par défaut=1200)
Le compteur de temporisation dnsbl sera nettoyé après cet intervalle en secondes. Utilisez ceci
en conjonction avec le paramètre --dns_timeout_max.

--dns_async_txt
Effectuez des recherches dnsbl A et TXT simultanément (sinon uniquement pour les annonces avec au
au moins un enregistrement A). Cela nécessite plus de bande passante réseau en raison de l'augmentation des requêtes, mais
peut augmenter le débit car les recherches peuvent être parallélisées.

--dns_max_ns_lookups (par défaut=0)
maximum de noms ns à rechercher avec l'élément sender_ns_addrs. utilisez 0 pour aucun maximum.

--dns_max_mx_lookups (par défaut=0)
maximum de noms mx à rechercher avec l'élément sender_mx_addrs. utilisez 0 pour aucun maximum.

-Je, --instantcfg
Les fichiers de configuration, spécifiés par -f seront relus pour chaque requête
postfwd2 reçoit. Cela permet des changements de configuration à la volée
sans redémarrer. Bien que les fichiers ne soient lus que si nécessaire
(ce qui signifie que leurs temps d'accès ont changé depuis la dernière lecture) cela pourrait
augmenter considérablement la charge du système.

--config_timeout (par défaut=3)
timeout en secondes pour analyser une seule ligne de configuration. en cas de dépassement, la règle sera
être ignoré. ceci est utilisé pour éviter les problèmes dus à des fichiers volumineux ou à des boucles.

--keep_rates (défaut=0)
Avec cette option définie, postfwd2 n'efface pas les compteurs de limite de débit lors du rechargement. S'il te plaît
notez que vous devez redémarrer (pas recharger) postfwd avec cette option si vous changez
toute règle de limite de taux.

--save_rates (par défaut=aucun)
Avec cette option, postfwd enregistre les compteurs de limite de débit existants sur le disque et les recharge
au démarrage du programme. Cela permet des limites de débit persistantes lors des redémarrages ou des redémarrages du programme.
Veuillez noter que postfwd a besoin d'un accès en lecture et en écriture au fichier spécifié.

--fast_limit_evaluation (défaut=0)
Une fois qu'une limite de débit a été définie par l'ensemble de règles, les futures demandes seront évaluées en fonction de celle-ci
avant de consulter le jeu de règles. Ce mode était le comportement par défaut jusqu'à la v1.30.
Avec ce mode les limites de débit seront plus rapides, mais aussi éventuellement mises en place
whitelisting-rules dans l'ensemble de règles peut ne pas fonctionner comme prévu.
LIMITATIONS : Cette option n'autorise pas les commandes postfwd imbriquées comme
action=taux(expéditeur/3/60/attendez(3))
Cette option ne fonctionne pas avec les fonctions rate() strict-rfc5321.

D'information arguments

Ces arguments sont uniquement destinés à une utilisation en ligne de commande. Ne les utilisez jamais avec postfix !

-C, --showconfig
Affiche l'ensemble de règles actuel. Utilisez -v pour la sortie détaillée.

-V, --version
Affiche la version du programme.

-h, --aide
Affiche l'utilisation du programme.

-m, --manuel
Affiche le manuel du programme.

-D, --valeurs par défaut
affiche les paramètres postfwd2 complets.

-P, --perfmon
Cette option désactive tout syslogging et sortie. C'est inclus
pour les tests de performances.

--dumpstats
Affiche les statistiques d'utilisation du programme.

--dumpcache
Affiche le contenu du cache.

--delcache
Supprime un élément du cache de requêtes. Utilisez --dumpcache pour identifier les objets.
Par exemple:
# postfwd --dumpcache
...
%rate_cache -> %sender=[email protected] -> %RATE002+2_600 -> @count -> '1'
%rate_cache -> %sender=[email protected] -> %RATE002+2_600 -> @maxcount -> '2'
...
# postfwd --delrate="expéditeur=[email protected]"
évaluer l'élément de cache 'expéditeur=[email protected]' supprimé

--delrate
Supprime un élément du cache de taux. Utilisez --dumpcache pour identifier les objets.

REFRESH
En mode démon, postfwd2 recharge son jeu de règles après avoir reçu un signal HUP. S'il vous plaît voir le
description du commutateur '-I' pour rafraîchir votre configuration à chaque requête
postfwd2 reçoit.

EXEMPLES
## liste blanche
# 1. réseaux 192.168.1.0/24, 192.168.2.4
# 2. noms_clients *.gmx.net et *.gmx.de
# 3. expéditeur *@someshop.tld du 11.22.33.44
identifiant=WL001; action=je ne sais pas ; adresse_client=192.168.1.0/24, 192.168.2.4
identifiant=WL002 ; action=je ne sais pas ; nom_client=\.gmx\.(net|de)$
identifiant=WL003 ; action=je ne sais pas ; sender=@someshop\.tld$ ; adresse_client=11.22.33.44

## Contrôle TLS
# 1. *@authority.tld uniquement avec une empreinte TLS correcte
# 2. *@secret.tld uniquement avec des tailles de clé >=64
identifiant=TL001 ; action=je ne sais pas ; sender=@autorité\.tld$ ; ccert_fingerprint=AA:BB:CC..
identifiant=TL002 ; action=REJECT mauvaise empreinte TLS ; expéditeur=@autorité\.tld$
identifiant=TL003 ; action=REJECT tls keylength < 64 ; sender=@secret\.tld$ ; cryptage_keysize=64

## Chèques RBL combinés
# Ceci rejettera le courrier si
#1. répertorié sur ix.dnsbl.manitu.net
# 2. répertorié sur zen.spamhaus.org (sbl et xbl, dns cache timeout 1200s au lieu de 3600s)
# 3. répertorié sur min 2 de bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
# 4. répertorié sur bl.spamcop.net et l'un de rhsbl.ahbl.org, rhsbl.sorbs.net
identifiant=RBL01 ; action=REJECT répertorié sur ix.dnsbl.manitu.net ; rbl=ix.dnsbl.manitu.net
identifiant=RBL02 ; action=REJECT répertorié sur zen.spamhaus.org ; rbl=zen.spamhaus.org/127.0.0.[2-8]/1200
identifiant=RBL03 ; action=REJECT répertorié sur trop de RBL ; rblcount=2 ; rbl=bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
identifiant=RBL04 ; action=REJET contrôle combiné RBL+RHSBL ; rbl=bl.spamcop.net ; rhsbl=rhsbl.ahbl.org, rhsbl.sorbs.net

## Taille du message (nécessite que message_size_limit soit défini sur 30000000)
# 1. 30 Mo pour les systèmes en *.customer1.tld
# 2. 20 Mo pour l'utilisateur SASL joejob
# 3. 10 Mo par défaut
identifiant=SZ001; protocol_state==END-OF-MESSAGE ; action=NE SAIS PAS ; taille<=30000000 ; nom_client=\.client1.tld$
identifiant=SZ002; protocol_state==END-OF-MESSAGE ; action=NE SAIS PAS ; taille<=20000000 ; sasl_username==joejob
identifiant=SZ002; protocol_state==END-OF-MESSAGE ; action=NE SAIS PAS ; taille<=10000000
identifiant=SZ100 ; protocol_state==END-OF-MESSAGE ; action=REJET message trop volumineux

## Liste grise sélective
##
## Notez que postfwd n'inclut pas les listes grises. Cette configuration nécessite un service postgrey en cours d'exécution
## au port 10031 et la classe de restriction de suffixe suivante dans votre main.cf :
##
## smtpd_restriction_classes = check_postgrey, ...
## check_postgrey = check_policy_service inet:127.0.0.1:10031
#
# 1. si répertorié sur zen.spamhaus.org avec les résultats 127.0.0.10 ou .11, délai d'expiration du cache DNS 1200s
# 2. Le client n'a pas de rDNS
# 3. Le client provient de plusieurs domaines de connexion
identifiant=GR001; action=check_postgrey ; rbl=dul.dnsbl.sorbs.net, zen.spamhaus.org/127.0.0.1[01]/1200
identifiant=GR002 ; action=check_postgrey ; client_name=^inconnu$
identifiant=GR003 ; action=check_postgrey ; nom_client=\.(t-ipconnect|alicedsl|ish)\.de$

## Date Heure
date=24.12.2007-26.12.2007 ; action=450 4.7.1 bureau fermé pendant noël
heure=04:00:00-05:00:00 ; action=450 4.7.1 maintenance en cours, réessayer plus tard
heure=-07:00:00 ; sasl_username=jim ; action=450 4.7.1 trop tôt pour toi, jim
heure=22:00:00- ; sasl_username=jim ; action=450 4.7.1 à tard maintenant, jim
mois=-Avr ; action=450 4.7.1 rendez-vous en mai
jours=!!Lun-Ven ; action=check_postgrey

## Utilisation du saut
# Ce qui suit autorise une taille de message de 30 Mo pour différents
# utilisateurs/clients tandis que d'autres n'auront que 10 Mo.
identifiant=R001 ; action=saut(R100) ; sasl_username=^(Alice|Bob|Jane)$
identifiant=R002 ; action=saut(R100) ; adresse_client=192.168.1.0/24
identifiant=R003 ; action=saut(R100) ; ccert_fingerprint=AA:BB:CC:DD:...
identifiant=R004 ; action=saut(R100) ; ccert_fingerprint=AF:BE:CD:DC:...
identifiant=R005 ; action=saut(R100) ; ccert_fingerprint=DD:CC:BB:DD:...
identifiant=R099 ; protocol_state==END-OF-MESSAGE ; action=REJET message trop gros (max. 10 Mo) ; taille=10000000
identifiant=R100 ; protocol_state==END-OF-MESSAGE ; action=REJET message trop gros (max. 30 Mo) ; taille=30000000

## Utilisation de la partition
# Ce qui suit rejette un mail, si le client
# - est cotée sur 1 RBL et 1 RHSBL
# - est répertorié dans 1 RBL ou 1 RHSBL et n'a pas de rDNS correct
# - les autres clients sans rDNS correct seront vérifiés par liste grise
# - certaines listes blanches sont utilisées pour baisser le score
identifiant=S01 ; note=2.6 ; action=check_postgrey
identifiant=S02 ; note=5.0 ; action=REJECT score postfwd trop élevé
identifiant=R00 ; action=score(-1.0) ; rbl=exemptions.ahbl.org,list.dnswl.org,query.bondedsender.org,spf.trusted-forwarder.org
identifiant=R01 ; action=score(2.5) ; rbl=bl.spamcop.net, list.dsbl.org, dnsbl.sorbs.net
identifiant=R02 ; action=score(2.5) ; rhsbl=rhsbl.ahbl.org, rhsbl.sorbs.net
identifiant=N01 ; action=score(-0.2) ; client_name==$$helo_name
identifiant=N02 ; action=score(2.7) ; client_name=^inconnu$
...

## Utilisation du taux et de la taille
# L'élément temporaire suivant rejette les demandes des clients "inconnus", s'ils
# 1. dépassé 30 demandes par heure ou
# 2. essayé d'envoyer plus de 1.5 Mo en 10 minutes
id=RATE01 ; nom_client==inconnu ; protocol_state==RCPT
action=rate(client_address/30/3600/450 4.7.1 désolé, max 30 requêtes par heure)
id=TAILLE01 ; nom_client==inconnu ; protocol_state==END-OF-MESSAGE
action=size(client_address/1572864/600/450 4.7.1 désolé, max 1.5 Mo par 10 minutes)

## Macro
# définition
&&RBLS { rbl=zen.spamhaus.org,list.dsbl.org,bl.spamcop.net,dnsbl.sorbs.net,ix.dnsbl.manitu.net; } ;
&&GONOW { action=REJECT votre demande a entraîné le rejet de ce message par notre politique de détection des spams. Plus d'infos sur http://www.domain.local; } ;
# règles
&&GONOW ; &&RBLS ; client_name=^inconnu$
&&GONOW ; &&RBLS ; nom_client=(\d+[\.-_]){4}
&&GONOW ; &&RBLS ; client_name=[\.-_](adsl|dynamic|ppp|)[\.-_]

## Groupes
# définition
&&RBLS{
rbl=zen.spamhaus.org
rbl=list.dsbl.org
rbl=bl.spamcop.net
rbl=dnsbl.sorbs.net
rbl=ix.dnsbl.manitu.net
};
&&RHSBLS{
...
};
&&DYNAMIQUE{
client_name==inconnu
nom_client~=(\d+[\.-_]){4}
nom_client~=[\.-_](adsl|dynamic|ppp|)[\.-_]
...
};
&&MAUVAIS_HELO{
helo_name==mon.nom.tld
helo_name~=^([^\.]+)$
helo_name~=\.(local|lan)$
...
};
&&MAINTENANCE{
date = 15.01.2007/XNUMX/XNUMX
date = 15.04.2007/XNUMX/XNUMX
date = 15.07.2007/XNUMX/XNUMX
date = 15.10.2007/XNUMX/XNUMX
time=03:00:00 - 04:00:00
};
# règles
id=COMBINÉ ; &&RBLS ; &&DYNAMIQUE ; action=REJECT client dynamique et répertorié sur RBL
id=ENTRETIEN ; &&MAINTENANCE ; action=DÉFERER le temps de maintenance - veuillez réessayer plus tard

# maintenant avec la commande set(), notez cet élément long
# listes n'ont pas besoin d'être comparées deux fois
identifiant=RBL01 ; &&RBLS ; action=set(HIT_rbls=1)
id=HELO01 ; &&BAD_HELO ; action=set(HIT_helo=1)
id=DYNA01 ; &&DYNAMIQUE ; action=set(HIT_dyna=1)
id=REJECT01 ; HIT_rbls==1 ; HIT_helo==1 ; action=REJECT s'il vous plaît voir http://some.org/info?reject=01 pour plus d'informations
id=REJET02 ; HIT_rbls==1 ; HIT_dyna==1 ; action=REJECT s'il vous plaît voir http://some.org/info?reject=02 pour plus d'informations
id=REJET03 ; HIT_helo==1 ; HIT_dyna==1 ; action=REJECT s'il vous plaît voir http://some.org/info?reject=03 pour plus d'informations

## combiné avec des fonctionnalités rbl améliorées
#
identifiant=RBL01 ; rhsblcount=all ; rblcount=all ; &&RBLS ; &&RHSBLS
action=set(HIT_dnsbls=$$rhsblcount,HIT_dnsbls+=$$rblcount,HIT_dnstxt=$$dnsbltext)
identifiant=RBL02 ; HIT_dnsbls>=2 ; action=554 5.7.1 bloqué à l'aide des DNSBL $$HIT_dnsbls [INFO : $$HIT_dnstxt]

PARSEUR
Configuration

L'ensemble de règles postfwd2 peut être spécifié sur la ligne de commande (option -r) ou être lu à partir de fichiers
(-F). L'ordre de vos arguments sera conservé. Vous devriez vérifier l'analyseur avec le -C |
--showconfig bascule sur la ligne de commande avant d'appliquer une nouvelle configuration. L'appel suivant :

postfwd2 --showconfig \
-r "id=TEST ; receiver_count=100 ; action=WARN mail avec plus de 100 destinataires" \
-f /etc/postfwd.cf \
-r "id=DEFAUT ; action=je ne sais pas" ;

produira la sortie suivante :

Règle 0 : id->"TEST" action->"WARN mail avec plus de 100 destinataires" ; destinataire_count->"100"
...
... ...
...
Régner : id->"DEFAUT" action->"je ne sais pas"

Plusieurs éléments du même type seront ajoutés aux listes (voir la section « ÉLÉMENTS » pour plus
Info):

postfwd2 --showconfig \
-r "adresse_client=192.168.1.0/24 ; adresse_client=172.16.26.32 ; action=je ne sais pas"

aura pour résultat:

Règle 0 : id->"R-0" ; action->"je ne sais pas" ; adresse_client->"192.168.1.0/24, 172.16.26.32"

Les macros sont évaluées au stade de la configuration, ce qui signifie que

postfwd2 --showconfig \
-r "&&RBLS { rbl=bl.spamcop.net; nom_client=^unknown$; };" \
-r "id=RBL001; &&RBLS; action=REJECT répertorié sur spamcop et mauvais rdns";

aura pour résultat:

Règle 0 : id->"RBL001" ; action->"REJECT listé sur spamcop et bad rdns" ; rbl->"bl.spamcop.net" ; nom_client->"^inconnu$"

Demander traitement

Lorsqu'une demande de délégation de politique arrive, elle sera comparée à l'ensemble de règles de postfwd. À
inspectez le traitement en détail, vous devez augmenter la verbosité en utilisant le "-v" ou "-vv"
changer. "-L" redirige les messages de journal vers stdout.

En gardant l'ordre de l'ensemble de règles en général, les éléments seront comparés dans un ordre aléatoire, ce qui
signifie essentiellement que

identifiant=R001; action=je ne sais pas ; adresse_client=192.168.1.1 ; expéditeur=[email protected]

est égal à

identifiant=R001; expéditeur=[email protected]; adresse_client=192.168.1.1 ; action=je ne sais pas

Les listes seront évaluées dans l'ordre spécifié. Cela permet de placer plus rapidement
expressions dans un premier temps :

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

produit ce qui suit

[Infos LOGS] : comparez rbl : "remotehost.remote.net[68.10.1.7]" -> "localrbl.local"
[Info LOGS] : count1 rbl : "2" -> "0"
[Info LOGS] : requête rbl : localrbl.local 7.1.10.68 (7.1.10.68.localrbl.local)
[Info LOGS] : count2 rbl : "2" -> "0"
[Info LOGS] : match rbl : FALSE
[Info LOGS] : comparez rbl : "remotehost.remote.net[68.10.1.7]" -> "zen.spamhaus.org"
[Info LOGS] : count1 rbl : "2" -> "0"
[Info LOGS] : requête rbl : zen.spamhaus.org 7.1.10.68 (7.1.10.68.zen.spamhaus.org)
[Info LOGS] : count2 rbl : "2" -> "0"
[Info LOGS] : match rbl : FALSE
[Info LOGS] : Action : je ne sais pas

L'opérateur de négation !!( ) a la priorité la plus élevée et sera donc évalué
premier. Ensuite, des substitutions de variables sont effectuées :

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

va donner

[INFO LOGS] : comparez le client_name : "unknown" -> "!!($$helo_name)"
[INFOS LOGS] : negate client_name : "inconnu" -> "$$helo_name"
[INFO LOGS] : remplacez le nom_client : "inconnu" -> "english-breakfast.cloud8.net"
[INFOS LOGS] : correspond au nom_client : TRUE
[Info LOGS] : Action : REJETER

Ensemble de règles évaluation

Une règle est déclenchée lorsque tous les éléments (ou au moins un élément d'une liste pour chaque élément) correspondent.
Dès qu'un élément (ou tous les éléments d'une liste) ne parvient pas à se comparer à la demande
attribut l'analyseur passera à la règle suivante dans l'ensemble de règles postfwd2.

Si une règle correspond, il y a deux options :

* La règle renvoie l'action de suffixe (je ne sais pas, rejeter, ...) L'analyseur arrête le traitement de la règle et
renvoie l'action à postfix. Les autres règles ne seront pas évaluées.

* La règle renvoie l'action postfwd2 (saut(), Remarque(), ...) Le parseur évalue le donné
action et continue avec la règle suivante (sauf pour le saut() or quitter() actions - s'il vous plaît
voir la section « ACTIONS » pour plus d'informations). Rien ne sera envoyé à postfix.

Si aucune règle ne correspond et que la fin de l'ensemble de règles est atteinte, postfwd2 renverra je ne sais pas
sans rien enregistrer sauf en mode verbeux. Vous pouvez placer une dernière règle fourre-tout pour
changer ce comportement :

... ...
id=DEFAUT ; action=je ne sais pas

enregistrera toute demande qui passe l'ensemble de règles sans avoir atteint une règle précédente.

DÉBOGAGE
Pour déboguer des étapes spéciales de l'analyseur, le commutateur '--debug' prend une liste de classes de débogage.
Actuellement, les classes suivantes sont définies :

toutes les configurations de cache debugdns devel dns getcache getdns
getdnspacket rate request setcache setdns
parent_cache parent_dns_cache parent_rate_cache parent_request_cache
enfant_cache enfant_dns_cache enfant_rate_cache enfant_request_cache

INTÉGRATION
Intégration : via démon mode

La façon courante d'utiliser postfwd2 est de le démarrer en tant que démon, en écoutant à un tcp spécifié
Port. postfwd2 engendrera plusieurs processus enfants qui communiquent avec un cache parent.
C'est la meilleure façon d'utiliser postfwd2 dans des environnements à volume élevé. Démarrez postfwd2 avec
les paramètres suivants :

postfwd2 -d -f /etc/postfwd.cf -i 127.0.0.1 -p 10045 -u personne -g personne -S

Pour une mise en cache efficace, vous devez vérifier si vous pouvez utiliser les options --cacheid,
--cache-rdomain-only, --cache-no-sender et --cache-no-size.

Vérifiez maintenant vos syslogs (installation par défaut "mail") pour une ligne comme :

9 août 23:00:24 mail postfwd[5158] : postfwd2 n.nn prêt pour la saisie

et utilisez `netstat -an|grep 10045` pour vérifier quelque chose comme

tcp 0 0 127.0.0.1:10045 0.0.0.0:* ÉCOUTER

Si tout fonctionne, ouvrez votre postfix main.cf et insérez ce qui suit

127.0.0.1:10045_time_limit = 3600 <--- intégration
smtpd_recipient_restrictions = permit_mynetworks <--- recommandé
rejet_unauth_destination <--- recommandé
check_policy_service inet:127.0.0.1:10045 <--- intégration

Rechargez votre configuration avec `postfix reload` et surveillez vos logs. Dans cela fonctionne vous
devrait voir des lignes comme les suivantes dans votre journal de messagerie :

9 août 23:01:24 mail postfwd[5158]: rule=22, id=ML_POSTFIX, client=english-breakfast.cloud9.net[168.100.1.7], sender=[email protected], destinataire=[email protected], helo=english-breakfast.cloud9.net, proto=ESMTP, état=RCPT, action=dunno

Si vous souhaitez vérifier la taille ou les éléments rcpt_count, vous devez intégrer postfwd2 dans
smtp_data_restrictions ou smtpd_end_of_data_restrictions. Bien sûr, vous pouvez également spécifier un
restriction et utilisez-la dans vos tables d'accès. Créez d'abord un fichier
/etc/postfix/policy contenant :

domaine1.local postfwdcheck
domaine2.local postfwdcheck
...

Ensuite, postmap ce fichier (`postmap hash:/etc/postfix/policy`), ouvrez votre main.cf et entrez

# Classes de restriction
smtpd_restriction_classes = postfwdcheck, ... <--- intégration
postfwdcheck = check_policy_service inet:127.0.0.1:10045 <--- intégration

127.0.0.1:10045_time_limit = 3600 <--- intégration
smtpd_recipient_restrictions = permit_mynetworks, <--- recommandé
rejeter_unauth_destination, <--- recommandé
... <--- facultatif
check_recipient_access hash :/etc/postfix/policy, <--- intégration
... <--- facultatif

Rechargez postfix et surveillez vos journaux.

TESTS
Vous devez d'abord créer un ensemble de règles (voir la section Configuration). Vérifiez avec

postfwd2 -f /etc/postfwd.cf -C

Il existe un exemple de requête de politique distribuée avec postfwd, appelée « request.sample ».
Modifiez-le simplement pour répondre à vos besoins et utilisez

postfwd2 -f /etc/postfwd.cf

Vous devriez obtenir une réponse comme

action=

Pour les tests réseau, j'utilise netcat :

nc 127.0.0.1 10045

pour envoyer une demande à postfwd. Si vous ne recevez rien, assurez-vous que postfwd2 est en cours d'exécution
et écouter sur les paramètres réseau spécifiés.

PERFORMANCE
Certaines de ces propositions peuvent ne pas correspondre à votre environnement. Veuillez vérifier vos exigences
et testez attentivement les nouvelles options !

- utiliser les options de mise en cache
- utilisez le bon opérateur de correspondance ==, <=, >=
- utilisez ^ et/ou $ dans les expressions régulières
- utiliser des listes d'articles (plus rapide que des règles simples)
- utiliser l'action set() sur les listes d'éléments répétées
- utiliser des sauts et des limites de taux
- utiliser une règle de pré-recherche pour rbl/rhsbls avec une action note() vide

VOIR AUSSI
Voirhttp://www.postfix.org/SMTPD_POLICY_README.html> pour une description de la façon dont Postfix
les serveurs de politiques fonctionnent.

Utilisez postfwd2 en ligne à l'aide des services onworks.net