base64.cpp

使用TCL实现BASE64的编码和解码功能

//==========================================================================
// Base64 encode & decode algorithm
// Author: YuiDon	Cyberscience Academy Sichuan University 1997
//==========================================================================
// Sequential base64 encoding of which each part must have divisibility by 3 
// to ensure without any redundant pad among them.

//#define BASE64_ENCODE_LENGTH(data_length) ((data_length/3+(data_length%3!=0))*4+(3-(data_length%3)))
#define BASE64_ENCODE_LENGTH(data_length) ((data_length/3+(data_length%3!=0))*4)
#define BASE64_DECODE_LENGTH(code_length) (((code_length/4)+(code_length%4!=0))*3)
const unsigned char _BASE64_ENCODE_MATRIX[66]=\
//	 0123456789ABCDEF
	"ABCDEFGHIJKLMNOP"	// 0
	"QRSTUVWXYZ"		// 1
			  "abcdef"	// 1
	"ghijklmnopqrstuv"	// 2
	"wxyz"				// 3
	    "0123456789+/"	// 3
	"=";				// 4

const unsigned __int8 _BASE64_DECODE_MATRIX[256]=\
{//    0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 0000:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 0010:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,0x3E,  -1,  -1,  -1,0x3F,	// 0020:
	0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,  -1,  -1,  -1,0x00,  -1,  -1,	// 0030:
	  -1,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,	// 0040:
	0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,  -1,  -1,  -1,  -1,  -1,	// 0050:
	  -1,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,	// 0060:
	0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,  -1,  -1,  -1,  -1,  -1,	// 0070:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 0080:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 0090:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00A0:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00B0:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00C0:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00D0:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00E0:
	  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,	// 00F0:
};

unsigned __int32 Base64Encode(unsigned __int8 *_code,const unsigned __int8 *_data,unsigned __int32 data_length);
unsigned __int32 Base64Decode(unsigned __int8 *_data,const unsigned __int8 *_code,unsigned __int32 code_length);

#define BASE64_EXEC 1
#ifdef BASE64_EXEC
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#define _USAGE "Base64 encoder\nCoder YuiDia 1999\nUSAGE: base64 encode|decode <filename>\n"
#define  BUFFERSIZE 65536
#define MAX_PATH 255
int main(int argc, char **__argv, char **__env)
{
	if(argc!=3)
	{
		printf("%s",_USAGE);
		return -1;
	}

	int ret;
	FILE *_fp;

	if(!strcmp(__argv[1],"encode"))
	{
		_fp=fopen(__argv[2],"rb");
		if(!_fp)
		{
			printf("Open file %s failed.\n",__argv[2]);
			return -1;
		}

		struct stat s;
		ret=fstat(fileno(_fp), &s);
		if(ret)
		{
			fclose(_fp);
			printf("Seek file %s failed.\n",__argv[2]);
			return -1;
		}
		unsigned __int32 data_length=s.st_size;

		unsigned __int8 *_data=(unsigned __int8 *)malloc(data_length);
		if(!_data)
		{
			fclose(_fp);
			printf("Not enough memory for %lu bytes.\n",data_length);
			return -1;
		}

		ret=fread(_data,1,data_length,_fp);
		if((unsigned __int32)ret!=data_length)
		{
			free(_data);
			fclose(_fp);
			printf("Read file %s failed.\n",__argv[2]);
			return -1;
		}

		fclose(_fp);

		unsigned __int8 *_code=(unsigned __int8 *)malloc(BASE64_ENCODE_LENGTH(data_length)+1);
		if(!_code)
		{
			free(_data);
			printf("Not enough memory for %lu bytes.\n",BASE64_ENCODE_LENGTH(data_length)+1);
			return -1;
		}

		unsigned __int32 code_length=Base64Encode(_code,_data,data_length);
		free(_data);
		_code[code_length]=0x00;

		char _filename[MAX_PATH+1];
		sprintf(_filename,"%.*s.base64",MAX_PATH,__argv[2]);
		
		FILE *_fp=fopen(_filename,"w");
		if(!_fp)
		{
			free(_code);
			printf("Open file %s failed.\n",_filename);
			return -1;
		}
		
		fprintf(_fp,"%s",_code);		
		fclose(_fp);
		free(_code);
	}
	else if(!strcmp(__argv[1],"decode"))
	{
		_fp=fopen(__argv[2],"r");
		if(!_fp)
		{
			printf("Open file %s failed.\n",__argv[2]);
			return -1;
		}

		struct stat s;
		ret=fstat(fileno(_fp), &s);
		if(ret)
		{
			fclose(_fp);
			printf("Seek file %s failed.\n",__argv[2]);
			return -1;
		}
		unsigned __int32 code_length=s.st_size;
		
		unsigned __int8 *_code=(unsigned __int8 *)malloc(code_length+1);
		if(!_code)
		{
			fclose(_fp);
			printf("Not enough memory for %lu bytes.\n",code_length+1);
			return -1;
		}

		unsigned __int8 *_p=_code;
		unsigned __int32 counter=0;
		while(fread(_p,1,1,_fp))
		{
			
			if(_BASE64_DECODE_MATRIX[*_p]!=0xFF)
			{	counter++;	_p++;	}
		}
		*_p=0x00;

		fclose(_fp);

		unsigned __int8 *_data=(unsigned __int8 *)malloc(BASE64_DECODE_LENGTH(counter)+1);
		if(!_data)
		{
			free(_code);
			printf("Not enough memory for %lu bytes.\n",BASE64_DECODE_LENGTH(counter));
			return -1;
		}

		unsigned __int32 data_length=Base64Decode(_data,_code,counter);
		free(_code);

		char _filename[MAX_PATH+1];
		sprintf(_filename,"%.*s.dat",MAX_PATH,__argv[2]);
		
		FILE *_fp=fopen(_filename,"wb");
		if(!_fp)
		{
			free(_data);
			printf("Open file %s failed.\n",_filename);
			return -1;
		}
		
		ret=fwrite(_data,1,data_length,_fp);
		fclose(_fp);
		free(_data);
	}
	else
		printf("%s\n",_USAGE);

	return 0;
}

#else
#pragma once
#endif

//--------------------------------------------------------------------------
unsigned __int32 Base64Encode(unsigned __int8 *_code,const unsigned __int8 *_data,unsigned __int32 data_length)
{
	unsigned __int32 flag=0;
	unsigned __int32 i;
	unsigned __int8 * _base64_encode_matrix=(unsigned __int8 *)_BASE64_ENCODE_MATRIX;
	for(i=0;i<data_length;i+=3)
	{
		// base: [AAAAAA|AA] [BBBB|BBBB] [.... ....]
		// code: [.... ....] [.... ....] [.... ....] [.... ....]
		*_code++=_base64_encode_matrix[_data[i]>>2&0x3F];
		// code: [00AA AAAA] [.... ....] [.... ....] [.... ....]
		*_code++=_base64_encode_matrix[_data[i]<<4&0x30|(i+1<data_length?(_data[i+1]>>4)&0x0F:0x00)];
		// code: [00AA AAAA] [00AA BBBB] [.... ....] [.... ....]
//		*_code++=_base64_encode_matrix[(i+1<data_length?_data[i+1]<<2&0x3C:0x00)|(i+2<data_length?_data[i+2]>>6&0x03:0x00)];
		*_code++=_base64_encode_matrix[i+1<data_length?((_data[i+1]<<2&0x3C)|(i+2<data_length?_data[i+2]>>6&0x03:0x00)):0x40];
		// code: [00AA AAAA] [00AA BBBB] [00BB BB00] [.... ....]
		*_code++=_base64_encode_matrix[i+2<data_length?_data[i+2]&0x3F:0x40];
		// code: [00AA AAAA] [00AA BBBB] [00BB BB00] [0000 0000]
	}
	unsigned __int32 pad_length=3-(data_length%3);
//	for(i=0;i<pad_length;i++)	*(--_code)='=';
	unsigned __int32 code_length=(data_length/3+(data_length%3!=0))*4;	//+(3-(data_length%3));
	return code_length;
}

//--------------------------------------------------------------------------
unsigned __int32 Base64Decode(unsigned __int8 *_data,const unsigned __int8 *_code,unsigned __int32 code_length)
{
	unsigned __int32 i;
	unsigned __int8 data=0;
	unsigned __int32 pad_length=0;
	unsigned __int8 *_base64_decode_matrix=(unsigned __int8 *)_BASE64_DECODE_MATRIX;
	/*
	unsigned __int8 _base64_decode_matrix[256]={-1};
	for(i='A';i<='Z';i++,data++)
		_base64_decode_matrix[i]=data;
	for(i='a';i<='z';i++,data++)
		_base64_decode_matrix[i]=data;
	for(i='0';i<='9';i++,data++)
		_base64_decode_matrix[i]=data;
	_base64_decode_matrix['+']=data++;
	_base64_decode_matrix['/']=data++;
	_base64_decode_matrix['=']=0x00;
	*/
	for(i=0;i<code_length;i+=4)
	{
		// base: [00AA AAAA] [00BB BBBB] [00CC CCCC] [00DD DDDD]
		if(i  >=code_length||_code[i  ]=='='||!_code[i  ]){	pad_length=4;	break;	}
		if(_base64_decode_matrix[_code[i]]==-1)	return -1;
		// data: [.... ....] [.... ....] [.... ....] [.... ....]
		*_data++=                (_base64_decode_matrix[_code[i  ]]<<2&0xFC)     |(i+1<code_length?_base64_decode_matrix[_code[i+1]]>>4&0x03:0x00);

		if(i+1>=code_length||_code[i+1]=='='||!_code[i+1]){	pad_length=3;	break;	}
		if(_base64_decode_matrix[_code[i+1]]==-1)	return -1;
		// data: [AAAA AABB] [.... ....] [.... ....] [.... ....]
		*_data++=(i+1<code_length?_base64_decode_matrix[_code[i+1]]<<4&0xF0:0x00)|(i+2<code_length?_base64_decode_matrix[_code[i+2]]>>2&0x0F:0x00);

		if(i+2>=code_length||_code[i+2]=='='||!_code[i+2]){	pad_length=2;	break;	}
		if(_base64_decode_matrix[_code[i+2]]==-1)	return -1;
		// data: [AAAA AABB] [BBBB CCCC] [.... ....] [.... ....]
		*_data++=(i+2<code_length?_base64_decode_matrix[_code[i+2]]<<6&0xC0:0x00)|(i+3<code_length?_base64_decode_matrix[_code[i+3]]&0x3F:0x00);

		if(i+3>=code_length||_code[i+3]=='='||!_code[i+3]){	pad_length=1;	break;	}
		if(_base64_decode_matrix[_code[i+3]]==-1)	return -1;
		// data: [AAAA AABB] [BBBB CCCC] [CCDD DDDD] [.... ....]
	}

	unsigned __int32 data_length=((code_length/4)+(code_length%4!=0))*3-pad_length;
	return data_length;
}
//-----------------------------------------------------------------------------
unsigned __int32 Base64CheckCode(unsigned __int8 *_data,const unsigned __int8 *_code,unsigned __int32 code_length)
{
	unsigned __int32 i;
	unsigned __int8 data=0;
	unsigned __int32 pad_length=0;
	unsigned __int8 *_base64_decode_matrix=(unsigned __int8 *)_BASE64_DECODE_MATRIX;

	for(i=0;i<code_length;i+=4)
	{
		if(_base64_decode_matrix[_code[i]]==-1)	return -1;
		if(i  >=code_length||_code[i  ]=='='||!_code[i  ]){	pad_length=4;	break;	}
		if(_base64_decode_matrix[_code[i+1]]==-1)	return -1;
		if(i+1>=code_length||_code[i+1]=='='||!_code[i+1]){	pad_length=3;	break;	}
		if(_base64_decode_matrix[_code[i+2]]==-1)	return -1;
		if(i+2>=code_length||_code[i+2]=='='||!_code[i+2]){	pad_length=2;	break;	}
		if(_base64_decode_matrix[_code[i+3]]==-1)	return -1;
		if(i+3>=code_length||_code[i+3]=='='||!_code[i+3]){	pad_length=1;	break;	}
	}

	unsigned __int32 data_length=((code_length/4)+(code_length%4!=0))*3-pad_length;
	return data_length;
}