base64编解码

最新推荐文章于 2023-12-01 14:07:35 发布
最新推荐文章于 2023-12-01 14:07:35 发布
阅读量723 收藏
点赞数
分类专栏： VC编程 文章标签： byte null delete module macros class

/*
Module : Base64Coder.CPP
Purpose: Definition for the Base64 encoder / decoder class
Created: PJN / 20-06-2000
History: None

Copyright (c) 1998 - 2002 by PJ Naughter. 
All rights reserved.

*/

/// Defines ///
#ifndef __BASE64CODER_H__
#define __BASE64CODER_H__


/// Classes ///

class CBase64Coder 
{
public:
//Constructors / Destructors
    CBase64Coder();
    virtual ~CBase64Coder();

//·½·¨
    virtual void     Encode(const PBYTE, DWORD);
    virtual void     Decode(const PBYTE, DWORD);
    virtual void     Encode(LPCSTR sMessage);
    virtual void     Decode(LPCSTR sMessage);
    virtual LPSTR  DecodedMessage() const;
    virtual LPSTR  EncodedMessage() const;
    virtual LONG     DecodedMessageSize() const;
    virtual LONG     EncodedMessageSize() const;

protected:
// 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;
    static char m_DecodeTable[256];
    static BOOL m_Init;

//M·½·¨
    virtual void     AllocEncode(DWORD);
    virtual void     AllocDecode(DWORD);
    virtual void     SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
    virtual void     SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
    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);
    void                    _Init();
};


#endif //__BASE64CODER_H__

 

 

 

/*
Module : Base64Coder.CPP
Purpose: Implementation for the Base64 encoder / decoder class
Created: PJN / 20-06-2000
History: None

Copyright (c) 1998 - 2002 by PJ Naughter. 
All rights reserved.

*/

Includes

#include "stdafx.h"
#include "Base64Coder.h"



Macros / Locals /

static char    Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
BOOL CBase64Coder::m_Init        = FALSE;
char CBase64Coder::m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE                    4096
#endif

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



// Implementation

CBase64Coder::CBase64Coder() : m_pDBuffer(NULL), m_pEBuffer(NULL),
                               m_nDBufLen(0),    m_nEBufLen(0)
{
}

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

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

LPSTR CBase64Coder::DecodedMessage() const
{
    return (LPSTR) m_pDBuffer;
}

LPSTR CBase64Coder::EncodedMessage() const
{
    return (LPSTR) m_pEBuffer;
}

LONG CBase64Coder::DecodedMessageSize() const
{
    return m_nDDataLen;
}

LONG CBase64Coder::EncodedMessageSize() const
{
    return m_nEDataLen;
}

void CBase64Coder::AllocEncode(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 CBase64Coder::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 CBase64Coder::SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
    DWORD    i = 0;

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

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

void CBase64Coder::Encode(const PBYTE pBuffer, DWORD nBufLen)
{
    SetDecodeBuffer(pBuffer, nBufLen);
    AllocEncode(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;
    }
}

void CBase64Coder::Encode(LPCSTR szMessage)
{
    if (szMessage != NULL)
        Encode((const PBYTE)szMessage, strlen(szMessage));
}

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

    SetEncodeBuffer(pBuffer, dwBufLen);
    AllocDecode(dwBufLen);

    TempBucket Raw;
    DWORD    nIndex = 0;
    while((nIndex + 4) <= m_nEDataLen)
    {
        Raw.Clear();
        Raw.nData[0] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex]];
        Raw.nData[1] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 1]];
        Raw.nData[2] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 2]];
        Raw.nData[3] = CBase64Coder::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 i=nIndex; i<m_nEDataLen; i++)
        {
            Raw.nData[i - nIndex] = CBase64Coder::m_DecodeTable[m_pEBuffer[i]];
            Raw.nSize++;
            if(Raw.nData[i - nIndex] == 255)
                Raw.nData[i - nIndex] = 0;
        }

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

void CBase64Coder::Decode(LPCSTR szMessage)
{
    if (szMessage != NULL)
        Decode((const PBYTE)szMessage, strlen(szMessage));
}

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

    _DecodeRaw(Data, Decode);

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

    return nCount;
}


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

    _EncodeRaw(Data, Decode);

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

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

void CBase64Coder::_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 CBase64Coder::_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 CBase64Coder::_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 CBase64Coder::_Init()
{ 
  // Initialize Decoding table.
    int    i;
    for (i=0; i<256; i++)
        CBase64Coder::m_DecodeTable[i] = -2;

    for (i=0; i<64; i++)
    {
        CBase64Coder::m_DecodeTable[Base64Digits[i]]    = (char) i;
        CBase64Coder::m_DecodeTable[Base64Digits[i]|0x80] = (char) i;
    }

    CBase64Coder::m_DecodeTable['=']    = -1;
    CBase64Coder::m_DecodeTable['='|0x80] = -1;
    CBase64Coder::m_Init = TRUE;
}

base64 coder
05-27
java版本的base64编码解码的源代码
base64coder
08-15
用于rsa加密 如需要做加密 自行查询我的文档 地址https://blog.csdn.net/qq_34468274
Base64Coder
shine4j的专栏
05-19 1047
package com.shine; public class Base64Coder {     private static char[] map1 = new char[64];       private static byte[] map2;       public static String encodeString(String s)       {      
base64 code
jwqu的专栏
09-28 1057
////////////////////////////////////////////////////////////// base64.h//************************************************************************/// base64编码表// //0 A 17 R 34 i 51 z //1 B 18 S 35 j 52
易语言源码易语言Base64编解码新汇编源码.rar
03-30
在本压缩包“易语言源码易语言Base64编解码新汇编源码.rar”中，包含的是关于Base64编解码的易语言源码，以及可能使用了新的汇编技术编写的源代码。Base64是一种用于编码二进制数据的算法，常用于在网络上传输文本...
C/C++ Base64编解码开源库
10-31
在C/C++中，处理Base64编解码通常需要自定义函数或者利用开源库。这个开源库提供了解决这个问题的方法。 1. **Base64编码原理** - Base64编码是将每3个字节（24位）的数据转换为4个6位的字符（每个字符对应Base64...
易语言Base64编解码新汇编源码
06-02
易语言Base64编解码新汇编源码是一个针对易语言编程环境的代码资源，主要功能是实现Base64编码和解码。Base64是一种用于将任意二进制数据转换为可打印字符的编码方式，常用于在网络上传输包含二进制的数据，如图片或...
易语言Base64编解码新汇编源码-易语言
06-13
易语言Base64编解码新汇编源码是一个针对易语言编程平台的高级教程，主要涉及了数据编码与解码的重要技术——Base64。Base64是一种用于将二进制数据转换为可打印字符的编码方式，常用于在网络上传输包含二进制的数据...
base64编解码C/C++实现
07-03
9. **使用示例**：在`base64.cpp`和`base64.h`中提供的`main`函数可能是演示如何使用这两个函数的例子，可以通过它了解如何在C++程序中调用这些编解码方法。 10. **API设计**：`base64.h`文件通常会定义接口，如`...
base64编码
weixin_33709219的博客
07-02 63
2019独角兽企业重金招聘Python工程师标准>>> ...
Base64编码介绍及基于Java语言实现
关注微信公众号【OpenCV学堂】
11-27 5386
Base64编码介绍及基于Java语言实现   Base64编码被设计用来表示任意顺序的八位一个字节单元，允许使用大写和小写字符而不要求内容可读。65个US-ASCII子集被用来表示Base64编码，所以每六位表示一个可以打印的Base64的字符，第65字符’=’被用来表示特殊处理的功能字符，后面会详细说明。   预编码处理一次输入24位（三个字符）作为一组，输出的是四个Base64的编码
Base64Coder方式实现android向jsp服务器后台上传图片
qihaha_521的专栏
06-29 1305
android端（上代码）：
图片通过Base64Coder编码、解码
weixin_34166472的博客
09-23 209
通过这个编码类我们可以将图片转换为这个编码的字符串，上传到服务器。 这个编码是来自小马的一个范例，我看了下挺有用的。所以就放上来以备不时之需。 先说下用法: /** * 下面注释的方法是将裁剪之后的图片以Base64Coder的字符方式上 * 传到服务器，QQ头像上传采用的方法跟这个类似 ...
base64加密 解密
a coder 的心如止水
03-29 673
（一）java自带的加密和解密 import sun.misc.BASE64Decoder; public class Base64Utils {    public static String getBASE64(byte[] b) {   String s = null;   if (b != null) {    s = new sun.misc.BASE64Encod
base64code 的一个例子代码
testing2007的专栏
04-05 1553
#include "stdafx.h" #include #include #include #include struct CartoonInfo { std::wstring strInfo; }; typedef std::vector VEC_CI; VEC_CI g_vci; void AddInfo(LPCWSTR info) { Ca
关于Base64编码(Encode)与解码(Decode)的几种方式
热门推荐
樂小伍
03-10 3万+
关于Base64编码(Encode)与解码(Decode)的几种方式
Base64加密解密
CoderLam的博客
11-24 376
关于base64编码Encode和Decode编码的几种方式Base64是一种能将任意Binary资料用64种字元组合成字串的方法，而这个Binary资料和字串资料彼此之间是可以互相转换的，十分方便。在实际应用上，Base64除了能将Binary资料可视化之外，也常用来表示字串加密过后的内容。如果要使用Java 程式语言来实作Base64的编码与解码功能，...
实用篇 | Base64详解及代码示例
最新发布
weixin_44649780的博客
12-01 8018
Base64是一种二进制到文本的编码系统，它使用一组 64 个不同的 ASCII 字符将二进制数据传输为基于文本的格式。它通常用于对二进制数据进行编码，例如图像或音频文件。一般来说，编码是指将数据从一种格式转换为另一种格式的过程。Base64 编码是通过使用一组 64 个不同的 ASCII 字符表示二进制数据来实现的。当需要在本机不支持二进制数据的系统之间交换数据时，此编码特别有用。
C++实现Base64编解码
"base64编解码C++实现，包含了一个64字符的编码映射表，并提供了编码函数encodetribyte" 在信息技术中，Base64是一种用于将二进制数据转换为可打印字符的编码方法，常用于在网络上传输包含二进制的数据，如电子邮件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>