C语言解码Base64编码的wchar_t*遇问题，求可用实现

问题描述 #

我在纯C（非C++）环境下尝试解码Base64编码的wchar_t*时遇到了困难，自己修改现有实现写的解码函数无法正常工作。以下是我的代码：

#include <stdlib.h>
#include <wchar.h>

wchar_t* base64_decode(const wchar_t* encoded)
{
    const wchar_t base64_chars[] = L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    const size_t encoded_len = wcslen(encoded);
    size_t i = 0, j = 0;
    int padding = 0;
    if (encoded_len < 4 || encoded_len % 4 != 0)
        return NULL;
    if (encoded[encoded_len - 1] == L'=')
        padding++;
    if (encoded[encoded_len - 2] == L'=')
        padding++;
    const size_t decoded_len = ((encoded_len / 4) * 3) - padding;
    wchar_t* decoded = (wchar_t*)malloc((decoded_len + 1) * sizeof(wchar_t));
    if (!decoded)
        return NULL;
    while (i < encoded_len)
    {
        uint32_t sextet_a = encoded[i] == L'=' ? 0 & i++ : base64_chars[wcschr(base64_chars, encoded[i++]) - base64_chars];
        uint32_t sextet_b = encoded[i] == L'=' ? 0 & i++ : base64_chars[wcschr(base64_chars, encoded[i++]) - base64_chars];
        uint32_t sextet_c = encoded[i] == L'=' ? 0 & i++ : base64_chars[wcschr(base64_chars, encoded[i++]) - base64_chars];
        uint32_t sextet_d = encoded[i] == L'=' ? 0 & i++ : base64_chars[wcschr(base64_chars, encoded[i++]) - base64_chars];
        uint32_t triple = (sextet_a << 3 * 6)
                        + (sextet_b << 2 * 6)
                        + (sextet_c << 1 * 6)
                        + (sextet_d << 0 * 6);
        if (j < decoded_len)
            decoded[j++] = (triple >> 2 * 8) & 0xFF;
        if (j < decoded_len)
            decoded[j++] = (triple >> 1 * 8) & 0xFF;
        if (j < decoded_len)
            decoded[j++] = (triple >> 0 * 8) & 0xFF;
    }
    decoded[j] = L'\0';
    return decoded;
}

测试代码：

int main() 
{
        wchar_t* decoded_string = base64_decode(L"c3RhY2tvdmVyZmxvdw=="); // "stackoverflow"
        std::wcout << decoded_string; // 输出乱码，预期是"stackoverflow"
}

代码中的核心问题 #

1. 字符索引逻辑错误
   获取Base64字符对应的6位编码值时，你错误地将wcschr返回的指针偏移量（即正确的索引值）作为下标去访问base64_chars，这会重新取出原字符而非编码值。正确做法是直接使用该偏移量作为编码值。

2. 填充字符处理语法错误
   处理=填充字符时，0 & i++完全无意义，虽然i++会执行，但这种写法极易混淆，正确分支应为0, i++（逗号表达式）或分开写逻辑。

3. 位运算写法不规范
   C语言中乘法优先级高于位移，3 * 6虽结果正确，但直接写位移位数（如18）更清晰，避免依赖运算优先级带来的潜在错误。

4. 宽字符存储逻辑偏差
   Base64解码结果是原始字节流，直接将单字节值存入wchar_t不符合Windows平台UTF-16宽字符规范，虽ASCII字符高位补0可临时显示，但更规范的方式是先解码为字节数组，再通过系统API转换为宽字符。

Windows平台纯C实现（无外部依赖） #

#include <stdlib.h>
#include <wchar.h>
#include <ctype.h>
#include <windows.h>

// 快速映射Base64字符到对应的6位编码值
static int base64_char_to_val(wchar_t c) {
    if (c >= L'A' && c <= L'Z') return c - L'A';
    if (c >= L'a' && c <= L'z') return c - L'a' + 26;
    if (c >= L'0' && c <= L'9') return c - L'0' + 52;
    if (c == L'+') return 62;
    if (c == L'/') return 63;
    return -1; // 无效字符标记
}

wchar_t* base64_decode(const wchar_t* encoded) {
    if (!encoded) return NULL;

    size_t encoded_len = wcslen(encoded);
    // 过滤Base64中可能存在的换行、空格等无关字符
    wchar_t* filtered = (wchar_t*)malloc((encoded_len + 1) * sizeof(wchar_t));
    if (!filtered) return NULL;

    size_t filtered_len = 0;
    for (size_t i = 0; i < encoded_len; i++) {
        if (iswalnum(encoded[i]) || encoded[i] == L'+' || encoded[i] == L'/' || encoded[i] == L'=') {
            filtered[filtered_len++] = encoded[i];
        }
    }
    filtered[filtered_len] = L'\0';
    encoded_len = filtered_len;

    // 检查Base64长度合法性
    if (encoded_len % 4 != 0) {
        free(filtered);
        return NULL;
    }

    // 统计填充字符数量
    int padding = 0;
    if (encoded_len >= 1 && filtered[encoded_len - 1] == L'=') padding++;
    if (encoded_len >= 2 && filtered[encoded_len - 2] == L'=') padding++;

    size_t decoded_byte_len = ((encoded_len / 4) * 3) - padding;
    unsigned char* decoded_bytes = (unsigned char*)malloc(decoded_byte_len);
    if (!decoded_bytes) {
        free(filtered);
        return NULL;
    }

    size_t i = 0, j = 0;
    while (i < encoded_len) {
        int val_a = base64_char_to_val(filtered[i++]);
        int val_b = base64_char_to_val(filtered[i++]);
        int val_c = (i < encoded_len) ? base64_char_to_val(filtered[i++]) : 0;
        int val_d = (i < encoded_len) ? base64_char_to_val(filtered[i++]) : 0;

        // 检查无效字符
        if (val_a == -1 || val_b == -1 || 
            (val_c == -1 && filtered[i-1] != L'=') || 
            (val_d == -1 && filtered[i-1] != L'=')) {
            free(filtered);
            free(decoded_bytes);
            return NULL;
        }

        // 组合4个6位值为3个8位字节
        uint32_t triple = ((uint32_t)val_a << 18) | 
                          ((uint32_t)val_b << 12) | 
                          ((uint32_t)val_c << 6) | 
                          val_d;

        if (j < decoded_byte_len) decoded_bytes[j++] = (triple >> 16) & 0xFF;
        if (j < decoded_byte_len) decoded_bytes[j++] = (triple >> 8) & 0xFF;
        if (j < decoded_byte_len) decoded_bytes[j++] = triple & 0xFF;
    }

    // 将字节流转换为Windows UTF-16宽字符
    wchar_t* decoded_wstr = (wchar_t*)malloc((decoded_byte_len + 1) * sizeof(wchar_t));
    if (!decoded_wstr) {
        free(filtered);
        free(decoded_bytes);
        return NULL;
    }

    // 假设解码结果为UTF-8编码，若确定是ASCII可替换为CP_ACP
    int result_len = MultiByteToWideChar(CP_UTF8, 0, (char*)decoded_bytes, decoded_byte_len, decoded_wstr, decoded_byte_len);
    if (result_len == 0) {
        free(filtered);
        free(decoded_bytes);
        free(decoded_wstr);
        return NULL;
    }
    decoded_wstr[result_len] = L'\0';

    // 释放临时内存
    free(filtered);
    free(decoded_bytes);
    return decoded_wstr;
}

// 纯C测试主函数
#include <stdio.h>
int main() {
    wchar_t* decoded_string = base64_decode(L"c3RhY2tvdmVyZmxvdw==");
    if (decoded_string) {
        wprintf(L"%ls\n", decoded_string);
        free(decoded_string);
    }
    return 0;
}

实现说明 #

• 用base64_char_to_val替代字符串查找，效率更高且避免索引错误。
• 自动过滤Base64中的无关字符（如换行、空格），提升健壮性。
• 先解码为原始字节流，再通过Windows原生API MultiByteToWideChar转换为UTF-16宽字符，符合平台规范。
• 增加无效字符检查，避免非法输入导致的崩溃。

内容的提问来源于stack exchange，提问作者George Autry