c++如何實現Base64演算法

阿新 • • 發佈：2020-08-06

Base64用途

1.用於對SOHO級路由器（閘道器裝置）管理員帳戶密碼的加密

2.流媒體網站對於播放的流媒體檔案的路徑的加密

3.迅雷等下載軟體對下載連結地址的加密

Base64演算法

Base64編碼要求把3個8位位元組（3*8=24）轉化為4個6位的位元組（4*6=24），之後在6位的前面補兩個0，形成8位一個位元組的形式。

c++如何實現Base64演算法

Base64類

函式：

unsigned int CreateMatchingEncodingBuffer (unsigned int p_InputByteCount,char** p_ppEncodingBuffer);

建立匹配於編碼的快取空間。引數：1輸入位元組數，2進行編碼需要的快取空間；返回值：快取空間大小。

unsigned int CreateMatchingDecodingBuffer (char* p_pInputBufferString,char** p_ppDecodingBuffer);

建立匹配於解碼的快取空間。引數：1解碼物件快取，2進行解碼需要的快取空間；返回值：快取空間大小。

void EncodeBuffer (char* p_pInputBuffer,unsigned int p_InputBufferLength,char* p_pOutputBufferString);

進行編碼。引數：1明文，2明文長度，3密文輸出。

unsigned int DecodeBuffer (char* p_pInputBufferString,char* p_pOutputBuffer);

進行解碼。引數：1密文，2明文；返回值：明文長度

C++實現：

標頭檔案：

View Code 

/************************************************
*            *
* CBase64.h          *
* Base 64 de- and encoding class    *
*            *
* ============================================ *
*            *
* This class was written on 28.05.2003    *
* by Jan Raddatz [[email protected]]    *
*            *
* ============================================ *
*            *
* Copyright (c) by Jan Raddatz      *
* This class was published @ codeguru.com  *
* 28.05.2003          *
*            *
************************************************/

#pragma once

#include <afx.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>
const static unsigned int MAX_LINE_LENGTH = 76;

const static char BASE64_ALPHABET [64] = 
{
  'A','B','C','D','E','F','G','H','I','J',//  0 -  9
  'K','L','M','N','O','P','Q','R','S','T',// 10 - 19
  'U','V','W','X','Y','Z','a','b','c','d',// 20 - 29
  'e','f','g','h','i','j','k','l','m','n',// 30 - 39
  'o','p','q','r','s','t','u','v','w','x',// 40 - 49
  'y','z','0','1','2','3','4','5','6','7',// 50 - 59
  '8','9','+','/'         // 60 - 63
};

const static char BASE64_DEALPHABET [128] = 
{
  0,//  0 -  9
  0,// 10 - 19
  0,// 20 - 29
  0,// 30 - 39
  0,62,63,52,53,// 40 - 49
  54,55,56,57,58,59,60,61,// 50 - 59
  0,1,2,3,4,// 60 - 69
  5,6,7,8,9,10,11,12,13,14,// 70 - 79
  15,16,17,18,19,20,21,22,23,24,// 80 - 89
  25,26,27,28,// 90 - 99
  29,30,31,32,33,34,35,36,37,38,// 100 - 109
  39,40,41,42,43,44,45,46,47,48,// 110 - 119
  49,50,51,0    // 120 - 127
};

enum
{
  UNABLE_TO_OPEN_INPUT_FILE,UNABLE_TO_OPEN_OUTPUT_FILE,UNABLE_TO_CREATE_OUTPUTBUFFER
};

class CBase64
{
public:
  CBase64 ();

  unsigned int CalculateRecquiredEncodeOutputBufferSize (unsigned int p_InputByteCount);
  unsigned int CalculateRecquiredDecodeOutputBufferSize (char* p_pInputBufferString);

  void EncodeByteTriple (char* p_pInputBuffer,unsigned int InputCharacters,char* p_pOutputBuffer);
  unsigned int DecodeByteQuartet (char* p_pInputBuffer,char* p_pOutputBuffer);

  void EncodeBuffer (char* p_pInputBuffer,char*p_pOutputBufferString);
  unsigned int DecodeBuffer (char* p_pInputBufferString,char* p_pOutputBuffer);

  unsigned int CreateMatchingEncodingBuffer (unsigned int p_InputByteCount,char** p_ppEncodingBuffer);
  unsigned int CreateMatchingDecodingBuffer (char* p_pInputBufferString,char** p_ppDecodingBuffer);

  unsigned int EncodeFile (char* p_pSourceFileName,char* p_pEncodedFileName);
  unsigned int DecodeFile (char* p_pSourceFileName,char* p_pDecodedFileName);
};

cpp檔案：

View Code 

/************************************************
*            *
* CBase64.cpp          *
* Base 64 de- and encoding class    *
*            *
* ============================================ *
*            *
* This class was written on 28.05.2003    *
* by Jan Raddatz [[email protected]]    *
*            *
* ============================================ *
*            *
* Copyright (c) by Jan Raddatz      *
* This class was published @ codeguru.com  *
* 28.05.2003          *
*            *
************************************************/
#include "stdafx.h"
#include "CBase64.h"


CBase64::CBase64 ()
{
}

unsigned int CBase64::CalculateRecquiredEncodeOutputBufferSize (unsigned int p_InputByteCount)
{
  div_t result = div (p_InputByteCount,3);

  unsigned int RecquiredBytes = 0;
  if (result.rem == 0)
  {
    // Number of encoded characters
    RecquiredBytes = result.quot * 4;

    // CRLF -> "\r\n" each 76 characters
    result = div (RecquiredBytes,76);
    RecquiredBytes += result.quot * 2;

    // Terminating null for the Encoded String
    RecquiredBytes += 1;

    return RecquiredBytes;
  }
  else
  {
    // Number of encoded characters
    RecquiredBytes = result.quot * 4 + 4;

    // CRLF -> "\r\n" each 76 characters
    result = div (RecquiredBytes,76);
    RecquiredBytes += result.quot * 2;

    // Terminating null for the Encoded String
    RecquiredBytes += 1;

    return RecquiredBytes;
  }
}

unsigned int CBase64::CalculateRecquiredDecodeOutputBufferSize (char* p_pInputBufferString)
{
  unsigned int BufferLength = strlen (p_pInputBufferString);

  div_t result = div (BufferLength,4);

  if (p_pInputBufferString [BufferLength - 1] != '=')
  {
    return result.quot * 3;
  }
  else
  {
    if (p_pInputBufferString [BufferLength - 2] == '=')
    {
      return result.quot * 3 - 2;
    }
    else
    {
      return result.quot * 3 - 1;
    }
  }
}

void CBase64::EncodeByteTriple (char* p_pInputBuffer,char* p_pOutputBuffer)
{
  unsigned int mask = 0xfc000000;
  unsigned int buffer = 0;


  char* temp = (char*) &buffer;
  temp [3] = p_pInputBuffer [0];
  if (InputCharacters > 1)
    temp [2] = p_pInputBuffer [1];
  if (InputCharacters > 2)
    temp [1] = p_pInputBuffer [2];

  switch (InputCharacters)
  {
  case 3:
    {
      p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [2] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [3] = BASE64_ALPHABET [(buffer & mask) >> 26];
      break;
    }
  case 2:
    {
      p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [2] = BASE64_ALPHABET [(buffer & mask) >> 26];
      p_pOutputBuffer [3] = '=';
      break;
    }
  case 1:
    {
      p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
      buffer = buffer << 6;
      p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
      p_pOutputBuffer [2] = '=';
      p_pOutputBuffer [3] = '=';
      break;
    }
  }
}

unsigned int CBase64::DecodeByteQuartet (char* p_pInputBuffer,char* p_pOutputBuffer)
{
  unsigned int buffer = 0;

  if (p_pInputBuffer[3] == '=')
  {
    if (p_pInputBuffer[2] == '=')
    {
      buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
      buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
      buffer = buffer << 14;

      char* temp = (char*) &buffer;
      p_pOutputBuffer [0] = temp [3];

      return 1;
    }
    else
    {
      buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
      buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
      buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[2]]) << 6;
      buffer = buffer << 8;

      char* temp = (char*) &buffer;
      p_pOutputBuffer [0] = temp [3];
      p_pOutputBuffer [1] = temp [2];

      return 2;
    }
  }
  else
  {
    buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
    buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
    buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[2]]) << 6;
    buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[3]]) << 6; 
    buffer = buffer << 2;

    char* temp = (char*) &buffer;
    p_pOutputBuffer [0] = temp [3];
    p_pOutputBuffer [1] = temp [2];
    p_pOutputBuffer [2] = temp [1];

    return 3;
  }

  return -1;
}

void CBase64::EncodeBuffer(char* p_pInputBuffer,char* p_pOutputBufferString)
{
  unsigned int FinishedByteQuartetsPerLine = 0;
  unsigned int InputBufferIndex = 0;
  unsigned int OutputBufferIndex = 0;

  memset (p_pOutputBufferString,CalculateRecquiredEncodeOutputBufferSize (p_InputBufferLength));

  while (InputBufferIndex < p_InputBufferLength)
  {
    if (p_InputBufferLength - InputBufferIndex <= 2)
    {
      FinishedByteQuartetsPerLine ++;
      EncodeByteTriple (p_pInputBuffer + InputBufferIndex,p_InputBufferLength - InputBufferIndex,p_pOutputBufferString + OutputBufferIndex);
      break;
    }
    else
    {
      FinishedByteQuartetsPerLine++;
      EncodeByteTriple (p_pInputBuffer + InputBufferIndex,p_pOutputBufferString + OutputBufferIndex);
      InputBufferIndex += 3;
      OutputBufferIndex += 4;
    }

    if (FinishedByteQuartetsPerLine == 19)
    {
      p_pOutputBufferString [OutputBufferIndex ] = '\r';
      p_pOutputBufferString [OutputBufferIndex+1] = '\n';
      p_pOutputBufferString += 2;
      FinishedByteQuartetsPerLine = 0;
    }
  }
}

unsigned int CBase64::DecodeBuffer (char* p_pInputBufferString,char* p_pOutputBuffer)
{
  unsigned int InputBufferIndex = 0;
  unsigned int OutputBufferIndex = 0;
  unsigned int InputBufferLength = strlen (p_pInputBufferString);

  char ByteQuartet [4];

  while (InputBufferIndex < InputBufferLength)
  {
    for (int i = 0; i < 4; i++)
    {
      ByteQuartet [i] = p_pInputBufferString [InputBufferIndex];

      // Ignore all characters except the ones in BASE64_ALPHABET
      if ((ByteQuartet [i] >= 48 && ByteQuartet [i] <= 57) ||
        (ByteQuartet [i] >= 65 && ByteQuartet [i] <= 90) ||
        (ByteQuartet [i] >= 97 && ByteQuartet [i] <= 122) ||
        ByteQuartet [i] == '+' || ByteQuartet [i] == '/' || ByteQuartet [i] == '=')
      {
      }
      else
      {
        // Invalid character
        i--;
      }

      InputBufferIndex++;
    }

    OutputBufferIndex += DecodeByteQuartet (ByteQuartet,p_pOutputBuffer + OutputBufferIndex);
  }

  // OutputBufferIndex gives us the next position of the next decoded character
  // inside our output buffer and thus represents the number of decoded characters
  // in our buffer.
  return OutputBufferIndex;
}

unsigned int CBase64::CreateMatchingEncodingBuffer (unsigned int p_InputByteCount,char** p_ppEncodingBuffer)
{
  unsigned int Size = CalculateRecquiredEncodeOutputBufferSize (p_InputByteCount);
  (*p_ppEncodingBuffer) = (char*) malloc (Size);
  memset (*p_ppEncodingBuffer,Size);
  return Size;
}

unsigned int CBase64::CreateMatchingDecodingBuffer (char* p_pInputBufferString,char** p_ppDecodingBuffer)
{
  unsigned int Size = CalculateRecquiredDecodeOutputBufferSize (p_pInputBufferString);
  (*p_ppDecodingBuffer) = (char*) malloc (Size+1);
  memset (*p_ppDecodingBuffer,Size+1);
  return Size+1;
}

unsigned int CBase64::EncodeFile (char* p_pSourceFileName,char* p_pEncodedFileName)
{
  CFile InputFile;
  CFile OutputFile;

  if (!InputFile.Open (p_pSourceFileName,CFile::modeRead))
    return UNABLE_TO_OPEN_INPUT_FILE;

  if (!OutputFile.Open (p_pEncodedFileName,CFile::modeCreate|CFile::modeWrite))
    return UNABLE_TO_OPEN_OUTPUT_FILE;

  char InputBuffer [19 * 3];
  char* pOutputBuffer;
  CreateMatchingEncodingBuffer (sizeof (InputBuffer),&pOutputBuffer);

  if (pOutputBuffer == 0)
    return UNABLE_TO_CREATE_OUTPUTBUFFER;

  unsigned int ReadBytes = 0;
  while ((ReadBytes = InputFile.Read (InputBuffer,sizeof (InputBuffer))) != 0)
  {
    EncodeBuffer (InputBuffer,ReadBytes,pOutputBuffer);
    OutputFile.Write (pOutputBuffer,strlen (pOutputBuffer));
  }

  OutputFile.Flush ();
  OutputFile.Close ();
  InputFile.Close ();

  return 0;
}

unsigned int CBase64::DecodeFile (char* p_pSourceFileName,char* p_pDecodedFileName)
{
  CStdioFile  InputFile;
  CFile    OutputFile;

  if (!InputFile.Open (p_pSourceFileName,CFile::modeRead))
    return UNABLE_TO_OPEN_INPUT_FILE;

  if (!OutputFile.Open (p_pDecodedFileName,CFile::modeCreate|CFile::modeWrite))
    return UNABLE_TO_OPEN_OUTPUT_FILE;

  CString InputBuffer;
  char  OutputBuffer[64];

  unsigned int ReadBytes = 0;
  while ((ReadBytes = InputFile.ReadString (InputBuffer)) != 0)
  {
    InputBuffer.Remove ('\r');
    InputBuffer.Remove ('\n');
    unsigned int DecodedBytes = DecodeBuffer ((LPTSTR) (LPCTSTR) InputBuffer,OutputBuffer);
    OutputFile.Write (&OutputBuffer [0],DecodedBytes);
  }

  OutputFile.Flush ();
  OutputFile.Close ();
  InputFile.Close ();

  return 0;
}

以上就是c++如何實現Base64演算法的詳細內容，更多關於c++ base64演算法的資料請關注我們其它相關文章！