MX-Record-Validierung: Entwickler-Leitfaden

Infrastruktur-Verifizierung

Gültige MX-Records, die zu funktionierenden Mailservern aufgelöst werden, zeigen an, dass die Domain über E-Mail-Infrastruktur verfügt. Dies garantiert nicht, dass eine bestimmte Adresse existiert, aber es bestätigt, dass die Domain E-Mails empfangen kann.

Spam- und Betrugs-Erkennung

Seriöse Unternehmen pflegen ordnungsgemäße MX-Records. Verdächtige Domains, die für Spam oder Betrug verwendet werden, haben oft falsch konfigurierte oder fehlende MX-Records.

Leistungsoptimierung

Die Prüfung von MX-Records vor dem Versuch einer SMTP-Verifizierung vermeidet verschwendete Zeit für Verbindungen zu Domains, die keine E-Mails empfangen können.

Implementierung von MX-Record-Lookups

Lassen Sie uns erkunden, wie man MX-Record-Validierung in verschiedenen Programmierumgebungen implementiert.

Node.js-Implementierung

Node.js bietet integrierte DNS-Auflösung über das dns-Modul:

const dns = require('dns').promises;

async function getMxRecords(domain) {
  try {
    const records = await dns.resolveMx(domain);

    // Nach Priorität sortieren (niedrigste zuerst)
    records.sort((a, b) => a.priority - b.priority);

    return {
      success: true,
      domain,
      records: records.map(r => ({
        exchange: r.exchange,
        priority: r.priority
      }))
    };
  } catch (error) {
    return {
      success: false,
      domain,
      error: error.code,
      message: getMxErrorMessage(error.code)
    };
  }
}

function getMxErrorMessage(code) {
  const messages = {
    'ENODATA': 'No MX records found for this domain',
    'ENOTFOUND': 'Domain does not exist',
    'ETIMEOUT': 'DNS lookup timed out',
    'ESERVFAIL': 'DNS server failed to respond'
  };
  return messages[code] || 'Unknown DNS error';
}

// Usage
const result = await getMxRecords('gmail.com');
console.log(result);

Python-Implementierung

Pythons dns.resolver-Modul aus der dnspython-Bibliothek bietet umfassende DNS-Lookup-Funktionen:

import dns.resolver
import dns.exception

def get_mx_records(domain):
    try:
        answers = dns.resolver.resolve(domain, 'MX')

        records = []
        for rdata in answers:
            records.append({
                'exchange': str(rdata.exchange).rstrip('.'),
                'priority': rdata.preference
            })

        # Sort by priority
        records.sort(key=lambda x: x['priority'])

        return {
            'success': True,
            'domain': domain,
            'records': records
        }

    except dns.resolver.NXDOMAIN:
        return {
            'success': False,
            'domain': domain,
            'error': 'NXDOMAIN',
            'message': 'Domain does not exist'
        }

    except dns.resolver.NoAnswer:
        return {
            'success': False,
            'domain': domain,
            'error': 'NoAnswer',
            'message': 'No MX records found for this domain'
        }

    except dns.exception.Timeout:
        return {
            'success': False,
            'domain': domain,
            'error': 'Timeout',
            'message': 'DNS lookup timed out'
        }

# Usage
result = get_mx_records('gmail.com')
print(result)

Go-Implementierung

Gos net-Paket bietet unkomplizierte DNS-Lookup-Funktionen:

package main

import (
    "fmt"
    "net"
    "sort"
)

type MxResult struct {
    Success bool
    Domain  string
    Records []MxRecord
    Error   string
}

type MxRecord struct {
    Exchange string
    Priority uint16
}

func getMxRecords(domain string) MxResult {
    records, err := net.LookupMX(domain)

    if err != nil {
        return MxResult{
            Success: false,
            Domain:  domain,
            Error:   err.Error(),
        }
    }

    if len(records) == 0 {
        return MxResult{
            Success: false,
            Domain:  domain,
            Error:   "No MX records found",
        }
    }

    // Sort by priority
    sort.Slice(records, func(i, j int) bool {
        return records[i].Pref < records[j].Pref
    })

    result := MxResult{
        Success: true,
        Domain:  domain,
        Records: make([]MxRecord, len(records)),
    }

    for i, r := range records {
        result.Records[i] = MxRecord{
            Exchange: r.Host,
            Priority: r.Pref,
        }
    }

    return result
}

func main() {
    result := getMxRecords("gmail.com")
    fmt.Printf("%+v\n", result)
}

Fortgeschrittene MX-Validierungstechniken

Grundlegende MX-Lookups bestätigen, dass Records existieren, aber umfassende E-Mail-Validierung erfordert tiefere Analyse.

Validierung der Mailserver-Konnektivität

MX-Records verweisen auf Hostnamen, die in IP-Adressen aufgelöst werden müssen. Überprüfen Sie, ob die Mailserver tatsächlich erreichbar sind:

const dns = require('dns').promises;
const net = require('net');

async function validateMxConnectivity(domain) {
  // Get MX records
  const mxResult = await getMxRecords(domain);

  if (!mxResult.success) {
    return mxResult;
  }

  // Validate each mail server
  const validatedRecords = [];

  for (const record of mxResult.records) {
    const validation = await validateMailServer(record.exchange);
    validatedRecords.push({
      ...record,
      ...validation
    });
  }

  return {
    success: true,
    domain,
    records: validatedRecords,
    hasReachableServer: validatedRecords.some(r => r.reachable)
  };
}

async function validateMailServer(hostname) {
  try {
    // Resolve hostname to IP
    const addresses = await dns.resolve4(hostname);

    if (addresses.length === 0) {
      return { reachable: false, error: 'No A record' };
    }

    // Test connection to port 25
    const connected = await testConnection(addresses[0], 25);

    return {
      reachable: connected,
      ip: addresses[0],
      error: connected ? null : 'Connection refused'
    };
  } catch (error) {
    return {
      reachable: false,
      error: error.message
    };
  }
}

function testConnection(host, port, timeout = 5000) {
  return new Promise((resolve) => {
    const socket = new net.Socket();

    socket.setTimeout(timeout);

    socket.on('connect', () => {
      socket.destroy();
      resolve(true);
    });

    socket.on('timeout', () => {
      socket.destroy();
      resolve(false);
    });

    socket.on('error', () => {
      resolve(false);
    });

    socket.connect(port, host);
  });
}

Behandlung von A-Record-Fallback

Wenn keine MX-Records existieren, legen E-Mail-Standards (RFC 5321) fest, dass der A-Record der Domain als Fallback verwendet werden sollte. Implementieren Sie diesen Fallback in Ihrer Validierung:

async function getMailServers(domain) {
  // Try MX records first
  try {
    const mxRecords = await dns.resolveMx(domain);

    if (mxRecords.length > 0) {
      return {
        type: 'MX',
        servers: mxRecords.sort((a, b) => a.priority - b.priority)
      };
    }
  } catch (error) {
    if (error.code !== 'ENODATA') {
      throw error;
    }
  }

  // Fallback to A record
  try {
    const aRecords = await dns.resolve4(domain);

    if (aRecords.length > 0) {
      return {
        type: 'A_FALLBACK',
        servers: [{ exchange: domain, priority: 0 }],
        warning: 'Using A record fallback - no MX records found'
      };
    }
  } catch (error) {
    if (error.code !== 'ENODATA') {
      throw error;
    }
  }

  return {
    type: 'NONE',
    servers: [],
    error: 'No mail servers found for domain'
  };
}

Erkennung von Null-MX-Records

RFC 7505 definiert "Null-MX"-Records, die explizit angeben, dass eine Domain keine E-Mails akzeptiert. Diese Records haben einen einzelnen MX-Eintrag mit Priorität 0 und einem leeren Hostnamen ("."):

function hasNullMx(mxRecords) {
  if (mxRecords.length === 1) {
    const record = mxRecords[0];
    if (record.priority === 0 &&
        (record.exchange === '.' || record.exchange === '')) {
      return true;
    }
  }
  return false;
}

async function validateDomainMx(domain) {
  const mxResult = await getMxRecords(domain);

  if (!mxResult.success) {
    return mxResult;
  }

  if (hasNullMx(mxResult.records)) {
    return {
      success: false,
      domain,
      error: 'NULL_MX',
      message: 'Domain explicitly does not accept email'
    };
  }

  return mxResult;
}

Caching von MX-Lookups

DNS-Lookups fügen jeder Verifizierung Latenz hinzu. Implementieren Sie Caching zur Verbesserung der Leistung:

class MxCache {
  constructor(ttlMs = 3600000) { // 1 hour default TTL
    this.cache = new Map();
    this.ttl = ttlMs;
  }

  get(domain) {
    const entry = this.cache.get(domain.toLowerCase());

    if (!entry) return null;

    if (Date.now() > entry.expiry) {
      this.cache.delete(domain.toLowerCase());
      return null;
    }

    return entry.data;
  }

  set(domain, data) {
    this.cache.set(domain.toLowerCase(), {
      data,
      expiry: Date.now() + this.ttl
    });
  }

  // Respect DNS TTL values when available
  setWithTtl(domain, data, ttlSeconds) {
    const ttlMs = Math.min(ttlSeconds * 1000, this.ttl);
    this.cache.set(domain.toLowerCase(), {
      data,
      expiry: Date.now() + ttlMs
    });
  }
}

const mxCache = new MxCache();

async function getMxRecordsCached(domain) {
  const cached = mxCache.get(domain);

  if (cached) {
    return { ...cached, fromCache: true };
  }

  const result = await getMxRecords(domain);

  if (result.success) {
    mxCache.set(domain, result);
  }

  return { ...result, fromCache: false };
}

Häufige MX-Record-Muster

Das Verständnis gängiger MX-Konfigurationen hilft Ihnen, Validierungsergebnisse zu interpretieren und potenzielle Probleme zu identifizieren.

Große E-Mail-Anbieter

Das Erkennen von MX-Mustern für große Anbieter kann helfen, kostenlose E-Mail-Adressen zu identifizieren:

const knownProviders = {
  'google': [
    'gmail-smtp-in.l.google.com',
    'googlemail-smtp-in.l.google.com',
    'aspmx.l.google.com'
  ],
  'microsoft': [
    'outlook-com.olc.protection.outlook.com',
    'mail.protection.outlook.com'
  ],
  'yahoo': [
    'mta5.am0.yahoodns.net',
    'mta6.am0.yahoodns.net',
    'mta7.am0.yahoodns.net'
  ],
  'protonmail': [
    'mail.protonmail.ch',
    'mailsec.protonmail.ch'
  ]
};

function identifyEmailProvider(mxRecords) {
  const exchanges = mxRecords.map(r => r.exchange.toLowerCase());

  for (const [provider, patterns] of Object.entries(knownProviders)) {
    for (const pattern of patterns) {
      if (exchanges.some(ex => ex.includes(pattern.toLowerCase()))) {
        return provider;
      }
    }
  }

  return 'unknown';
}

Google Workspace-Erkennung

Google Workspace (ehemals G Suite) Domains verwenden Googles Mailserver, sind aber keine kostenlosen E-Mail-Konten:

function isGoogleWorkspace(domain, mxRecords) {
  const isGoogleMx = mxRecords.some(r =>
    r.exchange.toLowerCase().includes('google') ||
    r.exchange.toLowerCase().includes('googlemail')
  );

  // Check if domain is not a known Google consumer domain
  const googleConsumerDomains = ['gmail.com', 'googlemail.com'];
  const isConsumerDomain = googleConsumerDomains.includes(domain.toLowerCase());

  return isGoogleMx && !isConsumerDomain;
}

Erkennung von selbst gehosteten E-Mails

Domains, die ihre eigene E-Mail hosten, haben oft MX-Records, die auf Subdomains verweisen:

function isSelfHosted(domain, mxRecords) {
  const domainParts = domain.toLowerCase().split('.');
  const baseDomain = domainParts.slice(-2).join('.');

  return mxRecords.some(r => {
    const exchange = r.exchange.toLowerCase();
    return exchange.includes(baseDomain) &&
           !isKnownProvider(exchange);
  });
}

function isKnownProvider(exchange) {
  const providers = ['google', 'microsoft', 'yahoo', 'outlook', 'protonmail'];
  return providers.some(p => exchange.includes(p));
}

MX-Validierung in E-Mail-Verifizierungs-Pipelines

MX-Validierung ist ein Schritt in einem umfassenden E-Mail-Verifizierungsprozess. Das Verständnis ihrer Rolle hilft beim Aufbau effektiver Verifizierungs-Pipelines.

Verifizierungsreihenfolge

MX-Validierung erfolgt typischerweise früh in der Verifizierungs-Pipeline:

async function verifyEmail(email) {
  // 1. Syntax validation (fastest, no network)
  const syntaxResult = validateEmailSyntax(email);
  if (!syntaxResult.valid) {
    return { valid: false, reason: 'invalid_syntax', details: syntaxResult };
  }

  const domain = email.split('@')[1];

  // 2. MX record validation (fast DNS lookup)
  const mxResult = await validateMxRecords(domain);
  if (!mxResult.valid) {
    return { valid: false, reason: 'no_mx_records', details: mxResult };
  }

  // 3. Additional checks (disposable, role-based, etc.)
  const domainCheck = await checkDomainReputation(domain);
  if (domainCheck.isDisposable) {
    return { valid: true, risky: true, reason: 'disposable_domain' };
  }

  // 4. SMTP verification (slowest, most thorough)
  const smtpResult = await verifySmtp(email, mxResult.records);

  return {
    valid: smtpResult.exists,
    deliverable: smtpResult.deliverable,
    mxRecords: mxResult.records,
    provider: mxResult.provider
  };
}

Parallele MX-Lookups

Beim Verifizieren mehrerer E-Mails parallelisieren Sie MX-Lookups für verschiedene Domains:

async function verifyEmailsBatch(emails) {
  // Group emails by domain
  const emailsByDomain = {};

  for (const email of emails) {
    const domain = email.split('@')[1];
    if (!emailsByDomain[domain]) {
      emailsByDomain[domain] = [];
    }
    emailsByDomain[domain].push(email);
  }

  // Lookup MX records for all domains in parallel
  const domains = Object.keys(emailsByDomain);
  const mxResults = await Promise.all(
    domains.map(domain => getMxRecordsCached(domain))
  );

  // Map results back to domains
  const mxByDomain = {};
  domains.forEach((domain, index) => {
    mxByDomain[domain] = mxResults[index];
  });

  // Process emails with MX data
  const results = [];

  for (const email of emails) {
    const domain = email.split('@')[1];
    const mx = mxByDomain[domain];

    if (!mx.success) {
      results.push({ email, valid: false, reason: 'invalid_domain' });
      continue;
    }

    // Continue with SMTP verification using cached MX data
    const smtpResult = await verifySmtp(email, mx.records);
    results.push({ email, ...smtpResult });
  }

  return results;
}

Fehlerbehandlung und Sonderfälle

Robuste MX-Validierung behandelt verschiedene Fehlerbedingungen elegant.

Behandlung von DNS-Timeouts

Netzwerkprobleme können dazu führen, dass DNS-Lookups hängen bleiben. Implementieren Sie Timeout-Behandlung:

async function getMxRecordsWithTimeout(domain, timeoutMs = 10000) {
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error('DNS_TIMEOUT')), timeoutMs);
  });

  try {
    const result = await Promise.race([
      getMxRecords(domain),
      timeoutPromise
    ]);
    return result;
  } catch (error) {
    if (error.message === 'DNS_TIMEOUT') {
      return {
        success: false,
        domain,
        error: 'TIMEOUT',
        message: 'DNS lookup timed out',
        retryable: true
      };
    }
    throw error;
  }
}

Behandlung ungültiger Domains

Behandeln Sie syntaktisch ungültige Domains, bevor Sie DNS-Lookups versuchen:

function isValidDomain(domain) {
  if (!domain || typeof domain !== 'string') {
    return false;
  }

  // Check length
  if (domain.length > 253) {
    return false;
  }

  // Check for valid characters and structure
  const domainRegex = /^(?!-)[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}$/;

  if (!domainRegex.test(domain)) {
    return false;
  }

  // Check each label length
  const labels = domain.split('.');
  for (const label of labels) {
    if (label.length > 63) {
      return false;
    }
  }

  return true;
}

async function validateDomainMxSafe(domain) {
  if (!isValidDomain(domain)) {
    return {
      success: false,
      domain,
      error: 'INVALID_DOMAIN',
      message: 'Domain format is invalid'
    };
  }

  return await getMxRecordsWithTimeout(domain);
}

Behandlung temporärer DNS-Fehler

DNS-Fehler können temporär sein. Implementieren Sie Wiederholungslogik mit exponentiellem Backoff:

async function getMxRecordsWithRetry(domain, maxRetries = 3) {
  const delays = [1000, 2000, 4000];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const result = await getMxRecordsWithTimeout(domain);

    // Don't retry for definitive failures
    if (result.success ||
        result.error === 'NXDOMAIN' ||
        result.error === 'ENOTFOUND') {
      return result;
    }

    // Retry for temporary failures
    if (result.retryable && attempt < maxRetries - 1) {
      await sleep(delays[attempt]);
      continue;
    }

    return result;
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

Sicherheitsüberlegungen

MX-Validierung bringt Sicherheitsaspekte mit sich, die Entwickler berücksichtigen müssen.

Verhinderung von DNS-Spoofing

Standard-DNS-Abfragen sind unverschlüsselt und anfällig für Spoofing. Erwägen Sie die Verwendung von DNS über HTTPS (DoH) für sensible Anwendungen:

const https = require('https');

async function getMxRecordsDoH(domain) {
  const url = `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(domain)}&type=MX`;

  return new Promise((resolve, reject) => {
    https.get(url, {
      headers: { 'Accept': 'application/dns-json' }
    }, (res) => {
      let data = '';

      res.on('data', chunk => data += chunk);

      res.on('end', () => {
        try {
          const response = JSON.parse(data);

          if (response.Status !== 0) {
            resolve({
              success: false,
              domain,
              error: 'DNS_ERROR',
              status: response.Status
            });
            return;
          }

          const records = (response.Answer || [])
            .filter(a => a.type === 15)
            .map(a => {
              const [priority, exchange] = a.data.split(' ');
              return {
                priority: parseInt(priority),
                exchange: exchange.replace(/\.$/, '')
              };
            })
            .sort((a, b) => a.priority - b.priority);

          resolve({
            success: records.length > 0,
            domain,
            records
          });
        } catch (error) {
          reject(error);
        }
      });
    }).on('error', reject);
  });
}

Ratenbegrenzung von DNS-Abfragen

Verhindern Sie Missbrauch durch Begrenzung der Rate von DNS-Abfragen:

class DnsRateLimiter {
  constructor(maxQueriesPerSecond = 100) {
    this.tokens = maxQueriesPerSecond;
    this.maxTokens = maxQueriesPerSecond;
    this.lastRefill = Date.now();
  }

  async acquire() {
    this.refillTokens();

    if (this.tokens > 0) {
      this.tokens--;
      return true;
    }

    // Wait for token availability
    await sleep(1000 / this.maxTokens);
    return this.acquire();
  }

  refillTokens() {
    const now = Date.now();
    const elapsed = now - this.lastRefill;
    const tokensToAdd = (elapsed / 1000) * this.maxTokens;

    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
    this.lastRefill = now;
  }
}

const dnsLimiter = new DnsRateLimiter(50);

async function getMxRecordsRateLimited(domain) {
  await dnsLimiter.acquire();
  return getMxRecords(domain);
}

Verwendung von BillionVerify für MX-Validierung

Während die eigene Implementierung der MX-Validierung einen pädagogischen Wert hat, übernehmen professionelle E-Mail-Verifizierungsdienste wie BillionVerify die MX-Validierung als Teil einer umfassenden E-Mail-Verifizierung.

Vorteile der Verwendung einer E-Mail-Verifizierungs-API

Umfassende Prüfungen

Die E-Mail-Verifizierungs-API von BillionVerify kombiniert MX-Validierung mit Syntaxprüfung, SMTP-Verifizierung, Erkennung von Wegwerf-E-Mails und mehr in einem einzigen API-Aufruf. Dies eliminiert die Notwendigkeit, mehrere Validierungssysteme zu pflegen.

Optimierte Infrastruktur

Professionelle Dienste unterhalten global verteilte DNS-Resolver, handhaben Caching im großen Maßstab und optimieren die Leistung über Millionen von Verifizierungen hinweg.

Kontinuierliche Updates

Mailserver-Konfigurationen ändern sich ständig. E-Mail-Verifizierungsdienste aktualisieren kontinuierlich ihre Datenbanken bekannter Anbieter, Wegwerf-Domains und Mailserver-Muster.

Beispiel für API-Integration

async function verifyEmailWithBillionVerify(email) {
  const response = await fetch('https://api.billionverify.com/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.BV_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email })
  });

  const result = await response.json();

  // MX information is included in the response
  console.log('MX Valid:', result.mx_found);
  console.log('Domain Valid:', result.domain_valid);
  console.log('Is Deliverable:', result.is_deliverable);

  return result;
}

Fazit

MX-Record-Validierung ist eine grundlegende Komponente der E-Mail-Verifizierung, die bestätigt, dass eine Domain E-Mails empfangen kann, bevor ressourcenintensivere Prüfungen versucht werden. Durch die Implementierung ordnungsgemäßer MX-Validierung können Sie schnell ungültige Domains herausfiltern, die Verifizierungsleistung optimieren und zuverlässigere E-Mail-Verarbeitungsanwendungen erstellen.

Wichtige Erkenntnisse zur MX-Record-Validierung:

1. Prüfen Sie immer MX-Records, bevor Sie SMTP-Verifizierung versuchen, um Zeit und Ressourcen zu sparen
2. Behandeln Sie den A-Record-Fallback gemäß RFC-Standards für Domains ohne MX-Records
3. Implementieren Sie Caching, um den DNS-Lookup-Overhead für wiederholte Validierungen zu reduzieren
4. Erkennen Sie gängige Muster, um E-Mail-Anbieter und potenzielle Risiken zu identifizieren
5. Behandeln Sie Fehler elegant mit Timeouts, Wiederholungen und angemessenen Fehlermeldungen

Ob Sie ein benutzerdefiniertes E-Mail-Verifizierungssystem erstellen oder einen Dienst wie BillionVerify integrieren – das Verständnis von MX-Records hilft Ihnen, bessere E-Mail-Verarbeitung in Ihre Anwendungen zu integrieren. Beginnen Sie noch heute mit der Implementierung der MX-Validierung und machen Sie den ersten Schritt zur umfassenden E-Mail-Verifizierung.