[Java] BASE64 암호화, 복호화 방법

# 네이버블로그에서 이사 (http://blog.naver.com/rkdmfql1540)

Base64라는 암호화 복호화 관련 자바 코드가 있다.

이것은 입력된 byte 문자열을 24bit 단위로 잘라서 다시 6bit씩 잘라서 표에 따라 문자로 변환하는 방법이다.. 

기본적으로

import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

예전 jdk버전에서는 제공하였으나 안전상에 이유로 최신 jdk에서는 지원을 하지 않고 있다. 그래서 Base64로 암호화된 문자열을 복화하하거나 Base64로 암호화하려면 다음의 소스를 이용하면 쉽게 사용할 수 있다.

public class Base64 {
    private static byte[] encodeData;
    private static String charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ;

    static {
        encodeData = new byte[64];

        for (int i = 0; i < 64; i++) {
            byte c = (byte) charSet.charAt(i);
            encodeData[i] = c;
        }
    }

    public static String encode(String s) {
        return encode(s.getBytes());
    }

    public static String encode(byte[] src) {
        return encode(src, 0, src.length);
    }

    public static String encode(byte[] src, int start, int length) {
        byte[] dst = new byte[(length + 2) / 3 * 4 + length / 72];

        int x = 0;
        int dstIndex = 0;
        int state = 0; // which char in pattern
        int old = 0; // previous byte
        int len = 0; // length decoded so far
        int max = length + start;

        for (int srcIndex = start; srcIndex < max; srcIndex++) {
            x = src[srcIndex];

            switch (++state) {
                case 1:
                    dst[dstIndex++] = encodeData[(x >> 2) & 0x3f];
                    break;
                case 2:
                    dst[dstIndex++] = encodeData[((old << 4) & 0x30) | ((x >> 4) & 0xf)];
                    break;
                case 3:
                    dst[dstIndex++] = encodeData[((old << 2) & 0x3C) | ((x >> 6) & 0x3)];
                    dst[dstIndex++] = encodeData[x & 0x3F];
                    state = 0;
                    break;
            }
            old = x;
            if (++len >= 72) {
                dst[dstIndex++] = (byte) '\n';
                len = 0;
            }
        }
        switch (state) {
            case 1:
                dst[dstIndex++] = encodeData[(old << 4) & 0x30];
                dst[dstIndex++] = (byte) '=';
                dst[dstIndex++] = (byte) '=';
                break;
            case 2:
                dst[dstIndex++] = encodeData[(old << 2) & 0x3c];
                dst[dstIndex++] = (byte) '=';
                break;
        }
        return new String(dst);
    }

    public static byte[] decode(String s) {
        int end = 0; // end state

        if (s.endsWith("=")) {
            end++;
        }

        if (s.endsWith("==")) {
            end++;
        }

        int len = (s.length() + 3) / 4 * 3 - end;
        byte[] result = new byte[len];
        int dst = 0;

        try {
            for (int src = 0; src < s.length(); src++) {
                int code = charSet.indexOf(s.charAt(src));

                if (code == -1) {
                    break;
                }

                switch (src % 4) {
                    case 0:
                        result[dst] = (byte) (code << 2);
                        break;
                    case 1:
                        result[dst++] |= (byte) ((code >> 4) & 0x3);
                        result[dst] = (byte) (code << 4);
                        break;
                    case 2:
                        result[dst++] |= (byte) ((code >> 2) & 0xf);
                        result[dst] = (byte) (code << 6);
                        break;
                    case 3:
                        result[dst++] |= (byte) (code & 0x3f);
                        break;
                }
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        return result;
    }
}