一种新的非对称加密算法-CSDN博客

概述

这种算法是我研究的一种新的基于高维混沌系统的非对称加密算法。是否安全，具有抗量子性，暴力破解的情况下，如果按代码中的混沌系统参数来说，密钥空间为2^8448。假设调用全球算力，也要10^100世纪以上(这些数据你们可以去证实)

开源，C++语言

#include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <chrono>
#include <stdexcept>
#include <bitset>

using namespace std;
using namespace std::chrono;

// 混沌系统参数
const int CHAOS_DIM = 33; // 混沌系统维度
const int ITERATIONS = 128; // 迭代轮数
const double SYSTEM_PARAM = 114.514; // 混沌参数

// 格密码参数
const int LATTICE_DIM = 256; // 格维度
const int MODULUS_BITS = 2048; // 模数位数

// 混沌系统类
class HyperbolicChaosSystem {
private:
vector<double> state;
mt19937_64 rng;

// 双曲混沌函数
double hyperbolic_map(double x, double a) {
double t = exp(-a * pow(sinh(x), 2));
return (1 - t) / (1 + t);
}

public:
HyperbolicChaosSystem(size_t dim) : state(dim) {
random_device rd;
rng.seed(rd());
uniform_real_distribution<double> dist(-1.0, 1.0);

for (auto& s : state) {
s = dist(rng);
}
}

// 混沌系统迭代
void iterate() {
vector<double> new_state(CHAOS_DIM);
for (int i = 0; i < CHAOS_DIM; ++i) {
double sum = 0.0;
for (int j = 0; j < CHAOS_DIM; ++j) {
if (i != j) {
sum += hyperbolic_map(state[j], SYSTEM_PARAM);
}
}
new_state[i] = hyperbolic_map(sum, SYSTEM_PARAM);
}
state = move(new_state);
}

// 生成随机位
bool generate_bit() {
iterate();
double sum = 0.0;
for (double s : state) {
sum += s;
}
return fmod(abs(sum), 1.0) > 0.5;
}

// 生成随机大整数
vector<bool> generate_bigint(size_t bits) {
vector<bool> result;
for (size_t i = 0; i < bits; ++i) {
result.push_back(generate_bit());
}
return result;
}
};

// 大整数运算工具
class BigInt {
private:
vector<bool> bits;

// 移除前导零
void remove_leading_zeros() {
while (!bits.empty() && !bits.back()) {
bits.pop_back();
}
if (bits.empty()) bits.push_back(false);
}

public:
BigInt() {}

BigInt(size_t size, bool value) : bits(size, value) {}

BigInt(const vector<bool>& b) : bits(b) {
remove_leading_zeros();
}

size_t size() const { return bits.size(); }

bool operator[](size_t idx) const {
return bits[idx];
}

// 加法
BigInt operator+(const BigInt& other) const {
size_t max_size = max(size(), other.size());
vector<bool> result;
bool carry = false;

for (size_t i = 0; i < max_size; ++i) {
bool a = (i < size()) ? bits[i] : false;
bool b = (i < other.size()) ? other[i] : false;

bool sum = a ^ b ^ carry;
carry = (a && b) || (a && carry) || (b && carry);

result.push_back(sum);
}

if (carry) result.push_back(true);

return BigInt(result);
}

// 乘法
BigInt operator*(const BigInt& other) const {
BigInt result(size() + other.size(), false);

for (size_t i = 0; i < size(); ++i) {
if (bits[i]) {
vector<bool> temp(i, false);
temp.insert(temp.end(), other.bits.begin(), other.bits.end());
result = result + BigInt(temp);
}
}

return result;
}

// 模运算
BigInt operator%(const BigInt& mod) const {
if (mod.bits.empty() || !mod.bits.back()) {
throw invalid_argument("Modulus cannot be zero");
}

BigInt remainder = *this;
BigInt divisor = mod;

if (divisor.size() > size()) {
return remainder;
}

// 对齐除数
size_t shift = size() - divisor.size();
divisor = BigInt(vector<bool>(shift, false)).operator+(divisor);

for (int i = shift; i >= 0; --i) {
if (remainder.size() >= divisor.size()) {
remainder = remainder + divisor;
}
divisor = divisor.shift_right(1);
}

return remainder;
}

// 右移
BigInt shift_right(size_t n) const {
if (n >= size()) return BigInt();
return BigInt(vector<bool>(bits.begin() + n, bits.end()));
}

// 转换为字节向量
vector<uint8_t> to_bytes() const {
vector<uint8_t> bytes;
size_t byte_count = (size() + 7) / 8;
bytes.resize(byte_count, 0);

for (size_t i = 0; i < size(); ++i) {
if (bits[i]) {
size_t byte_idx = i / 8;
size_t bit_idx = i % 8;
bytes[byte_idx] |= (1 << bit_idx);
}
}

return bytes;
}

// 从字节创建
static BigInt from_bytes(const vector<uint8_t>& bytes) {
vector<bool> bits;
for (uint8_t b : bytes) {
for (int i = 0; i < 8; ++i) {
bits.push_back(b & (1 << i));
}
}
return BigInt(bits);
}
};

// 密钥对结构
struct KeyPair {
BigInt publicKey;
BigInt privateKey;
};

// 加密系统核心
class QuantumResistCrypto {
private:
// 混沌格生成器
pair<BigInt, BigInt> generate_chaotic_lattice() {
HyperbolicChaosSystem chaos(CHAOS_DIM);
BigInt lattice_base(LATTICE_DIM * 2, false);
BigInt error_vector(LATTICE_DIM, false);

vector<bool> base_bits = chaos.generate_bigint(MODULUS_BITS);
vector<bool> error_bits = chaos.generate_bigint(LATTICE_DIM);

return {BigInt(base_bits), BigInt(error_bits)};
}

public:
// 密钥生成
KeyPair generate_keys() {
auto start = high_resolution_clock::now();

auto [lattice, error] = generate_chaotic_lattice();
HyperbolicChaosSystem chaos(CHAOS_DIM);

// 生成私钥（多维混沌向量）
BigInt privateKey = BigInt(chaos.generate_bigint(MODULUS_BITS));

// 生成公钥（格困难问题）
BigInt publicKey = (lattice * privateKey) + error;

auto end = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(end - start);
cout << "密钥生成时间: " << duration.count() << " ms\n";

return {publicKey, privateKey};
}

// 加密
vector<BigInt> encrypt(const BigInt& publicKey, const vector<uint8_t>& message) {
auto start = high_resolution_clock::now();

HyperbolicChaosSystem chaos(CHAOS_DIM);
vector<BigInt> ciphertext;

// 消息转换为大整数
BigInt msg_int = BigInt::from_bytes(message);

// 生成随机掩码
BigInt r = BigInt(chaos.generate_bigint(MODULUS_BITS));

// 格基加密
BigInt c1 = (publicKey * r) % BigInt(vector<bool>(MODULUS_BITS, true));
BigInt c2 = (msg_int + r) % BigInt(vector<bool>(MODULUS_BITS, true));

ciphertext.push_back(c1);
ciphertext.push_back(c2);

auto end = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(end - start);
cout << "加密时间: " << duration.count() << " ms\n";

return ciphertext;
}

// 解密
vector<uint8_t> decrypt(const BigInt& privateKey, const vector<BigInt>& ciphertext) {
auto start = high_resolution_clock::now();

if (ciphertext.size() != 2) {
throw invalid_argument("无效的密文");
}

BigInt c1 = ciphertext[0];
BigInt c2 = ciphertext[1];

// 格基解密
BigInt r_prime = (c1 * privateKey) % BigInt(vector<bool>(MODULUS_BITS, true));
BigInt msg_int = (c2 + r_prime) % BigInt(vector<bool>(MODULUS_BITS, true));

auto bytes = msg_int.to_bytes();

// 移除填充
while (!bytes.empty() && bytes.back() == 0) {
bytes.pop_back();
}

auto end = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(end - start);
cout << "解密时间: " << duration.count() << " ms\n";

return bytes;
}
};

int main() {
try {
QuantumResistCrypto crypto;

// 生成密钥对
KeyPair keys = crypto.generate_keys();

// 测试消息
string message = "抗量子加密算法测试@2025! 安全等级: ∞";
vector<uint8_t> plaintext(message.begin(), message.end());
plaintext.resize(1024); // 填充到1KB

// 加密
auto ciphertext = crypto.encrypt(keys.publicKey, plaintext);

// 解密
auto decrypted = crypto.decrypt(keys.privateKey, ciphertext);

// 验证解密结果
string decrypted_str(decrypted.begin(), decrypted.end());

cout << "解密结果: " << decrypted_str.substr(0, 40) << "..." << endl;

// 安全性分析
double security_level = pow(2, LATTICE_DIM * CHAOS_DIM);
double global_hashrate = 1e20; // 全球算力（每秒哈希次数）
double seconds_in_century = 3.15576e9;
double centuries = security_level / (global_hashrate * seconds_in_century * 1e100);

cout << "\n安全参数分析:\n";
cout << "密钥空间: 2^" << (LATTICE_DIM * CHAOS_DIM) << endl;
cout << "暴力破解所需世纪数: " << scientific << centuries << endl;
cout << "抗量子安全等级: 抵抗已知量子算法攻击" << endl;

} catch (const exception& e) {
cerr << "错误: " << e.what() << endl;
return 1;
}

return 0;
}