一、非对称加密概述

1.1 基本概念

非对称加密（Asymmetric Cryptography），也称为公钥加密，是一种使用一对数学相关的密钥进行加密和解密的密码系统：

• 公钥（Public Key）：可公开分享，由私钥用于加密数据或验证签名
• 私钥（Private Key）：随机生成，必须严格保密，用于解密数据或创建签名

1.2 与对称加密的关键区别

特性	对称加密	非对称加密
密钥数量	单个共享密钥	密钥对（公钥+私钥）
密钥分发	困难且不安全	容易且安全
计算效率	高	相对较低
主要用途	批量数据加密	密钥交换、数字签名、身份验证

二、非对称加密核心原理

2.1 数学基础：单向函数

非对称加密基于单向函数的数学原理：

• 正向计算容易：给定输入x，容易计算f(x)
• 反向计算困难：给定f(x)，难以计算出x

2.2 非对称加密工作流程

三、主要非对称加密算法

3.1 RSA算法（加密，密钥交换，数字签名）

RSA（Rivest-Shamir-Adleman）是最广泛使用的非对称加密算法。
核心原理：基于大整数质因数分解的困难性。简单说，很容易将两个大质数相乘得到一个极大的合数，但极难将这个极大的合数逆向分解回原来的两个质数。

1. RSA密钥生成过程：

• 选择两个大质数 p 和 q
• 计算 n = p × q
• 计算欧拉函数 φ(n) = (p-1) × (q-1)
• 选择公钥指数 e，满足 1 < e < φ(n) 且与 φ(n) 互质
• 计算私钥指数 d，满足 d × e ≡ 1 mod φ(n)

2. RSA加密/解密：

• 加密：c = mᵉ mod n
• 解密：m = cᵈ mod n

主要用途：

• 加密解密：用于加密对称密钥 (如AES密钥)，然后使用对称密钥加密实际数据。这是HTTPS协议中的标准做法。
• 数字签名：用于验证数据的完整性和来源真实性。比如软件发布、数字证书、SSL/TLS握手。

特点：

• 非常通用和成熟，几乎所有安全场景都支持。
• 密钥长度较长（通常2048位或以上才安全），计算相对较慢。

3.2 ECC算法（密钥交换、数字签名）

椭圆曲线密码学（Elliptic Curve Cryptography）提供相同安全等级下更短的密钥长度。
这是一种较新的算法，但在现代应用中变得越来越重要，尤其是在移动设备和资源受限的环境中。

常见实现：

• ECDH（椭圆曲线迪菲-赫尔曼密钥交换）、ECDSA（椭圆曲线数字签名算法）。

核心原理：

• 基于椭圆曲线离散对数问题的困难性。数学上非常复杂，但其核心优势是：在提供相同安全强度的情况下，ECC的密钥长度比RSA短得多。

主要用途：

• 与RSA类似，用于密钥交换和数字签名。

• 广泛应用于现代协议中，如TLS 1.3、区块链（比特币、以太坊）、移动设备加密、智能卡。

特点：

• 效率高：更短的密钥意味着计算更快、带宽占用更少、存储空间更小。
• 更安全：在相同的密钥长度下，破解ECC的难度远高于RSA。256位的ECC密钥安全性相当于3072位的RSA密钥。

安全级别	RSA密钥长度	ECC密钥长度
80位	1024位	160位
128位	3072位	256位
256位	15360位	512位

3.3 Diffie-Hellman密钥交换（仅密钥交换）

允许双方在不安全的通道上建立共享密钥。

总结与对比

算法名称	主要用途	优点	缺点	常见应用场景
RSA	加密、密钥交换、数字签名	功能全面，应用广泛，支持性好	密钥长，计算慢	HTTPS (SSL/TLS)、软件签名、电子邮件加密
ECC (含 ECDH, ECDSA)	密钥交换、数字签名	效率高（密钥短，速度快），同等长度更安全	实现相对复杂，历史不如RSA悠久	现代HTTPS (TLS 1.3)、区块链、移动设备、物联网
Diffie-Hellman (DH)	仅密钥交换	安全的密钥协商原理	无认证功能，需配合其他算法	SSL/TLS 的密钥交换阶段

四、非对称加密在嵌入式系统的应用

4.1 安全启动与固件验证

// 简化的安全启动验证流程
#include <stdint.h>
#include "crypto.h"

#define FIRMWARE_BASE_ADDR  0x08000000
#define SIGNATURE_SIZE      256
#define HASH_SIZE           32

typedef struct {
    uint8_t signature[SIGNATURE_SIZE];
    uint32_t firmware_size;
    // 其他元数据...
} firmware_header_t;

bool verify_firmware_signature(const uint8_t *public_key) {
    firmware_header_t *header = (firmware_header_t*)FIRMWARE_BASE_ADDR;
    uint8_t *firmware_data = (uint8_t*)(FIRMWARE_BASE_ADDR + sizeof(firmware_header_t));
    
    // 计算固件哈希值
    uint8_t hash[HASH_SIZE];
    sha256_calculate(firmware_data, header->firmware_size, hash);
    
    // 使用公钥验证签名
    return rsa_verify(public_key, hash, HASH_SIZE, 
                     header->signature, SIGNATURE_SIZE);
}

void boot_secure_firmware(void) {
    // 从安全存储读取公钥
    uint8_t public_key[PUB_KEY_SIZE];
    read_public_key(public_key);
    
    if (verify_firmware_signature(public_key)) {
        // 验证成功，跳转到固件
        jump_to_firmware(FIRMWARE_BASE_ADDR + sizeof(firmware_header_t));
    } else {
        // 验证失败，进入安全恢复模式
        handle_boot_failure();
    }
}

4.2 TLS/SSL安全通信

嵌入式设备使用非对称加密建立安全连接：

// 简化的TLS握手过程
#include "mbedtls/ssl.h"
#include "mbedtls/entropy.h"
#include "mbedtls/ctr_drbg.h"

mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
mbedtls_x509_crt cert;
mbedtls_pk_context pkey;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;

int tls_handshake(void) {
    // 初始化随机数生成器
    mbedtls_entropy_init(&entropy);
    mbedtls_ctr_drbg_init(&ctr_drbg);
    mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, 
                         (const unsigned char*)"embedded_device", 14);
    
    // 加载证书和私钥
    mbedtls_x509_crt_init(&cert);
    mbedtls_pk_init(&pkey);
    
    int ret = mbedtls_x509_crt_parse_file(&cert, "device_cert.pem");
    if (ret != 0) return ret;
    
    ret = mbedtls_pk_parse_keyfile(&pkey, "device_key.pem", "");
    if (ret != 0) return ret;
    
    // 配置SSL上下文
    mbedtls_ssl_init(&ssl);
    mbedtls_ssl_config_init(&conf);
    
    mbedtls_ssl_config_defaults(&conf,
                                MBEDTLS_SSL_IS_CLIENT,
                                MBEDTLS_SSL_TRANSPORT_STREAM,
                                MBEDTLS_SSL_PRESET_DEFAULT);
    
    mbedtls_ssl_conf_rng(&conf, mbedtls_ctr_drbg_random, &ctr_drbg);
    mbedtls_ssl_conf_ca_chain(&conf, cert.next, NULL);
    
    // 设置证书和私钥
    mbedtls_ssl_conf_own_cert(&conf, &cert, &pkey);
    
    mbedtls_ssl_setup(&ssl, &conf);
    
    // 执行TLS握手
    return mbedtls_ssl_handshake(&ssl);
}

4.3 数字签名与身份验证

// 设备身份验证实现
#include <string.h>
#include "signature.h"

typedef struct {
    uint32_t timestamp;
    uint8_t device_id[16];
    uint8_t challenge[32];
    uint8_t signature[256];
} auth_message_t;

bool authenticate_device(const uint8_t *public_key, const auth_message_t *msg) {
    // 验证消息时效性（防止重放攻击）
    uint32_t current_time = get_current_timestamp();
    if (current_time - msg->timestamp > MAX_TIME_DIFF) {
        return false;
    }
    
    // 计算消息哈希
    uint8_t hash[32];
    sha256_calculate((const uint8_t*)msg, 
                    sizeof(auth_message_t) - sizeof(msg->signature), 
                    hash);
    
    // 验证签名
    return rsa_verify(public_key, hash, sizeof(hash), 
                     msg->signature, sizeof(msg->signature));
}

// 创建身份验证响应
void create_auth_response(const uint8_t *private_key, 
                         const uint8_t *challenge,
                         uint8_t *response) {
    auth_message_t *msg = (auth_message_t*)response;
    
    msg->timestamp = get_current_timestamp();
    get_device_id(msg->device_id);
    memcpy(msg->challenge, challenge, sizeof(msg->challenge));
    
    // 计算哈希并签名
    uint8_t hash[32];
    sha256_calculate((const uint8_t*)msg, 
                    sizeof(auth_message_t) - sizeof(msg->signature), 
                    hash);
    
    rsa_sign(private_key, hash, sizeof(hash), 
            msg->signature, sizeof(msg->signature));
}

五、嵌入式系统实现考虑

5.1 性能优化策略

1.算法选择：

// 根据资源约束选择算法
#if defined(USE_ECC)
#include "ecc.h"
#define KEY_SIZE         32  // 256位ECC
#define SIGNATURE_SIZE   64
#elif defined(USE_RSA)
#include "rsa.h"
#define KEY_SIZE         256 // 2048位RSA
#define SIGNATURE_SIZE   256
#endif

2.硬件加速：

// 使用硬件加密引擎
#if defined(STM32_HW_CRYPTO)
#include "stm32l4xx_hal.h"
#define rsa_sign(data, sig) HAL_RSA_Sign(&hrsa, data, sig)
#elif defined(NXP_HW_CRYPTO)
#include "fsl_caam.h"
#define rsa_sign(data, sig) CAAM_RSA_Sign(data, sig)
#else
// 软件实现
#define rsa_sign(data, sig) software_rsa_sign(data, sig)
#endif

5.2 内存管理优化

// 内存高效的RSA实现（使用滑动窗口优化）
int rsa_crt_sign(const rsa_key_t *key, const uint8_t *hash, 
                uint8_t *signature, size_t hash_len) {
    // 使用中国剩余定理(CRT)加速计算
    bigint_t m1, m2, h;
    
    // 转换哈希值为大整数
    bigint_from_bytes(&h, hash, hash_len);
    
    // 计算 m1 = h^d mod p
    bigint_mod_exp(&m1, &h, &key->dp, &key->p);
    
    // 计算 m2 = h^d mod q  
    bigint_mod_exp(&m2, &h, &key->dq, &key->q);
    
    // 使用CRT组合结果
    bigint_t tmp;
    bigint_sub(&tmp, &m1, &m2);
    bigint_mod(&tmp, &tmp, &key->p);
    bigint_mul(&tmp, &tmp, &key->qinv);
    bigint_mod(&tmp, &tmp, &key->p);
    bigint_mul(&tmp, &tmp, &key->q);
    bigint_add(&tmp, &tmp, &m2);
    
    // 转换为字节数组
    bigint_to_bytes(&tmp, signature, key->size);
    
    return 0;
}

5.3 侧信道攻击防护

// 防止时序攻击的常数时间比较
bool constant_time_compare(const uint8_t *a, const uint8_t *b, size_t len) {
    uint8_t result = 0;
    for (size_t i = 0; i < len; i++) {
        result |= a[i] ^ b[i];
    }
    return (result == 0);
}

// 防止功耗分析攻击的盲签名
int rsa_blind_sign(const rsa_key_t *key, const uint8_t *hash,
                  uint8_t *signature, size_t hash_len) {
    bigint_t m, blind, unblind, blinded;
    bigint_from_bytes(&m, hash, hash_len);
    
    // 生成盲化因子
    bigint_rand(&blind, key->n.bits);
    bigint_mod(&blind, &blind, &key->n);
    
    // 计算盲化消息：blinded = m × blindᵉ mod n
    bigint_mod_exp(&blinded, &blind, &key->e, &key->n);
    bigint_mul(&blinded, &blinded, &m);
    bigint_mod(&blinded, &blinded, &key->n);
    
    // 对盲化消息签名：sig = blindedᵈ mod n
    bigint_mod_exp(&blinded, &blinded, &key->d, &key->n);
    
    // 去盲化：signature = sig × blind⁻¹ mod n
    bigint_mod_inv(&unblind, &blind, &key->n);
    bigint_mul(&blinded, &blinded, &unblind);
    bigint_mod(&blinded, &blinded, &key->n);
    
    bigint_to_bytes(&blinded, signature, key->size);
    return 0;
}

六、实际应用案例

6.1 IoT设备安全通信

// IoT设备安全初始化流程
void iot_device_init(void) {
    // 1. 从安全存储读取或生成密钥对
    uint8_t public_key[PUB_KEY_SIZE];
    uint8_t private_key[PRIV_KEY_SIZE];
    
    if (!read_key_from_secure_storage(public_key, private_key)) {
        generate_key_pair(public_key, private_key);
        store_key_to_secure_storage(public_key, private_key);
    }
    
    // 2. 向服务器注册公钥
    if (!register_with_server(public_key)) {
        // 注册失败，进入安全模式
        enter_safe_mode();
    }
    
    // 3. 建立安全连接
    establish_secure_connection();
    
    // 4. 启动安全通信任务
    start_secure_communication_task();
}

6.2 安全固件更新

// 安全OTA更新实现
typedef struct {
    uint8_t signature[SIGNATURE_SIZE];
    uint32_t firmware_version;
    uint32_t firmware_size;
    uint32_t crc;
    // ...其他元数据
} firmware_metadata_t;

bool verify_firmware_update(const uint8_t *firmware_data, 
                           size_t firmware_size,
                           const uint8_t *public_key) {
    firmware_metadata_t *metadata = (firmware_metadata_t*)firmware_data;
    uint8_t *actual_firmware = firmware_data + sizeof(firmware_metadata_t);
    
    // 验证CRC
    if (calculate_crc32(actual_firmware, metadata->firmware_size) != metadata->crc) {
        return false;
    }
    
    // 计算哈希
    uint8_t hash[HASH_SIZE];
    sha256_calculate(actual_firmware, metadata->firmware_size, hash);
    
    // 验证签名
    return rsa_verify(public_key, hash, HASH_SIZE, 
                     metadata->signature, SIGNATURE_SIZE);
}

总结

非对称加密为嵌入式系统提供了强大的安全基础，特别是在以下场景：

• 安全密钥交换：在不安全通道上建立安全通信
• 数字身份验证：验证设备身份和消息完整性
• 安全启动：确保只有经过授权的代码能够执行
• 安全更新：验证固件更新包的 authenticity

实施建议：

• 根据性能要求选择RSA或ECC算法
• 尽可能使用硬件加密加速器
• 实现侧信道攻击防护措施
• 安全地管理和存储私钥
• 定期更新和轮换密钥

通过合理实施非对称加密技术，嵌入式系统能够达到企业级的安全标准，保护敏感数据和防止未授权访问。