{

/* ******** P U B L I C F I E L D S ******** */

/** No options specified. Value is zero. */

public final static int NO_OPTIONS = 0;

/** Specify encoding. */

public final static int ENCODE = 1;

/** Specify decoding. */

public final static int DECODE = 0;

/** Specify that data should be gzip-compressed. */

public final static int GZIP = 2;

/** Don't break lines when encoding (violates strict Base64 specification) */

public final static int DONT_BREAK_LINES = 8;

/**

public final static int URL_SAFE = 16;

/**

public final static int ORDERED = 32;

/* ******** P R I V A T E F I E L D S ******** */

/** Maximum line length (76) of Base64 output. */

private final static int MAX_LINE_LENGTH = 76;

/** The equals sign (=) as a byte. */

private final static byte EQUALS_SIGN = (byte)'=';

/** The new line character (\n) as a byte. */

private final static byte NEW_LINE = (byte)'\n';

/** Preferred encoding. */

private final static String PREFERRED_ENCODING = "UTF-8";

// I think I end up not using the BAD_ENCODING indicator.

//private final static byte BAD_ENCODING = -9; // Indicates error in encoding

private final static byte WHITE_SPACE_ENC = -5; // Indicates white space in encoding

private final static byte EQUALS_SIGN_ENC = -1; // Indicates equals sign in encoding

private static final Logger logger = ESAPI.getLogger("Base64");

/* ******** S T A N D A R D B A S E 6 4 A L P H A B E T ******** */

/** The 64 valid Base64 values. */

//private final static byte[] ALPHABET;

/* Host platform me be something funny like EBCDIC, so we hardcode these values. */

private final static byte[] _STANDARD_ALPHABET =

{

(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',

(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',

(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',

(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',

(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',

(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',

(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',

(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',

(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',

(byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/'

};

/**

private final static byte[] _STANDARD_DECODABET =

{

-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8

-5,-5, // Whitespace: Tab and Linefeed

-9,-9, // Decimal 11 - 12

-5, // Whitespace: Carriage Return

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26

-9,-9,-9,-9,-9, // Decimal 27 - 31

-5, // Whitespace: Space

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42

62, // Plus sign at decimal 43

-9,-9,-9, // Decimal 44 - 46

63, // Slash at decimal 47

52,53,54,55,56,57,58,59,60,61, // Numbers zero through nine

-9,-9,-9, // Decimal 58 - 60

-1, // Equals sign at decimal 61

-9,-9,-9, // Decimal 62 - 64

0,1,2,3,4,5,6,7,8,9,10,11,12,13, // Letters 'A' through 'N'

14,15,16,17,18,19,20,21,22,23,24,25, // Letters 'O' through 'Z'

-9,-9,-9,-9,-9,-9, // Decimal 91 - 96

26,27,28,29,30,31,32,33,34,35,36,37,38, // Letters 'a' through 'm'

39,40,41,42,43,44,45,46,47,48,49,50,51, // Letters 'n' through 'z'

-9,-9,-9,-9 // Decimal 123 - 126

/*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139

};

/**

private final static byte[] _URL_SAFE_ALPHABET =

{

(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',

(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',

(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',

(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',

(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',

(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',

(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',

(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',

(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',

(byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'-', (byte)'_'

};

/**

private final static byte[] _URL_SAFE_DECODABET =

{

-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8

-5,-5, // Whitespace: Tab and Linefeed

-9,-9, // Decimal 11 - 12

-5, // Whitespace: Carriage Return

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26

-9,-9,-9,-9,-9, // Decimal 27 - 31

-5, // Whitespace: Space

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42

-9, // Plus sign at decimal 43

-9, // Decimal 44

62, // Minus sign at decimal 45

-9, // Decimal 46

-9, // Slash at decimal 47

52,53,54,55,56,57,58,59,60,61, // Numbers zero through nine

-9,-9,-9, // Decimal 58 - 60

-1, // Equals sign at decimal 61

-9,-9,-9, // Decimal 62 - 64

0,1,2,3,4,5,6,7,8,9,10,11,12,13, // Letters 'A' through 'N'

14,15,16,17,18,19,20,21,22,23,24,25, // Letters 'O' through 'Z'

-9,-9,-9,-9, // Decimal 91 - 94

63, // Underscore at decimal 95

-9, // Decimal 96

26,27,28,29,30,31,32,33,34,35,36,37,38, // Letters 'a' through 'm'

39,40,41,42,43,44,45,46,47,48,49,50,51, // Letters 'n' through 'z'

-9,-9,-9,-9 // Decimal 123 - 126

/*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139

};

/**

private final static byte[] _ORDERED_ALPHABET =

{

(byte)'-',

(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4',

(byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9',

(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',

(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',

(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',

(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',

(byte)'_',

(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',

(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',

(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',

(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z'

};

/**

private final static byte[] _ORDERED_DECODABET =

{

-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8

-5,-5, // Whitespace: Tab and Linefeed

-9,-9, // Decimal 11 - 12

-5, // Whitespace: Carriage Return

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26

-9,-9,-9,-9,-9, // Decimal 27 - 31

-5, // Whitespace: Space

-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42

-9, // Plus sign at decimal 43

-9, // Decimal 44

0, // Minus sign at decimal 45

-9, // Decimal 46

-9, // Slash at decimal 47

1,2,3,4,5,6,7,8,9,10, // Numbers zero through nine

-9,-9,-9, // Decimal 58 - 60

-1, // Equals sign at decimal 61

-9,-9,-9, // Decimal 62 - 64

11,12,13,14,15,16,17,18,19,20,21,22,23, // Letters 'A' through 'M'

24,25,26,27,28,29,30,31,32,33,34,35,36, // Letters 'N' through 'Z'

-9,-9,-9,-9, // Decimal 91 - 94

37, // Underscore at decimal 95

-9, // Decimal 96

38,39,40,41,42,43,44,45,46,47,48,49,50, // Letters 'a' through 'm'

51,52,53,54,55,56,57,58,59,60,61,62,63, // Letters 'n' through 'z'

-9,-9,-9,-9 // Decimal 123 - 126

/*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139

};

/**

private final static byte[] getAlphabet( int options )

{

if( (options & URL_SAFE) == URL_SAFE ) return _URL_SAFE_ALPHABET;

else if( (options & ORDERED) == ORDERED ) return _ORDERED_ALPHABET;

else return _STANDARD_ALPHABET;

} // end getAlphabet

/**

private final static byte[] getDecodabet( int options )

{

if( (options & URL_SAFE) == URL_SAFE ) return _URL_SAFE_DECODABET;

else if( (options & ORDERED) == ORDERED ) return _ORDERED_DECODABET;

else return _STANDARD_DECODABET;

} // end getAlphabet

/** Defeats instantiation. */

private Base64(){}

/**

public final static void main( String[] args )

{

if( args.length < 3 ){

usage("Not enough arguments.");

} // end if: args.length < 3

else {

String flag = args[0];

String infile = args[1];

String outfile = args[2];

if( flag.equals( "-e" ) ){

Base64.encodeFileToFile( infile, outfile );

} // end if: encode

else if( flag.equals( "-d" ) ) {

Base64.decodeFileToFile( infile, outfile );

} // end else if: decode

else {

usage( "Unknown flag: " + flag );

} // end else

} // end else

} // end main

/**

private final static void usage( String msg )

{

System.err.println( msg );

System.err.println( "Usage: java Base64 -e|-d inputfile outputfile" );

} // end usage

/* ******** E N C O D I N G M E T H O D S ******** */

/**

private static byte[] encode3to4( byte[] b4, byte[] threeBytes, int numSigBytes, int options )

{

encode3to4( threeBytes, 0, numSigBytes, b4, 0, options );

return b4;

} // end encode3to4

/**

private static byte[] encode3to4(

byte[] source, int srcOffset, int numSigBytes,

byte[] destination, int destOffset, int options )

{

byte[] ALPHABET = getAlphabet( options );

// 1 2 3

// 01234567890123456789012345678901 Bit position

// --------000000001111111122222222 Array position from threeBytes

// --------| || || || | Six bit groups to index ALPHABET

// >>18 >>12 >> 6 >> 0 Right shift necessary

// 0x3f 0x3f 0x3f Additional AND

// Create buffer with zero-padding if there are only one or two

// significant bytes passed in the array.

// We have to shift left 24 in order to flush out the 1's that appear

// when Java treats a value as negative that is cast from a byte to an int.

int inBuff = ( numSigBytes > 0 ? ((source[ srcOffset ] << 24) >>> 8) : 0 )

| ( numSigBytes > 1 ? ((source[ srcOffset + 1 ] << 24) >>> 16) : 0 )

| ( numSigBytes > 2 ? ((source[ srcOffset + 2 ] << 24) >>> 24) : 0 );

switch( numSigBytes )

{

case 3:

destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];

destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];

destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];

destination[ destOffset + 3 ] = ALPHABET[ (inBuff ) & 0x3f ];

return destination;

case 2:

destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];

destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];

destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];

destination[ destOffset + 3 ] = EQUALS_SIGN;

return destination;

case 1:

destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];

destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];

destination[ destOffset + 2 ] = EQUALS_SIGN;

destination[ destOffset + 3 ] = EQUALS_SIGN;

return destination;

default:

return destination;

} // end switch

} // end encode3to4

/**

public static String encodeObject( java.io.Serializable serializableObject )

{

return encodeObject( serializableObject, NO_OPTIONS );

} // end encodeObject

/**

public static String encodeObject( java.io.Serializable serializableObject, int options )

{

// Streams

java.io.ByteArrayOutputStream baos = null;

java.io.OutputStream b64os = null;

java.io.ObjectOutputStream oos = null;

java.util.zip.GZIPOutputStream gzos = null;

// Isolate options

int gzip = (options & GZIP);

int dontBreakLines = (options & DONT_BREAK_LINES);

try

{

// ObjectOutputStream -> (GZIP) -> Base64 -> ByteArrayOutputStream

baos = new java.io.ByteArrayOutputStream();

b64os = new Base64.OutputStream( baos, ENCODE | options );

// GZip?

if( gzip == GZIP )

{

gzos = new java.util.zip.GZIPOutputStream( b64os );

oos = new java.io.ObjectOutputStream( gzos );

} // end if: gzip

else

oos = new java.io.ObjectOutputStream( b64os );

oos.writeObject( serializableObject );

} // end try

catch( java.io.IOException e )

{

logger.error( Logger.SECURITY, "Problem writing object", e );

return null;

} // end catch

finally

{

try{ oos.close(); } catch( Exception e ){}

try{ gzos.close(); } catch( Exception e ){}

try{ b64os.close(); } catch( Exception e ){}

try{ baos.close(); } catch( Exception e ){}

} // end finally

// Return value according to relevant encoding.

try

{

return new String( baos.toByteArray(), PREFERRED_ENCODING );

} // end try

catch (java.io.UnsupportedEncodingException uue)

{

return new String( baos.toByteArray() );

} // end catch

} // end encode

/**

public static String encodeBytes( byte[] source )

{

return encodeBytes( source, 0, source.length, NO_OPTIONS );

} // end encodeBytes

/**

public static String encodeBytes( byte[] source, int options )

{

return encodeBytes( source, 0, source.length, options );

} // end encodeBytes

/**

public static String encodeBytes( byte[] source, int off, int len )

{

return encodeBytes( source, off, len, NO_OPTIONS );

} // end encodeBytes

/**

public static String encodeBytes( byte[] source, int off, int len, int options )

{

// Isolate options

int dontBreakLines = ( options & DONT_BREAK_LINES );

int gzip = ( options & GZIP );

// Compress?

if( gzip == GZIP )

{

java.io.ByteArrayOutputStream baos = null;

java.util.zip.GZIPOutputStream gzos = null;

Base64.OutputStream b64os = null;

try

{

// GZip -> Base64 -> ByteArray

baos = new java.io.ByteArrayOutputStream();

b64os = new Base64.OutputStream( baos, ENCODE | options );

gzos = new java.util.zip.GZIPOutputStream( b64os );

gzos.write( source, off, len );

gzos.close();

} // end try

catch( java.io.IOException e )

{

logger.error( Logger.SECURITY, "Problem writing gzip stream", e );

return null;

} // end catch

finally

{

try{ gzos.close(); } catch( Exception e ){}

try{ b64os.close(); } catch( Exception e ){}

try{ baos.close(); } catch( Exception e ){}

} // end finally

// Return value according to relevant encoding.

try

{

return new String( baos.toByteArray(), PREFERRED_ENCODING );

} // end try

catch (java.io.UnsupportedEncodingException uue)

{

return new String( baos.toByteArray() );

} // end catch

} // end if: compress

// Else, don't compress. Better not to use streams at all then.

else

{

// Convert option to boolean in way that code likes it.

boolean breakLines = dontBreakLines == 0;

int len43 = len * 4 / 3;

byte[] outBuff = new byte[ ( len43 ) // Main 4:3

+ ( (len % 3) > 0 ? 4 : 0 ) // Account for padding

+ (breakLines ? ( len43 / MAX_LINE_LENGTH ) : 0) ]; // New lines

int d = 0;

int e = 0;

int len2 = len - 2;

int lineLength = 0;

for( ; d < len2; d+=3, e+=4 )

{

encode3to4( source, d+off, 3, outBuff, e, options );

lineLength += 4;

if( breakLines && lineLength == MAX_LINE_LENGTH )

{

outBuff[e+4] = NEW_LINE;

e++;

lineLength = 0;

} // end if: end of line

} // en dfor: each piece of array

if( d < len )

{

encode3to4( source, d+off, len - d, outBuff, e, options );

e += 4;

} // end if: some padding needed

// Return value according to relevant encoding.

try

{

return new String( outBuff, 0, e, PREFERRED_ENCODING );

} // end try

catch (java.io.UnsupportedEncodingException uue)

{

return new String( outBuff, 0, e );

} // end catch

} // end else: don't compress

} // end encodeBytes

/**

private static int decode4to3( byte[] source, int srcOffset, byte[] destination, int destOffset, int options )

{

byte[] DECODABET = getDecodabet( options );

// Example: Dk==

if( source[ srcOffset + 2] == EQUALS_SIGN )

{

// Two ways to do the same thing. Don't know which way I like best.

//int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )

// | ( ( DECODABET[ source[ srcOffset + 1] ] << 24 ) >>> 12 );

int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )

| ( ( DECODABET[ source[ srcOffset + 1] ] & 0xFF ) << 12 );

destination[ destOffset ] = (byte)( outBuff >>> 16 );

return 1;

}

// Example: DkL=

else if( source[ srcOffset + 3 ] == EQUALS_SIGN )

{

// Two ways to do the same thing. Don't know which way I like best.

//int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )

// | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )

// | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 );

int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )

| ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )

| ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) << 6 );

destination[ destOffset ] = (byte)( outBuff >>> 16 );

destination[ destOffset + 1 ] = (byte)( outBuff >>> 8 );

return 2;

}

// Example: DkLE

else

{

try{

// Two ways to do the same thing. Don't know which way I like best.

//int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )

// | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )

// | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 )

// | ( ( DECODABET[ source[ srcOffset + 3 ] ] << 24 ) >>> 24 );

int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )

| ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )

| ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) << 6)

| ( ( DECODABET[ source[ srcOffset + 3 ] ] & 0xFF ) );

destination[ destOffset ] = (byte)( outBuff >> 16 );

destination[ destOffset + 1 ] = (byte)( outBuff >> 8 );

destination[ destOffset + 2 ] = (byte)( outBuff );

return 3;

}catch( Exception e){

logger.error( Logger.SECURITY, "Problem writing object", e );

logger.error( Logger.SECURITY, ""+source[srcOffset]+ ": " + ( DECODABET[ source[ srcOffset ] ] ) );

logger.error( Logger.SECURITY, ""+source[srcOffset+1]+ ": " + ( DECODABET[ source[ srcOffset + 1 ] ] ) );

logger.error( Logger.SECURITY, ""+source[srcOffset+2]+ ": " + ( DECODABET[ source[ srcOffset + 2 ] ] ) );

logger.error( Logger.SECURITY, ""+source[srcOffset+3]+ ": " + ( DECODABET[ source[ srcOffset + 3 ] ] ) );

return -1;

} // end catch

}

} // end decodeToBytes

/**

public static byte[] decode( byte[] source, int off, int len, int options )

{

byte[] DECODABET = getDecodabet( options );

int len34 = len * 3 / 4;

byte[] outBuff = new byte[ len34 ]; // Upper limit on size of output

int outBuffPosn = 0;

byte[] b4 = new byte[4];

int b4Posn = 0;

int i = 0;

byte sbiCrop = 0;

byte sbiDecode = 0;

for( i = off; i < off+len; i++ )

{

sbiCrop = (byte)(source[i] & 0x7f); // Only the low seven bits

sbiDecode = DECODABET[ sbiCrop ];

if( sbiDecode >= WHITE_SPACE_ENC ) // White space, Equals sign or better

{

if( sbiDecode >= EQUALS_SIGN_ENC )

{

b4[ b4Posn++ ] = sbiCrop;

if( b4Posn > 3 )

{

outBuffPosn += decode4to3( b4, 0, outBuff, outBuffPosn, options );

b4Posn = 0;

// If that was the equals sign, break out of 'for' loop

if( sbiCrop == EQUALS_SIGN )

break;

} // end if: quartet built

} // end if: equals sign or better

} // end if: white space, equals sign or better

else

{

logger.error( Logger.SECURITY, "Bad Base64 input character at " + i + ": " + source[i] + "(decimal)" );

return null;

} // end else:

} // each input character

byte[] out = new byte[ outBuffPosn ];

System.arraycopy( outBuff, 0, out, 0, outBuffPosn );

return out;

} // end decode

/**

public static byte[] decode( String s )

{

return decode( s, NO_OPTIONS );

}

/**

public static byte[] decode( String s, int options )

{

byte[] bytes;

try

{

bytes = s.getBytes( PREFERRED_ENCODING );

} // end try

catch( java.io.UnsupportedEncodingException uee )

{

bytes = s.getBytes();

} // end catch

//</change>

// Decode

bytes = decode( bytes, 0, bytes.length, options );

// Check to see if it's gzip-compressed

// GZIP Magic Two-Byte Number: 0x8b1f (35615)

if( bytes != null && bytes.length >= 4 )