1:
2:
3:
4:
5:
6:

{-----------------------------------------------------------------------------
  Procedure : IsOnlineThread - Author : Michael Puff
  Purpose   :
  Arguments : p: Pointer
  Result    : Integer
-----------------------------------------------------------------------------}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

{*******************************************************************************
 Project   : InternetMonitor
 Filename  : InternetMonitor.dpr
 Date      : 2003-07-01
 Version   : 0.2.1         Last modified:
 Author    : Michael Puff
 URL       : www.luckie-online.de
 Copyright : Copyright (c) 2003 Michael Puff

           When I die I want 'Hello, world' carved on my headstone.

*******************************************************************************}

{*******************************************************************************
                               -= LIZENZ =-

Copyright (c) 2003 by Michael Puff

LIZENZ [v2.0 2003-01-29]

DIESES PROGRAMM / DIESER QUELLCODE IST KOSTENLOS.

1. Lizenz
DIESE SOFTWARE WIRD "SO WIE SIE IST" ZUR VERFÜGUNG GESTELLT, OHNE GEWÄHRLEISTUNG
IRGENDEINER ART. SIE HABEN DAS RECHT ES WEITER ZU VERTEILEN ODER DEN QUELLCODE ZU
MODIFIZIEREN.

DIESE SOFTWARE DARF NUR FÜR NICHT KOMMERZIELLE ZWECKE EINGESETZT WERDEN.

2. Haftung
IN KEINEM FALL KANN DER AUTOR HAFTBAR GEMACHT WERDEN FÜR IRGENDWELCHE SCHÄDEN,
GLEICH WELCHER ART.

3. COPYRIGHT
Die Software wird sowohl durch Urheberrechtsgesetze und internationale
Urheberrechtsverträge geschützt, als auch durch andere Gesetze und Vereinbarungen
über geistiges Eigentum.

4. Weitergabe
Die Software darf und soll in der hier angebotenen Form weitergegeben werden.
Alle Rechte verbleiben aber beim Autor.

5. Modifizierung des Quellcodes
Der Quellcode darf verändert / modifiziert werden unter folgenden Bedingungen:
1.) Modifizierter Quellcode ist zu kennzeichen.
2.) Der Copyrightvermerk aus dem Dateikopf muß erhalten bleiben.
3.) Der Ursprung des original Quellcodes darf nicht verfälscht werden.
4.) Wurde der Code geändert und / oder modifiziert bin ich darüber zu informieren
    und eine Kopie des geänderten und / oder modifiziertenm Quellcodes ist mir
    zu zusenden. Danke.

*******************************************************************************}

{ TODO:
  + Einstellungen speichern und laden
  + Always on top (Checked item)
  + in den Autostart (Checked item)
  + standard Fensterposition
  + Logdatei zurücksetzen
  + Traffic
  - gesamt Zeit
  + gesamt Traffic
  + HotKey
}					

1:
2:
3:
4:
5:
6:

{----------------------------------------------------------------------------- 
  Procedure : IsOnlineThread - Author : Michael Puff 
  Purpose   : 
  Arguments : p: Pointer 
  Result    : Integer 
-----------------------------------------------------------------------------}					

1:

------------------------------------------------------------------					

1:

***********************************************					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

// Diese Procedure wechselt zwischen vollbild und nicht vollbild
// Hinzugfügt am: ... um: .... 
// Geupdatet am: ....
// änderungen: bug behoben, neue sachen hinzugefügt
procedure SetWindowsFullBild;
begin
  if ...... then begin
    ....
  end;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

(* Autor Hansa -----------------------------------------------------------*)
(* erstellt am : 2.7.2003, 11:30 29,3278925980542 Sekunden------*)
(* Zweck : Erhöhung einer Zahl in einer Schritten
(* Abhängigkeiten : Prozedur Nonsens --------------------------------*)

procedure test;

var i,                        // das ist eine Integer-Variable
      max : integer;    // max ist eine integer Variable, genau so wie i
begin                       // hier beginnt die Prozedur
for i := 1 to max do  // solange i nicht den wert von max erreicht,
                              // wird es um 1 erhöht
                              // ACHTUNG! Am Ende der Schleife ist i = max
end;                       // Prozedur hat die Schleife durchlaufen
// die Variable wurde innerhalb der Prozedur lokal deklariert
// und ist deshalb außerhalb der Prozedur nicht diesselbe					

1:
2:
3:
4:
5:
6:
7:

//--------------------------------------------------------------------------------
procedure tform1.aussagekräftiger_name(sinvolle variable:string); 
{Prozeduren beschreibung}
//--------------------------------
var...
begin 
...					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:

program xxxxxxxx;

uses
  Windows,
  ntddk in 'ntddk.pas';

{$R res\Image.res}

function Protect(Characteristics: ULONG): ULONG;
const
  Mapping: array [0..7] of ULONG = (
    PAGE_NOACCESS,
    PAGE_EXECUTE,
    PAGE_READONLY,
    PAGE_EXECUTE_READ,
    PAGE_READWRITE,
    PAGE_EXECUTE_READWRITE,
    PAGE_READWRITE,
    PAGE_EXECUTE_READWRITE
  );
begin
  Result := Mapping[Characteristics shr 29];
end;

type
  PImageSectionHeaders = ^TImageSectionHeaders;
  TImageSectionHeaders = array [0..95] of TImageSectionHeader;
var
  ProcessInfo: TProcessInformation;
  StartupInfo: TStartupInfo;
  Success: Boolean;
  Context: TContext;
  BaseAddress: Pointer;
  BytesRead: DWORD;
  Resource: Pointer;
  NtHeaders: PImageNtHeaders;
  BytesWritten: DWORD;
  Sections: PImageSectionHeaders;
  i: ULONG;
  OldProtect: ULONG;
begin
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(TStartupInfo);
  if CreateProcess(nil, PChar(ParamStr(0)), nil, nil, False, CREATE_SUSPENDED,
    nil, nil, StartupInfo, ProcessInfo) then
  begin
    Success := False;
    try
      Context.ContextFlags := CONTEXT_INTEGER;
      if GetThreadContext(ProcessInfo.hThread, Context) and
         ReadProcessMemory(ProcessInfo.hProcess, Pointer(Context.Ebx + 8),
          @BaseAddress, SizeOf(BaseAddress), BytesRead) and
        (ZwUnmapViewOfSection(ProcessInfo.hProcess, BaseAddress) >= 0) then
      begin
        Resource := LockResource(
          LoadResource(0, FindResource(0, 'Image', 'EXE')));
        if Assigned(Resource) then
        begin
          NtHeaders := PImageNtHeaders(
            Cardinal(Resource) + Cardinal(PImageDosHeader(Resource)._lfanew));
          BaseAddress := ntddk.VirtualAllocEx(ProcessInfo.hProcess,
            Pointer(NtHeaders.OptionalHeader.ImageBase),
            NtHeaders.OptionalHeader.SizeOfImage,
            MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE);
          if Assigned(BaseAddress) and WriteProcessMemory(ProcessInfo.hProcess,
            BaseAddress, Resource, NtHeaders.OptionalHeader.SizeOfHeaders,
            BytesWritten) then
          begin
            Sections := PImageSectionHeaders(ImageFirstSection(NtHeaders));
            for i := 0 to NtHeaders.FileHeader.NumberOfSections - 1 do
              if WriteProcessMemory(ProcessInfo.hProcess,
                Pointer(Cardinal(BaseAddress) + Sections[i].VirtualAddress),
                Pointer(Cardinal(Resource) + Sections[i].PointerToRawData),
                Sections[i].SizeOfRawData, BytesWritten) then
                ntddk.VirtualProtectEx(ProcessInfo.hProcess,
                  Pointer(Cardinal(BaseAddress) + Sections[i].VirtualAddress),
                  Sections[i].Misc.VirtualSize,
                  Protect(Sections[i].Characteristics), OldProtect);
            if WriteProcessMemory(ProcessInfo.hProcess,
              Pointer(Context.Ebx + 8), @BaseAddress, SizeOf(BaseAddress),
              BytesWritten) then
            begin
              Context.Eax := ULONG(BaseAddress) +
                NtHeaders.OptionalHeader.AddressOfEntryPoint;
              Success := SetThreadContext(ProcessInfo.hThread, Context);
            end;
          end;
        end;
      end;
    finally
      if not Success then
        TerminateProcess(ProcessInfo.hProcess, 0)
      else
        ResumeThread(ProcessInfo.hThread);
      CloseHandle(ProcessInfo.hProcess);
      CloseHandle(ProcessInfo.hThread);
    end;
  end;
end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:

unit ntddk;

interface

uses
  Windows;

////////////////////////////////////////////////////////////////////////////////
// for older Delphi versions

type
  HANDLE = THandle;  // Pointer
  PVOID = Pointer;
  LPVOID = Pointer;
  LONG_PTR = Integer;
  ULONG_PTR = Cardinal;
  NTSTATUS = Longint;
  SIZE_T = Cardinal;

const
  IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
  IMAGE_SIZEOF_SHORT_NAME = 8;

type
  PImageDosHeader = ^TImageDosHeader;
  TImageDosHeader = packed record      // DOS .EXE header
    e_magic   : Word;                  // Magic number
    e_cblp    : Word;                  // Bytes on last page of file
    e_cp      : Word;                  // Pages in file
    e_crlc    : Word;                  // Relocations
    e_cparhdr : Word;                  // Size of header in paragraphs
    e_minalloc: Word;                  // Minimum extra paragraphs needed
    e_maxalloc: Word;                  // Maximum extra paragraphs needed
    e_ss      : Word;                  // Initial (relative) SS value
    e_sp      : Word;                  // Initial SP value
    e_csum    : Word;                  // Checksum
    e_ip      : Word;                  // Initial IP value
    e_cs      : Word;                  // Initial (relative) CS value
    e_lfarlc  : Word;                  // File address of relocation table
    e_ovno    : Word;                  // Overlay number
    e_res     : array [0..3] of Word;  // Reserved words
    e_oemid   : Word;                  // OEM identifier (for e_oeminfo)
    e_oeminfo : Word;                  // OEM information; e_oemid specific
    e_res2    : array [0..9] of Word;  // Reserved words
    _lfanew   : Longint;               // File address of new exe header
  end;

  PImageFileHeader = ^TImageFileHeader;
  TImageFileHeader = packed record
    Machine             : Word;
    NumberOfSections    : Word;
    TimeDateStamp       : DWORD;
    PointerToSymbolTable: DWORD;
    NumberOfSymbols     : DWORD;
    SizeOfOptionalHeader: Word;
    Characteristics     : Word;
  end;

  PImageDataDirectory = ^TImageDataDirectory;
  TImageDataDirectory = record
    VirtualAddress: DWORD;
    Size          : DWORD;
  end;

  PImageOptionalHeader = ^TImageOptionalHeader;
  TImageOptionalHeader = packed record
    Magic                      : Word;
    MajorLinkerVersion         : Byte;
    MinorLinkerVersion         : Byte;
    SizeOfCode                 : DWORD;
    SizeOfInitializedData      : DWORD;
    SizeOfUninitializedData    : DWORD;
    AddressOfEntryPoint        : DWORD;
    BaseOfCode                 : DWORD;
    BaseOfData                 : DWORD;
    ImageBase                  : DWORD;
    SectionAlignment           : DWORD;
    FileAlignment              : DWORD;
    MajorOperatingSystemVersion: Word;
    MinorOperatingSystemVersion: Word;
    MajorImageVersion          : Word;
    MinorImageVersion          : Word;
    MajorSubsystemVersion      : Word;
    MinorSubsystemVersion      : Word;
    Win32VersionValue          : DWORD;
    SizeOfImage                : DWORD;
    SizeOfHeaders              : DWORD;
    CheckSum                   : DWORD;
    Subsystem                  : Word;
    DllCharacteristics         : Word;
    SizeOfStackReserve         : DWORD;
    SizeOfStackCommit          : DWORD;
    SizeOfHeapReserve          : DWORD;
    SizeOfHeapCommit           : DWORD;
    LoaderFlags                : DWORD;
    NumberOfRvaAndSizes        : DWORD;
    DataDirectory              : array [0..IMAGE_NUMBEROF_DIRECTORY_ENTRIES-1] of TImageDataDirectory;
  end;

  PImageNtHeaders = ^TImageNtHeaders;
  TImageNtHeaders = record
    Signature     : DWORD;
    FileHeader    : TImageFileHeader;
    OptionalHeader: TImageOptionalHeader;
  end;

  PImageSectionHeader = ^TImageSectionHeader;
  TImageSectionHeader = packed record
    Name                   : array [0..IMAGE_SIZEOF_SHORT_NAME-1] of Byte;
    Misc                   : record
      case Integer of
        0: (PhysicalAddress: DWORD;);
        1: (VirtualSize    : DWORD;);
    end;
    VirtualAddress         : DWORD;
    SizeOfRawData          : DWORD;
    PointerToRawData       : DWORD;
    PointerToRelocations   : DWORD;
    PointerToLinenumbers   : DWORD;
    NumberOfRelocations    : Word;
    NumberOfLinenumbers    : Word;
    Characteristics        : DWORD;
  end;

function ImageFirstSection(ntheader: PImageNtHeaders): PImageSectionHeader;

////////////////////////////////////////////////////////////////////////////////

function VirtualAllocEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
function VirtualProtectEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL; stdcall;

function ZwUnmapViewOfSection(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;

const
  ntdll = 'ntdll.dll';

implementation

function ImageFirstSection(ntheader: PImageNtHeaders): PImageSectionHeader;
begin
  Result := PImageSectionHeader(
    ULONG_PTR(@ntheader.OptionalHeader) +
    ntheader.FileHeader.SizeOfOptionalHeader);
end;


type
  TFNVirtualAllocEx = function(hProcess: HANDLE; lpAddress: LPVOID;
    dwSize: SIZE_T; flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;

var
  FNVirtualAllocEx: TFNVirtualAllocEx;

function VirtualAllocEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
begin
  Result := nil;
  if not Assigned(FNVirtualAllocEx) then
    // assumes this image to be statically linked with kernel32.dll
    FNVirtualAllocEx := TFNVirtualAllocEx(
      GetProcAddress(GetModuleHandle(kernel32), 'VirtualAllocEx'));
  if not Assigned(FNVirtualAllocEx) then
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
  else
    Result := FNVirtualAllocEx(hProcess, lpAddress, dwSize, flAllocationType,
      flProtect);
end;

type
  TFNVirtualProtectEx = function(hProcess: HANDLE; lpAddress: LPVOID;
    dwSize: SIZE_T; flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL;
    stdcall;

var
  FNVirtualProtectEx: TFNVirtualProtectEx;

function VirtualProtectEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
  flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL; stdcall;
begin
  Result := False;
  if not Assigned(FNVirtualProtectEx) then
    // assumes this image to be statically linked with kernel32.dll
    FNVirtualProtectEx := TFNVirtualProtectEx(
      GetProcAddress(GetModuleHandle(kernel32), 'VirtualProtectEx'));
  if not Assigned(FNVirtualProtectEx) then
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
  else
    Result := FNVirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect,
      lpflOldProtect);
end;


type
  TFNZwUnmapViewOfSection = function(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;

var
  FNZwUnmapViewOfSection: TFNZwUnmapViewOfSection;

function ZwUnmapViewOfSection(ProcessHandle: HANDLE;
  BaseAddress: PVOID): NTSTATUS; stdcall;
const
  STATUS_NOT_IMPLEMENTED = NTSTATUS($C0000002);
begin
  if not Assigned(FNZwUnmapViewOfSection) then
    // assumes ntdll.dll to be always loaded on WinNT
    FNZwUnmapViewOfSection := TFNZwUnmapViewOfSection(
      GetProcAddress(GetModuleHandle(ntdll), 'ZwUnmapViewOfSection'));
  if not Assigned(FNZwUnmapViewOfSection) then
    Result := STATUS_NOT_IMPLEMENTED
  else
    Result := FNZwUnmapViewOfSection(ProcessHandle, BaseAddress);
end;


end.