常见加密算法全面总结与分类详解

通用字符串与十六进制互转

function myStrtoHex(s: string): string;       //原字符串转16进制字符串
var tmpstr:string;
    i:integer;
begin
    tmpstr := '';
    for i:=1 to length(s) do
    begin
        tmpstr := tmpstr + inttoHex(ord(s[i]),2);
    end;
    result := tmpstr;
end;

function myHextoStr(S: string): string;           //16进制字符串转原字符串
var hexS,tmpstr:string;
    i:integer;
    a:byte;
begin
    hexS :=s;
    if length(hexS) mod 2=1 then
    begin
        hexS:=hexS+'0';
    end;
    tmpstr:='';
    for i:=1 to (length(hexS) div 2) do
    begin
        a:=strtoint('$' + hexS[2*i-1] + hexS[2*i]);
        tmpstr := tmpstr + chr(a);
    end;
    result :=tmpstr;
end;

多轮异或加密/解密（encryptstr / decryptstr）

该加密过程先将密钥转为十六进制，再对原文进行多轮逐位XOR，每轮使用密钥的一位。解密时反向操作即可。

function encryptstr(const s:string; skey:string):string;       //异或运算加密
var
    i,j: integer;
    hexS,hexskey,midS,tmpstr:string;
    a,b,c:byte;
begin
    hexS   :=myStrtoHex(s);
    hexskey:=myStrtoHex(skey);
    midS   :=hexS;
    for i:=1 to (length(hexskey) div 2)   do
    begin
        if i<>1 then midS:= tmpstr;
        tmpstr:='';
        for j:=1 to (length(midS) div 2) do
        begin
            a:=strtoint('$' + midS[2*j-1] + midS[2*j]);
            b:=strtoint('$' + hexskey[2*i-1] + hexskey[2*i]);
            c:=a xor b;
            tmpstr := tmpstr + myStrtoHex(chr(c));
        end;
    end;
    result := tmpstr;
end;

function decryptstr(const s:string; skey:string):string;    //异或运算解密
var
    i,j: integer;
    hexS,hexskey,midS,tmpstr:string;
    a,b,c:byte;
begin
    hexS :=s;
    if length(hexS) mod 2=1 then
    begin
        showmessage('密文错误！');
        exit;
    end;
    hexskey:=myStrtoHex(skey);
    tmpstr :=hexS;
    midS   :=hexS;
    for i:=(length(hexskey) div 2) downto 1 do
    begin
        if i<>(length(hexskey) div 2) then midS:= tmpstr;
        tmpstr:='';
        for j:=1 to (length(midS) div 2) do
        begin
            a:=strtoint('$' + midS[2*j-1] + midS[2*j]);
            b:=strtoint('$' + hexskey[2*i-1] + hexskey[2*i]);
            c:=a xor b;
            tmpstr := tmpstr + myStrtoHex(chr(c));
        end;
    end;
    result := myHextoStr(tmpstr);
end;

//调用示例
//Edit2.Text :=encryptstr(Edit1.Text,Editkey.Text);

最简单的XOR加密/解密与加法加密

单字节XOR是最基础的加密方式，加解密使用同一个函数。加法加密则需要分开实现。

// XOR 加密/解密
function XorEncDec(AStr:String;Key:Byte):String;
var
i,n:Integer;
begin
n:=Length(AStr);
SetLength(Result,n);
for i:=1 to n do
    Result[i]:=Char(Byte(AStr[i]) xor Key);
end;

//加法加密
function AddEnc(AStr:String;Key:Byte):String;
var
i,n:Integer;
begin
n:=Length(AStr);
SetLength(Result,n);
for i:=1 to n do
    Result[i]:=Char(Byte(AStr[i]) + Key);
end;

//加法解密
function AddDec(AStr:String;Key:Byte):String;
var
i,n:Integer;
begin
n:=Length(AStr);
SetLength(Result,n);
for i:=1 to n do
    Result[i]:=Char(Byte(AStr[i]) - Key);
end;

其中XorEncDec的加密/解密均为同一个过程，而加法加密、解密则需要两个过程配套使用。

procedure TForm1.Button1Click(Sender: TObject);
begin
Edit2.Text:=XorEncDec(Edit1.Text,123); //加密（Edit1中存放明文，Edit2存放密文）
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
Edit1.Text:=XorEncDec(Edit2.Text,123); //解密（Edit2存放密文，Edit1中存放解密的明文）
end;

算法趣味题与收集的CM算法

四位数字的全排列（经典练习题：1、2、3、4能组成多少个无重复的三位数？）

function permutation( int:integer ):string;
var
i,j,k:integer;
begin
for i:=1 to int do
for j:=1 to int do
for k:=1 to int do
begin
if (i<>j) and (i<>k) and (j<>k)then
result:=result + inttostr(i) + inttostr(j) + inttostr(k) + #13 + #10;
end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
     Memo1.Clear;
     Memo1.Lines.Add(permutation(4));
     label1.Caption:=inttostr(memo1.Lines.Count);
end;

acafeel 算法（来自逆向分析）

这是一个从某个CrackMe中提取的注册算法，包含多层字符串拼接和字符替换，最终输出5段形式的注册码。

function acafeel(Name:string):string;
var
strA,strB, strC : string;
sum, pos : integer;
begin
if Name ='' then exit;
for pos := 1 to length(Name) do
    if (ord(Name[pos]) < $20) or (ord(Name[pos]) > $7E) then
      begin
        showmessage('请输入字母或者数字，不支持中文！');
        exit;
      end;
sum := ord(Name[1]) * length(Name) * $64;
strA := ' ' + intTostr(sum) + 'NoName SwordMan nOnAME';
strB := strA[$12] + (strA[$7] + strA[$8]) + strA[$9] + strA[$5] + strA[$3] +
          strA[$1] + (strA[$14] + strA[$15] + strA[$16] + strA[$17] + strA[$18]) +
          (strA[$D] + strA[$E]) + strA[$8];
for pos := 1 to length(strB) do
    if (ord(strB[pos]) <> $20) then strC := strC + strB[pos];
if length(strC) < 14 then
    begin
      strC := strC + copy(strA, 7, 23);
      strC := copy(strC, 1, 15) + 'bywjy';
    end;
Result := copy(strC, 1, 5) + '-' + copy(strC, 5, 4) + '-' + copy(strC, 8, 4) +
          '-' + copy(strC, 11, 4) + '-' + copy(strC, 14, 7); 
end;

acafeel2 算法（更复杂的运算）

该算法对用户名长度做了分支判断，引入了大量数学运算和字符串反序操作，最后生成形如“RHM-xxxxxxxxx”的注册码。

function acafeel2(Name:string):string;
var
temp1, temp2, temp3,
tempA, tempB, tempC1, tempC2, tempD1, tempD2,
pos, posSTR, posADD, posSUB : integer;
begin
    if length(Name) < 5 then
    begin
    showmessage('注册名的长度必须大于4位数!');
    exit;
    end;
    //注册名长度5-9
    if (5 <= length(Name)) and (length(Name) <= 9) then
    begin
    temp1 := ((ord(Name[1]) + $56B) xor $890428) + $18;
    temp2 := ((ord(Name[4]) + length(Name)) xor $54) xor $25D;
    temp3 := (ord(Name[1]) + $56B) * $1024;
    tempA := ((temp1 * temp2) + $400) + temp3 ;
     for pos := 2 to length(Name) do
     begin
     temp1 := temp1 + ((ord(Name[pos]) + $56B) xor $890428);
     temp2 := ((ord(Name[4]) + length(Name)) xor $54) xor $25D;
     temp3 := (ord(Name[pos]) + $56B) * $1024;
     tempA := tempA + (temp1 * temp2) + temp3;
     end;
     end;
    //注册名长度>9
    if length(Name) > 9 then
    begin
     temp1 := ((ord(Name[1]) + $56B) xor $890428) + $18;
     temp2 := (((ord(Name[4]) + length(Name)) xor $54) xor $25D) * $400;
     temp3 := ((ord(Name[1]) + $56B) * $1024) + $400;
     tempA := temp3;
     for pos := 2 to length(Name) do
     begin
     temp1 := temp1 + temp2 + ((ord(Name[pos]) + $56B) xor $890428);
     temp2 := (((ord(Name[4]) + length(Name)) xor $54) xor $25D) * temp3;
     temp3 := temp3 + ((ord(Name[pos]) + $56B) * $1024);
     tempA := temp3;
     end;
     temp1 := temp1 + temp2;
     end;
     //小循环1
    tempB := ord(Name[5+1]) + $32 + $134A;
     for posSTR := length(Name) downto 1 do
     begin
     Name := Name + Name[posSTR];
     end;
     posSTR := length(Name) div 2;
     Name := copy(Name, posSTR+1, posSTR);
    for pos := 4 downto 1 do
    begin
    tempB := tempB + ord(Name[pos+1]) + $134A;
    for posSTR := length(Name) downto 1 do
    begin
    Name := Name + Name[posSTR];
    end;
    posSTR := length(Name) div 2;
    Name := copy(Name, posSTR+1, posSTR);
    end;
    //小循环2
    tempC1 := ord(Name[1]) + tempB + $134A;
    tempC2 := ((ord(Name[2]) + $23) * $25A) + temp1;
    posADD := 2;
    for pos := 4 downto 1 do
    begin
    posADD := posADD + 1;
    tempC1 := tempC1 + ord(Name[1]) + $134A;
    tempC2 := tempC2 + ((ord(Name[posADD]) + $23) * $25A);
    if (posADD = 4) or (posADD = 5) then
    begin
    for posSTR := length(Name) downto 1 do
    begin
    Name := Name + Name[posSTR];
    end;
    posSTR := length(Name) div 2;
    Name := copy(Name, posSTR+1, posSTR);
    end;
    end;
    //最后检测
    tempD1 := (tempC2 + $3C) xor ($1337 - ord(Name[3]));
    tempD2 := (tempC1 + tempA) xor ($18 - ord(Name[6]));
    Result:= 'RHM' + '-' + inttostr(tempD1) + inttostr(tempD2);
end;

johnroot 写的注册机改写（不懂算法的CM）

这个算法相对简单：对16字节的name做两次不同常量的XOR，然后对结果进行变换，最后拼接成注册码。

function johnroot(Name:string):string;
var
nameok,gg,gg2,mm,mm2:pchar;
i,j,j2,k:integer;
begin
getmem(nameok,$10);
ZeroMemory(nameok,$10);
getmem(mm,5);
ZeroMemory(mm,5);
getmem(mm2,5);
ZeroMemory(mm2,5);
for i:=0 to (length(name)-1) do
begin
nameok[i]:=Name[i];
end;
j:=0;
for i:=0 to $f do
begin
   k:=ord(nameok[i]) xor $82;
   j:=j + k;
end;
gg := pchar(inttostr(j));
j:=0;
for i:=0 to $f do
begin
   k:=ord(nameok[i]) xor $28;
   j2:=j2 + k;
end;
gg2 := pchar(inttostr(j2));
if length(gg2)<4 then
begin
gg2:=pchar('0' + string(gg2));
end;
for i:=0 to 3 do
begin
   mm[i]:= char($69 - ord(gg[i]));
end;
for i:=0 to 3 do
begin
   mm2[i]:= char($69 - ord(gg2[i]));
end;
Result:=string(gg) + string(gg2) + string(mm) + string(mm2);
end;

这些代码大部分来自早期学习逆向时的实践，有不少直接改写自网上其他兄弟的成果。核心思路就是理解算法后，用Delphi重现一遍。对于初学者来说，多读多改这些现成的实现，比从头造轮子更能快速进步。