bytequeue.java

一个木马程序源码

/*
 *   File:  ByteQueue.java
 *
 *   This Class queues up bits, then returns them later as needed.
 *   Used for storing truly random entropy from keystrokes of the user.
 *
 *   version 1.02 v1a
 *   Copyright 1998, 1999 by Hush Communications Corporation, BWI
 */

package hushcode;

import java.util.Vector;
import hushcode.Conversions;


final class ByteQueue
{
   private Vector bytes;
   private int currentByte;
   private int currentBit;
   private int bitsEnqueued;
   private Byte zero = new Byte((byte)0);


   ByteQueue()
   {
      bytes = new Vector();
      currentByte = 0; 
      currentBit = 7;
      bytes.addElement(zero);
   }


   /*  This method accepts a number and enqueues the numBits least significant bits.
    *  The number must be positive, and no more than 63 bits may be enqueued at a time.
    */
   void enqueueBits(long number, int numBits)
   {   
      long p2 = (long)(Math.pow(2,(double)(numBits-1)));
      if (number-p2 > p2) number = number%(p2*2);
      for (long n=p2; ;n=n/2)
      {
         if (number%n==number) currentBit--;
         else 
         {
            byte newByte = (byte)
               ((int)((Byte)(bytes.elementAt(currentByte))).byteValue() | (1<<currentBit--));
            bytes.setElementAt(new Byte(newByte),currentByte);
         }
         if (currentBit<0)
         {
            currentBit = 7;
            currentByte++;
            bytes.setSize(currentByte);
            bytes.addElement(zero);
         }
         number = number % n;
         if (n==1) break;
      }
      bitsEnqueued = bitsEnqueued+numBits;    
   }


   int bitsEnqueued() { return bitsEnqueued; }

   int bytesAvailable() { return currentByte; }

   int longsAvailable() { return currentByte/8; }


   byte[] dequeueBytes(int numBytes)
   {
      byte[] returnBytes = new byte[numBytes];
      for (int n=0; n<numBytes; n++)
         returnBytes[n] = dequeueByte();
      return returnBytes; 
   }


   byte dequeueByte()
   {
      byte returnByte = ((Byte)bytes.firstElement()).byteValue();
      bytes.removeElementAt(0);
      currentByte--;
      return returnByte;
   }


   long dequeueLong()
   {
      byte[] rBytes = new byte[8];
      for (int n=0; n<8; n++)
         rBytes[n] = dequeueByte();
      return Conversions.bytesToLong(rBytes); 
   }

}   //  end ByteQueue