我现在要用delphi做个接口,双方使用标准的单倍des算法进行加密解密,
但我的结果与对方结果总是不能匹配,谁帮下忙看看哪里出错了。
网上没有找到与对方的des算法匹配的源码,我晕呀。我与对方的delphi源码如下:

解决方案 »

  1.   

    unit   Des;
        
    interface
        
    uses   SysUtils;
        
    type   
      TKeyByte   =   array[0..5]   of   Byte;
      TDesMode   =   (dmEncry,   dmDecry);   
        
      function   EncryStr(Str,   Key:   String):   String;   
      function   DecryStr(Str,   Key:   String):   String;   
      function   EncryStrHex(Str,   Key:   String):   String;   
      function   DecryStrHex(StrHex,   Key:   String):   String;   
        
    const   
      BitIP:   array[0..63]   of   Byte   =   
          (57,   49,   41,   33,   25,   17,     9,     1,   
            59,   51,   43,   35,   27,   19,   11,     3,   
            61,   53,   45,   37,   29,   21,   13,     5,   
            63,   55,   47,   39,   31,   23,   15,     7,   
            56,   48,   40,   32,   24,   16,     8,     0,   
            58,   50,   42,   34,   26,   18,   10,     2,   
            60,   52,   44,   36,   28,   20,   12,     4,   
            62,   54,   46,   38,   30,   22,   14,     6   );   
        
      BitCP:   array[0..63]   of   Byte   =   
          (   39,     7,   47,   15,   55,   23,   63,   31,   
              38,     6,   46,   14,   54,   22,   62,   30,   
              37,     5,   45,   13,   53,   21,   61,   29,   
              36,     4,   44,   12,   52,   20,   60,   28,   
              35,     3,   43,   11,   51,   19,   59,   27,   
              34,     2,   42,   10,   50,   18,   58,   26,   
              33,     1,   41,     9,   49,   17,   57,   25,   
              32,     0,   40,     8,   48,   16,   56,   24   );   
        
      BitExp:   array[0..47]   of   Integer   =   
          (   31,   0,   1,   2,   3,   4,   3,   4,   5,   6,   7,   8,   7,   8,   9,10,   
              11,12,11,12,13,14,15,16,15,16,17,18,19,20,19,20,   
              21,22,23,24,23,24,25,26,27,28,27,28,29,30,31,0     );   
        
      BitPM:   array[0..31]   of   Byte   =   
          (   15,   6,19,20,28,11,27,16,   0,14,22,25,   4,17,30,   9,   
                1,   7,23,13,31,26,   2,   8,18,12,29,   5,21,10,   3,24   );   
        
      sBox:   array[0..7]   of   array[0..63]   of   Byte   =   
          (   (   14,     4,   13,     1,     2,   15,   11,     8,     3,   10,     6,   12,     5,     9,     0,     7,   
                    0,   15,     7,     4,   14,     2,   13,     1,   10,     6,   12,   11,     9,     5,     3,     8,   
                    4,     1,   14,     8,   13,     6,     2,   11,   15,   12,     9,     7,     3,   10,     5,     0,   
                  15,   12,     8,     2,     4,     9,     1,     7,     5,   11,     3,   14,   10,     0,     6,   13   ),   
        
              (   15,     1,     8,   14,     6,   11,     3,     4,     9,     7,     2,   13,   12,     0,     5,   10,   
                    3,   13,     4,     7,   15,     2,     8,   14,   12,     0,     1,   10,     6,     9,   11,     5,   
                    0,   14,     7,   11,   10,     4,   13,     1,     5,     8,   12,     6,     9,     3,     2,   15,   
                  13,     8,   10,     1,     3,   15,     4,     2,   11,     6,     7,   12,     0,     5,   14,     9   ),   
        
              (   10,     0,     9,   14,     6,     3,   15,     5,     1,   13,   12,     7,   11,     4,     2,     8,   
                  13,     7,     0,     9,     3,     4,     6,   10,     2,     8,     5,   14,   12,   11,   15,     1,   
                  13,     6,     4,     9,     8,   15,     3,     0,   11,     1,     2,   12,     5,   10,   14,     7,   
                    1,   10,   13,     0,     6,     9,     8,     7,     4,   15,   14,     3,   11,     5,     2,   12   ),   
        
              (     7,   13,   14,     3,     0,     6,     9,   10,     1,     2,     8,     5,   11,   12,     4,   15,   
                  13,     8,   11,     5,     6,   15,     0,     3,     4,     7,     2,   12,     1,   10,   14,     9,   
                  10,     6,     9,     0,   12,   11,     7,   13,   15,     1,     3,   14,     5,     2,     8,     4,   
                    3,   15,     0,     6,   10,     1,   13,     8,     9,     4,     5,   11,   12,     7,     2,   14   ),   
        
              (     2,   12,     4,     1,     7,   10,   11,     6,     8,     5,     3,   15,   13,     0,   14,     9,   
                  14,   11,     2,   12,     4,     7,   13,     1,     5,     0,   15,   10,     3,     9,     8,     6,   
                    4,     2,     1,   11,   10,   13,     7,     8,   15,     9,   12,     5,     6,     3,     0,   14,   
                  11,     8,   12,     7,     1,   14,     2,   13,     6,   15,     0,     9,   10,     4,     5,     3   ),   
        
              (   12,     1,   10,   15,     9,     2,     6,     8,     0,   13,     3,     4,   14,     7,     5,   11,   
                  10,   15,     4,     2,     7,   12,     9,     5,     6,     1,   13,   14,     0,   11,     3,     8,   
                    9,   14,   15,     5,     2,     8,   12,     3,     7,     0,     4,   10,     1,   13,   11,     6,   
                    4,     3,     2,   12,     9,     5,   15,   10,   11,   14,     1,     7,     6,     0,     8,   13   ),   
        
              (     4,   11,     2,   14,   15,     0,     8,   13,     3,   12,     9,     7,     5,   10,     6,     1,   
                  13,     0,   11,     7,     4,     9,     1,   10,   14,     3,     5,   12,     2,   15,     8,     6,   
                    1,     4,   11,   13,   12,     3,     7,   14,   10,   15,     6,     8,     0,     5,     9,     2,   
                    6,   11,   13,     8,     1,     4,   10,     7,     9,     5,     0,   15,   14,     2,     3,   12   ),   
        
              (   13,     2,     8,     4,     6,   15,   11,     1,   10,     9,     3,   14,     5,     0,   12,     7,   
                    1,   15,   13,     8,   10,     3,     7,     4,   12,     5,     6,   11,     0,   14,     9,     2,   
                    7,   11,     4,     1,     9,   12,   14,     2,     0,     6,   10,   13,   15,     3,     5,     8,   
                    2,     1,   14,     7,     4,   10,     8,   13,   15,   12,     9,     0,     3,     5,     6,   11   )   );   
        
      BitPMC1:   array[0..55]   of   Byte   =   
          (   56,   48,   40,   32,   24,   16,     8,   
                0,   57,   49,   41,   33,   25,   17,   
                9,     1,   58,   50,   42,   34,   26,   
              18,   10,     2,   59,   51,   43,   35,   
              62,   54,   46,   38,   30,   22,   14,   
                6,   61,   53,   45,   37,   29,   21,   
              13,     5,   60,   52,   44,   36,   28,   
              20,   12,     4,   27,   19,   11,     3   );   
        
      BitPMC2:   array[0..47]   of   Byte   =   
          (   13,   16,   10,   23,     0,     4,   
                2,   27,   14,     5,   20,     9,   
              22,   18,   11,     3,   25,     7,   
              15,     6,   26,   19,   12,     1,   
              40,   51,   30,   36,   46,   54,   
              29,   39,   50,   44,   32,   47,   
              43,   48,   38,   55,   33,   52,   
              45,   41,   49,   35,   28,   31   );   
        
    var   
      subKey:   array[0..15]   of   TKeyByte;   
                    
      

  2.   

    implementation   
        
    procedure   initPermutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   8,   0);   
      for   i   :=   0   to   63   do   
          if   (inData[BitIP[i]   shr   3]   and   (1   shl   (7-   (BitIP[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   7   do   inData[i]   :=   newData[i];   
    end;   
        
    procedure   conversePermutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   8,   0);   
      for   i   :=   0   to   63   do   
          if   (inData[BitCP[i]   shr   3]   and   (1   shl   (7-(BitCP[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   7   do   inData[i]   :=   newData[i];   
    end;   
        
    procedure   expand(inData:   array   of   Byte;   var   outData:   array   of   Byte);   
    var   
      i:   Integer;   
    begin   
      FillChar(outData,   6,   0);   
      for   i   :=   0   to   47   do   
          if   (inData[BitExp[i]   shr   3]   and   (1   shl   (7-(BitExp[i]   and   $07))))   <>   0   then   
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
    end;   
        
    procedure   permutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..3]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   4,   0);   
      for   i   :=   0   to   31   do   
          if   (inData[BitPM[i]   shr   3]   and   (1   shl   (7-(BitPM[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   3   do   inData[i]   :=   newData[i];   
    end;   
        
    function   si(s,inByte:   Byte):   Byte;   
    var   
      c:   Byte;   
    begin   
      c   :=   (inByte   and   $20)   or   ((inByte   and   $1e)   shr   1)   or   
          ((inByte   and   $01)   shl   4);   
      Result   :=   (sBox[s][c]   and   $0f);   
    end;   
        
    procedure   permutationChoose1(inData:   array   of   Byte;   
      var   outData:   array   of   Byte);
    var
      i:   Integer;
    begin
      FillChar(outData,   7,   0);   
      for   i   :=   0   to   55   do
          if   (inData[BitPMC1[i]   shr   3]   and   (1   shl   (7-(BitPMC1[i]   and   $07))))   <>   0   then
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));
    end;procedure   permutationChoose2(inData:   array   of   Byte;
      var   outData:   array   of   Byte);   
    var   
      i:   Integer;   
    begin   
      FillChar(outData,   6,   0);   
      for   i   :=   0   to   47   do   
          if   (inData[BitPMC2[i]   shr   3]   and   (1   shl   (7-(BitPMC2[i]   and   $07))))   <>   0   then   
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
    end;   
        
    procedure   cycleMove(var   inData:   array   of   Byte;   bitMove:   Byte);   
    var   
      i:   Integer;   
    begin   
      for   i   :=   0   to   bitMove   -   1   do   
      begin   
          inData[0]   :=   (inData[0]   shl   1)   or   (inData[1]   shr   7);   
          inData[1]   :=   (inData[1]   shl   1)   or   (inData[2]   shr   7);   
          inData[2]   :=   (inData[2]   shl   1)   or   (inData[3]   shr   7);   
          inData[3]   :=   (inData[3]   shl   1)   or   ((inData[0]   and   $10)   shr   4);   
          inData[0]   :=   (inData[0]   and   $0f);   
      end;   
    end;   
        
    procedure   makeKey(inKey:   array   of   Byte;   var   outKey:   array   of   TKeyByte);   
    const   
      bitDisplace:   array[0..15]   of   Byte   =   
          (   1,1,2,2,   2,2,2,2,   1,2,2,2,   2,2,2,1   );   
    var   
      outData56:   array[0..6]   of   Byte;   
      key28l:   array[0..3]   of   Byte;   
      key28r:   array[0..3]   of   Byte;   
      key56o:   array[0..6]   of   Byte;   
      i:   Integer;   
    begin   
      permutationChoose1(inKey,   outData56);   
        
      key28l[0]   :=   outData56[0]   shr   4;   
      key28l[1]   :=   (outData56[0]   shl   4)   or   (outData56[1]   shr   4);   
      key28l[2]   :=   (outData56[1]   shl   4)   or   (outData56[2]   shr   4);   
      key28l[3]   :=   (outData56[2]   shl   4)   or   (outData56[3]   shr   4);   
      key28r[0]   :=   outData56[3]   and   $0f;   
      key28r[1]   :=   outData56[4];   
      key28r[2]   :=   outData56[5];   
      key28r[3]   :=   outData56[6];   
        
      for   i   :=   0   to   15   do   
      begin   
          cycleMove(key28l,   bitDisplace[i]);   
          cycleMove(key28r,   bitDisplace[i]);   
          key56o[0]   :=   (key28l[0]   shl   4)   or   (key28l[1]   shr   4);   
          key56o[1]   :=   (key28l[1]   shl   4)   or   (key28l[2]   shr   4);   
          key56o[2]   :=   (key28l[2]   shl   4)   or   (key28l[3]   shr   4);   
          key56o[3]   :=   (key28l[3]   shl   4)   or   (key28r[0]);   
          key56o[4]   :=   key28r[1];   
          key56o[5]   :=   key28r[2];   
          key56o[6]   :=   key28r[3];   
          permutationChoose2(key56o,   outKey[i]);   
      end;   
    end;   
        
    procedure   encry(inData,   subKey:   array   of   Byte;   
        var   outData:   array   of   Byte);   
    var   
      outBuf:   array[0..5]   of   Byte;   
      buf:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      expand(inData,   outBuf);   
      for   i   :=   0   to   5   do   outBuf[i]   :=   outBuf[i]   xor   subKey[i];   
                                                                                                  //   outBuf               xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   
      buf[0]   :=   outBuf[0]   shr   2;                                                                     //xxxxxx   ->   2   
      buf[1]   :=   ((outBuf[0]   and   $03)   shl   4)   or   (outBuf[1]   shr   4);   //   4   <-   xx   xxxx   ->   4   
      buf[2]   :=   ((outBuf[1]   and   $0f)   shl   2)   or   (outBuf[2]   shr   6);   //                 2   <-   xxxx   xx   ->   6   
      buf[3]   :=   outBuf[2]   and   $3f;                                                                 //                                         xxxxxx   
      buf[4]   :=   outBuf[3]   shr   2;                                                                     //                                                       xxxxxx   
      buf[5]   :=   ((outBuf[3]   and   $03)   shl   4)   or   (outBuf[4]   shr   4);   //                                                                   xx   xxxx   
      buf[6]   :=   ((outBuf[4]   and   $0f)   shl   2)   or   (outBuf[5]   shr   6);   //                                                                                 xxxx   xx   
      buf[7]   :=   outBuf[5]   and   $3f;                                                                 //                                                                                               xxxxxx   
      for   i   :=   0   to   7   do   buf[i]   :=   si(i,   buf[i]);   
      for   i   :=   0   to   3   do   outBuf[i]   :=   (buf[i*2]   shl   4)   or   buf[i*2+1];   
      permutation(outBuf);   
      for   i   :=   0   to   3   do   outData[i]   :=   outBuf[i];   
    end;   
        
    procedure   desData(desMode:   TDesMode;   
      inData:   array   of   Byte;   var   outData:   array   of   Byte);   
    //   inData,   outData   常?8Bytes??   
    var   
      i,   j:   Integer;   
      temp,   buf:   array[0..3]   of   Byte;   
    begin   
      for   i   :=   0   to   7   do   outData[i]   :=   inData[i];   
      initPermutation(outData);   
      if   desMode   =   dmEncry   then   
      begin   
          for   i   :=   0   to   15   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];                                   //temp   =   Ln   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];                 //Ln+1   =   Rn   
              encry(outData,   subKey[i],   buf);                                                       //Rn   ==Kn==>   buf   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];     //Rn+1   =   Ln^buf   
          end;   
        
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end   
      else   if   desMode   =   dmDecry   then   
      begin   
          for   i   :=   15   downto   0   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];   
              encry(outData,   subKey[i],   buf);   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];   
          end;   
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end;   
      conversePermutation(outData);   
    end;   
        
      

  3.   

    implementation   
        
    procedure   initPermutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   8,   0);   
      for   i   :=   0   to   63   do   
          if   (inData[BitIP[i]   shr   3]   and   (1   shl   (7-   (BitIP[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   7   do   inData[i]   :=   newData[i];   
    end;   
        
    procedure   conversePermutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   8,   0);   
      for   i   :=   0   to   63   do   
          if   (inData[BitCP[i]   shr   3]   and   (1   shl   (7-(BitCP[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   7   do   inData[i]   :=   newData[i];   
    end;   
        
    procedure   expand(inData:   array   of   Byte;   var   outData:   array   of   Byte);   
    var   
      i:   Integer;   
    begin   
      FillChar(outData,   6,   0);   
      for   i   :=   0   to   47   do   
          if   (inData[BitExp[i]   shr   3]   and   (1   shl   (7-(BitExp[i]   and   $07))))   <>   0   then   
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
    end;   
        
    procedure   permutation(var   inData:   array   of   Byte);   
    var   
      newData:   array[0..3]   of   Byte;   
      i:   Integer;   
    begin   
      FillChar(newData,   4,   0);   
      for   i   :=   0   to   31   do   
          if   (inData[BitPM[i]   shr   3]   and   (1   shl   (7-(BitPM[i]   and   $07))))   <>   0   then   
              newData[i   shr   3]   :=   newData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
      for   i   :=   0   to   3   do   inData[i]   :=   newData[i];   
    end;   
        
    function   si(s,inByte:   Byte):   Byte;   
    var   
      c:   Byte;   
    begin   
      c   :=   (inByte   and   $20)   or   ((inByte   and   $1e)   shr   1)   or   
          ((inByte   and   $01)   shl   4);   
      Result   :=   (sBox[s][c]   and   $0f);   
    end;   
        
    procedure   permutationChoose1(inData:   array   of   Byte;   
      var   outData:   array   of   Byte);
    var
      i:   Integer;
    begin
      FillChar(outData,   7,   0);   
      for   i   :=   0   to   55   do
          if   (inData[BitPMC1[i]   shr   3]   and   (1   shl   (7-(BitPMC1[i]   and   $07))))   <>   0   then
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));
    end;procedure   permutationChoose2(inData:   array   of   Byte;
      var   outData:   array   of   Byte);   
    var   
      i:   Integer;   
    begin   
      FillChar(outData,   6,   0);   
      for   i   :=   0   to   47   do   
          if   (inData[BitPMC2[i]   shr   3]   and   (1   shl   (7-(BitPMC2[i]   and   $07))))   <>   0   then   
              outData[i   shr   3]   :=   outData[i   shr   3]   or   (1   shl   (7-(i   and   $07)));   
    end;   
        
    procedure   cycleMove(var   inData:   array   of   Byte;   bitMove:   Byte);   
    var   
      i:   Integer;   
    begin   
      for   i   :=   0   to   bitMove   -   1   do   
      begin   
          inData[0]   :=   (inData[0]   shl   1)   or   (inData[1]   shr   7);   
          inData[1]   :=   (inData[1]   shl   1)   or   (inData[2]   shr   7);   
          inData[2]   :=   (inData[2]   shl   1)   or   (inData[3]   shr   7);   
          inData[3]   :=   (inData[3]   shl   1)   or   ((inData[0]   and   $10)   shr   4);   
          inData[0]   :=   (inData[0]   and   $0f);   
      end;   
    end;   
        
    procedure   makeKey(inKey:   array   of   Byte;   var   outKey:   array   of   TKeyByte);   
    const   
      bitDisplace:   array[0..15]   of   Byte   =   
          (   1,1,2,2,   2,2,2,2,   1,2,2,2,   2,2,2,1   );   
    var   
      outData56:   array[0..6]   of   Byte;   
      key28l:   array[0..3]   of   Byte;   
      key28r:   array[0..3]   of   Byte;   
      key56o:   array[0..6]   of   Byte;   
      i:   Integer;   
    begin   
      permutationChoose1(inKey,   outData56);   
        
      key28l[0]   :=   outData56[0]   shr   4;   
      key28l[1]   :=   (outData56[0]   shl   4)   or   (outData56[1]   shr   4);   
      key28l[2]   :=   (outData56[1]   shl   4)   or   (outData56[2]   shr   4);   
      key28l[3]   :=   (outData56[2]   shl   4)   or   (outData56[3]   shr   4);   
      key28r[0]   :=   outData56[3]   and   $0f;   
      key28r[1]   :=   outData56[4];   
      key28r[2]   :=   outData56[5];   
      key28r[3]   :=   outData56[6];   
        
      for   i   :=   0   to   15   do   
      begin   
          cycleMove(key28l,   bitDisplace[i]);   
          cycleMove(key28r,   bitDisplace[i]);   
          key56o[0]   :=   (key28l[0]   shl   4)   or   (key28l[1]   shr   4);   
          key56o[1]   :=   (key28l[1]   shl   4)   or   (key28l[2]   shr   4);   
          key56o[2]   :=   (key28l[2]   shl   4)   or   (key28l[3]   shr   4);   
          key56o[3]   :=   (key28l[3]   shl   4)   or   (key28r[0]);   
          key56o[4]   :=   key28r[1];   
          key56o[5]   :=   key28r[2];   
          key56o[6]   :=   key28r[3];   
          permutationChoose2(key56o,   outKey[i]);   
      end;   
    end;   
        
    procedure   encry(inData,   subKey:   array   of   Byte;   
        var   outData:   array   of   Byte);   
    var   
      outBuf:   array[0..5]   of   Byte;   
      buf:   array[0..7]   of   Byte;   
      i:   Integer;   
    begin   
      expand(inData,   outBuf);   
      for   i   :=   0   to   5   do   outBuf[i]   :=   outBuf[i]   xor   subKey[i];   
                                                                                                  //   outBuf               xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   xxxxxxxx   
      buf[0]   :=   outBuf[0]   shr   2;                                                                     //xxxxxx   ->   2   
      buf[1]   :=   ((outBuf[0]   and   $03)   shl   4)   or   (outBuf[1]   shr   4);   //   4   <-   xx   xxxx   ->   4   
      buf[2]   :=   ((outBuf[1]   and   $0f)   shl   2)   or   (outBuf[2]   shr   6);   //                 2   <-   xxxx   xx   ->   6   
      buf[3]   :=   outBuf[2]   and   $3f;                                                                 //                                         xxxxxx   
      buf[4]   :=   outBuf[3]   shr   2;                                                                     //                                                       xxxxxx   
      buf[5]   :=   ((outBuf[3]   and   $03)   shl   4)   or   (outBuf[4]   shr   4);   //                                                                   xx   xxxx   
      buf[6]   :=   ((outBuf[4]   and   $0f)   shl   2)   or   (outBuf[5]   shr   6);   //                                                                                 xxxx   xx   
      buf[7]   :=   outBuf[5]   and   $3f;                                                                 //                                                                                               xxxxxx   
      for   i   :=   0   to   7   do   buf[i]   :=   si(i,   buf[i]);   
      for   i   :=   0   to   3   do   outBuf[i]   :=   (buf[i*2]   shl   4)   or   buf[i*2+1];   
      permutation(outBuf);   
      for   i   :=   0   to   3   do   outData[i]   :=   outBuf[i];   
    end;   
        
    procedure   desData(desMode:   TDesMode;   
      inData:   array   of   Byte;   var   outData:   array   of   Byte);   
    //   inData,   outData   常?8Bytes??   
    var   
      i,   j:   Integer;   
      temp,   buf:   array[0..3]   of   Byte;   
    begin   
      for   i   :=   0   to   7   do   outData[i]   :=   inData[i];   
      initPermutation(outData);   
      if   desMode   =   dmEncry   then   
      begin   
          for   i   :=   0   to   15   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];                                   //temp   =   Ln   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];                 //Ln+1   =   Rn   
              encry(outData,   subKey[i],   buf);                                                       //Rn   ==Kn==>   buf   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];     //Rn+1   =   Ln^buf   
          end;   
        
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end   
      else   if   desMode   =   dmDecry   then   
      begin   
          for   i   :=   15   downto   0   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];   
              encry(outData,   subKey[i],   buf);   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];   
          end;   
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end;   
      conversePermutation(outData);   
    end;   
        
      

  4.   

    procedure   desData(desMode:   TDesMode;   
      inData:   array   of   Byte;   var   outData:   array   of   Byte);   
    //   inData,   outData   常?8Bytes??   
    var   
      i,   j:   Integer;   
      temp,   buf:   array[0..3]   of   Byte;   
    begin   
      for   i   :=   0   to   7   do   outData[i]   :=   inData[i];   
      initPermutation(outData);   
      if   desMode   =   dmEncry   then   
      begin   
          for   i   :=   0   to   15   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];                                   //temp   =   Ln   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];                 //Ln+1   =   Rn   
              encry(outData,   subKey[i],   buf);                                                       //Rn   ==Kn==>   buf   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];     //Rn+1   =   Ln^buf   
          end;   
        
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end   
      else   if   desMode   =   dmDecry   then   
      begin   
          for   i   :=   15   downto   0   do   
          begin   
              for   j   :=   0   to   3   do   temp[j]   :=   outData[j];   
              for   j   :=   0   to   3   do   outData[j]   :=   outData[j   +   4];   
              encry(outData,   subKey[i],   buf);   
              for   j   :=   0   to   3   do   outData[j   +   4]   :=   temp[j]   xor   buf[j];   
          end;   
          for   j   :=   0   to   3   do   temp[j]   :=   outData[j   +   4];   
          for   j   :=   0   to   3   do   outData[j   +   4]   :=   outData[j];   
          for   j   :=   0   to   3   do   outData[j]   :=   temp[j];   
      end;   
      conversePermutation(outData);   
    end;   
        
    //////////////////////////////////////////////////////////////   
        
    function   EncryStr(Str,   Key:   String):   String;   
    var   
      StrByte,   OutByte,   KeyByte:   array[0..7]   of   Byte;   
      StrResult:   String;   
      I,   J:   Integer;   
    begin   
      if   (Length(Str)   >   0)   and   (Ord(Str[Length(Str)])   =   0)   then   
          raise   Exception.Create('Error:   the   last   char   is   NULL   char.');   
      if   Length(Key)   <   8   then   
          while   Length(Key)   <   8   do   Key   :=   Key   +   Chr(0);   
      while   Length(Str)   mod   8   <>   0   do   Str   :=   Str   +   Chr(0);   
        
      for   J   :=   0   to   7   do   KeyByte[J]   :=   Ord(Key[J   +   1]);   
      makeKey(keyByte,   subKey);   
        
      StrResult   :=   '';   
        
      for   I   :=   0   to   Length(Str)   div   8   -   1   do   
      begin   
          for   J   :=   0   to   7   do   
              StrByte[J]   :=   Ord(Str[I   *   8   +   J   +   1]);   
          desData(dmEncry,   StrByte,   OutByte);   
          for   J   :=   0   to   7   do   
              StrResult   :=   StrResult   +   Chr(OutByte[J]);   
      end;   
        
      Result   :=   StrResult;   
    end;   
        
    function   DecryStr(Str,   Key:   String):   String;   
    var   
      StrByte,   OutByte,   KeyByte:   array[0..7]   of   Byte;   
      StrResult:   String;   
      I,   J:   Integer;   
    begin   
      if   Length(Key)   <   8   then   
          while   Length(Key)   <   8   do   Key   :=   Key   +   Chr(0);   
        
      for   J   :=   0   to   7   do   KeyByte[J]   :=   Ord(Key[J   +   1]);   
      makeKey(keyByte,   subKey);   
        
      StrResult   :=   '';   
        
      for   I   :=   0   to   Length(Str)   div   8   -   1   do   
      begin   
          for   J   :=   0   to   7   do   StrByte[J]   :=   Ord(Str[I   *   8   +   J   +   1]);   
          desData(dmDecry,   StrByte,   OutByte);   
          for   J   :=   0   to   7   do   
              StrResult   :=   StrResult   +   Chr(OutByte[J]);   
      end;   
      while   (Length(StrResult)   >   0)   and   
          (Ord(StrResult[Length(StrResult)])   =   0)   do   
          Delete(StrResult,   Length(StrResult),   1);   
      Result   :=   StrResult;   
    end;   
        
    ///////////////////////////////////////////////////////////   
        
    function   EncryStrHex(Str,   Key:   String):   String;   
    var   
      StrResult,   TempResult,   Temp:   String;   
      I:   Integer;   
    begin   
      TempResult   :=   EncryStr(Str,   Key);   
      StrResult   :=   '';   
      for   I   :=   0   to   Length(TempResult)   -   1   do   
      begin   
          Temp   :=   Format('%x',   [Ord(TempResult[I   +   1])]);   
          if   Length(Temp)   =   1   then   Temp   :=   '0'   +   Temp;   
          StrResult   :=   StrResult   +   Temp;   
      end;   
      Result   :=   StrResult;   
    end;   
        
    function   DecryStrHex(StrHex,   Key:   String):   String;   
      function   HexToInt(Hex:   String):   Integer;   
      var   
          I,   Res:   Integer;   
          ch:   Char;   
      begin   
          Res   :=   0;   
          for   I   :=   0   to   Length(Hex)   -   1   do   
          begin   
              ch   :=   Hex[I   +   1];   
              if   (ch   >=   '0')   and   (ch   <=   '9')   then   
                  Res   :=   Res   *   16   +   Ord(ch)   -   Ord('0')   
              else   if   (ch   >=   'A')   and   (ch   <=   'F')   then   
                  Res   :=   Res   *   16   +   Ord(ch)   -   Ord('A')   +   10   
              else   if   (ch   >=   'a')   and   (ch   <=   'f')   then   
                  Res   :=   Res   *   16   +   Ord(ch)   -   Ord('a')   +   10   
              else   raise   Exception.Create('Error:   not   a   Hex   String');   
          end;   
          Result   :=   Res;   
      end;   
        
    var   
      Str,   Temp:   String;   
      I:   Integer;   
    begin   
      Str   :=   '';   
      for   I   :=   0   to   Length(StrHex)   div   2   -   1   do   
      begin   
          Temp   :=   Copy(StrHex,   I   *   2   +   1,   2);   
          Str   :=   Str   +   Chr(HexToInt(Temp));   
      end;   
      Result   :=   DecryStr(Str,   Key);   
    end;   
        
    end.  
      

  5.   

    对方的接口是C的,des的加解密算法如下:
    关于C的源码:
    文件 StdDes.h  内容如下:#ifndef _TT_STDDES_H_
    #define _TT_STDDES_H_
    int RunDes(int bType,int bMode,char* In,char* Out,const int datalen,const char* Key,const int keylen);
    void Char2Hex(const int srclen, const char *src, unsigned char *outdata);
    void HexToStr(const int srclen, const unsigned char *src, char *outData);#endif
      

  6.   

    文件  StdDes.c 内容如下:#include "StdDes.h"
    #include "memory.h"
    ////////////////////////////////////////////////////////////////////////
    // initial permutation IP
    const char IP_Table[64] = {
    58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
            62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
            57, 49, 41, 33, 25, 17,  9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
            61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
    };
    // final permutation IP^-1 
    const char IPR_Table[64] = {
      40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
      38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
      36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
      34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41,  9, 49, 17, 57, 25
    };
    // expansion operation matrix
    const char E_Table[48] = {
      32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
      8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
      16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
      24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
    };
    // 32-bit permutation function P used on the output of the S-boxes 
    const char P_Table[32] = {
      16, 7, 20, 21, 29, 12, 28, 17, 1,  15, 23, 26, 5,  18, 31, 10,
      2,  8, 24, 14, 32, 27, 3,  9,  19, 13, 30, 6,  22, 11, 4,  25
    };
    // permuted choice table (key) 
    const char PC1_Table[56] = {
      57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
      10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
      63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
      14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
    };
    // permuted choice key (table) 
    const char PC2_Table[48] = {
      14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
      23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
      41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
      44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
    };
    // number left rotations of pc1 
    const char LOOP_Table[16] = {
      1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
    };
    // The (in)famous S-boxes 
    const char S_Box[8][4][16] = {
    // S1 
      14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
      0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
      4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
      15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
    // S2 
      15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
      3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
      0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
      13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
    // S3 
      10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
      13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
      13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
      1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
    // S4 
      7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
      13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
      10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
      3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
    // S5 
      2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
      14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
      4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
      11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
    // S6 
      12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
      10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
      9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
      4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
    // S7 
      4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
      13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
      1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
      6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
    // S8 
      13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
      1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
      7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
      2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
    };typedef char    (*PSubKey)[16][48];/*******************************************************************/
    /*
      函 数 名 称: ByteToBit
      功 能 描 述: 把BYTE转化为Bit流
      参 数 说 明: Out: 输出的Bit流[in][out]
    In: 输入的BYTE流[in]
    bits: Bit流的长度[in]
    /*******************************************************************/
    void ByteToBit(char *Out, const char *In, int bits)
    {
      int i;
      for(i=0; i<bits; ++i)
        Out[i] = (In[i>>3]>>(7 - i&7)) & 1;
    }/*******************************************************************/
    /*
      函 数 名 称: BitToByte
      功 能 描 述: 把Bit转化为Byte流
      参 数 说 明: Out: 输出的BYTE流[in][out]
    In: 输入的Bit流[in]
    bits: Bit流的长度[in]
    /*******************************************************************/
    void BitToByte(char *Out, const char *In, int bits)
    {
      int i;
      memset(Out, 0, bits>>3);
      for(i=0; i<bits; ++i)
        Out[i>>3] |= In[i]<<(7 - i&7);
    }/*******************************************************************/
    /*
      函 数 名 称: RotateL
      功 能 描 述: 把BIT流按位向左迭代
      参 数 说 明: In: 输入的Bit流[in]
    len: Bit流的长度[in]
    loop: 向左迭代的长度
    /*******************************************************************/
    void RotateL(char *In, int len, int loop)
    {
      char Tmp[256]={0};  memcpy(Tmp, In, loop);
      memcpy(In, In+loop, len-loop);
      memcpy(In+len-loop, Tmp, loop);
    }/*******************************************************************/
    /*
      函 数 名 称: Xor
      功 能 描 述: 把两个Bit流进行异或
      参 数 说 明: InA: 输入的Bit流[in][out]
    InB: 输入的Bit流[in]
    loop: Bit流的长度
    /*******************************************************************/
    void Xor(char *InA, const char *InB, int len)
    {
      int i;
      for(i=0; i<len; ++i)
        InA[i] ^= InB[i];
    }
    /*******************************************************************/
    /*
      函 数 名 称: Transform
      功 能 描 述: 把两个Bit流按表进行位转化
      参 数 说 明: Out: 输出的Bit流[out]
    In: 输入的Bit流[in]
    Table: 转化需要的表指针
    len: 转化表的长度
    /*******************************************************************/
    void Transform(char *Out, char *In, const char *Table, int len)
    {
      char Tmp[256]={0};  int i;
      for(i=0; i<len; ++i)
        Tmp[i] = In[ Table[i]-1 ];
      memcpy(Out, Tmp, len);
    }/*******************************************************************/
    /*
      函 数 名 称: S_func
      功 能 描 述: 实现数据加密S BOX模块
      参 数 说 明: Out: 输出的32Bit[out]
    In: 输入的48Bit[in]
    /*******************************************************************/
    void S_func(char Out[32], const char In[48])
    {
      char i,j,k;
      int l;
      for(i=0,j,k; i<8; ++i,In+=6,Out+=4) 
      {
        j = (In[0]<<1) + In[5];
        k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4]; //组织SID下标

        for(l=0; l<4; ++l) //把相应4bit赋值
          Out[l] = (S_Box[i][j][k]>>(3 - l)) & 1;
      }
    }
    /*******************************************************************/
    /*
      函 数 名 称: F_func
      功 能 描 述: 实现数据加密到输出P
      参 数 说 明: Out: 输出的32Bit[out]
    In: 输入的48Bit[in]
    /*******************************************************************/
    void F_func(char In[32], const char Ki[48])
    {
      char MR[48]={0};
      Transform(MR, In, E_Table, 48);
      Xor(MR, Ki, 48);
      S_func(In, MR);
      Transform(In, In, P_Table, 32);
    }
    //计算并填充子密钥到SubKey数据中
    void SetSubKey(PSubKey pSubKey, const char Key[8])
    {
      int i;
      char K[64]={0}, *KL=&K[0], *KR=&K[28];
      ByteToBit(K, Key, 64);
      Transform(K, K, PC1_Table, 56);
      for(i=0; i<16; ++i) {
        RotateL(KL, 28, LOOP_Table[i]);
        RotateL(KR, 28, LOOP_Table[i]);
        Transform((*pSubKey)[i], K, PC2_Table, 48);
      }
    }
    //DES单元运算
    void DES(char Out[8], char In[8], const PSubKey pSubKey, int Type)
    {
      char M[64]={0}, tmp[32]={0}, *Li=&M[0], *Ri=&M[32];
      ByteToBit(M, In, 64);
      Transform(M, M, IP_Table, 64);
      int i;
      if( Type==1  )
      {
        for( i=0; i<16; ++i)
        {
          memcpy(tmp, Ri, 32); //Ri[i-1] 保存
          F_func(Ri, (*pSubKey)[i]); //Ri[i-1]经过转化和SBox输出为P
          Xor(Ri, Li, 32); //Ri[i] = P XOR Li[i-1]
          memcpy(Li, tmp, 32); //Li[i] = Ri[i-1]
        }
      }
      else
      {
        for( i=15; i>=0; --i) 
        {
          memcpy(tmp, Ri, 32); //Ri[i-1] 保存
          F_func(Ri, (*pSubKey)[i]); //Ri[i-1]经过转化和SBox输出为P
          Xor(Ri, Li, 32); //Ri[i] = P XOR Li[i-1]
          memcpy(Li, tmp, 32); //Li[i] = Ri[i-1]
        }
      }
      RotateL(M,64,32); //Ri与Li换位重组M
      Transform(M, M, IPR_Table, 64); //最后结果进行转化
      BitToByte(Out, M, 64); //组织成字符
    }
      

  7.   

    /*******************************************************************/
    /*
      函 数 名 称: RunDes
      功 能 描 述: 执行DES算法对文本加解密
      参 数 说 明: bType :类型:1-加密,0-解密
    bMode :模式:ECB,CBC (1=ECB,0=CBC);
    In :待加密串指针
    Out :待输出串指针
    datalen :待加密串的长度,同时Out的缓冲区大小应大于或者等于datalen
    Key :密钥(可为8位,16位,24位)支持3密钥
    keylen :密钥长度,多出24位部分将被自动裁减  返回值 说明: int :是否加密成功 1-SUCC 0-FAILD
    /*******************************************************************/
    int RunDes(int bType,int bMode,char* In,char* Out,const int datalen,const char* Key,const int keylen)
    {
    //判断输入合法性
      if(!(In && Out && Key && datalen && keylen>=8))
        return 0;
    //只处理8的整数倍,不足长度自己填充
      if(datalen & 0x00000007)
        return 0;

      char m_SubKey[3][16][48]={0}; //秘钥
    //构造并生成SubKeys
      unsigned char nKey = (keylen>>3)>3 ? 3: (keylen>>3);
      int i,j;
      for( i=0;i<nKey;i++)
      {
        SetSubKey(&m_SubKey[i],&Key[i<<3]);
      }  if(bMode ) //ECB模式
      {
        if(nKey == 1) //单Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            DES(Out,In,&m_SubKey[0],bType);
          }
        }
        else
          if(nKey == 2) //3DES 2Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            DES(Out,In,&m_SubKey[0],bType);
            DES(Out,Out,&m_SubKey[1],!bType);
            DES(Out,Out,&m_SubKey[0],bType);
          }
        }
        else //3DES 3Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            DES(Out,In,&m_SubKey[bType? 2 : 0],bType);
            DES(Out,Out,&m_SubKey[1],!bType);
            DES(Out,Out,&m_SubKey[bType? 0 : 2],bType);
          }
        }
      }
      else //CBC模式
      {
        char cvec[8] = ""; //扭转向量
        char cvin[8] = ""; //中间变量    if(nKey == 1) //单Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            if(bType )
            {
              for(j=0;j<8;++j) //将输入与扭转变量异或
              {
                cvin[j] = In[j] ^ cvec[j];
              }
            }
            else
            {
              memcpy(cvin,In,8);
            }        DES(Out,cvin,&m_SubKey[0],bType);        if(bType)
            {
              memcpy(cvec,Out,8); //将输出设定为扭转变量
            }
            else
            {
              for(j=0;j<8;++j) //将输出与扭转变量异或
              {
                Out[j] = Out[j] ^ cvec[j];
              }
              memcpy(cvec,cvin,8); //将输入设定为扭转变量
            }
          }
        }
        else
          if(nKey == 2) //3DES CBC 2Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            if(bType)
            {
              for( j=0;j<8;++j) //将输入与扭转变量异或
              {
                cvin[j] = In[j] ^ cvec[j];
              }
            }
            else
            {
              memcpy(cvin,In,8);
            }

            DES(Out,cvin,&m_SubKey[0],bType);
            DES(Out,Out,&m_SubKey[1],!bType);
            DES(Out,Out,&m_SubKey[0],bType);

            if(bType)
            {
              memcpy(cvec,Out,8); //将输出设定为扭转变量
            }
            else
            {
              for( j=0;j<8;++j) //将输出与扭转变量异或
              {
                Out[j] = Out[j] ^ cvec[j];
              }
              memcpy(cvec,cvin,8); //将输入设定为扭转变量
            }
          }
        }
        else //3DES CBC 3Key
        {
          for( i=0,j=datalen>>3;i<j;++i,Out+=8,In+=8)
          {
            if(bType)
            {
              for( j=0;j<8;++j) //将输入与扭转变量异或
              {
                cvin[j] = In[j] ^ cvec[j];
              }
            }
            else
            {
              memcpy(cvin,In,8);
            }

            DES(Out,cvin,&m_SubKey[bType ? 2 : 0],bType);
            DES(Out,Out,&m_SubKey[1],!bType);
            DES(Out,Out,&m_SubKey[bType ? 0 : 2],bType);

            if(bType)
            {
              memcpy(cvec,Out,8); //将输出设定为扭转变量
            }
            else
            {
              for( j=0;j<8;++j) //将输出与扭转变量异或
              {
                Out[j] = Out[j] ^ cvec[j];
              }
              memcpy(cvec,cvin,8); //将输入设定为扭转变量
            }
          }
        }
      }

      return 1;
    }
    void Char2Hex(const int srclen, const char *src, unsigned char *outdata)
    {
      if (!src || !outdata)
      {
        return;
      }
      int i, k;
      for(i = 0; i < srclen; i++)
      {
        char c[3];
        c[0] = src[0 + 2 * i];
        c[1] = src[1 + 2 * i];
        c[2] = '\0';
        sscanf(c, "%x", &k);            // 把每两个字节的十六进制字符串转换成十六进制数字
        outdata[i] = ((k / 16) << 4) | (k % 16);      // 把十六进制数字压缩成单字节并转换成字符
      }
      return;
    }void HexToStr(const int srclen, const unsigned char *src, char *outData)
    {
      int i;
      for(i=0;i<srclen;i++)
      {
        sprintf((char *)outData+i*2,"%02x",src[i]);
      }
    }int main()
    {
      unsigned char tbuf[8],tkey[8],outdata[16];
      char outbuf[8];
      Char2Hex(8,"E7FCEFA3478AE100", tbuf);
      Char2Hex(8,"F1F2F3F4F5F6F7F8", tkey);
      RunDes(0,1,(char *)tbuf,(char *)outbuf,8,(char *)tkey,8);
      HexToStr(8,(unsigned char *)outbuf,(char *)outdata);
      printf("buf=%s\n",outdata);
      
      int i;
      for (i=0;i<8;i++)
      {
        tbuf[i]=i+1;
        tkey[i]=i+1;
      }
      RunDes(1,1,(char *)tbuf,(char *)outbuf,8,(char *)tkey,8);
      printf("buf=%s\n",outbuf);
            
    }
      

  8.   

    上面的代码分别是DELPHI的des单元源码和C的源码
      

  9.   

    最好是写一个TestCase来测试。
    需要注意的是,对称加密算法需要考虑
    1. 加密模式(CipherMode),如ECB,CBC。
    2. 填充模式(PaddingMode),当加密区域长度不是单位块长度的整数倍时,如何填充。Delphi Spring Framework已经封装好了常见的Cryptography库,可以参考一下。