Google Git
Sign in
apache / shiro-site / 01016f43374d9b054f3ea1e568b015d5d69428f9 / . / src / site / assets / static / 1.4.0-RC2 / shiro-all / jacoco-aggregate / shiro-lang / org.apache.shiro.codec / Base64.java.html
blob: 7fbf2f420fdc24d1ba945f28f36a1326795face3 [file] [log] [blame]
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/><link rel="stylesheet" href="../../jacoco-resources/report.css" type="text/css"/><link rel="shortcut icon" href="../../jacoco-resources/report.gif" type="image/gif"/><title>Base64.java</title><link rel="stylesheet" href="../../jacoco-resources/prettify.css" type="text/css"/><script type="text/javascript" src="../../jacoco-resources/prettify.js"></script></head><body onload="window['PR_TAB_WIDTH']=4;prettyPrint()"><div class="breadcrumb" id="breadcrumb"><span class="info"><a href="../../jacoco-sessions.html" class="el_session">Sessions</a></span><a href="../../index.html" class="el_report">Apache Shiro :: All (aggregate jar)</a> &gt; <a href="../index.html" class="el_bundle">shiro-lang</a> &gt; <a href="index.source.html" class="el_package">org.apache.shiro.codec</a> &gt; <span class="el_source">Base64.java</span></div><h1>Base64.java</h1><pre class="source lang-java linenums">/*
* 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
* &quot;License&quot;); 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
* &quot;AS IS&quot; 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.
*/
package org.apache.shiro.codec;
/**
* Provides &lt;a href=&quot;http://en.wikipedia.org/wiki/Base64&quot;&gt;Base 64&lt;/a&gt; encoding and decoding as defined by
* &lt;a href=&quot;http://www.ietf.org/rfc/rfc2045.txt&quot;&gt;RFC 2045&lt;/a&gt;.
* &lt;p/&gt;
* This class implements section &lt;cite&gt;6.8. Base64 Content-Transfer-Encoding&lt;/cite&gt; from RFC 2045 &lt;cite&gt;Multipurpose
* Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies&lt;/cite&gt; by Freed and Borenstein.
* &lt;p/&gt;
* This class was borrowed from Apache Commons Codec SVN repository (rev. 618419) with modifications
* to enable Base64 conversion without a full dependency on Commons Codec. We didn't want to reinvent the wheel of
* great work they've done, but also didn't want to force every Shiro user to depend on the commons-codec.jar
* &lt;p/&gt;
* As per the Apache 2.0 license, the original copyright notice and all author and copyright information have
* remained in tact.
*
* @see &lt;a href=&quot;http://en.wikipedia.org/wiki/Base64&quot;&gt;Wikipedia: Base 64&lt;/a&gt;
* @see &lt;a href=&quot;http://www.ietf.org/rfc/rfc2045.txt&quot;&gt;RFC 2045&lt;/a&gt;
* @since 0.9
*/
<span class="nc" id="L39">public class Base64 {</span>
/**
* Chunk size per RFC 2045 section 6.8.
* &lt;p/&gt;
* The character limit does not count the trailing CRLF, but counts all other characters, including any
* equal signs.
*
* @see &lt;a href=&quot;http://www.ietf.org/rfc/rfc2045.txt&quot;&gt;RFC 2045 section 6.8&lt;/a&gt;
*/
static final int CHUNK_SIZE = 76;
/**
* Chunk separator per RFC 2045 section 2.1.
*
* @see &lt;a href=&quot;http://www.ietf.org/rfc/rfc2045.txt&quot;&gt;RFC 2045 section 2.1&lt;/a&gt;
*/
<span class="fc" id="L56"> static final byte[] CHUNK_SEPARATOR = &quot;\r\n&quot;.getBytes();</span>
/**
* The base length.
*/
private static final int BASELENGTH = 255;
/**
* Lookup length.
*/
private static final int LOOKUPLENGTH = 64;
/**
* Used to calculate the number of bits in a byte.
*/
private static final int EIGHTBIT = 8;
/**
* Used when encoding something which has fewer than 24 bits.
*/
private static final int SIXTEENBIT = 16;
/**
* Used to determine how many bits data contains.
*/
private static final int TWENTYFOURBITGROUP = 24;
/**
* Used to get the number of Quadruples.
*/
private static final int FOURBYTE = 4;
/**
* Used to test the sign of a byte.
*/
private static final int SIGN = -128;
/**
* Byte used to pad output.
*/
private static final byte PAD = (byte) '=';
/**
* Contains the Base64 values &lt;code&gt;0&lt;/code&gt; through &lt;code&gt;63&lt;/code&gt; accessed by using character encodings as
* indices.
* &lt;p/&gt;
* &lt;p&gt;For example, &lt;code&gt;base64Alphabet['+']&lt;/code&gt; returns &lt;code&gt;62&lt;/code&gt;.&lt;/p&gt;
* &lt;p/&gt;
* &lt;p&gt;The value of undefined encodings is &lt;code&gt;-1&lt;/code&gt;.&lt;/p&gt;
*/
<span class="fc" id="L106"> private static final byte[] base64Alphabet = new byte[BASELENGTH];</span>
/**
* &lt;p&gt;Contains the Base64 encodings &lt;code&gt;A&lt;/code&gt; through &lt;code&gt;Z&lt;/code&gt;, followed by &lt;code&gt;a&lt;/code&gt; through
* &lt;code&gt;z&lt;/code&gt;, followed by &lt;code&gt;0&lt;/code&gt; through &lt;code&gt;9&lt;/code&gt;, followed by &lt;code&gt;+&lt;/code&gt;, and
* &lt;code&gt;/&lt;/code&gt;.&lt;/p&gt;
* &lt;p/&gt;
* &lt;p&gt;This array is accessed by using character values as indices.&lt;/p&gt;
* &lt;p/&gt;
* &lt;p&gt;For example, &lt;code&gt;lookUpBase64Alphabet[62] &lt;/code&gt; returns &lt;code&gt;'+'&lt;/code&gt;.&lt;/p&gt;
*/
<span class="fc" id="L117"> private static final byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];</span>
// Populating the lookup and character arrays
static {
<span class="fc bfc" id="L122" title="All 2 branches covered."> for (int i = 0; i &lt; BASELENGTH; i++) {</span>
<span class="fc" id="L123"> base64Alphabet[i] = (byte) -1;</span>
}
<span class="fc bfc" id="L125" title="All 2 branches covered."> for (int i = 'Z'; i &gt;= 'A'; i--) {</span>
<span class="fc" id="L126"> base64Alphabet[i] = (byte) (i - 'A');</span>
}
<span class="fc bfc" id="L128" title="All 2 branches covered."> for (int i = 'z'; i &gt;= 'a'; i--) {</span>
<span class="fc" id="L129"> base64Alphabet[i] = (byte) (i - 'a' + 26);</span>
}
<span class="fc bfc" id="L131" title="All 2 branches covered."> for (int i = '9'; i &gt;= '0'; i--) {</span>
<span class="fc" id="L132"> base64Alphabet[i] = (byte) (i - '0' + 52);</span>
}
<span class="fc" id="L135"> base64Alphabet['+'] = 62;</span>
<span class="fc" id="L136"> base64Alphabet['/'] = 63;</span>
<span class="fc bfc" id="L138" title="All 2 branches covered."> for (int i = 0; i &lt;= 25; i++) {</span>
<span class="fc" id="L139"> lookUpBase64Alphabet[i] = (byte) ('A' + i);</span>
}
<span class="fc bfc" id="L142" title="All 2 branches covered."> for (int i = 26, j = 0; i &lt;= 51; i++, j++) {</span>
<span class="fc" id="L143"> lookUpBase64Alphabet[i] = (byte) ('a' + j);</span>
}
<span class="fc bfc" id="L146" title="All 2 branches covered."> for (int i = 52, j = 0; i &lt;= 61; i++, j++) {</span>
<span class="fc" id="L147"> lookUpBase64Alphabet[i] = (byte) ('0' + j);</span>
}
<span class="fc" id="L150"> lookUpBase64Alphabet[62] = (byte) '+';</span>
<span class="fc" id="L151"> lookUpBase64Alphabet[63] = (byte) '/';</span>
<span class="fc" id="L152"> }</span>
/**
* Returns whether or not the &lt;code&gt;octet&lt;/code&gt; is in the base 64 alphabet.
*
* @param octect The value to test
* @return &lt;code&gt;true&lt;/code&gt; if the value is defined in the the base 64 alphabet, &lt;code&gt;false&lt;/code&gt; otherwise.
*/
private static boolean isBase64(byte octect) {
<span class="fc bfc" id="L161" title="All 2 branches covered."> if (octect == PAD) {</span>
<span class="fc" id="L162"> return true;</span>
} else //noinspection RedundantIfStatement
<span class="pc bpc" id="L164" title="2 of 4 branches missed."> if (octect &lt; 0 || base64Alphabet[octect] == -1) {</span>
<span class="nc" id="L165"> return false;</span>
} else {
<span class="fc" id="L167"> return true;</span>
}
}
/**
* Tests a given byte array to see if it contains only valid characters within the Base64 alphabet.
*
* @param arrayOctect byte array to test
* @return &lt;code&gt;true&lt;/code&gt; if all bytes are valid characters in the Base64 alphabet or if the byte array is
* empty; false, otherwise
*/
public static boolean isBase64(byte[] arrayOctect) {
<span class="nc" id="L180"> arrayOctect = discardWhitespace(arrayOctect);</span>
<span class="nc" id="L182"> int length = arrayOctect.length;</span>
<span class="nc bnc" id="L183" title="All 2 branches missed."> if (length == 0) {</span>
// shouldn't a 0 length array be valid base64 data?
// return false;
<span class="nc" id="L186"> return true;</span>
}
<span class="nc bnc" id="L188" title="All 2 branches missed."> for (int i = 0; i &lt; length; i++) {</span>
<span class="nc bnc" id="L189" title="All 2 branches missed."> if (!isBase64(arrayOctect[i])) {</span>
<span class="nc" id="L190"> return false;</span>
}
}
<span class="nc" id="L193"> return true;</span>
}
/**
* Discards any whitespace from a base-64 encoded block.
*
* @param data The base-64 encoded data to discard the whitespace from.
* @return The data, less whitespace (see RFC 2045).
*/
static byte[] discardWhitespace(byte[] data) {
<span class="nc" id="L203"> byte groomedData[] = new byte[data.length];</span>
<span class="nc" id="L204"> int bytesCopied = 0;</span>
<span class="nc bnc" id="L206" title="All 2 branches missed."> for (byte aByte : data) {</span>
<span class="nc bnc" id="L207" title="All 2 branches missed."> switch (aByte) {</span>
case (byte) ' ':
case (byte) '\n':
case (byte) '\r':
case (byte) '\t':
<span class="nc" id="L212"> break;</span>
default:
<span class="nc" id="L214"> groomedData[bytesCopied++] = aByte;</span>
}
}
<span class="nc" id="L218"> byte packedData[] = new byte[bytesCopied];</span>
<span class="nc" id="L220"> System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);</span>
<span class="nc" id="L222"> return packedData;</span>
}
/**
* Base64 encodes the specified byte array and then encodes it as a String using Shiro's preferred character
* encoding (UTF-8).
*
* @param bytes the byte array to Base64 encode.
* @return a UTF-8 encoded String of the resulting Base64 encoded byte array.
*/
public static String encodeToString(byte[] bytes) {
<span class="fc" id="L233"> byte[] encoded = encode(bytes);</span>
<span class="fc" id="L234"> return CodecSupport.toString(encoded);</span>
}
/**
* Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
*
* @param binaryData binary data to encodeToChars
* @return Base64 characters chunked in 76 character blocks
*/
public static byte[] encodeChunked(byte[] binaryData) {
<span class="nc" id="L244"> return encode(binaryData, true);</span>
}
/**
* Encodes a byte[] containing binary data, into a byte[] containing characters in the Base64 alphabet.
*
* @param pArray a byte array containing binary data
* @return A byte array containing only Base64 character data
*/
public static byte[] encode(byte[] pArray) {
<span class="fc" id="L254"> return encode(pArray, false);</span>
}
/**
* Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encodeToChars.
* @param isChunked if &lt;code&gt;true&lt;/code&gt; 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 static byte[] encode(byte[] binaryData, boolean isChunked) {
<span class="fc" id="L266"> long binaryDataLength = binaryData.length;</span>
<span class="fc" id="L267"> long lengthDataBits = binaryDataLength * EIGHTBIT;</span>
<span class="fc" id="L268"> long fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;</span>
<span class="fc" id="L269"> long tripletCount = lengthDataBits / TWENTYFOURBITGROUP;</span>
long encodedDataLengthLong;
<span class="fc" id="L271"> int chunckCount = 0;</span>
<span class="fc bfc" id="L273" title="All 2 branches covered."> if (fewerThan24bits != 0) {</span>
// data not divisible by 24 bit
<span class="fc" id="L275"> encodedDataLengthLong = (tripletCount + 1) * 4;</span>
} else {
// 16 or 8 bit
<span class="fc" id="L278"> encodedDataLengthLong = tripletCount * 4;</span>
}
// If the output is to be &quot;chunked&quot; into 76 character sections,
// for compliance with RFC 2045 MIME, then it is important to
// allow for extra length to account for the separator(s)
<span class="pc bpc" id="L284" title="1 of 2 branches missed."> if (isChunked) {</span>
<span class="nc bnc" id="L286" title="All 2 branches missed."> chunckCount = (CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math</span>
<span class="nc" id="L287"> .ceil((float) encodedDataLengthLong / CHUNK_SIZE));</span>
<span class="nc" id="L288"> encodedDataLengthLong += chunckCount * CHUNK_SEPARATOR.length;</span>
}
<span class="pc bpc" id="L291" title="1 of 2 branches missed."> if (encodedDataLengthLong &gt; Integer.MAX_VALUE) {</span>
<span class="nc" id="L292"> throw new IllegalArgumentException(</span>
&quot;Input array too big, output array would be bigger than Integer.MAX_VALUE=&quot; + Integer.MAX_VALUE);
}
<span class="fc" id="L295"> int encodedDataLength = (int) encodedDataLengthLong;</span>
<span class="fc" id="L296"> byte encodedData[] = new byte[encodedDataLength];</span>
byte k, l, b1, b2, b3;
<span class="fc" id="L300"> int encodedIndex = 0;</span>
int dataIndex;
int i;
<span class="fc" id="L303"> int nextSeparatorIndex = CHUNK_SIZE;</span>
<span class="fc" id="L304"> int chunksSoFar = 0;</span>
// log.debug(&quot;number of triplets = &quot; + numberTriplets);
<span class="fc bfc" id="L307" title="All 2 branches covered."> for (i = 0; i &lt; tripletCount; i++) {</span>
<span class="fc" id="L308"> dataIndex = i * 3;</span>
<span class="fc" id="L309"> b1 = binaryData[dataIndex];</span>
<span class="fc" id="L310"> b2 = binaryData[dataIndex + 1];</span>
<span class="fc" id="L311"> b3 = binaryData[dataIndex + 2];</span>
// log.debug(&quot;b1= &quot; + b1 +&quot;, b2= &quot; + b2 + &quot;, b3= &quot; + b3);
<span class="fc" id="L315"> l = (byte) (b2 &amp; 0x0f);</span>
<span class="fc" id="L316"> k = (byte) (b1 &amp; 0x03);</span>
<span class="fc bfc" id="L318" title="All 2 branches covered."> byte val1 = ((b1 &amp; SIGN) == 0) ? (byte) (b1 &gt;&gt; 2) : (byte) ((b1) &gt;&gt; 2 ^ 0xc0);</span>
<span class="fc bfc" id="L319" title="All 2 branches covered."> byte val2 = ((b2 &amp; SIGN) == 0) ? (byte) (b2 &gt;&gt; 4) : (byte) ((b2) &gt;&gt; 4 ^ 0xf0);</span>
<span class="fc bfc" id="L320" title="All 2 branches covered."> byte val3 = ((b3 &amp; SIGN) == 0) ? (byte) (b3 &gt;&gt; 6) : (byte) ((b3) &gt;&gt; 6 ^ 0xfc);</span>
<span class="fc" id="L322"> encodedData[encodedIndex] = lookUpBase64Alphabet[val1];</span>
// log.debug( &quot;val2 = &quot; + val2 );
// log.debug( &quot;k4 = &quot; + (k&lt;&lt;4) );
// log.debug( &quot;vak = &quot; + (val2 | (k&lt;&lt;4)) );
<span class="fc" id="L326"> encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k &lt;&lt; 4)];</span>
<span class="fc" id="L327"> encodedData[encodedIndex + 2] = lookUpBase64Alphabet[(l &lt;&lt; 2) | val3];</span>
<span class="fc" id="L328"> encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 &amp; 0x3f];</span>
<span class="fc" id="L330"> encodedIndex += 4;</span>
// If we are chunking, let's put a chunk separator down.
<span class="pc bpc" id="L333" title="1 of 2 branches missed."> if (isChunked) {</span>
// this assumes that CHUNK_SIZE % 4 == 0
<span class="nc bnc" id="L335" title="All 2 branches missed."> if (encodedIndex == nextSeparatorIndex) {</span>
<span class="nc" id="L336"> System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedIndex, CHUNK_SEPARATOR.length);</span>
<span class="nc" id="L337"> chunksSoFar++;</span>
<span class="nc" id="L338"> nextSeparatorIndex = (CHUNK_SIZE * (chunksSoFar + 1)) + (chunksSoFar * CHUNK_SEPARATOR.length);</span>
<span class="nc" id="L339"> encodedIndex += CHUNK_SEPARATOR.length;</span>
}
}
}
// form integral number of 6-bit groups
<span class="fc" id="L345"> dataIndex = i * 3;</span>
<span class="fc bfc" id="L347" title="All 2 branches covered."> if (fewerThan24bits == EIGHTBIT) {</span>
<span class="fc" id="L348"> b1 = binaryData[dataIndex];</span>
<span class="fc" id="L349"> k = (byte) (b1 &amp; 0x03);</span>
// log.debug(&quot;b1=&quot; + b1);
// log.debug(&quot;b1&lt;&lt;2 = &quot; + (b1&gt;&gt;2) );
<span class="fc bfc" id="L352" title="All 2 branches covered."> byte val1 = ((b1 &amp; SIGN) == 0) ? (byte) (b1 &gt;&gt; 2) : (byte) ((b1) &gt;&gt; 2 ^ 0xc0);</span>
<span class="fc" id="L353"> encodedData[encodedIndex] = lookUpBase64Alphabet[val1];</span>
<span class="fc" id="L354"> encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k &lt;&lt; 4];</span>
<span class="fc" id="L355"> encodedData[encodedIndex + 2] = PAD;</span>
<span class="fc" id="L356"> encodedData[encodedIndex + 3] = PAD;</span>
<span class="fc bfc" id="L357" title="All 2 branches covered."> } else if (fewerThan24bits == SIXTEENBIT) {</span>
<span class="fc" id="L359"> b1 = binaryData[dataIndex];</span>
<span class="fc" id="L360"> b2 = binaryData[dataIndex + 1];</span>
<span class="fc" id="L361"> l = (byte) (b2 &amp; 0x0f);</span>
<span class="fc" id="L362"> k = (byte) (b1 &amp; 0x03);</span>
<span class="fc bfc" id="L364" title="All 2 branches covered."> byte val1 = ((b1 &amp; SIGN) == 0) ? (byte) (b1 &gt;&gt; 2) : (byte) ((b1) &gt;&gt; 2 ^ 0xc0);</span>
<span class="fc bfc" id="L365" title="All 2 branches covered."> byte val2 = ((b2 &amp; SIGN) == 0) ? (byte) (b2 &gt;&gt; 4) : (byte) ((b2) &gt;&gt; 4 ^ 0xf0);</span>
<span class="fc" id="L367"> encodedData[encodedIndex] = lookUpBase64Alphabet[val1];</span>
<span class="fc" id="L368"> encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k &lt;&lt; 4)];</span>
<span class="fc" id="L369"> encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l &lt;&lt; 2];</span>
<span class="fc" id="L370"> encodedData[encodedIndex + 3] = PAD;</span>
}
<span class="pc bpc" id="L373" title="1 of 2 branches missed."> if (isChunked) {</span>
// we also add a separator to the end of the final chunk.
<span class="nc bnc" id="L375" title="All 2 branches missed."> if (chunksSoFar &lt; chunckCount) {</span>
<span class="nc" id="L376"> System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedDataLength - CHUNK_SEPARATOR.length,</span>
CHUNK_SEPARATOR.length);
}
}
<span class="fc" id="L381"> return encodedData;</span>
}
/**
* Converts the specified UTF-8 Base64 encoded String and decodes it to a resultant UTF-8 encoded string.
*
* @param base64Encoded a UTF-8 Base64 encoded String
* @return the decoded String, UTF-8 encoded.
*/
public static String decodeToString(String base64Encoded) {
<span class="fc" id="L391"> byte[] encodedBytes = CodecSupport.toBytes(base64Encoded);</span>
<span class="fc" id="L392"> return decodeToString(encodedBytes);</span>
}
/**
* Decodes the specified Base64 encoded byte array and returns the decoded result as a UTF-8 encoded.
*
* @param base64Encoded a Base64 encoded byte array
* @return the decoded String, UTF-8 encoded.
*/
public static String decodeToString(byte[] base64Encoded) {
<span class="fc" id="L402"> byte[] decoded = decode(base64Encoded);</span>
<span class="fc" id="L403"> return CodecSupport.toString(decoded);</span>
}
/**
* Converts the specified UTF-8 Base64 encoded String and decodes it to a raw Base64 decoded byte array.
*
* @param base64Encoded a UTF-8 Base64 encoded String
* @return the raw Base64 decoded byte array.
*/
public static byte[] decode(String base64Encoded) {
<span class="fc" id="L413"> byte[] bytes = CodecSupport.toBytes(base64Encoded);</span>
<span class="fc" id="L414"> return decode(bytes);</span>
}
/**
* Decodes Base64 data into octets
*
* @param base64Data Byte array containing Base64 data
* @return Array containing decoded data.
*/
public static byte[] decode(byte[] base64Data) {
// RFC 2045 requires that we discard ALL non-Base64 characters
<span class="fc" id="L425"> base64Data = discardNonBase64(base64Data);</span>
// handle the edge case, so we don't have to worry about it later
<span class="pc bpc" id="L428" title="1 of 2 branches missed."> if (base64Data.length == 0) {</span>
<span class="nc" id="L429"> return new byte[0];</span>
}
<span class="fc" id="L432"> int numberQuadruple = base64Data.length / FOURBYTE;</span>
byte decodedData[];
byte b1, b2, b3, b4, marker0, marker1;
// Throw away anything not in base64Data
<span class="fc" id="L438"> int encodedIndex = 0;</span>
int dataIndex;
{
// this sizes the output array properly - rlw
<span class="fc" id="L442"> int lastData = base64Data.length;</span>
// ignore the '=' padding
<span class="fc bfc" id="L444" title="All 2 branches covered."> while (base64Data[lastData - 1] == PAD) {</span>
<span class="pc bpc" id="L445" title="1 of 2 branches missed."> if (--lastData == 0) {</span>
<span class="nc" id="L446"> return new byte[0];</span>
}
}
<span class="fc" id="L449"> decodedData = new byte[lastData - numberQuadruple];</span>
}
<span class="fc bfc" id="L452" title="All 2 branches covered."> for (int i = 0; i &lt; numberQuadruple; i++) {</span>
<span class="fc" id="L453"> dataIndex = i * 4;</span>
<span class="fc" id="L454"> marker0 = base64Data[dataIndex + 2];</span>
<span class="fc" id="L455"> marker1 = base64Data[dataIndex + 3];</span>
<span class="fc" id="L457"> b1 = base64Alphabet[base64Data[dataIndex]];</span>
<span class="fc" id="L458"> b2 = base64Alphabet[base64Data[dataIndex + 1]];</span>
<span class="fc bfc" id="L460" title="All 4 branches covered."> if (marker0 != PAD &amp;&amp; marker1 != PAD) {</span>
// No PAD e.g 3cQl
<span class="fc" id="L462"> b3 = base64Alphabet[marker0];</span>
<span class="fc" id="L463"> b4 = base64Alphabet[marker1];</span>
<span class="fc" id="L465"> decodedData[encodedIndex] = (byte) (b1 &lt;&lt; 2 | b2 &gt;&gt; 4);</span>
<span class="fc" id="L466"> decodedData[encodedIndex + 1] = (byte) (((b2 &amp; 0xf) &lt;&lt; 4) | ((b3 &gt;&gt; 2) &amp; 0xf));</span>
<span class="fc" id="L467"> decodedData[encodedIndex + 2] = (byte) (b3 &lt;&lt; 6 | b4);</span>
<span class="fc bfc" id="L468" title="All 2 branches covered."> } else if (marker0 == PAD) {</span>
// Two PAD e.g. 3c[Pad][Pad]
<span class="fc" id="L470"> decodedData[encodedIndex] = (byte) (b1 &lt;&lt; 2 | b2 &gt;&gt; 4);</span>
} else {
// One PAD e.g. 3cQ[Pad]
<span class="fc" id="L473"> b3 = base64Alphabet[marker0];</span>
<span class="fc" id="L474"> decodedData[encodedIndex] = (byte) (b1 &lt;&lt; 2 | b2 &gt;&gt; 4);</span>
<span class="fc" id="L475"> decodedData[encodedIndex + 1] = (byte) (((b2 &amp; 0xf) &lt;&lt; 4) | ((b3 &gt;&gt; 2) &amp; 0xf));</span>
}
<span class="fc" id="L477"> encodedIndex += 3;</span>
}
<span class="fc" id="L479"> return decodedData;</span>
}
/**
* Discards any characters outside of the base64 alphabet, per the requirements on page 25 of RFC 2045 - &quot;Any
* characters outside of the base64 alphabet are to be ignored in base64 encoded data.&quot;
*
* @param data The base-64 encoded data to groom
* @return The data, less non-base64 characters (see RFC 2045).
*/
static byte[] discardNonBase64(byte[] data) {
<span class="fc" id="L490"> byte groomedData[] = new byte[data.length];</span>
<span class="fc" id="L491"> int bytesCopied = 0;</span>
<span class="fc bfc" id="L493" title="All 2 branches covered."> for (byte aByte : data) {</span>
<span class="pc bpc" id="L494" title="1 of 2 branches missed."> if (isBase64(aByte)) {</span>
<span class="fc" id="L495"> groomedData[bytesCopied++] = aByte;</span>
}
}
<span class="fc" id="L499"> byte packedData[] = new byte[bytesCopied];</span>
<span class="fc" id="L501"> System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);</span>
<span class="fc" id="L503"> return packedData;</span>
}
}
</pre><div class="footer"><span class="right">Created with <a href="http://www.eclemma.org/jacoco">JaCoCo</a> 0.7.7.201606060606</span></div></body></html>