Java之Base64编码解析

最新推荐文章于 2024-01-25 16:31:42 发布

置顶两只小猴

最新推荐文章于 2024-01-25 16:31:42 发布

阅读量3k

点赞数

分类专栏： java 文章标签： Base64 base64编码

本文链接：https://blog.csdn.net/dycsos123/article/details/84144010

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

说明：前段时间梳理了一下最近工作中用到加解密算法，从最早的MD5、Base64到后面的对称算法DES、IDEA，非对称算法RSA、DSA等，准备整理出来做一备份。base64是比较特殊的，准确的说它是一种编码方式，主要解决网络某些字节编码传输问题的；我们项目中也确实把它作为一种加密算法，这里在第4部分结合代码详细说明（部分原理&图片或取于网络）。

1、Base64编码起源

因为有些网络传送渠道并不支持所有的字节，例如传统的邮件只支持可见字符的传送，像ASCII码的控制字符就不能通过邮件传送。这样用途就受到了很大的限制，比如图片二进制流的每个字节不可能全部是可见字符，所以就传送不了。最好的方法就是在不改变传统协议的情况下，做一种扩展方案来支持二进制文件的传送。把不可打印的字符也能用可打印字符来表示，问题就解决了。Base64编码应运而生，Base64就是一种基于64个可打印字符来表示二进制数据的表示方法。

2、Base64编码原理

在这里插入图片描述
这是一张base64的序列图，通常一个字节是用8个bit 表示，在通常字符处理中一个字符通常是2字节16bit，也有utf-8中字符占3个字节24bit…；而base64是用6个bit表示一个字节，通过是以6的位数12bit,18bit…去处理；这里取8与6的最小公位数24，所以通过用4个Base64字符可以表示3个标准的ascll字符（所以经过base64编码后，长度会比源串长1/3，后面谈到RSA会具体说明加密后的长度变化）。
在这里插入图片描述
像上图中，A字符占一个字节8位，转成base64编码先以6位划分，第二个6位只有01其余位则用0占用，第三个6位与第四个6位为空，则用==表示，这也是我们常看到经base64转码后为啥常以=结尾的原因。

3、Base64加解密

这里加解密，主要是以Java自带的为主(这里用的是jdk7)，jdk中实现base64加解密主要是基于图一中标准的字典序实现的，源码在rt.jar中。
在这里插入图片描述
具体代码会在第4部分中说明，很显然JDK实现了标准的字典序，用来进base64进行编码处理肯定没问题，但用来加解密貌似没意义，大家用共同的标准，就像你家的门给每个访问都准备的钥匙。

4、变化的Base64序列

如果让Base64具有加解密的功能，至少要一部分是变化的；这里可以通过变化标准序列的方式；建议大家用到的时候，可以先看一下第3部分中标出那个类的源码（没几行代码）；这个变化的序列可以根据时间、根据UUID、根据一切可以变换的东西来生成，这里是根据UUID来随机生成序列。
1、生成随机序列

private static String base64Str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	// 根据UUID生成
	public static synchronized String getRandomBase64(int len) {
		char[] chars = base64Str.toCharArray();
		String uuid = UUID.randomUUID().toString();
		byte[] sha256Arr = null;
		try {
			MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
			messageDigest.reset();
			sha256Arr = messageDigest.digest(uuid.getBytes());
			if (sha256Arr != null) {
				for (int i = 0; i < sha256Arr.length; i++) {
					int pos = Math.abs(sha256Arr[i]) % 32;
					char tmp = chars[i];
					chars[i] = chars[32 + pos];
					chars[32 + pos] = tmp;
				}
			}
		} catch (Exception e) {}
		return new String(chars).substring(0, len);
	}

2、base64的编码与解码的算法我就不自己实现了(网上有各种实现)，我比较懒，直接Copy出来改JDK7源码自带的，将它带的标准序列替换掉(下面只是测试代码，不严谨供参考用)。

public class Base64Encode extends CharacterEncoder {
	public static char[] pem_array;
	@Override
	protected int bytesPerAtom() {
		return 3;
	}
	@Override
	protected int bytesPerLine() {
		return 57;
	}
	@Override
	protected void encodeAtom(final OutputStream outputStream,
			final byte[] array, final int n, final int n2) throws IOException {
		if (n2 == 1) {
			final byte b = array[n];
			final int n3 = 0;
			outputStream.write(Base64Encode.pem_array[b >>> 2 & 0x3F]);
			outputStream.write(Base64Encode.pem_array[(b << 4 & 0x30)
					+ (n3 >>> 4 & 0xF)]);
			outputStream.write(61);
			outputStream.write(61);
		} else if (n2 == 2) {
			final byte b2 = array[n];
			final byte b3 = array[n + 1];
			final int n4 = 0;
			outputStream.write(Base64Encode.pem_array[b2 >>> 2 & 0x3F]);
			outputStream.write(Base64Encode.pem_array[(b2 << 4 & 0x30)
					+ (b3 >>> 4 & 0xF)]);
			outputStream.write(Base64Encode.pem_array[(b3 << 2 & 0x3C)
					+ (n4 >>> 6 & 0x3)]);
			outputStream.write(61);
		} else {
			final byte b4 = array[n];
			final byte b5 = array[n + 1];
			final byte b6 = array[n + 2];
			outputStream.write(Base64Encode.pem_array[b4 >>> 2 & 0x3F]);
			outputStream.write(Base64Encode.pem_array[(b4 << 4 & 0x30)
					+ (b5 >>> 4 & 0xF)]);
			outputStream.write(Base64Encode.pem_array[(b5 << 2 & 0x3C)
					+ (b6 >>> 6 & 0x3)]);
			outputStream.write(Base64Encode.pem_array[b6 & 0x3F]);
		}
	}
	/*static {
    pem_array = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
	}*/
}

public class Base64Decode extends CharacterDecoder{
	public static  char[] pem_array;
    private static  byte[] pem_convert_array;
    byte[] decode_buffer;
    public Base64Decode() {
        this.decode_buffer = new byte[4];
    }
    @Override
    protected int bytesPerAtom() {
        return 4;
    } 
    @Override
    protected int bytesPerLine() {
        return 72;
    }  
    @Override
    protected void decodeAtom(final PushbackInputStream pushbackInputStream, final OutputStream outputStream, int n) throws IOException {
        int n2 = -1;
        int n3 = -1;
        int n4 = -1;
        int n5 = -1;
        if (n < 2) {
            throw new CEFormatException("Base64Decode: Not enough bytes for an atom.");
        }
        int read;
        do {
            read = pushbackInputStream.read();
            if (read == -1) {
                throw new CEStreamExhausted();
            }
        } while (read == 10 || read == 13);
        this.decode_buffer[0] = (byte)read;
        if (this.readFully(pushbackInputStream, this.decode_buffer, 1, n - 1) == -1) {
            throw new CEStreamExhausted();
        }
        if (n > 3 && this.decode_buffer[3] == 61) {
            n = 3;
        }
        if (n > 2 && this.decode_buffer[2] == 61) {
            n = 2;
        }
        switch (n) {
            case 4: {
                n5 = Base64Decode.pem_convert_array[this.decode_buffer[3] & 0xFF];
            }
            case 3: {
                n4 = Base64Decode.pem_convert_array[this.decode_buffer[2] & 0xFF];
            }
            case 2: {
                n3 = Base64Decode.pem_convert_array[this.decode_buffer[1] & 0xFF];
                n2 = Base64Decode.pem_convert_array[this.decode_buffer[0] & 0xFF];
                break;
            }
        }
        switch (n) {
            case 2: {
                outputStream.write((byte)((n2 << 2 & 0xFC) | (n3 >>> 4 & 0x3)));
                break;
            }
            case 3: {
                outputStream.write((byte)((n2 << 2 & 0xFC) | (n3 >>> 4 & 0x3)));
                outputStream.write((byte)((n3 << 4 & 0xF0) | (n4 >>> 2 & 0xF)));
                break;
            }
            case 4: {
                outputStream.write((byte)((n2 << 2 & 0xFC) | (n3 >>> 4 & 0x3)));
                outputStream.write((byte)((n3 << 4 & 0xF0) | (n4 >>> 2 & 0xF)));
                outputStream.write((byte)((n4 << 6 & 0xC0) | (n5 & 0x3F)));
                break;
            }
        }
    }   
     {
       // pem_array = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
        pem_convert_array = new byte[256];
        for (int i = 0; i < 255; ++i) {
            Base64Decode.pem_convert_array[i] = -1;
        }
        for (int j = 0; j < Base64Decode.pem_array.length; ++j) {
            Base64Decode.pem_convert_array[Base64Decode.pem_array[j]] = (byte)j;
        }
    }
}

这里写了两个类Base64Encoder、Base64Decoder分别继承CharacterEncoder和CharacterDecoder两个你类(照抄源码)，将标准序列中private final 改掉便可。
3、传入随机序列，测试，可以多试几次

private static char[] ch = Base64Util.getRandomBase64(64).toCharArray() ;
	// 加密
	public static String getBase64(String str) throws Exception {
		byte[] b = null;
		String s = null;
			b = str.getBytes("utf-8");
		if (b != null) {
			Base64Encode.pem_array=ch;
			s = new Base64Encode().encode(b);
		}
		return s;
	}
	// 解密
	public static String getFromBase64(String s) throws Exception {
		byte[] b = null;
		String result = null;
		if (s != null) {
			Base64Decode.pem_array = ch ;
			Base64Decode decoder = new Base64Decode();
				b = decoder.decodeBuffer(s);
				result = new String(b, "utf-8");
		}
		return result;
	}
	public static void main(String[] s) throws Exception{
		String o = "日明星辰hello" ;
		System.out.println(getBase64(o));
		System.out.println(getFromBase64(getBase64(o)));
	}

在这里插入图片描述

持续更新中，可以关注…

两只小猴

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java之Base64编码解析

说明：前段时间梳理了一下最近工作中用到加解密算法，从最早的MD5、Base64到后面的对称算法DES、IDEA，非对称算法RSA、DSA等，准备整理出来做一备份。base64是比较特殊的，准确的说它是一种编码方式，主要解决网络某些字节编码传输问题的；我们项目中也确实把它作为一种加密算法，这里在第4部分结合代码详细说明（部分原理&amp;amp;amp;图片或取于网络）。1、Base64编码起源因为有...
复制链接

扫一扫