⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 morph.dpr

📁 The final version of UPX scrambler and PE sources in Delphi and flat assembler.
💻 DPR
📖 第 1 页 / 共 3 页
字号:
🔍
123 
  Inc(AMem);
end;

procedure AndReg8Rand(var AMem: PByte);
var
  LReg8: Byte;
begin
  LReg8 := RandomReg8ABCD;
  AMem^ := $22;
  Inc(AMem);
  AMem^ := $C0 + LReg8 * 9;                 
  Inc(AMem);
end;

procedure CmpRegRegNum8Rand(var AMem: PByte);
var
  LRnd: Byte;
begin
  LRnd := Random(3);
  AMem^ := $3A + LRnd;
  Inc(AMem);
  if LRnd < 2 then
    LRnd := Random($40) + $C0
  else
    LRnd := Random($100);
  AMem^ := LRnd;
  Inc(AMem);
end;

function CmpReg32Reg32(var AMem: PByte; AReg1, AReg2: Byte): Byte;
begin
  Result := 2;
  AMem^ := $39;
  Inc(AMem);
  AMem^ := $C0 + AReg1 + AReg2 * 8;
  Inc(AMem);
end;

procedure CmpReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $F8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure CmpReg32RandNum8(var AMem: PByte; AReg: Byte);
begin
  CmpReg32Num8(AMem, AReg, Random($100));
end;

procedure CmpRandReg32RandNum8(var AMem: PByte);
begin
  CmpReg32RandNum8(AMem, RandomReg32All);
end;

procedure JmpNum8(var AMem: PByte; ANum: Byte);
var
  LRnd: Byte;
begin
  LRnd := Random(16);
  if LRnd = 16 then
    AMem^ := $EB
  else
    AMem^ := $70 + LRnd;
  Inc(AMem);
  AMem^ := ANum;                       
  Inc(AMem);
end;

procedure SubReg32Reg32(var AMem: PByte; AReg1, AReg2: Byte);
begin
  AMem^ := $29;
  Inc(AMem);
  AMem^ := AReg2 * 8 + AReg1 + $C0;            
  Inc(AMem);
end;

procedure SubReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $E8 + AReg;
  Inc(AMem);
  AMem^ := ANum;                         
  Inc(AMem);
end;

function SubReg32Num8Rand(var AMem: PByte; ANum: Byte): Byte;
begin
  Result := RandomReg32All;
  SubReg32Num8(AMem, Result, ANum);
end;

function AddReg32Num8Rand(var AMem: PByte; ANum: Byte): Byte;
begin
  Result := RandomReg32All;
  AddReg32Num8(AMem, Result, ANum);
end;

procedure SubAlNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $2C;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure TestAlNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $A8;
  Inc(AMem);
  AMem^ := ANum;                        
  Inc(AMem);
end;

procedure TestAlNum8Rand(var AMem: PByte);
begin
  TestAlNum8(AMem, Random($100));
end;

procedure SubReg8Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $80;
  Inc(AMem);
  AMem^ := $E8 + AReg;
  Inc(AMem);
  AMem^ :=ANum;
  Inc(AMem);
end;

procedure SubReg8Num8Rand(var AMem: PByte; ANum: Byte);
var
  LReg8: Byte;
begin
  LReg8 := RandomReg8ABCD;
  SubReg8Num8(AMem, LReg8, ANum);
end;

procedure TestReg8Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $F6;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure TestReg8Num8Rand(var AMem: PByte);
begin
  TestReg8Num8(AMem, RandomReg8ABCD, Random($100));
end;

procedure AddReg8Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $80;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure AddReg8Num8Rand(var AMem: PByte; ANum: Byte);
var
  LReg8: Byte;
begin
  LReg8 := RandomReg8ABCD;
  AddReg8Num8(AMem, LReg8, ANum);
end;

procedure AddAlNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $04;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure FNop(var AMem: PByte);
begin
  AMem^ := $D9;
  Inc(AMem);
  AMem^ := $D0;
  Inc(AMem);
end;

procedure OrReg16Rand(var AMem:PByte);
var
  LReg16: Byte;
begin
  LReg16 := RandomReg16All;
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $0B;
  Inc(AMem);
  AMem^ := $C0 + LReg16 * 9;
  Inc(AMem);
end;

procedure TestReg16Rand(var AMem: PByte);
var
  LReg16: Byte;
begin
  LReg16 := RandomReg16All;
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $85;
  Inc(AMem);
  AMem^ := $C0 + LReg16 * 9;                 
  Inc(AMem);
end;

procedure AndReg16Rand(var AMem: PByte);
var
  LReg16: Byte;
begin
  LReg16 := RandomReg16All;
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $23;
  Inc(AMem);
  AMem^ := $C0 + LReg16 * 9;
  Inc(AMem);
end;

procedure Cdq(var AMem:PByte);
begin
  AMem^ := $99;
  Inc(AMem);
end;

procedure ShlReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $E0 + AReg;
  Inc(AMem);
  AMem^ := ANum;                       
  Inc(AMem);
end;

procedure ShlReg32RandNum8FullRand(var AMem: PByte);
begin
  ShlReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure ShrReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $E8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure ShrReg32RandNum8FullRand(var AMem: PByte);
begin
  ShrReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure SalReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $F0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure SalReg32RandNum8FullRand(var AMem: PByte);
begin
  SalReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure SarReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $F8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure SarReg32RandNum8FullRand(var AMem: PByte);
begin
  SarReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure RolReg8Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C0;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure RolReg8RandNum8FullRand(var AMem: PByte);
begin
  RolReg8Num8(AMem, RandomReg8ABCD, Random($20) * 8);
end;

procedure RorReg8Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C0;
  Inc(AMem);
  AMem^ := $C8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure RorReg8RandNum8FullRand(var AMem: PByte);
begin
  RorReg8Num8(AMem, RandomReg8ABCD, Random($20) * 8);
end;

procedure RolReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure RolReg32RandNum8FullRand(var AMem: PByte);
begin
  RolReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure RorReg32Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $C8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure RorReg32RandNum8FullRand(var AMem: PByte);
begin
  RorReg32Num8(AMem, RandomReg32All, Random(8) * $20);
end;

procedure TestAxNum16(var AMem: PByte; ANum: Word);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $A9;
  Inc(AMem);
  PWord(AMem)^ := ANum;                   
  Inc(AMem,2);
end;

procedure TestAxNum16Rand(var AMem: PByte);
begin
  TestAxNum16(AMem, Random($10000));
end;

procedure CmpAxNum16(var AMem: PByte; ANum: Word);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $3D;
  Inc(AMem);
  PWord(AMem)^ := ANum;                  
  Inc(AMem,2);
end;

procedure CmpAxNum16Rand(var AMem: PByte);
begin
  TestAxNum16(AMem, Random($10000));
end;

procedure PushNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $6A;
  Inc(AMem);
  AMem^ := ANum;                         
  Inc(AMem);
end;

procedure PushNum8Rand(var AMem: PByte);
begin
  PushNum8(AMem, Random($100));
end;

function XorRand(var AMem: PByte): Word;
var
  LRnd: Byte;
  LRes: PWord;
begin
  LRes := Pointer(AMem);
  LRnd := Random(5);
  AMem^ := $30 + LRnd;
  Inc(AMem);
  if LRnd = 4 then
    AMem^ := Random($100)
  else
    AMem^ := Random(7) * 9 + Random(8) + 1 + $C0; 
  Inc(AMem);
  Result := LRes^;
end;

procedure InvertXor(var AMem: PByte; AXor: Word);
begin
  PWord(AMem)^ := AXor;
  Inc(AMem,2);
end;

procedure DoubleXorRand(var AMem: PByte);
begin
  InvertXor(AMem, XorRand(AMem));
end;

function NotReg32(var AMem: PByte; AReg: Byte): Byte;
begin
  Result := 2;
  AMem^ := $F7;
  Inc(AMem);
  AMem^ := $D0 + AReg;
  Inc(AMem);
end;

function NegReg32(var AMem: PByte; AReg: Byte): Byte;
begin
  Result := 2;
  AMem^ := $F7;
  Inc(AMem);
  AMem^ := $D8 + AReg;                     
  Inc(AMem);
end;

function NotRand(var AMem: PByte): Word;
var
  LRes: PWord;
begin
  LRes := Pointer(AMem);
  AMem^ := $F6 + Random(1);
  Inc(AMem);
  AMem^ := $D0 + Random(8);
  Inc(AMem);
  Result := LRes^;
end;

procedure InvertNot(var AMem: PByte; ANot: Word);
begin
  PWord(AMem)^ := ANot;
  Inc(AMem,2);
end;

procedure DoubleNotRand(var AMem: PByte);
begin
  InvertNot(AMem, NotRand(AMem));
end;

function NegRand(var AMem: PByte): Word;
var
  LRes: PWord;
begin
  LRes := Pointer(AMem);
  AMem^ := $F6 + Random(1);
  Inc(AMem);
  AMem^ := $D8 + Random(8);                 
  Inc(AMem);
  Result := LRes^;
end;

procedure InvertNeg(var AMem: PByte; ANeg: Word);
begin
  PWord(AMem)^ := ANeg;
  Inc(AMem,2);
end;

procedure DoubleNegRand(var AMem: PByte);
begin
  InvertNeg(AMem, NegRand(AMem));
end;

procedure AddReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;                           
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure AddReg16Num8Rand(var AMem: PByte; ANum: Byte);
begin
  AddReg16Num8(AMem, RandomReg16All, ANum);
end;

procedure OrReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $C8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure OrReg16Num8Rand(var AMem: PByte; ANum: Byte);
begin
  OrReg16Num8(AMem, RandomReg16All, ANum);
end;

procedure AndReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $E0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure AndReg16Num8Rand(var AMem: PByte; ANum: Byte);
begin
  AndReg16Num8(AMem, RandomReg16All, ANum);
end;

procedure SubReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $E8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure SubReg16Num8Rand(var AMem: PByte; ANum: Byte);
begin
  SubReg16Num8(AMem, RandomReg16All, ANum);
end;

procedure XorReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $F0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure XorReg16Num8Rand(var AMem: PByte; ANum: Byte);
begin
  XorReg16Num8(AMem, RandomReg16All, ANum);
end;

procedure CmpReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $83;
  Inc(AMem);
  AMem^ := $F8 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure CmpReg16Num8RandRand(var AMem: PByte);
begin
  CmpReg16Num8(AMem, RandomReg16All, Random($100));
end;

procedure RolReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $C0 + AReg;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure RolReg16RandNum8FullRand(var AMem: PByte);
begin
  RolReg16Num8(AMem, RandomReg16All, Random($10)*$10);
end;

procedure RorReg16Num8(var AMem: PByte; AReg, ANum: Byte);
begin
  AMem^ := $66;
  Inc(AMem);
  AMem^ := $C1;
  Inc(AMem);
  AMem^ := $C1 + AReg;
  Inc(AMem);
  AMem^ := ANum;                          
  Inc(AMem);
end;

procedure RorReg16RandNum8FullRand(var AMem: PByte);
begin
  RorReg16Num8(AMem, RandomReg16All, Random($10)*$10);
end;

function XchgRand(var AMem: PByte): Word;
var
  LRes: PWord;
  LRnd: Byte;
begin
  LRes := Pointer(AMem);
  LRnd := Random(4);
  case LRnd of
    0, 1: AMem^ := $66 + LRnd;
    2, 3: AMem^ := $86 + LRnd - 2;
  end;
  Inc(AMem);
  case LRnd of
    0, 1: AMem^ := $90 + Random(8);
    2, 3: AMem^ := $C0 + Random($10);
  end;
  Inc(AMem);
  Result := LRes^;
end;

procedure InvertXchg(var AMem: PByte; AXchg: Word);
begin
  PWord(AMem)^ := AXchg;
  Inc(AMem,2);
end;

procedure DoubleXchgRand(var AMem: PByte);
begin
  InvertXchg(AMem, XchgRand(AMem));
end;

procedure LoopNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $E2;
  Inc(AMem);
  AMem^ := ANum;
  Inc(AMem);
end;

procedure JecxzNum8(var AMem: PByte; ANum: Byte);
begin
  AMem^ := $E3;
  Inc(AMem);
  AMem^ := ANum;                         
  Inc(AMem);
end;

procedure MovzxEcxCl(var AMem: PByte);
begin
  AMem^ := $0F;
  Inc(AMem);
  AMem^ := $B6;
  Inc(AMem);
  AMem^ := $C9;
123

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -