Bogofilter Logo  v1.2.4 SourceForge Logo

FAQ Bogofilter

FAQ Bogofilter

Versions Officielles: en Anglais ou Français ou Italien ou Bulgares
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.


Qu'est ce que 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.


Bogo-quoi?

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).


Comment fonctionne Bogofilter?

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 :

  • Les mots dans un e-mail ne sont en aucun cas indépendants. Dans toutes les langues c'est même le contraire qui prime.
  • Les mots utilisés ne sont pas aléatoires, même si certains spammeurs utilisent des mots aléatoires.
  • L'entrainement complet, ou utilisant un échantillon aléatoire, suit les principes de Bayes. Choisir les messages pour l'entrainement viole le postulat disant que les messages utilisés pour l'entrainement sont un échantillon aléatoire des messages reçus. Ce principe est aussi violé par la fonction auto-update de Bogofilter (avec le paramètre tresh_update), l'entrainement sur erreur, ou n'importe quelle approche similaire.
  • La même chose s'applique si vous utilisez le même message plus d'une fois.
  • D'autres problèmes peuvent être soulevés par le fait de modifier la base de données en enlevant les tokens (en utilisant par exemple bogoutil avec -a ou -c).
  • Il y en a certainement d'autres.

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.


Listes de diffusion

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.

Comment débuter l'apprentissage de Bogofilter?

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.mbox et spam.mbox.

  • Méthode 1) Entrainement complet: Entraînez Bogofilter avec tous vos messages. Dans notre example:

        bogofilter -s < spam.mbox
        bogofilter -n < ham.mbox

Note: 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.mbox spam.mbox '-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.mbox -n ham.mbox

    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.mbox [bogofilter options]
        bogofilter -s < corpus.good
        rm -f corpus.*
        classify ham.mbox [bogofilter options]
        bogofilter -n < corpus.bad
        rm -f corpus.*

Comparaison de ces méthodes

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.


Comment lancer l'entrainement avec des formats mbox et maildir?

Entrainement initial avec un format mbox:

    bogofilter -M -s -I ~/mail/Spam
    bogofilter -M -n -I ~/mail/NonSpam

Entrainement initial avec un format maildir:

    bogofilter -s -B ~/Maildir/.Spam
    bogofilter -n -B ~/Maildir/.NonSpam

Entrainement sur erreur avec un format mbox:

    bogofilter -M -Ns -I ~/mail/Missed_Spam
    bogofilter -M -Sn -I ~/mail/False_Spam

Entrainement sur erreur avec un format maildir:

    bogofilter -s -B ~/Maildir/.Missed_Spam
    bogofilter -n -B ~/Maildir/.False_Spam

Comment puis-je conserver une bonne acuité?

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.


Quels formats de fichier Bogofilter comprend-il?

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.

Par exemple, pour convertir format UW-IMAP/PINE mbx en mbox:

    mailtool copy /full/path/to/mail.mbox '#driver.unix//full/path/to/mbox'

ou:

    for MSG in /full/path/to/maildir/* ; do 
        formail -I Status: < "$MSG" >> /full/path/to/mbox
    done

Quelle est la signification de la sortie verbeuse de Bogofilter?

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".

  • En utilisant "-v", Bogofilter génère la ligne d'entête "X-Bogosity:", par exemple
      X-Bogosity: Ham, tests=bogofilter, spamicity=0.500000
  • En utilisant "-vv" Bogofilter génère un histogramme, par exemple
        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

  • En utilisant "-vvv" on produit la liste de tous les tokens dans le message, avec de l'information pour chacun d'un. Par exemple:
      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:
    "…"
    le token pris en compte
    n
    Le nombre de fois ou le token a été rencontré lors de l'apprentissage
    pgood
    Proportion de bons messages (ham) contenant ce token
    pbad
    Proportion de mauvais messages (spam) contenant ce token
    fw
    L'index pondéré de Robinson, qui combine pgood et pbad pour donner une valeur qui sera proche de zéro si un message contenant ce token est vraisemblablement un ham, et proche de un s'il est vraisemblablement un spam.
    U
    '+' Si ce token contribue à la note finale, '-' sinon. Un token est exclu quand un score est à moins de "min_dev" de 0.5. min_dev est paramétrable.

    La dernière ligne montre:

    • Les résultats cumulés des colonnes
    • Les valeurs des paramètres de Robinson s et x et celle de min_dev
  • Utiliser "-R" produit la sortie de "-vvv" décrite plus haut plus 2 colonnes supplémentaires:
    invfwlog
    le logarithme of fw
    fwlog
    le logarithme of (1-fw)

    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/.


Qu'est-ce que le mode Unsure?

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 Yes/No/Unsure au lieu de Spam/Ham/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

Qu'est-ce que "l'entrainement sur erreur" et "l'entrainement sur épuisement"?

"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.


Que fait l'option '-u' (autoupdate)?

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.


Comment puis-je utiliser SpamAssassin pour l'apprentissage de Bogofilter?

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:.Spam
    spam

    :0:
    * ^X-Bogosity:.Ham
    non-spam

Comment traiter les spams asiatiques?

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.

  • Une seconde méthode est d'utiliser l'option du fichier de configuration "replace_nonascii_characters". Ceci remplacera les caractères à code ASCII "haut" (ceux compris entre 0x80 et 0xFF) avec des points d'interrogations '?'. Ceci permet de garder une base de petite taille. Malheureusement ceci entre en conflit avec les langues européennes qui contiennent beaucoup de voyelles et de consonnes accentuées à code ASCII "haut".
  • Si vous êtes sûr de ne jamais recevoir un message légitime dans ces langues, vous pouvez directement les détruire. Cela diminuera la base d'autant. Vous pouvez le faire avec un script MDA.
  • Ceci est un script qui effacera les messages écrits avec les tables de caractères asiatiques
  • ## 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.


Comment compacter les bases?

Vous pouvez périodiquement compacter les bases afin d'occuper un minimum d'estpace disque. En supposant que votre base de mots se trouve dans le répertoire ~/.bogofilter, pour bogofilter 0.93.0 (ou plus récent) tapez :

    bf_compact ~/.bogofilter wordlist.db

Pour un bogofilter antérieur à 0.93.0, tapez:

    cd ~/.bogofilter
    bogoutil -d wordlist.db | bogoutil -l wordlist.db.new
    mv wordlist.db wordlist.db.prv
    mv wordlist.db.new wordlist.db

Ce script est nécessaire pour dupliquer votre environnement de base de données (afin de supporter le traitement des transactions en BerkeleyDB). Votre répertoire original sera renommé en ~/.bogofilter.old et ~/.bogofilter contiendra le nouvel environnement.

Pour les anciennes versions de Bogofilter qui n'utilisent pas le principe des transactions, la base de données est un simple fichier (wordlist.db) et ne nécessite pas d'utiliser le script. Les commandes ci-dessus créent une nouvelle base de données plus compacte et renomment le fichier original en wordlist.db.prv

Note: Il est tout à fait valide d'utiliser le script avec d'anciennes versions de Bogofilter.


Comment faire une requête manuelle sur la base?

Pour trouver le nombre de spam et ham pour un token (mot), utiliser l'option '-w' de bogoutil. Par exemple, "bogoutil -w $BOGOFILTER_DIR/wordlist.db 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/wordlist.db 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/wordlist.db .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/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).


Puis-je utiliser plusieurs listes de mots?

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.

  • Le type: 'R' et 'I' (pour Regular et Ignore). Les listes actuelles sont de type 'R'. Le type 'I' signifie "n'évalue pas le token s'il est trouvé dans la liste ignore".
  • Nom: un identifiant court qui sera utilisé pour l'affichage de messages d'erreur. Par exemple "global", "utilisateur" et "ignore". Mais n'importe quel identifiant est valide.
  • Nom du fichier: le nom du fichier des mots. Quand on ouvre la base, si le chemin est complètement qualifié (avec un '/' en tête, ou '~') le nom est utilisé, sinon Bogofilter ajoute le contenu des variables de chemin dans l'ordre suivant : $BOGOFILTER_DIR, $BOGODIR, $HOME.
  • Précédence: c'est un entier tel que 1, 2, 3, ... On recherche le token dans les listes de mots dans le sens ascendant de la précédence. Si le token est trouvé, les listes de même précédence sont utilisées pour faire la somme des comptes. Les listes avec une précédence supérieure, ne sont pas vérifiées.

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.


Puis-je indiquer à Bogofilter d'ignorer certains tokens?

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

Comment puis-je faire pour transformer la base des mots séparé dans le format combiné?

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.


Comment faire si ma liste de mots est corrompue?

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.new.db

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.db < wordlist.txt

Comment puis-je convertir ma base de mots de/vers l'unicode?

La base de mots peut être convertie du format brut vers l'unicode en utilisant les commandes suivantes :

    bogoutil -d wordlist.db > wordlist.raw.txt
    iconv -f iso-8859-1 -t utf-8 < wordlist.raw.txt > wordlist.utf8.txt
    bogoutil -l wordlist.db.new < wordlist.utf8.txt

ou alors :

    bogoutil --unicode=yes -m wordlist.db

La base de mots peut-être convertie de l'unicode vers le format brut en tapant ceci :

    bogoutil -d wordlist.db > wordlist.utf8.txt
    iconv -f utf-8  -t iso-8859-1 < wordlist.utf8.txt > wordlist.raw.txt
    bogoutil -l wordlist.db.new < wordlist.raw.txt

ou encore:

    bogoutil --unicode=no -m wordlist.db

Comment passer du mode non-transactionnel au mode transactionnel?

La procédure est complètement documentée dans le fichier doc/README.db section 2.2.1. Nous vous suggérons de lire complètement le paragraphe.

En résumé, utilisez ces commandes:

    cd ~/.bogofilter
    bogoutil -d wordlist.db > wordlist.txt
    mv wordlist.db wordlist.db.old
    bogoutil --db-transaction=yes -l wordlist.db < wordlist.txt

Si tout ce passe bien, vous pouvez enlever les fichiers de sauvegarde:

    rm wordlist.db.old wordlist.txt

Comment passer du mode transactionnel au mode non transactionnel?

La procédure est complètement documentée dans le fichier doc/README.db section 2.2.1. Nous vous suggérons de lire complètement le paragraphe.

En résumé, vous pouvez utiliser bogoutil pour copier et recharger la base de mots, par exemple :

    cd ~/.bogofilter
    bogoutil -d wordlist.db > wordlist.txt
    mv wordlist.db wordlist.db.old
    rm -f log.?????????? __db.???
    bogoutil --db-transaction=no -l wordlist.db < wordlist.txt

Pourquoi Bogofilter meurt après avoir afficher "Lock table is out of available locks" ou "Lock table is out of available object entries"

Les modes transactionnel et concurrent de BerkeleyDB nécessitent une table de verrouillage qui correspond à la base de données en taille. Lisez le fichier README.db pour une explication détaillée et la solution.

La taille de la table de verrouillage peut-être paramétrée dans bogofilter.cf ou dans DB_CONFIG. Bogofilter.cf utilise les directives db_lk_max_locks et db_lk_max_objects, tandis que DB_CONFIG utilise les directives set_lk_max_objects et set_lk_max_locks.

Après avoir changé ces valeurs dans DB_CONFIG, lancez la commande

  bogoutil --db-recover /votre/repertoire/bogofilter

pour reconstruire la table de verrouillage.


Comment se fait-il que j'obtienne des messages DB_PAGE_NOTFOUND?

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.


Pourquoi obtient-on "Berkeley DB library configured to support only DB_PRIVATE environments" ou
"Berkeley DB library configured to support only private environments"?

Certaines distributions (par exemple le projet Fedora) propose BerkeleyDB avec le support des threads POSIX, et par conséquent les mutexes POSIX, alors que votre système ne supporte pas ces mutexes. (ceci dépend de votre version de noyau et du type exact de processeur).

Pour contourner le problème

  1. téléchargez, compilez et installez Berkeley DB manuellement et reconfigurez bogofilter:
    1. cd build_unix
    2. ../dist/configure --enable-cxx
    3. make
    4. make install
  2. recompilez et installez bogofilter:
    1. ./configure --with-libdb-prefix=/usr/local/BerkeleyDB.4.3 (remplacer le numéro de version de Berkeley DB)
    2. make && make check
    3. make install (si la notion d'espace est importante utilisez make install-strip)

Bogofilter peut-il fonctionner en environnement multi-utilisateurs?

Oui, il peut. Il existe de multiples stratégies pour le faire. les deux extrêmes sont:

  • Avoir un administrateur Bogofilter qui maintient une base globale que chacun utilise.
  • Que chaque utilisateur maintienne sa propre base.

Le compromis courant : l'administrateur Bogofilter maintient la base de mots globale et chaque utilisateur est autorisé à utiliser la liste globale ou sa liste privée. Un MDA, tel que procmail, peut-être programé pour appliquer d'abord la liste global (avec un seuil spam très strict) puis, si nécessaire, appliquer la liste des mots privée.


Puis-je partager une liste de mots par NFS?

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.


Pourquoi Bogofilter fournit des codes de retour tels que 0 et 256 quand il est lancé à l'intérieur d'un programme?

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".


Pourquoi mes scripts échouent depuis que j'ai mis à jour?

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.


Pourquoi, depuis que j'ai changé de version, Bogofilter fonctionne-t-il moins bien?

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.


Avec une wordlist combinée, comment puis-je détruire tous les tokens spams (ou les non-spams)?

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

Comment faire fonctionner Bogofilter sur Solaris, BSD, etc.?

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.

Sur Solaris

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).

Sur FreeBSD

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.

Sur HP-UX

Regardez le fichier doc/programmer/README.hp-ux dans la distribution source.


Puis-je utiliser la commande make sur mon système?

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.


Comment compiler Bogofilter pour un utilisateur non-root ou avec un préfixe d'installation non standard?

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.


Comment dois-je compiler Bogofilter avec les patches?

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.


Comment rendre les exécutables plus petits?

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.


datastore_db.c ne se compile pas!

Si vous configurez le chemin de la base de données avec, par exemple, --with-libdb-prefix ou via CPPFLAGS et LIBS, assurez-vous que vous fournissez un chemin absolu (avec un slash en début), un chemin relatif ne marchera pas. Exemple: utilisez --with-libdb-prefix=/usr/local/BerkeleyDB.4.2, mais pas --with-libdb-prefix=../BerkeleyDB.4.2


Avec quel programme de messgerie Bogofilter fonctionne-t-il?

Bogofilter est réputé pour fonctionner avec kmail, mozilla-mail, mutt, alpine, sylpheed-claws. Une recherche Googole vous aidera à obtenir d'autres informations pour utiliser Bogofilter avec votre programme de messagerie habituel.


Comment utiliser Bogofilter avec Mutt?

Utilisez a filtre mail (procmail, maildrop, etc.) pour aiguiller le mail dans différents dossiers suivant le code de retour de Bogofilter, et associez les touches pour entrainer Bogofilter sur les erreurs :

    macro index S "|bogofilter -s\ns=junkmail"  "Apprendre comme spam et sauvegarder dans junk"
    macro pager S "|bogofilter -s\ns=junkmail"  "Apprendre comme spam et sauvegarder dans junk"
    macro index H "|bogofilter -n\ns="          "Apprendre comme spam et sauvegarder"
    macro pager H "|bogofilter -n\ns="          "Apprendre comme spam et sauvegarder"

Ceci enverra les messages sélectionnés dans Bogofilter, enseignant les faux-ham en spam et vice-versa, puis proposera la sauvegarde dans un dossier différent.


Comment utiliser Bogofilter avec Sylpheed Claws?

Ajoutez une règle de filtrage pour lancer Bogofilter sur les messages entrants et une action à effectuer s'il s'agit d'un spam.

    condition:
    * test "bogofilter < %F"
    action:
    * move "#mh/VOTRE_BOITE_A_SPAM"

Note: ceci suppose que bogofilter est dans votre path!

Créer deux actions Clasw - une pour marquer les messages comme spam et l'autre pour marquer les messages comme ham. Utilisez l'action "Mark As Spam" pour les messages incorrectement classés comme ham et utilisez "Mark As Ham" pour les messages incorrectement classés comme spam.

    Mark as ham / spam:
    * bogofilter -n -v -B "%f" (mark ham)
    * bogofilter -s -v -B "%f" (mark spam)

Une autre approche est de sauvegarder les messages incorrectement classés dans un dossier (ou plusieurs) et de lancer un script tel que:

    #!/bin/sh
    CONFIGDIR=~/.bogofilter
    SPAMDIRS="$CONFIGDIR/spamdirs"
    MARKFILE="$CONFIGDIR/lastbogorun"
    for D in `cat "$SPAMDIRS"`; do
        find "$D" -type f -newer "$MARKFILE" -not -name ".sylpheed*"
    done|bogofilter -bNsv
    touch "$MARKFILE"

Ce script peut-être utilisez comme une action ou transformé comme un bouton. Ceci enregistrera comme spam, les messages dans ${SPAMDIRS} qui sont plus récents que ${MARKFILE}.

D'autres informations sont disponible dans le wiki de Sylpheed-Claws.


Une autre approche est de lancer Bogofilter depuis procmail, maildrop,etc. et de faire vérifier par Claws l'en-tête X-Bogosity et de filtrer les messages dans les dossiesr Spams et Unsure. Par exemple:

    Condition:
        header "X-Bogosity" matchcase "Spam"
    Action:
        move "#mh/Mailbox/Spam"
    Condition:
        header "X-Bogosity" matchcase "Unsure"
    Action:
        move "#mh/Mailbox/Unsure"

Tout message dans le dossier Unsure devrait être enseigné, comme tout message incorrectement classé comme ham ou spam. Les actions suivantes gèreront de tels cas :

    Register Spam:
        bogofilter -s < "%f"

    Register Ham:
        bogofilter -n < "%f"

    Unregister Spam:
        bogofilter -S < "%f"

    Unregister Ham:
        bogofilter -N < "%f"

Pour vérifier dans le mécanisme de notation de Bogofilter, le diagnostic suivant est utile:

    BogoTest -vv:
        bogofilter -vv < "%f"

    BogoTest -vvv:
        bogofilter -vvv < "%f"

D'autres informations sur cette approche sont disponibles ici.


Comment utiliser Bogofilter avec VM (un logiciel de messagerie sous Emacs)?

Vous devez inclure le fichier vm-bogofilter.el (que vous pouvez avec la distributione bogofilter ou télécharger à http://www.cis.upenn.edu/~bjornk/bogofilter/vm-bogofilter.el) dans le chemin des bibliothèques de votre Emacs.

Il ne vous reste plus qu'à mettre dans votre fichier de configuration ~/.vm :

;; Lutte contre les pourriels (via bogofilter)
;;
(require 'vm-bogofilter)

;; Raccourcis-clavier pour bogofilter
;; C (shift-c) : pourriel
;; K (shift-k) : message correct
(define-key vm-mode-map "K" 'vm-bogofilter-is-spam)
(define-key vm-mode-map "C" 'vm-bogofilter-is-clean)

Tous les messages sont filtrés par bogofilter à chaque fois que vous vérifiez vos nouveaux messages. Quand vous changez l'état d'un message, les en-têtes du message sont changées (en-tête X-Bogosity:).

Il y a toutefois une limite : vous ne pouvez changer l'état d'un ensemble de messages sélectionnés : vous devez le faire message après message...


Comment utiliser Bogofilter avec MH-E (l'interface Emacs pour le système de mail MH)?

Le paramétrage par défaut de l'option 'mh-junk-program' est 'Auto-detect' ce qui signifie que MH-E choisira automatiquement entre SpamAssassin, Bogofilter, ou SpamProbe, dans cet ordre. Si, par exemple, vous avez installé SpamAssassin et Bogofilter, et que vous souhaitiez utiliser Bogofilter, vous devrez modifier cette option pour 'Bogofilter'.

La commande 'J b' ('mh-junk-blacklist') Entrainer le programme de spam en cours avec le contenu sélectionné, puis traite le(s) message(s) comme spécifié dans l'option 'mh-junk-disposition'. Par défaut, cette option est positionné sur 'Delete Spam' Mais vous pouvez aussi spécifier le nom d'un répertoire, ce qui sera utile pour construire un corpus de spam pour l'entrainement.

Au contraire, la commande 'J w' ('mh-junk-whitelist') reclassifie les messages sélectionnés comme Ham s'ils étaient incorrectement classés comme spam. Elle déplace alors les messages dans le dossier '+inbox'.

Pour plus d'information lire la page MH-E




SourceForge Logo

Site designed by
www.nkstudios.net