Prüfen, ob RegistryKey vorhanden ist?

[Jamah]

Moin.
Ich versuche jetzt seit Stunden, mein Programm zum laufen zu bringen aber es will einfach nicht. Es soll einfach nur überprüfen, ob ein Key in der Registry vorhanden ist.
Aber ich habs echt in X verschiedenen Arten getestet, z.B. so:

Delphi-Quellcode:

begin
  result:= false;
  reg:= TRegistry.Create;
  try
    reg.RootKey:= HKEY_Local_Machine;
    if reg.KeyExists('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName') = True then
      begin
       Name:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
       result:= True;
      end;
  finally
     reg.Free;
  end;
end;

oder so:

Delphi-Quellcode:

begin
  result:= false;
  reg:= TRegistry.Create;
  try
    reg.RootKey:= HKEY_Local_Machine;
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName', False) = True then
      begin
       Name:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
       result:= True;
      end;
  finally
     reg.Free;
  end;
end;

und so:

Delphi-Quellcode:

begin
  result:= false;
  reg:= TRegistry.Create;
  try
    reg.RootKey:= HKEY_Local_Machine;
    reg.CurrentPath:= '\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\';
    if reg.KeyExists('KeyName') = True then
      begin
       Name:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
       result:= True;
      end;
  finally
     reg.Free;
  end;
end;

Wahrscheinlich wieder irgendwas ganz primitives, das ih übersehen habe oder?

Danke für eure Hilfe

[Luckie]

Zitat:

Es will nicht.

Aha. Und was kann ich mir, als jemand, der nicht vor deinem Computer sitzt, darunter vorstellen?

[Jamah]

Er gibt mir immer aus, dass der Key nicht vorhanden ist, obwohl er existiert.
Beziehungsweise result ist immer false.
Sorry die Beschreibung oben war missverständlich. Hatte ich garnicht bemerkt.

[Andreas L.]

Ganz wichtig: Man prüft einen Boolean nicht mit = TRUE oder = FALSE. Das ist nicht nur unlogisch sondern kann auch Fehler (insbesondere in Verbindung mit API-Funktionen) verursachen.

Delphi-Quellcode:

  if Reg.KeyExists then  //richtig
    //true

  if not Reg.KeyExists then //richtig
    //false

  if Reg.KeyExists = TRUE then //falsch

  if Reg.KeyExists = FALSE then //falsch

Zu deinen Code: Du verwechselst den Schlüssel (Key, z. B. \SOFTWARE\Irgendwas\) mit dem Namen eines Wertes (KeyName).

Delphi-Quellcode:

  Result := False;

  Reg := TRegistry.Create(KEY_READ);  //Reg Nur-Lesen öffnen, dann brauchen wir auch keine Adminrechte
  try
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    if Reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
    begin
      Result := Reg.ValueExists('KeyName');
    end;
  finally
    Reg.Free;
  end;

[Jamah]

Oh. Da war mein code doch mal wieder ein Griff ins Klo. :lol:

Falls ich den Key jetzt bearbeiten wollte, würde es aber reichen, einfach das (KEY_READ) wegzulassen, oder? Und nebenbei falls das Programm dann immer als Administrator gestrtet werden muss, kann man das gleich im Code mitgeben oder abfragen, damit dadurch keine Fehler entstehen?

Danke

[Luckie]

Und unter Vista und höher schlägt wahrscheinlich auch noch die Virtualisierung zu, da du den Schlüssel mit allen Rechnen öffnest. Als normaler Benutzer hast du aber keine Schreibrechte unter HKLM. Öffne den Schlüssel also nur zum Lesen.

[Andreas L.]

Zitat:

Zitat von Jamah

Falls ich den Key jetzt bearbeiten wollte, würde es aber reichen, einfach das (KEY_READ) wegzulassen, oder?

Normalerweise schon, du kannst dir ja mal in der Delphi-Hilfe anschauen welche Konstanten da man noch so alles übergeben kann :wink:

Zitat:

Zitat von Jamah

Und nebenbei falls das Programm dann immer als Administrator gestrtet werden muss, kann man das gleich im Code mitgeben oder abfragen, damit dadurch keine Fehler entstehen?

Such mal im Forum bzw. in MSDN nach IsUserAdmin oder UserIsAdmin oder ähnlich. Damit kannst abfragen ob der aktuelle Nutzer Admin-Rechte hat.

[Luckie]

Aber vorsicht. Unter Vista und höher ist Administrator nicht gleich Administrator!

[Andreas L.]

Zitat:

Zitat von Luckie

Aber vorsicht. Unter Vista und höher ist Administrator nicht gleich Administrator!

Ja, wegen UAC richtig? Soweit ich weiß gibt die API-Funktion IsUserAnAdmin (http://msdn.microsoft.com/en-us/library/bb776463.aspx) false zurück wenn der User zwar Admin ist aber trotzdem nur Benutzer-Rechte hat.

[Jamah]

Ich brauch nochmal Rat.
ich hab hier jetzt das hier fabriziert:

Delphi-Quellcode:

function RegCheck():Boolean;
begin
  result:= false;
  reg:= TRegistry.Create;
  try
    reg.RootKey:= HKEY_Local_Machine;
    if reg.KeyExists('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\') then
      begin
        if reg.ValueExists('KeyName') then
          begin
            Name:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 1;
          end;
      end;
    reg.RootKey:= HKEY_Current_User;
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
    begin
      if reg.ValueExists('KeyName') then
          begin
            Name:= ('HKEY_Current_User\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 2;
          end;
    end;
  finally
     reg.Free;
  end;
end;

Ich bekomme als Result zwar True, was richtig ist, allerdings wird x nicht deklariert, und die name-ausgabe liefert: 'Form1', und das obwohl die nirgendwo als 'Form1' definiert wird.

Was nu?
Danke

[Andreas L.]

Schon klar das in Name der Name der Form drinsteht. Ist schließlich nichts anderes wie Self.Name und Self ist eben die Form. Wo hast du x denn definiert? Global?

[Jamah]

Warum denn?
Steht doch drin: Name:= ('HKEY_Current_User.......');

Ja x ist global definiert.

[lbccaleb]

Zitat:

Zitat von Jamah

Warum denn?
Steht doch drin: Name:= ('HKEY_Current_User.......');

Ja x ist global definiert.

Er wollte dir damit sagen, dass du mit dem oben geposteten nicht den Reg.Name änderst, sondern den der Form..

Wenn du es soc machen willst, musst du mit

Delphi-Quellcode:

with reg do begin
  //...
end;

arbeiten.

[Jamah]

Ok. funktioniert jetzt beides.
Letztes Manko:
Wenn ich den Schlüssel mit dem Value: KeyName in HKEY_Current_User hab, gehts, und er liefert den richtigen Wert zurück.
Wenn ich den Schlüssel aber in HKEY_Local_Machine (also ein x-wert 1 rauskommen müsste,) kommt nix raus. Findet entweder den Value nicht oder geht garnicht erst in die Schleife.
Das verstehe ich nicht.

[lbccaleb]

Existiert er dort denn??

[DeddyH]

Kann es sein, dass die ganzen Ratschläge von oben wieder über Bord geworfen wurden? Ich versuch es mal aus der hohlen Hand:

Delphi-Quellcode:

function RegCheck():Boolean;
begin
  result:= false;
  reg:= TRegistry.Create(KEY_READ); //nur zum Lesen öffnen <-- fehlte
  try
    reg.RootKey:= HKEY_Local_Machine;
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\',false) then
      try
        if reg.ValueExists('KeyName') then
          begin
            Name:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 1;
          end;
      finally
        Reg.CloseKey; //das hab ich in den oberen Codes komplett vermisst
      end;
    reg.RootKey:= HKEY_Current_User;
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
     try
       if reg.ValueExists('KeyName') then
          begin
            Name:= ('HKEY_Current_User\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 2;
          end;
     finally
       Reg.CloseKey; //s.o.
     end;
  finally
     reg.Free;
  end;
end;

Außerdem würde ich nicht auf globale Variablen zugreifen wollen, sondern x und Name eher als var-Parameter übergeben.

[Jamah]

100%ig.
Der ist da. Aber irgendwie bekomme ich die Rückgabe: Alles in Ordnung.
Soll eigentlich eine Art Removal Tool für einen bestimmten Virus werden. Einen Trojaner, der sich an einer Stelle mit einem bestimmten Value in die Registry schreibt, nämlich entweder in HKEY_Current_User oder in den Local_Machine. Pfad ist der Selbe.
Ich will nur den Key abfragen und dann in einem 2. Schritt bei existenz löschen.

[DeddyH]

Zitat:

Zitat von Jamah

Soll eigentlich eine Art Removal Tool für einen bestimmten Virus werden. Einen Trojaner, der sich an einer Stelle mit einem bestimmten Value in die Registry schreibt, nämlich entweder in HKEY_Current_User oder in den Local_Machine. Pfad ist der Selbe.
Ich will nur den Key abfragen und dann in einem 2. Schritt bei existenz löschen.

Ist das Dein Ernst? :shock: Wenn ich mir einen Virus/Trojaner einfange, verlasse ich mich nicht darauf, dass nach dem Löschen div. Registrykeys alles wieder in Butter ist.

[lbccaleb]

Die Arbeit würd ich auch den Antiviren Tools überlassen ;)

Glaub mir das ist sicherer ;)

[Jamah]

Ob sowas sicher ist oder nicht lasst lieber meine Sorge sein. Ich bin mir sicher, dass es 100% funktionieren wird, da das Ding einfach schlecht programmiert ist und zumindest das letzte offizielle Build immer die gleichen Sachen benutzt. Dependencies löschen geht schon, die .exe an sich mit Taskkill und on Reboot auch. Einziges Problem ist, dass ich dne Registry-Eintrag beseitigt haben will, damit ich wirklich 100% sicher sein kann.

Ich glaube, dass wir hier nicht über den Sinn diskutieren sollten. Tatsache ist:
- Der Key ist existent (hat nix drinstehen nur den Value 'KeyName'
- Wenn der in CurrentUser abgelegt ist kann der gefunden und gelöscht werden, nur in HKEY_LOCAL_MACHINE findet der den nicht
- x: Integer und reg: TRegistry sind global definiert.


nochmal der aktuelle Code:

Delphi-Quellcode:

function RegCheck():Boolean;
begin
  result:= false;
  reg:= TRegistry.Create;
  try
    reg.RootKey:= HKEY_LOCAL_MACHINE;
    if reg.KeyExists('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\') then
      begin
        if reg.ValueExists('KeyName') then
          begin
            Names:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 1;
          end;
      end;
    reg.RootKey:= HKEY_Current_User;
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
    begin
      if reg.ValueExists('KeyName') then
          begin
            Names:= ('HKEY_Current_User\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 2;
          end;
    end;
  finally
     reg.Free;
  end;
end;

Leider funktioniert dieser Code auch nicht, ich denke es ist der selbe Fehler, dieser Code sollte den Key löschen aber anscheinend geht er nicht in die Schleife ich weiß nicht warum. Dort steht dann nur Starting removal dependencies... und die procedure ist beendet.

Delphi-Quellcode:

  if Res1 = True then
      begin
        sMemo1.Lines.Add('Starting removal dependencies...');
        if x = 1 then
          begin
            reg:= Tregistry.Create;
            try
               reg.RootKey:= HKEY_Local_Machine;
               if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
                 begin
                    sMemo1.Lines.Add('');
                    sMemo1.Lines.Add('Getting values...');
                    sMemo1.Lines.Add('Deleting trojan from registry...');
                    reg.DeleteValue('KeyName');
                    if reg.ValueExists('KeyName') then
                      begin
                        sMemo1.Lines.Add('');
                        sMemo1.Lines.Add('Failed to delete.');
                        sMemo1.Lines.Add('Maybe you have no admin rights?');
                        sMemo1.Lines.Add('You can also delete it manually using the ''''regedit''''command');
                        sMemo1.Lines.Add('');
                      end;
                 end;
              finally
               reg.Free;
            end;
      if x = 2 then
          begin
            reg:= Tregistry.Create;
            try
               reg.RootKey:= HKEY_Current_User;
               if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
                 begin
                    sMemo1.Lines.Add('');
                    sMemo1.Lines.Add('Getting values...');
                    sMemo1.Lines.Add('Deleting trojan from registry...');
                    reg.DeleteValue('KeyName');
                    if reg.ValueExists('KeyName') then
                      begin
                        sMemo1.Lines.Add('');
                        sMemo1.Lines.Add('Failed to delete.');
                        sMemo1.Lines.Add('Maybe you have no admin rights?');
                        sMemo1.Lines.Add('You can also delete it manually using the ''''regedit''''command');
                        sMemo1.Lines.Add('');
                      end;
                 end;
            finally
              reg.Free;
            end;
          end;

Danke für euer Verständnis und eure Hilfe

[daywalker9]

Wieso definierst du Reg global?

Du erzeugst es doch in der Funktion und gibst es dort auch wieder frei. Es reicht in dem moment, wenn du es lokal definierst.

Achja und Boolean nie auf = true oder = false abfragen. Das Thema wurde hier im Forum schon oft diskutiert

[Luckie]

Und noch was. Du hast zweimal fast identischen Code. Warum übergibst du den Registry Hive nicht als Parameter?

Und hast du schon mal debuggt, ob er überhaupt in den Zweig rein geht, in dem er aus HKLM löschen soll?

[Jamah]

Ich brauch das doch später auch nochmal um das ganze aufzurufen, um den Key zulöschen...

Ich hab übrigens grad gesehen, dass ich da versehentlich KeyExists statt OpenKey genommen hab. hab das jetzt mal geändert aber irgendwie gehts immernoch nicht. Also gleiches Problem. und ich hab das eingebaut, was DeddyH oben geschrieben hat. Also mit dem Try und Finally um jede schleife.

Und wie soll ich sonst das Abfragen, mit Boolean, wenn nicht mit True & False? :wiejetzt:

Ja ich hab debuggt und bei reg.ValueExists n Breakpoint hingesetzt und da kommt der auch an, nur in die schleife danach geht der nicht rein.

[daywalker9]

Delphi-Quellcode:

var ok : boolean;

if ok then

if not ok then

[Luckie]

Zitat:

Zitat von Jamah

Ich brauch das doch später auch nochmal um das ganze aufzurufen, um den Key zulöschen...

Und was hat da smit dem doppeltem Code zu tun?

Zitat:

Und wie soll ich sonst das Abfragen, mit Boolean, wenn nicht mit True & False? :wiejetzt:

Delphi-Quellcode:

if Res then

Zitat:

Ja ich hab debuggt und bei reg.ValueExists n Breakpoint hingesetzt und da kommt der auch an, nur in die schleife danach geht der nicht rein.

Welche Schleife?

[Jamah]

Ok jetzt schnall ich das xD
Ich hab mal bei dem Löschen-Prozedre debuggt. Der kommt irgendwie garnicht bei der Schleife an.
Also bei der 2.
Delphi wird mir grad immer unheimlicher..... :D :gruebel:

Bei if reg.ValueExists(value) sollte der ja dann in das begin.....end reingehen aber da kommt der nicht an....


OK Ich erklär mich jetzt mal zum blindesten Menschen der Welt.
Ich hab bei der delete schleife einfach nur ein 'end' an die falsche stelle gesetzt. Das stand unten und nicht oben.

Das hat sich dann erledigt. Nur warum der oben (Abfrage, ob der Key existiert) den einen Schlüssel nicht findet bleibt mir ein Rätsel...

[Luckie]

Dann mach da doch mal eine gescheite Fehlerbehandlung rein. Und frag mal den letzten Fehler ab.

[daywalker9]

Dann bau mal Fehlerbehandlung bei dir ein.

Kannst du mit

Delphi-Quellcode:

TRegistry.LastError
TRegistry.LastErrorMsg

abfragen

[Jamah]

Sorry, wenn die Frage vllt verwirrt klingt aber wo denn? Ich habs jetz so zimelich überall versucht aber irgendwie kommt immer: Auf LastError kann hier nicht zugegriffen werden...

[daywalker9]

Zitat:

Zitat von Jamah

Sorry, wenn die Frage vllt verwirrt klingt aber wo denn? Ich habs jetz so zimelich überall versucht aber irgendwie kommt immer: Auf LastError kann hier nicht zugegriffen werden...

Delphi-Quellcode:

if reg.LastError<>0 then
  begin  
   ShowMessage(reg.LastErrorMsg);
  end;

[Jamah]

Wenn ich das in die erste Schleife baue, die als einzige nicht funktioniert, kommt: Das System kann die angegebene Datei nicht finden.

Aber irgendwie hab ich mich doch nicht vertippt. Ich habs nochmal von dem funktionierenden Teil mit Copy & Paste übernommen...

[daywalker9]

Zeig den Source nun mal mit der Fehlerbehandlung und zeige mal genau wo der Fehler aufläuft

[Jamah]

Delphi-Quellcode:

function RegCheck():Boolean;
begin
  result:= false;
  reg:= TRegistry.Create(Key_Read);
  try
    reg.RootKey:= (HKEY_LOCAL_MACHINE);
    try
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
    begin
      if reg.ValueExists('KeyName') then
          begin
            Names:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 1;
          end;
      end;
      if reg.LastError<>0 then
  begin
   ShowMessage(reg.LastErrorMsg);
  end;
      finally
        reg.CloseKey;
      end;
    reg.RootKey:= HKEY_Current_User;
    try
    if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
    begin
      if reg.ValueExists('KeyName') then
          begin
            Names:= ('HKEY_Current_User\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
            result:= True;
            x:= 2;
          end;
    end;
    finally
      Reg.CloseKey;
    end;
  finally
     reg.Free;
  end;
end;

Die obere Schleife

[daywalker9]

Aber wenn du per regedit guckst ist der Key da?

[lbccaleb]

Also bei mir funktioniert das so:

Delphi-Quellcode:

function RegCheck():Boolean;
begin
  result:= false;
  reg := TRegistry.Create(Key_Read);
  with reg do begin
    RootKey := HKEY_LOCAL_MACHINE;
    try
      if OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
        if ValueExists('KeyName') then begin;
          ShowMessage('da');
          x := 1;
          //Names:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
      end;
    finally
      CloseKey;
    end;

    RootKey := HKEY_CURRENT_USER;
    try
      if OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
        if ValueExists('KeyName') then begin;
          ShowMessage('da');
          x := 2;
          //Names:= ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
      end;
    finally
      CloseKey;
    end;

    Free
  end;
end;

Jetzt ist es deine Aufgabe das noch anzupassen, und Fehlerbehandlungsroutinen einzubauen.
Das weiß ich nicht genau, das ist Delphi unterschiedlich, und die Fehlerbehandlungen die Ihr verwendet gibt es bei meinem Delphi noch net.

[Luckie]

So geht's mit der Fehlerbehandlung:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Dialogs, Registry, SysUtils;

implementation

function RegCheck(): Boolean;
var
  reg: TRegistry;
  Names: string;
  x: Integer;
begin
  result := false;
  reg := TRegistry.Create(Key_Read);
  try
    reg.RootKey := (HKEY_LOCAL_MACHINE);
    try
      if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
      begin
        if reg.ValueExists('KeyName') then
        begin
          Names := ('HKEY_Local_Machine\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
          result := True;
          x := 1;
        end;
      end
      else
        ShowMessage(SysErrorMessage(GetLastError));
    finally
      reg.CloseKey;
    end;
    reg.RootKey := HKEY_Current_User;
    try
      if reg.OpenKey('\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', False) then
      begin
        if reg.ValueExists('KeyName') then
        begin
          Names := ('HKEY_Current_User\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\KeyName');
          result := True;
          x := 2;
        end;
      end
      else
        ShowMessage(SysErrorMessage(GetLastError));
    finally
      Reg.CloseKey;
    end;
  finally
    reg.Free;
  end;
end;

end.

Und hör bitte auf von Schleifen zu reden. In dem ganzen Code gibt es keine einzige Schleife. if-Bedingungen sind Verzweigungen.

[Jamah]

Okay.
Wenn ich dieses Else mit dem ShowMessage(SysErrorMessage(GetLastError))einbaue (obere verzweigung) dann kommt (Key vorhanden, wird aber nicht gefunden) erst: Das Fenster hat keine Bildlaufleisten! und dann Falscher Parameter. Also 2 ShowMessages.
Hilft das weiter?

[lbccaleb]

Welche Version benutzt du jetzt??
Die von Luckie hat bereits Fehlerbehandlungen mit eingebaut.

Vllt solltest du noch mal zeigen was genau du jetzt hast an, weil ich hab das gefühl so kommen wir hier nicht weiter :shock:

[Jamah]

Das kommt bei mir mit der Version von Luckie raus.

[p80286]

Das ist aber ein seltsames Verhalten.

Ich habe Lukies Version ausprobiert, und sie funktioniert fehlerfrei.
allerdings läuft reg.OpenKey vor die Wand, da ich nur Leserechte habe. Dafür gibt es ja auch reg.OpenKeyReadonly.

Gruß
K-H