Base64算法

Base64算法概述

Base64算法最先应用于解决电子邮件传输的问题。早期，因为“历史问题”，电子邮件只容许ASCII码字符，若是邮件中包含非ASCII码字符，当它经过有“历史问题”的网关时，这个网关会对该字符的二进制位进行调整，即将其8位二进制码的最高位置0，这样用户收到的邮件就会是一封乱码。为了解决这个问题，产生了Base64算法。

Base64主要用于将不可打印的字符转换成可打印字符，或者简单的说将二进制数据编码成ASCII字符（注：可打印的）。

将二进制数据编码成ASCII字符主要的目的是能在纯文本内容中插入二进制数据，常见的应用场景包括：

1. 电子邮件

这个可参考阮一峰的《MIME笔记》。

2. 微软的MHT格式

这是模仿邮件格式将多种资源打包在一个文件中的格式，全部二进制资源都采用 Base64 编码。

3. XML文件

这是一个纯文本文件，若是要基于 XML 格式设计能够保存图片或其它附件的数据格式，那就须要将这些二进制数据转码成 ASCII 字符。

4. DATA URL

最近流行起来的 Data URL，要在URL中使用二进制数据，固然也只能进行 ASCII 编码。

固然除了 Base64 以外，还有其它一些编码方式能够将二进制数据编码成 ASCII 字符，好比十六进制编码，除此以外还有 Quoted-printable 等。甚至 URL 中使用 %XX 来对非 ASCII 字符进行编码的方式也能够算在内。

固然通常非特定环境下，选用十六进制编码和 Base64 编码的状况比较多，主要是由于这两种编码易用，并且转换后的数据量相对较小。

十六进制编码是将 1 个字节编码成 2 个十六进制字符，好比 0x10110110 编码成 B6，转换后数据量会增大 1 倍。

Base64 编码是将 3 个字节共 24 位数据，以每 6 位一个 Base64 字符 [0-9a-zA-Z+/] 表示，24 位数据共须要 4 个 Base64 字符表示，编码后数据增加约 1/3。为何是“约”？由于若是原数据字节数不是 3 的倍数，须要补位，这样转换出来的数据量就会比原来的 4/3 略多一点。

从上面的数据增加比来看，Base64编码 比十六进制编码更节省磁盘容量，因此通常较大的数据须要进行 ASCII 编码多采用 Base64；而较小的数据，则使用易于人工识别十六进制（用纸笔就能解码出来）。

具体参考：为何有的代码要用 base64 进行编码？

Base64算法基本原理

Base64算法的转换方式相似于古典加密算法里的单表置换算法 。RFC 2045中给出了Base64的字符映射表，以下图所示。

这张字符映射表中，Value是十进制编码，Encoding是字符，共映射了64个字符，这也是Base64算法命名的由来。映射表的最后一个字符“=”是用来补位的。

Base64算法的编码和解码操做可用做加密解密，可是Base64的字符映射表是公开的，所以并不能叫作加密算法。

Base64算法主要是将给定的字符以字符编码（如ASCII、UTF-8等）对应的十进制数为基准，作编码操做：

1. 将给定的字符串以字符为单位，转换为对应的字符编码。

2. 将得到的字符编码转换为二进制串。

3. 将得到的二进制串作分组转换操做，每3个8位的二进制串为一组，将这样的一组再转换为4个6位二进制串，不足6位时低位补0。

4. 对每组4个6位二进制串补位，即向6位二进制串的高位补两个0，生成4个8位二进制串。

5. 将得到的4-8二进制码转换为十进制码。

6. 将得到的十进制码用Base64字符映射表中对应的字符替换。

通过Base64编码后的数据会比原始数据略长，为原来的4/3倍，编码后的字符数是4的倍数。

编码后的字符串最多有2个补位的“=”，由于原始数据的二进制串的分组是以3个8位为一组的，余数 = 原始数据字节数 mod 3，余数只能为0、一、2。若是余数为0，3个8位转换为4个6位，高位补0以后是4个8位，则不须要补位符；若是余数为1，1个8位只能转换为2个6位，高位补0以后是2个8位，为了让编码以后的字符数是4的倍数，要补两个补位符；同理，若是余数为2，要补一个补位符。

ASCII码进行Base64编码的例子以下图，字符“A”编码以后的字符串为“QQ==”。

非ASCII码如GBK、UTF-8等编码，一个字符包含多个字节，如UTF-8用3个字节表示一个汉字，GBK用2个字节表示一个汉字。以字符串“密”为例，对应的UTF-8编码是-2七、-8一、-122，用Base64编码以下图，编码后的字符串为“5a+G”。

具体参考：Java加密与解密 - Base64算法 （这个好）     java加密解密研究三、Base64算法

Base64算法的实现

Java API中没有Base64的实现，实际上Sun也有Base64算法的实现，可是没有公布。Bouncy Castle提供了通常Base64算法的实现，Commons Codec提供了基于RFC 2045相关定义的Base64算法实现。

Bouncy Castle遵循的是通常Base64算法，就是根据字符映射表作了编码转换。Commons Codec中既支持RFC 2045定义的Base64算法，也支持通常的Base64算法。这两种的差别是RFC 2045定义的算法要求在编码后的字符串中换行和末尾添加回车换行符。

注：RFC 2045中规定，在电子邮件中，每行为76个字符，每行末需添加一个回车换行符（"\r\n"），无论每行是否够76个字符，都要添加一个回车换行符。不过在实际应用中，根据实际须要，这一要求每每被忽略。

kSOAP中也提供Base64的实现，具体以下：

package org.kobjects.base64;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Base64
{
  static final char[] charTab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();

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

  public static StringBuffer encode(byte[] paramArrayOfByte, int paramInt1, int paramInt2, StringBuffer paramStringBuffer)
  {
    if (paramStringBuffer == null)
      paramStringBuffer = new StringBuffer(paramArrayOfByte.length * 3 / 2);
    int i = paramInt2 - 3;
    int j = paramInt1;
    int k = 0;
    int l;
    while (j <= i)
    {
      l = (paramArrayOfByte[j] & 0xFF) << 16 | (paramArrayOfByte[(j + 1)] & 0xFF) << 8 | paramArrayOfByte[(j + 2)] & 0xFF;
      paramStringBuffer.append(charTab[(l >> 18 & 0x3F)]);
      paramStringBuffer.append(charTab[(l >> 12 & 0x3F)]);
      paramStringBuffer.append(charTab[(l >> 6 & 0x3F)]);
      paramStringBuffer.append(charTab[(l & 0x3F)]);
      j += 3;
      if (k++ < 14)
        continue;
      k = 0;
      paramStringBuffer.append("\r\n");
    }
    if (j == paramInt1 + paramInt2 - 2)
    {
      l = (paramArrayOfByte[j] & 0xFF) << 16 | (paramArrayOfByte[(j + 1)] & 0xFF) << 8;
      paramStringBuffer.append(charTab[(l >> 18 & 0x3F)]);
      paramStringBuffer.append(charTab[(l >> 12 & 0x3F)]);
      paramStringBuffer.append(charTab[(l >> 6 & 0x3F)]);
      paramStringBuffer.append("=");
    }
    else if (j == paramInt1 + paramInt2 - 1)
    {
      l = (paramArrayOfByte[j] & 0xFF) << 16;
      paramStringBuffer.append(charTab[(l >> 18 & 0x3F)]);
      paramStringBuffer.append(charTab[(l >> 12 & 0x3F)]);
      paramStringBuffer.append("==");
    }
    return paramStringBuffer;
  }

  static int decode(char paramChar)
  {
    if ((paramChar >= 'A') && (paramChar <= 'Z'))
      return paramChar - 'A';
    if ((paramChar >= 'a') && (paramChar <= 'z'))
      return paramChar - 'a' + 26;
    if ((paramChar >= '0') && (paramChar <= '9'))
      return paramChar - '0' + 26 + 26;
    switch (paramChar)
    {
    case '+':
      return 62;
    case '/':
      return 63;
    case '=':
      return 0;
    }
    throw new RuntimeException("unexpected code: " + paramChar);
  }

  public static byte[] decode(String paramString)
  {
    ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();
    try
    {
      decode(paramString, localByteArrayOutputStream);
    }
    catch (IOException localIOException)
    {
      throw new RuntimeException();
    }
    return localByteArrayOutputStream.toByteArray();
  }

  public static void decode(String paramString, OutputStream paramOutputStream)
    throws IOException
  {
    int i = 0;
    int j = paramString.length();
    while (true)
    {
      if ((i < j) && (paramString.charAt(i) <= ' '))
        ++i;
      if (i == j)
        return;
      int k = (decode(paramString.charAt(i)) << 18) + (decode(paramString.charAt(i + 1)) << 12) + (decode(paramString.charAt(i + 2)) << 6) + decode(paramString.charAt(i + 3));
      paramOutputStream.write(k >> 16 & 0xFF);
      if (paramString.charAt(i + 2) == '=')
        return;
      paramOutputStream.write(k >> 8 & 0xFF);
      if (paramString.charAt(i + 3) == '=')
        return;
      paramOutputStream.write(k & 0xFF);
      i += 4;
    }
  }
}