Validateur d'e-mail SMTP

Question

J'ai besoin d'envoyer des centaines de newsletters, mais j'aimerais d'abord vérifier si le courrier électronique existe sur le serveur.C'est appelé SMTP validation, du moins je le pense, sur la base de mes recherches sur Internet.

Il existe plusieurs bibliothèques qui peuvent le faire, ainsi qu'une page contenant du code open source dans ASP Classique (http://www.coveryourasp.com/ValidateEmail.asp#Result3), mais j'ai du mal à lire ASP Classic, et il semble qu'il utilise une bibliothèque tierce...

Existe-t-il du code pour la validation SMTP en C# et/ou une explication générale de son fonctionnement ?

Answer 1

Sachez que la plupart des MTA (Mail Transfer Agent) auront la commande VRFY désactivée pour des raisons de protection anti-spam, ils vous bloqueront probablement même si vous essayez plusieurs RCPT TO d'affilée (voir http://www.spamresource.com/2007/01/whatever-happened-to-vrfy.html).Donc même si vous trouvez une bibliothèque pour faire cette vérification, cela ne vaudra pas grand-chose.Ishmaeel a raison, la seule façon de vraiment le savoir est d'envoyer un e-mail et de voir s'il rebondit ou non.

@Hrvoje :Oui, je vous suggère de surveiller les e-mails rejetés.MAIS:tous les mails renvoyés ne devraient pas automatiquement se retrouver sur votre liste "n'existe pas", vous devez également faire la différence entre les mails temporaires (par ex.boîte aux lettres pleine) et erreurs permanentes.

Answer 2

SMTP est un protocole basé sur du texte porté sur TCP/IP.

Votre programme de validation doit ouvrir une connexion TCP/IP sur le port 25 (SMTP) du serveur, écrire quelques lignes et lire la réponse.La validation se fait (mais pas toujours) sur la ligne "RCTP TO" et sur la ligne "VFRY".

Le SMTP-RFC décrit comment cela fonctionne (voir Green@Beta.ARPA ci-dessous, S sont les lignes envoyées par le client, R sont les lignes reçues du serveur) :

Example of the SMTP Procedure

         This SMTP example shows mail sent by Smith at host Alpha.ARPA,
         to Jones, Green, and Brown at host Beta.ARPA.  Here we assume
         that host Alpha contacts host Beta directly.

            S: MAIL FROM:
            R: 250 OK

            S: RCPT TO:
            R: 250 OK

            S: RCPT TO:
            R: 550 No such user here

Answer 3

S'il est vrai que de nombreux domaines renvoient des faux positifs en raison d'abus, il existe encore d'excellents composants qui effectueront plusieurs niveaux de validation au-delà de la simple validation SMTP.Par exemple, cela vaut la peine de vérifier d’abord si au moins le domaine existe.Je suis en train de compiler ma propre liste de ressources liées à cette question que vous pouvez suivre ici :

http://delicious.com/dworthley/email.validation

Pour ceux qui voudraient compléter cette liste, j'inclurai également ce que j'ai actuellement ici :

• aspNetMX
• Bibliothèque de classes de l'assistant de validation de courrier électronique .NET
• MONOProg Email Validator.Net

Pour un formulaire à toute épreuve et une expérience utilisateur exceptionnelle, il est utile de valider autant d'aspects que possible de l'adresse e-mail.Je peux voir du aspNetMX validateur qu'ils vérifient :

• la syntaxe
• l'e-mail contre une liste de mauvaises adresses e-mail
• le domaine contre une liste de mauvais domaines
• une liste de domaines de boîtes aux lettres
• si le domaine existe ou non
• s'il existe des enregistrements MX pour le domaine
• et enfin via SMTP qu'une boîte mail existe ou non

C'est cette dernière étape qui peut être contournée par les administrateurs en renvoyant true à pratiquement toutes les demandes de vérification de compte, mais dans la plupart des cas, si l'utilisateur a intentionnellement saisi une mauvaise adresse, elle a déjà été détectée.Et s’il s’agissait d’une erreur de l’utilisateur dans la partie domaine de l’adresse, cela sera également détecté.

Bien entendu, une bonne pratique pour utiliser ce type de service pour un écran ou un formulaire d’inscription serait de combiner ce type de validation avec un processus de vérification pour garantir que l’adresse e-mail est valide.L’avantage d’utiliser un validateur d’e-mail avant un processus de vérification est que cela permettra une meilleure expérience utilisateur globale.

Answer 4

Vous pouvez essayer le code ci-dessous, cela fonctionne bien pour moi :

public class EmailTest {
    private static int hear(BufferedReader in) throws IOException {
        String line = null;
        int res = 0;

        while ((line = in.readLine()) != null) {
            String pfx = line.substring(0, 3);
            try {
                res = Integer.parseInt(pfx);
            } catch (Exception ex) {
                res = -1;
            }
            if (line.charAt(3) != '-')
                break;
        }

        return res;
    }

    private static void say(BufferedWriter wr, String text) throws IOException {
        wr.write(text + "\r\n");
        wr.flush();

        return;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private static ArrayList getMX(String hostName) throws NamingException {
        // Perform a DNS lookup for MX records in the domain
        Hashtable env = new Hashtable();
        env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
        DirContext ictx = new InitialDirContext(env);
        Attributes attrs = ictx.getAttributes(hostName, new String[] { "MX" });
        Attribute attr = attrs.get("MX");

        // if we don't have an MX record, try the machine itself
        if ((attr == null) || (attr.size() == 0)) {
            attrs = ictx.getAttributes(hostName, new String[] { "A" });
            attr = attrs.get("A");
            if (attr == null)
                throw new NamingException("No match for name '" + hostName + "'");
        }
        /*
         Huzzah! we have machines to try. Return them as an array list
         NOTE: We SHOULD take the preference into account to be absolutely
         correct. This is left as an exercise for anyone who cares.
         */
        ArrayList res = new ArrayList();
        NamingEnumeration en = attr.getAll();

        while (en.hasMore()) {
            String mailhost;
            String x = (String) en.next();
            String f[] = x.split(" ");
            // THE fix *************
            if (f.length == 1)
                mailhost = f[0];
            else if (f[1].endsWith("."))
                mailhost = f[1].substring(0, (f[1].length() - 1));
            else
                mailhost = f[1];
            // THE fix *************
            res.add(mailhost);
        }
        return res;
    }

    @SuppressWarnings("rawtypes")
    public static boolean isAddressValid(String address) {
        // Find the separator for the domain name
        int pos = address.indexOf('@');

        // If the address does not contain an '@', it's not valid
        if (pos == -1)
            return false;

        // Isolate the domain/machine name and get a list of mail exchangers
        String domain = address.substring(++pos);
        ArrayList mxList = null;
        try {
            mxList = getMX(domain);
        } catch (NamingException ex) {
            return false;
        }

        /*
        Just because we can send mail to the domain, doesn't mean that the
        address is valid, but if we can't, it's a sure sign that it isn't
        */
        if (mxList.size() == 0)
            return false;

        /* 
        Now, do the SMTP validation, try each mail exchanger until we get
        a positive acceptance. It *MAY* be possible for one MX to allow
        a message [store and forwarder for example] and another [like
        the actual mail server] to reject it. This is why we REALLY ought
        to take the preference into account.
        */
        for (int mx = 0; mx < mxList.size(); mx++) {
            boolean valid = false;
            try {
                int res;
                //
                Socket skt = new Socket((String) mxList.get(mx), 25);
                BufferedReader rdr = new BufferedReader(new InputStreamReader(skt.getInputStream()));
                BufferedWriter wtr = new BufferedWriter(new OutputStreamWriter(skt.getOutputStream()));

                res = hear(rdr);
                if (res != 220)
                    throw new Exception("Invalid header");
                say(wtr, "EHLO rgagnon.com");

                res = hear(rdr);
                if (res != 250)
                    throw new Exception("Not ESMTP");

                // validate the sender address
                say(wtr, "MAIL FROM: <tim@orbaker.com>");
                res = hear(rdr);
                if (res != 250)
                    throw new Exception("Sender rejected");

                say(wtr, "RCPT TO: <" + address + ">");
                res = hear(rdr);

                // be polite
                say(wtr, "RSET");
                hear(rdr);
                say(wtr, "QUIT");
                hear(rdr);
                if (res != 250)
                    throw new Exception("Address is not valid!");

                valid = true;
                rdr.close();
                wtr.close();
                skt.close();
            } catch (Exception ex) {
                // Do nothing but try next host
                ex.printStackTrace();
            } finally {
                if (valid)
                    return true;
            }
        }
        return false;
    }

    public static void main(String args[]) {
        String testData[] = { "rahul.saraswat@techblue.com", "rahul.saraswat@techblue.co.uk", "srswt.rahul12345@gmail.com",
        "srswt.rahul@gmail.com" };
        System.out.println(testData.length);
        for (int ctr = 0; ctr < testData.length; ctr++) {
            System.out.println(testData[ctr] + " is valid? " + isAddressValid(testData[ctr]));
        }
        return;
    }
}

Merci et Cordialement Rahul Saraswat

Answer 5

La validation de l'e-mail Real(TM) essaie d'envoyer quelque chose à l'adresse et de voir si elle est rejetée/rebondie.Il vous suffira donc de les renvoyer et de supprimer les adresses qui échouent de votre liste de diffusion.

Answer 6

Ne le prenez pas mal, mais envoyer des newsletters à plus d’une poignée de personnes de nos jours est une affaire assez sérieuse.Oui, vous devez surveiller les rebonds (e-mails rejetés) qui peuvent se produire de manière synchrone lors de l'envoi SMTP (généralement si le serveur SMTP auquel vous êtes connecté fait autorité), ou de manière asynchrone en tant que message électronique généré par le système qui apparaît un certain temps après. l'envoi SMTP a réussi.

Gardez également à l'esprit la loi CAN-SPAM et respectez la loi lors de l'envoi de ces e-mails ;vous devez fournir un lien de désabonnement ainsi qu'une adresse physique (à la fois pour vous identifier et pour permettre aux utilisateurs d'envoyer des demandes de désabonnement par courrier postal s'ils le souhaitent).

Si vous ne faites pas ces choses, votre adresse IP pourrait, au mieux, être acheminée par null et, au pire, poursuivie en justice.

Answer 7

Vous pourriez en avoir besoin Composant Email Validator pour .NET

Voici l'exemple de code :

   // Create a new instance of the EmailValidator class.
   EmailValidator em = new EmailValidator();
   em.MessageLogging += em_MessageLogging;
   em.EmailValidated += em_EmailValidationCompleted;
   try
   {
       string[] list = new string[3] { "test1@testdomain.com", "test2@testdomain.com", "test3@testdomain.com" };
       em.ValidateEmails(list);
   }
   catch (EmailValidatorException exc2)
   {
       Console.WriteLine("EmailValidatorException: " + exc2.Message);
   }