base64

       

       介绍部分来自百度百科。

       标准的Base64并不适合直接放在URL里传输，因为URL编码器会把标准Base64中的“/”和“+”字符变为形如“%XX”的形式，而这些“%”号在存入数据库时还需要再进行转换，因为ANSI SQL中已将“%”号用作 通配符。

为解决此问题，可采用一种用于URL的改进Base64编码，它在末尾填充'='号，并将标准Base64中的“+”和“/”分别改成了“_”和“-”，这样就免去了在URL编解码和数据库存储时所要作的转换，避免了编码信息长度在此过程中的增加，并统一了数据库、表单等处对象 标识符的格式。

另有一种用于 正则表达式的改进Base64变种，它将“+”和“/”改成了“!”和“-”，因为“+”,“*”以及前面在IRCu中用到的“[”和“]”在正则表达式中都可能具有特殊含义。

此外还有一些变种，它们将“+/”改为“_-”或“._”（用作 编程语言中的 标识符名称）或“.-”（用于XML中的Nmtoken）甚至“_:”（用于XML中的Name）。

Base64要求把每三个8Bit的字节转换为四个6Bit的字节（3*8 = 4*6 = 24），然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。

规则

关于这个编码的规则：

①.把3个字符变成4个字符。

②每76个字符加一个换行符。

③.最后的结束符也要处理。

例子（1）

转换前 11111111, 11111111, 11111111 （二进制）

转换后 00111111, 00111111, 00111111, 00111111 （二进制）

上面的三个字节是原文，下面的四个字节是转换后的Base64编码，其前两位均为0。

转换后，我们用一个码表来得到我们想要的字符串（也就是最终的Base64编码），这个表是这样的：（摘自RFC2045）

转换表

Table 1: The Base64 Alphabet

索引	对应字符	索引	对应字符	索引	对应字符	索引	对应字符
0	A	17	R	34	i	51	z
1	B	18	S	35	j	52	0
2	C	19	T	36	k	53	1
3	D	20	U	37	l	54	2
4	E	21	V	38	m	55	3
5	F	22	W	39	n	56	4
6	G	23	X	40	o	57	5
7	H	24	Y	41	p	58	6
8	I	25	Z	42	q	59	7
9	J	26	a	43	r	60	8
10	K	27	b	44	s	61	9
11	L	28	c	45	t	62	+
12	M	29	d	46	u	63	/
13	N	30	e	47	v		（pad =）
14	O	31	f	48	w
15	P	32	g	49	x
16	Q	33	h	50	y

例子（2）

转换前 10101101,10111010,01110110

转换后 00101011, 00011011 ,00101001 ,00110110

十进制 43 27 41 54

对应码表中的值 r b p 2

所以上面的24位编码，编码后的Base64值为 rbp2

用更接近于编程的思维来说，编码的过程是这样的：

第一个字符通过右移2位获得第一个目标字符的Base64表位置，根据这个数值取到表上相应的字符，就是第一个目标字符。
然后将第一个字符左移4位加上第二个字符右移4位，即获得第二个目标字符。
再将第二个字符左移2位加上第三个字符右移6位，获得第三个目标字符。
最后取第三个字符的右6位即获得第四个目标字符。

在以上的每一个步骤之后，再把结果与 0x3F 进行 AND 位操作，就可以得到编码后的字符了。

原文的字节数量应该是3的倍数啊，如果这个条件不能满足的话，那么该原文的字节不够的地方可以用全0来补足，转换时Base64编码用=号来代替。这就是为什么有些Base64编码会以一个或两个等号结束的原因，但等号最多只有两个。因为：

余数 = 原文字节数 MOD 3

所以余数任何情况下都只可能是0，1，2这三个数中的一个。如果余数是0的话，就表示原文字节数正好是3的倍数（最理想的情况啦）。如果是1的话，为了让Base64编码是4的倍数，就要补2个等号；同理，如果是2的话，就要补1个等号。

例子

Encryption.h

#ifndef ENCRYPTION_H
#define ENCRYPTION_H

 /**
  * ptr is pointer of need encryption string
  * encodePtr is the pointer of string that had encryption, it is better to be null
  * return number littler than 0 mean error; 0 is success
  * count is the size of need encode data;
 */
 int Encode(const char* ptr, char* &encodePtr, int count);
 /**
  * ptr is pointer of need UnEncryption string
  * encodePtr is the pointer of string that had UnEncryption, it is better to be null
  * return number littler than 0 mean error; 0 is success
  * count is the size of need unEncode data;
 */
 int UnEncode(const char* ptr, char* &uncodePtr, int count);

#endif

Encryption.cpp

#include "Encryption.h"
#include "string"
#include "SaveLog.h"

/*base64 码表数组*/
static char base[64] = {
'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','+','/',
};

int Encode(const char* sorPtr, char* &disPtr, int count)
{
 bool is_encode = -1;
 int size = 0;
 unsigned int sorPtr_indx = 0;
 unsigned int disPtr_indx = 0;

 do{
  if(sorPtr == NULL || count <= 0)
  {
   writeLog("param address is null \n");
   break;
  }
  size = count % 3;
  if(size)
  {
   size = (count / 3 + 1) * 4 + 2;
  }
  else
  {
   size = count / 3 * 4 + 2;
  }
  disPtr = (char*)malloc(size);
  if(!disPtr)
  {
   writeLog("malloc address is null \n");
   break;
  }
  memset(disPtr,'\0',size);
  for(unsigned int p = 0; ;)
  {
   if(sorPtr[sorPtr_indx] == '\0')
   {
    //goto end_while;
    break;//加密完成 结束
   }
   else
   {    
    disPtr_indx = sorPtr[sorPtr_indx]>>2 & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;
   }
   if(sorPtr[sorPtr_indx+1] == '\0' )
   {
    disPtr_indx = (sorPtr[sorPtr_indx]<<4 & sorPtr[sorPtr_indx+1]>>4) & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;
    disPtr[p] = '=';
    p++;
    disPtr[p] = '=';
    break;//加密完成 结束
   }
   else
   {
    disPtr_indx = (sorPtr[sorPtr_indx]<<4 & sorPtr[sorPtr_indx+1]>>4) & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;
   }
   if( sorPtr[sorPtr_indx+2] == '\0')
   {
    disPtr_indx = (sorPtr[sorPtr_indx+1]<<2 & sorPtr[sorPtr_indx+2]>>6) & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;
    disPtr[p] = '=';
    break;//加密完成 结束
   }
   else
   {
    disPtr_indx = (sorPtr[sorPtr_indx+1]<<2 & sorPtr[sorPtr_indx+2]>>6) & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;

    disPtr_indx = sorPtr[sorPtr_indx+2]>>6 & 0x3f;
    disPtr[p] = base[disPtr_indx];
    p++;
    sorPtr_indx = sorPtr_indx + 3 ;
   }   
   
  }
  is_encode = 0;
 }while(0);
 
 return is_encode;
}

int UnEncode(const char* cod_Ptr, char* &dis_Ptr,int count)
{
 bool is_unCode = -1;
 int size = 0;
 unsigned int sorPtr_indx = 0;
 unsigned int disPtr_indx = 0;
 char* sor_Ptr = NULL;
 
 do{
  size = count % 4;
  if(!cod_Ptr || size)
  {
   writeLog("param is error line: %d \n",__LINE__);
   break;
  }
  size = count / 4 * 3 + 2;
  dis_Ptr = (char*)malloc(size);
  if(!dis_Ptr)
  {
   writeLog("malloc failed line: %d \n",__LINE__);
   break;
  }
  memset(dis_Ptr,'\0',size);

  sor_Ptr = (char*)malloc(count + 1);
  if(!sor_Ptr)
  {
   writeLog("malloc failed line: %d \n",__LINE__);
   break;
  }
  memset(sor_Ptr, '\0', count + 1);
  memcpy(sor_Ptr, cod_Ptr, count);
  for(sorPtr_indx = 0; sor_Ptr[sorPtr_indx] != '\0'; sorPtr_indx++)
  {
   if( 65 <= sor_Ptr[sorPtr_indx] && sor_Ptr[sorPtr_indx] <= 90)
   {
    sor_Ptr[sorPtr_indx] = sor_Ptr[sorPtr_indx] - 65;
   }
   else if(97 <= sor_Ptr[sorPtr_indx] && sor_Ptr[sorPtr_indx] <= 122)
   {
    sor_Ptr[sorPtr_indx] = sor_Ptr[sorPtr_indx] - 71;
   }
   else if(48 <= sor_Ptr[sorPtr_indx] && sor_Ptr[sorPtr_indx] <= 57)
   {
    sor_Ptr[sorPtr_indx] = sor_Ptr[sorPtr_indx] + 4;
   }
   else if(sor_Ptr[sorPtr_indx] == 43)
   {
    sor_Ptr[sorPtr_indx] = sor_Ptr[sorPtr_indx] + 19;
   }
   else if(sor_Ptr[sorPtr_indx] == 47)
   {
    sor_Ptr[sorPtr_indx] = sor_Ptr[sorPtr_indx] + 16;
   }
   else if(sor_Ptr[sorPtr_indx] == '=')
   {
    sor_Ptr[sorPtr_indx] = 0;
   }
   else
   {
    writeLog("sor_Ptr error line: %d \n",__LINE__);
    goto end_while;
   }
  }
  for(sorPtr_indx =0; sor_Ptr[sorPtr_indx] != '\0'; )
  {
   static  unsigned int p = 0;
   dis_Ptr[p] = (sor_Ptr[sorPtr_indx]<<2) & (sor_Ptr[sorPtr_indx+1] >>6);
   p++;
   dis_Ptr[p] = (sor_Ptr[sorPtr_indx + 1]<<4) & (sor_Ptr[sorPtr_indx+2] >>2);
   p++;
   dis_Ptr[p] = (sor_Ptr[sorPtr_indx + 2]<<6) & (sor_Ptr[sorPtr_indx+3] >>2);
   p++;
   sorPtr_indx = sorPtr_indx + 4;
  }
  is_unCode = 0;
 }while(0);

end_while:
 return is_unCode;
}