[C語言]Base64編碼解碼

Base64編碼解碼

一，Base64編碼原理

        Base64編碼的字符數組如下所示 ：

        ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

        字符串轉Base64編碼：取3字節的字符串轉換為四字節的字符串，依次往后轉換。得到Base64編碼字符串。具體原理如下：

1，如果需要編碼的原串字節數剛好為3的倍數，那么轉換規則如下：

        以中文字符'嚴'為例，'嚴'字的UTF-8編碼為：0xE4B8A5 ＝ 11100100  10111000  10101001。即有:

        1）UTF－8第一個字節：0xE4 = 11100100

        2）UTF－8第二個字節：0xB8 = 10111000

        3）UTF－8第三個字節：0xA5 = 10101001

        轉Base64的過程如下：

        1）Base64第一個字節：取UTF－8第一字節的前六位（111001），然后在六位字符前（111001）填充00，既得Base64編碼的第一個字節（00111001）。

        2）Base64第二個字節：取UTF－8第一字節的最后兩位（00），再取UTF－8第二字節的前四位（1011）組成六位字符串001011，然后在組成的六位字符串（001011）前面填充00，既得Base64編碼的第二個字節（00001011）

        3）Base64第三個字節：取UTF－8第二字節的后四位（1000），再取UTF－8第三字節的前兩位（10）組成六位字符串100010，然后在組成的六位字符串（100010）前面填充00，既得Base64編碼的第三個字節（00100010）

        4）Base64第四個字節：取UTF－8第三字節的后六位（101001），然后在六位字符前（101001）填充00，既得Base64編碼的第四個字節（00101001）。

2，如果需要編碼的原串字節數最后剩余2，那么轉換規則如下：

        以字符串"aa"為例，"aa"的UTF－8編碼為：0x6161  =  01100001  01100001。既有：

        1）UTF－8第一個字節：0x61 ＝ 01100001

        2）UTF－8第二個字節：0x61  =  01100001

        轉Base64的過程如下：

        1）Base64第一個字節：取UTF－8第一字節的前六位（011000），然后在六位字符前（011000）填充00，既得Base64編碼的第一個字節（00011000）。

        2）Base64第二個字節：取UTF－8第一字節的最后兩位（01），再取UTF－8第二字節的前四位（0110）組成六位字符串010110，然后在組成的六位字符串（010110）前面填充00，既得Base64編碼的第二個字節（00010110）。

        3）Base64第三個字節：取UTF－8第二字節的后四位（0001），然后在四位字符（0001）前填充00，得六位字符串（000001），由于此時不夠一個字節（八位），再在六位字符串（000001）后面填充00即可，既得Base64編碼的第三個字節（00000100）。

        4）Base64第四個字節：此時使用字符'='填充即可。

3，如果需要編碼的原串字節數最后剩余1，那么轉換規則如下：

        以字符串"a"為例，"a"的UTF－8編碼為：0x61  =  01100001。既有：

        1）UTF－8第一個字節：0x61  ＝ 01100001

        轉Base64的過程如下：

        1）Base64第一個字節：取UTF－8第一字節的前六位（011000），然后在六位字符前（011000）填充00，既得Base64編碼的第一個字節（00011000）。

        2）Base64第二個字節：取UTF－8第一字節的最后兩位（01），然后在兩位字符（01）前填充00，得四位字符串（0001），由于此時不夠一個字節（八位），再在四位字符串（0001）后面填充0000即可，既得Base64編碼的第二個字節（00010000）。

        3）Base64第三個字節：此時使用字符'='填充即可。

        3）Base64第四個字節：此時使用字符'='填充即可。

綜上可得編碼程序如下：

int
base64_string( const unsigned char *src, unsigned char *dest, unsigned char *base64, int index )
{
    assert( src );

    unsigned char one;
    unsigned char two;
    unsigned char thr;
    unsigned char fou;

    size_t len = strlen( src );
    if ( len >= 3 )
    {
        one = src[0] >> 2;
        two = ( ( src[0] & 0x03 ) << 4 ) | ( src[1] >> 4 );
        thr = ( ( src[1] & 0x0F ) << 2 ) | ( src[2] >> 6 );
        fou = src[2] & 0x3F;

        *( dest + index++ ) = base64[one];
        *( dest + index++ ) = base64[two];
        *( dest + index++ ) = base64[thr];
        *( dest + index   ) = base64[fou];
    }
    else if ( len == 2 )
    {
        one = src[0] >> 2;
        two = ( ( src[0] & 0x03) << 4 ) | ( src[1] >> 4 );
        thr = ( src[1] & 0x0F ) << 2;

        *( dest + index++ ) = base64[one];
        *( dest + index++ ) = base64[two];
        *( dest + index++ ) = base64[thr];
        *( dest + index   ) = '=';
    }
    else if ( len == 1 )
    {
        one = src[0] >> 2;
        two = ( src[0] & 0x03 ) << 4;

        *( dest + index++ ) = base64[one];
        *( dest + index++ ) = base64[two];
        *( dest + index++ ) = '=';
        *( dest + index   ) = '=';
    }
    else
    {
        printf( "Unknow length\n" );
    }

    return len >= 3 ? 3 : len;
}

void
base64_encode( const unsigned char *src, unsigned char *dest )
{
    assert( src );

    unsigned char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    int index = 0;
    while ( *src )
    {
        int step = base64_string( src, dest, base64, index );

        index += 4;
        src   += step;
    }

    *( dest + index ) = '\0';
}

二，Base64解碼

1，原理

        Base64字符串以四字節為一組，轉換為三字節的過程。依次類推，直到全部轉化完成。

2，數組

        由于Base64編碼時用到如下所示的字符數組進行轉換，字符數組如下：

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

        由上可知，A在數組的位置為0，故有（A，0）,依次類推有（B，1），（C，2）等。故可得如下所示的對應關系：

A  B  C  D  E  F  G  H  I  J
0  1  2  3  4  5  6  7  8  9

K  L  M  N  O  P  Q  R  S  T 
10 11 12 13 14 15 16 17 18 19

U  V  W  X  Y  Z  a  b  c  d
20 21 22 23 24 25 26 27 28 29

e  f  g  h  i  j  k  l  m  n
30 31 32 33 34 35 36 37 38 39

o  p  q  r  s  t  u  v  w  x
40 41 42 43 44 45 46 47 48 49

y  z  0  1  2  3  4  5  6  7
50 51 52 53 54 55 56 57 58 59

8  9  +  /
60 61 62 63

        由于編碼時，如果得到的一個字節的值為0那么編碼后即為A。相應的，在解碼過程中，如果一個字節的值為A，那么轉換為0即可。由于A的十進制值為65，而在編碼數組的下標為0。既有A-65-0。同理，B的十進制值為66，在編碼數組的下標為1，既有B-66-1。

        Base64字符所在的區間為A-Z，a-z，0-9，+，/。由上可知，其中的臨界值有如下對應關系：

base64字符 - 字符值（解碼數組的下標） - 在base64編碼數組中的下標

A  -  65  -  0

Z  -  90  -  25

a  -  97  -  26

z  - 122 -  51

0  -  48  -  52

9  -  57  -  61

+  -  43  -  62

/   -  47  -  63

        一個字節八位，故最大值為2^8 = 256，但由上臨界值可知最大值為122，所以實際解碼數組定義為124長度即可（0-122存關鍵信息，123存'\0'）。故可得如下數組：

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3F, 
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 
0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 
0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,

        獲取數組的程序如下所示：

void
create_array( unsigned char *array )
{
    int index  = 0;
    for ( index  = 0; index < 123; index += 1 )
    {
        if ( index == 0x2B )
        {
            *( array + index ) = 0x3E;
        }
        else if ( index == 0x2F )
        {
            *( array + index ) = 0x3F;
        }
        else if ( index >= 0x30 && index <= 0x39 )
        {
            *( array + index ) = 0x34 + index - 0x30;
        }
        else if ( index == 0x3D )
        {
             /* 特殊字符'='，也可合并到else情況 */
            *( array + index ) = 0x00;
        }
        else if ( index >= 0x41 && index <= 0x5A )
        {
            *( array + index ) = index - 0x41;
        }
        else if ( index >= 0x61 && index <= 0x7A )
            *( array + index ) = 0x1A + index - 0x61;
        }
        else
        {
            *( array + index ) = 0x00;
        }
    }

    *( array + 123 ) = '\0';
}

3，解碼

解碼時分三種情況處理：

1）四個字符中最后一個字符為'='的情況，以YWE=為例：

首先將除'='外的字節轉換為對應的二進制：

Base64第一個字節：Y ：24 ＝ 0001 1000（24是Y對應數組下標的值）

Base64第二個字節：W：22 ＝ 0001 0110

Base64第三個字節：E ：4   ＝ 0000 0100

        取Base64的第一字節后六位（011000）和Base64第二字節去掉前兩位填充位00后（010110）的前兩位（01），拼接后既得UTF－8編碼的第一個字節（01100001）

        取Base64的第二字節后四位（0110）和Base64第三字節去掉前兩位填充位00后（000100），再去掉后兩位填充位00后（0001），拼接后既得UTF－8編碼的第二個字節（01100001）

2）四個字符中最后兩個字符為'='的情況，以YQ==為例：

首先將除'='外的字節轉換為對應的二進制：

Base64第一個字節：Y ：24 ＝ 0001 1000

Base64第二個字節：Q ：16 ＝ 0001 0000

        取Base64的第一個字節后六位（011000）和Base64第二字節去掉前兩位填充位00后（010000），再去掉后四位填充位0000后（01），拼接后即可得UTF－8編碼的第一個字節（01100001）

3）四個字符中不包含字符'='的情況，以5Lil為例：

首先將除'='外的字節轉換為對應的二進制：

Base64第一個字節：5：57 ＝ 0011 1001

Base64第二個字節：L：11 ＝ 0000 1011

Base64第三個字節：i：34  ＝ 0010 0010

Base64第四個字節：l：37  ＝ 0010 0101

        取Base64第一個字節后六位（111001）和Base64第二字節去掉前兩位填充位00后的前兩位（00），拼接后既得UTF－8編碼的第一個字節（11100100）

        取Base64第二字節的后四位（1011）和Base64第三字節去掉前兩位填充位00后的前四位（1000），拼接后既得UTF－8編碼的第二字節（10111000）

        取Base64第三字節的后兩位（10）和Base64第四字節的后六位（100101），拼接后既得UTF－8編碼的第三字節（10100101）

綜上可知，解碼程序如下：

int
decode_string( const unsigned char *src, unsigned char *dest, unsigned char *array, int index )
{
    assert( src );

    int step = 0;

    unsigned char one;
    unsigned char two;
    unsigned char thr;
    if ( src[3] == '=' && src[2] == '=' )
    {
        one = ( array[src[0]] << 2 ) | ( array[src[1]] >> 4 );
        *( dest + index ) = one;

        step = 1;
    }
    else if ( src[3] == '=' )
    {
        one = ( array[src[0]] << 2 ) | ( array[src[1]] >> 4 );
        two = ( ( array[src[1]] & 0x0F ) << 4 ) | ( array[src[2]] >> 2 );

        *( dest + index++ ) = one;
        *( dest + index   ) = two;

        step = 2;
    }
    else
    {
        one = ( array[src[0]] << 2 ) | ( array[src[1]] >> 4 );
        two = ( ( array[src[1]] & 0x0F ) << 4 ) | ( array[src[2]] >> 2 );
        thr = ( array[src[2]] << 6 ) | array[src[3]];

        *( dest + index++ ) = one;
        *( dest + index++ ) = two;
        *( dest + index   ) = thr;

        step = 3;
    }

    return step;
}

void
base64_decode( const unsigned char *src, unsigned char *dest )
{
    assert( src );

    unsigned char array[124];
    memset( array, 0x00, 124 );
    create_array( array );

    int index = 0;
    while ( *src )
    {
        int step = decode_string( src, dest, array, index );

        index += step;
        src   += 4;
    }

    *( dest + index ) = '\0';
}

參考文獻：http://blog.itpub.net/18903360/viewspace-1985669/