ftp://ftp.isi.edu/in-notes/rfc2045.txt.
*
* All methods of this class are static and thread-safe.
*
* @since 1.0
* @author Anne Anderson
*/
class Base64
{
/*
* ASCII white-space characters. These are the ones recognized by the
* C and Java language [pre-processors].
*/
private static final char SPACE = 0x20; /* space, or blank, character */
private static final char ETX = 0x04; /* end-of-text character */
private static final char VTAB = 0x0b; /* vertical tab character */
private static final char FF = 0x0c; /* form-feed character */
private static final char HTAB = 0x09; /* horizontal tab character */
private static final char LF = 0x0a; /* line feed character */
private static final char ALTLF = 0x13; /* line feed on some systems */
private static final char CR = 0x0d; /* carriage-return character */
/*
* The character used to pad out a 4-character Base64-encoded block,
* or "quantum".
*/
private static char PAD = '=';
/*
* String used for BASE64 encoding and decoding.
*
* For index values 0-63, the character at each index is the Base-64
* encoded value of the index value. Index values beyond 63 are never
* referenced during encoding, but are used in this implementation to
* help in decoding. The character at index 64 is the Base64 pad
* character '='.
*
* Charaters in index positions 0-64 MUST NOT be moved or altered, as
* this will break the implementation.
*
* The characters after index 64 are white space characters that should be
* ignored in Base64-encoded input strings while doing decoding. Note that
* the white-space character set should include values used on various
* platforms, since a Base64-encoded value may have been generated on a
* non-Java platform. The values included here are those used in Java and
* in C.
*
* The white-space character set may be modified without affecting the
* implementation of the encoding algorithm.
*/
private static final String BASE64EncodingString =
"ABCDEFGHIJ"
+ "KLMNOPQRST"
+ "UVWXYZabcd"
+ "efghijklmn"
+ "opqrstuvwx"
+ "yz01234567"
+ "89+/"
+ "="
+ SPACE + ETX + VTAB + FF + HTAB + LF + ALTLF + CR;
// Index of pad character in Base64EncodingString
private static final int PAD_INDEX = 64;
/*
* The character in Base64EncodingString with the maximum
* character value in Unicode.
*/
private static final int MAX_BASE64_CHAR = 'z';
/*
* Array for mapping encoded characters to decoded values.
* This array is initialized when needed by calling
* initDecodeArray(). Only includes entries up to
* MAX_BASE64_CHAR.
*/
private static int [] Base64DecodeArray = null;
/*
* State values used for decoding a quantum of four encoded input
* characters as follows.
*
* Initial state: NO_CHARS_DECODED
* NO_CHARS_DECODED: no characters have been decoded
* on encoded char: decode char into output quantum;
* new state: ONE_CHAR_DECODED
* otherwise: Exception
* ONE_CHAR_DECODED: one character has been decoded
* on encoded char: decode char into output quantum;
* new state: TWO_CHARS_DECODED
* otherwise: Exception
* TWO_CHARS_DECODED: two characters have been decoded
* on encoded char: decode char into output quantum;
* new state: THREE_CHARS_DECODED
* on pad: write quantum byte 0 to output;
* new state: PAD_THREE_READ
* THREE_CHARS_DECODED: three characters have been decoded
* on encoded char: decode char into output quantum;
* write quantum bytes 0-2 to output;
* new state: NO_CHARS_DECODED
* on pad: write quantum bytes 0-1 to output;
* new state: PAD_FOUR_READ
* PAD_THREE_READ: pad character has been read as 3rd of 4 chars
* on pad: new state: PAD_FOUR_READ
* otherwise: Exception
* PAD_FOUR_READ: pad character has been read as 4th of 4 char
* on any char: Exception
*
* The valid terminal states are NO_CHARS_DECODED and PAD_FOUR_READ.
*/
private static final int NO_CHARS_DECODED = 0;
private static final int ONE_CHAR_DECODED = 1;
private static final int TWO_CHARS_DECODED = 2;
private static final int THREE_CHARS_DECODED = 3;
private static final int PAD_THREE_READ = 5;
private static final int PAD_FOUR_READ = 6;
/**
* The maximum number of groups that should be encoded
* onto a single line (so we don't exceed 76 characters
* per line).
*/
private static final int MAX_GROUPS_PER_LINE = 76/4;
/**
* Encodes the input byte array into a Base64-encoded
* String. The output String
* has a CR LF (0x0d 0x0a) after every 76 bytes, but
* not at the end.
*
* WARNING: If the input byte array is modified
* while encoding is in progress, the output is undefined.
*
* @param binaryValue the byte array to be encoded
*
* @return the Base64-encoded String
*/
public static String encode(byte[] binaryValue) {
int binaryValueLen = binaryValue.length;
// Estimated output length (about 1.4x input, due to CRLF)
int maxChars = (binaryValueLen * 7) / 5;
// Buffer for encoded output
StringBuffer sb = new StringBuffer(maxChars);
int groupsToEOL = MAX_GROUPS_PER_LINE;
// Convert groups of 3 input bytes, with pad if < 3 in final
for (int binaryValueNdx = 0; binaryValueNdx < binaryValueLen;
binaryValueNdx += 3) {
// Encode 1st 6-bit group
int group1 = (binaryValue[binaryValueNdx] >> 2) & 0x3F;
sb.append(BASE64EncodingString.charAt(group1));
// Encode 2nd 6-bit group
int group2 = (binaryValue[binaryValueNdx] << 4) & 0x030;
if ((binaryValueNdx+1) < binaryValueLen) {
group2 = group2
| ((binaryValue[binaryValueNdx+1] >> 4) & 0xF);
}
sb.append(BASE64EncodingString.charAt(group2));
// Encode 3rd 6-bit group
int group3;
if ((binaryValueNdx+1) < binaryValueLen) {
group3 = (binaryValue[binaryValueNdx+1] << 2) & 0x03C;
if ((binaryValueNdx+2) < binaryValueLen) {
group3 = group3
| ((binaryValue[binaryValueNdx+2] >> 6) & 0x3);
}
} else {
group3 = PAD_INDEX;
}
sb.append(BASE64EncodingString.charAt(group3));
// Encode 4th 6-bit group
int group4;
if ((binaryValueNdx+2) < binaryValueLen) {
group4 = binaryValue[binaryValueNdx+2] & 0x3F;
} else {
group4 = PAD_INDEX;
}
sb.append(BASE64EncodingString.charAt(group4));
// After every MAX_GROUPS_PER_LINE groups, insert CR LF.
// Unless this is the final line, in which case we skip that.
groupsToEOL = groupsToEOL - 1;
if (groupsToEOL == 0) {
groupsToEOL = MAX_GROUPS_PER_LINE;
if ((binaryValueNdx+3) <= binaryValueLen) {
sb.append(CR);
sb.append(LF);
}
}
}
return sb.toString();
}
/**
* Initializes Base64DecodeArray, if this hasn't already been
* done.
*/
private static void initDecodeArray() {
if (Base64DecodeArray != null)
return;
int [] ourArray = new int [MAX_BASE64_CHAR+1];
for (int i = 0; i <= MAX_BASE64_CHAR; i++)
ourArray[i] = BASE64EncodingString.indexOf(i);
Base64DecodeArray = ourArray;
}
/**
* Decodes a Base64-encoded String. The result
* is returned in a byte array that should match the original
* binary value (before encoding). Whitespace characters
* in the input String are ignored.
*
* If the ignoreBadChars parameter is
* true, characters that are not allowed
* in a BASE64-encoded string are ignored. Otherwise,
* they cause an IOException to be raised.
*
* @param encoded a String containing a
* Base64-encoded value
* @param ignoreBadChars If true, bad characters
* are ignored. Otherwise, they cause
* an IOException to be
* raised.
*
* @return a byte array containing the decoded value
*
* @throws IOException if the input String is not
* a valid Base64-encoded value
*/
public static byte[] decode(String encoded, boolean ignoreBadChars)
throws IOException
{
int encodedLen = encoded.length();
int maxBytes = (encodedLen/4)*3; /* Maximum possible output bytes */
ByteArrayOutputStream ba = /* Buffer for decoded output */
new ByteArrayOutputStream(maxBytes);
byte[] quantum = new byte[3]; /* one output quantum */
// ensure Base64DecodeArray is initialized
initDecodeArray();
/*
* Every 4 encoded characters in input are converted to 3 bytes of
* output. This is called one "quantum". Each encoded character is
* mapped to one 6-bit unit of the output. Whitespace characters in
* the input are passed over; they are not included in the output.
*/
int state = NO_CHARS_DECODED;
for (int encodedNdx = 0; encodedNdx < encodedLen; encodedNdx++) {
// Turn encoded char into decoded value
int encodedChar = encoded.charAt(encodedNdx);
int decodedChar;
if (encodedChar > MAX_BASE64_CHAR)
decodedChar = -1;
else
decodedChar = Base64DecodeArray[encodedChar];
// Handle white space and invalid characters
if (decodedChar == -1) {
if (ignoreBadChars)
continue;
throw new IOException("Invalid character");
}
if (decodedChar > PAD_INDEX) { /* whitespace */
continue;
}
// Handle valid characters
switch (state) {
case NO_CHARS_DECODED:
if (decodedChar == PAD_INDEX) {
throw new IOException("Pad character in invalid position");
}
quantum[0] = (byte) ((decodedChar << 2) & 0xFC);
state = ONE_CHAR_DECODED;
break;
case ONE_CHAR_DECODED:
if (decodedChar == PAD_INDEX) {
throw new IOException("Pad character in invalid position");
}
quantum[0] = (byte) (quantum[0] | ((decodedChar >> 4) & 0x3));
quantum[1] = (byte) ((decodedChar << 4) & 0xF0);
state = TWO_CHARS_DECODED;
break;
case TWO_CHARS_DECODED:
if (decodedChar == PAD_INDEX) {
ba.write(quantum, 0, 1);
state = PAD_THREE_READ;
} else {
quantum[1] =
(byte) (quantum[1] | ((decodedChar >> 2) & 0x0F));
quantum[2] = (byte) ((decodedChar << 6) & 0xC0);
state = THREE_CHARS_DECODED;
}
break;
case THREE_CHARS_DECODED:
if (decodedChar == PAD_INDEX) {
ba.write(quantum, 0, 2);
state = PAD_FOUR_READ;
} else {
quantum[2] = (byte) (quantum[2] | decodedChar);
ba.write(quantum, 0, 3);
state = NO_CHARS_DECODED;
}
break;
case PAD_THREE_READ:
if (decodedChar != PAD_INDEX) {
throw new IOException("Missing pad character");
}
state = PAD_FOUR_READ;
break;
case PAD_FOUR_READ:
throw new IOException("Invalid input follows pad character");
}
}
// Test valid terminal states
if (state != NO_CHARS_DECODED && state != PAD_FOUR_READ)
throw new IOException("Invalid sequence of input characters");
return ba.toByteArray();
}
}