Deixa kl Indetect pela source

[qolyx]

O unico jeito mais facil é crypter FUD (Full Undetected)
bom tem varios crypter publicos por ai , mas todos estao sendo detectaveis
eu faço crypts 100% FUD e compativeis com todos windows, eu vendo cada Stub por 30 reais
dura cerca de 2 meses...............

Olá brunow*bcr* !

Até que não tá kro pelo trabalho que dá , mas o cesargbi16 tá querendo mesmo é fazer ele masmo no fonte. Eu já passei por isso e vi que o problema estava na estrutura de montagem do código que o compilador do Delphi construia (constroi sempre do mesmo mesmo jeito mesmo que eu mudasse a ordem das funções e encriptasse as strings, a estrutura do código permanecia) a solução que achei foi mudar de linguagem, então o reescrevi em C e tudo ficou resolvido.

A eurística dos AVs pega a maioria dos malware escritos em Delphi, principalmente o AVIRA, por isso, hoje este tipo de código escrevo sempre em Masm, porque em asm tenho controle total sobre a estrutura final do código.

Mas como cesargbi16 quer encriptar as strings, vou deixar uma função encriptadora RC4 em Delphi aqui

{ RC4 Encryption

  Ported by: Qolyx
}

unit uRC4;

interface

uses Windows;
function RC4(Expression, Password:string):string;

type
  TByteArray = array of Byte;

implementation

procedure Move(Destination, Source: Pointer; dLength:Cardinal);
begin
  CopyMemory(Destination, Source, dLength);
end;

function RC4(Expression, Password:string):string;
var
  RB:         array[0..255] of integer;
  X, Y, Z:    LongInt;
  Key:        TByteArray;
  ByteArray:  TByteArray;
  Temp:       Byte;
begin
  if Length(Password) = 0 then
    Exit;
  if Length(Expression) = 0 then
    Exit;
  if Length(Password) > 256 then
  begin
    SetLength(Key, 256);
    Move(@Key[0], @Password[1], 256)
  end
  else
  begin
    SetLength(Key, Length(Password));
    Move(@Key[0], @Password[1], Length(Password));
  end;
  for X := 0 to 255 do
    RB[X] := X;

  Y := 0;

  for X := 0 to 255 do
  begin
    Y := (Y + RB[X] + Key[X mod Length(Password)]) mod 256;
    Temp := RB[X];
    RB[X] := RB[Y];
    RB[Y] := Temp;
  end;

  Y := 0;
  Z := 0;
  SetLength(ByteArray, Length(Expression));
  Move(@ByteArray[0], @Expression[1], Length(Expression));
  for X := 0 to Length(Expression) - 1 do
  begin
    Y := (Y + 1) mod 256;
    Z := (Z + RB[Y]) mod 256;
    Temp := RB[Y];
    RB[Y] := RB[Z];
    RB[Z] := Temp;
    ByteArray[X] := ByteArray[X] xor (RB[(RB[Y] + RB[Z]) mod 256]);
  end;
  SetLength(Result, Length(Expression));
  Move(@Result[1], @ByteArray[0], Length(Expression));
end;

end.

Lembre-se que o problema é a estrutura do código montado pelo Delphi que sempre segue o mesmo roteiro!

[]'s Qolyx.