Versions Officielles: en
Anglais or
Français
Mainteneur: David Relson <relson@osagesoftware.com>
Traducteur: Fabrice Prigent <Fabrice.Prigent@univ-tlse1.fr>
Ce document a pour but de répondre aux questions fréquemment posées sur Bogofilter.
Bogofilter est un filtre bayésien rapide basé sur les travaux de Paul Graham dans son article Un plan contre le Spam. Bogofilter utilise l'algorithme de moyenne géométrique de Gary Robinson avec la méthode modifiée de Fisher (khi2) pour classifier les spams et hams (N.D.T.: les mails autres que des spams).
La page web de Bogofilter chez SourceForge est le point central pour toutes les ressources sur Bogofilter.
Bogofilter a été créé par Eric S. Raymond le 19 Août 2002. Il a gagné en popularité depuis Septembre 2002, et un grand nombre de programmeurs ont commencé à participer au projet.
Le fichier NEWS décrit l'historique des versions de Bogofilter.
Bogofilter est une sorte de bogomètre (bogometer) ou filtre à bogues (bogon-filter), c'est à dire qu'il essaie d'identifier des mails bogués (bogus) en mesurant leur bogosité (bogosity).
Jetez d'abord un oeil sur la section THEORY OF OPERATION du manuel pour une introduction. La principale source pour comprendre est l'article de Gary Robinson dans le Linux Journal "A Statistical Approach to the Spam Problem" (Une approche statistique du problème du Spam).
Après avoir lu tout ceci, vous vous posez probablement quelques questions. La première pourrait être "Bogofilter est-il réellement un filtre anti-spam bayésien ?" Bogofilter est basé sur le théorème de Bayes et l'utilise dans les premières parties du calcul, puis d'autres méthodes statistiques par la suite. On peut donc affirmer sans risque qu'il s'agit d'un filtre anti-spam statistique avec un parfum bayésien.
D'autres questions qui pourraient vous assaillir concerneraient les prérequis ou hypothèses de la théorie de Bayes. Les réponses simples sont : "Non, ils ne sont pas remplis" et "On s'en moque tant que cela marche". Une réponse plus élaborée mentionnerait que le postulat de base qui dit que "Un email est une collection aléatoire de mots, totalement indépendants les uns des autres" est violé. Il y a plusieurs points où la pratique prend des libertés avec la théorie. Certains sont tout le temps présents, d'autres dépendent de la manière dont vous utilisez Bogofilter :
Comme la page manuel l'explique, Bogofilter essaie de composer avec l'influence négative de ces hypothèses non respectées. Certains disent que "ces écarts de la réalité travaillent en général en notre faveur" (Article de Gary). D'autres disent que, même dans ce cas, nous devrions ne pas trop nous écarter des hypothèses de base. En fait, ersonne ne sait réellement. Gardez simplement à l'esprit que si vous "chargez la mule", des problèmes se poseront. La clé de l'approche de Bogofilter est : la chose qui importe le plus est que cela fonctionne dans le monde réel.
Maintenant que vous avez été prévenus, amusez vous et utilisez Bogofilter au mieux de vos besoins.
Il existe actuellement 4 listes de diffusion pour Bogofilter (en anglais):
| Adresses des listes | Liens | Description |
|---|---|---|
| bogofilter-announce@bogofilter.org | [subscribe] [archives: mailman, gmane] | Une liste où sont annoncées les nouvelles versions. |
| bogofilter@bogofilter.org | [subscribe] [archives: mailman, gmane] | Une liste de diffusion généraliste sur Bogofilter. |
| bogofilter-dev@bogofilter.org | [subscribe] [archives: mailman, gmane] | Une liste pour des échanges de patches, le développement, et les discussions techniques. |
| bogofilter-cvs@lists.sourceforge.net | [abonnement] [archive] | Une liste pour annoncer les changements de code sur l'archive CVS. |
Pour classifier les messages comme ham ou spam, Bogofilter
a besoin d'apprendre votre courrier. Pour commencer, le mieux est d'avoir
un corpus (aussi large que possible) de messages dont vous êtes sûr de
l'état de ham ou de spam. (Des erreurs à ce stade occasionneront des problèmes plus tard,
aussi, soyez attentifs ;-)). Attention, n'utilisez que votre email. L'utilisation d'autres
corpus (tel qu'un corpus trouvé sur Internet), peut pousser
Bogofilter à tirer de mauvaises conclusions après tout, votre but est de lui
faire comprendre votre courrier.
Une fois que vous avez vos corpus de spam et de ham, vous avez quatre choix possibles. Dans tous les cas, cela fonctionnera mieux si votre base d'apprentissage (les corpus ci-dessus) est conséquente. Plus un corpus est petit, plus grand sera le nombre d'erreurs que fera Bogofilter en production. Supposons que vos corpus se trouvent dans deux fichiers mbox: ham.mbx et spam.mbx.
Méthode 1) Entrainement complet: Entraînez Bogofilter avec tous vos messages. Dans notre example:
bogofilter -s < spam.mbx
bogofilter -n < ham.mbxNote: Le répertoire contrib de Bogofilter contient deux scripts qui tous les deux utilisent une technique d'entrainement sur erreur. Cette technique évalue chaque message et n'ajoute à la base de données que les messages qui ont été mal évalués (messages marqués comme incertains, ham évalués en tant que spam ou inversement). Le but est de créer une base de données des mots réellement nécessaires pour classer correctement les messages. La base de données résultante est plus petite que celle de l'entrainement complet.
Méthode 2) Utilisez le script bogominitrain.pl (dans le répertoire contrib).
Il évalue les messages le même ordre que vos fichiers mailbox. Vous devriez utiliser
l'option -f qui va demander au script de répéter le travail, jusqu'à ce que tous
les messages soient classés correctement.
(Si nécessaire, vous pouvez même ajuster le niveau de certitude). Comme le script s'assure
que la base de données
connaît "tout" votre corpus d'entrainement (avec la précision de votre choix), cela
fonctionne très bien. Vous pouvez utiliser -o pour créer une marge de
sécurité autour de "spam_cutoff"
Avec spam_cutoff=0.6 vous voudrez peut-être évaluer tous les hams
dans votre corpus en dessous de 0.3 et tous les spams au delà de 0.9. Notre exemple devient:
bogominitrain.pl -fnv ~/.bogofilter ham.mbx spam.mbx '-o 0.9,0.3'
Méthode 3) Utilisez le script randomtrain (dans le répertoire contrib). Le script génère une liste de tous les messages dans les mailbox, mélange la liste, puis évalue chaque message, suiv d'un entrainement si nécessaire. Dans notre exemple:
randomtrain -s spam.mbx -n ham.mbx
Comme pour la méthode 4, cela fonctionne mieux si vous commencer avec un corpus d'entrainement de plusieurs milliers de messages. Ceci vous donnera une base de données plus complète et significativement plus grande.
Méthode 4) Si vous avez suffisamment de spam et de ham dans votre corpus, "réservez" 10000 spams et 10000 hams dans des fichiers mbox séparés, puis utilisez ce corpus pour l'entraînement. Lancez alors Bogofilter pour classer les spams et hams restants. Prenez tout message incorrectement évalué ou ayant le statut incertain, et utilisez les pour un nouvel apprentissage. Cette méthode donne la meilleure méthode possible de discrimination. Voici deux petits scripts qui peuvent être utilisés pour classifier les messages "mauvais élèves".
#! /bin/sh # class3 -- classe un message en mauvais, bon ou incertain cat >msg.$$ bogofilter $* <msg.$$ res=$? if [ $res = 0 ]; then cat msg.$$ >>corpus.bad elif [ $res = 1 ]; then cat msg.$$ >>corpus.good elif [ $res = 2 ]; then cat msg.$$ >>corpus.unsure fi rm msg.$$
#! /bin/sh # classify -- Place tous les messages dans un fichier mbox à l'aide de class3 src=$1; shift formail -s class3 $* <$src
Dans notre exemple (après l'entrainement initial):
classify spam.mbx [bogofilter options]
bogofilter -s < corpus.good
rm -f corpus.*
classify ham.mbx [bogofilter options]
bogofilter -n < corpus.bad
rm -f corpus.*Il est important de comprendre les conséquences des méthodes que nous venons de décrire. Faire un entrainement complet, tel que dans les méthodes 1 et 4 produit une base de données plus grande que ne le ferait un entrainement avec les méthodes 2 ou 3. Si votre base de données doit être de petite taille (par exemple à cause de quotas), utilisez les méthodes 2 ou 3.
L'entrainement avec la méthode 1 est le plus rapide. L'entrainement sur erreur (tel que décrit dans les méthodes 2,3 et 4) est efficace, mais l'apprentissage est plutôt lent.
Bogofilter fera des erreurs de temps en temps. C'est pourquoi un apprentissage régulier est important. Il existe principalement deux méthodes pour le faire. Premièrement, vous pouvez l'entraîner avec chaque nouveau message (en utilisant l'option -u). Deuxièmement, vous pouvez ne l'entraîner que sur des erreurs.
De plus, vous pouvez reconstruire votre base à certains moments, par exemple quand une nouvelle fonctionnalité importante est ajoutée à Bogofilter. Il peut être alors fort utile de mettre à jour régulièrement votre corpus d'apprentissage.
Bogofilter fait toujours de son mieux avec les informations
disponibles. Cependant, il fera des erreurs, tel que classer des ham en spam
(faux positifs) ou spam en ham (faux négatifs). Pour réduire la probabilité d'un réapparition
de l'erreur, il sera nécessaire d'entrainer Bogofilter avec le message erroné. Si un message est
classé incorrectement spam, utilisez l'option -n pour l'intégrer en tant que ham.
Utilisez l'option -s pour l'intégrer en tant que spam.
Bogofilter a une option -u qui, automagiquement, met à jour la liste des mots
après chaque évaluation de messages. Comme Bogofilter fait parfois des erreurs, cette méthode a
l'inconvénient de dégrader la base d'entrainement avec des entrées erronées. Vous aurez alors
besoin de la regarder et la corriger fréquemment.
La correction peut être faite en utilisant -Sn pour changer la classification du message
de spam en ham et -Ns pour changer de ham en spam.
Corriger un message incorrectement classé peut affecter la classification d'autres messages. Plus votre base de données sera petite, plus grande sera la probabilité qu'une erreur d'apprentissage créee des classifications incorrectes.
L'utilisation de la méthode 2 ou 3 (ci-dessus) peut compenser cet effet. Repéter l'entrainement avec le corpus complet (y compris les messages de corrections ajoutés depuis le précédent apprentissage). Ceci ajoutera des messages dans la base de données afin que d'atteindre un nouvel équilibre, annulant les effets éventuellement de "surcompensation".
Une stratégie alternative, basée sur la méthode 4 de la section précédente est la suivante: Périodiquement, prenez des blocs de messages et utilisez les scripts de la méthode 4 pour les classer. Analyser manuellement les spams, ham et incertains, corriger les erreurs, puis séparer les incertains en hams et spam. Jusqu'à ce que vous ayez 10000 spams et 10000 hams dans votre base d'apprentissage, entraînez avec les hams, les spams, puis les erreurs et enfin les incertains. Plus tard, vous n'entrainerez qu'avec les erreurs et les incertains, en ignorant les messagess que Bogofilter a correctement classé.
Notez que vous devrez régulièrement lancer:
bogoutil -d wordlist.db | bogoutil -l wordlist.db.new
mv wordlist.db wordlist.db.prv
mv wordlist.db.new wordlist.db
ou pour les fichiers spamlist.db et goodlist.db (si vous utilisez Bogofilter avec les listes de mots séparés). Ceci compressera les bases de données pour n'occuper que le minimum d'espace disque nécessaire.
Bogofilter comprend les formats mbox traditionnel, Maildir et MH. Bogofilter ne soutient pas des sous-répertoires, vous devrez explicitement les lister si vous avez des répertoires Maildir++ ou MH - mentionnez seulement les noms absoluts des sous-répertoires.
Pour des formats non soutenus, vous devrez transformer le fichier en un format que Bogofilter comprend. Mbox est souvent commode parce qu'il peut être enovyé directement à bogofilter.
La liste suivante pourrait vous aider:
On peut dire à Bogofilter d'afficher des informations sur l'évaluation d'un message en le lançant avec les paramètres "-v", "-vv", "-vvv", or "-R".
X-Bogosity: Ham, tests=bogofilter, spamicity=0.500000
X-Bogosity: Ham, tests=bogofilter, spamicity=0.500000
int cnt prob spamicity histogram
0.00 29 0.000209 0.000052 #############################
0.10 2 0.179065 0.003425 ##
0.20 2 0.276880 0.008870 ##
0.30 18 0.363295 0.069245 ##################
0.40 0 0.000000 0.069245
0.50 0 0.000000 0.069245
0.60 37 0.667823 0.257307 #####################################
0.70 5 0.767436 0.278892 #####
0.80 13 0.836789 0.334980 #############
0.90 32 0.984903 0.499835 ################################
Chaque ligne présente un intervalle, le nombre de tokens (N.D.T. élément minimal pour le traitement, généralement un mot) avec le score dans cet intervalle, la moyenne de la probabilité de spam pour ces tokens, l'évaluation de la "spamicité" du message (pour les tokens de cet intervalle ou des précédents) et une barre correspondant au nombre de tokens.
Dans l'histogramme ci-dessus, il y a beaucoup de tokens à faible score et à haut score. Ils s'équilibrent pour donner une "spamicité" de 0.500000
X-Bogosity: Ham, tests=bogofilter, spamicity=0.500000
n pgood pbad fw U
"which" 10 0.208333 0.000000 0.000041 +
"own" 7 0.145833 0.000000 0.000059 +
"having" 6 0.125000 0.000000 0.000069 +
...
"unsubscribe.asp" 2 0.000000 0.095238 0.999708 +
"million" 4 0.000000 0.190476 0.999854 +
"copy" 5 0.000000 0.238095 0.999883 +
N_P_Q_S_s_x_md 138 0.00e+00 0.00e+00 5.00e-01
1.00e-03 4.15e-01 0.100
Les colonnes affichées donnent les informations suivantes:
La dernière ligne montre:
La sortie de "-R" est présentée pour être utilisé avec le langage R de calcul statistique. Plus d'information est disponible sur la page du projet R pour le calcul statistique http://www.r-project.org/.
La configuration par défaut de Bogofilter classera un message en tant que spam ou non-spam. Le paramètre SPAM_CUTOFF est utilisé pour cela. Les messages avec un score supérieur ou égal à SPAM_CUTOFF sont classés en spam. Les autres en ham.
Il y a aussi un paramètre HAM_CUTOFF. Quand il est utilisé, les messages doivent avoir un score inférieur ou égal à HAM_CUTOFF pour être classés ham. Les messages avec un score compris entre HAM_CUTOFF et SPAM_CUTOFF sont étiquetés "unsure". Si vous regardez le fichier bogofilter.cf, vous verrez les lignes suivantes :
#### CUTOFF Values # # both ham_cutoff and spam_cutoff are allowed. # setting ham_cutoff to a non-zero value will # enable tri-state results (Spam/Ham/Unsure). # #ham_cutoff = 0.45 #spam_cutoff = 0.99 # # for two-state classification: # ## ham_cutoff = 0.00 ## spam_cutoff= 0.99
Pour activer la classification Yes/No/Unsure, enlevez les dièses devant les deux dernières lignes.
Alternativement, si vous préférez utiliser les labels Spam/Ham/Unsure au lieu de Yes/No/Unsure, enlevez les dièses devant la ligne :
## spamicity_tags = Yes, No, Unsure
Une fois que cela est fait, vous pourrez inclure les règles de filtrage suivantes pour votre outil de messagerie:
if header contains "X-Bogosity: Spam", put in Spam folder if header contains "X-Bogosity: Unsure", put in Unsure folder
De plus, bogofilter.cf possède des directives pour modifier la ligne Sujet:, par exemple.
#### SPAM_SUBJECT_TAG # # tag added to "Subject: " line for identifying spam or unsure # default is to add nothing. # ##spam_subject_tag=***SPAM*** ##unsure_subject_tag=???UNSURE???
Avec de tels marqueurs, les règles de filtrage ressembleraient à ceci:
if subject contains "***SPAM***", put in Spam folder if subject contains "???UNSURE???", put in Unsure folder
"L'entrainement sur erreur" implique l'analyse d'un corpus de messages dont le statut de spam ou ham est connu. Seuls ceux qui sont mal classés, ou dont le classement est incertain, seront intégrés dans la base de données d'apprentissage. Il a été montré que la sélection des seuls messages "mauvais élèves" était un moyen efficace d'entrainement. Si l'on entrainait Bogofilter avec tous les messages, il va réapprendre avec des spams ou hams évidents.
Cette méthode peut être améliorée en utilisant une "marge de sécurité". En augmentant la valeur "spam cutoff" et en diminuant la valeur "ham cutoff", les messages qui sont proches du seuil seront utilisés, pour l'entrainement. L'utilisation de cette marge de sécurité a montré son efficacité à améliorer les résultats dans l'entrainement sur erreur. En général, des marges plus larges sont une aide supplémentaire (malgré le fait que des marges trop grandes ne soient pas optimales). Pour un mode à triple état, vous pouvez utiliser le milieu de l'état unsure avec un intervalle de +/- 0.3 pour l'entrainement
Répéter l'entrainement sur erreur sur le même corpus de message peut améliorer la précision. L'idée est que les messages qui ont été bien classés une première fois peuvent, à la suite de l'entrainement, être mal classés. Fait qui sera compensé par cette répétition.
"L'entrainement sur épuisement" est la répétition de l'entrainement sur erreur, avec le même corpus de messages, jusqu'à ce que plus aucune erreur ne subsiste. Cette méthode peut aussi être améliorée grâce aux marges de sécurité. Voir pour cela L'article de Gary Robinson pour plus de détail.
Note: bogominitrain.pl possède une option -f qui permet de réaliser
"l'entrainement sur épuisement". Si
vous choisissez de l'utiliser, soyez conscient des effets secondaires possibles. L'utilisation
de -fn évite de répéter l'entrainement pour chaque message.
L'option '-u' (autoupdate) est utilisé pour compléter automatiquement la liste de mots. Quand cette option est utilisée et que Bogofilter classe un message en Spam ou Ham, les tokens du message sont ajoutés dans la liste de mots avec un marqueur ham ou spam (suivi le contexte).
Prenons le cas de l'arrivée d'un nouveau message "Refinance now - best Mortgage rates". Il contient des mots que Bogofilter a déjà vu et, probablement, des nouveaux. En utilisant '-u' ces nouveaux mots seront ajoutés dans la liste des mots, afin que Bogofilter puisse mieux reconnaître les messages suivants qui lui ressembleraient.
Si vous utilisez '-u', vous avez besoin de regarder attentivement les erreurs de classification et de réentrainer Bogofilter avec les messages qu'il a mal identifiés. Un message incorrectement classé et qui est auto-appris _peut_ amplifier les futures mauvaises classifications de Bogofilter. C'est le même problème que si vous, administrateur système, vous enregistriez mal un message : ham en spam ou vice versa.
Si vous avez un SpamAssassin actif (ou si vous voulez en créer un), vous pouvez utiliser ses codes de retour pour l'apprentissage de Bogofilter. Le moyen le plus simple est de créer un script pour votre MDA qui fait tourner SpamAssassin, tester l'état du code de retour spam/ham, et lancer Bogofilter pour valider le message. Le script procmail ci-dessous est un moyen de le faire:
BOGOFILTER = "/usr/bin/bogofilter" BOGOFILTER_DIR = "training" SPAMASSASSIN = "/usr/bin/spamassassin" :0 HBc * ? $SPAMASSASSIN -e #spam yields non-zero #non-spam yields zero | $BOGOFILTER -n -d $BOGOFILTER_DIR #else (E) :0Ec | $BOGOFILTER -s -d $BOGOFILTER_DIR :0fw | $BOGOFILTER -p -e :0: * ^X-Bogosity:.Yes spam :0: * ^X-Bogosity:.No non-spam
Beaucoup de personnes reçoivent du mail non sollicité utilisant des caractères asiatiques. Comme ils ne pratiquent pas la langue et qu'ils ne connaissent personne là bas, ils supposent qu'il s'agit de spam.
La bonne nouvelle est que bogofilter les détecte de manière plutôt efficace. La mauvaise nouvelle est que cela peut être coûteux. Vous avez en gros trois possibilités:
Vous pouvez simplement laisser bogofilter gérer le problème. Entraînez le avec des messages asiatiques identifiés comme spam. Bogofilter analysera les messages du mieux qu'il peut et ajoutera des tokens à la liste des mots de spam. La liste des mots contiendra beaucoup de tokens qui n'auront pas de sens pour vous (puisque la table de caractères ne peut être affichée), mais Bogofilter peut travailler avec eux et identifier correctement du spam asiatique.
## Efface silencieusement tous les mails en langue asiatique UNREADABLE='[^?"]*big5|iso-2022-jp|ISO-2022-KR|euc-kr|gb2312|ks_c_5601-1987' :0: * 1^0 $ ^Subject:.*=\?($UNREADABLE) * 1^0 $ ^Content-Type:.*charset="?($UNREADABLE) spam-unreadable :0: * ^Content-Type:.*multipart * B?? $ ^Content-Type:.*^?.*charset="?($UNREADABLE) spam-unreadable
Avec un tel programme, Bogofilter ne verra jamais le message.
Pour trouver le nombre de spam et ham pour un token (mot), utiliser l'option '-w' de bogoutil. Par exemple, "bogoutil -w $BOGOFILTER_DIR example.com" fournit le nombre de ham et spam pour "example.com".
Si vous voulez le score de spamicité en plus du nombre de ham et spam pour un token, utilisez l'option '-p' de bogoutil. Par exemple, "bogoutil -p $BOGOFILTER_DIR example.com" fournit en plus des nombres ham et spam, le score du mot.
Pour trouver combien de messages sont dans votre liste de mots, faites une requête sur le pseudo-token ".MSG_COUNT" (avec le point devant NdT). Par exemple, lancez la commande "bogoutil -w $BOGOFILTER_DIR .MSG_COUNT".
Pour dire combien de tokens sont présents dans votre liste de mots, envoyez la sortie de la commande dump de bogoutil vers la commande "wc". Par exemple utilisez "bogoutil -d $BOGOFILTER_DIR/wordlist.db | wc -l " pour afficher le nombre d'apparitions des tokens (Si vous utilisez spamlist.db et goodlist.db, lancez la commande pour chacun d'eux).
Vous avez certainement un problème avec votre base de données BerkeleyDB. Il y a deux causes probables : soit vous avez atteint une taille limite, ou bien, la base est corrompue.
Certains serveurs de messagerie, tel Postfix, impose une taille de fichier limite. Quand la base de données Bogofilter atteint cette limite, des problèmes d'écriture apparaissent.
Pour voir la taille utilisée par la base de données:
ls -lh $BOGOFILTER_DIR/wordlist.db
Pour voir la taille limite avec postfix:
postconf | grep mailbox_size_limit
Pour positionner la taille limite à 73MB (ou n'importe quelle taille appropriée):
postconf -e mailbox_size_limit=73000000
Si vous pensez que votre base de données est corrompue, lisez le point Comment faire si ma liste de mots est corroumpue ? de la FAQ.
Si vous pensez que vos listes de mots ont été dégradées, vous pouvez regarder ce qu'en dit BerkeleyDB en lançant:
db_verify wordlist.db
S'il y a un problème, vous pouvez récupérer tout ou partie des tokens et leur nombre avec la commande suivante:
bogoutil -d wordlist.db | bogoutil -l wordlist.db.new
ou - si la liste ne pourrait pas être récupérée par la commande précédente - avec:
db_dump -r wordlist.db > wordlist.txt
db_load wordlist.new < wordlist.txt
Lancez le script bogoupgrade. Pour plus d'informations lancez "bogoupgrade -h" pour voir le message d'aide ou "man bogoupgrade" et lisez la page manuel.
Oui. Bogofilter peut travailler avec plusieurs listes de mots. Par exemple,
si vous avez des listes utilisateur et
systeme, Bogofilter peut vérifier si le mot se trouve dans
la liste utilisateur, et si le mot ne s'y trouve pas, vérifier la liste systeme.
Bogofilter peut aussi mixer ensemble l'information des deux listes.
Voici par les options du fichier de configuration et quelques exemples:
Une liste de mots possède plusieurs attributs, particulièrement le type, le nom, le nom de fichier et la précédence.
Exemple 1 - mixage des listes systeme et utilisateur:
wordlist R,utilisateur,~/wordlist.db,1 wordlist R,systeme,/var/spool/bogofilter/wordlist.db,1
Exemple 2 - priorité à la liste utilisateur:
wordlist R,utilisateur,~/wordlist.db,2 wordlist R,systeme,/var/spool/bogofilter/wordlist.db,3
Exemple 3 - priorité à la liste systeme:
wordlist R,utilisateur,~/wordlist.db,5 wordlist R,systeme,/var/spool/bogofilter/wordlist.db,4
Note 1: les options d'enregristrement de Bogofilter ('-s', '-n', '-u', '-S', '-N' ) ne s'appliqueront qu'aux listes les plus basses en précédence.
Note 2: avoir des listes de type 'R' et 'I' de même précédence n'est pas autorisé, car les types sont contradictoires.
A travers l'utilisation des listes de type "ignore", Bogofilter ne prendra pas en compte les tokens listés pour évaluer le message.
Exemple:
wordlist I,ignore,~/ignorelist.db,7 wordlist R,systeme,/var/spool/bogofilter/wordlist.db,8
Puisque ignorelist.db a un index inférieur (7), à celui de
wordlist.db (8), Bogofilter ne regardera pas les tokens
qui se trouveront dans ignorelist.db.
Note: Techniquement, Bogofilter donne le score de ROBX aux tokens, et s'attend à ce que le paramètre min_dev les fasse "annuler".
Il y a deux méthodes principales pour construire/maintenir une liste "ignore".
Primo, un fichier texte peut être créé et maintenu à l'aide d'un éditeur. Bogoutil peut alors convertir le fichier texte en base de données, e.g. "bogoutil -l ignorelist.db < ignorelist.txt".
Secondo, echo ... | bogoutil ... peut être utilisé pour
ajouter un simple token, par exemple "ignorez.moi" :
echo ignorez.moi | bogoutil -l ~/ignorelist.db
Si vous ne faites que les lire, il n'y a pas de problème. Si vous les mettez à jour, vous devrez fournir les bonnes options de verrouillage pour éviter la corruption des données. Quand vous compilerez Bogofilter, vous aurez besoin de vérifier que le script configure a positionné "#define HAVE_FCNTL 1" dans votre fichier config.h. Les systèmes d'exploitation UNIX supporteront quasiment tous ceci. Si vous utilisez une version exotique ou particulièrement ancienne, assurez-vous qu'elle supporte fcntl(). Si "#define HAVE_FCNTL 1" est positionné, ce qui indique que votre système connaît la fonction fcntl(), alors décommentez "#define HAVE_FLOCK 1" afin que le système de verrouillage utilise fcntl() au lieu du verrouillage flock(). Si votre système ne supporte pas fcntl, alors vous ne pourrez partager les listes de mots en NFS sans risquer une corruption des données.
Ensuite, assurez-vous que NFS est correctement configuré avec "lockd" en fonctionnement. Référez vous à la documentation NFS à propos du lancement de "lockd" ou de "rpc.lockd". La plupart des systèmes avec NFS l'active par défaut.
Vraisemblablement les codes de retour ont été réécrits par
waitpid(2). En C utilisez WEXITSTATUS(status) dans sys/wait.h, ou
une macro comparable pour obtenir la valeur correcte. En Perl
utilisez 'system("bogofilter $input")>> 8'.
Si vous voulez plus d'information, lancez la commande
"man waitpid".
Au fur et à mesure, Bogofilter a accumulé un grand nombre d'options. Certaines d'entre elles ont disparu ou changé. Lisez le fichier NEWS pour plus d'informations.
Le lexer, la partie qui extrait les tokens des messages, évolue. Ceci occasionne une modification de la génération de la liste des tokens, qui, par contrecoups va rendre des anciens tokens inutilisés.
Si vous rencontrez ce problème, vous êtes vivement encouragés à reconstruire votre base. Si cela n'est pas possible, vous pouvez utiliser la version 0.15.13 et lire la documentation qui va avec pour voir comment migrer.
Bogoutil vous permet de lister (dump) une wordlist et de charger les tokens dans une nouvelle wordlist. Avec l'aide d'outils tels que awk et grep, les nombres peuvent être mis à zéros et les tokens dont les comptes seraient à zéro pour les spams et les hams pourraient être détruits.
Les commandes suivantes vont détruire les tokens des messages spams:
bogoutil -d wordlist.db | \
awk '{print $1 " " $2 " 0"}' | grep -v " 0 0" | \
bogoutil -l wordlist.new.db
Les commandes suivantes vont détruire les tokens provenant des messages hams.
bogoutil -d wordlist.db | \
awk '{print $1 " 0 " $3}' | grep -v " 0 0" | \
bogoutil -l wordlist.new.db
Si vous n'avez pas déjà la version 3.0 ou plus de la BerkeleyDB, alors téléchargez la (prenez une des 4.2.X), décompactez la, et lancez les commandes suivantes dans le répertoire 'dist':
$ cd build_unix $ sh ../dist/configure $ make # make install
Puis, téléchargez la version portable de Bogofilter.
Décompactez la, puis faites:
$ ./configure --with-libdb-prefix=/usr/local/BerkeleyDB-4.2 $ make # make install-strip
Vous pourrez alors, soit mettre un lien symbolique sur libdb.so dans /usr/lib, ou utiliser une version modifiée de la variable d'environnement LD_LIBRARY_PATH avant de lancer Bogofilter.
$ LD_LIBRARY_PATH=/usr/lib:/usr/local/lib:/usr/local/BerkeleyDB-4.2
$ export LD_LIBRARY_PATH
Notez que que certaines versions de make livrées avec Solaris bugguent quand vous essayez de compiler Bogofilter hors de son répertoire source. Soit vous compilez dans le répertoire source (comme suggéré ci-avant), soit vous utilisez GNU make (gmake).
Des paquetages existent avec des versions très récentes de Bogofilter. Cette approche utilise les paquetages très recommandés portupgrade et cvsup. Pour installer ces deux magnifiques outils (vous n'avez besoin de le faire qu'une seule fois):
# pkg_add -r portupgrade cvsup
Pour installer ou mettre à jour Bogofilter, il suffit de mettre à jour l'arbre de conversion (ports tree) avec cvsup puis de taper
# portupgrade -N bogofilter
Note: Ceci suppose que vous soyez root. Sinon, lisez le mémento sur la section FreeBSC, et regardez comment compiler si vous n'avez pas les privilèges requis..
Suivant votre système, vous pourrez avoir à positionner certaines variables
d'environnement pour la commande ./configure. Exemple:
# env CPPFLAGS=-I/usr/local/include/db3 LIBS=-ldb3 LDFLAGS=-L/usr/local/lib ./configure
Les chemins dépendent de votre système et des versions de bases de données que vous avez installées. Vérifiez et remplacez en conséquence.
Regardez le fichier doc/programmer/README.hp-ux dans la distribution source.
Bogofilter a été compilé avec succès sur plusieurs systèmes en utilisant la commande GNU make et les commandes natives make. Cependant, le Makefile de Bogofilter ne fonctionne pas avec certaines commandes make.
GNU make est recommandé pour compiler Bogofilter car nous savons qu'il fonctionne. Nous ne pouvons maintenir des commandes make moins performantes. Si votre make non-GNU fonctionne, magnifique !. Si vous rencontrez des problèmes, la chose à faire est d'installer la commande GNU make. Si votre make non-GNU ne peut compiler Bogofilter, nous sommes désolés, mais c'est votre problème. Si cela ne nécessite qu'un petit patch propre pour le rendre compatible, nous pouvons éventuellement l'intégrer.
Pour installer Bogofilter dans un répertoire non standard (en tant qu'utilisateur
non-root vous n'avez pas les permissions pour les répertoires normaux), vous
aurez besoin de préciser le préfixe d'installation quand vous lancerez
./configure.
Après avoir télécharger et décompacter
le code source, lancez ./configure --prefix=PATH où
PATH est le préfixe d'installation pour les fichiers générés (binaires, manuel, etc.)
Puis lancez les commandes habituelles —
make && make check && make install.
S'il vous est nécessaire d'appliquer des correctifs, récupérez
le code source
et décompactez le en utilisant tar -xzf ou gunzip
| tar -xf -. Placez vous dans le répertoire source et lancez la commande./configure --prefix=PATH
où
PATH est le préfixe d'installation pour les fichiers générés (binaires, manuel, etc.)
Puis, après avoir appliqué les correctifs, lancez les commandes habituelles —
make && make install.
Quand votre espace est réduit, vous pouvez utiliser make
install-strip en lieu et place de make install.
Ceci permet d'économiser de l'espace disque, mais ne permet pas le
debugage lors de crash, à moins que plus d'informations pour reproduire le bug
ne soient fournies aux développeurs.