Wraps a stream that has been exported to import the data in readable form : InputStream « File Input Output « Java






Wraps a stream that has been exported to import the data in readable form

      
/*
 * ImportStream.java Created Sep 9, 2010 by Andrew Butler, PSL
 */
//package prisms.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

/** Wraps a stream that has been exported to import the data in readable form */
public class ImportStream extends java.io.InputStream
{
  private java.io.InputStream theInput;

  /**
   * Wraps a stream with an import stream
   * 
   * @param wrap The exported stream to wrap
   * @throws IOException If an error occurs wrapping the stream
   */
  public ImportStream(java.io.InputStream wrap) throws IOException
  {
    java.util.zip.ZipInputStream zis;
    zis = new java.util.zip.ZipInputStream(ObfuscatingStream.unobfuscate(wrap));
    zis.getNextEntry();
    theInput = zis;
  }

  @Override
  public int read() throws IOException
  {
    return theInput.read();
  }

  @Override
  public int read(byte [] b) throws IOException
  {
    return theInput.read(b);
  }

  @Override
  public int read(byte [] b, int off, int len) throws IOException
  {
    return theInput.read(b, off, len);
  }

  @Override
  public long skip(long n) throws IOException
  {
    return theInput.skip(n);
  }

  @Override
  public int available() throws IOException
  {
    return theInput.available();
  }

  @Override
  public boolean markSupported()
  {
    return theInput.markSupported();
  }

  @Override
  public synchronized void mark(int readlimit)
  {
    theInput.mark(readlimit);
  }

  @Override
  public synchronized void reset() throws IOException
  {
    theInput.reset();
  }

  @Override
  public void close() throws IOException
  {
    theInput.close();
  }

}

/**
 * A utility class that allows for easy simple obfuscation of streamed data
 */
 class ObfuscatingStream
{
  private static final char [] HEX_CHARS = new char [] {'0', '1', '2', '3', '4', '5', '6', '7',
    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

  /**
   * A class that obfuscates data as it is written to a binary stream
   */
  public static class ObfuscatingOutputStream extends OutputStream
  {
    private OutputStream theOS;

    private int theWarp;

    private int theCount;

    ObfuscatingOutputStream(OutputStream os)
    {
      theOS = os;
      theWarp = -1;
    }

    /**
     * @see java.io.OutputStream#write(int)
     */
    @Override
    public void write(int b) throws IOException
    {
      if(theWarp < 0)
      {
        theWarp = (int) (Math.random() * 8);
        theOS.write(theWarp);
      }
      int shift = (theWarp + theCount) % 8;
      theCount++;
      int toWrite = b & 0xff;
      toWrite = ((toWrite >> shift) | (toWrite << (8 - shift))) & 0xff;
      theOS.write(toWrite);
    }
  }

  /**
   * A class the unobfuscates data that was obfuscated by an {@link ObfuscatingOutputStream} as it
   * is read from an input stream
   */
  public static class UnobfuscatingInputStream extends InputStream
  {
    private InputStream theIS;

    private int theWarp;

    private int theCount;

    UnobfuscatingInputStream(InputStream is)
    {
      theIS = is;
      theWarp = -1;
    }

    /**
     * @see java.io.InputStream#read()
     */
    @Override
    public int read() throws IOException
    {
      if(theWarp < 0)
        theWarp = theIS.read();
      int read = theIS.read();
      if(read < 0)
        return read;
      int shift = (theWarp + theCount) % 8;
      theCount++;
      int ret = read & 0xff;
      ret = ((ret << shift) | (ret >> (8 - shift))) & 0xff;
      return ret;
    }
  }

  /**
   * Obfuscates an output stream
   * 
   * @param os The binary output stream for this utility to write obfuscated data to
   * @return The output stream for the calling method to write unobfuscated data
   */
  public static OutputStream obfuscate(OutputStream os)
  {
    return new ObfuscatingOutputStream(os);
  }

  /**
   * Unobfuscates an input stream
   * 
   * @param is The binary input stream for this utililty to read obfuscated data from
   * @return The input stream for the calling method to read the unobfuscated data from
   */
  public static InputStream unobfuscate(InputStream is)
  {
    return new UnobfuscatingInputStream(is);
  }

  /**
   * Obfuscates or unobfuscates the second command-line argument, depending on whether the first
   * argument starts with "o" or "u"
   * 
   * @param args Command-line arguments
   * @throws IOException If an error occurs obfuscating or unobfuscating
   */
  public static void main(String [] args) throws IOException
  {
    InputStream input = new ByteArrayInputStream(args[1].getBytes());
    StringBuilder toPrint = new StringBuilder();
    if(args[0].startsWith("o"))
    {
      ByteArrayOutputStream bytes = new ByteArrayOutputStream();
      OutputStream out = obfuscate(bytes);
      int read = input.read();
      while(read >= 0)
      {
        out.write(read);
        read = input.read();
      }
      byte [] receiptBytes = bytes.toByteArray();
      for(int b = 0; b < receiptBytes.length; b++)
      {
        int chr = (receiptBytes[b] + 256) % 256;
        toPrint.append(HEX_CHARS[chr >>> 4]);
        toPrint.append(HEX_CHARS[chr & 0xf]);
      }
    }
    else if(args[0].startsWith("u"))
    {
      input = unobfuscate(input);
      InputStreamReader reader = new InputStreamReader(input);

      int read = reader.read();
      while(read >= 0)
      {
        toPrint.append((char) read);
        read = reader.read();
      }
    }
    else
      throw new IllegalArgumentException("First argument must start with o or u");
    System.out.println(toPrint.toString());
  }
}

   
    
    
    
    
    
  








Related examples in the same category

1.Creating an input or output stream on a ByteBuffer
2.Creating a Manifest for a JAR File
3.Convert InputStream to String
4.An limited-data-size input stream
5.An input stream which reads sequentially from multiple sources
6.Combined InputStream
7.Size Limit InputStream
8.Minimal InputStream subclass to fetch bytes form a String
9.Read and return the entire contents of the supplied InputStream. This method always closes the stream when finished reading.
10.Compare two InputStream
11.Read and return the entire contents of the supplied InputStream.
12.Deserializes an object from an input stream.
13.Reads at most certain bytes from input stream and returns them as a byte array.
14.Convert Reader to InputStream
15.A trace of the data that is being retrieved from an input stream
16.EOLConvertingInputStream: InputStream which converts \r bytes not followed by \n and \n not preceded by \r to \r\n.
17.A line reading wrapper that works with byte streams.
18.Smart Encoding InputStream
19.This input stream wrapper closes the base input stream when fully read.
20.LZFInputStream and LZFOutputStream
21.Random input stream