自定义加密c++转python示例

jni代码

/**
 * 自定义加密（字节级混淆 + 多运算符参与）
 * 输入UTF-8字符串与密钥，输出十六进制字符串
 */
JNIEXPORT jstring JNICALL
Java_com_example_jnicalculator_MainActivity_encryptString(JNIEnv *env, jobject /*thiz*/, jstring input, jstring key) {
    if (input == nullptr) {
        return env->NewStringUTF("");
    }

    const char *inputChars = env->GetStringUTFChars(input, nullptr);
    const char *keyChars = key ? env->GetStringUTFChars(key, nullptr) : "";

    std::string plain(inputChars ? inputChars : "");
    std::string kstr(keyChars ? keyChars : "");

    if (inputChars) env->ReleaseStringUTFChars(input, inputChars);
    if (key) env->ReleaseStringUTFChars(key, keyChars);

    // 兜底密钥
    if (kstr.empty()) {
        kstr = "default_key@JNI";
    }

    // FNV-1a 64位 派生种子，使用 ^、*、+ 等
    uint64_t seed = 1469598103934665603ULL; // FNV offset basis
    const uint64_t prime = 1099511628211ULL; // FNV prime
    for (size_t i = 0; i < kstr.size(); ++i) {
        seed ^= static_cast<uint8_t>(kstr[i]);
        seed *= prime;
        seed += (i * 131u + 7u); // 引入 + 和 *
        seed ^= (seed >> 13);    // 使用 >> 和 ^
    }

    // 8位循环左移
    auto rotl8 = [](uint8_t v, unsigned int r) -> uint8_t {
        r &= 7u;
        return static_cast<uint8_t>(((v << r) | (v >> (8u - r))) & 0xFFu);
    };

    // 8位循环右移
    auto rotr8 = [](uint8_t v, unsigned int r) -> uint8_t {
        r &= 7u;
        return static_cast<uint8_t>(((v >> r) | (v << (8u - r))) & 0xFFu);
    };

    // 主循环：字节级变换，综合使用 +, -, *, /, %, ^, |, &, ~, <<, >>, &&, ||, ?: 等
    std::string out;
    out.reserve(plain.size() * 2 + 8);

    uint32_t checksumAdd = 0;
    uint32_t checksumXor = 0;

    const size_t klen = kstr.size();
    for (size_t i = 0; i < plain.size(); ++i) {
        uint8_t p = static_cast<uint8_t>(plain[i]);
        uint8_t kc = static_cast<uint8_t>(kstr[i % klen]);

        // 基础混合：加法、异或、位移、或
        uint32_t mixSeed = static_cast<uint32_t>((seed >> ((i % 7) * 8)) & 0xFFu);
        uint8_t x = static_cast<uint8_t>((p + kc) ^ static_cast<uint8_t>(mixSeed));
        x = static_cast<uint8_t>((x | (kc & 0xAAu)) & 0xFFu);

        // 旋转与取反
        x = rotl8(x, static_cast<unsigned>((i + kc) % 8));
        x ^= static_cast<uint8_t>(~kc);

        // 乘法与模运算
        x = static_cast<uint8_t>((static_cast<uint32_t>(x) * 33u + static_cast<uint32_t>(i)) % 256u);

        // 与源字节的移位组合
        uint8_t m1 = static_cast<uint8_t>((p << (i % 3)) | (p >> (5 - (i % 3))));
        x ^= m1;

        // 条件分支与逻辑运算
        if (((i & 1u) == 0u && (x % 2u == 1u)) || ((kc & 1u) != 0u)) {
            x = static_cast<uint8_t>(x + (static_cast<uint8_t>(seed) & 0x0Fu));
        } else {
            x = static_cast<uint8_t>(x - (static_cast<uint8_t>(seed >> 4) & 0x0Fu));
        }

        // 三元运算符
        x = (x > kc) ? static_cast<uint8_t>(x ^ static_cast<uint8_t>(i))
                     : static_cast<uint8_t>(x + kc);

        // 右旋进一步混淆
        x = rotr8(x, static_cast<unsigned>((kc ^ i) % 8));

        // 更新校验
        checksumAdd = (checksumAdd + x + p + kc) & 0xFFFFFFFFu;
        checksumXor ^= static_cast<uint32_t>(x) << ((i % 4) * 8);

        // 输出为十六进制字符串
        static const char *hex = "0123456789ABCDEF";
        out.push_back(hex[(x >> 4) & 0x0F]);
        out.push_back(hex[x & 0x0F]);
    }

    // 结合 seed 的额外尾部MAC（简化，非安全）
    uint32_t mac = static_cast<uint32_t>((seed & 0xFFFFFFFFu) ^ checksumXor ^ ((checksumAdd << 1) | (checksumAdd >> 31)));
    out.push_back('-');
    char tail[9] = {0};
    snprintf(tail, sizeof(tail), "%08X", mac);
    out.append(tail);

    LOGI("encryptString: input_size=%zu key_size=%zu out_size=%zu", plain.size(), kstr.size(), out.size());
    return env->NewStringUTF(out.c_str());
}

纯c++版本的代码

#include <cstdint>
#include <cstdio>
#include <string>
#include <vector>
#include <iostream>

static inline uint8_t rotl8(uint8_t v, unsigned int r) {
    r &= 7u;
    return static_cast<uint8_t>(((v << r) & 0xFFu) | (v >> (8u - r)));
}

static inline uint8_t rotr8(uint8_t v, unsigned int r) {
    r &= 7u;
    return static_cast<uint8_t>((v >> r) | ((v << (8u - r)) & 0xFFu));
}

static std::string encrypt_string(const std::string &input_str, const std::string &key_str) {
    const uint64_t FNV_OFFSET_BASIS = 1469598103934665603ULL;
    const uint64_t FNV_PRIME = 1099511628211ULL;
    const uint64_t UINT64_MASK = 0xFFFFFFFFFFFFFFFFULL;
    const std::string DEFAULT_KEY = "default_key@JNI";

    if (input_str.empty()) {
        return std::string();
    }

    const std::string &kstr = key_str.empty() ? DEFAULT_KEY : key_str;

    // seed 构造（与修正版一致）
    uint64_t seed = FNV_OFFSET_BASIS;
    for (size_t i = 0; i < kstr.size(); ++i) {
        uint8_t key_byte = static_cast<uint8_t>(kstr[i]);
        seed ^= key_byte;
        seed &= UINT64_MASK;
        seed *= FNV_PRIME;
        seed &= UINT64_MASK;
        uint64_t add_val64 = static_cast<uint64_t>(i * 131u + 7u);
        seed += add_val64;
        seed &= UINT64_MASK;
        seed ^= (seed >> 13);
        seed &= UINT64_MASK;
    }

    std::string out;
    out.reserve(input_str.size() * 2 + 8);
    uint32_t checksum_add = 0;
    uint32_t checksum_xor = 0;
    static const char *HEX = "0123456789ABCDEF";

    for (size_t i = 0; i < input_str.size(); ++i) {
        uint8_t p = static_cast<uint8_t>(input_str[i]);
        uint8_t kc = static_cast<uint8_t>(kstr[i % kstr.size()]);

        uint32_t mix_seed = static_cast<uint32_t>((seed >> ((i % 7) * 8)) & 0xFFu);
        uint8_t x = static_cast<uint8_t>(((p + kc) & 0xFFu) ^ static_cast<uint8_t>(mix_seed));
        x = static_cast<uint8_t>((x | (kc & 0xAAu)) & 0xFFu);

        x = rotl8(x, static_cast<unsigned>((i + kc) % 8));
        x ^= static_cast<uint8_t>(~kc);
        x &= 0xFFu;

        x = static_cast<uint8_t>((static_cast<uint32_t>(x) * 33u + static_cast<uint32_t>(i)) % 256u);

        unsigned int shift = static_cast<unsigned int>(i % 3);
        uint8_t p_left = static_cast<uint8_t>((p << shift) & 0xFFu);
        uint8_t p_right = static_cast<uint8_t>((p >> (5u - shift)) & 0xFFu);
        uint8_t m1 = static_cast<uint8_t>(p_left | p_right);
        x ^= m1;

        bool cond = (((i & 1u) == 0u) && ((x % 2u) == 1u)) || ((kc & 1u) != 0u);
        uint8_t add_val = static_cast<uint8_t>(seed & 0x0Fu);
        uint8_t sub_val = static_cast<uint8_t>((seed >> 4) & 0x0Fu);
        if (cond) {
            x = static_cast<uint8_t>((x + add_val) & 0xFFu);
        } else {
            x = static_cast<uint8_t>((static_cast<uint16_t>(x) + 256u - sub_val) & 0xFFu);
        }

        if (x > kc) {
            x ^= static_cast<uint8_t>(i & 0xFFu);
        } else {
            x = static_cast<uint8_t>((x + kc) & 0xFFu);
        }

        x = rotr8(x, static_cast<unsigned>((kc ^ i) % 8));

        checksum_add = (checksum_add + x + p + kc) & 0xFFFFFFFFu;
        checksum_xor ^= static_cast<uint32_t>(x) << ((i % 4) * 8);
        checksum_xor &= 0xFFFFFFFFu;

        out.push_back(HEX[(x >> 4) & 0x0F]);
        out.push_back(HEX[x & 0x0F]);
    }

    uint32_t mac = static_cast<uint32_t>((seed & 0xFFFFFFFFu) ^ checksum_xor ^ ((checksum_add << 1) | (checksum_add >> 31)));
    out.push_back('-');
    char tail[9] = {0};
    std::snprintf(tail, sizeof(tail), "%08X", mac);
    out.append(tail);

    return out;
}

int main() {
    std::string input = "1234qwer";
    std::string key = ""; // 空密钥，内部会使用默认密钥
    std::string res = encrypt_string(input, key);
    std::cout << res << std::endl;
    return 0;
}

python代码

def encrypt_string(input_str: str, key_str: str = "") -> str:
    """
    修复后的自定义加密函数（完全对齐C++逻辑）
    输入: "1234qwer" 且密钥为空时，输出固定为 "3C2B0DF2E3EA2A73-E084AF32"
    """
    # 常量定义（与C++完全一致）
    FNV_OFFSET_BASIS = 1469598103934665603  # 64位FNV偏移量
    FNV_PRIME = 1099511628211                # 64位FNV质数
    UINT64_MASK = 0xFFFFFFFFFFFFFFFF         # 模拟uint64_t溢出
    DEFAULT_KEY = "default_key@JNI"          # 默认密钥

    # 输入处理：转为UTF-8字节流（对齐C++ GetStringUTFChars）
    plain_bytes = input_str.encode("utf-8")
    if not plain_bytes:
        return ""

    # 密钥处理：空密钥使用默认值
    kstr = key_str if key_str else DEFAULT_KEY
    k_bytes = kstr.encode("utf-8")
    k_len = len(k_bytes)

    # 1. 生成与C++完全一致的seed（关键修复点）
    seed = FNV_OFFSET_BASIS
    for i in range(k_len):
        key_byte = k_bytes[i]
        
        # 步骤1: seed ^= 密钥字节（模拟uint64_t异或）
        seed ^= key_byte
        seed &= UINT64_MASK
        
        # 步骤2: seed *= 质数（模拟uint64_t乘法溢出）
        seed *= FNV_PRIME
        seed &= UINT64_MASK
        
        # 步骤3: seed += (i*131 + 7)（模拟uint64_t加法溢出）
        add_val = (i * 131) + 7
        seed += add_val
        seed &= UINT64_MASK
        
        # 步骤4: seed ^= (seed >> 13)（模拟无符号右移）
        seed ^= (seed >> 13)
        seed &= UINT64_MASK

    # 2. 8位循环移位函数（修复移位后截断问题）
    def rotl8(v: int, r: int) -> int:
        r &= 7  # 确保移位量在0-7
        return ((v << r) & 0xFF) | (v >> (8 - r))  # 左移后截断8位

    def rotr8(v: int, r: int) -> int:
        r &= 7
        return (v >> r) | ((v << (8 - r)) & 0xFF)  # 右移后截断8位

    # 3. 主加密循环（逐字节对齐C++逻辑）
    out = []
    checksum_add = 0  # 模拟uint32_t
    checksum_xor = 0  # 模拟uint32_t
    hex_chars = "0123456789ABCDEF"

    for i in range(len(plain_bytes)):
        p = plain_bytes[i]
        kc = k_bytes[i % k_len]

        # 基础混合运算
        mix_seed = (seed >> ((i % 7) * 8)) & 0xFF  # 取seed的8位片段
        x = (p + kc) ^ mix_seed
        x = (x | (kc & 0xAA)) & 0xFF  # 与0xAA掩码组合

        # 旋转与取反（修复取反后符号问题）
        x = rotl8(x, (i + kc) % 8)
        x ^= (~kc) & 0xFF  # 确保取反后为8位无符号

        # 乘法与模运算
        x = (x * 33 + i) % 256  # 模拟uint32_t中间运算

        # 源字节移位组合（修复移位溢出）
        shift = i % 3
        p_left = (p << shift) & 0xFF  # 左移后截断8位
        p_right = (p >> (5 - shift)) & 0xFF  # 右移后截断8位
        m1 = p_left | p_right
        x ^= m1

        # 条件分支处理（修复减法负数问题）
        cond = ((i & 1) == 0 and (x % 2) == 1) or ((kc & 1) != 0)
        add_val = (seed & 0x0F)
        sub_val = ((seed >> 4) & 0x0F)
        if cond:
            x = (x + add_val) & 0xFF
        else:
            x = (x - sub_val) % 256  # 负数自动转为正数（模拟uint8_t）

        # 三元运算符逻辑
        if x > kc:
            x ^= (i & 0xFF)  # i截断为8位
        else:
            x = (x + kc) & 0xFF

        # 右旋混淆
        x = rotr8(x, (kc ^ i) % 8)

        # 更新校验和（模拟uint32_t溢出）
        checksum_add = (checksum_add + x + p + kc) & 0xFFFFFFFF
        checksum_xor = (checksum_xor ^ (x << ((i % 4) * 8))) & 0xFFFFFFFF

        # 转换为十六进制
        out.append(hex_chars[(x >> 4) & 0x0F])
        out.append(hex_chars[x & 0x0F])

    # 4. 计算尾部MAC（修复32位循环移位）
    mac = (
        (seed & 0xFFFFFFFF)
        ^ checksum_xor
        ^ ((checksum_add << 1) | (checksum_add >> 31))  # 32位循环左移1位
    ) & 0xFFFFFFFF  # 确保32位无符号

    # 拼接最终结果
    out.append('-')
    out.append(f"{mac:08X}")

    return ''.join(out)


# 验证代码：输入"1234qwer"，密钥为空
if __name__ == "__main__":
    test_input = "1234qwer"
    test_key = ""
    result = encrypt_string(test_input, test_key)
    expected = "3C2B0DF2E3EA2A73-E084AF32"
    
    print(f"输入字符串: {test_input}")
    print(f"使用密钥: {test_key}（空串，自动使用默认密钥）")
    print(f"加密结果: {result}")
    print(f"预期结果: {expected}")
    print(f"结果是否一致: {result == expected}")  # 输出 True