| Methods Summary |
|---|
| public static byte[] | decode(byte[] base64)Method decode
return decodeInternal(base64);
|
| public static byte[] | decode(java.io.BufferedReader reader)Base64 decode the lines from the reader and return an InputStream
with the bytes.
UnsyncByteArrayOutputStream baos = new UnsyncByteArrayOutputStream();
String line;
while (null != (line = reader.readLine())) {
byte[] bytes = decode(line);
baos.write(bytes);
}
return baos.toByteArray();
|
| public static final byte[] | decode(java.lang.String encoded)Decodes Base64 data into octects
if (encoded == null)
return null;
return decodeInternal(encoded.getBytes());
|
| public static final void | decode(byte[] base64Data, java.io.OutputStream os)Decodes Base64 data into outputstream
// remove white spaces
int len = removeWhiteSpace(base64Data);
if (len%FOURBYTE != 0) {
throw new Base64DecodingException("decoding.divisible.four");
//should be divisible by four
}
int numberQuadruple = (len/FOURBYTE );
if (numberQuadruple == 0)
return;
//byte decodedData[] = null;
byte b1=0,b2=0,b3=0, b4=0;
int i = 0;
int dataIndex = 0;
//the begin
for (i=numberQuadruple-1; i>0; i--) {
b1 = base64Alphabet[base64Data[dataIndex++]];
b2 = base64Alphabet[base64Data[dataIndex++]];
b3 = base64Alphabet[base64Data[dataIndex++]];
b4 = base64Alphabet[base64Data[dataIndex++]];
if ( (b1==-1) ||
(b2==-1) ||
(b3==-1) ||
(b4==-1) )
throw new Base64DecodingException("decoding.general");//if found "no data" just return null
os.write((byte)( b1 <<2 | b2>>4 ) );
os.write((byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
os.write( (byte)( b3<<6 | b4 ));
}
b1 = base64Alphabet[base64Data[dataIndex++]];
b2 = base64Alphabet[base64Data[dataIndex++]];
// first last bits.
if ((b1==-1) ||
(b2==-1) ){
throw new Base64DecodingException("decoding.general");//if found "no data" just return null
}
byte d3,d4;
b3= base64Alphabet[d3 = base64Data[dataIndex++]];
b4= base64Alphabet[d4 = base64Data[dataIndex++]];
if ((b3==-1 ) ||
(b4==-1) ) {//Check if they are PAD characters
if (isPad( d3 ) && isPad( d4)) { //Two PAD e.g. 3c[Pad][Pad]
if ((b2 & 0xf) != 0)//last 4 bits should be zero
throw new Base64DecodingException("decoding.general");
os.write( (byte)( b1 <<2 | b2>>4 ) );
} else if (!isPad( d3) && isPad(d4)) { //One PAD e.g. 3cQ[Pad]
if ((b3 & 0x3 ) != 0)//last 2 bits should be zero
throw new Base64DecodingException("decoding.general");
os.write( (byte)( b1 <<2 | b2>>4 ));
os.write( (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
} else {
throw new Base64DecodingException("decoding.general");//an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
}
} else {
//No PAD e.g 3cQl
os.write((byte)( b1 <<2 | b2>>4 ) );
os.write( (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
os.write((byte)( b3<<6 | b4 ));
}
return ;
|
| public static final void | decode(java.io.InputStream is, java.io.OutputStream os)Decodes Base64 data into outputstream
//byte decodedData[] = null;
byte b1=0,b2=0,b3=0, b4=0;
int index=0;
byte []data=new byte[4];
int read;
//the begin
while ((read=is.read())>0) {
byte readed=(byte)read;
if (isWhiteSpace(readed)) {
continue;
}
if (isPad(readed)) {
data[index++]=readed;
if (index==3)
data[index++]=(byte)is.read();
break;
}
if ((data[index++]=readed)==-1) {
throw new Base64DecodingException("decoding.general");//if found "no data" just return null
}
if (index!=4) {
continue;
}
index=0;
b1 = base64Alphabet[data[0]];
b2 = base64Alphabet[data[1]];
b3 = base64Alphabet[data[2]];
b4 = base64Alphabet[data[3]];
os.write((byte)( b1 <<2 | b2>>4 ) );
os.write((byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
os.write( (byte)( b3<<6 | b4 ));
}
byte d1=data[0],d2=data[1],d3=data[2], d4=data[3];
b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2];
b3 = base64Alphabet[ d3 ];
b4 = base64Alphabet[ d4 ];
if ((b3==-1 ) ||
(b4==-1) ) {//Check if they are PAD characters
if (isPad( d3 ) && isPad( d4)) { //Two PAD e.g. 3c[Pad][Pad]
if ((b2 & 0xf) != 0)//last 4 bits should be zero
throw new Base64DecodingException("decoding.general");
os.write( (byte)( b1 <<2 | b2>>4 ) );
} else if (!isPad( d3) && isPad(d4)) { //One PAD e.g. 3cQ[Pad]
b3 = base64Alphabet[ d3 ];
if ((b3 & 0x3 ) != 0)//last 2 bits should be zero
throw new Base64DecodingException("decoding.general");
os.write( (byte)( b1 <<2 | b2>>4 ));
os.write( (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
} else {
throw new Base64DecodingException("decoding.general");//an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
}
} else {
//No PAD e.g 3cQl
os.write((byte)( b1 <<2 | b2>>4 ) );
os.write( (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ));
os.write((byte)( b3<<6 | b4 ));
}
return ;
|
| public static byte[] | decode(org.w3c.dom.Element element)Method decode
Takes the Text children of the Element and interprets
them as input for the Base64.decode() function.
Node sibling = element.getFirstChild();
StringBuffer sb = new StringBuffer();
while (sibling!=null) {
if (sibling.getNodeType() == Node.TEXT_NODE) {
Text t = (Text) sibling;
sb.append(t.getData());
}
sibling=sibling.getNextSibling();
}
return decode(sb.toString());
|
| public static java.math.BigInteger | decodeBigIntegerFromElement(org.w3c.dom.Element element)Method decodeBigIntegerFromElement
return new BigInteger(1, Base64.decode(element));
|
| public static java.math.BigInteger | decodeBigIntegerFromText(org.w3c.dom.Text text)Method decodeBigIntegerFromText
return new BigInteger(1, Base64.decode(text.getData()));
|
| protected static final byte[] | decodeInternal(byte[] base64Data)
// remove white spaces
int len = removeWhiteSpace(base64Data);
if (len%FOURBYTE != 0) {
throw new Base64DecodingException("decoding.divisible.four");
//should be divisible by four
}
int numberQuadruple = (len/FOURBYTE );
if (numberQuadruple == 0)
return new byte[0];
byte decodedData[] = null;
byte b1=0,b2=0,b3=0, b4=0;
int i = 0;
int encodedIndex = 0;
int dataIndex = 0;
//decodedData = new byte[ (numberQuadruple)*3];
dataIndex=(numberQuadruple-1)*4;
encodedIndex=(numberQuadruple-1)*3;
//first last bits.
b1 = base64Alphabet[base64Data[dataIndex++]];
b2 = base64Alphabet[base64Data[dataIndex++]];
if ((b1==-1) || (b2==-1)) {
throw new Base64DecodingException("decoding.general");//if found "no data" just return null
}
byte d3,d4;
b3 = base64Alphabet[d3=base64Data[dataIndex++]];
b4 = base64Alphabet[d4=base64Data[dataIndex++]];
if ((b3==-1 ) || (b4==-1) ) {
//Check if they are PAD characters
if (isPad( d3 ) && isPad( d4)) { //Two PAD e.g. 3c[Pad][Pad]
if ((b2 & 0xf) != 0)//last 4 bits should be zero
throw new Base64DecodingException("decoding.general");
decodedData = new byte[ encodedIndex + 1 ];
decodedData[encodedIndex] = (byte)( b1 <<2 | b2>>4 ) ;
} else if (!isPad( d3) && isPad(d4)) { //One PAD e.g. 3cQ[Pad]
if ((b3 & 0x3 ) != 0)//last 2 bits should be zero
throw new Base64DecodingException("decoding.general");
decodedData = new byte[ encodedIndex + 2 ];
decodedData[encodedIndex++] = (byte)( b1 <<2 | b2>>4 );
decodedData[encodedIndex] = (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) );
} else {
throw new Base64DecodingException("decoding.general");//an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
}
} else {
//No PAD e.g 3cQl
decodedData = new byte[encodedIndex+3];
decodedData[encodedIndex++] = (byte)( b1 <<2 | b2>>4 ) ;
decodedData[encodedIndex++] = (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) );
decodedData[encodedIndex++] = (byte)( b3<<6 | b4 );
}
encodedIndex=0;
dataIndex=0;
//the begin
for (i=numberQuadruple-1; i>0; i--) {
b1 = base64Alphabet[base64Data[dataIndex++]];
b2 = base64Alphabet[base64Data[dataIndex++]];
b3 = base64Alphabet[base64Data[dataIndex++]];
b4 = base64Alphabet[base64Data[dataIndex++]];
if ( (b1==-1) ||
(b2==-1) ||
(b3==-1) ||
(b4==-1) ) {
throw new Base64DecodingException("decoding.general");//if found "no data" just return null
}
decodedData[encodedIndex++] = (byte)( b1 <<2 | b2>>4 ) ;
decodedData[encodedIndex++] = (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) );
decodedData[encodedIndex++] = (byte)( b3<<6 | b4 );
}
return decodedData;
|
| public static java.lang.String | encode(byte[] binaryData)Encode a byte array and fold lines at the standard 76th character.
return encode(binaryData,BASE64DEFAULTLENGTH);
|
| public static java.lang.String | encode(byte[] binaryData, int length)Encode a byte array in Base64 format and return an optionally
wrapped line.
if (length<4) {
length=Integer.MAX_VALUE;
}
if (binaryData == null)
return null;
int lengthDataBits = binaryData.length*EIGHTBIT;
if (lengthDataBits == 0) {
return "";
}
int fewerThan24bits = lengthDataBits%TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits/TWENTYFOURBITGROUP;
int numberQuartet = fewerThan24bits != 0 ? numberTriplets+1 : numberTriplets;
int quartesPerLine = length/4;
int numberLines = (numberQuartet-1)/quartesPerLine;
char encodedData[] = null;
encodedData = new char[numberQuartet*4+numberLines];
byte k=0, l=0, b1=0,b2=0,b3=0;
int encodedIndex = 0;
int dataIndex = 0;
int i = 0;
if (fDebug) {
System.out.println("number of triplets = " + numberTriplets );
}
for (int line = 0; line < numberLines; line++) {
for (int quartet = 0; quartet < 19; quartet++) {
b1 = binaryData[dataIndex++];
b2 = binaryData[dataIndex++];
b3 = binaryData[dataIndex++];
if (fDebug) {
System.out.println( "b1= " + b1 +", b2= " + b2 + ", b3= " + b3 );
}
l = (byte)(b2 & 0x0f);
k = (byte)(b1 & 0x03);
byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
byte val2 = ((b2 & SIGN)==0)?(byte)(b2>>4):(byte)((b2)>>4^0xf0);
byte val3 = ((b3 & SIGN)==0)?(byte)(b3>>6):(byte)((b3)>>6^0xfc);
if (fDebug) {
System.out.println( "val2 = " + val2 );
System.out.println( "k4 = " + (k<<4));
System.out.println( "vak = " + (val2 | (k<<4)));
}
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val1 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val2 | ( k<<4 )];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ (l <<2 ) | val3 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ b3 & 0x3f ];
i++;
}
encodedData[encodedIndex++] = 0xa;
}
for (; i<numberTriplets; i++) {
b1 = binaryData[dataIndex++];
b2 = binaryData[dataIndex++];
b3 = binaryData[dataIndex++];
if (fDebug) {
System.out.println( "b1= " + b1 +", b2= " + b2 + ", b3= " + b3 );
}
l = (byte)(b2 & 0x0f);
k = (byte)(b1 & 0x03);
byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
byte val2 = ((b2 & SIGN)==0)?(byte)(b2>>4):(byte)((b2)>>4^0xf0);
byte val3 = ((b3 & SIGN)==0)?(byte)(b3>>6):(byte)((b3)>>6^0xfc);
if (fDebug) {
System.out.println( "val2 = " + val2 );
System.out.println( "k4 = " + (k<<4));
System.out.println( "vak = " + (val2 | (k<<4)));
}
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val1 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val2 | ( k<<4 )];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ (l <<2 ) | val3 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ b3 & 0x3f ];
}
// form integral number of 6-bit groups
if (fewerThan24bits == EIGHTBIT) {
b1 = binaryData[dataIndex];
k = (byte) ( b1 &0x03 );
if (fDebug) {
System.out.println("b1=" + b1);
System.out.println("b1<<2 = " + (b1>>2) );
}
byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val1 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ k<<4 ];
encodedData[encodedIndex++] = PAD;
encodedData[encodedIndex++] = PAD;
} else if (fewerThan24bits == SIXTEENBIT) {
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex +1 ];
l = ( byte ) ( b2 &0x0f );
k = ( byte ) ( b1 &0x03 );
byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
byte val2 = ((b2 & SIGN)==0)?(byte)(b2>>4):(byte)((b2)>>4^0xf0);
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val1 ];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ val2 | ( k<<4 )];
encodedData[encodedIndex++] = lookUpBase64Alphabet[ l<<2 ];
encodedData[encodedIndex++] = PAD;
}
//encodedData[encodedIndex] = 0xa;
return new String(encodedData);
|
| public static java.lang.String | encode(java.math.BigInteger big)Encode in Base64 the given {@link BigInteger}.
return encode(getBytes(big, big.bitLength()));
|
| public static byte[] | encode(java.math.BigInteger big, int bitlen)Returns a byte-array representation of a {@link BigInteger}.
No sign-bit is outputed.
N.B.: {@link BigInteger}'s toByteArray
retunrs eventually longer arrays because of the leading sign-bit.
//round bitlen
bitlen = ((bitlen + 7) >> 3) << 3;
if (bitlen < big.bitLength()) {
throw new IllegalArgumentException(I18n
.translate("utils.Base64.IllegalBitlength"));
}
byte[] bigBytes = big.toByteArray();
if (((big.bitLength() % 8) != 0)
&& (((big.bitLength() / 8) + 1) == (bitlen / 8))) {
return bigBytes;
}
// some copying needed
int startSrc = 0; // no need to skip anything
int bigLen = bigBytes.length; //valid length of the string
if ((big.bitLength() % 8) == 0) { // correct values
startSrc = 1; // skip sign bit
bigLen--; // valid length of the string
}
int startDst = bitlen / 8 - bigLen; //pad with leading nulls
byte[] resizedBytes = new byte[bitlen / 8];
System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, bigLen);
return resizedBytes;
|
| public static org.w3c.dom.Element | encodeToElement(org.w3c.dom.Document doc, java.lang.String localName, byte[] bytes)Method encodeToElement
Element el = XMLUtils.createElementInSignatureSpace(doc, localName);
Text text = doc.createTextNode(encode(bytes));
el.appendChild(text);
return el;
|
| public static void | fillElementWithBigInteger(org.w3c.dom.Element element, java.math.BigInteger biginteger)This method takes an (empty) Element and a BigInteger and adds the
base64 encoded BigInteger to the Element.
String encodedInt = encode(biginteger);
if (encodedInt.length() > 76) {
encodedInt = "\n" + encodedInt + "\n";
}
Document doc = element.getOwnerDocument();
Text text = doc.createTextNode(encodedInt);
element.appendChild(text);
|
| static byte[] | getBytes(java.math.BigInteger big, int bitlen)Returns a byte-array representation of a {@link BigInteger}.
No sign-bit is outputed.
N.B.: {@link BigInteger}'s toByteArray
retunrs eventually longer arrays because of the leading sign-bit.
//round bitlen
bitlen = ((bitlen + 7) >> 3) << 3;
if (bitlen < big.bitLength()) {
throw new IllegalArgumentException(I18n
.translate("utils.Base64.IllegalBitlength"));
}
byte[] bigBytes = big.toByteArray();
if (((big.bitLength() % 8) != 0)
&& (((big.bitLength() / 8) + 1) == (bitlen / 8))) {
return bigBytes;
}
// some copying needed
int startSrc = 0; // no need to skip anything
int bigLen = bigBytes.length; //valid length of the string
if ((big.bitLength() % 8) == 0) { // correct values
startSrc = 1; // skip sign bit
bigLen--; // valid length of the string
}
int startDst = bitlen / 8 - bigLen; //pad with leading nulls
byte[] resizedBytes = new byte[bitlen / 8];
System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, bigLen);
return resizedBytes;
|
| protected static final boolean | isPad(byte octect)
return (octect == PAD);
|
| protected static final boolean | isWhiteSpace(byte octect)
for (int i = 0; i<BASELENGTH; i++) {
base64Alphabet[i] = -1;
}
for (int i = 'Z"; i >= 'A"; i--) {
base64Alphabet[i] = (byte) (i-'A");
}
for (int i = 'z"; i>= 'a"; i--) {
base64Alphabet[i] = (byte) ( i-'a" + 26);
}
for (int i = '9"; i >= '0"; i--) {
base64Alphabet[i] = (byte) (i-'0" + 52);
}
base64Alphabet['+"] = 62;
base64Alphabet['/"] = 63;
for (int i = 0; i<=25; i++)
lookUpBase64Alphabet[i] = (char)('A"+i);
for (int i = 26, j = 0; i<=51; i++, j++)
lookUpBase64Alphabet[i] = (char)('a"+ j);
for (int i = 52, j = 0; i<=61; i++, j++)
lookUpBase64Alphabet[i] = (char)('0" + j);
lookUpBase64Alphabet[62] = '+";
lookUpBase64Alphabet[63] = '/";
return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
|
| public static void | main(java.lang.String[] args)Method main
DocumentBuilderFactory docBuilderFactory =
DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
String testString1 =
"<container><base64 value=\"Should be 'Hallo'\">SGFsbG8=</base64></container>";
InputSource inputSource = new InputSource(new StringReader(testString1));
Document doc = docBuilder.parse(inputSource);
Element base64Elem =
(Element) doc.getDocumentElement().getChildNodes().item(0);
System.out.println(new String(decode(base64Elem)));
|
| protected static int | removeWhiteSpace(byte[] data)remove WhiteSpace from MIME containing encoded Base64 data.
if (data == null)
return 0;
// count characters that's not whitespace
int newSize = 0;
int len = data.length;
for (int i = 0; i < len; i++) {
byte dataS=data[i];
if (!isWhiteSpace(dataS))
data[newSize++] = dataS;
}
return newSize;
|
