[D2009] Online eMail-Adress Prüfung obs valide ist?

[KodeZwerg]

Zitat:

Zitat von CCRDude (Beitrag 1409067)

Jeder Spammer würde Jubelschreie ausstoßen, wenn sich die Existenz von Email-Postfächern so passiv testen ließe.

SMTP-Server können (konnten) das prüfen, aber ich erinnere mich grob, dass das schon vor 20 Jahren eben aus Spamvermeidungsgründen flächendeckend deaktiviert wurde.

In Sachen Datenschutz wäre die folgende heute gängige Methode wohl der Kompromiss:
Email mit Code/Link an Adresse verschicken, über den Empfang der Email vom Halter der Email-Adresse bestätigt werden muss (Link anklicken oder Code eingeben).

Bei syntaktischer Prüfung vorab bitte unbedingt in den Standard schauen, nicht einfach nur auf die üblichen verdächtigen Buchstaben prüfen... mehr als die Hälfte aller Webseite lehnen gültige Adressen z.B. mit "+" im Usernamen ab. Erlebe ich immer wieder, weil ich Googles Alias-System verwende ([e-mail] landet automatisch in Inbox [e-mail], d.h. ich kann spezifische Email-Adressen pro Dienst verwenden, ohne etwas einzurichten, und sehe sofort, wer meine Email-Adresse veruntreut hat, wenn ich mal Spam erhalte).

Schließe mich ansonsten der Overkill-Fraktion an :D

Ich schrieb ja das ich Neuling bin mit dem was ich vorhabe.

Delphi-Quellcode:

[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]

so in etwa schaut meine Syntax-Prüfung aus um der RFC Norm zu entsprechen.
Wenn meine Theorie eh Mist ist bzw heutzutage nicht mehr brauchbar ist dann bleibt mir wohl keine andere Wahl als tatsächlich ne Mail zu versenden. (Da brauche ich keine Hilfe, da hilft mir ICS)
Dann muss ich wohl an einem Dienst arbeiten der den ganzen Tag nichts weiter macht als ein Konto abzufragen ob da was angekommen ist, automatisch was zurücksenden, User muss dann das gesendete in Dialog einfügen, fertig. Oje...... was solls, alles wird gut.

[Delphi.Narium]

Beschreib' bitte Deine Aufgabenstellung nochmal etwas genauer:

Programm hat 'nen Registriedialog.
User gibt da was ein, u. a. eine eMail-Adresse.
Du bekommst diese Infos.
Prüfen, ob es die eMail-Adresse gibt.
Wenn ja, geschieht irgendwas, wenn nein geschieht was anderes.

Eigentlich kannst Du Dir das ganze Prüfen sparen.

Ob 'ne eMail-Adresse gültig ist oder nicht erfährst Du letztlich mit (annähernder) Sicherheit nur, wenn Du 'ne Mail hinschickst und über einen darin enthaltenen Link eine Antwort bekommst.

Bekommst Du diese nicht in einer von Dir festgelegten Zeitspanne, dann verwerfe die Anfrage aus dem Registriedialog.

Das Prüfen von Fehlermeldungen im eigenen Postfach (wegen Unzustellbarkeit ...) kann die Wartezeit verkürzen, da Du dann definitiv weist, dass es "diese" eMail-Adresse nicht gibt. Du kannst Dich aber schon nicht darauf verlassen, dass Du diese Meldung bekommst.

'ne Syntaxprüfung von eMail-Adressen kann nie vollständig sein, sondern nur 'ne Näherung ergeben, die aber schlimmstenfalls auch mal 'ne gültige eMail-Adresse als falsch erkennt.

Eine Antwortmail kann man manipulieren, in dem der Absender nicht zwingend der tatsächliche Absender ist, bringt also auch keine absolute Sicherheit.

Die Antwort auf einen Link in 'ner Mail bringt Dir zumindest die Sicherheit, dass Deine Mail erfolgreich an die angegebene eMail-Adresse verschickt wurde, die Mail geöffnet wurde und der Link angeklickt wurde.

Ob sich hinter der eMail-Adresse ein Sammelpostfach befindet, das die Mails von X Fake-eMail-Adressen entgegennimmt, wirst Du nie mit letzter Sicherheit erfahren.

[KodeZwerg]

Ich glaube ich entferne einfach dieses Feature, das übersteigt meinen Horizont. Meine 5 Punkte Theorie will ich zumindest einmal umgesetzt haben um daraus zu Lernen wie die Dinge so funktionieren/funktioniert haben.
Link verschicken, User klickt Link, das bedarf doch WebServer?

Was ich vorhatte war:
Registrier-Dialog öffnet sich, Anwender gibt Daten ein, auch eine eMail Adresse, dahinter sollte ein grüner Haken bzw gelbes Fragezeichen erscheinen, mehr nicht. Ist grüner Haken da werden mehr features im Programm aktiv, ohne das ich weiß wer es benutzt, das ist mir zu diesem Zeitpunkt noch egal. Ob da nun einer "[e-mail]" eintippt oder sonst was ist mir auch egal. Ich wollte damit nicht prüfen ob Anwender derjenige ist der sagt er ist dieses oder jenes. Nur Grundsätzlich als Gimmick ein "Existiert diese eMail-Adresse oder eben nicht" um die GUI aufzuhübschen.
Später wollte ich für Support/Kauf eine sende mail funktion integrieren das man mir Bugs Wünsche Freischaltung etc schicken kann. An dieser Stelle sollte halt geprüft werden ob derjenige auch ist wer er vorgibt zu sein.

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1409082)

[...]
Ich wollte damit nicht prüfen ob Anwender derjenige ist der sagt er ist dieses oder jenes.
[...]
An dieser Stelle sollte halt geprüft werden ob derjenige auch ist wer er vorgibt zu sein.

Du solltest mit dir selbst im Reinen sein, was du nun wirklich willst, sonst klappt die Umsetzung gar nicht.

[KodeZwerg]

Beachte meine Erste Zeile, ich bin mit mir im Reinen.

Delphi-Quellcode:

Ich glaube ich entferne einfach dieses Feature, das übersteigt meinen Horizont.

Beispiel:
User tippt ein: "[e-mail]" wollte ich ursprünglich schauen, existiert "ha.se", hat "ha.se" einen SMTP usw usf. Halte die 5 Punkte rasch runterrattern lassen. Dies hat noch nichts mit einer "mach aus Demo eine Vollversion" zu tun. Das dient nur der GUI Optik.
Demo nach Vollprodukt: Das wollte ich dann im nächsten Schritt erst bewerkstelligen. Support/Kauf, wo man mich anmailen kann/muss.

[Delphi.Narium]

Ok, das ist also eine etwas andere Aufgabenstellung, als ich vermutet hatte.

Per DNS prüfen, ob es die Domaine gibt.
Abfragen, ob es einen MX-Record gibt (d. h.: Domaine hat auch 'nen Mailserver).
Per RegEx prüfen, ob die angegebene Mailadresse (weitgehend) plausibel erscheint.

Als Gimmick vollkommen ausreichend.

Für die Verarbeitung einer Antwort per Link, wird ein Webserver benötigt. Den kann man aber per Indy oder ICS ins eigene Programm einbauen.

Theoretisch:

Programm starten
eMail-Adresse eingeben lassen
Mail an diese verschicken
User öffnet in seinem Mailprogramm die Mail
Klickt auf den Link
Das Programm kann mit seinem eingebauten HTTP-Server darauf reagieren.
(Es muss halt die ganze Zeit laufen und wir gehen davon aus, dass keine Firewall oder sonstwas die Kommunikation be- bzw. verhindert.)

Die Url im Link muss dann halt ungefähr so aussehen:

Code:

http://IP-des-Rechners-auf-dem-das-Programm-läuft:Port-auf-dem-das-Programmlauscht?email=[e-mail]

also z. B.:

Code:

http://172.217.20.99:88?email=[e-mail]

Als Spielerei, um sich mit der Thematik mal auseinanderzusetzen, eine durchaus sinnvollunsinnige Aufgabe. Das dabei "abgegraste" Spektrum ist dann doch schon eher vielseitig ;-)

[KodeZwerg]

Zitat:

Zitat von Delphi.Narium (Beitrag 1409086)

Für die Verarbeitung einer Antwort per Link, wird ein Webserver benötigt. Den kann man aber per Indy oder ICS ins eigene Programm einbauen.

Das ist es!!! Mir fehlt halt die Erfahrung, von daher wusste ich nicht mal das es Möglich ist bzw habe ich so etwas erst gar nicht in Betracht gezogen. Auch Dein Quick-Check Vorschlag gefällt mir sehr gut. Genau so werde ich vorgehen, Beispiele dafür (Server) gibt es ja reichlich.

Thread mehr als Happy beendet.

Vielen Dank für all Eure Mühen mit mir!!! Ich stürze mich da jetzt mal rein, ihr rockt:thumb:

[Schokohase]

Einen HTTP-Server den die Anwendung bereitstellt ... das ist doch eher ungewöhnlich und aus mehreren Gründen nicht zu empfehlen. Aber einfach selber probieren das übt.

Eigentlich hat man einen WebService laufen, der dann von der Anwendung diese email(-Adresse) erhält. Der WebService verschickt die email mit dem Link und verarbeitet auch den Link-Aufruf vom Anwender.

Die Anwendung fragt den WebService einfach nur noch nach dem Status der Aktivierung und gut.

[Rolf Frei]

Eine 100%ige E-Mailüberprüfung kannst du nicht machen, wie dir hier ja schon mehrere geschrieben haben. Du kannst im Prinzip nur die Syntax und das Vorhandensein eines Mailsservers, der zur EMail-Domäne passt, überprüfen.

Die Syntaxprüfung kannst du mit einem RegEx machen und die Abfage, ob es einen MX-Record zu einer E-Mailadresse gibt, kannst du mit folgender Unit machen. Die Funktion RFResolveMailServer liefert dir das Gewünschte retour.

Beispiel:

Code:

s := RFResolveMailServer('8.8.8.8', 'meinefirma.de');  // Google DNS

// Wenn kein zur Domäne passender MX-Record über den Google DSN gefunden wurde, 
// durchsuchen wir nun vom Root-DNS Server aus nach unten durch die DNS-Serverlisten. 
if s = '' then  
  s := RFResolveMailServer('', 'meinefirma.de');

if (s <> '') then
  Mailserver := s
else
  Mailserver := 'E-Mail domäne ungültig';

Code:

unit RFIndyUtils;

{$IFNDEF INDY9}
  {$IF RTLVersion > 18.0}
    {$DEFINE INDY10}
  {$IFEND}
{$ENDIF}

interface

uses
  Classes, IdDNSResolver;

function RFGetMXServers(const ADNSServer: String; const ADomain: String;
  AMXServers: TStrings;  ATimeOutMS: Integer = 0): Boolean; overload;
function RFGetMXServers(ADNSResolverComp: TIdDNSResolver;
  const ADNSServer: String; const ADomain: String; AMXServers: TStrings): Boolean; overload;
{ Liefert alle zu einer Domäne passenden Mailserver (MX) als StringList retour.
    ADNSServer:  Name des zu verwendenden DNS-Servers oder leer wenn e.root-servers.net
                 verwendet werden soll.
    AResolveDomain:  Domain-Name zu dem die Mailserver (MX) retour gegeben werden soll.
    AMXServers:  Stringliste in der die Mailserver retour geliefert werden. }

function RFResolveMailServer(const ADNSServer, AResolveDomain: String;
  ATimeOutMS: Integer = 0): String;
{ Liefert die Mailserveradresse zu einer EMail zurück. Bsp: [e-mail] -> mail.domain.com
  Mögliche Rückgabewerte:
    Server gemäss DNS MX-Record oder leer wenn nichts gefunden.
  Parameter:
    ADNSServer:  Name des zu verwendenden DNS-Servers oder leer zum Start bei einem root DNS-Server (empfohlen).
    AResolveDomain:  Domain-Name zu dem der eigentliche Server-Name retour gegeben werden soll
    ATimeOutMS:  Timeout in ms, die beim Lesen gewartet werden soll bevor ein Fehler kommt.
                 Wenn <= 0 wird der Standard verwendet }


implementation

uses
  SysUtils;


function SortServers(List: TStringList; Index1, Index2: Integer): Integer;
{ RFGetMXServers StringList-Sortierungsroutine }
var
  p1, p2: Word;
begin
  p1 := Word(List.Objects[Index1]);
  p2 := Word(List.Objects[Index2]);
  if p1 < p2 then
    Result := -1
  else if p1 > p2 then
    Result := 1
  else
    Result := 0;
end;

function InternalGetMXServers(ADNSResolverComp: TIdDNSResolver; const ADNSServer: String;
  const ADomain: String; AMXServers, ASearchedNSServers: TStrings): Boolean;
var
  i : Integer;
  NSServers, MXServers: TStringList;
  ServerARecord: String;
  TmpQueryType: TQueryType;
begin
  Result := False;
  AMXServers.Clear;
  if ADNSResolverComp = nil then
    Exit;

  if ADNSServer = '' then
    ADNSResolverComp.Host := 'k.root-servers.net'
  else
    ADNSResolverComp.Host := ADNSServer;
  try
    ADNSResolverComp.Resolve(ADomain);
    if ADNSResolverComp.QueryResult.Count = 0 then
    begin
      ADNSResolverComp.Host := 'i.root-servers.net';
      ADNSResolverComp.Resolve(ADomain);
    end;
  except
    Exit;
  end;

  MXServers := nil;
  ServerARecord := '';
  for i := 0 to ADNSResolverComp.QueryResult.Count - 1 do
  begin
    if ADNSResolverComp.QueryResult[i] is TMXRecord then
    begin
      if MXServers = nil then
        MXServers := TStringList.Create;
      with TMXRecord(ADNSResolverComp.QueryResult[i]) do
        MXServers.AddObject(ExchangeServer,TObject(Integer(Preference)));
    end;
    if ADNSResolverComp.QueryResult[i] is TARecord then
      ServerARecord := TARecord(ADNSResolverComp.QueryResult[i]).Name;
  end;

  if MXServers <> nil then
  begin
    MXServers.CustomSort(SortServers);
    AMXServers.Assign(MXServers);
    FreeAndNil(MXServers);
    Result := True;
    Exit;
  end;

  NSServers := nil;
  try
    for i := 0 to ADNSResolverComp.QueryResult.Count - 1 do
    begin
      if ADNSResolverComp.QueryResult[i] is TNSRecord then
      begin
        with TNSRecord(ADNSResolverComp.QueryResult[i]) do
        begin
          if HostName <> '' then
          begin
            if NSServers = nil then
              NSServers := TStringList.Create;
            NSServers.Add(HostName);
          end;
        end;
      end;
    end;

    if NSServers <> nil then
    begin
      for i := 0 to NSServers.Count-1 do
      begin
        { Bereits durchsuchte Subdomains sollen nicht mehr durchsucht werden }
        if ASearchedNSServers.IndexOf(NSServers[i]) = -1 then
        begin
          Result := InternalGetMXServers(ADNSResolverComp, NSServers[i], ADomain,
            AMXServers, ASearchedNSServers);
          if Result then
            Exit;
          ASearchedNSServers.Add(NSServers[i]);
        end;
      end;
    end
    else if ServerARecord <> '' then
    begin
      { Top Level no MX found, so we report the A record }
{$IFDEF INDY10}
      TmpQueryType := ADNSResolverComp.QueryType;
      ADNSResolverComp.QueryType := [qtA];
{$ELSE}
      TmpQueryType := ADNSResolverComp.QueryRecords;
      ADNSResolverComp.QueryRecords := [qtA];
{$ENDIF}
      try
        ADNSResolverComp.Resolve(ADomain);
        if ADNSResolverComp.QueryResult.Count <> 0 then
        begin
          AMXServers.Add(ADomain);
          Result := True;
        end;
      finally
{$IFDEF INDY10}
        ADNSResolverComp.QueryType := TmpQueryType;
{$ELSE}
        ADNSResolverComp.QueryRecords := TmpQueryType;
{$ENDIF}
      end;
    end;
  finally
    if NSServers <> nil then
      NSServers.Free;
  end;
end;

function RFGetMXServers(ADNSResolverComp: TIdDNSResolver; const ADNSServer: String;
  const ADomain: String; AMXServers: TStrings): Boolean; overload;
var
  SearchedNSServers: TStringList;
begin
  SearchedNSServers := TStringList.Create;
  try
    Result := InternalGetMXServers(ADNSResolverComp, ADNSServer, ADomain,
      AMXServers, SearchedNSServers);
  finally
    SearchedNSServers.Free;
  end;
end;


function RFGetMXServers(const ADNSServer: String; const ADomain: String;
  AMXServers: TStrings; ATimeOutMS: Integer = 0): Boolean;
var
  DNSResolver: TIdDNSResolver;
begin
  DNSResolver := TIdDNSResolver.Create(nil);
  try
{$IFDEF INDY10}
    if ATimeOutMS <> 0 then
      DNSResolver.WaitingTime := ATimeOutMS
    else
      DNSResolver.WaitingTime := 3000;
    DNSResolver.QueryType := [qtMX];
{$ELSE}
    if ATimeOutMS <> 0 then
      DNSResolver.ReceiveTimeout := ATimeOutMS
    else
      DNSResolver.ReceiveTimeout := 3000;
    DNSResolver.QueryRecords := [qtMX];
{$ENDIF}

    Result := RFGetMXServers(DNSResolver, ADNSServer, ADomain, AMXServers);
  finally
    DNSResolver.Free;
  end;
end;

function RFResolveMailServer(const ADNSServer, AResolveDomain: String;
  ATimeOutMS: Integer = 0): String;
var
  MXServers: TStringList;
begin
  Result := '';
  MXServers := TStringList.Create;
  try
    if RFGetMXServers(ADNSServer, AResolveDomain, MXServers, ATimeOutMS) then
      Result := Trim(MXServers[0]);
  finally
    MXServers.Free;
  end;
end;


end.

[KodeZwerg]

@Schokohase:
Für Leute die keinen Eigenen Web-Server betreiben finde ich diese Idee total klasse von Delphi.Narium.
Ich muss halt Proxy/Firewall features mit reinbringen damit es überall laufen sollte, da lese ich mich gerade rein.

Zu Übungszwecke für mich als Neuling, finde ich es ein tolles Nebenprojekt um Erfahrung sammeln zu können.

Ob und in wie fern ich meine daraus gewonnenen Skills dann im Produkt umsetze weiß ich gerade selbst noch nicht.
Grundsätzlich hat bereits Delphi.Nariums Post meinen Horizont erweitert. Damit werde ich eine Weile beschäftigt sein.

*da war was rotes mit ellenlangen Text, ich hab auf Antworten geklickt.


@Rolf Frei: Vielen Dank für diesen umfangreichen und vor allem kommentierten Source, das ist echt voll nett von Dir!