Encryption-基础：base64加解密

环境：vc2003

.h

 /**********
 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; either version 2.1 of the License, or (at your
 option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)

 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
 more details.

 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 **********/
 // "liveMedia"
 // Copyright (c) 1996-2010 Live Networks, Inc.  All rights reserved.
 // Base64 encoding and decoding
 // C++ header

 #ifndef _BASE64_HH
 #define _BASE64_HH

 //#ifndef _BOOLEAN_HH
 //#include "Boolean.hh"
 //#endif

 #ifdef __cplusplus
 extern "C" {
 #endif

     unsigned char* base64Decode(char* in, unsigned int& resultSize, bool trimTrailingZeros = true);
     // returns a newly allocated array - of size "resultSize" - that
     // the caller is responsible for delete[]ing.

     char* base64Encode(char const* orig, unsigned origLength);
     // returns a 0-terminated string that
     // the caller is responsible for delete[]ing.

 #ifdef __cplusplus
 }
 #endif

 #endif

.cpp

 #include <string.h>
 #include "Base64New.h"
 static char base64DecodeTable[];

 ////////////////////////////////////////
 char* strDup(char const* str)
 {
     if (str == NULL) return NULL;
     size_t len = strlen(str) + ;
     char* copy = new char[len];

     if (copy != NULL)
     {
         memcpy(copy, str, len);
     }
     return copy;
 }

 char* strDupSize(char const* str)
 {
     if (str == NULL) return NULL;
     size_t len = strlen(str) + ;
     char* copy = new char[len];

     return copy;
 }

 static void initBase64DecodeTable()
 {
     int i;
     for (i = ; i < ; ++i) base64DecodeTable[i] = (char)0x80;
     // default value: invalid

     for (i = 'A'; i <= 'Z'; ++i) base64DecodeTable[i] =  + (i - 'A');
     for (i = 'a'; i <= 'z'; ++i) base64DecodeTable[i] =  + (i - 'a');
     for (i = ''; i <= ''; ++i) base64DecodeTable[i] =  + (i - '');
     base64DecodeTable[(unsigned char)'+'] = ;
     base64DecodeTable[(unsigned char)'/'] = ;
     base64DecodeTable[(unsigned char)'='] = ;
 }

 unsigned char* base64Decode(char* in, unsigned int& resultSize, bool trimTrailingZeros)
 {
     static bool haveInitedBase64DecodeTable = false;
     if (!haveInitedBase64DecodeTable)
     {
         initBase64DecodeTable();
         haveInitedBase64DecodeTable = true;
     }

     unsigned char* out = (unsigned char*)strDupSize(in); // ensures we have enough space
     int k = ;
     int const jMax = strlen(in) - ;
     // in case "in" is not a multiple of 4 bytes (although it should be)
     for (int j = ; j < jMax; j += )
     {
         char inTmp[], outTmp[];
         for (int i = ; i < ; ++i)
         {
             inTmp[i] = in[i+j];
             outTmp[i] = base64DecodeTable[(unsigned char)inTmp[i]];
             if ((outTmp[i]&0x80) != ) outTmp[i] = ; // pretend the input was 'A'
         }

         out[k++] = (outTmp[]<<) | (outTmp[]>>);
         out[k++] = (outTmp[]<<) | (outTmp[]>>);
         out[k++] = (outTmp[]<<) | outTmp[];
     }

     if (trimTrailingZeros)
     {
         while (k >  && out[k-] == '/0') --k;
     }
     resultSize = k;
     unsigned char* result = new unsigned char[resultSize];
     memmove(result, out, resultSize);
     delete[] out;

     return result;
 }

 static const char base64Char[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

 char* base64Encode(char  const* origSigned, unsigned origLength)
 {
     unsigned char const* orig = (unsigned char const*)origSigned; // in case any input bytes have the MSB set //参数1转换成无符号的
     if (orig == NULL) return NULL;

     unsigned const numOrig24BitValues = origLength/; //numOrig24BitValues保存整除3后的值
     bool havePadding = origLength > numOrig24BitValues*;//判断源字符串长度，大于整除后，再乘3的长度，有大于或等于两种可能。
     bool havePadding2 = origLength == numOrig24BitValues* + ;  //整除3后，再乘3，再加2，与源字符串长度比较是否相等。
     unsigned const numResultBytes = *(numOrig24BitValues + havePadding);  //计算长度，判断整除3后，加0或1，乘4，赋给numResultBytes；
     char* result = new char[numResultBytes+]; // allow for trailing '/0'

     memset(result,,numResultBytes+);  //add by wjz20130813

     // Map each full group of 3 input bytes into 4 output base-64 characters:
     unsigned i;
     for (i = ; i < numOrig24BitValues; ++i)
     {
         result[*i+] = base64Char[(orig[*i]>>)&0x3F];
         result[*i+] = base64Char[(((orig[*i]&0x3)<<) | (orig[*i+]>>))&0x3F];
         result[*i+] = base64Char[((orig[*i+]<<) | (orig[*i+]>>))&0x3F];
         result[*i+] = base64Char[orig[*i+]&0x3F];
     }

     // Now, take padding into account.  (Note: i == numOrig24BitValues)
     if (havePadding)
     {
         result[*i+] = base64Char[(orig[*i]>>)&0x3F];
         if (havePadding2)
         {
             result[*i+] = base64Char[(((orig[*i]&0x3)<<) | (orig[*i+]>>))&0x3F];
             result[*i+] = base64Char[(orig[*i+]<<)&0x3F];
         }
         else
         {
             result[*i+] = base64Char[((orig[*i]&0x3)<<)&0x3F];
             result[*i+] = '=';
         }
         result[*i+] = '=';
     }

     result[numResultBytes+] = '/0';  //alter by wjz 20130813

     return result;
 }