10位整数,对每一位进行加密,要10种不同的加密算法(简单点就行,最好10行以内解决问题).或者直接提供思路也行,谢谢!

解决方案 »

  1.   

    lywho(阿勇) 举个例子行不行?
      

  2.   

    很普通的一个字符串加密函数(只是简单罢了)function cryptstr(const s:string; stype: dword):string;
    var
      i: integer;
      fkey: integer;
    begin
      result:='';
      case stype of
      0:    
        begin
          randomize;
          fkey := random($ff);
          for i:=1 to length(s) do
           result := result+chr( ord(s[i]) xor i xor fkey);
          result := result + char(fkey);
        end;
      1:    
        begin
          fkey :=  ord(s[length(s)]);
          for i:=1 to length(s) - 1 do
          result := result+chr( ord(s[i]) xor i xor fkey);
       end;
    end;
    var
      s,s_result:string;
      x:longint;//要加密的整数
    begin
      s := IntToStr(x);
      s_result := cryptstr(s,0);
      //s_result := cryptstr(s,1);
    end;
      

  3.   

    {解密函数}function Decrypt(const InString: string; StartKey, MultKey, AddKey: Integer):
        string;
    var
        I: integer;
    begin
        Result := '';
        for I := 1 to Length(InString) do
        begin
            Result := Result + CHAR(Byte(InString[I]) xor (StartKey shr 8));
            StartKey := (Byte(InString[I]) + StartKey) * MultKey + AddKey;
        end;
    end;
    {加密函数}function Encrypt(const InString: string; StartKey, MultKey, AddKey: Integer):
        string;
    var
        I: integer;
    begin
        Result := '';
        for I := 1 to Length(InString) do
        begin
            Result := Result + CHAR(Byte(InString[I]) xor (StartKey shr 8));
            StartKey := (Byte(Result[I]) + StartKey) * MultKey + AddKey;
        end;
    end;
      

  4.   

    这个更简单const Key:Array[1..10] of Byte=[76,34,12,36,0,4,5,99,83,88];function fly(S:string):string;
    var
      I,L:Integer;
    begin
      L:=Length(S);
      SetLength(Result,L);
      for I:=1 to L do
      begin
        Result[I]:=Char(Byte(S[I]) xor Byte(Key[(I mod 10)+1]));
      end;
    end;
      

  5.   

    MD5是个不可逆推的加密函数,解密只需自己自己对应即可:
    function MD_dzt(sMessage:WideString):WideString;function RotateLeft(lValue, iShiftBits:integer):integer;
    begin
      result := (lValue shl iShiftBits)  or  (lValue shr (32-iShiftBits));
    end;function AddUnsigned(lX,lY:integer):integer;
    var
      lX4,lY4,lX8,lY8,lResult:integer;
    begin
      lX8 := (lX  and  $80000000);
      lY8 := (lY  and  $80000000);
      lX4 := (lX  and  $40000000);
      lY4 := (lY  and  $40000000);
      lResult := (lX  and  $3FFFFFFF)+(lY  and  $3FFFFFFF);
      if (lX4  and  lY4) <> 0 then begin result := (lResult xor $80000000 xor lX8 xor lY8); Exit; end;
      if (lX4  or  lY4) <> 0 then
      begin
        if (lResult  and  $40000000) <>0 then
          begin result :=  (lResult xor $C0000000 xor lX8 xor lY8); end
        else
          begin result :=  (lResult xor $40000000 xor lX8 xor lY8); end
      end
      else
        begin result :=  (lResult xor lX8 xor lY8); end
    end;function F(x,y,z:integer):integer; begin  result :=  (x  and  y)  or  (( not x)  and  z); end;
    function G(x,y,z:integer):integer; begin  result :=  (x  and  z)  or  (y  and  ( not z)); end;
    function H(x,y,z:integer):integer; begin  result :=  (x xor y xor z); end;
    function I(x,y,z:integer):integer; begin  result :=  (y xor (x  or  ( not z))); end;function FF(a,b,c,d,x,s,ac:integer):integer;
    begin
      a := AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
      result :=  AddUnsigned(RotateLeft(a, s), b);
    end;
    function GG(a,b,c,d,x,s,ac:integer):integer;
    begin
      a := AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
      result :=  AddUnsigned(RotateLeft(a, s), b);
    end;
    function HH(a,b,c,d,x,s,ac:integer):integer;
    begin
      a := AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
      result :=  AddUnsigned(RotateLeft(a, s), b);
    end;
    function II(a,b,c,d,x,s,ac:integer):integer;
    begin
      a := AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
      result :=  AddUnsigned(RotateLeft(a, s), b);
    end;type IntArray = array of integer;
    function ConvertToWordArray(sMessage:WideString):IntArray;
    var lWordCount:integer;
    var lMessageLength:integer;
    var lNumberOfWords_temp1:integer;
    var lNumberOfWords_temp2:integer;
    var lNumberOfWords:integer;
    var lWordArray:IntArray;
    var lBytePosition:integer;
    var lByteCount:integer;
    begin
      lMessageLength := length(sMessage);
      lNumberOfWords_temp1:=lMessageLength + 8;
      lNumberOfWords_temp2:=(lNumberOfWords_temp1-(lNumberOfWords_temp1  mod  64)) div 64;
      lNumberOfWords := (lNumberOfWords_temp2+1)*16;
      SetLength(lWordArray,lNumberOfWords);
      lBytePosition := 0;
      lByteCount := 0;
      while ( lByteCount < lMessageLength ) do
      begin
        lWordCount := (lByteCount-(lByteCount  mod  4)) div 4;
        lBytePosition := (lByteCount  mod  4)*8;
        lWordArray[lWordCount] := (lWordArray[lWordCount]  or  (ord(sMessage[lByteCount+1]) shl lBytePosition));
        inc(lByteCount);
      end;
      lWordCount := (lByteCount-(lByteCount  mod  4)) div 4;
      lBytePosition := (lByteCount  mod  4)*8;
      lWordArray[lWordCount] := lWordArray[lWordCount]  or  ($80 shl lBytePosition);
      lWordArray[lNumberOfWords-2] := lMessageLength shl 3;
      lWordArray[lNumberOfWords-1] := lMessageLength shr 29;
      result :=  lWordArray;
    end;function WordToHex(lValue:integer):WideString;
    var WordToHexValue,WordToHexValue_temp:WideString;
      lByte,lCount:integer;
    begin
      Result := '';
      for lCount := 0 to 3 do
      begin
        lByte := (lValue shr (lCount*8))  and  255;
        result := result + IntToHex(lByte,2);
      end;
    end;var x:IntArray;
    var k,AA,BB,CC,DD,a,b,c,d:integer;
    const S11:integer=7; S12:integer=12; S13:integer=17; S14:integer=22;
     S21:integer=5; S22:integer=9 ; S23:integer=14; S24:integer=20;
     S31:integer=4; S32:integer=11; S33:integer=16; S34:integer=23;
     S41:integer=6; S42:integer=10; S43:integer=15; S44:integer=21;
    begin
       //  Steps 1 and 2. Append padding bits and length and convert to words
      x := ConvertToWordArray(sMessage);
       //  Step 3. Initialise
      a := $67452301; b := $EFCDAB89; c := $98BADCFE; d := $10325476;
       //  Step 4. Process the message in 16-word blocks
      k :=0 ;
      while k< length(x) do
      //for (k=0;k<x.length;k+=16)
      begin
        AA:=a; BB:=b; CC:=c; DD:=d;
        a:=FF(a,b,c,d,x[k+0], S11,$D76AA478);
        d:=FF(d,a,b,c,x[k+1], S12,$E8C7B756);
        c:=FF(c,d,a,b,x[k+2], S13,$242070DB);
        b:=FF(b,c,d,a,x[k+3], S14,$C1BDCEEE);
        a:=FF(a,b,c,d,x[k+4], S11,$F57C0FAF);
        d:=FF(d,a,b,c,x[k+5], S12,$4787C62A);
        c:=FF(c,d,a,b,x[k+6], S13,$A8304613);
        b:=FF(b,c,d,a,x[k+7], S14,$FD469501);
        a:=FF(a,b,c,d,x[k+8], S11,$698098D8);
        d:=FF(d,a,b,c,x[k+9], S12,$8B44F7AF);
        c:=FF(c,d,a,b,x[k+10],S13,$FFFF5BB1);
        b:=FF(b,c,d,a,x[k+11],S14,$895CD7BE);
        a:=FF(a,b,c,d,x[k+12],S11,$6B901122);
        d:=FF(d,a,b,c,x[k+13],S12,$FD987193);
        c:=FF(c,d,a,b,x[k+14],S13,$A679438E);
        b:=FF(b,c,d,a,x[k+15],S14,$49B40821);
        a:=GG(a,b,c,d,x[k+1], S21,$F61E2562);
        d:=GG(d,a,b,c,x[k+6], S22,$C040B340);
        c:=GG(c,d,a,b,x[k+11],S23,$265E5A51);
        b:=GG(b,c,d,a,x[k+0], S24,$E9B6C7AA);
        a:=GG(a,b,c,d,x[k+5], S21,$D62F105D);
        d:=GG(d,a,b,c,x[k+10],S22,$2441453);
        c:=GG(c,d,a,b,x[k+15],S23,$D8A1E681);
        b:=GG(b,c,d,a,x[k+4], S24,$E7D3FBC8);
        a:=GG(a,b,c,d,x[k+9], S21,$21E1CDE6);
        d:=GG(d,a,b,c,x[k+14],S22,$C33707D6);
        c:=GG(c,d,a,b,x[k+3], S23,$F4D50D87);
        b:=GG(b,c,d,a,x[k+8], S24,$455A14ED);
        a:=GG(a,b,c,d,x[k+13],S21,$A9E3E905);
        d:=GG(d,a,b,c,x[k+2], S22,$FCEFA3F8);
        c:=GG(c,d,a,b,x[k+7], S23,$676F02D9);
        b:=GG(b,c,d,a,x[k+12],S24,$8D2A4C8A);
        a:=HH(a,b,c,d,x[k+5], S31,$FFFA3942);
        d:=HH(d,a,b,c,x[k+8], S32,$8771F681);
        c:=HH(c,d,a,b,x[k+11],S33,$6D9D6122);
        b:=HH(b,c,d,a,x[k+14],S34,$FDE5380C);
        a:=HH(a,b,c,d,x[k+1], S31,$A4BEEA44);
        d:=HH(d,a,b,c,x[k+4], S32,$4BDECFA9);
        c:=HH(c,d,a,b,x[k+7], S33,$F6BB4B60);
        b:=HH(b,c,d,a,x[k+10],S34,$BEBFBC70);
        a:=HH(a,b,c,d,x[k+13],S31,$289B7EC6);
        d:=HH(d,a,b,c,x[k+0], S32,$EAA127FA);
        c:=HH(c,d,a,b,x[k+3], S33,$D4EF3085);
        b:=HH(b,c,d,a,x[k+6], S34,$4881D05);
        a:=HH(a,b,c,d,x[k+9], S31,$D9D4D039);
        d:=HH(d,a,b,c,x[k+12],S32,$E6DB99E5);
        c:=HH(c,d,a,b,x[k+15],S33,$1FA27CF8);
        b:=HH(b,c,d,a,x[k+2], S34,$C4AC5665);
        a:=II(a,b,c,d,x[k+0], S41,$F4292244);
        d:=II(d,a,b,c,x[k+7], S42,$432AFF97);
        c:=II(c,d,a,b,x[k+14],S43,$AB9423A7);
        b:=II(b,c,d,a,x[k+5], S44,$FC93A039);
        a:=II(a,b,c,d,x[k+12],S41,$655B59C3);
        d:=II(d,a,b,c,x[k+3], S42,$8F0CCC92);
        c:=II(c,d,a,b,x[k+10],S43,$FFEFF47D);
        b:=II(b,c,d,a,x[k+1], S44,$85845DD1);
        a:=II(a,b,c,d,x[k+8], S41,$6FA87E4F);
        d:=II(d,a,b,c,x[k+15],S42,$FE2CE6E0);
        c:=II(c,d,a,b,x[k+6], S43,$A3014314);
        b:=II(b,c,d,a,x[k+13],S44,$4E0811A1);
        a:=II(a,b,c,d,x[k+4], S41,$F7537E82);
        d:=II(d,a,b,c,x[k+11],S42,$BD3AF235);
        c:=II(c,d,a,b,x[k+2], S43,$2AD7D2BB);
        b:=II(b,c,d,a,x[k+9], S44,$EB86D391);
        a:=AddUnsigned(a,AA); b:=AddUnsigned(b,BB); c:=AddUnsigned(c,CC); d:=AddUnsigned(d,DD);
        inc (k,16);
      end;
      result := LowerCase(WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d));
    end;调用:MD_DZT(Edit4.Text)便可以了
      

  6.   

    >>要10种不同的加密算法(简单点就行,最好10行以内解决问题).一行一个加密算法呀,高难!
      

  7.   

    去DelphiBox.com找了有简单加密算法的http://lysoft.7u7.net