MATLAB隐枚举法解谜:当整数规划遇上背包加密算法

[Web3] 基础第3篇: 区块链的基础密码学原理 Hash 函数又称单向散列函数或者杂凑函数*图:哈希函数示意——任意长度消息映射为固定长度摘要,单向不可逆*定义:给定一个 Message M,对 M 进行 Hash 可以得到 H(M) = Hash(M)由 Message H Hash 之后可以得到 H(m), 但是不能从 Hash(m) 反推出 Message M, 由此可以看出 Hash 函数具备单向不可逆性。 阅读详情

MATLAB隐枚举法解谜:当整数规划遇上背包加密算法

你是否曾好奇,那些看似坚不可摧的密码系统,其背后是否隐藏着可以被数学工具破解的脆弱性?在信息安全领域,经典的背包加密算法曾一度被认为是安全的典范,直到数学家们发现,它本质上可以转化为一个0-1整数规划问题。这不仅仅是理论上的巧合,更是一个将优化算法直接应用于密码分析的绝佳案例。对于信息安全专业的学生和算法爱好者而言,理解这种跨界思维,不仅能深化对密码学原理的认识,更能掌握一种用计算工具解决复杂问题的实战能力。

今天,我们将从一个全新的视角出发,不再将整数规划视为单纯的运筹学工具,而是将其作为一把解开密码谜题的钥匙。我们将聚焦于过滤隐枚举法——一种专门用于求解0-1整数规划的高效算法,并演示如何用它来“攻击”一个简化的背包加密系统。整个过程将完全在MATLAB环境中实现,从模型构建、算法编码到效率对比,我们将一步步拆解,让你不仅能看懂,更能亲手复现。你会发现,当抽象的数学规划遇上具体的加密算法,碰撞出的火花远比想象中更加精彩。

1. 从密码到方程:背包问题的整数规划建模

要理解如何用数学规划破解密码,首先得弄清楚背包加密算法到底在做什么。简单来说,背包问题描述的是:给定一组物品的重量和一个背包的承重上限,如何选择物品(每个物品要么全拿,要么不拿),使得背包中物品的总重量恰好等于某个目标值。在密码学中,我们利用一个“超递增序列”来构造公钥和私钥,使得用私钥解密(求解背包问题)很容易,但用公钥加密后,对应的背包问题却非常难解。

假设我们有一个公钥向量 a = [a1, a2, ..., an] 和一个密文 S。加密过程可以理解为:将明文(一个0-1比特串)与公钥向量做点积,得到密文S。解密,就是要找到一个0-1向量 x = [x1, x2, ..., xn],使得:

a1x1 + a2x2 + ... + an*xn = S

其中,xi ∈ {0, 1}。

看,这正是一个标准的0-1整数规划问题!我们的目标就是找到满足这个等式的0-1解。对于一般的背包问题(非超递增序列),这就是一个NP难问题。而过滤隐枚举法的核心思想,就是智能地枚举部分可能的0-1组合,利用约束条件提前“过滤”掉大量不可能成为最优解的分支,从而避免穷举所有2^n种可能性。

为了更直观地对比,我们来看一个传统投资选址的0-1规划例子与背包加密问题的异同:

特性维度经典0-1规划(如投资选址)背包加密破解问题
决策变量是否在某个地点投资(0/1)明文比特位是0还是1(0/1)
核心等式/不等式资源约束、逻辑约束(如∑成本 ≤ 预算)加密等式:∑(公钥_i * 明文_i) = 密文S
目标函数最大化利润或最小化成本在本例中,目标是找到任意一个可行解(满足等式),而非优化某个指标。但可扩展为寻找特定模式的解。
求解意义得到最优商业决策恢复原始明文,完成密码破译

通过上表可以看出,虽然应用场景天差地别,但两者的数学模型内核高度一致。这为我们借用成熟的优化算法来解决密码学问题铺平了道路。在MATLAB中,我们首先需要定义这个问题。假设公钥向量 a = [62, 93, 81, 88, 102, 37],密文 S = 280。我们的任务就是找到 x,使得 a * x' = S。

% 定义背包加密问题的参数
public_key = [62, 93, 81, 88, 102, 37]; % 公钥向量
cipher_text = 280; % 密文
n = length(public_key); % 变量个数

2. 过滤隐枚举法:智能搜索的艺术

过滤隐枚举法之所以“隐”,是因为它并非盲目枚举。它从一个可行解(或通过试探得到)出发,记录当前最优解的目标值(在背包破解中,我们更关注是否找到可行解,但算法框架类似)。然后,它系统地枚举变量组合,但在枚举每个分支时,会计算一个界限(Bound)。

对于最大化问题,这个界限是当前分支可能达到的目标值上界;对于最小化问题,则是下界。如果这个界限比已知的最优解还差,那么整个分支都可以被“剪掉”(过滤),无需继续探索其子节点。在背包破解的语境下,我们可以将“找到可行解”视为一个特殊的目标。算法会维护一个过滤条件,通常是当前部分解对应的公钥和,如果它已经超过密文S,那么无论后面变量取0还是1,总和只会更大,因此该分支不可能得到等式解,可以立即剪枝。

让我们来看一下过滤隐枚举法在MATLAB中的核心实现步骤。算法的骨架通常包含深度优先搜索(DFS)或广度优先搜索(BFS),这里我们用递归来实现DFS,逻辑更清晰。

function [solution, found] = filter_implicit_enumeration(a, S, current_sum, index, current_solution)
% a: 公钥向量
% S: 目标密文
% current_sum: 当前部分解对应的和
% index: 当前正在决策的变量索引
% current_solution: 当前的解向量(部分)
% solution: 找到的完整解
% found: 是否找到解的标志

    n = length(a);
    solution = [];
    found = false;

    % 递归终止条件1: 找到可行解
    if current_sum == S
        solution = current_solution;
        found = true;
        return;
    end

    % 递归终止条件2: 已经处理完所有变量
    if index > n
        return;
    end

    % 递归终止条件3: 过滤条件(剪枝)
    % 如果当前和已经大于目标S,或者即使后面所有变量都取1(最大可能和)也小于S,则剪枝
    max_possible_sum = current_sum + sum(a(index:end));
    min_possible_sum = current_sum; % 后面全取0
    if current_sum > S || max_possible_sum < S
        return;
    end

    % 分支1: 尝试将当前变量xi设为1
    current_solution(index) = 1;
    new_sum = current_sum + a(index);
    [sol1, f1] = filter_implicit_enumeration(a, S, new_sum, index+1, current_solution);
    if f1
        solution = sol1;
        found = true;
        return;
    end

    % 分支2: 尝试将当前变量xi设为0 (回溯)
    current_solution(index) = 0;
    [sol2, f2] = filter_implicit_enumeration(a, S, current_sum, index+1, current_solution);
    if f2
        solution = sol2;
        found = true;
        return;
    end

    % 如果两个分支都没找到,返回未找到
    found = false;
end

提示:上述代码中的过滤条件 current_sum > S || max_possible_sum < S 是算法的效率关键。它提前排除了大量无效搜索路径。在实际更复杂的背包问题中,还可以加入更紧的界,例如对公钥序列进行排序等,以进一步提升过滤效果。

这个递归函数清晰地展示了隐枚举的“分支-过滤-回溯”过程。我们从一个空解开始,在每一个决策点(变量),尝试将其设为1或0,形成两个分支。但在深入任何一个分支之前,我们先计算当前路径的“潜力”:如果当前部分和已经超标,或者即便后面全选也达不到目标,那么这条路径注定失败,果断放弃。这种策略能极大地缩小搜索空间。

3. 暴力枚举与智能算法的效率对决

为了真切感受过滤隐枚举法的威力,最直接的方式就是让它与最朴素的暴力枚举法同台竞技。暴力枚举,即穷举所有2^n种可能的0-1组合,并逐一检查是否满足等式 a*x' = S。当n较小时,这尚可接受;但当n增长到20、30甚至更高时,搜索空间呈指数级爆炸,计算将变得不可行。

让我们设计一个实验,在相同的问题实例上,分别运行暴力枚举法和我们的过滤隐枚举法,并记录它们找到解所需的时间。我们将使用MATLAB的 tic 和 toc 函数来精确计时。

% 测试用例:稍大规模的问题,展示效率差异
public_key_test = [45, 76, 32, 15, 90, 61, 28, 53, 87, 22];
cipher_text_test = 250;
n_test = length(public_key_test);

fprintf('问题规模: n = %d, 搜索空间大小: 2^%d = %d\n', n_test, n_test, 2^n_test);

% 方法1: 暴力枚举法
fprintf('\n--- 开始暴力枚举 ---\n');
tic;
brute_force_solution = [];
brute_force_found = false;
% 遍历所有从0到2^n - 1的整数,其二进制位对应一种组合
for i = 0:(2^n_test - 1)
    % 将整数i转换为二进制位向量
    x_candidate = bitget(i, n_test:-1:1); % 注意bitget的位顺序
    if public_key_test * x_candidate' == cipher_text_test
        brute_force_solution = x_candidate;
        brute_force_found = true;
        break;
    end
end
time_brute = toc;
if brute_force_found
    fprintf('暴力枚举找到解: %s\n', mat2str(brute_force_solution));
else
    fprintf('暴力枚举未找到解。\n');
end
fprintf('暴力枚举耗时: %.4f 秒\n', time_brute);

% 方法2: 过滤隐枚举法
fprintf('\n--- 开始过滤隐枚举 ---\n');
tic;
initial_solution = zeros(1, n_test);
[filter_solution, filter_found] = filter_implicit_enumeration(public_key_test, cipher_text_test, 0, 1, initial_solution);
time_filter = toc;
if filter_found
    fprintf('过滤隐枚举找到解: %s\n', mat2str(filter_solution));
else
    fprintf('过滤隐枚举未找到解。\n');
end
fprintf('过滤隐枚举耗时: %.4f 秒\n', time_filter);

% 效率对比
fprintf('\n=== 效率对比 ===\n');
fprintf('过滤隐枚举法速度是暴力枚举法的 %.2f 倍\n', time_brute / max(time_filter, eps));

运行这段代码,你会看到鲜明的对比。对于一个n=10的问题,暴力枚举可能需要遍历1024种组合,而过滤隐枚举法凭借其剪枝能力,可能只探索了其中几十或几百种组合就找到了解,耗时可能相差一个数量级。随着n增大,这种差距会呈指数级扩大。

注意:这里的暴力枚举实现使用了 bitget 函数来生成组合,在MATLAB中对于稍大的n(如>20)循环会非常慢。而过滤隐枚举法虽然在最坏情况下(问题无解或公钥序列特殊)也可能需要接近穷举的搜索,但在许多实际构造的或随机生成的问题实例上,其平均表现远优于暴力法。

这种效率的差异根源在于信息利用。暴力枚举不利用任何问题结构信息,而隐枚举法在搜索过程中,持续利用当前部分解的信息(当前和)以及剩余变量的信息(剩余公钥和)来预判,从而避免了大量无谓的尝试。这正体现了智能算法的核心:用计算和推理替代蛮力。

4. 代码实战:构建完整的MATLAB加密解密演示

理解了原理和算法,现在让我们动手构建一个完整的、可交互的演示程序。这个程序将模拟一个简化的背包加密系统,并展示用我们的隐枚举求解器进行“攻击”(解密)的过程。为了更完整,我们甚至可以实现加密过程。

首先,我们需要一个函数来生成用于演示的背包密钥对。一个安全的背包密码系统使用超递增序列作为私钥,然后通过一个模乘变换来产生公钥。这里我们做一个简化版,重点放在求解上。

function [public_key, private_key, modulus, multiplier] = generate_knapsack_keys(n)
% 生成一个简化背包密码系统的密钥对
% n: 密钥长度(物品数量)
% private_key: 私钥,一个超递增序列
% modulus: 模数,大于私钥序列总和
% multiplier: 乘数,与模数互质
% public_key: 公钥,由私钥变换而来

    % 1. 生成超递增序列作为私钥
    private_key = zeros(1, n);
    private_key(1) = randi([10, 20]); % 起始值
    for i = 2:n
        private_key(i) = sum(private_key(1:i-1)) + randi([1, 10]);
    end

    % 2. 选择模数m和乘数w
    total = sum(private_key);
    modulus = total + randi([100, 200]); % 确保m > total
    multiplier = 0;
    % 找一个与m互质的数作为w
    for w = 2:modulus-1
        if gcd(w, modulus) == 1
            multiplier = w;
            break;
        end
    end
    if multiplier == 0
        error('未能找到合适的乘数w。');
    end

    % 3. 计算公钥:public_key_i = (private_key_i * w) mod m
    public_key = mod(private_key * multiplier, modulus);
end

接下来,是加密函数,它将一个二进制明文加密为密文。

function cipher_text = knapsack_encrypt(plain_bits, public_key)
% 使用背包公钥加密明文
% plain_bits: 明文比特向量,长度等于公钥长度
% public_key: 公钥向量
% cipher_text: 密文(整数)
    if length(plain_bits) ~= length(public_key)
        error('明文长度必须与公钥长度一致。');
    end
    cipher_text = sum(plain_bits .* public_key);
end

最后,是我们的主角——基于过滤隐枚举法的解密/破解函数。注意,在真实的背包密码中,拥有私钥的人解密非常容易(因为私钥是超递增的),但攻击者只有公钥和密文,他面对的就是我们一直在求解的困难背包问题。

function decrypted_bits = knapsack_attack(cipher_text, public_key)
% 尝试使用过滤隐枚举法破解背包密文
% cipher_text: 密文
% public_key: 公钥向量
% decrypted_bits: 破解得到的明文比特(如果成功)
    n = length(public_key);
    initial_sol = zeros(1, n);
    [decrypted_bits, found] = filter_implicit_enumeration(public_key, cipher_text, 0, 1, initial_sol);
    if ~found
        warning('攻击失败:未找到满足等式的解。');
        decrypted_bits = [];
    end
end

现在,让我们写一个主脚本把这一切串起来,形成一个完整的演示:

%% 背包密码系统与隐枚举攻击演示
clear; clc;

fprintf('========== 背包密码系统演示 ==========\n\n');

% 1. 生成密钥
n = 8; % 使用较小的n确保演示速度,实际密码系统n很大(如100以上)
fprintf('1. 生成 %d 位的背包密钥对...\n', n);
[pub_key, priv_key, m, w] = generate_knapsack_keys(n);
fprintf('   私钥 (超递增序列): %s\n', mat2str(priv_key));
fprintf('   模数 m: %d\n', m);
fprintf('   乘数 w: %d\n', w);
fprintf('   公钥: %s\n\n', mat2str(pub_key));

% 2. 模拟加密过程
plaintext = randi([0, 1], 1, n); % 随机生成一个明文
fprintf('2. 加密过程\n');
fprintf('   原始明文: %s\n', mat2str(plaintext));
cipher = knapsack_encrypt(plaintext, pub_key);
fprintf('   生成密文: %d\n\n', cipher);

% 3. 使用私钥进行正常解密(仅作对比,展示其简单性)
fprintf('3. 使用私钥正常解密(超递增序列性质)...\n');
% (此处省略超递增序列解密的具体实现,因其非本文重点)
fprintf('   解密成功(过程略)。\n\n');

% 4. 攻击者视角:仅凭公钥和密文进行攻击
fprintf('4. 攻击者开始攻击(仅使用公钥和密文)...\n');
fprintf('   调用过滤隐枚举求解器...\n');
tic;
attacked_bits = knapsack_attack(cipher, pub_key);
time_attack = toc;

if ~isempty(attacked_bits)
    fprintf('   攻击成功!破解得到的明文: %s\n', mat2str(attacked_bits));
    fprintf('   是否与原始明文一致? %s\n', string(isequal(attacked_bits, plaintext)));
else
    fprintf('   攻击失败。\n');
end
fprintf('   攻击耗时: %.4f 秒\n\n', time_attack);

% 5. 效率对比:与暴力法对比(仅在小n下进行)
if n <= 12 % 避免暴力法时间过长
    fprintf('5. 与暴力枚举法效率对比(n=%d,搜索空间%d)...\n', n, 2^n);
    tic;
    brute_found = false;
    for i = 0:(2^n - 1)
        x_cand = bitget(i, n:-1:1);
        if pub_key * x_cand' == cipher
            brute_found = true;
            break;
        end
    end
    time_brute = toc;
    fprintf('   暴力枚举法耗时: %.4f 秒\n', time_brute);
    fprintf('   隐枚举法耗时是暴力法的 %.2f%%\n', (time_attack / time_brute) * 100);
end

fprintf('\n========== 演示结束 ==========\n');

运行这个脚本,你将看到一个完整的流程:系统生成密钥、加密一条随机消息,然后攻击者尝试破解。你会看到过滤隐枚举法如何工作,以及它与暴力法在时间上的巨大差异。这个演示虽然基于一个简化且不安全的系统(n太小),但它清晰地揭示了背包密码的原理性弱点,以及整数规划作为分析工具的威力。

在实际研究中,真正的背包密码系统使用非常长的密钥(n>100),并且公钥序列是经过精心伪装(通过模乘变换)的超递增序列,使得直接使用隐枚举法攻击在计算上不可行。这也促使了密码学家寻找更强大的整数规划求解技术,或者转向其他公钥密码体系。然而,这个案例作为数学、计算机科学和密码学交叉的典范,其教育意义和启发价值是永恒的。通过MATLAB亲手实现这一过程,你收获的不仅是一段代码,更是一种将复杂现实问题抽象为可计算模型,并运用智能算法予以解决的思维方式。

AI 应用开发 × 算法面试题:业务场景实战 12 题【TopK、LRU、RRF 融合、相似度、限流算法,含手撕代码与底层答案】 本文聚焦AI应用岗算法面试新趋势,剖析12道融合业务场景的高频题:从海量日志中挖掘慢查询(分治+小顶堆)、亿级去重(布隆过滤器)、向量与关键词融合排序(RRF)、语义缓存设计(带租户隔离与TTL的LRU)到限流策略(令牌桶+滑动窗口),强调“场景复述→算法选型→手撕代码→生产落地”四步答题框架。突出考察点已从纯算法转向工程权衡、业务理解与系统设计能力,如误判容忍度、实时性与内存预算的平衡,助力开发者应对2026年真实技术挑战。 阅读详情

相关推荐

如何用 Python 实现自动化测试?详细步骤和代码示例

Python自动化测试实战指南 本文系统介绍了使用Python构建自动化测试体系的完整方案。主要内容包括: 环境搭建:Python 3.8+虚拟环境配置,安装pytest、Selenium等核心测试库 分层测试实现: 单元测试:通过计算器示例演示pytest断言和异常测试 API测试:使用requests库进行RESTful接口验证 UI测试:Selenium WebDriver实现网页交互测试 高级特性: 使用fixture管理测试依赖 参数化实现数据驱动测试 生成HTML和Allure测试报告 GitH

m0_64424835的博客 454

零基础看懂 2026 工业互联网安全大赛全国预选赛 crypto-3

2026工业互联网安全大赛题crypto-3巧妙设计双路径攻击:一靠共享素因子(gcd分解模数),二靠Håstad广播攻击(e=3无填充+中国剩余定理)。两条独立路径均还原出明文,交叉验证后得flag。揭示密钥生成需随机、加密必填充、密钥全生命周期管理的重要性,体现“双路互证”在安全审计中的价值。

Morilight的博客 175

【RK3588 NPU性能调优实战】多线程异步推理YOLOv5,榨干6TOPS算力

本文详细解析了如何在RK3588 NPU上通过多线程异步推理优化YOLOv5目标检测性能,实现6TOPS算力的最大化利用。通过线程池设计、流水线化帧处理及避开内存带宽瓶颈等技巧,将NPU利用率从30%提升至82%,帧率显著提高至61.2FPS。文章还提供了环境配置、代码实现及性能对比数据,助力开发者高效部署AI模型。

weixin_29034963的博客 343

服务能启动、调用加密套件做签名校验报 libcrypto-1_1.dll 丢失:密码学依赖分析

在运行企业微服务客户端、网络安全审计工具或本地开发代理服务时,服务进程基础控制台可顺利拉起,但只要客户端发起带有 RSA 密钥签名、AES 对称加密或 SHA-256 完整性校验的远程认证请求,程序便突然抛出缺少 libcrypto-1_1.dll 错误并中断通信。排查前先把测试工程的私钥配置文件与证书链备份为安全副本,不改动正式生产密钥;常规网络监听只负责

2301_78581598的博客 110

matlab生成blocks、bumps和doppler标准测试信号

关键函数:wnoise使用方式X = wnoise(FUN,N) [X,XN] = wnoise(FUN,N,SQRT_SNR) [X,XN] = wnoise(FUN,N,SQRT_SNR,INIT)X = wnoise(FUN,N) 返回由 FUN给出的信号,长度为2^N,幅值范围[0,1].[X,XN] = wnoise(FUN,N,SQRT_SNR) ,返回了一个测试信号X,以及一个加噪

ZSZ_shsf的博客 6582

芯片低功耗设计的两种常用EDA流程

如题。

EricWZY2008的专栏 5559

FIPS ‘n’ Chips 2026:让未来触手可及

FIPS ‘n’ Chips大获成功,会议的“可及性”是其一大魅力。

艾特赛克(北京)信息技术有限公司 182

OpenCV安装配置教程VS2022(超级顺利)

博主最开始没打算写这篇博客,只是想简单的在网上找一下最新版的OpenCV的安装配置教程,适用于VS2022的,但是我搜了一早上,也没搜到一个能让我成功安装配置的,看了很多很多文章,根本就没有几篇有用的。所以没办法了,只能自己研究了,于是就整理了这篇博客,希望能帮到和我一样的人,这就是博主一直信奉的利他精神!

weixin_47367099的博客 5万+

安全存储之外(二):钱包密码学的安全实现

本文围绕攻击者不读取私钥存储副本也能恢复密钥的主题,梳理六起真实事件。第一部分阐明密钥生成、存储、使用三阶段的安全要求;随后分析四起密钥生成缺陷(Ill Bloom、Coldcard、XRPH Wallet、Qubic Wallet)如何因弱随机源、错误RNG绑定、输入转换和初始化状态过小导致密钥空间大幅缩小,以及两起签名缺陷(Zilliqa、SecondFi)如何因nonce偏差或完全可预测导致从公开签名恢复私钥。

BlockSec的博客 195

科研智能体平台搭建与实战:大模型如何驱动科研自动化

大模型技术的快速发展,正推动AI智能体从单纯对话工具向主动执行任务的科研伙伴演进。智能体的核心原理在于整合模型调用、工具使用、知识库检索与工作流编排,使其能够自主拆解目标、执行操作并迭代优化。在科研场景中,这一技术价值尤为突出:文献初筛、实验数据清洗、代码调试、结果汇总等高频重复劳动均可实现自动化,大幅释放研究者精力。从基础组件配置到多智能体协同,从平台选型到提示词调优,实际落地需要关注模型匹配、工具稳定性、记忆管理与人机校验机制。本文基于真实工程经验,系统梳理科研智能体平台的搭建路径、应用案例与高频问题排

weixin_32597009的博客 292

让 Claude Code 接管 SAP 事务流, 用 Python 和 SAP GUI Scripting 做一个真正能干活的 AI Agent

摘要:SAP系统自动化面临的核心瓶颈在于繁琐的GUI操作而非分析能力不足。通过整合Claude AI、Python和SAP GUI Scripting技术,可构建能直接操作SAP界面的智能代理。该方案利用SAP官方提供的脚本接口,实现事务码执行、界面导航、数据提取等自动化操作,特别适用于DMLT过账引擎等复杂错误分析场景。相比传统SQL导出方案,这种GUI级自动化能处理树控件、ALV表格等复杂界面元素,且无需额外API开发,直接在现有SAP GUI会话上工作,在保持原有权限体系的同时显著提升效率。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 325

FPGA 与加密行业:从算法加速到可信硬件的完整技术图谱

本文系统探讨FPGA与密码学的深度交叉,揭示其在加密加速、区块链基础设施、零知识证明及后量子密码中的关键作用。从底层硬件特性到工程实践,分析对称加密、公钥算法、零知识证明等负载的FPGA加速优势,强调其高能效、低延迟与灵活可重构的特性。结合当前密码学复杂度上升与硬件竞争加剧的趋势,指出FPGA是算法验证与高性能实现的理想载体,为安全计算提供高效硬件支撑。

weixin_49780322的博客 265

二维光子晶体禁带的遗传优化算法实现

二维光子晶体禁带的遗传优化算法MATLAB源代码 光子晶体中因周期性结构而存在的频率禁带称为光子禁带,光子禁带的存在是光子晶体具有广泛应用前景的重要原因。 禁带越大,可控光的频带也越宽,因此如何设计合适的晶体结构以获得大的光子禁带一直是研究和应用的重点与热点。 给大家讲解在平面波展开法的基础上,使用遗传算法寻找具有最大光子禁带的二维光子晶体结构。 %-------------------------------------------------------------------------- % Ph

m0_53407570的博客 583

[图解密码学]第6章 DES、AES 与 SM4

第6章 DES、AES 与 SM4第6章 DES、AES 与 SM4:一张“对称加密算法进化图”。左侧是DES的Feistel结构,标注“1977,56位密钥,64位分组,已破解”。中间是3DES和AES的SPN结构,标注“2001,128/192/256位密钥,128位分组,国际标准”。右侧是国密SM4的广义Feistel结构,标注“2006年公开,2012年国标,128位分组/128位密钥,中国商用密码标准”。

曼岛_的博客 423

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

BcoreOS安全通信架构:FsSession 抗算法后门安全设计

BcoreOS安全通信架构:FsSession 抗算法后门安全设计

xiaozhi@fslib.org的博客 316

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

ESP32 上的后量子密码学

 后量子密码算法现已标准化,用于保护联网设备抵御未来量子计算威胁。本文将介绍 esp-pqc 组件,该组件可为乐鑫 SoC 芯片引入 ML-KEM 与 ML-DSA 算法;同时展示 TLS 1.3 的实现方式以保障网络通信安全,以及 Secure Boot V2 实现固件完整性校验,并提供真实环境下的内存、闪存与性能基准测试数据。

乐鑫 Espressif 333

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

基于格的密码学

本文用通俗的方式介绍基于格的密码学。先从“格”这一高维规则点阵的几何结构讲起,说明 SVP、CVP 等格上困难问题为何难以求解;再借助“棉花糖”类比解释公钥(坏基)与私钥(好基)的关系;随后分析其抗量子原因(Shor 算法失效、Grover 加速有限)、效率与功能优势,并列举 Kyber、Dilithium、Falcon、NTRU 等主流方案,最后厘清其与 LWE / Ring-LWE 的关系。

优快云KAOSHANG的博客 151

[图解密码学]第7章 分组密码工作模式

工作模式是使用分组密码加密任意长度消息的规则。如何把消息分成块。如何处理最后一块(填充)。如何链接各个块的加密。如何使用IV/Nonce。如何解密。图7-2是工作模式定义图。图7-2 工作模式定义图分组密码(AES/SM4)+工作模式=任意长度加密。工作模式定义:分块、填充、链接、IV、解密。

曼岛_的博客 337

【算法拾光】队列|在每个树⾏中找最⼤值 + 最后⼀块⽯头的重量

本文总结两道经典算法题:一是通过层序遍历(BFS)逐层找最大值,利用队列分层处理,每层维护最大值;二是用大根堆(优先队列)模拟石头碰撞过程,每次取最大两块石头,差值重新入堆,直至剩余一块或无石。前者适用于树的层次遍历,后者适合动态获取最值场景。核心思想:队列用于分层遍历,堆用于高效取极值。

wuqingyigexiaoba的博客 192

【算法拾光】链表 哈希表|K个一组翻转链表 + 两数之和

K个一组翻转链表需分段反转,借助哑节点与前驱指针维护连接,避免断链;两数之和利用哈希表实现O(1)查找,空间换时间,高效定位目标组合。前者考察链表指针操作,后者聚焦映射关系构建,均为面试高频题。

wuqingyigexiaoba的博客 335

把 KV Cache 压到 FP4:BitDecoding-FP4 的算法-系统协同设计复盘

长上下文推理卡在KV Cache的显存与带宽上,而现有FP4方案要么精度崩、要么速度废。这篇文章复盘BitDecoding-FP4如何用三个算法补丁加一个系统重构,在B300上把服务吞吐提升2.4–3.0倍,精度几乎不掉。

helloagent的博客 315

排序算法深度笔记(下):非比较类排序的线性突破与工程边界

排序算法时间复杂度额外空间复杂度稳定性是否基于比较选择排序O(N^2)(O(1))不稳定是冒泡排序O(N^2)(O(1))稳定是插入排序O(N^2)(O(1))稳定是归并排序O(N\log N)(O(N))稳定是快速排序O(N\log N)O(log N)不稳定是堆排序O(N\log N)O(1)不稳定是计数排序(O(N + M))O(M))稳定否基数排序O(N)稳定否桶排序平均O(N) / 最坏O(N^2)

2401_87069538的博客 611

优选算法:分治-归并排序

交易逆序对的总数

Wangshijie1015的博客 149

408 算法 06|堆与 Top-K:最小的 10 个数,到底该用数组还是堆

2022(42) 找 100 万个数里最小的 10 个,官方给了"10 元素有序数组"和"大根堆"两种答案。我把两种都实现并数了比较次数:k=10 时两者几乎打平,k=10000 时堆少 111 倍。另附 2021(42) 计数排序的比较次数与稳定性实测。

m0_56226131的博客 450

牛客周赛165C题(前后缀性质,递推,排序,枚举)

题目大意:给定长度为 `n` 的数组,选择 `k ∈ [1,n]`,将前 `k` 个元素整体翻转,后面的元素不变。要求操作后的整个数组非递减,统计满足条件的 `k` 的数量。题目链接:https://ac.nowcoder.com/acm/contest/141721/C。时间复杂度:O(nlogn)

2501_94316951的博客 174

408 算法 04|主元素与三元组最小距离:两种“扫描时做决定“的思路

2013(41) 的主元素用摩尔投票一遍选出候选,但真正的考点是"选完必须验票";2020(41) 的三元组最小距离,三指针每次只挪最小的那个,靠的是 D=2×(max−min) 这个恒等式。两套完整 C 代码加真实输出,附官方评分档位表。

m0_56226131的博客 443
上一篇: 从ResNet到你的数据集:5步搞定图像分类微调(附PyTorch代码)
下一篇: React 18变量管理:从useState到useRef的7种实战场景解析
糖果HTML
博客等级 码龄3年 76粉丝 1357原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值