Java/Data Type/String Base64

Class decodes a Base64 encoded string back into the original byte

 
/*
 * Copyright 2005 Ralf Joachim
 *
 * Licensed 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.
 */
import java.io.ByteArrayOutputStream;
/**
 * Class decodes a Base64 encoded string back into the original byte representation
 * that can be read as byte array.
 *
 * @author 
 * @version $Revision: 6907 $ $Date: 2005-08-05 13:58:36 -0600 (Fri, 05 Aug 2005) $
 * @since 0.9.9
 */
public final class Base64Decoder {
    /** Mask buffer to or with first sextet. */
    private static final int    SEXTET_1_MASK = 0x03FFFF;
    
    /** Mask buffer to or with second sextet. */
    private static final int    SEXTET_2_MASK = 0xFC0FFF;
    /** Mask buffer to or with third sextet. */
    private static final int    SEXTET_3_MASK = 0xFFF03F;
    
    /** Mask buffer to or with forth sextet. */
    private static final int    SEXTET_4_MASK = 0xFFFFC0;
    
    /** Number of bits to shift for one sextet. */
    private static final int    SHIFT_1_SEXTET = 6;
    
    /** Number of bits to shift for two sextet. */
    private static final int    SHIFT_2_SEXTET = 12;
    
    /** Number of bits to shift for three sextet. */
    private static final int    SHIFT_3_SEXTET = 18;
    
    /** Second sextets in buffer. */
    private static final int    SEXTET_2 = 2;
    
    /** Third sextets in buffer. */
    private static final int    SEXTET_3 = 3;
    
    /** Forth sextets in buffer. */
    private static final int    SEXTET_4 = 4;
    
    /** Mask an octet. */
    private static final int    OCTET_MASK = 0xFF;
    
    /** Number of bits to shift for one octet. */
    private static final int    SHIFT_1_OCTET = 8;
    
    /** Number of bits to shift for two octet. */
    private static final int    SHIFT_2_OCTET = 16;
    
    /** White space character (out of range 0 - 63). */
    private static final byte SPC = 127;
    /** Padding character (out of range 0 - 63). */
    private static final byte PAD = 64;
    /** Array to translate base64 characters into sextet byte values. */
    private static final byte[] MAP = {
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 00-07
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 08-0F
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 10-17
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 18-1F
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 20-27
            SPC, SPC, SPC,  62, SPC, SPC, SPC,  63,     // 28-2F "   +   /"
             52,  53,  54,  55,  56,  57,  58,  59,     // 30-37 "01234567"
             60,  61, SPC, SPC, SPC, PAD, SPC, SPC,     // 38-3F "89   =  "
            SPC,   0,   1,   2,   3,   4,   5,   6,     // 40-47 " ABCDEFG"
              7,   8,   9,  10,  11,  12,  13,  14,     // 48-4F "HIJKLMNO"
             15,  16,  17,  18,  19,  20,  21,  22,     // 50-57 "PQRSTUVW"
             23,  24,  25, SPC, SPC, SPC, SPC, SPC,     // 58-5F "XYZ     "
            SPC,  26,  27,  28,  29,  30,  31,  32,     // 60-67 " abcdefg"
             33,  34,  35,  36,  37,  38,  39,  40,     // 68-6F "hijklmno"
             41,  42,  43,  44,  45,  46,  47,  48,     // 70-77 "pqrstuvw"
             49,  50,  51, SPC, SPC, SPC, SPC, SPC,     // 78-7F "xyz     "
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 80-87
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 88-8F
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 90-97
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // 98-9F
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // A0-A7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // A8-AF
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // B0-B7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // B8-BF
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // C0-C7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // C8-CF
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // D0-D7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // D8-DF
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // E0-E7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // E8-EF
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // F0-F7
            SPC, SPC, SPC, SPC, SPC, SPC, SPC, SPC,     // F8-FF
        };
    /** 24-bit buffer to translate 4 sextets into 3 octets. */
    private int                     _buffer = 0;
    /** Number of octets in buffer. */
    private int                     _sextets = 0;
    /** Stream buffer for decoded octets waiting to be read. */
    private ByteArrayOutputStream   _stream = new ByteArrayOutputStream();
    
    /**
     * Decode given string into a decoded byte array.
     * 
     * @param str Base64 String to be decoded.
     * @return All decoded octets as byte array.
     */
    public static byte[] decode(final String str) {
        Base64Decoder dec = new Base64Decoder();
        dec.translate(str);
        return dec.getByteArray();
    }
    /**
     * Construct a default Base64Decoder waiting on calls to its translate()
     * method.
     */
    public Base64Decoder() { }
    /**
     * Translate every base64 character from given string into a sextet byte value
     * by using above translation array. The sextets are then shiftet into an buffer
     * until the buffer contains 4 sextets which are then decoded into 3 octets.
     * The translate and decode process is continued until all characters of given
     * string are evaluated. If there are remaing sextets in the buffer they also
     * will be converted into octets at the end. All the converted octets are added
     * to the list for later read.
     * 
     * @param string    Base64 String to be decoded.
     */
    public void translate(final String string) {
        int len = string.length();
        int index = 0;
        int data = MAP[string.charAt(index)];
        while ((index < len) && (data != PAD)) {
            if (data != SPC) {
                if (_sextets == 0) {
                    _buffer = (_buffer & SEXTET_1_MASK) | (data << SHIFT_3_SEXTET);
                } else if (_sextets == 1) {
                    _buffer = (_buffer & SEXTET_2_MASK) | (data << SHIFT_2_SEXTET);
                } else if (_sextets == 2) {
                    _buffer = (_buffer & SEXTET_3_MASK) | (data << SHIFT_1_SEXTET);
                } else {
                    _buffer = (_buffer & SEXTET_4_MASK) | data;
                }
                if ((++_sextets) == SEXTET_4) { decode(); }
            }
            if (++index < len) { data = MAP[string.charAt(index)]; }
        }
        if (_sextets > 0) { decodeWithPadding(); }
    }
    /**
     * Decode 3 octets from buffer and add them to list of octets to read.
     */
    private void decode() {
        _stream.write((byte) ((_buffer >> SHIFT_2_OCTET) & OCTET_MASK));     // octet 1
        _stream.write((byte) ((_buffer >> SHIFT_1_OCTET) & OCTET_MASK));     // octet 2
        _stream.write((byte) (_buffer & OCTET_MASK));                        // octet 3
        _buffer = 0;
        _sextets = 0;
    }
    /**
     * Decode the remaining octets from buffer and add them to list of octets to read.
     */
    private void decodeWithPadding() {
        if (_sextets >= SEXTET_2) {                                     // octet 1
            _stream.write((byte) ((_buffer >> SHIFT_2_OCTET) & OCTET_MASK));
        }
        if (_sextets >= SEXTET_3) {                                     // octet 2
            _stream.write((byte) ((_buffer >> SHIFT_1_OCTET) & OCTET_MASK));
        }
        if (_sextets >= SEXTET_4) {                                     // octet 3
            _stream.write((byte) (_buffer & OCTET_MASK));
        }
        _buffer = 0;
        _sextets = 0;
    }
    /**
     * Get all decoded octets as byte array.
     * 
     * @return All decoded octets as byte array.
     */
    public byte[] getByteArray() {
        return _stream.toByteArray();
    }
}

Convert a base16 string into a byte array.

 
/*
 * 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.    
 */
/**
 * Base 16 encoder.
 *
 * @author Marc Prud"hommeaux
 * @nojavadoc
 */
 class Base16Encoder {
    private final static char[] HEX = new char[]{
        "0", "1", "2", "3", "4", "5", "6", "7",
        "8", "9", "A", "B", "C", "D", "E", "F" };
    /**
     * Convert bytes to a base16 string.
     */
    public static String encode(byte[] byteArray) {
        StringBuffer hexBuffer = new StringBuffer(byteArray.length * 2);
        for (int i = 0; i < byteArray.length; i++)
            for (int j = 1; j >= 0; j--)
                hexBuffer.append(HEX[(byteArray[i] >> (j * 4)) & 0xF]);
        return hexBuffer.toString();
    }
    /**
     * Convert a base16 string into a byte array.
     */
    public static byte[] decode(String s) {
        int len = s.length();
        byte[] r = new byte[len / 2];
        for (int i = 0; i < r.length; i++) {
            int digit1 = s.charAt(i * 2), digit2 = s.charAt(i * 2 + 1);
            if (digit1 >= "0" && digit1 <= "9")
                digit1 -= "0";
            else if (digit1 >= "A" && digit1 <= "F")
                digit1 -= "A" - 10;
            if (digit2 >= "0" && digit2 <= "9")
                digit2 -= "0";
            else if (digit2 >= "A" && digit2 <= "F")
                digit2 -= "A" - 10;
            r[i] = (byte) ((digit1 << 4) + digit2);
        }
        return r;
    }
}

Convert bytes to a base16 string.

 
/*
 * 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.    
 */
/**
 * Base 16 encoder.
 *
 * @author Marc Prud"hommeaux
 * @nojavadoc
 */
 class Base16Encoder {
    private final static char[] HEX = new char[]{
        "0", "1", "2", "3", "4", "5", "6", "7",
        "8", "9", "A", "B", "C", "D", "E", "F" };
    /**
     * Convert bytes to a base16 string.
     */
    public static String encode(byte[] byteArray) {
        StringBuffer hexBuffer = new StringBuffer(byteArray.length * 2);
        for (int i = 0; i < byteArray.length; i++)
            for (int j = 1; j >= 0; j--)
                hexBuffer.append(HEX[(byteArray[i] >> (j * 4)) & 0xF]);
        return hexBuffer.toString();
    }
    /**
     * Convert a base16 string into a byte array.
     */
    public static byte[] decode(String s) {
        int len = s.length();
        byte[] r = new byte[len / 2];
        for (int i = 0; i < r.length; i++) {
            int digit1 = s.charAt(i * 2), digit2 = s.charAt(i * 2 + 1);
            if (digit1 >= "0" && digit1 <= "9")
                digit1 -= "0";
            else if (digit1 >= "A" && digit1 <= "F")
                digit1 -= "A" - 10;
            if (digit2 >= "0" && digit2 <= "9")
                digit2 -= "0";
            else if (digit2 >= "A" && digit2 <= "F")
                digit2 -= "A" - 10;
            r[i] = (byte) ((digit1 << 4) + digit2);
        }
        return r;
    }
}