001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.commons.codec.binary; 019 020import org.apache.commons.codec.CodecPolicy; 021 022/** 023 * Provides Base32 encoding and decoding as defined by <a href="http://www.ietf.org/rfc/rfc4648.txt">RFC 4648</a>. 024 * 025 * <p> 026 * The class can be parameterized in the following manner with various constructors: 027 * </p> 028 * <ul> 029 * <li>Whether to use the "base32hex" variant instead of the default "base32"</li> 030 * <li>Line length: Default 76. Line length that aren't multiples of 8 will still essentially end up being multiples of 8 in the encoded data. 031 * <li>Line separator: Default is CRLF ("\r\n")</li> 032 * </ul> 033 * <p> 034 * This class operates directly on byte streams, and not character streams. 035 * </p> 036 * <p> 037 * This class is thread-safe. 038 * </p> 039 * 040 * @see <a href="http://www.ietf.org/rfc/rfc4648.txt">RFC 4648</a> 041 * 042 * @since 1.5 043 */ 044public class Base32 extends BaseNCodec { 045 046 /** 047 * BASE32 characters are 5 bits in length. They are formed by taking a block of five octets to form a 40-bit string, which is converted into eight BASE32 048 * characters. 049 */ 050 private static final int BITS_PER_ENCODED_BYTE = 5; 051 private static final int BYTES_PER_ENCODED_BLOCK = 8; 052 private static final int BYTES_PER_UNENCODED_BLOCK = 5; 053 054 /** 055 * This array is a lookup table that translates Unicode characters drawn from the "Base32 Alphabet" (as specified in Table 3 of RFC 4648) into their 5-bit 056 * positive integer equivalents. Characters that are not in the Base32 alphabet but fall within the bounds of the array are translated to -1. 057 */ 058 // @formatter:off 059 private static final byte[] DECODE_TABLE = { 060 // 0 1 2 3 4 5 6 7 8 9 A B C D E F 061 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f 062 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f 063 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f 064 -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1, // 30-3f 2-7 065 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 40-4f A-O 066 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 50-5a P-Z 067 -1, -1, -1, -1, -1, // 5b-5f 068 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 60-6f a-o 069 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 70-7a p-z 070 }; 071 // @formatter:on 072 073 /** 074 * This array is a lookup table that translates 5-bit positive integer index values into their "Base32 Alphabet" equivalents as specified in Table 3 of RFC 075 * 4648. 076 */ 077 // @formatter:off 078 private static final byte[] ENCODE_TABLE = { 079 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 080 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 081 '2', '3', '4', '5', '6', '7', 082 }; 083 // @formatter:on 084 085 /** 086 * This array is a lookup table that translates Unicode characters drawn from the "Base32 Hex Alphabet" (as specified in Table 4 of RFC 4648) into their 087 * 5-bit positive integer equivalents. Characters that are not in the Base32 Hex alphabet but fall within the bounds of the array are translated to -1. 088 */ 089 // @formatter:off 090 private static final byte[] HEX_DECODE_TABLE = { 091 // 0 1 2 3 4 5 6 7 8 9 A B C D E F 092 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f 093 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f 094 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f 095 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, // 30-3f 0-9 096 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 40-4f A-O 097 25, 26, 27, 28, 29, 30, 31, // 50-56 P-V 098 -1, -1, -1, -1, -1, -1, -1, -1, -1, // 57-5f 099 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 60-6f a-o 100 25, 26, 27, 28, 29, 30, 31 // 70-76 p-v 101 }; 102 // @formatter:on 103 104 /** 105 * This array is a lookup table that translates 5-bit positive integer index values into their "Base32 Hex Alphabet" equivalents as specified in Table 4 of 106 * RFC 4648. 107 */ 108 // @formatter:off 109 private static final byte[] HEX_ENCODE_TABLE = { 110 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 111 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 112 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 113 }; 114 // @formatter:on 115 116 /** Mask used to extract 5 bits, used when encoding Base32 bytes */ 117 private static final int MASK_5BITS = 0x1f; 118 119 /** Mask used to extract 4 bits, used when decoding final trailing character. */ 120 private static final long MASK_4BITS = 0x0fL; 121 122 /** Mask used to extract 3 bits, used when decoding final trailing character. */ 123 private static final long MASK_3BITS = 0x07L; 124 125 /** Mask used to extract 2 bits, used when decoding final trailing character. */ 126 private static final long MASK_2BITS = 0x03L; 127 128 /** Mask used to extract 1 bits, used when decoding final trailing character. */ 129 private static final long MASK_1BITS = 0x01L; 130 131 // The static final fields above are used for the original static byte[] methods on Base32. 132 // The private member fields below are used with the new streaming approach, which requires 133 // some state be preserved between calls of encode() and decode(). 134 135 /** 136 * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing. {@code decodeSize = {@link 137 * #BYTES_PER_ENCODED_BLOCK} - 1 + lineSeparator.length;} 138 */ 139 private final int decodeSize; 140 141 /** 142 * Decode table to use. 143 */ 144 private final byte[] decodeTable; 145 146 /** 147 * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing. {@code encodeSize = {@link 148 * #BYTES_PER_ENCODED_BLOCK} + lineSeparator.length;} 149 */ 150 private final int encodeSize; 151 152 /** 153 * Encode table to use. 154 */ 155 private final byte[] encodeTable; 156 157 /** 158 * Line separator for encoding. Not used when decoding. Only used if lineLength > 0. 159 */ 160 private final byte[] lineSeparator; 161 162 /** 163 * Creates a Base32 codec used for decoding and encoding. 164 * <p> 165 * When encoding the line length is 0 (no chunking). 166 * </p> 167 */ 168 public Base32() { 169 this(false); 170 } 171 172 /** 173 * Creates a Base32 codec used for decoding and encoding. 174 * <p> 175 * When encoding the line length is 0 (no chunking). 176 * </p> 177 * 178 * @param useHex if {@code true} then use Base32 Hex alphabet 179 */ 180 public Base32(final boolean useHex) { 181 this(0, null, useHex, PAD_DEFAULT); 182 } 183 184 /** 185 * Creates a Base32 codec used for decoding and encoding. 186 * <p> 187 * When encoding the line length is 0 (no chunking). 188 * </p> 189 * 190 * @param useHex if {@code true} then use Base32 Hex alphabet 191 * @param padding byte used as padding byte. 192 */ 193 public Base32(final boolean useHex, final byte padding) { 194 this(0, null, useHex, padding); 195 } 196 197 /** 198 * Creates a Base32 codec used for decoding and encoding. 199 * <p> 200 * When encoding the line length is 0 (no chunking). 201 * </p> 202 * 203 * @param pad byte used as padding byte. 204 */ 205 public Base32(final byte pad) { 206 this(false, pad); 207 } 208 209 /** 210 * Creates a Base32 codec used for decoding and encoding. 211 * <p> 212 * When encoding the line length is given in the constructor, the line separator is CRLF. 213 * </p> 214 * 215 * @param lineLength Each line of encoded data will be at most of the given length (rounded down to the nearest multiple of 8). If lineLength <= 0, then 216 * the output will not be divided into lines (chunks). Ignored when decoding. 217 */ 218 public Base32(final int lineLength) { 219 this(lineLength, CHUNK_SEPARATOR); 220 } 221 222 /** 223 * Creates a Base32 codec used for decoding and encoding. 224 * <p> 225 * When encoding the line length and line separator are given in the constructor. 226 * </p> 227 * <p> 228 * Line lengths that aren't multiples of 8 will still essentially end up being multiples of 8 in the encoded data. 229 * </p> 230 * 231 * @param lineLength Each line of encoded data will be at most of the given length (rounded down to the nearest multiple of 8). If lineLength <= 0, 232 * then the output will not be divided into lines (chunks). Ignored when decoding. 233 * @param lineSeparator Each line of encoded data will end with this sequence of bytes. 234 * @throws IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 characters. 235 */ 236 public Base32(final int lineLength, final byte[] lineSeparator) { 237 this(lineLength, lineSeparator, false, PAD_DEFAULT); 238 } 239 240 /** 241 * Creates a Base32 / Base32 Hex codec used for decoding and encoding. 242 * <p> 243 * When encoding the line length and line separator are given in the constructor. 244 * </p> 245 * <p> 246 * Line lengths that aren't multiples of 8 will still essentially end up being multiples of 8 in the encoded data. 247 * </p> 248 * 249 * @param lineLength Each line of encoded data will be at most of the given length (rounded down to the nearest multiple of 8). If lineLength <= 0, 250 * then the output will not be divided into lines (chunks). Ignored when decoding. 251 * @param lineSeparator Each line of encoded data will end with this sequence of bytes. 252 * @param useHex if {@code true}, then use Base32 Hex alphabet, otherwise use Base32 alphabet 253 * @throws IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 characters. Or the lineLength > 0 and lineSeparator is null. 254 */ 255 public Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex) { 256 this(lineLength, lineSeparator, useHex, PAD_DEFAULT); 257 } 258 259 /** 260 * Creates a Base32 / Base32 Hex codec used for decoding and encoding. 261 * <p> 262 * When encoding the line length and line separator are given in the constructor. 263 * </p> 264 * <p> 265 * Line lengths that aren't multiples of 8 will still essentially end up being multiples of 8 in the encoded data. 266 * </p> 267 * 268 * @param lineLength Each line of encoded data will be at most of the given length (rounded down to the nearest multiple of 8). If lineLength <= 0, 269 * then the output will not be divided into lines (chunks). Ignored when decoding. 270 * @param lineSeparator Each line of encoded data will end with this sequence of bytes. 271 * @param useHex if {@code true}, then use Base32 Hex alphabet, otherwise use Base32 alphabet 272 * @param padding byte used as padding byte. 273 * @throws IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 characters. Or the lineLength > 0 and lineSeparator is null. 274 */ 275 public Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, final byte padding) { 276 this(lineLength, lineSeparator, useHex, padding, DECODING_POLICY_DEFAULT); 277 } 278 279 /** 280 * Creates a Base32 / Base32 Hex codec used for decoding and encoding. 281 * <p> 282 * When encoding the line length and line separator are given in the constructor. 283 * </p> 284 * <p> 285 * Line lengths that aren't multiples of 8 will still essentially end up being multiples of 8 in the encoded data. 286 * </p> 287 * 288 * @param lineLength Each line of encoded data will be at most of the given length (rounded down to the nearest multiple of 8). If lineLength <= 0, 289 * then the output will not be divided into lines (chunks). Ignored when decoding. 290 * @param lineSeparator Each line of encoded data will end with this sequence of bytes. 291 * @param useHex if {@code true}, then use Base32 Hex alphabet, otherwise use Base32 alphabet 292 * @param padding byte used as padding byte. 293 * @param decodingPolicy The decoding policy. 294 * @throws IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 characters. Or the lineLength > 0 and lineSeparator is null. 295 * @since 1.15 296 */ 297 public Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, final byte padding, final CodecPolicy decodingPolicy) { 298 super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK, lineLength, lineSeparator == null ? 0 : lineSeparator.length, padding, decodingPolicy); 299 if (useHex) { 300 this.encodeTable = HEX_ENCODE_TABLE; 301 this.decodeTable = HEX_DECODE_TABLE; 302 } else { 303 this.encodeTable = ENCODE_TABLE; 304 this.decodeTable = DECODE_TABLE; 305 } 306 if (lineLength > 0) { 307 if (lineSeparator == null) { 308 throw new IllegalArgumentException("lineLength " + lineLength + " > 0, but lineSeparator is null"); 309 } 310 // Must be done after initializing the tables 311 if (containsAlphabetOrPad(lineSeparator)) { 312 final String sep = StringUtils.newStringUtf8(lineSeparator); 313 throw new IllegalArgumentException("lineSeparator must not contain Base32 characters: [" + sep + "]"); 314 } 315 this.encodeSize = BYTES_PER_ENCODED_BLOCK + lineSeparator.length; 316 this.lineSeparator = lineSeparator.clone(); 317 } else { 318 this.encodeSize = BYTES_PER_ENCODED_BLOCK; 319 this.lineSeparator = null; 320 } 321 this.decodeSize = this.encodeSize - 1; 322 323 if (isInAlphabet(padding) || Character.isWhitespace(padding)) { 324 throw new IllegalArgumentException("pad must not be in alphabet or whitespace"); 325 } 326 } 327 328 /** 329 * <p> 330 * 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 331 * 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. 332 * </p> 333 * <p> 334 * Ignores all non-Base32 characters. This is how chunked (e.g. 76 character) data is handled, since CR and LF are silently ignored, but has implications 335 * for other bytes, too. This method subscribes to the garbage-in, garbage-out philosophy: it will not check the provided data for validity. 336 * </p> 337 * <p> 338 * Output is written to {@link org.apache.commons.codec.binary.BaseNCodec.Context#buffer Context#buffer} as 8-bit octets, using 339 * {@link org.apache.commons.codec.binary.BaseNCodec.Context#pos Context#pos} as the buffer position 340 * </p> 341 * 342 * @param input byte[] array of ASCII data to Base32 decode. 343 * @param inPos Position to start reading data from. 344 * @param inAvail Amount of bytes available from input for decoding. 345 * @param context the context to be used 346 */ 347 @Override 348 void decode(final byte[] input, int inPos, final int inAvail, final Context context) { 349 // package protected for access from I/O streams 350 351 if (context.eof) { 352 return; 353 } 354 if (inAvail < 0) { 355 context.eof = true; 356 } 357 for (int i = 0; i < inAvail; i++) { 358 final byte b = input[inPos++]; 359 if (b == pad) { 360 // We're done. 361 context.eof = true; 362 break; 363 } 364 final byte[] buffer = ensureBufferSize(decodeSize, context); 365 if (b >= 0 && b < this.decodeTable.length) { 366 final int result = this.decodeTable[b]; 367 if (result >= 0) { 368 context.modulus = (context.modulus + 1) % BYTES_PER_ENCODED_BLOCK; 369 // collect decoded bytes 370 context.lbitWorkArea = (context.lbitWorkArea << BITS_PER_ENCODED_BYTE) + result; 371 if (context.modulus == 0) { // we can output the 5 bytes 372 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 32 & MASK_8BITS); 373 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 24 & MASK_8BITS); 374 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 16 & MASK_8BITS); 375 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 8 & MASK_8BITS); 376 buffer[context.pos++] = (byte) (context.lbitWorkArea & MASK_8BITS); 377 } 378 } 379 } 380 } 381 382 // Two forms of EOF as far as Base32 decoder is concerned: actual 383 // EOF (-1) and first time '=' character is encountered in stream. 384 // This approach makes the '=' padding characters completely optional. 385 if (context.eof && context.modulus > 0) { // if modulus == 0, nothing to do 386 final byte[] buffer = ensureBufferSize(decodeSize, context); 387 388 // We ignore partial bytes, i.e. only multiples of 8 count. 389 // Any combination not part of a valid encoding is either partially decoded 390 // or will raise an exception. Possible trailing characters are 2, 4, 5, 7. 391 // It is not possible to encode with 1, 3, 6 trailing characters. 392 // For backwards compatibility 3 & 6 chars are decoded anyway rather than discarded. 393 // See the encode(byte[]) method EOF section. 394 switch (context.modulus) { 395// case 0 : // impossible, as excluded above 396 case 1: // 5 bits - either ignore entirely, or raise an exception 397 validateTrailingCharacters(); 398 case 2: // 10 bits, drop 2 and output one byte 399 validateCharacter(MASK_2BITS, context); 400 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 2 & MASK_8BITS); 401 break; 402 case 3: // 15 bits, drop 7 and output 1 byte, or raise an exception 403 validateTrailingCharacters(); 404 // Not possible from a valid encoding but decode anyway 405 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 7 & MASK_8BITS); 406 break; 407 case 4: // 20 bits = 2*8 + 4 408 validateCharacter(MASK_4BITS, context); 409 context.lbitWorkArea = context.lbitWorkArea >> 4; // drop 4 bits 410 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 8 & MASK_8BITS); 411 buffer[context.pos++] = (byte) (context.lbitWorkArea & MASK_8BITS); 412 break; 413 case 5: // 25 bits = 3*8 + 1 414 validateCharacter(MASK_1BITS, context); 415 context.lbitWorkArea = context.lbitWorkArea >> 1; 416 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 16 & MASK_8BITS); 417 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 8 & MASK_8BITS); 418 buffer[context.pos++] = (byte) (context.lbitWorkArea & MASK_8BITS); 419 break; 420 case 6: // 30 bits = 3*8 + 6, or raise an exception 421 validateTrailingCharacters(); 422 // Not possible from a valid encoding but decode anyway 423 context.lbitWorkArea = context.lbitWorkArea >> 6; 424 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 16 & MASK_8BITS); 425 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 8 & MASK_8BITS); 426 buffer[context.pos++] = (byte) (context.lbitWorkArea & MASK_8BITS); 427 break; 428 case 7: // 35 bits = 4*8 +3 429 validateCharacter(MASK_3BITS, context); 430 context.lbitWorkArea = context.lbitWorkArea >> 3; 431 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 24 & MASK_8BITS); 432 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 16 & MASK_8BITS); 433 buffer[context.pos++] = (byte) (context.lbitWorkArea >> 8 & MASK_8BITS); 434 buffer[context.pos++] = (byte) (context.lbitWorkArea & MASK_8BITS); 435 break; 436 default: 437 // modulus can be 0-7, and we excluded 0,1 already 438 throw new IllegalStateException("Impossible modulus " + context.modulus); 439 } 440 } 441 } 442 443 /** 444 * <p> 445 * 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 446 * inAvail set to "-1" to alert encoder that EOF has been reached, so flush last remaining bytes (if not multiple of 5). 447 * </p> 448 * 449 * @param input byte[] array of binary data to Base32 encode. 450 * @param inPos Position to start reading data from. 451 * @param inAvail Amount of bytes available from input for encoding. 452 * @param context the context to be used 453 */ 454 @Override 455 void encode(final byte[] input, int inPos, final int inAvail, final Context context) { 456 // package protected for access from I/O streams 457 458 if (context.eof) { 459 return; 460 } 461 // inAvail < 0 is how we're informed of EOF in the underlying data we're 462 // encoding. 463 if (inAvail < 0) { 464 context.eof = true; 465 if (0 == context.modulus && lineLength == 0) { 466 return; // no leftovers to process and not using chunking 467 } 468 final byte[] buffer = ensureBufferSize(encodeSize, context); 469 final int savedPos = context.pos; 470 switch (context.modulus) { // % 5 471 case 0: 472 break; 473 case 1: // Only 1 octet; take top 5 bits then remainder 474 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 3) & MASK_5BITS]; // 8-1*5 = 3 475 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea << 2) & MASK_5BITS]; // 5-3=2 476 buffer[context.pos++] = pad; 477 buffer[context.pos++] = pad; 478 buffer[context.pos++] = pad; 479 buffer[context.pos++] = pad; 480 buffer[context.pos++] = pad; 481 buffer[context.pos++] = pad; 482 break; 483 case 2: // 2 octets = 16 bits to use 484 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 11) & MASK_5BITS]; // 16-1*5 = 11 485 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 6) & MASK_5BITS]; // 16-2*5 = 6 486 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 1) & MASK_5BITS]; // 16-3*5 = 1 487 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea << 4) & MASK_5BITS]; // 5-1 = 4 488 buffer[context.pos++] = pad; 489 buffer[context.pos++] = pad; 490 buffer[context.pos++] = pad; 491 buffer[context.pos++] = pad; 492 break; 493 case 3: // 3 octets = 24 bits to use 494 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 19) & MASK_5BITS]; // 24-1*5 = 19 495 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 14) & MASK_5BITS]; // 24-2*5 = 14 496 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 9) & MASK_5BITS]; // 24-3*5 = 9 497 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 4) & MASK_5BITS]; // 24-4*5 = 4 498 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea << 1) & MASK_5BITS]; // 5-4 = 1 499 buffer[context.pos++] = pad; 500 buffer[context.pos++] = pad; 501 buffer[context.pos++] = pad; 502 break; 503 case 4: // 4 octets = 32 bits to use 504 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 27) & MASK_5BITS]; // 32-1*5 = 27 505 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 22) & MASK_5BITS]; // 32-2*5 = 22 506 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 17) & MASK_5BITS]; // 32-3*5 = 17 507 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 12) & MASK_5BITS]; // 32-4*5 = 12 508 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 7) & MASK_5BITS]; // 32-5*5 = 7 509 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 2) & MASK_5BITS]; // 32-6*5 = 2 510 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea << 3) & MASK_5BITS]; // 5-2 = 3 511 buffer[context.pos++] = pad; 512 break; 513 default: 514 throw new IllegalStateException("Impossible modulus " + context.modulus); 515 } 516 context.currentLinePos += context.pos - savedPos; // keep track of current line position 517 // if currentPos == 0 we are at the start of a line, so don't add CRLF 518 if (lineLength > 0 && context.currentLinePos > 0) { // add chunk separator if required 519 System.arraycopy(lineSeparator, 0, buffer, context.pos, lineSeparator.length); 520 context.pos += lineSeparator.length; 521 } 522 } else { 523 for (int i = 0; i < inAvail; i++) { 524 final byte[] buffer = ensureBufferSize(encodeSize, context); 525 context.modulus = (context.modulus + 1) % BYTES_PER_UNENCODED_BLOCK; 526 int b = input[inPos++]; 527 if (b < 0) { 528 b += 256; 529 } 530 context.lbitWorkArea = (context.lbitWorkArea << 8) + b; // BITS_PER_BYTE 531 if (0 == context.modulus) { // we have enough bytes to create our output 532 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 35) & MASK_5BITS]; 533 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 30) & MASK_5BITS]; 534 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 25) & MASK_5BITS]; 535 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 20) & MASK_5BITS]; 536 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 15) & MASK_5BITS]; 537 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 10) & MASK_5BITS]; 538 buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea >> 5) & MASK_5BITS]; 539 buffer[context.pos++] = encodeTable[(int) context.lbitWorkArea & MASK_5BITS]; 540 context.currentLinePos += BYTES_PER_ENCODED_BLOCK; 541 if (lineLength > 0 && lineLength <= context.currentLinePos) { 542 System.arraycopy(lineSeparator, 0, buffer, context.pos, lineSeparator.length); 543 context.pos += lineSeparator.length; 544 context.currentLinePos = 0; 545 } 546 } 547 } 548 } 549 } 550 551 /** 552 * Returns whether or not the {@code octet} is in the Base32 alphabet. 553 * 554 * @param octet The value to test 555 * @return {@code true} if the value is defined in the Base32 alphabet {@code false} otherwise. 556 */ 557 @Override 558 public boolean isInAlphabet(final byte octet) { 559 return octet >= 0 && octet < decodeTable.length && decodeTable[octet] != -1; 560 } 561 562 /** 563 * Validates whether decoding the final trailing character is possible in the context of the set of possible base 32 values. 564 * <p> 565 * The character is valid if the lower bits within the provided mask are zero. This is used to test the final trailing base-32 digit is zero in the bits 566 * that will be discarded. 567 * </p> 568 * 569 * @param emptyBitsMask The mask of the lower bits that should be empty 570 * @param context the context to be used 571 * 572 * @throws IllegalArgumentException if the bits being checked contain any non-zero value 573 */ 574 private void validateCharacter(final long emptyBitsMask, final Context context) { 575 // Use the long bit work area 576 if (isStrictDecoding() && (context.lbitWorkArea & emptyBitsMask) != 0) { 577 throw new IllegalArgumentException("Strict decoding: Last encoded character (before the paddings if any) is a valid " + 578 "base 32 alphabet but not a possible encoding. Expected the discarded bits from the character to be zero."); 579 } 580 } 581 582 /** 583 * Validates whether decoding allows final trailing characters that cannot be created during encoding. 584 * 585 * @throws IllegalArgumentException if strict decoding is enabled 586 */ 587 private void validateTrailingCharacters() { 588 if (isStrictDecoding()) { 589 throw new IllegalArgumentException("Strict decoding: Last encoded character(s) (before the paddings if any) are valid " + 590 "base 32 alphabet but not a possible encoding. Decoding requires either 2, 4, 5, or 7 trailing 5-bit characters to create bytes."); 591 } 592 } 593}