BASE64编码

来源：互联网发布：希特勒经济政策知乎编辑：程序博客网时间：2024/04/30 01:31

1、编码规则：
Base64编码要求把3个8位字节（3*8=24）转化为4个6位的字节（4*6=24），之后在6位的前面补两个0，形成8位一个字节的形式。

BASE64编码表

0 1 2 3 4 5 6 7 8 9

0 A B C D E F G H I J

1 K L M N O P Q R S T

2 U V W X Y Z a b c d

3 e f g h i j k l m n

4 o p q r s t u v w x

5 y z 0 1 2 3 4 5 6 7

6 8 9 + /

这样拆分的时候，原文的字节数量应该是3的倍数，当这个条件不能满足时，用全零字节补足，转化时Base64编码用‘=’代替。

d =(原文数)%3；

1 d= 0; 正好被完全整除，可以按照编码表转化；

2 d = 1；余一个字节，根据编码规则，转化后为2个字节，剩下的2个字节补2个‘=’；

3 d = 2; 余两个字节根据编码规则，转化后成3个字节，剩下的一个字节补一个‘=’；

算法【c描述】

#include <stdio.h>
#include <string.h>

char const *b64 ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int base64encode(unsigned char *dest,unsigned char *src,int srclen)
{
int bytes, i;

/* work out how many bytes of output there are */
bytes = ((srclen * 8) + 5) / 6;

    for (i = 0; i < bytes; i++) {
        int             byte = (i * 6) / 8;
        int             bit = (i * 6) % 8;

        if (bit < 3) {
            if (byte >= srclen)
                return -1;
            *dest = b64[(src[byte] >> (2 - bit)) & 0x3F];
        } else {
            if (byte + 1 == srclen) {
                *dest = b64[(src[byte] << (bit - 2)) & 0x3F];
            } else {
                *dest = b64[(src[byte] << (bit - 2) |
                            src[byte + 1] >> (10 - bit)) & 0x3F];
            }
        }
        dest++;
    }
    while((bytes++)%4!=0)
      *(dest++)='=';
    *dest = 0;
    return bytes;

}
int base64decode(unsigned char *d,char *s/*,int srclen*/)
{
int             bit_offset, byte_offset, idx, i, n;
   // unsigned char *d = (unsigned char *) s;
    char           *p;

    n = i = 0;
    while(*s=='=')
   s++;
    while (*s && (p = strchr(b64, *s))) {
        idx = (int) (p - b64);
        byte_offset = (i * 6) / 8;
        bit_offset = (i * 6) % 8;
        d[byte_offset] &= ~((1 << (8 - bit_offset)) - 1);
        if (bit_offset < 3) {
            d[byte_offset] |= (idx << (2 - bit_offset));
            n = byte_offset + 1;
        } else {
            d[byte_offset] |= (idx >> (bit_offset - 2));
            d[byte_offset + 1] = 0;
            d[byte_offset + 1] |= (idx << (8 - (bit_offset - 2))) & 0xFF;
            n = byte_offset + 2;
        }
        s++;
        i++;
    }
d[n] = 0;
    return n;

}