Google propose une option bien sympathique pour ceux qui disposent d'un compte mail externe mais qui souhaitent lire leur mails sur Gmail. Il existe une option permettant de relever ses mails d'un compte externe via le POP3 pour ensuite les lire dans Gmail.

Cette option se situe dans dans les paramètres sur l'onglet « Comptes et importations » et s'appelle « Vérifier les messages avec le protocole POP3».

On peut ajouter un ou plusieurs comptes mails et laisser Google relever nos mails et tout ça en deux clics. Mais, car il y a un mais, on ne peut pas régler la fréquence à laquelle Google va aller tester notre boite mail pour savoir si de nouveaux messages sont arrivés. Sur une boite mail qui ne reçoit que quelques messages par jour le temps entre deux vérifications peut atteindre 1h ce qui enlève énormément d'intérêt à cette option. On peut également forcer la vérification de nouveaux message en cliquant sur un bouton mais je ne me vois pas passer mes journées à cliquer non plus.

Alors comment faire en sorte que Google vérifie l'arrivée de nouveaux emails régulièrement et cela même si vous ne recevez que 1 ou 2 mails dans la journée ?

Let the magic begin

La suite de ce hack présuppose que vous avez sous la main un serveur Linux configuré pour envoyer des mails (mais le principe peut fonctionner pour n'importe qui avec un peu d'adaptation).

Étudions tout d'abord le comportement de Gmail:

Après quelques tests, j'ai constaté que Gmail testait la présence de nouveaux mails dans des intervalles de plus en plus courtes si à chaque test au moins un mail était arrivé sur le serveur mail.
On peut donc moduler la fréquence de vérification des mails en augmentant le nombre de mails qui nous sont destinés et donc augmenter la fréquence de vérification. Le temps minimum entre deux vérifications étant de 2 minutes et le temps maximum de 1h.

Le principe est donc le suivant, je vais générer des mails à destination de mon adresse mail relevée par Gmail afin qu'il continue à vérifier les nouveaux mails toutes les deux minutes. Ainsi, si quelqu'un envoie un mail je le recevrai dans les deux minutes et non après 1h.

Difficultés techniques:

Il ne faut pas que les mails que je m'envoie aillent dans ma boite de réception sinon ils vont se mélanger avec les mails légitimes.

Il faut que les mails soient bien envoyés dans un intervalle régulier (au moins 1 toute les deux minutes) sinon le temps entre deux vérifications va augmenter.

Je veux que tous les mails que j'envoie aient un envoyeur, un sujet et un message différents pour contrer un éventuel programme de vérification d'abus que Google aurait mis en place.

Générons nos mails:

Nous allons écrire un petit script bash afin de générer aléatoirement nos mails.

Ce programme n'est pas ce qu'il y a de plus optimisé mais le bash n'est pas mon fort ;).

#!/bin/bash

#on définie les tailles max et min pour les différentes parties
MESSAGE_MAX_SIZE=150

MESSAGE_MIN_SIZE=10
SUBJECT_MAX_SIZE=20
SUBJECT_MIN_SIZE=5
SENDER_MAX_SIZE=10
SENDER_MIN_SIZE=4

MESSAGE_MODULO=$(($MESSAGE_MAX_SIZE-$MESSAGE_MIN_SIZE))
SENDER_MODULO=$(($SENDER_MAX_SIZE-$SENDER_MIN_SIZE))
SUBJECT_MODULO=$(($SUBJECT_MAX_SIZE-$SUBJECT_MIN_SIZE))

#on tire au hasard une taille pour les différentes parties (entre max et min)
MESSAGE_SIZE=$(($RANDOM%$MESSAGE_MODULO))
SUBJECT_SIZE=$(($RANDOM%$SUBJECT_MODULO))
SENDER_SIZE=$(($RANDOM%$SENDER_MODULO))

MESSAGE_SIZE=$(($MESSAGE_SIZE+$MESSAGE_MIN_SIZE))
SUBJECT_SIZE=$(($SUBJECT_SIZE+$SUBJECT_MIN_SIZE))
SENDER_SIZE=$(($SENDER_SIZE+$SENDER_MIN_SIZE))


#tableau contenant les caractères qui vont composer les messages
arrayMESSAGE=(
q w e r t y u i o p a s d f g h j k l z x c v b n m Q W E R T Y U I O P A S D
F G H J K L Z X C V B N M 1 2 3 4 5 6 7 8 9 0 ! ?  ' ' ' ' ' ' ' ' ' ' ' ' ' '
' ' ' ' ' ' ' ' ' ' ' ' ' '' ' ' ' ' ' ' ' ' ' ' ' ' '' ' ' ' ' ' ' ' ' '
)

#tableau contenant les caractères qui vont composer les sujets
arraySUBJECT=(
q w e r t y u i o p a s d f g h j k l z x c v b n m Q W E R T Y U I O P A S D
F G H J K L Z X C V B N M 1 2 3 4 5 6 7 8 9 0 ! ?  ' ' ' ' ' ' ' ' ' ' ' ' ' '
' ' ' ' ' ' ' ' ' ' ' ' ' '' ' ' ' ' ' ' ' ' '
)

#tableau contenant les caractères qui vont composer les envoyeurs
arraySENDER=(
q w e r t y u i o p a s d f g h j k l z x c v b n m 1 2 3 4 5 6 7 8 9 0
)

MODNUM_MESSAGE=${#arrayMESSAGE[*]}
MODNUM_SUBJECT=${#arraySUBJECT[*]}
MODNUM_SENDER=${#arraySENDER[*]}

message_len=0
subject_len=0
sender_len=0

message=""
subject=""
sender=""

#on tire autant de caractères dans le tableau de l'envoyeur que nécessaire
while [ $sender_len -lt $SENDER_SIZE ]
do
  index=$(($RANDOM%$MODNUM_SENDER))
  sender=${sender}${arraySENDER[$index]}
  ((sender_len++))
done

#on tire autant de caractères dans le tableau des sujets que nécessaire
while [ $subject_len -lt $SUBJECT_SIZE ]
do
  index=$(($RANDOM%$MODNUM_SUBJECT))
  subject=${subject}${arraySUBJECT[$index]}
  ((subject_len++))
done

#on tire autant de caractères dans le tableau des messages que nécessaire
while [ $message_len -lt $MESSAGE_SIZE ]
do
  index=$(($RANDOM%$MODNUM_MESSAGE))
  message=${message}${arrayMESSAGE[$index]}
  ((message_len++))
done

#on rajoute une séquence fixe pour identifier nos messages dans Gmail
message=${message}" _ENDING_SEQUENCE_"

#on crée un fichier temporaire qui contient le corps du message
echo $message text

#puis on prépare notre commande de mail
command="mail -s \""${subject}"\" MON#EMAIL@alefauch.fr -- -f "${sender}"@alefauch.fr < text"

#et on envoie notre mail
eval $command

rm text

exit 0


On sauvegarde le script sous le nom de « mail.sh »

On lui donne les droits d'exécution chmod u+x mail.sh et on l'exécute pour le tester ./mail.sh

Voici un aperçu d'un mail généré par ce script tel qu'il est affiché sur Gmail:



Il faut maintenant faire en sorte que ces mails ne pourrissent pas notre boite de réception:

On va utiliser pour cela les filtres de Gmail.

Les filtres de Gmail:

Cette option se situe dans dans les paramètres sur l'onglet « Filtres ». On va créer un nouveau filtre:


On met les valeurs suivantes dans les champs:

De : *@alefauch.fr
À : MON#EMAIL@alefauch.fr
Objet : (on laisse vide)
Contenant les mots: _ENDING_SEQUENCE_
Ne contenant pas : (on laisse vide)

On doit obtenir quelque chose qui ressemble à ça

Puis on passe à l'étape suivante

On coche:

Passer la boîte de réception (Archiver)
Supprimer

On doit obtenir quelque chose qui ressemble à ça



On valide en cliquant sur « Créer le filtre ».

Maintenant, tous les messages générés par notre script vont atterrir directement dans la Corbeille sans passer par la boite de réception.

Il est maintenant temps de programmer l'envoi automatique de mails de façon régulière.

Et maintenant la touche finale:

Il existe sous Linux un système de tâches planifiées appelé Cron. Celui-ci à un précision maximale de l'ordre de la minute ce qui est un peu trop grossier dans notre cas. On va donc écrire un autre petit script shell qui va se charger d'appeler le script de tout à l'heure pour générer des mails.


Le script de tout à l'heure s'appelle mail.sh

#!/bin/bash

# identifiant du processus
PID=$$

# intervalle entre deux envois de mails
INTERVAL=110

# date au lancement du processus
DATE=`eval date -R`

# commande permettant d'inscrire dans un fichier de log les lancements du script
command="echo \""${DATE}" - Gmail Mailer lauched with PID "${PID}". Mail interval: "${INTERVAL}\"" /var/log/gmailer"

# on exécute la commande
eval $command

#boucle infinie de mails
while :; do
# on attends le nombre de secondes spécifié
  sleep $INTERVAL
#on envoie un mail
  ./mail.sh
# on recommence l'opération
done

On sauvegarde le script sous le nom de « execmail.sh »

Il ne nous reste plus qu'a lancer ce script afin d'envoyer un mail toute les 110 secondes à Gmail. Mais avant il faut prendre quelques petites mesures de sécurité.

J'ai crée ces scripts en root et je ne veux pas qu'un autre utilisateur puisse les modifier afin de faire exécuter des commandes arbitraires avec les droits root.

On change donc les droits des scripts:

chmod 700 mail.sh execmail.sh

Puis on peut enfin exécuter execmail.sh

Afin que le terminal exécute execmail.sh en tâche de fond je vais le lancer avec la directive « & ».

Cela donne donc:

./execmail.sh &

Le fichier /var/log/gmailer contient maintenant les informations suivantes:

Sun, 28 Feb 2010 16:06:46 +0100 - Gmail Mailer lauched with PID 28864. Mail interval: 110

Le script est fonctionnel et les mails commencent à arriver.



On peut constater que Gmail relève maintenant notre boite mail  toutes les deux minutes



Nous avons donc réussi à forcer Gmail à relever notre boite mail régulièrement.