C语言实现 Base64 和 Base32 编解码

最新推荐文章于 2023-07-08 17:40:59 发布
最新推荐文章于 2023-07-08 17:40:59 发布
阅读量1.3k 收藏 1
点赞数 2
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44129085/article/details/125966715
版权

C语言实现 Base64 和 Base32 编解码

作者：Bright Xu

Base64 编解码

定义头文件 base64.h
#ifndef _BASE64_H
#define _BASE64_H

#include <stdint.h>

static const char BASE64_MAP[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
static const uint8_t BASE64_REVERSE_MAP[] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4,
        5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29,
        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
};

char *base64encode(const char *str, uint64_t len);

char *base64parse(const char *base64Str, uint64_t len);

#endif //_BASE64_H
思路

Base64编码就是用64个可打印字符表示二进制数据。 64 = 2 6 64 = 2^6 64=26，所以需要6 Bit来表示一个base64字符。一个字节8 Bit，6和8的最小公倍数是24。编码的过程中，以3个字节为一组转为4个base64字符，不足3个字节以0代替。为方便转换，以一个无符号32位整数(uint32_t)为中间载体。先由高位到低位将这三个字节填充到这个整数中，然后由高位到低位依次读取6位，获取对应数值的字母，共读取4次。如下图所示。解码的过程是上述的逆过程。

请添加图片描述

实现
#include "base64.h"
#include <stdlib.h>

#ifndef CEIL_POS
// 正数向上取整 CEIL_POS(2.345) => 3
#define CEIL_POS(X) (X > (uint64_t)(X) ? (uint64_t)(X+1) : (uint64_t)(X))
#endif

char *base64encode(const char *str, uint64_t len) {
    uint64_t length = CEIL_POS(len * 4 / 3) + 1;
    char *base64Chars = (char *) malloc(sizeof(char) * length);
    uint64_t idx = 0;
    
    for (uint64_t i = 0; i < len; i += 3) {
        uint32_t byte1 = (uint8_t) str[i];
        uint16_t byte2 = (i + 1 < len) ? (uint8_t) str[i + 1] : 0;
        uint8_t byte3 = (i + 2 < len) ? (uint8_t) str[i + 2] : 0;
        
        uint32_t triplet = (byte1 << 16) | (byte2 << 8) | byte3;
        
        for (uint64_t j = 0; (j < 4) && (i + j * 0.75 < len); j++) {
            base64Chars[idx] = BASE64_MAP[(triplet >> (6 * (3 - j))) & 0x3f];
            idx++;
        }
    }
    
    char paddingChar = BASE64_MAP[64];
    if (paddingChar) {
        while (idx % 4) {
            base64Chars[idx] = paddingChar;
            idx++;
        }
    }
    base64Chars[idx] = 0;
    return base64Chars;
}

char *base64parse(const char *base64Str, uint64_t len) {
    while (base64Str[len - 1] == BASE64_MAP[64]) {
        len--;
    }
    uint64_t length = CEIL_POS(len * 3 / 4) + 1;
    char *str = (char *) malloc(sizeof(char) * length);
    uint64_t idx = 0;
    
    for (uint64_t i = 0; i < len; i += 4) {
        uint32_t triplet = 0;
        for (uint8_t j = 0; j < 4; ++j) {
            if (i + j < len) triplet = (triplet << 6) | ((uint8_t) BASE64_REVERSE_MAP[base64Str[i + j]] & 0x3f);
            else triplet = triplet << 6;
        }
        for (uint8_t j = 0; (j < 3); ++j) {
            str[idx] = (triplet >> (8 * (2 - j))) & 0xff;
            idx++;
        }
    }
    str[idx] = 0;
    return str;
}
使用
// test_b64.c
#include <stdio.h>
#include <string.h>
#include "base64.h"

int main() {
    char str1[] = "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.";
    char *encoded = base64encode(str1, strlen(str1));
    puts(encoded);

    char str2[] = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=";
    char *decoded = base64parse(str2, strlen(str2));
    puts(decoded);
    return 0;
}

Base32 编解码

定义头文件 base32.h
#ifndef _BASE32_H
#define _BASE32_H

#include <stdint.h>

static const char BASE32_MAP[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=";
static const uint8_t BASE32_REVERSE_MAP[] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6,
        7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
};

char *base32encode(const char *str, uint64_t len);

char *base32parse(const char *base32Str, uint64_t len);

#endif //_BASE32_H
思路

Base32编码就是用32个可打印字符表示二进制数据。 32 = 2 5 32 = 2^5 32=25，所以需要5 Bit来表示一个base32字符。一个字节8 Bit，5和8的最小公倍数是40。编码的过程中，以5个字节为一组转为8个base32字符，不足5个字节以0代替。为方便转换，以一个无符号64位整数(uint64_t)为中间载体。先由高位到低位将这5个字节填充到这个整数中，然后由高位到低位依次读取5位，获取对应数值的字母，共读取8次。如下图所示。解码的过程是上述的逆过程。

请添加图片描述

实现
#include "base32.h"
#include <stdlib.h>

#ifndef CEIL_POS
#define CEIL_POS(X) (X > (uint64_t)(X) ? (uint64_t)(X+1) : (uint64_t)(X))
#endif

char *base32encode(const char *str, uint64_t len) {
    uint64_t length = CEIL_POS(len * 8 / 5) + 1;
    char *base32Chars = (char *) malloc(sizeof(char) * length);
    uint64_t idx = 0;
    
    for (uint64_t i = 0; i < len; i += 5) {
        uint64_t byte1 = (uint8_t) str[i];
        uint64_t byte2 = (i + 1 < len) ? (uint8_t) str[i + 1] : 0;
        uint32_t byte3 = (i + 2 < len) ? (uint8_t) str[i + 2] : 0;
        uint16_t byte4 = (i + 3 < len) ? (uint8_t) str[i + 3] : 0;
        uint8_t byte5 = (i + 4 < len) ? (uint8_t) str[i + 4] : 0;
        
        uint64_t quintuple = (byte1 << 32) | (byte2 << 24) | (byte3 << 16) | (byte4 << 8) | byte5;
        
        for (uint64_t j = 0; (j < 8) && (i + j * 0.625 < len); j++) {
            base32Chars[idx] = BASE32_MAP[(quintuple >> (5 * (7 - j))) & 0x1f];
            idx++;
        }
    }
    
    char paddingChar = BASE32_MAP[32];
    if (paddingChar) {
        while (idx % 8) {
            base32Chars[idx] = paddingChar;
            idx++;
        }
    }
    base32Chars[idx] = 0;
    return base32Chars;
}

char *base32parse(const char *base32Str, uint64_t len) {
    while (base32Str[len - 1] == BASE32_MAP[32]) {
        len--;
    }
    uint64_t length = CEIL_POS(len * 5 / 8) + 1;
    char *str = (char *) malloc(sizeof(char) * length);
    uint64_t idx = 0;
    
    for (uint64_t i = 0; i < len; i += 8) {
        uint64_t quintuple = 0;
        for (uint8_t j = 0; j < 8; ++j) {
            if (i + j < len) quintuple = (quintuple << 5) | ((uint8_t) BASE32_REVERSE_MAP[base32Str[i + j]] & 0x1f);
            else quintuple = quintuple << 5;
        }
        for (uint8_t j = 0; (j < 5); ++j) {
            str[idx] = (quintuple >> (8 * (4 - j))) & 0xff;
            idx++;
        }
    }
    str[idx] = 0;
    return str;
}
使用
// test_b32.c
#include <stdio.h>
#include <string.h>
#include "base32.h"

int main() {
    char str1[] = "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.";
    char *encoded = base32encode(str1, strlen(str1));
    puts(encoded);

    char str2[] = "JVQW4IDJOMQGI2LTORUW4Z3VNFZWQZLEFQQG433UEBXW43DZEBRHSIDINFZSA4TFMFZW63RMEBRHK5BAMJ4SA5DINFZSA43JNZTXK3DBOIQHAYLTONUW63RAMZZG63JAN52GQZLSEBQW42LNMFWHGLBAO5UGSY3IEBUXGIDBEBWHK43UEBXWMIDUNBSSA3LJNZSCYIDUNBQXIIDCPEQGCIDQMVZHGZLWMVZGC3TDMUQG6ZRAMRSWY2LHNB2CA2LOEB2GQZJAMNXW45DJNZ2WKZBAMFXGIIDJNZSGKZTBORUWOYLCNRSSAZ3FNZSXEYLUNFXW4IDPMYQGW3TPO5WGKZDHMUWCAZLYMNSWKZDTEB2GQZJAONUG64TUEB3GK2DFNVSW4Y3FEBXWMIDBNZ4SAY3BOJXGC3BAOBWGKYLTOVZGKLQ=";
    char *decoded = base32parse(str2, strlen(str2));
    puts(decoded);
    return 0;
}
Bright Xu
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Base32编码解码C语言实现
03-15
/* Base32编码解码C语言实现。 文件列表: base32.h, base32.cpp, test.cpp。 包含测试工程: VC++6.0, VC++2008, VC++2013, CentOS7-x64+gcc-4.8.5.20150623(cmake)。 提供此源码编译及使用方面的Email技术支持。 */
C语言编写base32编码解码代码实现
最新发布
lifan123321的博客
05-17 252
C语言编写base32编码解码代码实现
Base32系列编码 代码实现过程
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
06-05 550
【代码】Base32加密C++实现过程。
常见加密算法总结-base系列部分
m0_62690279的博客
04-03 2957
文章目录常见加密算法总结-base系列部分附上链接自己的总结base系列编码base64介绍字典加密原理图加密代码解密索引表解密代码base32介绍字典一字典二加密原理图解密base16介绍编码表加密原理图代码base58编码 常见加密算法总结-base系列部分 附上链接 参考学长的：https://the_itach1.gitee.io/2021/01/18/%E4%B8%80%E4%BA%9B%E5%B8%B8%E7%94%A8%E7%AE%97%E6%B3%95/ 自己的总结 base系列编码 ba
常见密码归纳（入门级）
热门推荐
I_am_busy的博客
03-25 1万+
** 常见密码归纳（入门级） ** 前言：前几天的比赛发现密码忘得有点多，今天总结一下吧。方便自己以后看看。 常见密码： 1：base密码（base16 ,32，64，58 ,85 ,100）；: 2：ROT密码：ROT 5/13/18/47; 3：凯撒密码+变异凯撒； 4：栅栏密码，栅栏密码W型； 5：猪圈密码； 6：维吉尼亚； 7: 特殊密码：摩斯密码，培根密码，与佛论禅，百家姓，Uuencode编码转换 一：base家族： base算是最常见的密码之一，经常用到的base64/32/16,少见的有58
C语言应用（3）——Base64编码/解码
Leung的博客
10-12 2666
Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性，需要解码后才能阅读。Base64由于以上优点被广泛应用于计算机的各个领域，然而由于输出内容中包括两个以上“符号类”字符（+, /, =)，不同的应用场景又分别研制了Base64的各种“变种”。
C语言实现Base64编解码（加密和解密）.zip
09-06
Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二...本资源使用C语言实现Base64加密和解密，可以实现数据的加密和文件的加密，不借助任何的第三方工具，便于移植。
c语言实现base64编码
04-21
C语言实现Base64编码通常涉及到以下几个核心概念和步骤： 1. **Base64字符集**： Base64编码使用64个字符来表示二进制数据，这些字符包括大写字母（A-Z）、小写字母（a-z）、数字（0-9）以及两个特殊字符`+`和`/`...
c语言实现base64编码解码
04-20
用c语言实现的base64，包括加密算法和解密算法。
c语言实现base64编解码
08-11
在C语言中实现Base64编解码涉及到对字符集的理解、位操作以及字符串处理。下面将详细介绍Base64编码原理、C语言实现的关键步骤以及可能遇到的问题。 1. **Base64编码原理** - Base64编码是将每3个字节（24位）的...
base16 base32 base64 C语言代码
08-21
总的来说，Base16、Base32和Base64编码是数据表示的关键工具，而C语言提供了实现这些编码的强大平台。通过分析提供的源代码，不仅可以深入了解这些编码机制，还能提升C语言编程技能，尤其是对于嵌入式系统开发者而言...
标准的base32编码和解码
jykenan的专栏
09-29 1026
public class Base32 { private static final String base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; private static final int[] base32Lookup = { 0xFF, 0xFF, 0x1A, ...
base64编码原理及C语言实现
qq_45698138的博客
06-02 1477
​ Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。位：bit字节：bytes 字通常由多个字节（8位）组成。 一个字的位数即为字长。 现代计算机的字长通常为16位（2个字节）、32位（4个字节）、64位（8个字节）。存储单元 以8位二进制作为一个存储单元，也就是一个字节。 每个单元有一个地址，是一个整数编码，可以表示为二进制整数。存储字 存储字是指存放在一个存储
C语言 base32与base64加解密
qq_36075612的博客
07-08 1566
C语言 base32与base64加解密
Base62编解码
Pig
05-06 4979
//！！！摘子新浪认证！！！ private static char[] encodes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); /** * 将data编码成Base62的字符串 * @param data * @return */
Base62（高精度 进制转换）
百般回首曾经的相遇，留下的只是一缕残忆
12-01 2381
Base62 题目 题意 将一个 x 进制的 z 转换成 y 进制的数并输出。 AC代码 #include <cstdio> #include <cstring> #include <string> using namespace std; void output(int a) { if (a > 9) { output(a ...
C/C++笔记二：内存池 、数据包粘包处理、ws握手 、收发数据
不负韶华梦为马
09-02 756
内存池 、数据包粘包处理、ws握手 、收发数据
基于C++实现的一种通用Base编解码器(Hex(Base16)/Base32/Base64)
yaoyuanyylyy的专栏
04-12 5256
使用Hex(十六进制)编码、Base32编码和Base64编码可以将二进制数据编码为可视化字符串。它们的原理是一样的，都是将指定位数的二进制数据编码为特定字符空间中的一个字符。 Hex：也叫作Base16编码；每4位编码为一个字符，字符空间为"0123456789abcdef"或"0123456789ABCDEF"；不区分大小写，其中的字母可以编码为大写也可以编码为小写，同时解码也不区分大小写，...
C语言实现base64编码解码
06-03
以下是C语言实现base64编码解码的示例代码： ```c #include <stdio.h> #include <string.h> #include <stdlib.h> // Base64编码表 static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // Base64解码表 static const char base64_decode_table[] = { 62, -1, -1, -1, 63, // '+', '/', and 0x3D are special 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // '0'-'9', '=', and 'A'-'Z' -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 }; // Base64编码函数 char* base64_encode(const unsigned char *data, size_t input_length, size_t *output_length) { *output_length = 4 * ((input_length + 2) / 3); // 计算编码后字符串长度 char *encoded_data = malloc(*output_length + 1); // 分配内存 if (encoded_data == NULL) { return NULL; } // 编码 for (size_t i = 0, j = 0; i < input_length;) { uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0; uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0; uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0; uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c; encoded_data[j++] = base64_table[(triple >> 3 * 6) & 0x3F]; encoded_data[j++] = base64_table[(triple >> 2 * 6) & 0x3F]; encoded_data[j++] = base64_table[(triple >> 1 * 6) & 0x3F]; encoded_data[j++] = base64_table[(triple >> 0 * 6) & 0x3F]; } // 添加填充字符 for (size_t i = 0; i < (*output_length - input_length % 3) % 3; i++) { encoded_data[*output_length - 1 - i] = '='; } encoded_data[*output_length] = '\0'; return encoded_data; } // Base64解码函数 unsigned char* base64_decode(const char *data, size_t input_length, size_t *output_length) { if (input_length % 4 != 0) { return NULL; } *output_length = input_length / 4 * 3; // 计算解码后字节数 if (data[input_length - 1] == '=') { (*output_length)--; } if (data[input_length - 2] == '=') { (*output_length)--; } unsigned char *decoded_data = malloc(*output_length + 1); // 分配内存 if (decoded_data == NULL) { return NULL; } // 解码 for (size_t i = 0, j = 0; i < input_length;) { uint32_t sextet_a = data[i] == '=' ? 0 & i++ : base64_decode_table[(int)data[i++]]; uint32_t sextet_b = data[i] == '=' ? 0 & i++ : base64_decode_table[(int)data[i++]]; uint32_t sextet_c = data[i] == '=' ? 0 & i++ : base64_decode_table[(int)data[i++]]; uint32_t sextet_d = data[i] == '=' ? 0 & i++ : base64_decode_table[(int)data[i++]]; uint32_t triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6); if (j < *output_length) { decoded_data[j++] = (triple >> 2 * 8) & 0xFF; } if (j < *output_length) { decoded_data[j++] = (triple >> 1 * 8) & 0xFF; } if (j < *output_length) { decoded_data[j++] = (triple >> 0 * 8) & 0xFF; } } decoded_data[*output_length] = '\0'; return decoded_data; } int main() { char *data = "Hello, world!"; size_t data_length = strlen(data); // 编码 size_t encoded_length; char *encoded_data = base64_encode((const unsigned char*)data, data_length, &encoded_length); printf("Base64 encoded data: %s\n", encoded_data); // 解码 size_t decoded_length; unsigned char *decoded_data = base64_decode(encoded_data, encoded_length, &decoded_length); printf("Base64 decoded data: %s\n", decoded_data); free(encoded_data); free(decoded_data); return 0; } ``` 上述代码中，`base64_encode`函数用于将二进制数据编码为Base64字符串，`base64_decode`函数用于将Base64字符串解码为原始的二进制数据。在编码时，函数会将每3个字节的二进制数据转换为4个Base64字符，如果遇到不足3个字节的末尾数据，则会用`=`字符进行填充。在解码时，函数会将每4个Base64字符转换为3个字节的二进制数据，如果遇到末尾的`=`字符，则会忽略它们。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值