Base64加解密

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，Base64编码可用于在HTTP环境下传递较长的标识信息。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base64编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。金融数据也常以base64编码格式提供。

Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64，所以每6个比特为一个单元，对应某个可打印字符。三个字节有24个比特，对应于4个Base64单元，即3个字节需要用4个可打印字符来表示。它可用来作为电子邮件的传输编码。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9，这样共有62个字符，此外两个可打印符号在不同的系统中而不同。一些如uuencode的其他编码方法，和之后binhex的版本使用不同的64字符集来代表6个二进制数字，但是它们不叫Base64。

Base64索引表

C++实现代码

1. 《Base64.h》

// Base64.h
#pragma once
#include <windows.h>

class CBase64
{
    // Internal bucket class.
    class TempBucket
    {
    public:
        BYTE         nData[4];
        BYTE         nSize;
        void         Clear() { ::ZeroMemory(nData, 4); nSize = 0; };
    };

    PBYTE                       m_pDBuffer;
    PBYTE                       m_pEBuffer;
    DWORD                       m_nDBufLen;
    DWORD                       m_nEBufLen;
    DWORD                       m_nDDataLen;
    DWORD                       m_nEDataLen;

public:
    CBase64();
    virtual ~CBase64();

public:
    virtual PBYTE         Encode(const PBYTE, DWORD);
    virtual PBYTE      Decode(const PBYTE, DWORD);
    virtual CString         Encode(LPCSTR sMessage);
    virtual CString      Decode(LPCSTR sMessage);

    virtual LPCSTR     DecodedMessage() const;
    virtual LPCSTR     EncodedMessage() const;

    virtual void         AlloCEncodeDlg(DWORD);
    virtual void         AllocDecode(DWORD);
    virtual void         SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
    virtual void         SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen);

protected:
    virtual void         _EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer);
    virtual ULONG         _DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer);
    virtual void         _EncodeRaw(TempBucket &, const TempBucket &);
    virtual void         _DecodeRaw(TempBucket &, const TempBucket &);
    virtual BOOL         _IsBadMimeChar(BYTE);

    static char         m_DecodeTable[256];
    static BOOL         m_Init;
    void                       _Init();
};

2. 《CBase64.cpp》

// CBase64.cpp
// CBase64.cpp: implementation of the CBase64 class.

//////////////////////////////////////////////////////////////////////
#include "stdAfx.h"
#include "Base64.h"
#include "DataX.h"

using namespace DataX;

// Digits...
static char Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

BOOL CBase64::m_Init   = FALSE;
char CBase64::m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE       4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a)     ((((a) / 4096)  +  1) * 4096)
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBase64::CBase64()
	: m_pDBuffer(NULL),
	m_pEBuffer(NULL),
	m_nDBufLen(0),
	m_nEBufLen(0)
{

}

CBase64::~CBase64()
{
	if (m_pDBuffer != NULL)
	{
		delete [] m_pDBuffer;
	}

	if (m_pEBuffer != NULL)
	{
		delete [] m_pEBuffer;
	}
}

LPCSTR CBase64::DecodedMessage() const
{
	return (LPCSTR) m_pDBuffer;
}

LPCSTR CBase64::EncodedMessage() const
{
	return (LPCSTR) m_pEBuffer;
}

void CBase64::AlloCEncodeDlg(DWORD nSize)
{
	if (m_nEBufLen < nSize)
	{
		if (m_pEBuffer != NULL)
			delete [] m_pEBuffer;

		m_nEBufLen = ROUNDTOPAGE(nSize);
		m_pEBuffer = new BYTE[m_nEBufLen];
	}

	::ZeroMemory(m_pEBuffer, m_nEBufLen);
	m_nEDataLen = 0;
}

void CBase64::AllocDecode(DWORD nSize)
{
	if (m_nDBufLen < nSize)
	{
		if (m_pDBuffer != NULL)
		{
			delete [] m_pDBuffer;
		}

		m_nDBufLen = ROUNDTOPAGE(nSize);
		m_pDBuffer = new BYTE[m_nDBufLen];
	}

	::ZeroMemory(m_pDBuffer, m_nDBufLen);
	m_nDDataLen = 0;
}

void CBase64::SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
	DWORD ii = 0;

	AlloCEncodeDlg(nBufLen);
	while(ii < nBufLen)
	{
		if (!_IsBadMimeChar(pBuffer[ii]))
		{
			m_pEBuffer[m_nEDataLen] = pBuffer[ii];
			m_nEDataLen ++ ;
		}

		ii ++ ;
	}
}

void CBase64::SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
	AllocDecode(nBufLen);
	::CopyMemory(m_pDBuffer, pBuffer, nBufLen);
	m_nDDataLen = nBufLen;
}

PBYTE CBase64::Encode(const PBYTE pBuffer, DWORD nBufLen)
{
	SetDecodeBuffer(pBuffer, nBufLen);
	AlloCEncodeDlg(nBufLen * 2);

	TempBucket     Raw;
	DWORD       nIndex = 0;

	while((nIndex  +  3) <= nBufLen)
	{
		Raw.Clear();
		::CopyMemory(&Raw, m_pDBuffer  +  nIndex, 3);
		Raw.nSize = 3;
		_EncodeToBuffer(Raw, m_pEBuffer  +  m_nEDataLen);
		nIndex += 3;

		m_nEDataLen  += 4;
	}

	if (nBufLen > nIndex)
	{
		Raw.Clear();
		Raw.nSize = (BYTE) (nBufLen - nIndex);
		::CopyMemory(&Raw, m_pDBuffer  +  nIndex, nBufLen - nIndex);
		_EncodeToBuffer(Raw, m_pEBuffer  +  m_nEDataLen);
		m_nEDataLen  += 4;
	}

	return m_pEBuffer;
}

CString CBase64::Encode(LPCSTR szMessage)
{
	CString strHex = _T("");
	if (szMessage != NULL)
	{
		CBase64::Encode((const PBYTE)szMessage, lstrlenA(szMessage));
		if (m_nEDataLen > 0)
		{
			AscToHex(m_pEBuffer, m_nEDataLen, strHex);
		}
	}

	return strHex;
}

PBYTE CBase64::Decode(const PBYTE pBuffer, DWORD dwBufLen)
{
	if (!CBase64::m_Init)
		_Init();

	SetEncodeBuffer(pBuffer, dwBufLen);

	AllocDecode(dwBufLen);

	TempBucket     Raw;

	DWORD   nIndex = 0;

	while((nIndex  +  4) <= m_nEDataLen)
	{
		Raw.Clear();
		Raw.nData[0] = CBase64::m_DecodeTable[m_pEBuffer[nIndex]];
		Raw.nData[1] = CBase64::m_DecodeTable[m_pEBuffer[nIndex  +  1]];
		Raw.nData[2] = CBase64::m_DecodeTable[m_pEBuffer[nIndex  +  2]];

		Raw.nData[3] = CBase64::m_DecodeTable[m_pEBuffer[nIndex  +  3]];

		if (Raw.nData[2] == 255)
			Raw.nData[2] = 0;
		if (Raw.nData[3] == 255)
			Raw.nData[3] = 0;

		Raw.nSize = 4;
		_DecodeToBuffer(Raw, m_pDBuffer  +  m_nDDataLen);
		nIndex  += 4;
		m_nDDataLen  += 3;
	}

	// If nIndex < m_nEDataLen, then we got a decode message without padding.
	// We may want to throw some kind of warning here, but we are still required
	// to handle the decoding as if it was properly padded.
	if (nIndex < m_nEDataLen)
	{
		Raw.Clear();
		for(DWORD ii = nIndex; ii < m_nEDataLen; ii ++ )
		{
			Raw.nData[ii - nIndex] = CBase64::m_DecodeTable[m_pEBuffer[ii]];
			Raw.nSize ++ ;
			if (Raw.nData[ii - nIndex] == 255)
				Raw.nData[ii - nIndex] = 0;
		}

		_DecodeToBuffer(Raw, m_pDBuffer  +  m_nDDataLen);
		m_nDDataLen  += (m_nEDataLen - nIndex);
	}

	return m_pDBuffer;
}

CString CBase64::Decode(LPCSTR pszMessage)
{
	if (!pszMessage)
	{
		return _T("");
	}

	CBase64::Decode((const PBYTE)pszMessage, lstrlenA(pszMessage));
	CString strHex = _T("");
	if (m_nDDataLen > 0)
	{
		AscToHex(m_pDBuffer, m_nDDataLen, strHex);
	}

	return strHex;

}

DWORD CBase64::_DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
	TempBucket Data;
	DWORD   nCount = 0;

	_DecodeRaw(Data, Decode);

	for(int ii = 0; ii < 3; ii ++ )
	{
		pBuffer[ii] = Data.nData[ii];
		if (pBuffer[ii] != 255)
			nCount ++ ;
	}

	return nCount;
}

void CBase64::_EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
	TempBucket Data;

	_EncodeRaw(Data, Decode);

	for(int ii = 0; ii < 4; ii ++ )
		pBuffer[ii] = Base64Digits[Data.nData[ii]];

	switch(Decode.nSize)
	{
	case 1:
		pBuffer[2] = '=';

	case 2:
		pBuffer[3] = '=';
	}
}

void CBase64::_DecodeRaw(TempBucket &Data, const TempBucket &Decode)
{
	BYTE   nTemp;

	Data.nData[0] = Decode.nData[0];
	Data.nData[0] <<= 2;

	nTemp = Decode.nData[1];
	nTemp >>= 4;
	nTemp &= 0x03;
	Data.nData[0] |= nTemp;

	Data.nData[1] = Decode.nData[1];
	Data.nData[1] <<= 4;

	nTemp = Decode.nData[2];
	nTemp >>= 2;
	nTemp &= 0x0F;
	Data.nData[1] |= nTemp;

	Data.nData[2] = Decode.nData[2];
	Data.nData[2] <<= 6;
	nTemp = Decode.nData[3];
	nTemp &= 0x3F;
	Data.nData[2] |= nTemp;
}

void CBase64::_EncodeRaw(TempBucket &Data, const TempBucket &Decode)
{
	BYTE   nTemp;

	Data.nData[0] = Decode.nData[0];
	Data.nData[0] >>= 2;

	Data.nData[1] = Decode.nData[0];
	Data.nData[1] <<= 4;
	nTemp = Decode.nData[1];
	nTemp >>= 4;
	Data.nData[1] |= nTemp;
	Data.nData[1] &= 0x3F;

	Data.nData[2] = Decode.nData[1];
	Data.nData[2] <<= 2;

	nTemp = Decode.nData[2];
	nTemp >>= 6;

	Data.nData[2] |= nTemp;
	Data.nData[2] &= 0x3F;

	Data.nData[3] = Decode.nData[2];
	Data.nData[3] &= 0x3F;
}

BOOL CBase64::_IsBadMimeChar(BYTE nData)
{
	switch(nData)
	{
	case '\r': case '\n': case '\t': case ' ' :
	case '\b': case '\a': case '\f': case '\v':
		return TRUE;

	default:
		return FALSE;
	}
}

void CBase64::_Init()
{
	// Initialize Decoding table.
	int ii;

	for(ii = 0; ii < 256; ii ++ )
		CBase64::m_DecodeTable[ii] = -2;

	for(ii = 0; ii < 64; ii ++ )
	{
		CBase64::m_DecodeTable[Base64Digits[ii]]   = (CHAR)ii;
		CBase64::m_DecodeTable[Base64Digits[ii]|0x80] = (CHAR)ii;
	}

	CBase64::m_DecodeTable['=']     = -1;

	CBase64::m_DecodeTable['='|0x80]   = -1;

	CBase64::m_Init = TRUE;
}

文/闫鑫原创转载请注明出处http://blog.csdn.net/yxstars/article/details/39031279

时间： 2024-08-08 13:51:42

Base64加解密的相关文章

Java基础加密之BASE64加解密

BASE64加解密,加密与解密实际是指编码(encode)和解码(decode)的过程,其变换是非常简单的,仅仅能够避免信息被直接识别. Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式. Base64使用A--Z,a--z,0--9,+,/ 这64个字符. Base64是一种很常见的编码规范,其作用是将二进制序列转换为人类可读的ASCII字符序列 Base64编码表 Value Encoding  Value Encoding  Value Encodin

oracle里面base64加解密

1. base64 的解密函数select utl_raw.cast_to_varchar2(utl_encode.base64_decode(utl_raw.cast_to_raw('dGVzdA=='))) from dual 2. base64 的加密函数select utl_raw.cast_to_varchar2(utl_encode.base64_encode(utl_raw.cast_to_raw('test'))) from dual

java之BASE64加解密

1.简介 Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一,采用Base64编码具有不可读性,即所编码的数据不会被人用肉眼所直接看到. 注:位于jdk的java.util包中. 2.代码 import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; import java.io.UnsupportedEncodingException; /** * Created by root on 16-6-2. */ publ

基于python3.5的 rsa+base64加解密

python3.5.3的版本.需要先生成一个私钥,然后放入这里面即可. 这个有个地方需要注意的是: 加密阶段,我们base64 第一次加密的时候,是加密传入的字符串,然后rsa继续把base64加密后的数据再次加密 , 等rsa加密完成后,我们base64进行第二次加密,此刻加密的数据是加密 rsa加密后的数据了. 解密阶段.一路狂解密,不要停 一定要注意上面的加密阶段,别等第一个base64加密后,第二个base64就解密了,这样是行不通的. #!/usr/bin/env python3 im

JavaScript Base64加解密

Base64加密算法是网络上最常见的用于传输8Bit字节代码的编码方式之一,大家可以查看RFC2045-RFC2049,上面有MIME的详细规范.Base64编码可用于在HTTP环境下传递较长的标识信息.例如,在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数.在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的

Python AES - base64 加解密

首先python引用AES加密 from Crypto.Cipher import AES 需要先安装  Crypto  模块, 可以使用 easy_install 进行安装   会自动去官网进行搜索安装 其中代码示例: aes 加密 需要进行加密数据的处理,要求数据长度必须是16的倍数,不足时,在后边补0 class MyCrypt(): def __init__(self, key): self.key = key self.mode = AES.MODE_CBC def myencrypt

关于Python实现Interface base64加解密方法

''' 以下Python Code运行环境为windows10, Python版本为3.5.3 涉及的库:base64,json,unittest ''' # coding=utf-8 # import requests # import hashlib import base64, json import unittest class DemoRequests(unittest.TestCase): def setUp(self): #self._url = 'http://www.baidu

微信小程序-Base64 加解密

js: var Base64 = { _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", encode (str) { // 加密 var output = ""; var chr1, chr2, chr3, enc1, enc2, enc3, enc4; var i = 0; str = this._utf16to8(str); while (i < st

C# Base64加解密

using System; using System.Collections.Generic; using System.Text; using System.Security.Cryptography; using System.IO; namespace EncryptAndDecrypt { public class CryptoUtil { //随机定义8个字节密钥和初始化向量 private byte[] Key_64 = new byte[] { 1, 2, 3, 3, 4, 5,