nuggets.util.Base64 Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jadex-nuggets Show documentation
Show all versions of jadex-nuggets Show documentation
The Jadex nuggets is a fast Java bean to
XML and back converter.
The newest version!
/*
* Base64.java
* Created by Walczak on Sep 8, 2005.
*
* Licence (BSD):
* ==============
*
* Copyright (c) 2005, Andrzej Walczak, University of Hamburg
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
* Neither the name of the University of Hamburg nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* this SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS for A PARTICULAR PURPOSE ARE DISCLAIMED.
* in NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE for ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER in CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF this SOFTWARE, EVEN if ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
*/
package nuggets.util;
/**
* Base64
* Contains lots of utilities for coding and decoding text and character arrays
* fore and back to the Base64 encoding. It is quite the fastest that I know.
*
* @author Walczak
* @since Sep 8, 2005
* @version 1.1
*/
public final class Base64 {
// ------------------------ ENCODER --------------------
/**
* This is a wrapper to
* toCharArray(final byte[] text, final int from, final int len)
*
* @param text
* @return an encoded char array from the text
*/
public final static char[] toCharArray(final byte[] text) {
return toCharArray(text, 0, text.length);
}
/**
* This will encode the text without line feeds added
*
* @param text
* @param from
* where to start
* @param len
* how long is the byte array
* @return an encoded char array from the text
*/
public final static char[] toCharArray(final byte[] text, final int from,
final int len) {
final char[] code;
int bi = from + len;
int ci = (len / 3) << 2;
int i;
switch (len % 3) { // length of padding
case 1:
ci += 4;
code = new char[ci];
i = text[--bi] << 4;
code[--ci] = '=';
code[--ci] = '=';
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
break;
case 2:
ci += 4;
code = new char[ci];
i = (text[--bi] & 0xFF) << 2 | text[--bi] << 10;
code[--ci] = '=';
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
code[--ci] = C[(i >>> 12) & 0x3F];
break;
default: // 0
code = new char[ci];
}
while (ci > 00) {
i = (text[--bi] & 0xFF) | (text[--bi] & 0xFF) << 8
| text[--bi] << 16;
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
code[--ci] = C[(i >>> 12) & 0x3F];
code[--ci] = C[(i >>> 18) & 0x3F];
}
return code;
}
/**
* @param text
* @return encoded text
*/
public final static byte[] encode(final byte[] text) {
return encode(text, 0, text.length);
}
/**
* This will encode the text without line feeds added
*
* @param text
* @param from
* where to start
* @param len
* how long is the byte array
* @return an encoded byte array from the text
*/
public final static byte[] encode(final byte[] text, final int from,
final int len) {
final byte[] code;
int bi = from + len;
int ci = (len / 3) << 2;
int i;
switch (len % 3) { // length of padding
case 1:
ci += 4;
code = new byte[ci];
i = text[--bi] << 4;
code[--ci] = '=';
code[--ci] = '=';
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
break;
case 2:
ci += 4;
code = new byte[ci];
i = (text[--bi] & 0xFF) << 2 | text[--bi] << 10;
code[--ci] = '=';
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
code[--ci] = B[(i >>> 12) & 0x3F];
break;
default: // 0
code = new byte[ci];
}
while (ci > 00) {
i = (text[--bi] & 0xFF) | (text[--bi] & 0xFF) << 8
| text[--bi] << 16;
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
code[--ci] = B[(i >>> 12) & 0x3F];
code[--ci] = B[(i >>> 18) & 0x3F];
}
return code;
}
/**
* This will encode the text without line feeds added. It will write all
* output to the dest buffer begining from dstart.
* Both src and dest may be the same provided (sstart <=dstart).
*
* @param src
* @param sstart
* where to start
* @param len
* how long is the byte array
* @param dest
* @param dstart
* @return index to the buffer byte ofter the text
*/
public final static int encode(final byte[] src, final int sstart,
final int len, final byte[] dest, final int dstart) {
int bi = sstart + len;
int ci = ((len / 3) << 2) + dstart;
int dend;
int i;
switch (len % 3) { // length of padding
case 1:
ci += 4;
dend = ci;
i = src[--bi] << 4;
dest[--ci] = '=';
dest[--ci] = '=';
dest[--ci] = B[i & 0x3F];
dest[--ci] = B[(i >>> 6) & 0x3F];
break;
case 2:
ci += 4;
dend = ci;
i = (src[--bi] & 0xFF) << 2 | src[--bi] << 10;
dest[--ci] = '=';
dest[--ci] = B[i & 0x3F];
dest[--ci] = B[(i >>> 6) & 0x3F];
dest[--ci] = B[(i >>> 12) & 0x3F];
break;
default:
dend = ci;
}
while (ci > dstart) {
i = (src[--bi] & 0xFF) | (src[--bi] & 0xFF) << 8 | src[--bi] << 16;
dest[--ci] = B[i & 0x3F];
dest[--ci] = B[(i >>> 6) & 0x3F];
dest[--ci] = B[(i >>> 12) & 0x3F];
dest[--ci] = B[(i >>> 18) & 0x3F];
}
return dend;
}
/**
* @param ba
* @param out
*/
public static void encode(byte[] ba, ICharStream out)
{
final int end = ba.length - 2;
int quad;
int start=0;
while(start>> 18) & 0x3F]);
out.write(B[(quad >>> 12) & 0x3F]);
out.write(B[(quad >>> 6) & 0x3F]);
out.write(B[quad & 0x3F]);
}
switch (ba.length % 3) { // length of padding
case 1:
quad = ba[start] << 4;
out.write(B[(quad >>> 6) & 0x3F]);
out.write(B[quad & 0x3F]);
out.write('=');
out.write('=');
break;
case 2:
quad = ba[start++] << 10 | (ba[start] & 0xFF) << 2;
out.write(B[(quad >>> 12) & 0x3F]);
out.write(B[(quad >>> 6) & 0x3F]);
out.write(B[quad & 0x3F]);
out.write('=');
break;
}
}
/**
* This will encode the text. The CRLF comes after lb
* characters.
*
* @param text
* @param llen
* the length of line (without CRLF) must be a multiple of 4
* @return an encoded char array from the text
*/
public final static char[] toCharArray(final byte[] text, final int llen) {
final char[] code;
int bi = text.length;
int ci = (bi / 3) << 2;
int i;
//@goal determine padding
switch (bi % 3) { // length of padding
case 1: // @goal pad two text
ci += 4;
ci += (ci / llen) << 1;
code = new char[ci];
if (ci % llen == 4) {
code[--ci] = '\n';
code[--ci] = '\r';
}
i = text[--bi] << 4;
code[--ci] = '=';
code[--ci] = '=';
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
break;
case 2: // @goal pad one byte
ci += 4;
ci += (ci / llen) << 1;
code = new char[ci];
if (ci % llen == 4) {
code[--ci] = '\n';
code[--ci] = '\r';
}
i = (text[--bi] & 0xFF) << 2 | text[--bi] << 10;
code[--ci] = '=';
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
code[--ci] = C[(i >>> 12) & 0x3F];
break;
default: // 0
ci += (ci / llen) << 1;
code = new char[ci];
}
//@goal calculate the line breaking constant and variable
int lmax = (llen >>> 2) - 1; // will break after this many quadruples
int li = (ci % (llen + 2)) >>> 2; // initialize the counter
while (bi > 00) {
if (li > 0) {
--li;
} else {
code[--ci] = '\n';
code[--ci] = '\r';
li = lmax;
}
i = (text[--bi] & 0xFF) | (text[--bi] & 0xFF) << 8
| text[--bi] << 16;
code[--ci] = C[i & 0x3F];
code[--ci] = C[(i >>> 6) & 0x3F];
code[--ci] = C[(i >>> 12) & 0x3F];
code[--ci] = C[(i >>> 18) & 0x3F];
}
return code;
}
/**
* This will encode the text. The CRLF comes after lb
* characters.
*
* @param text
* @param llen
* the length of line (without CRLF) must be a multiple of 4
* @return an encoded byte array from the text
*/
public final static byte[] encode(final byte[] text, final int llen) {
final byte[] code;
int bi = text.length;
int ci = (bi / 3) << 2;
int i;
//@goal determine padding
switch (bi % 3) { // length of padding
case 1: // @goal pad two text
ci += 4;
ci += (ci / llen) << 1;
code = new byte[ci];
if (ci % llen == 4) {
code[--ci] = '\n';
code[--ci] = '\r';
}
i = text[--bi] << 4;
code[--ci] = '=';
code[--ci] = '=';
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
break;
case 2: // @goal pad one byte
ci += 4;
ci += (ci / llen) << 1;
code = new byte[ci];
if (ci % llen == 4) {
code[--ci] = '\n';
code[--ci] = '\r';
}
i = (text[--bi] & 0xFF) << 2 | text[--bi] << 10;
code[--ci] = '=';
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
code[--ci] = B[(i >>> 12) & 0x3F];
break;
default: // 0
ci += (ci / llen) << 1;
code = new byte[ci];
}
//@goal calculate the line breaking constant and variable
int lmax = (llen >>> 2) - 1; // will break after this many quadruples
int li = (ci % (llen + 2)) >>> 2; // initialize the counter
while (ci > 00) {
if (li > 0) {
--li;
} else {
code[--ci] = '\n';
code[--ci] = '\r';
li = lmax;
}
i = (text[--bi] & 0xFF) | (text[--bi] & 0xFF) << 8
| text[--bi] << 16;
code[--ci] = B[i & 0x3F];
code[--ci] = B[(i >>> 6) & 0x3F];
code[--ci] = B[(i >>> 12) & 0x3F];
code[--ci] = B[(i >>> 18) & 0x3F];
}
return code;
}
//###################### DECODER #####################################
/**
* This is a wrapper to
* decode(final char[] code, final int from, final int len)
*
* @param code
* @return a byte array holding encoded char data
*/
public final static byte[] decode(final char[] code) {
return decode(code, 0, code.length);
}
/**
* This will decode base64 data without line feeds. The char array should be
* multiple of 4 in length.
*
* @param code
* @param from
* start position in code
* @param len
* length of the part
* @return the decoded sequence of text
*/
public final static byte[] decode(final char[] code, final int from,
final int len) {
int bi = (len >>> 2) * 3;
int ci = from + len;
int i;
final byte[] text;
if (code[ci - 1] == '=') {
if (code[ci - 2] == '=') { // padding 2
ci -= 3;
bi -= 2;
text = new byte[bi];
text[--bi] = (byte) ((I[code[ci]] | I[code[--ci]] << 6) >> 4);
} else { // padding 1
ci -= 2;
--bi;
text = new byte[bi];
i = I[code[ci]] | I[code[--ci]] << 6 | I[code[--ci]] << 12;
text[--bi] = (byte) (i >>> 2);
text[--bi] = (byte) (i >>> 10);
}
} else {
text = new byte[bi];
}
while (bi > 00) {
i = I[code[--ci]] | I[code[--ci]] << 6 | I[code[--ci]] << 12
| I[code[--ci]] << 18;
text[--bi] = (byte) (i);
text[--bi] = (byte) (i >>> 8);
text[--bi] = (byte) (i >>> 16);
}
return text;
}
/**
* This is a wrapper to
* decode(final byte[] code, final int from, final int len)
*
* @param code
* @return a byte array holding encoded char data
*/
public final static byte[] decode(final byte[] code) {
return decode(code, 0, code.length);
}
/**
* a copy of the char part
*
* @param src
* @param from
* @param len
* @return decoded byte array
*/
public final static byte[] decode(final byte[] src, final int from,
final int len) {
int bi = (len >>> 2) * 3;
int ci = from + len;
int i;
final byte[] text;
if (src[ci - 1] == '=') {
if (src[ci - 2] == '=') { // padding 2
ci -= 3;
bi -= 2;
text = new byte[bi];
text[--bi] = (byte) ((I[src[ci]] | I[src[--ci]] << 6) >> 4);
} else { // padding 1
ci -= 2;
--bi;
text = new byte[bi];
i = I[src[ci]] | I[src[--ci]] << 6 | I[src[--ci]] << 12;
text[--bi] = (byte) (i >>> 2);
text[--bi] = (byte) (i >>> 10);
}
} else {
text = new byte[bi];
}
while (bi > 00) {
i = I[src[--ci]] | I[src[--ci]] << 6 | I[src[--ci]] << 12
| I[src[--ci]] << 18;
text[--bi] = (byte) (i);
text[--bi] = (byte) (i >>> 8);
text[--bi] = (byte) (i >>> 16);
}
return text;
}
/**
* decodeCRLF(code, 0, code.length, 76)
*
* @param code
* @return the encoded text;
*/
public final static byte[] decode76(final char[] code) {
return decodeCRLF(code, 0, code.length, 76);
}
/**
* This will decode base64 data. The starting point and length must be
* accurate. The data must end on a multiple of 4 boundary and must include
* the '=' padding, if any.
*
* @param code
* @param from
* @param len
* the length of data
* @param llen
* the line length of this base64 (without CRLF)
* @return the decoded sequence of text
*/
public final static byte[] decodeCRLF(final char[] code, final int from,
final int len, final int llen) {
int bi = ((len - ((len / (llen + 2)) << 1)) >>> 2) * 3;
int ci = from + len;
int lmax = (llen >>> 2);
int li = (ci % (llen + 2)) >>> 2;
int i;
if (li == 0) { // skip crlf
ci -= 2;
li = lmax;
}
final byte[] text;
if (code[ci - 1] == '=') {
if (code[ci - 2] == '=') { // padding 2
ci -= 3;
bi -= 2;
text = new byte[bi];
text[--bi] = (byte) ((I[code[ci]] | I[code[--ci]] << 6) >> 4);
--li;
} else { // padding 1
ci -= 2;
--bi;
text = new byte[bi];
i = I[code[ci]] | I[code[--ci]] << 6 | I[code[--ci]] << 12;
text[--bi] = (byte) (i >>> 2);
text[--bi] = (byte) (i >>> 10);
--li;
}
} else {
text = new byte[bi];
}
while (bi > 00) {
if (li == 0) {
ci -= 2;
li = lmax;
}
i = I[code[--ci]] | I[code[--ci]] << 6 | I[code[--ci]] << 12
| I[code[--ci]] << 18;
text[--bi] = (byte) (i);
text[--bi] = (byte) (i >>> 8);
text[--bi] = (byte) (i >>> 16);
--li;
}
return text;
}
/**
* This will decode base64 data with CRLF at 4 character boundary.
* The sequence may look like:
*
* ABCDABCD\r\nABCDABCD or even ABCDABCD#####ABCD###ABCD#ABCD.
*
*
* The array must be multiple of 4 + number of CRLF or illegal characters
* and the line length may vary.
*
*
* @param code
* @param from
* @param len
* @return the decoded sequence of text
*/
public final static byte[] decodeCRLF(final char[] code, final int from,
final int len) {
int bi = len;
int ci = from + len;
int i;
//@goal determine the number of valid code
while (ci > from) {
if (I[code[--ci]] < 0)
--bi;
}
//@goal allocate byte array
bi = (bi >>> 2) * 3;
final byte[] text = new byte[bi];
//@goal decode the sequence
ci = from + len;
while (bi > 00) {
do
i = I[code[--ci]]; // look ahead
while (i < 0);
i |= I[code[--ci]] << 6 | I[code[--ci]] << 12 | I[code[--ci]] << 18;
text[--bi] = (byte) (i);
text[--bi] = (byte) (i >>> 8);
text[--bi] = (byte) (i >>> 16);
}
return text;
}
/**
* @param code
* @return the decoded array
*/
public final static byte[] decodeFailSafe(char[] code) {
return decodeFailSafe(code, 0, code.length);
}
/**
* This removes all bad characters from the char array. It modifies the
* array in the scope of the process !!! Than simply calls decode;
*
* @param code
* @param from
* @param len
* @return decoded text
*/
public final static byte[] decodeFailSafe(final char[] code,
final int from, final int len) {
char c;
int ci = from;
int cj = from;
int ce = from + len;
while (ci < ce) {
c = code[ci];
if (c == '=')
break;
try {
if (I[c] >= 0)
code[cj++] = c;
} catch (Exception e) {/**/
}
ci++;
}
switch (((cj - from) & 0x3)) {
case 1:
code[cj++] = C[0];
case 2:
code[cj++] = '=';
case 3:
code[cj++] = '=';
default:
}
return decode(code, from, cj - from);
}
//------------------ static fields -------------------
private static final byte[] B = new byte[] {
65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99,100,101,102,
103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,
119,120,121,122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, };
private static final char[] C = new char[] {
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/', };
private static final int[] I = new int[] {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, };
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy