Wie TLS Callback in Delphi

[omata]

Sorry, das ich was gesagt habe. Viel Glück bei der Umsetzung.

[itsme]

@omata

Nein, kein Grund sich zu entschuldigen, ich bin schließlich mit meinem offensichtlich obskuren Problem an die Community herangetreten...

Wenn man meine Zugehörigkeit und die Anzahl der posts in Relation setzt, wird man feststellen, dass ich so wenig wie möglich stören wollte, versucht hatte meine Probs möglichst selbst zu lösen, trotzdem kommt man irgendwann an den Punkt, wo es selbst einfach nicht weiter geht.

So what? vlt. kann man ja für 29.99$ irgendwo components erwerben, welche alle meine persönlichen Mühen nicht nur ersetzen, sondern durch ihre Einfachheit, auch ad adsurdum führen!

Jedenfalls möchte ich mich hier nochmals ausdrücklich für jede gutgemeinte Antwort bedanken und hoffe in Zukunft auch mal mit meinen bescheidenen Kenntnissen irgendwo ein kleines Lichtlein zünden zu können...

[nachti1505]

Zitat von itsme:

Ich bin mir derzeit echt nicht im Klaren darüber, ob ich die bass.pas mit den Deklarationen benutzen darf (muss), oder ob ich bei LoadLibrary und GetProcAddress, diese besser weglasse...

Ich weiß nicht sooooo genau, was die Bass.pas macht, aber wenn es eine normale Header-Übersetzung ist, kann es durchaus sein dass diese die DLL statisch einbindet... von daher würde ich sie nicht einbinden, wenn du eh LoadLibrary etc. nutzt.

[DeddyH]

Letzten Endes ist genau das des Pudels Kern, behaupte ich einfach mal rotzfrech

[omata]

Ich habe es ja schon geschrieben und auch einen Link auf das gegeben, was ich hier nochmal zusammengestellt habe. Das ist aber bestimmt sowieso genau das falsche. Also sorry für diesen sinnlosen Beitrag.

[itsme]

Zunächst vielen Dank für alle guten Ratschläge, welche mir die richtige Richtung gezeigt haben.
Und nein, es gab hier weder falsche, noch sinnlose posts.
Der Miniplayer von omata war schon in etwa, was ich gesucht hatte, allerdings habe ich ihn leider zu spät gelesen, aber fürs Feintuning war er noch allemal nützlich.
Nachfolgend der Code, den ich nun nach meinen Vorstellungen entwickelt hatte, wobei ich auf jegliches Error-Handling verzichtet habe, um ihn für mein post möglichst kurz zu halten...
Ich denke die Profis hier werden den Code in der Luft zerreißen, aber damit muss ein Hobby-Täter wie ich, wohl oder übel leben.

Code:

begin
  Application.Initialize;

  GetTempPath(Length(aTempPath), aTempPath);
  fName := aTempPath;
  StrCat(fName, 'Bass.dll');

  if not FileExists(fName) then
  begin
    nHandle := FindResource(hInstance, 'Bass', RT_RCDATA);
    nPointer := LockResource(LoadResource(hInstance, nHandle));
    nSize := SizeOfResource(hInstance, nHandle);

    hFile := CreateFile(fName, GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ or FILE_SHARE_WRITE, nil,
             CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, FILE_FLAG_DELETE_ON_CLOSE);
    WriteFile(hFile, nPointer^, nSize, nCount, nil);
    CloseHandle(hFile);
  end;

type
  QWORD = Int64;
  HSAMPLE = DWORD;
  HCHANNEL = DWORD;
  myFree = function(): bool; stdcall;
  myGetChannel = function(handle: HSAMPLE; onlynew: BOOL): HCHANNEL; stdcall;
  myChannelPlay = function(handle: DWORD; restart: BOOL): BOOL; stdcall;
  myInit = function(dev: LongInt; freq, flags: DWORD; win: HWND; clsid: PGUID): BOOL; stdcall;
  mySampleLoad = function(mem: BOOL; f: Pointer; offset: QWORD; length, max, flags: DWORD): HSAMPLE; stdcall;

var
  Form1: TForm1;
  aTempPath: array[0..255] of char;
  BASS_Free: myFree;
  BASS_Init: myInit;
  BASS_SampleLoad: mySampleLoad;
  BASS_SampleGetChannel: myGetChannel;
  BASS_ChannelPlay: myChannelPlay;
  hLib: THandle;
  hFile: THandle;
  hChan: HCHANNEL;
  hSamp: HSAMPLE;
  fName: PChar;
  nHandle: cardinal;
  nPointer: Pointer;
  nSize: cardinal;
  nCount: cardinal;
  const BASS_UNICODE = $80000000;
  const BASS_SAMPLE_LOOP = 4;

procedure TForm1.OnActivate(Sender: TObject);
begin
  GetTempPath(Length(aTempPath), aTempPath);
  fName := aTempPath;
  StrCat(fName, 'Bass.dll');
  nHandle := FindResource(hInstance, 'Intro', RT_RCDATA);
  nPointer := LockResource(LoadResource(hInstance, nHandle));
  nSize := SizeOfResource(hInstance, nHandle);
  hLib := LoadLibrary(aTempPath);
  @BASS_Free := GetProcAddress(hLib, 'BASS_Free');
  @BASS_Init := GetProcAddress(hLib, 'BASS_Init');
  @BASS_SampleLoad := GetProcAddress(hLib, 'BASS_SampleLoad');
  @BASS_SampleGetChannel := GetProcAddress(hLib, 'BASS_SampleGetChannel');
  @BASS_ChannelPlay := GetProcAddress(hLib, 'BASS_ChannelPlay');
  BASS_Init(-1, 44100, 0, Handle, nil);
  hSamp := BASS_SampleLoad(True, nPointer, 0, nSize, 10,
           BASS_SAMPLE_LOOP {$IFDEF UNICODE} or BASS_UNICODE {$ENDIF});
  hChan := BASS_SampleGetChannel(hSamp, True);
  BASS_ChannelPlay(hChan, True);
end;

procedure TForm1.OnClose(Sender: TObject; var Action: TCloseAction);
begin
  BASS_Free();
  FreeLibrary(hLib);
  if FileExists(fName) then
    DeleteFile(fName);
  Application.Terminate;
end;

LG itsme

[Assarbad]

Zitat von itsme:

Längere Suche im Netz hat lediglich Lösungen in ASM und C++ ans Licht gebracht, wobei in C++ die Funktion offensichtlich programmiertechnisch, vor die Main() Funktion gepackt wird.

TLS-Callbacks sind Teil der PE-Datei. Sie werden in der Tat vom Loader (aber nicht wirklich "vor dem Laden des Programms") vor dem Einsprungspunkt in den Code aufgerufen. Das wird und wurde von Malware verwendet um diverse Analysemöglichkeiten zu umgehen ...

Da man das in MSVC über den Linker machen muß, nähme ich mal an, daß es in Delphi ebenfalls über eine Linkeroption oder eine Präprozessordirektive funktioniert.