base64编码

1、Base64编码介绍

Base64编码是从二进制到字符的过程.

Base64编码主要用在传输、存储、表示二进制等领域，还可以用来加密，但是这种加密比较简单.

byte[] byteArray = Encoding.UTF8.GetBytes(content);
content = Convert.ToBase64String(byteArray);

开发者对 Base64编码肯定很熟悉，是否对它有很清晰的认识就不一定了。实际 上Base64已经简单到不能再简单了，如果对它的理解还是模棱两可实在不应该。大概介绍一下Base64的相关内容，花几分钟时间就可以彻底理解它。文 章下边贴了一个Base64的编解码器，方便阅读文章的同时来实验。

1.1Base64编码由来

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

1.2 Base64编码原理

看一下Base64的索引表，字符选用了"A-Z、a-z、0-9、+、/" 64个可打印字符。数值代表字符的索引，这个是标准Base64协议规定的，不能更改。64个字符用6个bit位就可以全部表示，一个字节有8个bit 位，剩下两个bit就浪费掉了，这样就不得不牺牲一部分空间了。这里需要弄明白的就是一个Base64字符是8个bit，但是有效部分只有右边的6个 bit，左边两个永远是0。

　　那么怎么用6个有效bit来表示传统字符的8个bit呢？8和6的最小公倍数 是24，也就是说3个传统字节可以由4个Base64字符来表示，保证有效位数是一样的，这样就多了1/3的字节数来弥补Base64只有6个有效bit 的不足。你也可以说用两个Base64字符也能表示一个传统字符，但是采用最小公倍数的方案其实是最减少浪费的。结合下边的图比较容易理解。Man是三个 字符，一共24个有效bit，只好用4个Base64字符来凑齐24个有效位。红框表示的是对应的Base64，6个有效位转化成相应的索引值再对应 Base64字符表，查出"Man"对应的Base64字符是"TWFU"。说到这里有个原则不知道你发现了没有，要转换成Base64的最小单位就是三个字节，对一个字符串来说每次都是三个字节三个字节的转换，对应的是Base64的四个字节。这个搞清楚了其实就差不多了。

但是转换到最后你发现不够三个字节了怎么办呢？愿望终于实现了，我们可以用两 个Base64来表示一个字符或用三个Base64表示两个字符，像下图的A对应的第二个Base64的二进制位只有两个，把后边的四个补0就是了。所以 A对应的Base64字符就是QQ。上边已经说过了，原则是Base64字符的最小单位是四个字符一组，那这才两个 字 符，后边补两个"=“吧。其实不用”=“也不耽误解码，之所以用”=“，可能是考虑到多段编码后的Base64字符串拼起来也不会引起混淆。由此可见 Base64字符串只可能最后出现一个或两个”=“，中间是不可能出现”="的。下图中字符"BC"的编码过程也是一样的。

1.3 总结

说起Base64编码可能有些奇怪，因为大多数的编码都是由字符转化成二进制的过程，而从二进制转成字符的过程称为解码。而Base64的概念就恰好反了，由二进制转到字符称为编码，由字符到二进制称为解码。

Base64编码主要用在传输、存储、表示二进制等领域，还可以用来加密，但是这种加密比较简单，只是一眼看上去不知道什么内容罢了，当然也可以对Base64的字符序列进行定制来进行加密。

Base64编码是从二进制到字符的过程，像一些中文字符用不同的编码转为二 进制时，产生的二进制是不一样的，所以最终产生的Base64字符也不一样。例如"上网"对应utf-8格式的Base64编码是"5LiK572R"， 对应GB2312格式的Base64编码是"yc/N+A=="。

2、base64 C语言代码

base64.c

#include "Base64.h"
unsigned char B64_EncodeByte(unsigned char c)
{
	c &= 0x3F;
	if (c < 26)
		return (c + 'A');
	if (c < 52)
		return (c + 'a' - 26);
	if (c < 62)
		return (c + '0' - 52);
	if (c == 62)
		return '+';
	return '/';
}
unsigned char B64_DecodeByte(unsigned char c)
{
	if (c >= '0' && c <= '9')
		return (c - '0' + 52);
	if (c >= 'a' && c <= 'z')
		return (c - 'a' + 26);
	if (c >= 'A' && c <= 'Z')
		return (c - 'A');
	if(c == '+')
		return 62;
	if(c == '/')
		return 63;
	return 0xFF;
}
int B64_EncodeBlock(unsigned char* lpIn, int iIndex, unsigned char* lpOut, int oIndex)
{
	unsigned char d0 = lpIn[iIndex];
	unsigned char d1 = lpIn[iIndex + 1];
	lpOut[oIndex] = B64_EncodeByte(d0 >> 2);
	lpOut[oIndex + 1] = B64_EncodeByte(((d0 << 6) >> 2) | (d1 >> 4));
	d0 = lpIn[iIndex + 2];
	lpOut[oIndex + 2] = B64_EncodeByte(((d1 << 4) >> 2) | (d0 >> 6));
	lpOut[oIndex + 3] = B64_EncodeByte((d0 << 2) >> 2);
	return iIndex + 3;
}
int B64_DecodeBlock(unsigned char* lpIn, int iIndex, unsigned char* lpOut, int oIndex)
{
	unsigned char d0 = B64_DecodeByte(lpIn[iIndex]);
	unsigned char d1 = B64_DecodeByte(lpIn[iIndex + 1]);
	lpOut[oIndex] = ((d0 << 2) | (d1 >> 4));
	d0 = B64_DecodeByte(lpIn[iIndex + 2]);
	if (d0 == 0xFF)
	{
		lpOut[oIndex + 1] = 0;
		lpOut[oIndex + 2] = 0;
		return oIndex + 1;
	}
	lpOut[oIndex + 1] = ((d1 << 4) | (d0 >> 2));
	d1 = B64_DecodeByte(lpIn[iIndex + 3]);
	if (d1 == 0xFF)
	{
		lpOut[oIndex + 2] = 0;
		return oIndex + 2;
	}
	lpOut[oIndex + 2] = ((d0 << 6) | d1);
	return oIndex + 3;
}

int B64_Encode(unsigned char* lpIn, int len, unsigned char* lpOut)
{
	int l = 0;
	int i = 0;
	unsigned char padding = '=';
	while (i < len)
	{
		if (i <= len - 3)
			i = B64_EncodeBlock(lpIn, i, lpOut, l);
		else
		{
			unsigned char t[3] = { 0, 0, 0 };
			if (i == len - 2)
			{
				t[0] = lpIn[i];		//lpIn[len - 2]
				t[1] = lpIn[i + 1];	//lpIn[len - 1]
				B64_EncodeBlock(t, 0, lpOut, l);
			}
			else if (i == len - 1)
			{
				t[0] = lpIn[i];		//lpIn[len - 1]
				B64_EncodeBlock(t, 0, lpOut, l);
				lpOut[l + 2] = padding;
			}
			i = len;
			lpOut[l + 3] = padding;
		}
		l += 4;
	}
	return l;
}
int B64_Decode(unsigned char* lpIn, int len, unsigned char* lpOut)
{
	int l = 0;
	int i = 0;
	while (i < len)
	{
		l = B64_DecodeBlock(lpIn, i, lpOut, l);
		i += 4;
	}
	return l;
}

base64.h

#ifndef __BASE64_H__
#define __BASE64_H__

#define B64_EncodeLength(len)		(((len) + 2) / 3 * 4)
#define B64_DecodeLength(len)		(((len) + 3) / 4 * 3)

extern int B64_Encode(unsigned char* lpIn, int len, unsigned char* lpOut);
extern int B64_Decode(unsigned char* lpIn, int len, unsigned char* lpOut);

#endif

void led_task(void * arg) 
{
	while(1)
	{
		//base64测试
		#if 1
		//加密
		uint16_t length_after,length_before;
		uint8_t  Encode_buff1[10]={'I','a','m','a','s','h','a','b','i',0x31};
		uint8_t  Decode_buff1[16];
		length_before=10;
		length_after=B64_Encode(Encode_buff1,length_before,Decode_buff1);
		
		//解密
		uint8_t Decode_buff2[16]={'S','W','F','t','Y','X','N','o','Y','W','J','p','M','Q','=','='};
		uint8_t Encode_buff2[10];
		B64_Decode(Decode_buff2,16,Encode_buff2);
		#endif
    osDelay(100);
		osThreadYield();
	}
}