Auf Exports hin prüfen ohne DLL zu laden

[EWeiss]

Um zu verhindern das unnötige System Messagen angezeigt werden würde ich gerne die Exports prüfen
ohne die DLL mit LoadLibrary vorher zu laden.

Hat da vielleicht jemand ein Code Schnipsel? (Man muss ja nicht alles neu erfinden)
Wenn jemand falsche DLL's in meinem Ordner abgelegt hat und diese auch noch fehlerhaft sind
dann nerven einfach die System Messagen die aufpoppen wenn ich diese vorher laden muss.

EDIT:
Hat sich erledigt hab ne Lösung gefunden!

gruss

[EWeiss]

na ja will euch die Lösung nicht verschweigen.

Delphi-Quellcode:

type
  PIMAGE_NT_HEADERS = ^IMAGE_NT_HEADERS;
  PIMAGE_EXPORT_DIRECTORY = ^IMAGE_EXPORT_DIRECTORY;

function ImageNtHeader(Base: Pointer): PIMAGE_NT_HEADERS; stdcall; external 'dbghelp.dll';
function ImageRvaToVa(NtHeaders: Pointer; Base: Pointer; Rva: ULONG;
  LastRvaSection: Pointer): Pointer; stdcall; external 'dbghelp.dll';


procedure ImageExportedFunctionNames(const ImageName: string; NamesList: TStrings);
var
  i: Integer;
  FileHandle: THandle;
  ImageHandle: THandle;
  ImagePointer: Pointer;
  Header: PIMAGE_NT_HEADERS;
  ExportTable: PIMAGE_EXPORT_DIRECTORY;
  NamesPointer: Pointer;
  Names: PAnsiChar;
  NamesDataLeft: Integer;
begin
  //NOTE: our policy in this procedure is to exit upon any failure and return an empty list
  NamesList.Clear;

  FileHandle := CreateFile(PWideChar(ImageName),GENERIC_READ, FILE_SHARE_READ,
    nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
  if FileHandle=INVALID_HANDLE_VALUE then
    exit;

  try
    ImageHandle := CreateFileMapping(FileHandle, nil, PAGE_READONLY, 0, 0, nil);
    if ImageHandle = 0 then
      exit;
    try
      ImagePointer := MapViewOfFile(ImageHandle, FILE_MAP_READ, 0, 0, 0);
      if not Assigned(ImagePointer) then
        exit;
      try
        Header := ImageNtHeader(ImagePointer);
        if not Assigned(Header) then
          exit;

        if Header.Signature<>$00004550 then  // "PE\0\0" as a DWORD.
          exit;

        ExportTable := ImageRvaToVa(Header, ImagePointer, Header.OptionalHeader.DataDirectory[0].VirtualAddress, nil);
        if not Assigned(ExportTable) then
          exit;

        NamesPointer := ImageRvaToVa(Header, ImagePointer, Cardinal(ExportTable.AddressOfNames), nil);
        if not Assigned(NamesPointer) then
          exit;

        Names := ImageRvaToVa(Header, ImagePointer, Cardinal(NamesPointer^), nil);
        if not Assigned(Names) then
          exit;

        NamesDataLeft := Header.OptionalHeader.DataDirectory[0].Size;
        for i := 0 to ExportTable.NumberOfNames-1 do begin
          NamesList.Add(string(Names));
          // Locate the next name
          while (Names^<>chr(0)) and (NamesDataLeft>0) do begin
            inc(Names);
            dec(NamesDataLeft);
          end;
          inc(Names);
        end;
      finally
        UnmapViewOfFile(ImagePointer); // Ignore error as there is not much we could do.
      end;
    finally
      CloseHandle(ImageHandle);
    end;
  finally
    CloseHandle(FileHandle);
  end;
end;

Delphi-Quellcode:

//Prüfroutine für Winamp-Plugins
function IsWinampPlugin(APlugin:string):LongBool;
var
  ext : string;
  //dll : HMODULE;
  //Filename : 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;

  {Filename := uppercase(ExtractFileName(VisName));
  // Nur DLL's laden mit vorhandenen VIS_ davor
  if not (LeftStr(Filename, 4) = 'VIS_') then
    exit;

  dll := LoadLibrary(VisName);
  if (dll = 0) then
    exit;

  if GetProcAddress(Dll, 'winampVisGetHeader') = nil then
  begin
    FreeLibrary(dll);
    exit;
  end;

  FreeLibrary(dll);
  result := TRUE; }
end;

gruss

[venice2]

Diese Funktion geht ohne Probleme unter 32Bit warum nicht mit 64Bit?
NamesPointer oder Names ist nil.

Woran könnte es liegen?
Eventuell das ich eine 32Bit DLL versuche mit einer 64Bit Anwendung auszulesen?
Wenn ja dann ist es seltsam denn ich führe Sie ja gar nicht damit aus sondern will nur lesen ob der Einsprungs punkt vorhanden ist. (bsp. 'winampVisGetHeader')

[Sinspin]

Hallo, ich vermute dass der PE Header für 64Bit Programme eine andere Sturktur hat. Da wirst Du wohl mal MSDN befragen müssen.

€: Ich habe dich falsch verstanden :-|
Unter 64Bit wird die Word-Ausrichtung im Programm anders sein. Dein Record ist dann zu groß und ließt an der falschen Stelle.

[venice2]

Zitat:

Zitat von Sinspin (Beitrag 1492194)

Hallo, ich vermute dass der PE Header für 64Bit Programme eine andere Sturktur hat. Da wirst Du wohl mal MSDN befragen müssen.

Hmm.. Es ist kein 64Bit Programm sondern eine 32Bit.DLL die ich mit einem 64Bit Programm auslesen will.
Denke sollte egal sein welchen PE Header die 64Bit hat. Damit lese ich nur aus. Oder?

EDIT:
Hmm.. Welcher Record?
Kann mir nur vorstellen das einige Daten typen für 64Bit falsch sind.. aber welche :)
Kompilieren läßt es sich ja.

[himitsu]

Zitat:

Zitat von venice2 (Beitrag 1492195)

Hmm.. Es ist kein 64Bit Programm sondern eine 32Bit.DLL die ich mit einem 64Bit Programm auslesen will.
Denke sollte egal sein welchen PE Header die 64Bit hat. Damit lese ich nur aus. Oder?

Nein, natürlich nicht.

Der/die ersten PE-Header sind gleich.
Dort steht dann auch drin, was die Binary bzw. PortableExecute für ein Format hat. (DOS, Win32, Win64 usw.)
Und damit kannst du dann bestimmen welches DatenFormat die nachfolgenden Header/Strukturen haben.

[venice2]

Zitat:

Zitat von himitsu (Beitrag 1492200)

Zitat:

Zitat von venice2 (Beitrag 1492195)

Hmm.. Es ist kein 64Bit Programm sondern eine 32Bit.DLL die ich mit einem 64Bit Programm auslesen will.
Denke sollte egal sein welchen PE Header die 64Bit hat. Damit lese ich nur aus. Oder?

Nein, natürlich nicht.

Der/die ersten PE-Header sind gleich.
Dort steht dann auch drin, was die Binary bzw. PortableExecute für ein Format hat. (DOS, Win32, Win64 usw.)
Und damit kannst du dann bestimmen welches DatenFormat die nachfolgenden Header/Strukturen haben.

Hmm.. Schwierig.
Eins davon schlägt immer fehl.

Delphi-Quellcode:

        ExportTable := ImageRvaToVa(Header, ImagePointer, Header.OptionalHeader.DataDirectory[0].VirtualAddress, nil);
        if not Assigned(ExportTable) then
          exit;

        NamesPointer := ImageRvaToVa(Header, ImagePointer, Cardinal(ExportTable.AddressOfNames), nil);
        if not Assigned(NamesPointer) then
          exit;

        Names := ImageRvaToVa(Header, ImagePointer, Cardinal(NamesPointer^), nil);
        if not Assigned(Names) then
          exit;

[Sinspin]

Zitat:

Zitat von venice2 (Beitrag 1492195)

Hmm.. Welcher Record?
Kann mir nur vorstellen das einige Daten typen für 64Bit falsch sind.. aber welche :)
Kompilieren läßt es sich ja.

Delphi-Quellcode:

var
...
  Header: PIMAGE_NT_HEADERS;
  ExportTable: PIMAGE_EXPORT_DIRECTORY;

Da stecken ja zwei Records dahinter. Wurden die nicht via

Delphi-Quellcode:

packed record

deklariert werden die wohl unter 64Bit eine andere Datenausrichtung haben.
Du könntest auch recht damit haben, das es Felder in den Records sind.

PS: Ist immer wieder schön zu sehen das noch jemand mit den WinAmp Dlls rumspielt.

[venice2]

Danke. Werde mal schauen wie ich das geregelt bekomme irgendwann fällt mir schon was ein :)
Mit den Plugins ist halt das Problem das diese alle 32Bitig sind bekanntlich kann man da ja auf normalen Wege 64Bit Anw.-> 32Bit.dll nichts machen.
Aber wird schon.

[Sinspin]

Das gibt dann aber noch mehr Probleme. Du musst die Funktionen ja dann auch geladen bekommen und der CPU füttern.
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.
Wenn ich das richtig sehe geht es dir um Visualisierung. Da sollte genug Luft für ein paar Millisekunden sein.

[venice2]

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!

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.

[venice2]

Zitat:

Zitat von KodeZwerg (Beitrag 1492215)

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.

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;

[venice2]

Es ist so..

Delphi-Quellcode:

PIMAGE_NT_HEADERS = ^IMAGE_NT_HEADERS;

^IMAGE_NT_HEADERS verzweigt unter 64Bit auf

Delphi-Quellcode:

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.

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.

[venice2]

Zitat:

Zitat von KodeZwerg (Beitrag 1492221)

>> 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!

[venice2]

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

[venice2]

jep!

Zitat:

sonst schick ich dir mein komplettes projekt zur analyse.

Wäre nicht verkehrt denn es fehlen ja einige Definitionen.

Interessant da mal reinzuschauen.
Falls ich mal ein Plugin in 64Bit schreibe wäre es vorteilhaft wenn man die Bittigkeit vorher prüfen könnte.
Dann könnte man diese im gleichen Ordner mischen.