blowfishcipher.java

一个木马程序源码

/*
 *   File:  BlowfishCipher.java
 *
 *   The Blowfish symmetric encryption algorithm, created by Bruce Schneier.
 *   64-bit (8 byte) block cipher.
 *   Does not work (not tested) on message sizes over 2 billion bits long.
 *
 *   version 1.02 v1a
 *   Copyright 1998, 1999 by Hush Communications Corporation, BWI
 */

package hushcode;

import java.util.Random;


final class BlowfishCipher
{
   private int[]
      S0 = new int[256],
      S1 = new int[256],
      S2 = new int[256],
      S3 = new int[256],
      P  = new int[18];

   private int
      P0, P1, P2, P3, P4, P5, P6, P7, P8, P9,
      P10, P11, P12, P13, P14, P15, P16, P17;


   BlowfishCipher() {  }


   // Set key of this BlowfishCipher from a String
   void setKey(String skey)
   {
      byte[] key = new byte[skey.length()];
      skey.getBytes(0, skey.length(), key, 0);
      setKey(key);
   }


   // Set key of this BlowfishCipher from a byte array
   void setKey(byte[] key)
   {
      int i, j, k, l, len = key.length;

      int[]    Ptemp = {0, 0};
      int[][]  Stemp = {S0, S1, S2, S3};

      System.arraycopy(Pinit, 0, P, 0, 18);

      for(i = 0, j = 0; j < 4; i += 256, j++)
         System.arraycopy(Sinit, i, Stemp[j], 0, 256);

      // Generate the P-values for this key
      for (i = 0, j = 0, l = 0; i < 18; P[i++] ^= l)
         for (k = 0; k < 4; k++, j++)
            l = (l << 8) | (key[j %= len] & 0xff);

      encrypt(Ptemp, 0, P, 0);
      for (i = 0; i < 16; i += 2) encrypt(P, i, P, i + 2);

      // Get rid of the slow P-array (ugly, but faster)..
      P0    = P[ 0];    P1    = P[ 1];    P2    = P[ 2];    P3    = P[ 3];
      P4    = P[ 4];    P5    = P[ 5];    P6    = P[ 6];    P7    = P[ 7];
      P8    = P[ 8];    P9    = P[ 9];    P10   = P[10];    P11   = P[11];
      P12   = P[12];    P13   = P[13];    P14   = P[14];    P15   = P[15];
      P16   = P[16];    P17   = P[17];

      // Generate the final S-values
      S0[0] = P16; S0[1] = P17;

      k = 0; l = 0;

      for(i = 0; i < 4; i++)
         for (j = 0; j < 256; k = i, l = j, j += 2)
            encrypt(Stemp[k], l, Stemp[i], j);
   }


   // Encrypt two integers, not optimized, used by the setKey() method.
   private void encrypt(int in[], int inOff, int[] out, int outOff)
   {
      int L = in[inOff++] ^ P[0], R = in[inOff], i = 0;

      while(i < 16)  {
         R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P[++i];
         L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P[++i];
      }
        
      out[outOff++] = R ^ P[17];
      out[outOff  ] = L;
   }


   /**
    * This method accepts a string and returns an array
    * of bytes encrypted by CBC Blowfish.
    */
   byte[] stringEncrypt(String inString)
   {
      byte[] returnBytes = encrypt(inString.getBytes());
      return returnBytes;
   }


   /**
    * This method accepts a byte array and returns an array
    * of bytes encrypted by CBC Blowfish.
    *
    *  Pad using PK1 and leave space for the initializationi vector.???
    */
   byte[] encrypt(byte[] bytes)
   {
      int leftoverspace = 8 - (bytes.length%8); 

      byte[] inBytes = new byte[bytes.length + leftoverspace + 8];

      for (int n=bytes.length+8;n<bytes.length+leftoverspace+8;n++)
         inBytes[n]=(byte)leftoverspace;    

      /* Set a 64 bit initialization vector
       */
      Random rand = new Random();
      byte[] iv = new byte[8];
      rand.nextBytes(iv);   
      System.arraycopy(iv, 0, inBytes, 0, 8);

      // Copy in plain text
      System.arraycopy(bytes, 0, inBytes, 8, bytes.length);

      /* encrypt
       * including CBC with initialization vector.
       * For no good reason we also encrypt the initialization vector
       */
      byte[] outBytes = new byte[inBytes.length];

      encrypt(inBytes, 0, outBytes, 0);
      for (int xx=8;xx<16;xx++)
         inBytes[xx]^=inBytes[xx-8];
      encrypt(inBytes,8,outBytes,8);
      for (int x=16;x<inBytes.length;x=x+8) 
      {
         for (int xx=0; xx<8; xx++)
            inBytes[x+xx] ^= outBytes[x+xx-8]; 
         encrypt(inBytes, x, outBytes, x);
      }
      return outBytes;
   }

 
   /**
    * This method accepts an array of bytes 
    * encrypted by CBC Blowfish and returns a string.
    */
   String stringDecrypt(byte[] inBytes)
   {
      String outString = new String(decrypt(inBytes));
      return outString;
   }


   /**
    * This method accepts an array of bytes 
    * encrypted by CBC Blowfish and returns a string.
    */
   byte[] decrypt(byte[] inBytes)
   {
      byte[] outBytes = new byte[inBytes.length];
      decrypt(inBytes,0,outBytes,0);
      decrypt(inBytes,8,outBytes,8);
      for (int xx=0; xx<8; xx++)
         outBytes[8+xx]^=outBytes[xx];
      for (int x=16; x<inBytes.length; x=x+8) 
      {
         decrypt(inBytes,x,outBytes,x);
         for (int xx=0; xx<8; xx++)
            outBytes[x+xx] ^= inBytes[x+xx-8];  
      }

      //  Remove padding and initialization vector;
      int leftoverspace = outBytes[outBytes.length-1];

      byte[] bytes = new byte[outBytes.length-(leftoverspace+8)];
      System.arraycopy(outBytes, 8, bytes, 0, bytes.length); 
      return bytes;
   }


   // Encrypt a block of eight bytes as fast as possible ..
   void encrypt (byte[] in, int off, byte[] out, int outOff)
   {
      int L = (((in[off++] & 0xff) << 24)    | ((in[off++] & 0xff) << 16) |
               ((in[off++] & 0xff) <<  8)    |  (in[off++] & 0xff) ) ^ P0 ,
          R =  ((in[off++] & 0xff) << 24)    | ((in[off++] & 0xff) << 16) |
               ((in[off++] & 0xff) <<  8)    |  (in[off  ] & 0xff);

      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P1;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P2;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P3;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P4;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P5;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P6;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P7;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P8;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P9;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P10;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P11;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P12;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P13;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P14;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P15;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P16;
      R ^= P17;

      out[outOff++] = (byte)((R >>> 24) & 0xff);
      out[outOff++] = (byte)((R >>> 16) & 0xff);
      out[outOff++] = (byte)((R >>>  8) & 0xff);
      out[outOff++] = (byte)( R         & 0xff);
      out[outOff++] = (byte)((L >>> 24) & 0xff);
      out[outOff++] = (byte)((L >>> 16) & 0xff);
      out[outOff++] = (byte)((L >>>  8) & 0xff);
      out[outOff  ] = (byte)( L         & 0xff);
   }


   // Decrypt a block of eight bytes
   void decrypt (byte[] in, int off, byte[] out, int outOff)
   {
      int L = (((in[off++] & 0xff) << 24) | ((in[off++] & 0xff) << 16) |
               ((in[off++] & 0xff) <<  8) |  (in[off++] & 0xff) ) ^ P17,
          R =  ((in[off++] & 0xff) << 24) | ((in[off++] & 0xff) << 16) |
               ((in[off++] & 0xff) <<  8) |  (in[off  ] & 0xff);

      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P16;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P15;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P14;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P13;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P12;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P11;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P10;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P9;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P8;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P7;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P6;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P5;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P4;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P3;
      R ^= (((S0[(L>>>24)&0xff]+S1[(L>>>16)&0xff])^S2[(L>>>8)&0xff])+S3[L&0xff])^P2;
      L ^= (((S0[(R>>>24)&0xff]+S1[(R>>>16)&0xff])^S2[(R>>>8)&0xff])+S3[R&0xff])^P1;
      R ^= P0;

      out[outOff++] = (byte)((R >>> 24)    & 0xff);
      out[outOff++] = (byte)((R >>> 16)    & 0xff);
      out[outOff++] = (byte)((R >>>  8)    & 0xff);
      out[outOff++] = (byte)( R            & 0xff);
      out[outOff++] = (byte)((L >>> 24)    & 0xff);
      out[outOff++] = (byte)((L >>> 16)    & 0xff);
      out[outOff++] = (byte)((L >>>  8)    & 0xff);
      out[outOff  ] = (byte)( L            & 0xff);
   }


   private static final int[]
      Pinit = {