This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 7.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
The following commit(s) were added to refs/heads/7.0.x by this push:
new df20351 Update Commons Codec to latest
df20351 is described below
commit df20351955650581c8ddd852a27fbba62cbdaa60
Author: Mark Thomas <[email protected]>
AuthorDate: Tue Aug 25 19:57:05 2020 +0100
Update Commons Codec to latest
---
.../apache/tomcat/util/codec/binary/Base64.java | 1031 ++++++++++----------
.../tomcat/util/codec/binary/BaseNCodec.java | 546 ++++++-----
.../util/codec/binary/LocalStrings.properties | 19 +
.../util/codec/binary/LocalStrings_fr.properties | 19 +
.../util/codec/binary/LocalStrings_ja.properties | 19 +
.../util/codec/binary/LocalStrings_ko.properties | 19 +
.../codec/binary/LocalStrings_zh_CN.properties | 19 +
.../tomcat/util/codec/binary/StringUtils.java | 28 +-
webapps/docs/changelog.xml | 4 +
9 files changed, 924 insertions(+), 780 deletions(-)
diff --git a/java/org/apache/tomcat/util/codec/binary/Base64.java
b/java/org/apache/tomcat/util/codec/binary/Base64.java
index 0543826..581d7ea 100644
--- a/java/org/apache/tomcat/util/codec/binary/Base64.java
+++ b/java/org/apache/tomcat/util/codec/binary/Base64.java
@@ -35,7 +35,7 @@ import java.math.BigInteger;
* <li>Line separator: Default is CRLF ("\r\n")</li>
* </ul>
* <p>
- * The URL-safe parameter is only applied to encode operations. Decoding only
handles standard mode.
+ * The URL-safe parameter is only applied to encode operations. Decoding
seamlessly handles both modes.
* </p>
* <p>
* Since this class operates directly on byte streams, and not character
streams, it is hard-coded to only
@@ -61,17 +61,6 @@ public class Base64 extends BaseNCodec {
private static final int BYTES_PER_ENCODED_BLOCK = 4;
/**
- * Chunk separator per RFC 2045 section 2.1.
- *
- * <p>
- * N.B. The next major release may break compatibility and make this field
private.
- * </p>
- *
- * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045 section
2.1</a>
- */
- static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
-
- /**
* This array is a lookup table that translates 6-bit positive integer
index values into their "Base64 Alphabet"
* equivalents as specified in Table 1 of RFC 2045.
*
@@ -104,12 +93,13 @@ public class Base64 extends BaseNCodec {
* in Table 1 of RFC 2045) into their 6-bit positive integer equivalents.
Characters that are not in the Base64
* alphabet but fall within the bounds of the array are translated to -1.
*
- * Note: The seamless decoding of URL safe values has been disabled
because Tomcat doesn't use it.
+ * Note: '+' and '-' both decode to 62. '/' and '_' both decode to 63.
This means decoder seamlessly handles both
+ * URL_SAFE and STANDARD base64. (The encoder, on the other hand, needs to
know ahead of time what to emit).
*
* Thanks to "commons" project in ws.apache.org for this code.
* https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
*/
- private static final byte[] DECODE_TABLE = {
+ private static final byte[] STANDARD_DECODE_TABLE = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
00-0f
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
10-1f
@@ -121,6 +111,18 @@ public class Base64 extends BaseNCodec {
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 //
70-7a p-z
};
+ private static final byte[] URL_SAFE_DECODE_TABLE = {
+ // 0 1 2 3 4 5 6 7 8 9 A B C D E F
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, // 00-0f
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, // 10-1f
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1,
-1, // 20-2f -
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1,
-1, // 30-3f 0-9
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, // 40-4f A-O
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
63, // 50-5f P-Z _
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, // 60-6f a-o
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
// 70-7a p-z
+ };
+
/**
* Base64 uses 6-bit fields.
*/
@@ -136,356 +138,203 @@ public class Base64 extends BaseNCodec {
// some state be preserved between calls of encode() and decode().
/**
- * Encode table to use: either STANDARD or URL_SAFE. Note: the
DECODE_TABLE above remains static because it is able
- * to decode both STANDARD and URL_SAFE streams, but the encodeTable must
be a member variable so we can switch
- * between the two modes.
+ * Decodes Base64 data into octets.
+ * <p>
+ * <b>Note:</b> this method seamlessly handles data encoded in URL-safe or
normal mode.
+ * </p>
+ *
+ * @param base64Data
+ * Byte array containing Base64 data
+ * @return Array containing decoded data.
*/
- private final byte[] encodeTable;
+ public static byte[] decodeBase64(final byte[] base64Data) {
+ return decodeBase64(base64Data, 0, base64Data.length);
+ }
- // Only one decode table currently; keep for consistency with Base32 code
- private final byte[] decodeTable = DECODE_TABLE;
+ public static byte[] decodeBase64(
+ final byte[] base64Data, final int off, final int len) {
+ return new Base64().decode(base64Data, off, len);
+ }
/**
- * Line separator for encoding. Not used when decoding. Only used if
lineLength > 0.
+ * Decodes a Base64 String into octets.
+ * <p>
+ * <b>Note:</b> this method seamlessly handles data encoded in URL-safe or
normal mode.
+ * </p>
+ *
+ * @param base64String
+ * String containing Base64 data
+ * @return Array containing decoded data.
+ * @since 1.4
*/
- private final byte[] lineSeparator;
+ public static byte[] decodeBase64(final String base64String) {
+ return new Base64().decode(base64String);
+ }
+ public static byte[] decodeBase64URLSafe(final String base64String) {
+ return new Base64(true).decode(base64String);
+ }
+
+ // Implementation of integer encoding used for crypto
/**
- * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
- * <code>decodeSize = 3 + lineSeparator.length;</code>
+ * Decodes a byte64-encoded integer according to crypto standards such as
W3C's XML-Signature.
+ *
+ * @param pArray
+ * a byte array containing base64 character data
+ * @return A BigInteger
+ * @since 1.4
*/
- private final int decodeSize;
+ public static BigInteger decodeInteger(final byte[] pArray) {
+ return new BigInteger(1, decodeBase64(pArray));
+ }
/**
- * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
- * <code>encodeSize = 4 + lineSeparator.length;</code>
+ * Encodes binary data using the base64 algorithm but does not chunk the
output.
+ *
+ * @param binaryData
+ * binary data to encode
+ * @return byte[] containing Base64 characters in their UTF-8
representation.
*/
- private final int encodeSize;
+ public static byte[] encodeBase64(final byte[] binaryData) {
+ return encodeBase64(binaryData, false);
+ }
/**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length is 0 (no chunking), and the encoding
table is STANDARD_ENCODE_TABLE.
- * </p>
+ * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
*
- * <p>
- * When decoding all variants are supported.
- * </p>
+ * @param binaryData
+ * Array containing binary data to encode.
+ * @param isChunked
+ * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
+ * @return Base64-encoded data.
+ * @throws IllegalArgumentException
+ * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
*/
- public Base64() {
- this(0);
+ public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked) {
+ return encodeBase64(binaryData, isChunked, false);
}
/**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
the given URL-safe mode.
- * <p>
- * When encoding the line length is 76, the line separator is CRLF, and
the encoding table is STANDARD_ENCODE_TABLE.
- * </p>
- *
- * <p>
- * When decoding all variants are supported.
- * </p>
+ * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
*
+ * @param binaryData
+ * Array containing binary data to encode.
+ * @param isChunked
+ * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
* @param urlSafe
- * if <code>true</code>, URL-safe encoding is used. In most
cases this should be set to
- * <code>false</code>.
+ * if {@code true} this encoder will emit - and _ instead of
the usual + and / characters.
+ * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
+ * @return Base64-encoded data.
+ * @throws IllegalArgumentException
+ * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
* @since 1.4
*/
- public Base64(final boolean urlSafe) {
- this(MIME_CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
+ public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked, final boolean urlSafe) {
+ return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
}
/**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length is given in the constructor, the line
separator is CRLF, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
+ * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
*
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
+ * @param binaryData
+ * Array containing binary data to encode.
+ * @param isChunked
+ * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
+ * @param urlSafe
+ * if {@code true} this encoder will emit - and _ instead of
the usual + and / characters.
+ * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
+ * @param maxResultSize
+ * The maximum result size to accept.
+ * @return Base64-encoded data.
+ * @throws IllegalArgumentException
+ * Thrown when the input array needs an output array bigger
than maxResultSize
* @since 1.4
*/
- public Base64(final int lineLength) {
- this(lineLength, CHUNK_SEPARATOR);
+ public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked,
+ final boolean urlSafe, final int
maxResultSize) {
+ if (binaryData == null || binaryData.length == 0) {
+ return binaryData;
+ }
+
+ // Create this so can use the super-class method
+ // Also ensures that the same roundings are performed by the ctor and
the code
+ final Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0,
CHUNK_SEPARATOR, urlSafe);
+ final long len = b64.getEncodedLength(binaryData);
+ if (len > maxResultSize) {
+ throw new IllegalArgumentException(sm.getString(
+ "base64.inputTooLarge", Long.valueOf(len),
Integer.valueOf(maxResultSize)));
+ }
+
+ return b64.encode(binaryData);
}
/**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length and line separator are given in the
constructor, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
+ * Encodes binary data using the base64 algorithm and chunks the encoded
output into 76 character blocks
*
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
- * @param lineSeparator
- * Each line of encoded data will end with this sequence of
bytes.
- * @throws IllegalArgumentException
- * Thrown when the provided lineSeparator included some base64
characters.
- * @since 1.4
+ * @param binaryData
+ * binary data to encode
+ * @return Base64 characters chunked in 76 character blocks
*/
- public Base64(final int lineLength, final byte[] lineSeparator) {
- this(lineLength, lineSeparator, false);
+ public static byte[] encodeBase64Chunked(final byte[] binaryData) {
+ return encodeBase64(binaryData, true);
}
/**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length and line separator are given in the
constructor, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
+ * Encodes binary data using the base64 algorithm but does not chunk the
output.
*
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
- * @param lineSeparator
- * Each line of encoded data will end with this sequence of
bytes.
- * @param urlSafe
- * Instead of emitting '+' and '/' we emit '-' and '_'
respectively. urlSafe is only applied to encode
- * operations. Decoding only handles standard mode.
- * <b>Note: no padding is added when using the URL-safe
alphabet.</b>
- * @throws IllegalArgumentException
- * The provided lineSeparator included some base64 characters.
That's not going to work!
+ * NOTE: We changed the behavior of this method from multi-line chunking
(commons-codec-1.4) to
+ * single-line non-chunking (commons-codec-1.5).
+ *
+ * @param binaryData
+ * binary data to encode
+ * @return String containing Base64 characters.
+ * @since 1.4 (NOTE: 1.4 chunked the output, whereas 1.5 does not).
+ */
+ public static String encodeBase64String(final byte[] binaryData) {
+ return StringUtils.newStringUsAscii(encodeBase64(binaryData, false));
+ }
+
+ /**
+ * Encodes binary data using a URL-safe variation of the base64 algorithm
but does not chunk the output. The
+ * url-safe variation emits - and _ instead of + and / characters.
+ * <b>Note: no padding is added.</b>
+ * @param binaryData
+ * binary data to encode
+ * @return byte[] containing Base64 characters in their UTF-8
representation.
* @since 1.4
*/
- public Base64(final int lineLength, final byte[] lineSeparator, final
boolean urlSafe) {
- super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK,
- lineLength,
- lineSeparator == null ? 0 : lineSeparator.length);
- // TODO could be simplified if there is no requirement to reject
invalid line sep when length <=0
- // @see test case Base64Test.testConstructors()
- if (lineSeparator != null) {
- if (containsAlphabetOrPad(lineSeparator)) {
- final String sep = StringUtils.newStringUtf8(lineSeparator);
- throw new IllegalArgumentException("lineSeparator must not
contain base64 characters: [" + sep + "]");
- }
- if (lineLength > 0){ // null line-sep forces no chunking rather
than throwing IAE
- this.encodeSize = BYTES_PER_ENCODED_BLOCK +
lineSeparator.length;
- this.lineSeparator = new byte[lineSeparator.length];
- System.arraycopy(lineSeparator, 0, this.lineSeparator, 0,
lineSeparator.length);
- } else {
- this.encodeSize = BYTES_PER_ENCODED_BLOCK;
- this.lineSeparator = null;
- }
- } else {
- this.encodeSize = BYTES_PER_ENCODED_BLOCK;
- this.lineSeparator = null;
- }
- this.decodeSize = this.encodeSize - 1;
- this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE :
STANDARD_ENCODE_TABLE;
+ public static byte[] encodeBase64URLSafe(final byte[] binaryData) {
+ return encodeBase64(binaryData, false, true);
}
/**
- * Returns our current encode mode. True if we're URL-SAFE, false
otherwise.
- *
- * @return true if we're in URL-SAFE mode, false otherwise.
+ * Encodes binary data using a URL-safe variation of the base64 algorithm
but does not chunk the output. The
+ * url-safe variation emits - and _ instead of + and / characters.
+ * <b>Note: no padding is added.</b>
+ * @param binaryData
+ * binary data to encode
+ * @return String containing Base64 characters
* @since 1.4
*/
- public boolean isUrlSafe() {
- return this.encodeTable == URL_SAFE_ENCODE_TABLE;
+ public static String encodeBase64URLSafeString(final byte[] binaryData) {
+ return StringUtils.newStringUsAscii(encodeBase64(binaryData, false,
true));
}
/**
- * <p>
- * Encodes all of the provided data, starting at inPos, for inAvail bytes.
Must be called at least twice: once with
- * the data to encode, and once with inAvail set to "-1" to alert encoder
that EOF has been reached, to flush last
- * remaining bytes (if not multiple of 3).
- * </p>
- * <p><b>Note: no padding is added when encoding using the URL-safe
alphabet.</b></p>
- * <p>
- * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
- *
- * @param in
- * byte[] array of binary data to base64 encode.
- * @param inPos
- * Position to start reading data from.
- * @param inAvail
- * Amount of bytes available from input for encoding.
- * @param context
- * the context to be used
- */
- @Override
- void encode(final byte[] in, int inPos, final int inAvail, final Context
context) {
- if (context.eof) {
- return;
- }
- // inAvail < 0 is how we're informed of EOF in the underlying data
we're
- // encoding.
- if (inAvail < 0) {
- context.eof = true;
- if (0 == context.modulus && lineLength == 0) {
- return; // no leftovers to process and not using chunking
- }
- final byte[] buffer = ensureBufferSize(encodeSize, context);
- final int savedPos = context.pos;
- switch (context.modulus) { // 0-2
- case 0 : // nothing to do here
- break;
- case 1 : // 8 bits = 6 + 2
- // top 6 bits:
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 2) & MASK_6BITS];
- // remaining 2:
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
<< 4) & MASK_6BITS];
- // URL-SAFE skips the padding to further reduce size.
- if (encodeTable == STANDARD_ENCODE_TABLE) {
- buffer[context.pos++] = PAD;
- buffer[context.pos++] = PAD;
- }
- break;
-
- case 2 : // 16 bits = 6 + 6 + 4
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 10) & MASK_6BITS];
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 4) & MASK_6BITS];
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
<< 2) & MASK_6BITS];
- // URL-SAFE skips the padding to further reduce size.
- if (encodeTable == STANDARD_ENCODE_TABLE) {
- buffer[context.pos++] = PAD;
- }
- break;
- default:
- throw new IllegalStateException("Impossible modulus
"+context.modulus);
- }
- context.currentLinePos += context.pos - savedPos; // keep track of
current line position
- // if currentPos == 0 we are at the start of a line, so don't add
CRLF
- if (lineLength > 0 && context.currentLinePos > 0) {
- System.arraycopy(lineSeparator, 0, buffer, context.pos,
lineSeparator.length);
- context.pos += lineSeparator.length;
- }
- } else {
- for (int i = 0; i < inAvail; i++) {
- final byte[] buffer = ensureBufferSize(encodeSize, context);
- context.modulus = (context.modulus+1) %
BYTES_PER_UNENCODED_BLOCK;
- int b = in[inPos++];
- if (b < 0) {
- b += 256;
- }
- context.ibitWorkArea = (context.ibitWorkArea << 8) + b; //
BITS_PER_BYTE
- if (0 == context.modulus) { // 3 bytes = 24 bits = 4 * 6 bits
to extract
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 18) & MASK_6BITS];
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 12) & MASK_6BITS];
- buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 6) & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea &
MASK_6BITS];
- context.currentLinePos += BYTES_PER_ENCODED_BLOCK;
- if (lineLength > 0 && lineLength <=
context.currentLinePos) {
- System.arraycopy(lineSeparator, 0, buffer,
context.pos, lineSeparator.length);
- context.pos += lineSeparator.length;
- context.currentLinePos = 0;
- }
- }
- }
- }
- }
-
- /**
- * <p>
- * Decodes all of the provided data, starting at inPos, for inAvail bytes.
Should be called at least twice: once
- * with the data to decode, and once with inAvail set to "-1" to alert
decoder that EOF has been reached. The "-1"
- * call is not necessary when decoding, but it doesn't hurt, either.
- * </p>
- * <p>
- * Ignores all non-base64 characters. This is how chunked (e.g. 76
character) data is handled, since CR and LF are
- * silently ignored, but has implications for other bytes, too. This
method subscribes to the garbage-in,
- * garbage-out philosophy: it will not check the provided data for
validity.
- * </p>
- * <p>
- * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
+ * Encodes to a byte64-encoded integer according to crypto standards such
as W3C's XML-Signature.
*
- * @param in
- * byte[] array of ascii data to base64 decode.
- * @param inPos
- * Position to start reading data from.
- * @param inAvail
- * Amount of bytes available from input for decoding.
- * @param context
- * the context to be used
+ * @param bigInteger
+ * a BigInteger
+ * @return A byte array containing base64 character data
+ * @throws NullPointerException
+ * if null is passed in
+ * @since 1.4
*/
- @Override
- void decode(final byte[] in, int inPos, final int inAvail, final Context
context) {
- if (context.eof) {
- return;
- }
- if (inAvail < 0) {
- context.eof = true;
- }
- for (int i = 0; i < inAvail; i++) {
- final byte[] buffer = ensureBufferSize(decodeSize, context);
- final byte b = in[inPos++];
- if (b == PAD) {
- // We're done.
- context.eof = true;
- break;
- } else {
- if (b >= 0 && b < DECODE_TABLE.length) {
- final int result = DECODE_TABLE[b];
- if (result >= 0) {
- context.modulus = (context.modulus+1) %
BYTES_PER_ENCODED_BLOCK;
- context.ibitWorkArea = (context.ibitWorkArea <<
BITS_PER_ENCODED_BYTE) + result;
- if (context.modulus == 0) {
- buffer[context.pos++] = (byte)
((context.ibitWorkArea >> 16) & MASK_8BITS);
- buffer[context.pos++] = (byte)
((context.ibitWorkArea >> 8) & MASK_8BITS);
- buffer[context.pos++] = (byte)
(context.ibitWorkArea & MASK_8BITS);
- }
- }
- }
- }
- }
-
- // Two forms of EOF as far as base64 decoder is concerned: actual
- // EOF (-1) and first time '=' character is encountered in stream.
- // This approach makes the '=' padding characters completely optional.
- if (context.eof && context.modulus != 0) {
- final byte[] buffer = ensureBufferSize(decodeSize, context);
-
- // We have some spare bits remaining
- // Output all whole multiples of 8 bits and ignore the rest
- switch (context.modulus) {
-// case 0 : // impossible, as excluded above
- case 1 : // 6 bits - ignore entirely
- // TODO not currently tested; perhaps it is impossible?
- break;
- case 2 : // 12 bits = 8 + 4
- validateCharacter(MASK_4BITS, context);
- context.ibitWorkArea = context.ibitWorkArea >> 4; // dump
the extra 4 bits
- buffer[context.pos++] = (byte) ((context.ibitWorkArea) &
MASK_8BITS);
- break;
- case 3 : // 18 bits = 8 + 8 + 2
- validateCharacter(MASK_2BITS, context);
- context.ibitWorkArea = context.ibitWorkArea >> 2; // dump
2 bits
- buffer[context.pos++] = (byte) ((context.ibitWorkArea >>
8) & MASK_8BITS);
- buffer[context.pos++] = (byte) ((context.ibitWorkArea) &
MASK_8BITS);
- break;
- default:
- throw new IllegalStateException("Impossible modulus
"+context.modulus);
- }
+ public static byte[] encodeInteger(final BigInteger bigInteger) {
+ if (bigInteger == null) {
+ throw new
NullPointerException(sm.getString("base64.nullEncodeParameter"));
}
+ return encodeBase64(toIntegerBytes(bigInteger), false);
}
/**
@@ -496,7 +345,7 @@ public class Base64 extends BaseNCodec {
* byte array to test
* @return {@code true} if all bytes are valid characters in the Base64
alphabet or if the byte array is empty;
* {@code false}, otherwise
- * @deprecated 1.5 Use {@link #isBase64(byte[])}, will be removed in 2.0.
+ * @deprecated 1.5 Use {@link #isBase64(byte[])}, will be removed in
Tomcat 8.
*/
@Deprecated
public static boolean isArrayByteBase64(final byte[] arrayOctet) {
@@ -504,29 +353,15 @@ public class Base64 extends BaseNCodec {
}
/**
- * Returns whether or not the <code>octet</code> is in the base 64
alphabet.
+ * Returns whether or not the {@code octet} is in the base 64 alphabet.
*
* @param octet
* The value to test
- * @return <code>true</code> if the value is defined in the the base 64
alphabet, <code>false</code> otherwise.
+ * @return {@code true} if the value is defined in the the base 64
alphabet, {@code false} otherwise.
* @since 1.4
*/
public static boolean isBase64(final byte octet) {
- return octet == PAD_DEFAULT || (octet >= 0 && octet <
DECODE_TABLE.length && DECODE_TABLE[octet] != -1);
- }
-
- /**
- * Tests a given String to see if it contains only valid characters within
the Base64 alphabet. Currently the
- * method treats whitespace as valid.
- *
- * @param base64
- * String to test
- * @return <code>true</code> if all characters in the String are valid
characters in the Base64 alphabet or if
- * the String is empty; <code>false</code>, otherwise
- * @since 1.5
- */
- public static boolean isBase64(final String base64) {
- return isBase64(StringUtils.getBytesUtf8(base64));
+ return octet == PAD_DEFAULT || (octet >= 0 && octet <
STANDARD_DECODE_TABLE.length && STANDARD_DECODE_TABLE[octet] != -1);
}
/**
@@ -535,8 +370,8 @@ public class Base64 extends BaseNCodec {
*
* @param arrayOctet
* byte array to test
- * @return <code>true</code> if all bytes are valid characters in the
Base64 alphabet or if the byte array is empty;
- * <code>false</code>, otherwise
+ * @return {@code true} if all bytes are valid characters in the Base64
alphabet or if the byte array is empty;
+ * {@code false}, otherwise
* @since 1.5
*/
public static boolean isBase64(final byte[] arrayOctet) {
@@ -549,266 +384,436 @@ public class Base64 extends BaseNCodec {
}
/**
- * Encodes binary data using the base64 algorithm but does not chunk the
output.
+ * Tests a given String to see if it contains only valid characters within
the Base64 alphabet. Currently the
+ * method treats whitespace as valid.
*
- * @param binaryData
- * binary data to encode
- * @return byte[] containing Base64 characters in their UTF-8
representation.
+ * @param base64
+ * String to test
+ * @return {@code true} if all characters in the String are valid
characters in the Base64 alphabet or if
+ * the String is empty; {@code false}, otherwise
+ * @since 1.5
*/
- public static byte[] encodeBase64(final byte[] binaryData) {
- return encodeBase64(binaryData, false);
+ public static boolean isBase64(final String base64) {
+ return isBase64(StringUtils.getBytesUtf8(base64));
}
/**
- * Encodes binary data using the base64 algorithm but does not chunk the
output.
+ * Returns a byte-array representation of a {@code BigInteger} without
sign bit.
*
- * NOTE: We changed the behaviour of this method from multi-line chunking
(commons-codec-1.4) to
- * single-line non-chunking (commons-codec-1.5).
- *
- * @param binaryData
- * binary data to encode
- * @return String containing Base64 characters.
- * @since 1.4 (NOTE: 1.4 chunked the output, whereas 1.5 does not).
+ * @param bigInt
+ * {@code BigInteger} to be converted
+ * @return a byte array representation of the BigInteger parameter
*/
- public static String encodeBase64String(final byte[] binaryData) {
- return StringUtils.newStringUsAscii(encodeBase64(binaryData, false));
+ static byte[] toIntegerBytes(final BigInteger bigInt) {
+ int bitlen = bigInt.bitLength();
+ // round bitlen
+ bitlen = ((bitlen + 7) >> 3) << 3;
+ final byte[] bigBytes = bigInt.toByteArray();
+
+ if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1)
== (bitlen / 8))) {
+ return bigBytes;
+ }
+ // set up params for copying everything but sign bit
+ int startSrc = 0;
+ int len = bigBytes.length;
+
+ // if bigInt is exactly byte-aligned, just skip signbit in copy
+ if ((bigInt.bitLength() % 8) == 0) {
+ startSrc = 1;
+ len--;
+ }
+ final int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
+ final byte[] resizedBytes = new byte[bitlen / 8];
+ System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
+ return resizedBytes;
}
/**
- * Encodes binary data using a URL-safe variation of the base64 algorithm
but does not chunk the output. The
- * url-safe variation emits - and _ instead of + and / characters.
- * <b>Note: no padding is added.</b>
- * @param binaryData
- * binary data to encode
- * @return byte[] containing Base64 characters in their UTF-8
representation.
- * @since 1.4
+ * Validates whether decoding the final trailing character is possible in
the context
+ * of the set of possible base 64 values.
+ *
+ * <p>The character is valid if the lower bits within the provided mask
are zero. This
+ * is used to test the final trailing base-64 digit is zero in the bits
that will be discarded.
+ *
+ * @param emptyBitsMask The mask of the lower bits that should be empty
+ * @param context the context to be used
+ *
+ * @throws IllegalArgumentException if the bits being checked contain any
non-zero value
*/
- public static byte[] encodeBase64URLSafe(final byte[] binaryData) {
- return encodeBase64(binaryData, false, true);
+ private static void validateCharacter(final int emptyBitsMask, final
Context context) {
+ if ((context.ibitWorkArea & emptyBitsMask) != 0) {
+ throw new IllegalArgumentException(
+ "Last encoded character (before the paddings if any) is a
valid base 64 alphabet but not a possible value. " +
+ "Expected the discarded bits to be zero.");
+ }
}
+
/**
- * Encodes binary data using a URL-safe variation of the base64 algorithm
but does not chunk the output. The
- * url-safe variation emits - and _ instead of + and / characters.
- * <b>Note: no padding is added.</b>
- * @param binaryData
- * binary data to encode
- * @return String containing Base64 characters
- * @since 1.4
+ * Encode table to use: either STANDARD or URL_SAFE. Note: the
DECODE_TABLE above remains static because it is able
+ * to decode both STANDARD and URL_SAFE streams, but the encodeTable must
be a member variable so we can switch
+ * between the two modes.
*/
- public static String encodeBase64URLSafeString(final byte[] binaryData) {
- return StringUtils.newStringUsAscii(encodeBase64(binaryData, false,
true));
- }
+ private final byte[] encodeTable;
+
+ // Only one decode table currently; keep for consistency with Base32 code
+ private final byte[] decodeTable;
/**
- * Encodes binary data using the base64 algorithm and chunks the encoded
output into 76 character blocks
- *
- * @param binaryData
- * binary data to encode
- * @return Base64 characters chunked in 76 character blocks
+ * Line separator for encoding. Not used when decoding. Only used if
lineLength > 0.
*/
- public static byte[] encodeBase64Chunked(final byte[] binaryData) {
- return encodeBase64(binaryData, true);
- }
+ private final byte[] lineSeparator;
/**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
- *
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if <code>true</code> this encoder will chunk the base64
output into 76 character blocks
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
+ * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
+ * {@code decodeSize = 3 + lineSeparator.length;}
*/
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked) {
- return encodeBase64(binaryData, isChunked, false);
- }
+ private final int decodeSize;
/**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
+ * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
+ * {@code encodeSize = 4 + lineSeparator.length;}
+ */
+ private final int encodeSize;
+
+ /**
+ * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
+ * <p>
+ * When encoding the line length is 0 (no chunking), and the encoding
table is STANDARD_ENCODE_TABLE.
+ * </p>
*
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if <code>true</code> this encoder will chunk the base64
output into 76 character blocks
- * @param urlSafe
- * if <code>true</code> this encoder will emit - and _ instead
of the usual + and / characters.
- * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
- * @since 1.4
+ * <p>
+ * When decoding all variants are supported.
+ * </p>
*/
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked, final boolean urlSafe) {
- return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
+ public Base64() {
+ this(0);
}
/**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
+ * Creates a Base64 codec used for decoding (all modes) and encoding in
the given URL-safe mode.
+ * <p>
+ * When encoding the line length is 76, the line separator is CRLF, and
the encoding table is STANDARD_ENCODE_TABLE.
+ * </p>
+ *
+ * <p>
+ * When decoding all variants are supported.
+ * </p>
*
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if <code>true</code> this encoder will chunk the base64
output into 76 character blocks
* @param urlSafe
- * if <code>true</code> this encoder will emit - and _ instead
of the usual + and / characters.
- * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
- * @param maxResultSize
- * The maximum result size to accept.
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than maxResultSize
+ * if {@code true}, URL-safe encoding is used. In most cases
this should be set to
+ * {@code false}.
* @since 1.4
*/
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked,
- final boolean urlSafe, final int
maxResultSize) {
- if (binaryData == null || binaryData.length == 0) {
- return binaryData;
- }
-
- // Create this so can use the super-class method
- // Also ensures that the same roundings are performed by the ctor and
the code
- final Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0,
CHUNK_SEPARATOR, urlSafe);
- final long len = b64.getEncodedLength(binaryData);
- if (len > maxResultSize) {
- throw new IllegalArgumentException("Input array too big, the
output array would be bigger (" +
- len +
- ") than the specified maximum size of " +
- maxResultSize);
- }
-
- return b64.encode(binaryData);
+ public Base64(final boolean urlSafe) {
+ this(MIME_CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
}
/**
- * Decodes a Base64 String into octets.
+ * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
+ * <p>
+ * When encoding the line length is given in the constructor, the line
separator is CRLF, and the encoding table is
+ * STANDARD_ENCODE_TABLE.
+ * </p>
* <p>
- * <b>Note:</b> this method only handles data encoded in standard mode.
+ * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
+ * </p>
+ * <p>
+ * When decoding all variants are supported.
* </p>
*
- * @param base64String
- * String containing Base64 data
- * @return Array containing decoded data.
+ * @param lineLength
+ * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
+ * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
+ * decoding.
* @since 1.4
*/
- public static byte[] decodeBase64(final String base64String) {
- return new Base64().decode(base64String);
+ public Base64(final int lineLength) {
+ this(lineLength, CHUNK_SEPARATOR);
}
/**
- * Decodes Base64 data into octets.
+ * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
* <p>
- * <b>Note:</b> this method only handles data encoded in standard mode.
+ * When encoding the line length and line separator are given in the
constructor, and the encoding table is
+ * STANDARD_ENCODE_TABLE.
+ * </p>
+ * <p>
+ * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
+ * </p>
+ * <p>
+ * When decoding all variants are supported.
* </p>
*
- * @param base64Data
- * Byte array containing Base64 data
- * @return Array containing decoded data.
+ * @param lineLength
+ * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
+ * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
+ * decoding.
+ * @param lineSeparator
+ * Each line of encoded data will end with this sequence of
bytes.
+ * @throws IllegalArgumentException
+ * Thrown when the provided lineSeparator included some base64
characters.
+ * @since 1.4
*/
- public static byte[] decodeBase64(final byte[] base64Data) {
- return decodeBase64(base64Data, 0, base64Data.length);
- }
-
- public static byte[] decodeBase64(
- final byte[] base64Data, final int off, final int len) {
- return new Base64().decode(base64Data, off, len);
+ public Base64(final int lineLength, final byte[] lineSeparator) {
+ this(lineLength, lineSeparator, false);
}
- // Implementation of the Encoder Interface
-
- // Implementation of integer encoding used for crypto
/**
- * Decodes a byte64-encoded integer according to crypto standards such as
W3C's XML-Signature.
+ * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
+ * <p>
+ * When encoding the line length and line separator are given in the
constructor, and the encoding table is
+ * STANDARD_ENCODE_TABLE.
+ * </p>
+ * <p>
+ * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
+ * </p>
+ * <p>
+ * When decoding all variants are supported.
+ * </p>
*
- * @param pArray
- * a byte array containing base64 character data
- * @return A BigInteger
+ * @param lineLength
+ * Each line of encoded data will be at most of the given
length (rounded down to nearest multiple of
+ * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
+ * decoding.
+ * @param lineSeparator
+ * Each line of encoded data will end with this sequence of
bytes.
+ * @param urlSafe
+ * Instead of emitting '+' and '/' we emit '-' and '_'
respectively. urlSafe is only applied to encode
+ * operations. Decoding seamlessly handles both modes.
+ * <b>Note: no padding is added when using the URL-safe
alphabet.</b>
+ * @throws IllegalArgumentException
+ * Thrown when the {@code lineSeparator} contains Base64
characters.
* @since 1.4
*/
- public static BigInteger decodeInteger(final byte[] pArray) {
- return new BigInteger(1, decodeBase64(pArray));
+ public Base64(final int lineLength, final byte[] lineSeparator, final
boolean urlSafe) {
+ super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK,
+ lineLength,
+ lineSeparator == null ? 0 : lineSeparator.length);
+ // Needs to be set early to avoid NPE during call to
containsAlphabetOrPad() below
+ this.decodeTable = urlSafe ? URL_SAFE_DECODE_TABLE :
STANDARD_DECODE_TABLE;
+ // TODO could be simplified if there is no requirement to reject
invalid line sep when length <=0
+ // @see test case Base64Test.testConstructors()
+ if (lineSeparator != null) {
+ if (containsAlphabetOrPad(lineSeparator)) {
+ final String sep = StringUtils.newStringUtf8(lineSeparator);
+ throw new
IllegalArgumentException(sm.getString("base64.lineSeparator", sep));
+ }
+ if (lineLength > 0){ // null line-sep forces no chunking rather
than throwing IAE
+ this.encodeSize = BYTES_PER_ENCODED_BLOCK +
lineSeparator.length;
+ this.lineSeparator = new byte[lineSeparator.length];
+ System.arraycopy(lineSeparator, 0, this.lineSeparator, 0,
lineSeparator.length);
+ } else {
+ this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+ this.lineSeparator = null;
+ }
+ } else {
+ this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+ this.lineSeparator = null;
+ }
+ this.decodeSize = this.encodeSize - 1;
+ this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE :
STANDARD_ENCODE_TABLE;
}
+ // Implementation of the Encoder Interface
+
/**
- * Encodes to a byte64-encoded integer according to crypto standards such
as W3C's XML-Signature.
+ * <p>
+ * Decodes all of the provided data, starting at inPos, for inAvail bytes.
Should be called at least twice: once
+ * with the data to decode, and once with inAvail set to "-1" to alert
decoder that EOF has been reached. The "-1"
+ * call is not necessary when decoding, but it doesn't hurt, either.
+ * </p>
+ * <p>
+ * Ignores all non-base64 characters. This is how chunked (e.g. 76
character) data is handled, since CR and LF are
+ * silently ignored, but has implications for other bytes, too. This
method subscribes to the garbage-in,
+ * garbage-out philosophy: it will not check the provided data for
validity.
+ * </p>
+ * <p>
+ * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
+ * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ * </p>
*
- * @param bigInt
- * a BigInteger
- * @return A byte array containing base64 character data
- * @throws NullPointerException
- * if null is passed in
- * @since 1.4
+ * @param in
+ * byte[] array of ascii data to base64 decode.
+ * @param inPos
+ * Position to start reading data from.
+ * @param inAvail
+ * Amount of bytes available from input for decoding.
+ * @param context
+ * the context to be used
*/
- public static byte[] encodeInteger(final BigInteger bigInt) {
- if (bigInt == null) {
- throw new NullPointerException("encodeInteger called with null
parameter");
+ @Override
+ void decode(final byte[] in, int inPos, final int inAvail, final Context
context) {
+ if (context.eof) {
+ return;
+ }
+ if (inAvail < 0) {
+ context.eof = true;
+ }
+ for (int i = 0; i < inAvail; i++) {
+ final byte[] buffer = ensureBufferSize(decodeSize, context);
+ final byte b = in[inPos++];
+ if (b == pad) {
+ // We're done.
+ context.eof = true;
+ break;
+ }
+ if (b >= 0 && b < decodeTable.length) {
+ final int result = decodeTable[b];
+ if (result >= 0) {
+ context.modulus = (context.modulus+1) %
BYTES_PER_ENCODED_BLOCK;
+ context.ibitWorkArea = (context.ibitWorkArea <<
BITS_PER_ENCODED_BYTE) + result;
+ if (context.modulus == 0) {
+ buffer[context.pos++] = (byte) ((context.ibitWorkArea
>> 16) & MASK_8BITS);
+ buffer[context.pos++] = (byte) ((context.ibitWorkArea
>> 8) & MASK_8BITS);
+ buffer[context.pos++] = (byte) (context.ibitWorkArea &
MASK_8BITS);
+ }
+ }
+ }
+ }
+
+ // Two forms of EOF as far as base64 decoder is concerned: actual
+ // EOF (-1) and first time '=' character is encountered in stream.
+ // This approach makes the '=' padding characters completely optional.
+ if (context.eof && context.modulus != 0) {
+ final byte[] buffer = ensureBufferSize(decodeSize, context);
+
+ // We have some spare bits remaining
+ // Output all whole multiples of 8 bits and ignore the rest
+ switch (context.modulus) {
+// case 0 : // impossible, as excluded above
+// case 1 : // 6 bits - invalid - use default below
+ case 2 : // 12 bits = 8 + 4
+ validateCharacter(MASK_4BITS, context);
+ context.ibitWorkArea = context.ibitWorkArea >> 4; // dump
the extra 4 bits
+ buffer[context.pos++] = (byte) ((context.ibitWorkArea) &
MASK_8BITS);
+ break;
+ case 3 : // 18 bits = 8 + 8 + 2
+ validateCharacter(MASK_2BITS, context);
+ context.ibitWorkArea = context.ibitWorkArea >> 2; // dump
2 bits
+ buffer[context.pos++] = (byte) ((context.ibitWorkArea >>
8) & MASK_8BITS);
+ buffer[context.pos++] = (byte) ((context.ibitWorkArea) &
MASK_8BITS);
+ break;
+ default:
+ throw new IllegalStateException(sm.getString(
+ "base64.impossibleModulus",
Integer.valueOf(context.modulus)));
+ }
}
- return encodeBase64(toIntegerBytes(bigInt), false);
}
/**
- * Returns a byte-array representation of a <code>BigInteger</code>
without sign bit.
+ * <p>
+ * Encodes all of the provided data, starting at inPos, for inAvail bytes.
Must be called at least twice: once with
+ * the data to encode, and once with inAvail set to "-1" to alert encoder
that EOF has been reached, to flush last
+ * remaining bytes (if not multiple of 3).
+ * </p>
+ * <p><b>Note: no padding is added when encoding using the URL-safe
alphabet.</b></p>
+ * <p>
+ * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
+ * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ * </p>
*
- * @param bigInt
- * <code>BigInteger</code> to be converted
- * @return a byte array representation of the BigInteger parameter
+ * @param in
+ * byte[] array of binary data to base64 encode.
+ * @param inPos
+ * Position to start reading data from.
+ * @param inAvail
+ * Amount of bytes available from input for encoding.
+ * @param context
+ * the context to be used
*/
- static byte[] toIntegerBytes(final BigInteger bigInt) {
- int bitlen = bigInt.bitLength();
- // round bitlen
- bitlen = ((bitlen + 7) >> 3) << 3;
- final byte[] bigBytes = bigInt.toByteArray();
-
- if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1)
== (bitlen / 8))) {
- return bigBytes;
+ @Override
+ void encode(final byte[] in, int inPos, final int inAvail, final Context
context) {
+ if (context.eof) {
+ return;
}
- // set up params for copying everything but sign bit
- int startSrc = 0;
- int len = bigBytes.length;
+ // inAvail < 0 is how we're informed of EOF in the underlying data
we're
+ // encoding.
+ if (inAvail < 0) {
+ context.eof = true;
+ if (0 == context.modulus && lineLength == 0) {
+ return; // no leftovers to process and not using chunking
+ }
+ final byte[] buffer = ensureBufferSize(encodeSize, context);
+ final int savedPos = context.pos;
+ switch (context.modulus) { // 0-2
+ case 0 : // nothing to do here
+ break;
+ case 1 : // 8 bits = 6 + 2
+ // top 6 bits:
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 2) & MASK_6BITS];
+ // remaining 2:
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
<< 4) & MASK_6BITS];
+ // URL-SAFE skips the padding to further reduce size.
+ if (encodeTable == STANDARD_ENCODE_TABLE) {
+ buffer[context.pos++] = pad;
+ buffer[context.pos++] = pad;
+ }
+ break;
- // if bigInt is exactly byte-aligned, just skip signbit in copy
- if ((bigInt.bitLength() % 8) == 0) {
- startSrc = 1;
- len--;
+ case 2 : // 16 bits = 6 + 6 + 4
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 10) & MASK_6BITS];
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 4) & MASK_6BITS];
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
<< 2) & MASK_6BITS];
+ // URL-SAFE skips the padding to further reduce size.
+ if (encodeTable == STANDARD_ENCODE_TABLE) {
+ buffer[context.pos++] = pad;
+ }
+ break;
+ default:
+ throw new IllegalStateException(sm.getString(
+ "base64.impossibleModulus",
Integer.valueOf(context.modulus)));
+ }
+ context.currentLinePos += context.pos - savedPos; // keep track of
current line position
+ // if currentPos == 0 we are at the start of a line, so don't add
CRLF
+ if (lineLength > 0 && context.currentLinePos > 0) {
+ System.arraycopy(lineSeparator, 0, buffer, context.pos,
lineSeparator.length);
+ context.pos += lineSeparator.length;
+ }
+ } else {
+ for (int i = 0; i < inAvail; i++) {
+ final byte[] buffer = ensureBufferSize(encodeSize, context);
+ context.modulus = (context.modulus+1) %
BYTES_PER_UNENCODED_BLOCK;
+ int b = in[inPos++];
+ if (b < 0) {
+ b += 256;
+ }
+ context.ibitWorkArea = (context.ibitWorkArea << 8) + b; //
BITS_PER_BYTE
+ if (0 == context.modulus) { // 3 bytes = 24 bits = 4 * 6 bits
to extract
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 18) & MASK_6BITS];
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 12) & MASK_6BITS];
+ buffer[context.pos++] = encodeTable[(context.ibitWorkArea
>> 6) & MASK_6BITS];
+ buffer[context.pos++] = encodeTable[context.ibitWorkArea &
MASK_6BITS];
+ context.currentLinePos += BYTES_PER_ENCODED_BLOCK;
+ if (lineLength > 0 && lineLength <=
context.currentLinePos) {
+ System.arraycopy(lineSeparator, 0, buffer,
context.pos, lineSeparator.length);
+ context.pos += lineSeparator.length;
+ context.currentLinePos = 0;
+ }
+ }
+ }
}
- final int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
- final byte[] resizedBytes = new byte[bitlen / 8];
- System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
- return resizedBytes;
}
/**
- * Returns whether or not the <code>octet</code> is in the Base64 alphabet.
+ * Returns whether or not the {@code octet} is in the Base64 alphabet.
*
* @param octet
* The value to test
- * @return <code>true</code> if the value is defined in the the Base64
alphabet <code>false</code> otherwise.
+ * @return {@code true} if the value is defined in the the Base64 alphabet
{@code false} otherwise.
*/
@Override
protected boolean isInAlphabet(final byte octet) {
return octet >= 0 && octet < decodeTable.length && decodeTable[octet]
!= -1;
}
-
/**
- * Validates whether decoding the final trailing character is possible in
the context
- * of the set of possible base 64 values.
- *
- * <p>The character is valid if the lower bits within the provided mask
are zero. This
- * is used to test the final trailing base-64 digit is zero in the bits
that will be discarded.
- *
- * @param emptyBitsMask The mask of the lower bits that should be empty
- * @param context the context to be used
+ * Returns our current encode mode. True if we're URL-SAFE, false
otherwise.
*
- * @throws IllegalArgumentException if the bits being checked contain any
non-zero value
+ * @return true if we're in URL-SAFE mode, false otherwise.
+ * @since 1.4
*/
- private static void validateCharacter(final int emptyBitsMask, final
Context context) {
- if ((context.ibitWorkArea & emptyBitsMask) != 0) {
- throw new IllegalArgumentException(
- "Last encoded character (before the paddings if any) is a
valid base 64 alphabet but not a possible value. " +
- "Expected the discarded bits to be zero.");
- }
+ public boolean isUrlSafe() {
+ return this.encodeTable == URL_SAFE_ENCODE_TABLE;
}
}
diff --git a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
b/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
index 0245942..e3e8f46 100644
--- a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
+++ b/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
@@ -21,6 +21,7 @@ import org.apache.tomcat.util.codec.BinaryDecoder;
import org.apache.tomcat.util.codec.BinaryEncoder;
import org.apache.tomcat.util.codec.DecoderException;
import org.apache.tomcat.util.codec.EncoderException;
+import org.apache.tomcat.util.res.StringManager;
/**
* Abstract superclass for Base-N encoders and decoders.
@@ -31,6 +32,8 @@ import org.apache.tomcat.util.codec.EncoderException;
*/
public abstract class BaseNCodec implements BinaryEncoder, BinaryDecoder {
+ protected static final StringManager sm =
StringManager.getManager(BaseNCodec.class);
+
/**
* Holds thread context so classes can be thread-safe.
*
@@ -47,12 +50,6 @@ public abstract class BaseNCodec implements BinaryEncoder,
BinaryDecoder {
int ibitWorkArea;
/**
- * Place holder for the bytes we're dealing with for our based logic.
- * Bitwise operations store and extract the encoding or decoding from
this variable.
- */
- long lbitWorkArea;
-
- /**
* Buffer for streaming.
*/
byte[] buffer;
@@ -96,11 +93,9 @@ public abstract class BaseNCodec implements BinaryEncoder,
BinaryDecoder {
@SuppressWarnings("boxing") // OK to ignore boxing here
@Override
public String toString() {
- return String.format("%s[buffer=%s, currentLinePos=%s, eof=%s, " +
- "ibitWorkArea=%s, lbitWorkArea=%s, modulus=%s, pos=%s, " +
- "readPos=%s]", this.getClass().getSimpleName(),
- HexUtils.toHexString(buffer), currentLinePos, eof,
- ibitWorkArea, lbitWorkArea, modulus, pos, readPos);
+ return String.format("%s[buffer=%s, currentLinePos=%s, eof=%s,
ibitWorkArea=%s, " +
+ "modulus=%s, pos=%s, readPos=%s]",
this.getClass().getSimpleName(), HexUtils.toHexString(buffer),
+ currentLinePos, eof, ibitWorkArea, modulus, pos, readPos);
}
}
@@ -163,7 +158,112 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
*/
protected static final byte PAD_DEFAULT = '='; // Allow static access to
default
- protected final byte PAD = PAD_DEFAULT; // instance variable just in case
it needs to vary later
+ /**
+ * Chunk separator per RFC 2045 section 2.1.
+ *
+ * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045 section
2.1</a>
+ */
+ static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
+
+ /**
+ * Compares two {@code int} values numerically treating the values
+ * as unsigned. Taken from JDK 1.8.
+ *
+ * <p>TODO: Replace with JDK 1.8 Integer::compareUnsigned(int, int).</p>
+ *
+ * @param x the first {@code int} to compare
+ * @param y the second {@code int} to compare
+ * @return the value {@code 0} if {@code x == y}; a value less
+ * than {@code 0} if {@code x < y} as unsigned values; and
+ * a value greater than {@code 0} if {@code x > y} as
+ * unsigned values
+ */
+ private static int compareUnsigned(int x, int y) {
+ return Integer.valueOf(x +
Integer.MIN_VALUE).compareTo(Integer.valueOf(y + Integer.MIN_VALUE));
+ }
+
+ /**
+ * Create a positive capacity at least as large the minimum required
capacity.
+ * If the minimum capacity is negative then this throws an
OutOfMemoryError as no array
+ * can be allocated.
+ *
+ * @param minCapacity the minimum capacity
+ * @return the capacity
+ * @throws OutOfMemoryError if the {@code minCapacity} is negative
+ */
+ private static int createPositiveCapacity(final int minCapacity) {
+ if (minCapacity < 0) {
+ // overflow
+ throw new OutOfMemoryError("Unable to allocate array size: " +
(minCapacity & 0xffffffffL));
+ }
+ // This is called when we require buffer expansion to a very big array.
+ // Use the conservative maximum buffer size if possible, otherwise the
biggest required.
+ //
+ // Note: In this situation JDK 1.8 java.util.ArrayList returns
Integer.MAX_VALUE.
+ // This excludes some VMs that can exceed MAX_BUFFER_SIZE but not
allocate a full
+ // Integer.MAX_VALUE length array.
+ // The result is that we may have to allocate an array of this size
more than once if
+ // the capacity must be expanded again.
+ return (minCapacity > MAX_BUFFER_SIZE) ?
+ minCapacity :
+ MAX_BUFFER_SIZE;
+ }
+
+ /**
+ * Gets a copy of the chunk separator per RFC 2045 section 2.1.
+ *
+ * @return the chunk separator
+ * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045 section
2.1</a>
+ * @since 1.15
+ */
+ public static byte[] getChunkSeparator() {
+ return CHUNK_SEPARATOR.clone();
+ }
+
+ /**
+ * Checks if a byte value is whitespace or not.
+ * Whitespace is taken to mean: space, tab, CR, LF
+ * @param byteToCheck
+ * the byte to check
+ * @return true if byte is whitespace, false otherwise
+ */
+ protected static boolean isWhiteSpace(final byte byteToCheck) {
+ switch (byteToCheck) {
+ case ' ' :
+ case '\n' :
+ case '\r' :
+ case '\t' :
+ return true;
+ default :
+ return false;
+ }
+ }
+
+ /**
+ * Increases our buffer by the {@link #DEFAULT_BUFFER_RESIZE_FACTOR}.
+ * @param context the context to be used
+ * @param minCapacity the minimum required capacity
+ * @return the resized byte[] buffer
+ * @throws OutOfMemoryError if the {@code minCapacity} is negative
+ */
+ private static byte[] resizeBuffer(final Context context, final int
minCapacity) {
+ // Overflow-conscious code treats the min and new capacity as unsigned.
+ final int oldCapacity = context.buffer.length;
+ int newCapacity = oldCapacity * DEFAULT_BUFFER_RESIZE_FACTOR;
+ if (compareUnsigned(newCapacity, minCapacity) < 0) {
+ newCapacity = minCapacity;
+ }
+ if (compareUnsigned(newCapacity, MAX_BUFFER_SIZE) > 0) {
+ newCapacity = createPositiveCapacity(minCapacity);
+ }
+
+ final byte[] b = new byte[newCapacity];
+ System.arraycopy(context.buffer, 0, b, 0, context.buffer.length);
+ context.buffer = b;
+ return b;
+ }
+
+ protected final byte pad; // instance variable just in case it needs to
vary later
/** Number of bytes in each full block of unencoded data, e.g. 4 for
Base64 and 5 for Base32 */
private final int unencodedBlockSize;
@@ -179,16 +279,16 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
protected final int lineLength;
/**
- * Size of chunk separator. Not used unless {@link #lineLength} > 0.
+ * Size of chunk separator. Not used unless {@link #lineLength} > 0.
*/
private final int chunkSeparatorLength;
/**
- * Note <code>lineLength</code> is rounded down to the nearest multiple of
the encoded block size.
- * If <code>chunkSeparatorLength</code> is zero, then chunking is disabled.
+ * Note {@code lineLength} is rounded down to the nearest multiple of the
encoded block size.
+ * If {@code chunkSeparatorLength} is zero, then chunking is disabled.
* @param unencodedBlockSize the size of an unencoded block (e.g. Base64 =
3)
* @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
- * @param lineLength if > 0, use chunking with a length
<code>lineLength</code>
+ * @param lineLength if > 0, use chunking with a length {@code
lineLength}
* @param chunkSeparatorLength the chunk separator length, if relevant
*/
protected BaseNCodec(final int unencodedBlockSize, final int
encodedBlockSize,
@@ -197,11 +297,11 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
}
/**
- * Note <code>lineLength</code> is rounded down to the nearest multiple of
the encoded block size.
- * If <code>chunkSeparatorLength</code> is zero, then chunking is disabled.
+ * Note {@code lineLength} is rounded down to the nearest multiple of the
encoded block size.
+ * If {@code chunkSeparatorLength} is zero, then chunking is disabled.
* @param unencodedBlockSize the size of an unencoded block (e.g. Base64 =
3)
* @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
- * @param lineLength if > 0, use chunking with a length
<code>lineLength</code>
+ * @param lineLength if > 0, use chunking with a length {@code
lineLength}
* @param chunkSeparatorLength the chunk separator length, if relevant
* @param pad byte used as padding byte.
*/
@@ -212,16 +312,7 @@ public abstract class BaseNCodec implements BinaryEncoder,
BinaryDecoder {
final boolean useChunking = lineLength > 0 && chunkSeparatorLength > 0;
this.lineLength = useChunking ? (lineLength / encodedBlockSize) *
encodedBlockSize : 0;
this.chunkSeparatorLength = chunkSeparatorLength;
- }
-
- /**
- * Returns true if this object has buffered data for reading.
- *
- * @param context the context to be used
- * @return true if there is data still available for reading.
- */
- boolean hasData(final Context context) { // package protected for access
from I/O streams
- return context.buffer != null;
+ this.pad = pad;
}
/**
@@ -235,149 +326,142 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
}
/**
- * Get the default buffer size. Can be overridden.
+ * Tests a given byte array to see if it contains any characters within
the alphabet or PAD.
*
- * @return the default buffer size.
+ * Intended for use in checking line-ending arrays
+ *
+ * @param arrayOctet
+ * byte array to test
+ * @return {@code true} if any byte is a valid character in the alphabet
or PAD; {@code false} otherwise
*/
- protected int getDefaultBufferSize() {
- return DEFAULT_BUFFER_SIZE;
+ protected boolean containsAlphabetOrPad(final byte[] arrayOctet) {
+ if (arrayOctet == null) {
+ return false;
+ }
+ for (final byte element : arrayOctet) {
+ if (pad == element || isInAlphabet(element)) {
+ return true;
+ }
+ }
+ return false;
}
/**
- * Increases our buffer by the {@link #DEFAULT_BUFFER_RESIZE_FACTOR}.
- * @param context the context to be used
- * @param minCapacity the minimum required capacity
- * @return the resized byte[] buffer
- * @throws OutOfMemoryError if the {@code minCapacity} is negative
+ * Decodes a byte[] containing characters in the Base-N alphabet.
+ *
+ * @param pArray
+ * A byte array containing Base-N character data
+ * @return a byte array containing binary data
*/
- private static byte[] resizeBuffer(final Context context, final int
minCapacity) {
- // Overflow-conscious code treats the min and new capacity as unsigned.
- final int oldCapacity = context.buffer.length;
- int newCapacity = oldCapacity * DEFAULT_BUFFER_RESIZE_FACTOR;
- if (compareUnsigned(newCapacity, minCapacity) < 0) {
- newCapacity = minCapacity;
- }
- if (compareUnsigned(newCapacity, MAX_BUFFER_SIZE) > 0) {
- newCapacity = createPositiveCapacity(minCapacity);
- }
+ @Override
+ public byte[] decode(final byte[] pArray) {
+ return decode(pArray, 0, pArray.length);
+ }
- final byte[] b = new byte[newCapacity];
- System.arraycopy(context.buffer, 0, b, 0, context.buffer.length);
- context.buffer = b;
- return b;
+ public byte[] decode(final byte[] pArray, final int off, final int len) {
+ if (pArray == null || len == 0) {
+ return new byte[0];
+ }
+ final Context context = new Context();
+ decode(pArray, off, len, context);
+ decode(pArray, off, EOF, context); // Notify decoder of EOF.
+ final byte[] result = new byte[context.pos];
+ readResults(result, 0, result.length, context);
+ return result;
}
+ // package protected for access from I/O streams
+ abstract void decode(byte[] pArray, int i, int length, Context context);
+
/**
- * Compares two {@code int} values numerically treating the values
- * as unsigned. Taken from JDK 1.8.
- *
- * <p>TODO: Replace with JDK 1.8 Integer::compareUnsigned(int, int).</p>
+ * Decodes a String containing characters in the Base-N alphabet.
*
- * @param x the first {@code int} to compare
- * @param y the second {@code int} to compare
- * @return the value {@code 0} if {@code x == y}; a value less
- * than {@code 0} if {@code x < y} as unsigned values; and
- * a value greater than {@code 0} if {@code x > y} as
- * unsigned values
+ * @param pArray
+ * A String containing Base-N character data
+ * @return a byte array containing binary data
*/
- private static int compareUnsigned(int x, int y) {
- return Integer.valueOf(x +
Integer.MIN_VALUE).compareTo(Integer.valueOf(y + Integer.MIN_VALUE));
+ public byte[] decode(final String pArray) {
+ return decode(StringUtils.getBytesUtf8(pArray));
}
/**
- * Create a positive capacity at least as large the minimum required
capacity.
- * If the minimum capacity is negative then this throws an
OutOfMemoryError as no array
- * can be allocated.
+ * Decodes an Object using the Base-N algorithm. This method is provided
in order to satisfy the requirements of
+ * the Decoder interface, and will throw a DecoderException if the
supplied object is not of type byte[] or String.
*
- * @param minCapacity the minimum capacity
- * @return the capacity
- * @throws OutOfMemoryError if the {@code minCapacity} is negative
+ * @param obj
+ * Object to decode
+ * @return An object (of type byte[]) containing the binary data which
corresponds to the byte[] or String
+ * supplied.
+ * @throws DecoderException
+ * if the parameter supplied is not of type byte[]
+ * @deprecated This unused method will be removed in Tomcat 9
*/
- private static int createPositiveCapacity(int minCapacity) {
- if (minCapacity < 0) {
- // overflow
- throw new OutOfMemoryError("Unable to allocate array size: " +
(minCapacity & 0xffffffffL));
+ @Override
+ @Deprecated
+ public Object decode(final Object obj) throws DecoderException {
+ if (obj instanceof byte[]) {
+ return decode((byte[]) obj);
+ } else if (obj instanceof String) {
+ return decode((String) obj);
+ } else {
+ throw new DecoderException("Parameter supplied to Base-N decode is
not a byte[] or a String");
}
- // This is called when we require buffer expansion to a very big array.
- // Use the conservative maximum buffer size if possible, otherwise the
biggest required.
- //
- // Note: In this situation JDK 1.8 java.util.ArrayList returns
Integer.MAX_VALUE.
- // This excludes some VMs that can exceed MAX_BUFFER_SIZE but not
allocate a full
- // Integer.MAX_VALUE length array.
- // The result is that we may have to allocate an array of this size
more than once if
- // the capacity must be expanded again.
- return (minCapacity > MAX_BUFFER_SIZE) ?
- minCapacity :
- MAX_BUFFER_SIZE;
}
/**
- * Ensure that the buffer has room for <code>size</code> bytes
+ * Encodes a byte[] containing binary data, into a byte[] containing
characters in the alphabet.
*
- * @param size minimum spare space required
- * @param context the context to be used
- * @return the buffer
+ * @param pArray
+ * a byte array containing binary data
+ * @return A byte array containing only the base N alphabetic character
data
*/
- protected byte[] ensureBufferSize(final int size, final Context context){
- if (context.buffer == null) {
- context.buffer = new byte[getDefaultBufferSize()];
- context.pos = 0;
- context.readPos = 0;
-
- // Overflow-conscious:
- // x + y > z == x + y - z > 0
- } else if (context.pos + size - context.buffer.length > 0) {
- return resizeBuffer(context, context.pos + size);
+ @Override
+ public byte[] encode(final byte[] pArray) {
+ if (pArray == null || pArray.length == 0) {
+ return pArray;
}
- return context.buffer;
+ return encode(pArray, 0, pArray.length);
}
/**
- * Extracts buffered data into the provided byte[] array, starting at
position bPos, up to a maximum of bAvail
- * bytes. Returns how many bytes were actually extracted.
- * <p>
- * Package protected for access from I/O streams.
+ * Encodes a byte[] containing binary data, into a byte[] containing
+ * characters in the alphabet.
*
- * @param b
- * byte[] array to extract the buffered data into.
- * @param bPos
- * position in byte[] array to start extraction at.
- * @param bAvail
- * amount of bytes we're allowed to extract. We may extract
fewer (if fewer are available).
- * @param context
- * the context to be used
- * @return The number of bytes successfully extracted into the provided
byte[] array.
+ * @param pArray
+ * a byte array containing binary data
+ * @param offset
+ * initial offset of the subarray.
+ * @param length
+ * length of the subarray.
+ * @return A byte array containing only the base N alphabetic character
data
+ * @since 1.11
*/
- int readResults(final byte[] b, final int bPos, final int bAvail, final
Context context) {
- if (context.buffer != null) {
- final int len = Math.min(available(context), bAvail);
- System.arraycopy(context.buffer, context.readPos, b, bPos, len);
- context.readPos += len;
- if (context.readPos >= context.pos) {
- context.buffer = null; // so hasData() will return false, and
this method can return -1
- }
- return len;
+ public byte[] encode(final byte[] pArray, final int offset, final int
length) {
+ if (pArray == null || pArray.length == 0) {
+ return pArray;
}
- return context.eof ? EOF : 0;
+ final Context context = new Context();
+ encode(pArray, offset, length, context);
+ encode(pArray, offset, EOF, context); // Notify encoder of EOF.
+ final byte[] buf = new byte[context.pos - context.readPos];
+ readResults(buf, 0, buf.length, context);
+ return buf;
}
+ // package protected for access from I/O streams
+ abstract void encode(byte[] pArray, int i, int length, Context context);
+
/**
- * Checks if a byte value is whitespace or not.
- * Whitespace is taken to mean: space, tab, CR, LF
- * @param byteToCheck
- * the byte to check
- * @return true if byte is whitespace, false otherwise
- */
- protected static boolean isWhiteSpace(final byte byteToCheck) {
- switch (byteToCheck) {
- case ' ' :
- case '\n' :
- case '\r' :
- case '\t' :
- return true;
- default :
- return false;
- }
+ * Encodes a byte[] containing binary data, into a String containing
characters in the appropriate alphabet.
+ * Uses UTF8 encoding.
+ *
+ * @param pArray a byte array containing binary data
+ * @return String containing only character data in the appropriate
alphabet.
+ * @since 1.5
+ * This is a duplicate of {@link #encodeToString(byte[])}; it was merged
during refactoring.
+ */
+ public String encodeAsString(final byte[] pArray){
+ return StringUtils.newStringUtf8(encode(pArray));
}
/**
@@ -389,8 +473,10 @@ public abstract class BaseNCodec implements BinaryEncoder,
BinaryDecoder {
* @return An object (of type byte[]) containing the Base-N encoded data
which corresponds to the byte[] supplied.
* @throws EncoderException
* if the parameter supplied is not of type byte[]
+ * @deprecated This unused method will be removed in Tomcat 9
*/
@Override
+ @Deprecated
public Object encode(final Object obj) throws EncoderException {
if (!(obj instanceof byte[])) {
throw new EncoderException("Parameter supplied to Base-N encode is
not a byte[]");
@@ -411,108 +497,71 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
}
/**
- * Encodes a byte[] containing binary data, into a String containing
characters in the appropriate alphabet.
- * Uses UTF8 encoding.
- *
- * @param pArray a byte array containing binary data
- * @return String containing only character data in the appropriate
alphabet.
- * @since 1.5
- * This is a duplicate of {@link #encodeToString(byte[])}; it was merged
during refactoring.
- */
- public String encodeAsString(final byte[] pArray){
- return StringUtils.newStringUtf8(encode(pArray));
- }
-
- /**
- * Decodes an Object using the Base-N algorithm. This method is provided
in order to satisfy the requirements of
- * the Decoder interface, and will throw a DecoderException if the
supplied object is not of type byte[] or String.
+ * Ensure that the buffer has room for {@code size} bytes
*
- * @param obj
- * Object to decode
- * @return An object (of type byte[]) containing the binary data which
corresponds to the byte[] or String
- * supplied.
- * @throws DecoderException
- * if the parameter supplied is not of type byte[]
+ * @param size minimum spare space required
+ * @param context the context to be used
+ * @return the buffer
*/
- @Override
- public Object decode(final Object obj) throws DecoderException {
- if (obj instanceof byte[]) {
- return decode((byte[]) obj);
- } else if (obj instanceof String) {
- return decode((String) obj);
- } else {
- throw new DecoderException("Parameter supplied to Base-N decode is
not a byte[] or a String");
+ protected byte[] ensureBufferSize(final int size, final Context context){
+ if (context.buffer == null) {
+ context.buffer = new byte[Math.max(size, getDefaultBufferSize())];
+ context.pos = 0;
+ context.readPos = 0;
+
+ // Overflow-conscious:
+ // x + y > z == x + y - z > 0
+ } else if (context.pos + size - context.buffer.length > 0) {
+ return resizeBuffer(context, context.pos + size);
}
+ return context.buffer;
}
/**
- * Decodes a String containing characters in the Base-N alphabet.
+ * Get the default buffer size. Can be overridden.
*
- * @param pArray
- * A String containing Base-N character data
- * @return a byte array containing binary data
+ * @return the default buffer size.
*/
- public byte[] decode(final String pArray) {
- return decode(StringUtils.getBytesUtf8(pArray));
+ protected int getDefaultBufferSize() {
+ return DEFAULT_BUFFER_SIZE;
}
/**
- * Decodes a byte[] containing characters in the Base-N alphabet.
+ * Calculates the amount of space needed to encode the supplied array.
*
- * @param pArray
- * A byte array containing Base-N character data
- * @return a byte array containing binary data
+ * @param pArray byte[] array which will later be encoded
+ *
+ * @return amount of space needed to encoded the supplied array.
+ * Returns a long since a max-len array will require > Integer.MAX_VALUE
*/
- @Override
- public byte[] decode(final byte[] pArray) {
- return decode(pArray, 0, pArray.length);
- }
-
- public byte[] decode(final byte[] pArray, final int off, final int len) {
- if (pArray == null || len == 0) {
- return new byte[0];
+ public long getEncodedLength(final byte[] pArray) {
+ // Calculate non-chunked size - rounded up to allow for padding
+ // cast to long is needed to avoid possibility of overflow
+ long len = ((pArray.length + unencodedBlockSize-1) /
unencodedBlockSize) * (long) encodedBlockSize;
+ if (lineLength > 0) { // We're using chunking
+ // Round up to nearest multiple
+ len += ((len + lineLength-1) / lineLength) * chunkSeparatorLength;
}
- final Context context = new Context();
- decode(pArray, off, len, context);
- decode(pArray, off, EOF, context); // Notify decoder of EOF.
- final byte[] result = new byte[context.pos];
- readResults(result, 0, result.length, context);
- return result;
+ return len;
}
/**
- * Encodes a byte[] containing binary data, into a byte[] containing
characters in the alphabet.
+ * Returns true if this object has buffered data for reading.
*
- * @param pArray
- * a byte array containing binary data
- * @return A byte array containing only the base N alphabetic character
data
+ * @param context the context to be used
+ * @return true if there is data still available for reading.
*/
- @Override
- public byte[] encode(final byte[] pArray) {
- if (pArray == null || pArray.length == 0) {
- return pArray;
- }
- final Context context = new Context();
- encode(pArray, 0, pArray.length, context);
- encode(pArray, 0, EOF, context); // Notify encoder of EOF.
- final byte[] buf = new byte[context.pos - context.readPos];
- readResults(buf, 0, buf.length, context);
- return buf;
+ boolean hasData(final Context context) { // package protected for access
from I/O streams
+ return context.buffer != null;
}
- // package protected for access from I/O streams
- abstract void encode(byte[] pArray, int i, int length, Context context);
-
- // package protected for access from I/O streams
- abstract void decode(byte[] pArray, int i, int length, Context context);
-
/**
- * Returns whether or not the <code>octet</code> is in the current
alphabet.
+ * Returns whether or not the {@code octet} is in the current alphabet.
* Does not allow whitespace or pad.
*
* @param value The value to test
*
- * @return <code>true</code> if the value is defined in the current
alphabet, <code>false</code> otherwise.
+ * @return {@code true} if the value is defined in the current alphabet,
{@code false} otherwise.
*/
protected abstract boolean isInAlphabet(byte value);
@@ -521,15 +570,15 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
* The method optionally treats whitespace and pad as valid.
*
* @param arrayOctet byte array to test
- * @param allowWSPad if <code>true</code>, then whitespace and PAD are
also allowed
+ * @param allowWSPad if {@code true}, then whitespace and PAD are also
allowed
*
- * @return <code>true</code> if all bytes are valid characters in the
alphabet or if the byte array is empty;
- * <code>false</code>, otherwise
+ * @return {@code true} if all bytes are valid characters in the alphabet
or if the byte array is empty;
+ * {@code false}, otherwise
*/
public boolean isInAlphabet(final byte[] arrayOctet, final boolean
allowWSPad) {
for (final byte octet : arrayOctet) {
if (!isInAlphabet(octet) &&
- (!allowWSPad || (octet != PAD) && !isWhiteSpace(octet))) {
+ (!allowWSPad || (octet != pad) && !isWhiteSpace(octet))) {
return false;
}
}
@@ -541,8 +590,8 @@ public abstract class BaseNCodec implements BinaryEncoder,
BinaryDecoder {
* The method treats whitespace and PAD as valid.
*
* @param basen String to test
- * @return <code>true</code> if all characters in the String are valid
characters in the alphabet or if
- * the String is empty; <code>false</code>, otherwise
+ * @return {@code true} if all characters in the String are valid
characters in the alphabet or if
+ * the String is empty; {@code false}, otherwise
* @see #isInAlphabet(byte[], boolean)
*/
public boolean isInAlphabet(final String basen) {
@@ -550,42 +599,31 @@ public abstract class BaseNCodec implements
BinaryEncoder, BinaryDecoder {
}
/**
- * Tests a given byte array to see if it contains any characters within
the alphabet or PAD.
- *
- * Intended for use in checking line-ending arrays
+ * Extracts buffered data into the provided byte[] array, starting at
position bPos, up to a maximum of bAvail
+ * bytes. Returns how many bytes were actually extracted.
+ * <p>
+ * Package protected for access from I/O streams.
*
- * @param arrayOctet
- * byte array to test
- * @return <code>true</code> if any byte is a valid character in the
alphabet or PAD; <code>false</code> otherwise
+ * @param b
+ * byte[] array to extract the buffered data into.
+ * @param bPos
+ * position in byte[] array to start extraction at.
+ * @param bAvail
+ * amount of bytes we're allowed to extract. We may extract
fewer (if fewer are available).
+ * @param context
+ * the context to be used
+ * @return The number of bytes successfully extracted into the provided
byte[] array.
*/
- protected boolean containsAlphabetOrPad(final byte[] arrayOctet) {
- if (arrayOctet == null) {
- return false;
- }
- for (final byte element : arrayOctet) {
- if (PAD == element || isInAlphabet(element)) {
- return true;
+ int readResults(final byte[] b, final int bPos, final int bAvail, final
Context context) {
+ if (context.buffer != null) {
+ final int len = Math.min(available(context), bAvail);
+ System.arraycopy(context.buffer, context.readPos, b, bPos, len);
+ context.readPos += len;
+ if (context.readPos >= context.pos) {
+ context.buffer = null; // so hasData() will return false, and
this method can return -1
}
+ return len;
}
- return false;
- }
-
- /**
- * Calculates the amount of space needed to encode the supplied array.
- *
- * @param pArray byte[] array which will later be encoded
- *
- * @return amount of space needed to encoded the supplied array.
- * Returns a long since a max-len array will require > Integer.MAX_VALUE
- */
- public long getEncodedLength(final byte[] pArray) {
- // Calculate non-chunked size - rounded up to allow for padding
- // cast to long is needed to avoid possibility of overflow
- long len = ((pArray.length + unencodedBlockSize-1) /
unencodedBlockSize) * (long) encodedBlockSize;
- if (lineLength > 0) { // We're using chunking
- // Round up to nearest multiple
- len += ((len + lineLength-1) / lineLength) * chunkSeparatorLength;
- }
- return len;
+ return context.eof ? EOF : 0;
}
}
diff --git a/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
new file mode 100644
index 0000000..1ae86a3
--- /dev/null
+++ b/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+base64.impossibleModulus=Impossible modulus [{0}]
+base64.inputTooLarge=Input array too large, the output array would be bigger
[{0}] than the specified maximum size of [{1}]
+base64.lineSeparator=Line separator must not contain base64 characters [{0}]
+base64.nullEncodeParameter=Cannot encode integer with null parameter
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
new file mode 100644
index 0000000..a2d0a67
--- /dev/null
+++ b/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+base64.impossibleModulus=Modulo [{0}] invalide
+base64.inputTooLarge=Le tableau en entrée est trop grand, la taille du tableau
de sortie [{0}] serait plus grande que la taille maximale autorisée [{1}]
+base64.lineSeparator=Le séparateur de ligne ne doit pas contenir des
caractères base64 [{0}]
+base64.nullEncodeParameter=Impossible d'encoder unentier en utilisant un
paramètre null
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
new file mode 100644
index 0000000..aaf4b51
--- /dev/null
+++ b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+base64.impossibleModulus=計算できない剰余 [{0}] です。
+base64.inputTooLarge=入力配列が大きすぎます。出力配列は[{1}]の指定された最大サイズよりも大きくなります[{0}]。
+base64.lineSeparator=行区切り記号にはbase64文字を使用できません[{0}]
+base64.nullEncodeParameter=null 値を整数に符号化できませんでした。
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
new file mode 100644
index 0000000..7bdc2bb
--- /dev/null
+++ b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+base64.impossibleModulus=불가능한 계수 [{0}]
+base64.inputTooLarge=입력 배열이 너무 큽니다. 출력 배열의 크기 [{0}]이(가), 지정된 최대 크기 [{1}] 보다 큰
값입니다.
+base64.lineSeparator=행 구분문자 [{0}]은(는) Base64 문자들을 포함해서는 안됩니다.
+base64.nullEncodeParameter=정수를 위한 파라미터가 널이라서 인코딩할 수 없습니다.
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
new file mode 100644
index 0000000..0624dec
--- /dev/null
+++ b/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+base64.impossibleModulus=不可能的模[{0}]
+base64.inputTooLarge=输入数组太大，输出数组将比指定的最大大小[{1}]大[{0}]
+base64.lineSeparator=行分隔符不能包含base64个字符[{0}]
+base64.nullEncodeParameter=不能用空参数编码整数
diff --git a/java/org/apache/tomcat/util/codec/binary/StringUtils.java
b/java/org/apache/tomcat/util/codec/binary/StringUtils.java
index a7b189d..2d49d4e 100644
--- a/java/org/apache/tomcat/util/codec/binary/StringUtils.java
+++ b/java/org/apache/tomcat/util/codec/binary/StringUtils.java
@@ -38,7 +38,7 @@ public class StringUtils {
* @param string
* The string to encode (if null, return null).
* @param charset
- * The {@link Charset} to encode the <code>String</code>
+ * The {@link Charset} to encode the {@code String}
* @return the encoded bytes
*/
private static byte[] getBytes(final String string, final Charset charset)
{
@@ -53,8 +53,8 @@ public class StringUtils {
* array.
*
* @param string
- * the String to encode, may be <code>null</code>
- * @return encoded bytes, or <code>null</code> if the input string was
<code>null</code>
+ * the String to encode, may be {@code null}
+ * @return encoded bytes, or {@code null} if the input string was {@code
null}
* @see <a
href="http://download.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html";>Standard
charsets</a>
*/
public static byte[] getBytesUtf8(final String string) {
@@ -62,38 +62,40 @@ public class StringUtils {
}
/**
- * Constructs a new <code>String</code> by decoding the specified array of
bytes using the given charset.
+ * Constructs a new {@code String} by decoding the specified array of
bytes using the given charset.
*
* @param bytes
* The bytes to be decoded into characters
* @param charset
- * The {@link Charset} to encode the <code>String</code>
- * @return A new <code>String</code> decoded from the specified array of
bytes using the given charset,
- * or <code>null</code> if the input byte array was
<code>null</code>.
+ * The {@link Charset} to encode the {@code String}; not {@code
null}
+ * @return A new {@code String} decoded from the specified array of bytes
using the given charset,
+ * or {@code null} if the input byte array was {@code null}.
+ * @throws NullPointerException
+ * Thrown if charset is {@code null}
*/
private static String newString(final byte[] bytes, final Charset charset)
{
return bytes == null ? null : new String(bytes, charset);
}
/**
- * Constructs a new <code>String</code> by decoding the specified array of
bytes using the US-ASCII charset.
+ * Constructs a new {@code String} by decoding the specified array of
bytes using the US-ASCII charset.
*
* @param bytes
* The bytes to be decoded into characters
- * @return A new <code>String</code> decoded from the specified array of
bytes using the US-ASCII charset,
- * or <code>null</code> if the input byte array was
<code>null</code>.
+ * @return A new {@code String} decoded from the specified array of bytes
using the US-ASCII charset,
+ * or {@code null} if the input byte array was {@code null}.
*/
public static String newStringUsAscii(final byte[] bytes) {
return newString(bytes, Charset.forName("US-ASCII"));
}
/**
- * Constructs a new <code>String</code> by decoding the specified array of
bytes using the UTF-8 charset.
+ * Constructs a new {@code String} by decoding the specified array of
bytes using the UTF-8 charset.
*
* @param bytes
* The bytes to be decoded into characters
- * @return A new <code>String</code> decoded from the specified array of
bytes using the UTF-8 charset,
- * or <code>null</code> if the input byte array was
<code>null</code>.
+ * @return A new {@code String} decoded from the specified array of bytes
using the UTF-8 charset,
+ * or {@code null} if the input byte array was {@code null}.
*/
public static String newStringUtf8(final byte[] bytes) {
return newString(bytes, B2CConverter.UTF_8);
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index d3008c4..35fc374 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -132,6 +132,10 @@
Update the internal fork of Apache Commons BCEL to 6.5.0. Code clean-up
only. (markt)
</add>
+ <add>
+ Update the internal fork of Apache Commons Codec to 53c93d0
(2020-08-18,
+ 1.15-SNAPSHOT). Code clean-up. (markt)
+ </add>
</changelog>
</subsection>
</section>
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
