Auf Exports hin prüfen ohne DLL zu laden

Zitat:

Ich würde mir wohl eine 32Bit exe schreiben mit der ich via IPC oder SharedMem rede. Das geht aber nur bei Sachen die nicht absolut zeitkritisch sind.

Ich habe eine 32Bit Anwendung

Aber ich möchte die Plugins 32Bit mit einer 64Bit Anwendung ansprechen was ja auch funktioniert.
Habe halt nur das Problem das ich den Einsprungs punkt nicht auslesen kann.

Ich habe es temporär so gelöst und umgehe die Export Funktion (kann aber Probleme geben wenn eine falsche DLL dort abgelegt wird)
Das ist der Sinn der Überprüfung der ExportedFunctionNames damit es hier nicht knallt!

zusammenfalten · markieren

Delphi-Quellcode:

			//Prüfroutine für Winamp-Plugins

function IsWinampPlugin(APlugin:string):LongBool;

var

  ext : string;

  Exported : TStringList;

  IntI : Integer;

begin

  result := FALSE;

  ext := uppercase(ExtractFileExt(APlugin));

  if (ext <> '.DLL') then

    exit;

///  Exported := TStringList.Create;

//  VisName := PWideChar(APlugin);

//  ImageExportedFunctionNames(VisName, Exported);

//  for IntI := 0 to Exported.Count - 1 do

//  begin

//    if (Exported.Strings[IntI] = 'winampVisGetHeader') then

//    begin

      result := TRUE;

//      break;

//    end;

//  end;

//  Exported.Free;

end;

**KodeZwerg**

Es gibt 32 und 64 bit header, du musst auslesen ob PE oder PE+ datei typ und dann entsprechend den in windows.pas hinterlegten header nutzen.
Per standard wird der header genutzt mit dem du das kompilat erstellst, du musst delphi also etwas "überzeugen" den richtigen zu verwenden.

Wenn benötigt buddel ich aus meinem exe tool die sourcen raus.

Zitat von KodeZwerg:

Es gibt 32 und 64 bit header, du musst auslesen ob PE oder PE+ datei typ und dann entsprechend den in windows.pas hinterlegten header nutzen.
Per standard wird der header genutzt mit dem du das kompilat erstellst, du musst delphi also etwas "überzeugen" den richtigen zu verwenden.

Wenn benötigt buddel ich aus meinem exe tool die sourcen raus.

Jup wäre super wenn du zeit dafür hast.

Aber irgendwie verstehe ich das Problem nicht.
Nochmal. Ich habe eine 64Bit Anwendung die soll eine 32Bit.dll einlesen und mir den Export Namen davon zurückgeben.
Was hat jetzt die 64Bit Anwendung mit dem Header zu tun der wird doch aus der 32Bit DLL ausgelesen.

**KodeZwerg**

Schau mal, reicht dir das als ansatz? sonst schick ich dir mein komplettes projekt zur analyse.

zusammenfalten · markieren

Delphi-Quellcode:

			function TkzFileInfoExecutable.GetCustom: TExecutable;

var

  FS: TStream;

  Len: Int64;

  dwSig: DWORD;

  wSig: Word;

  bSig: Byte;

  i: Integer;

  s: string;

begin

  SetLastError(ERROR_SUCCESS);

  Result.HasMain := False;

  fHasInfo := Result.HasMain;

  if (not fCreated) then

    Exit;

  with fMain do

    begin

      Is64Bit := kzFileInfo.CodeBase.Is64Bit(fFileName);

      try

        Len := 0;

        FS := TFileStream.Create(fFileName, fmOpenRead or fmShareDenyNone);

        try

          try

            FS.Read(HeaderDos, SizeOf(IMAGE_DOS_HEADER));

            if ((HeaderDos.e_magic = IMAGE_DOS_SIGNATURE) or (HeaderDos.e_magic = IMAGE_DOSSTUB_SIGNATURE) or (HeaderDos.e_magic = IMAGE_OS2_SIGNATURE)) then

              begin

                try

                  PHeaderDos := @HeaderDos;

                  HasHeaderDos := (PHeaderDos <> nil);

                  HasMain := HasHeaderDos;

                  FS.Seek(HeaderDos._lfanew, soFromBeginning);

                  FS.Read(wSig, SizeOf(wSig));

                  FS.Seek(HeaderDos._lfanew, soFromBeginning);

                  FS.Read(dwSig, SizeOf(dwSig));

                  case HeaderDos.e_magic of

                    IMAGE_DOS_SIGNATURE:     HeaderSignature := Format('MZ [' + rsHexAndNumber + ']', [HeaderDos.e_magic, HeaderDos.e_magic], fFormatSettings);

                    IMAGE_DOSSTUB_SIGNATURE: HeaderSignature := Format('ZM (calling dos stub) [' + rsHexAndNumber + ']', [HeaderDos.e_magic, HeaderDos.e_magic], fFormatSettings);

                    IMAGE_OS2_SIGNATURE:     HeaderSignature := Format('NE (calling dos stub with segment registers DS=CS) [' + rsHexAndNumber + ']', [HeaderDos.e_magic, HeaderDos.e_magic], fFormatSettings);

                  end;

                except

                end;

                try

                  case wSig of

                    IMAGE_OS2_SIGNATURE:

                      begin

                        FS.Seek(HeaderDos._lfanew, soFromBeginning);

                        HeaderSignature := Format('NE [' + rsHexAndNumber + ']', [wSig, wSig], fFormatSettings);

                        FS.Read(HeaderNE, SizeOf(IMAGE_NE_HEADER));

                        PHeaderNE := @HeaderNE;

                        HasHeaderNE := (PHeaderNE <> nil);

//                        messagebox(0, pchar(inttostr(fs.position)), pchar(inttostr(fs.position)), mb_ok);

                      end;

                    IMAGE_VXD_SIGNATURE:

                      begin

                        HeaderSignature := Format('LE [' + rsHexAndNumber + ']', [wSig, wSig], fFormatSettings);

                      end;

                    IMAGE_NT_SIGNATURE:

                      begin

                        HeaderSignature := Format('PE [' + rsHexAndNumber + ']', [wSig, wSig], fFormatSettings);

                        FS.Read(HeaderFile, SizeOf(IMAGE_FILE_HEADER));

                        PHeaderFile := @HeaderFile;

                        HasHeaderFile := (PHeaderFile <> nil);

                      end;

                    else

                      HeaderSignature := Format('Unknown Signature: ' + rsHexAndNumber, [dwSig, dwSig], fFormatSettings);

                  end;

                  Len := FS.Position;

                except

                end;

                if HasHeaderFile then

                  begin

                    if (HeaderFile.SizeOfOptionalHeader > 0) then

                      begin

                        i := FS.Position;

                        FS.Read(wSig, SizeOf(wSig));

                        Is64Bit := (wSig = IMAGE_NT_OPTIONAL_HDR64_MAGIC);

                        HeaderMagicPEw := wSig;

                        FS.Seek(i, soFromBeginning);

                        FS.Read(dwSig, SizeOf(dwSig));

                        HeaderMagicPEdw := dwSig;

                        FS.Seek(i, soFromBeginning);

                        if Is64Bit then

                          begin

                            try

                              FS.Read(HeaderOptional64, SizeOf(IMAGE_OPTIONAL_HEADER64));

                              PHeaderOptional64 := @HeaderOptional64;

                              HasHeaderOptional := (PHeaderOptional64 <> nil);

                              IsROM := (HeaderOptional64.Magic = IMAGE_ROM_OPTIONAL_HDR_MAGIC);

                            except

                            end;

                          end

                          else

                          begin

                            try

                              FS.Read(HeaderOptional32, SizeOf(IMAGE_OPTIONAL_HEADER32));

                              PHeaderOptional32 := @HeaderOptional32;

                              HasHeaderOptional := (PHeaderOptional32 <> nil);

                              IsROM := (HeaderOptional32.Magic = IMAGE_ROM_OPTIONAL_HDR_MAGIC);

                            except

                            end;

                          end;

                        if IsROM then

                          begin

                            try

                              FS.Seek(Len, soFromBeginning);

                              FS.Read(HeaderROM, SizeOf(IMAGE_ROM_OPTIONAL_HEADER));

                              PHeaderROM := @HeaderROM;

                              HasHeaderROM := (PHeaderROM <> nil);

                            except

                            end;

                          end;

                      end;

                    { fill array with sections and compute filesize by header data }

                    if (HeaderFile.NumberOfSections > 0) then

                      begin

                        try

                          FileSizeHeader := 0;

                          SetLength(HeaderSection, HeaderFile.NumberOfSections);

                          SetLength(PHeaderSection, HeaderFile.NumberOfSections);

                          for i := 1 to HeaderFile.NumberOfSections do

                            begin

                              FS.Read(HeaderSection[i - 1], SizeOf(IMAGE_SECTION_HEADER));

                              PHeaderSection[i - 1] := @HeaderSection[i - 1];

                              with PHeaderSection[i - 1]^ do

//                                if ((PointerToRawData + SizeOfRawData > fFileSizeFromHeader) and (PointerToRawData + SizeOfRawData <= fFileSize)) then

                                if (PointerToRawData + SizeOfRawData > FileSizeHeader) then

                                  FileSizeHeader := PointerToRawData + SizeOfRawData;

                            end;

                          HasHeaderSection := (Length(HeaderSection) > 0);

                        except

                        end;

                      end;

                  end;

                { extract NE specific description }

                if HasHeaderNE then

                begin

                  try

                    FS.Seek(HeaderNE.NonresidentNameTableOffset, soFromBeginning);

                    FS.Read(bSig, SizeOf(bSig));

                    Len := bSig;

                    s := '';

                    for i := 0 to Len do

                      begin

                        FS.Read(bSig, SizeOf(bSig));

                        s := s + Char(bSig);

                      end;

                    DescriptionNE := Trim(s);

                  except

                  end;

                end;

              end;

          except

          end;

        finally

          FS.Free;

        end;

      except

      end;

      BinaryType := GetBinType(fFileName);

      ImageCheckSum := GetImageCheckSum(fFileName);

      fHasInfo := HasMain;

      if (HasHeaderDos) then

        DumpDos := DumpHeaderDos;

      if (HasHeaderFile) then

        DumpFile := DumpHeaderFile;

      if (HasHeaderOptional) then

        DumpOptional := DumpHeaderOptional;

      if (HasHeaderRom) then

        DumpRom := DumpHeaderRom;

      if (HasHeaderNE) then

        DumpNE := DumpHeaderNE;

      if (HasHeaderDos) then

        Entropy := GetEntropy;

    end;

  Result := fMain;

end;

Es ist so..

PIMAGE_NT_HEADERS = ^IMAGE_NT_HEADERS;
^IMAGE_NT_HEADERS verzweigt unter 64Bit auf
IMAGE_NT_HEADERS = IMAGE_NT_HEADERS64;
sollte also der richtige record sein.

geht aber trotzdem nicht.

Dein Schnipsel hilft mir bei den Problem nicht.
trotzdem Danke für das raussuchen.

EDIT:
So wie ich sagte der Header der 64Bit Anwendung hat nichts mit dem Header der 32Bit DLL's zu tun.
Es geht deshalb nicht weil Delphi mir den Header verdreht! Ich brauche den für 32Bit nicht den für 64Bit. Der Header einer 64Bit-DLL interessiert mich nicht!
Er macht aus IMAGE_NT_HEADERS = IMAGE_NT_HEADERS64 es muß aber IMAGE_NT_HEADERS32 sein denn die DLL die ich auslese ist 32Bit nicht 64Bit!

Siehe!

Zitat:

Nochmal. Ich habe eine 64Bit Anwendung die soll eine 32Bit.dll einlesen und mir den Export Namen davon zurückgeben.
Was hat jetzt die 64Bit Anwendung mit dem Header zu tun der wird doch aus der 32Bit DLL ausgelesen.

Nach dieser Änderung funktioniert es jetzt.

markieren

Delphi-Quellcode:

			PIMAGE_NT_HEADERS = ^IMAGE_NT_HEADERS32; // Das hier "^IMAGE_NT_HEADERS" wurde von Delphi auf 64Bit verdreht deshalb ging es nicht.

PIMAGE_EXPORT_DIRECTORY = ^IMAGE_EXPORT_DIRECTORY;

**KodeZwerg**

>> IMAGE_NT_OPTIONAL_HDR64_MAGIC << darauf musst du prüfen um zu entscheiden welchen optionalen header typ du verwenden musst (32/64 bit optionaler header)

die header sind unterschiedlich weswegen du mit 64bit header bei 32 bit anwendungen am falschen ziel landest.
umgekehrt genauso, 32 bit app die 64 bit analysiert.

ich kann mich leider nicht verständlicher ausdrücken, es tut mir leid.

Zitat von KodeZwerg:

>> IMAGE_NT_OPTIONAL_HDR64_MAGIC << darauf musst du prüfen um zu entscheiden welchen optionalen header typ du verwenden musst (32/64 bit optionaler header)

die header sind unterschiedlich weswegen du mit 64bit header bei 32 bit anwendungen am falschen ziel landest.
umgekehrt genauso, 32 bit app die 64 bit analysiert.

ich kann mich leider nicht verständlicher ausdrücken, es tut mir leid.

Siehe mein Edit wo das Problem war.
Danke dir.

**KodeZwerg**

Jo so kann man es machen wenn es nicht generisch sein soll.
per prüfung auf die bittigkeit kann dein code zukunftssicherer werden, falls die 2.te datei mal 32<>64 bit wechselt.
genau das stellt mein schnippsel dar, er entscheidet was korrekt ist zu nehmen.

thema ist ja durch, hab noch einen schönen tag!

Zitat:

genau das stellt mein schnippsel dar, er entscheidet was korrekt ist zu nehmen.

Habe ich auch so verstanden

Wenn ich aber weiß das ich mit 64Bit nur 32Bit DLL`s auslesen will dann ist meine Lösung das einfachste.
Vorher habe ich nicht gesehen das Delphi das einfach von sich aus umstellt.
Ist auch eigentlich logisch den normalerweise arbeitet man ja auch komplett in 64Bit.

Ist halt ein Ausnahmefall.

**himitsu**

Ja, Delphi (und auch andere Compiler) kompileren mit dem Typen, für welchen die eigene EXE erstellt wurde.
IMAGE_NT_HEADERS ist also nur für andere PE (EXE/DLL), vom selben Type, wie das eigene Compilat.

Aber niemand verbietet es direkt IMAGE_NT_HEADERS32 oder IMAGE_NT_HEADERS64 zu verwenden.
* entweder nur mit Einen der Typen, wenn IMMER die selbe PE gelesen werden soll (unabhängig was die eigene EXE ist)
* oder eben vorher auslesen was für ein Typ es ist und dann den jeweils passenden Header verwenden