求助编程实现判断一个字符串是否是base64加密?

朱朱你堕落了

请用C++实现一个判断函数，判断一个字符串是否是base64加密过的字符串，如：1234肯定不是被某个字符串加密过，
“MTIzNA==”是被某个字符串BASE64加密过，MTIzNA==是1234的BASE64编码过的，反正就是这个意思。

如BOOL bIsBase64String(string str)或BOOL bIsBase64String(char *str)，传入一个参数，判断后，是的话，
返回TRUE，不是的话返回FALSE，谢谢各位大佬。

addwy

#include <iostream>
#include <regex>
#include <string>

bool bIsBase64String(const std::string& str) {
    // Base64的正则表达式
    static const std::regex base64_regex("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$");

    // 检查字符串是否符合Base64格式
    return std::regex_match(str, base64_regex);
}

int main() {
    std::string str1 = "MTIzNA==";
    std::string str2 = "1234";

    if (bIsBase64String(str1)) {
        std::cout << str1 << " 是Base64编码的字符串" << std::endl;
    } else {
        std::cout << str1 << " 不是Base64编码的字符串" << std::endl;
    }

    if (bIsBase64String(str2)) {
        std::cout << str2 << " 是Base64编码的字符串" << std::endl;
    } else {
        std::cout << str2 << " 不是Base64编码的字符串" << std::endl;
    }

    return 0;
}

朱朱你堕落了

addwy 发表于 2024-11-12 12:56
#include
#include
#include

用正则表达式这种方法应该是不对的，1234和MTIzNA==这两个字符串，我只是打比方，不是真实的，很明显，这个函数有问题，有漏网之鱼，可能有些字符串符合BASE64格式，但是并不是BASE64加密过的。

zunmx

1. 通过正则只能简单判断是否满足base64的规则，不能判断是否是base64编码。
2. base64编码后的长度一定是4的倍数，虽然后面的等号有时候会省略也能解码，但是这个base64编码并不规范。
3. 尝试解码操作，这个只能看出来是不是字符串被编码了，如果是二进制数据，就不太好分析了，只能看头部的特征了。
4. 如果多重编码，比如说一个字符串经过AES或者RSA加密后在进行Base64编码，那么解密后依然是不可读的。

综上：好像没有什么更加直接的判断方式了，因为我随便写一个八位的字符串，满足base64编码的风格，也是可以解码的，但是并没有什么意义。

52pjllf

#include <iostream>
#include <string>
#include <cctype>

//一个辅助函数，检查字符是否为Base64字符
bool isBase64Char(char c) {
    return (std::isalnum(static_cast<unsigned char>(c)) || c == '+' || c == '/' || c == '=');
}

bool bIsBase64String(const std::string& str) {
    int paddingCount = 0;

    //遍历字符串，检查每个字符是否是Base64字符
    for (char c : str) {
        if (!isBase64Char(c)) {
            return false;
        }
        if (c == '=') {
            paddingCount++;
            // 记录填充字符=的数量，并确保=字符只出现在字符串的末尾
            if (std::find(str.begin(), str.begin() + str.find(c), c) != str.end() - paddingCount) {
                return false;
            }
        }
    }

    //计算除去填充字符的有效长度，确保它是4的倍数
    int validLength = str.length() - paddingCount;
    if (validLength % 4 != 0) {
        return false;
    }

    //确保填充字符'='的数量不超过2个。
    if (paddingCount > 2) {
        return false;
    }

    return true;
}

//测试几个字符串，打印结果
int main() {
    std::string test1 = "1234";
    std::string test2 = "MTIzNA==";
    std::string test3 = "InvalidBase64String";
    std::string test4 = "A===";
    std::string test5 = "AnotherValidBase64==";

    std::cout << "Test 1: " << (bIsBase64String(test1) ? "TRUE" : "FALSE") << std::endl;
    std::cout << "Test 2: " << (bIsBase64String(test2) ? "TRUE" : "FALSE") << std::endl;
    std::cout << "Test 3: " << (bIsBase64String(test3) ? "TRUE" : "FALSE") << std::endl;
    std::cout << "Test 4: " << (bIsBase64String(test4) ? "TRUE" : "FALSE") << std::endl;
    std::cout << "Test 5: " << (bIsBase64String(test5) ? "TRUE" : "FALSE") << std::endl;

    return 0;
}

xiadengma

[Python] 纯文本查看 复制代码

import base64
import re

def is_base64(s):
    # Step 1: 检查字符串是否符合Base64的字符集格式
    base64_pattern = re.compile(r'^[A-Za-z0-9+/]+={0,2}$')
    
    if not base64_pattern.match(s):
        return False
    
    try:
        # Step 2: 尝试解码并验证
        decoded_data = base64.b64decode(s, validate=True)
        
        # Step 3: 可以根据需求进一步验证解码后的数据，这里暂时返回True表示是Base64编码
        return True
    except (base64.binascii.Error, ValueError):
        # 如果解码失败，则返回False
        return False

# 测试示例
test_strings = [
    "U29tZSB0ZXh0IGVuY29kaW5nIGluIEJhc2U2NA==",  # Base64编码的字符串 (对应 "Some text encoding in Base64")
    "12345==",  # 非Base64编码的字符串
    "QmFzZTY0IGVuY29kaW5n",  # Base64编码的字符串 (对应 "Base64 encoding")
    "VGhpcyBpcyBhbiBpbnZhbGlkIHRleHQ=",  # Base64编码的字符串 (对应 "This is an invalid text"
]

for s in test_strings:
    result = is_base64(s)
    print(f"'{s}' is base64 encoded: {result}")

asq56747277

尝试进行Base64解码，成功就是编码后的。只能验证格式正确，内容有没有实际意义不好判断

朱朱你堕落了

asq56747277 发表于 2024-11-12 13:10
尝试进行Base64解码，成功就是编码后的。只能验证格式正确，内容有没有实际意义不好判断

你的意思应该和这个文章中判断方法一样。
https://cloud.tencent.com/develo ... 9%E6%95%88%EF%BC%9F

xwei2017

#include <string>
#include <cctype>

bool isBase64(const std::string& str) {
    if (str.empty()) {
        return false;
    } else {
        size_t len = str.length();
        if (len % 4 != 0) {
            return false;
        }

        for (char c : str) {
            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
                (c >= '0' && c <= '9') || c == '+' || c == '/' || c == '=') {
                continue;
            } else {
                return false;
            }
        }
        return true;
    }
}

xwei2017

#include <string>
#include <cctype>

bool isBase64(const std::string& str) {
    // Check for empty or null input
    if (str.empty()) return false;

    size_t len = str.length();
    bool hasNonAlphaNum = false;
    int numPaddedChars = 0;

    for (char c : str) {
        switch (c) {
            case '=': { // padding character, allowed only at the end
                if (!isBase64Padding(str, len)) return false;
                break;
            }
            case '+': case '/': case '=':
                hasNonAlphaNum = true; // allow these special chars
                continue;

            default:
                if (std::iscntrl(c) || c < 'A' || c > 'Z') {
                    // non-alphanumeric char, not allowed in base64
                    return false;
                }
        }

        numPaddedChars += (c == '=');
    }

    // Check for correct padding at the end of the string
    if (!isBase64Padding(str, len)) return false;

    return !hasNonAlphaNum && (len % 4 == 0 || numPaddedChars > 0);
}

bool isBase64Padding(const std::string& str, size_t len) {
    // Check for correct padding at the end of the string
    if (len < 3) return false; // too short to be a valid base64-encoded string

    char lastChar = str[len - 1];
    char secondLastChar = str[len - 2];

    switch (lastChar) {
        case '=':
            return true;
        default: break;

        case 'A': case 'B':
            if (secondLastChar == '=') return false; // not a valid padding
            break;
        case 'C': case 'D':
            if (secondLastChar != '=') return false; // not a valid padding
            break;
    }

    return false;
}